2

I like to use Numpy to create an array of vertices that is to be passed into glsl.

Vertices will be a numpy array that comprises the info of 3 vertex.

Each vertex consist of:

  1. pos = (x, y) a 64-bit signed floating-point format that has a 32-bit R component in bytes 0..3, and a 32-bit G component in bytes 4..7, and
  2. color = (r, g, b) a 96-bit signed floating-point format that has a 32-bit R component in bytes 0..3, a 32-bit G component in bytes 4..7, and a 32-bit B component in bytes 8..11

i.e. each vertex = (pos, color) = ( (x, y), (r, g, b) )

A triangle has 3 vertices, so finally I need a 1D numpy array to describe 

Vertices = [vertex1, vertex2, vertex3]
         = [ ( (x, y), (r, g, b) ), 
             ( (x, y), (r, g, b) ), 
             ( (x, y), (r, g, b) ) ]

How can I create Vertices in numpy? The below syntax looks wrong.

Vertices = np.array([( (x1, y1), (r1, g1, b1) ), 
                     ( (x2, y2), (r2, g2, b2) ), 
                     ( (x3, y3), (r3, g3, b3) )], dtype=np.float32)

The bytes size of each vertex should be 64/8 + 96/8 = 8 + 12 = 20 bytes. The bytes size of Vertices should be 20 bytes x 3 = 60 bytes.

Sun Bear
  • 7,594
  • 11
  • 56
  • 102
  • I think you should be more precise about the actual problem you are facing. Until now, you are only describing the output data but not the input data or anything else. – zimmerrol Aug 17 '18 at 08:49
  • Possible duplicate of [Store different datatypes in one NumPy array?](https://stackoverflow.com/questions/11309739/store-different-datatypes-in-one-numpy-array) – Yohanes Gultom Aug 17 '18 at 08:59

1 Answers1

2

This is quite simple, in numpy actually. Use structured arrays:

In [21]: PosType = np.dtype([('x','f4'), ('y','f4')])

In [22]: ColorType = np.dtype([('r','f4'), ('g', 'f4'), ('b', 'f4')])

In [23]: VertexType = np.dtype([('pos', PosType),('color', ColorType)])

In [24]: VertexType
Out[24]: dtype([('pos', [('x', '<f4'), ('y', '<f4')]), ('color', [('r', '<f4'), ('g', '<f4'), ('b', '<f4')])])

In [25]: VertexType.itemsize
Out[25]: 20

Then simply:

In [26]: vertices = np.array([( (1, 2), (3, 4, 5) ),
    ...:                      ( (6, 7), (8, 9, 10) ),
    ...:                      ( (11, 12), (13, 14, 15) )], dtype=VertexType)

In [27]: vertices.shape
Out[27]: (3,)

And basic indexing:

In [28]: vertices[0]
Out[28]: (( 1.,  2.), ( 3.,  4.,  5.))

In [29]: vertices[0]['pos']
Out[29]: ( 1.,  2.)

In [30]: vertices[0]['pos']['y']
Out[30]: 2.0

In [31]: VertexType.itemsize
Out[31]: 20

numpy ever provides record-arrays, so you can use attribute-access instead of indexing:

In [32]: vertices = np.rec.array([( (1, 2), (3, 4, 5) ),
    ...:                          ( (6, 7), (8, 9, 10) ),
    ...:                          ( (11, 12), (13, 14, 15) )], dtype=VertexType)

In [33]: vertices[0].pos
Out[33]: (1.0, 2.0)

In [34]: vertices[0].pos.x
Out[34]: 1.0

In [35]: vertices[2].color.g
Out[35]: 14.0
juanpa.arrivillaga
  • 88,713
  • 10
  • 131
  • 172
  • May I know what does `'f4'` and `' – Sun Bear Aug 17 '18 at 09:15
  • @SunBear it's the string-specification shorthand, see the [docs](https://docs.scipy.org/doc/numpy/user/basics.rec.html) I linked to for more details. `f4` is the 4-byte floating point type in native byte-order, it is the same thing as a `np.float32`. – juanpa.arrivillaga Aug 17 '18 at 09:24
  • Thank you for introducing me to the concept of Structured arrays. Exactly what I needed. :) – Sun Bear Aug 17 '18 at 10:35