| Name |
| |
| ARB_matrix_palette |
| |
| Name Strings |
| |
| GL_ARB_matrix_palette |
| |
| Contact |
| |
| Jon Paul Schelter (jschelte 'at' matrox.com) |
| |
| Notice |
| |
| Copyright (c) 2000-2013 The Khronos Group Inc. Copyright terms at |
| http://www.khronos.org/registry/speccopyright.html |
| |
| Status |
| |
| Complete. Approved by ARB on December 5, 2000. |
| |
| Version |
| |
| Date: 2004/04/02 |
| Revision: 0.7 |
| |
| Number |
| |
| ARB Extension #16 |
| |
| Dependencies |
| |
| ARB_vertex_blend and OpenGL 1.0 are required. |
| This extension is written against the ARB_vertex_blend extended |
| OpenGL 1.2.1 Specification. |
| |
| Overview |
| |
| This extension extends the abilities of ARB_vertex_blend to include |
| a palette of modelview matrices. The n vertex units use a palette |
| of m modelview matrices. (Where n and m are constrained to |
| implementation defined maxima.) Each vertex has a set of n |
| indices into the palette, and a corresponding set of n weights. |
| Matrix indices can be changed for each vertex (between Begin and |
| End). |
| |
| When this extension is utilized, the enabled units transform each |
| vertex by the modelview matrices specified by the vertices' |
| respective indices. These results are subsequently scaled by the |
| weights of the respective units and then summed to create the |
| eyespace vertex. |
| |
| A similar procedure is followed for normals. Normals, however, |
| are transformed by the inverse transpose of the modelview matrix. |
| |
| IP Status |
| |
| Unknown, but believed to be none. |
| |
| Issues |
| |
| |
| Should the matrix palette be loaded by adding MODELVIEWm tokens |
| for MatrixMode? |
| |
| No, this method is too difficult to extend to an arbitrary |
| (implementation defined) size palette, |
| and would imply having a 32 entry (minimum) stack per |
| matrix. |
| |
| |
| Should the Matrix palette be loaded with a new LoadMatrixPalette |
| command? |
| |
| No, although this provides an easy way to support arbitrary |
| palette sizes, the method loses the current (MultMatrix, |
| Rotate, Translate, Scale..) matrix functionality. |
| |
| Matrices will be Loaded into the palette with current |
| functions when MATRIX_MODE is MATRIX_PALETTE_ARB. The current |
| palette index is set by an explicit command: |
| CurrentPaletteMatrixARB(). |
| |
| |
| Should the Matrix Palette have a stack? |
| |
| Not required, this wastes a lot of space. Define the min |
| stack depth for the MATRIX_PALETTE_ARB MatrixMode to be 1. |
| This alows some implementations to add a stack if desired. |
| |
| The stacks established in ARB_vertex_blend for |
| MODELVIEW_MATRIXn are still present. |
| |
| |
| Should the matrix palette be gettable? |
| |
| Yes, CurrentPaletteMatrixARB() and |
| GetIntegerv(CURRENT_PALETTE_MATRIX_ARB, *data) define which |
| matrix in the palette is returned by |
| GetFloatv(MATRIX_PALETTE_ARB, *data). |
| |
| |
| Should MatrixIndexARB be changed to imply LoadMatrix calls to the |
| applicable MODELVIEW_MATRIXn stacks? |
| |
| No, the MODELVIEW_MATRIXn matrices are unused when |
| MATRIX_PALETTE is enabled. |
| |
| |
| Should there be a way to specify that the modelview matrices |
| for two different vertex units are identical? |
| |
| Not explicitely, but indexing the matrix palette provides this |
| functionality. (Both units will have the same matrix index.) |
| |
| Currently, the MATRIX_PALETTE_ARB enum is used to enable the |
| extension, to set the Matrix Mode, and to get the current matrix. |
| Is this confusing? Should more enums be added? |
| |
| No. |
| |
| New Procedures and Functions |
| |
| void CurrentPaletteMatrixARB(int index) |
| |
| void MatrixIndex{ubusui}vARB(int size, T *indices) |
| |
| void MatrixIndexPointerARB(int size, enum type, sizei stride, |
| void *pointer) |
| |
| |
| New Tokens |
| |
| Accepted by the <pname> parameters of GetFloatv, GetDoublev, |
| and IsEnabled, by the <mode> parameter of MatrixMode, and by the |
| <cap> parameters of Enable and Disable: |
| |
| MATRIX_PALETTE_ARB: 0x8840 |
| |
| Accepted by the <pname> parameters of GetIntegerv, GetFloatv, and |
| GetDoublev: |
| |
| MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841 |
| MAX_PALETTE_MATRICES_ARB 0x8842 |
| CURRENT_PALETTE_MATRIX_ARB 0x8843 |
| |
| Accepted by the <cap> parameters of EnableClientState and |
| DisableClientState and by the <pname> parameter of IsEnabled: |
| |
| MATRIX_INDEX_ARRAY_ARB: 0x8844 |
| |
| Accepted by the <pname> parameter of GetFloatv: |
| |
| CURRENT_MATRIX_INDEX_ARB 0x8845 |
| |
| Accepted by the <pname> parameter of GetIntegerv: |
| MATRIX_INDEX_ARRAY_SIZE_ARB 0x8846 |
| MATRIX_INDEX_ARRAY_TYPE_ARB 0x8847 |
| MATRIX_INDEX_ARRAY_STRIDE_ARB 0x8848 |
| |
| Accepted by the <pname> parameter of GetPointerv: |
| MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849 |
| |
| Additions to Chapter 2 of the OpenGL 1.2.1 Specification (Operation) |
| |
| - (2.6, p. 12) Second paragraph changed to: |
| |
| "Each vertex is specified with two, three, or four |
| coordinates. In addition, a current normal, current texture |
| coordinates, current color, current matrix indices, and |
| current weights may be used in processing each vertex. Normals |
| are used by the GL in lighting calculations; the current |
| normal is a three- dimensional vector that may be set by |
| sending three coordinates that specify it. Texture coordinates |
| determine how a texture image is mapped onto a |
| primitive. Indices are used to select modelview matrices |
| from the palette when blending is enabled. Weights are used |
| as blending factors when vertex blending is enabled. One |
| weight and one index exists for each enabled vertex blend |
| unit. Vertex units are enabled with Enable, and disabled |
| with Disable. Enabling or Disabling a vertex unit not |
| supported in the implementation results in the error |
| INVALID_OPERATION." |
| |
| - (2.6.3, p. 19) First paragraph changed to: |
| |
| "The only GL commands that are allowed within Begin/End |
| pairs are the commands for specifying vertex coordinates, |
| vertex color, normal coordinates, texture coordinates, matrix |
| indices, and weights (Vertex, Color, Index, Normal, TexCoord, |
| MatrixIndexARB, WeightARB), the ArrayElement command (see |
| section 2.8), the EvalCoord and EvalPoint commands (see |
| section 5.1), commands for specifying lighting material |
| parameters (Material commands; see section 2.13.2), display |
| list invocation commands (CallList and CallLists; see section |
| 5.4), and the EdgeFlag command. Executing any other GL command |
| between the execution of Begin and the corresponding execution |
| of End results in the error INVALID_OPERATION. Executing Begin |
| after Begin has already been executed but before an End is |
| executed generates the INVALID_OPERATION error, as does |
| executing End without a previous corresponding Begin." |
| |
| - (2.7, p. 20) Added after the third paragraph: |
| |
| "The current weights are set using |
| |
| void Weight{bsifd ubusui}vARB(int size, T *weights); |
| |
| the floating point values are assigned to the current |
| weight vector. The first <size> current weights are |
| replaced with <weights> such that: |
| |
| CURRENT_WEIGHT_ARB[i] = <weights>[i] |
| |
| When WEIGHT_SUM_UNITY_ARB is enabled, |
| |
| <size>-1 |
| CURRENT_WEIGHT_ARB[<size>] = 1 - SUM <weights>[i] |
| i=0 |
| |
| otherwise the rest of the current weights are set to 0. If |
| <size> is greater than MAX_VERTEX_UNITS_ARB or if |
| WEIGHTS_SUM_UNITY_ARB is enabled and <size> equals |
| MAX_VERTEX_UNITS_ARB, then the error INVALID_VALUE is |
| generated. When the values are supplied as byte, short, or |
| int, they are converted to floating-point values as |
| indicated for the corresponting type in Table 2.6. |
| |
| The current matrix indices are set using |
| |
| void MatrixIndex{ubusui}vARB(int size, T *indices); |
| |
| The specified indices are set to the first <size> Vertex |
| Unit index values. <size> indicates the count of matrix |
| indices in the <indices> array. |
| |
| Note that vertex units which are disabled can still receive |
| weights and indices." |
| |
| |
| - (2.8, p. 21) First paragraph changed to read: |
| |
| "The vertex specification commands described in section 2.7 |
| accept data in almost any format, but their use requires |
| many command executions to specify even simple geometry. |
| Vertex data may also be placed into arrays that are stored |
| in the client's address space. Blocks of data in these |
| arrays may then be used to specify multiple geometric |
| primitives through the execution of a single GL command. |
| The client may specify an implementation dependent set of |
| arrays: one each to store edge flags, texture coordinates, |
| colors, color indices, normals, and vertices, weights, and |
| matrix indices. The commands |
| |
| void EdgeFlagPointer( sizei stride, void *pointer); |
| |
| void TexCoordPointer( int size, enum type, sizei stride, |
| void *pointer ); |
| |
| void ColorPointer( int size, enum type, sizei stride, |
| void *pointer ); |
| |
| void IndexPointer( enum type, sizei stride, void |
| *pointer ); |
| |
| void NormalPointer( enum type, sizei stride, void |
| *pointer ); |
| |
| void VertexPointer( int size, enum type, sizei stride, |
| void *pointer ); |
| |
| void WeightPointerARB(int size, enum type, |
| sizei stride, void *pointer) |
| |
| void MatrixIndexPointerARB(int size, enum type, |
| sizei stride, void *pointer) |
| |
| describe the locations and organizations of these arrays. |
| For each command, type specifies the data type of the |
| values stored in the array. Because edge flags are always |
| type boolean, EdgeFlagPointer has no type argument. Size, |
| when present, indicates the number of values per vertex |
| that are stored in the array. Because normals are always |
| specified with three values, NormalPointer has no size |
| argument. Likewise, because color indices, and edge flags |
| are always specified with a single value, IndexPointer, and |
| EdgeFlagPointer also have no size argument. Table 2.4 |
| indicates the allowable values for size and type (when |
| present). For type the values BYTE, SHORT, INT, FLOAT, and |
| DOUBLE indicates types byte, short, int, float, and double, |
| respectively; and the values UNSIGNED_BYTE, UNSIGNED_SHORT, |
| and UNSIGNED_INT indicate types ubyte, ushort, and uint, |
| respectively. The error INVALID_VALUE is generated if size |
| is specified with a value other than that indicated in the |
| table. For implementations supporting vertex blending, note |
| that <size> values for WeightPointerARB and |
| MatrixIndexPointerARB must be less than the implementation |
| defined value MAX_VERTEX_UNITS_ARB." |
| |
| - (2.8, p. 22) Change table 2.4 to read: |
| |
| Command Sizes Types |
| ------- ----- ----- |
| VertexPointer 2,3,4 short, int, float, |
| double |
| NormalPointer 3 byte, short, int, float, |
| double |
| ColorPointer 3,4 byte, ubyte, short, |
| ushort, int, uint, |
| float, double |
| IndexPointer 1 ubyte, short, int, |
| float, double |
| TexCoordPointer 1,2,3,4 short, int, float, |
| double |
| EdgeFlagPointer 1 boolean |
| WeightPointerARB 1..MAX_VERTEX byte, ubyte, short, |
| _UNITS_ARB ushort, int, uint, |
| float, double |
| |
| MatrixIndexPointerARB 1..MAX_VERTEX unsigned byte, unsigned |
| _UNITS_ARB short, unsigned int |
| |
| |
| - (2.8 p. 23) Change paragraph two to: |
| |
| "An individual array is enabled or disabled by calling one |
| of |
| |
| void EnableClientState( enum array ); |
| void DisableClientState( enum array ); |
| |
| with array set to EDGE_FLAG_ARRAY, TEXTURE_COORD_ARRAY, |
| COLOR_ARRAY, INDEX_ARRAY, NORMAL_ARRAY, VERTEX_ARRAY, |
| MATRIX_INDEX_ARRAY_ARB, or WEIGHT_ARRAY_ARB, for the edge |
| flag, texture coordinate, color, color index, normal, vertex, |
| matrix index, or weight array, respectively. " |
| |
| - (2.8 p. 23) Change paragraph three to: |
| |
| "The ith element of every enabled array is transferred to |
| the GL by calling |
| |
| void ArrayElement( int i ); |
| |
| For each enabled array, it is as though the corresponding |
| command from section 2.7 or 2.6.2 were called with a |
| pointer to element i. For the vertex array, the |
| corresponding command is Vertex[size][type]v, where size is |
| one of [2,3,4], and type is one of [s,i,f,d], corresponding |
| to array types short, int, float, and double respectively. |
| The corresponding commands for the edge flag, texture |
| coordinate, color, color index, normal, and weight arrays |
| are EdgeFlagv, TexCoord[size][type]v, Color[size][type]v, |
| Index[type]v, Normal[type]v, MatrixIndex[type]vARB, and |
| Weight[type]vARB, respectively. If the vertex array is |
| enabled, it is as though Vertex[size][type]v is executed last, |
| after the executions of the other corresponding commands." |
| |
| - (2.10 p. 28) Edit to the last paragraph: |
| |
| "Figure 2.6 diagrams the sequence of transformations that are |
| applied to vertices. The vertex coordinates that are |
| presented to the GL are termed object coordinates. The |
| model-view matrix is applied to these coordinates to yield eye |
| coordinates. In implementations with vertex blending, all |
| enabled modelview matrices are applied to these coordinates, |
| and the weighted sum of the results are the eye coordinates. |
| Then another matrix, called the projection matrix, is applied |
| to eye coordinates to yield clip coordinates. A perspective |
| division is carried out on clip coordinates to yield |
| normalized device coordinates. A final viewport |
| transformation is applied to convert these coordinates into |
| window coordinates." |
| |
| - (2.10 p. 29) Edit to the second paragraph: |
| |
| "... the vertex's eye coordinates are found as: |
| |
| (xe) n-1 (xo) |
| (ye) = SUM w_i * M_i * (yo) |
| (ze) i=0 (zo) |
| (we) (wo) |
| |
| where M_i is the palette matrix associated with the i'th |
| Vertex unit: |
| |
| M_i = MatrixPalette[MatrixIndex[i]], if VERTEX_BLEND_ARB, |
| MATRIX_PALETTE_ARB and VERTEX_UNIT_ARB<i> are enabled, and |
| M_i = MODELVIEW_MATRIX, otherwise. |
| |
| w_i is the Vertex's associated weight for vertex unit i: |
| |
| w_i = weight_i, if VERTEX_BLEND_ARB, MATRIX_PALETTE_ARB |
| and VERTEX_UNIT_ARB<i> are enabled, |
| 1, if MATRIX_PALETTE_ARB is disabled, |
| |
| and, |
| |
| n = ACTIVE_VERTEX_UNITS_ARB." |
| |
| - (2.10.2 p. 31) Change the first paragraph to: |
| |
| "The projection matrix and model-view matrices are set |
| with a variety of commands. The affected matrix is |
| determined by the current matrix mode. The current |
| matrix mode is set with |
| |
| void MatrixMode( enum mode ); |
| |
| which takes one of the pre-defined constants TEXTURE, |
| MODELVIEW, COLOR, PROJECTION, MODELVIEWn_ARB, |
| MATRIX_PALETTE_ARB. TEXTURE is described later in section |
| 2.10.2, and COLOR is described in section 3.6.3. If the |
| current matrix mode is MODELVIEW, the matrix operations |
| apply to the model-view matrix; if PROJECTION, then they |
| apply to the projection matrix. |
| |
| |
| In implementations supporting ARB_matrix_palette, |
| |
| void CurrentPaletteMatrixARB(int index); |
| |
| defines which of the palette's matrices is affected by |
| subsequent matrix operations when the current matrix mode is |
| MATRIX_PALETTE_ARB. CurrentBlendMatrixARB generates the |
| error INVALID_VALUE if the <index> parameter is not between |
| 0 and MAX_PALETTE_MATRICES_ARB. |
| The CURRENT_PALETTE_MATRIX_ARB enum can be used to query the |
| last value set by CurrentPaletteMatrixARB." |
| |
| - (2.10.2 p. 34) Change to the fourth paragraph: |
| |
| "The state required to implement transformations consists of a |
| four-valued integer indicating the current matrix mode, a |
| stack of at least two 4 x 4 matrices for each of COLOR, |
| PROJECTION, and TEXTURE with associated stack pointers, a |
| stack of at least 32 4 x 4 matrices with an associated stack |
| pointer for MODELVIEW, and a set of MAX_PALETTE_MATRICES_ARB |
| stacks of at least 1 4 x 4 matrices each for the matrix palette. |
| Initially, there is only one matrix on each stack, and all |
| matrices are set to the identity. The initial matrix mode |
| is MODELVIEW. |
| |
| - (2.10.3 p. 35) Added after the second paragraph: |
| |
| "When vertex blending is enabled, the normal is transformed |
| to eye space by: |
| |
| n-1 |
| (nx' ny' nz') = (nx ny nz) Inv ( SUM w_i * Mu_i) |
| i=0 |
| |
| Alternatively implementations may choose to transform the |
| normal to eye-space by: |
| |
| n-1 |
| (nx' ny' nz') = SUM w_i * (nx ny nz) Inv(Mu_i) |
| i=0 |
| |
| where Mu_i is the upper leftmost 3x3 matrix taken from the |
| modelview for vertex unit i (M_i), |
| |
| M_i = MatrixPalette[MatrixIndex[i]] |
| |
| if VERTEX_BLEND_ARB, MATRIX_PALETTE_ARB and VERTEX_UNIT_ARB<i> |
| are enabled, and |
| |
| M_i = MODELVIEW_MATRIX |
| |
| otherwise. |
| |
| weight_i is the vertex's associated weight for vertex unit i, |
| |
| w_i = weight_i |
| |
| and |
| |
| n = ACTIVE_VERTEX_UNITS_ARB" |
| |
| |
| Additions to Chapter 3: |
| |
| None |
| |
| Additions to Chapter 4: |
| |
| None |
| |
| Additions to Chapter 5: |
| |
| None |
| |
| Additions to Chapter 6: |
| |
| None |
| |
| Additions to the GLX Specification |
| |
| In progress. |
| |
| Additions to the GLX Stream Protocol: |
| |
| |
| Four new GL rendering commandsl are added. The following commands |
| are sent to the server as part of a glXRender request: |
| |
| MatrixIndexubvARB |
| 2 8+n+p rendering command length |
| 2 4326 rendering command opcode |
| 4 INT32 size |
| 1*n CARD8 weights |
| p pad(n) |
| |
| MatrixIndexusvARB |
| 2 8+2*n rendering command length |
| 2 4327 rendering command opcode |
| 4 INT32 size |
| 2*n CARD16 weights |
| p pad(2*n) |
| |
| MatrixIndexuivARB |
| 2 8+4*n rendering command length |
| 2 4328 rendering command opcode |
| 4 INT32 size |
| 4*n CARD32 weights |
| |
| CurrentPaletteMatrixARB |
| 2 8 rendering command length |
| 2 4329 rendering command opcode |
| 4 INT32 count |
| |
| Errors |
| |
| INVALID_VALUE is generated if the <size> parameter for |
| MatrixIndexARB or MatrixIndexPointerARB is greater than |
| MAX_VERTEX_UNITS_ARB, or if WEIGHT_SUM_UNITY_ARB is enabled |
| and <size> is equal to MAX_VERTEX_UNITS_ARB. |
| |
| INVALID_VALUE is generated if the <count> parameter to |
| CurrentPaletteMatrixARB is greater than MAX_PALETTE_MATRICES_ARB |
| or if <count> is equal to zero. |
| |
| New State |
| |
| Modified State in Table 6.5 (p. 195): |
| Initial |
| Get Value Get Command Type Value Attribute Description |
| --------- ----------- ---- ------- --------- ----------- |
| CURRENT_MATRIX_INDEX_ARB GetIntegerv n*Z+ 0 current array of current matrix indices |
| |
| |
| Modified State in Table 6.6 (p. 196): |
| Initial |
| Get Value Type Get Command Value Description Sec. Attribute |
| --------- ---- ----------- ------- ----------- ---- --------- |
| MATRIX_INDEX_ARRAY_ARB B IsEnabled False Matrix indices enable 2.8 vertex-array |
| MATRIX_INDEX_ARRAY_SIZE_ARB Z+ GetIntegerv 0 Indices per element 2.8 vertex-array |
| MATRIX_INDEX_ARRAY_TYPE_ARB Z_3 GetIntegerv UBYTE Type of indices 2.8 vertex-array |
| MATRIX_INDEX_ARRAY_POINTER_ARB Y GetPointerv False Pointer to the Matrix 2.8 vertex-array |
| indices array |
| |
| Modified state in Table 6.7 (p. 197) Transformation State: |
| Initial |
| Get Value Get Command Type Value Attribute Description |
| --------- ----------- ---- --------- --------- ----------- |
| MATRIX_PALETTE_ARB GetFloatv 2*x1*xM4 Identity - stack of current modelview matrix in the palette |
| MATRIX_PALETTE_ARB IsEnabled B FALSE transform Enable for ARB_matrix_palette |
| CURRENT_PALETTE_ GetIntegerv Z+ 0 transform index of current modelview matrix in the |
| MATRIX_ARB palette, as set by CurrentPaletteMatrixARB() |
| |
| |
| New Implementation Dependent State |
| |
| Modified state in Table 6.24 (p. 214) Implementation Dependant Values: |
| |
| Get Value Get Command Type Min Value Description |
| --------- ----------- ---- --------- ----------- |
| MAX_MATRIX_PALETTE_ GetIntegerv Z+ 1 Max matrix palette stack depth |
| STACK_DEPTH_ARB |
| |
| |
| Modified state in Table 6.25 (p. 215): |
| |
| Get Value Get Command Type Min Value Description |
| --------- ----------- ---- --------- ----------- |
| MAX_PALETTE_MATRICES_ARB GetIntegerv Z+ MAX_VERTEX_ Max size of the matrix palette |
| UNITS_ARB |
| |
| Additions to Appendix A: |
| |
| None |
| |
| |
| Revision History |
| 2000/10/17 v 0.3 jschelte - added Usage example. |
| 2000/11/09 v 0.4 jschelte - cleaned up some "issues". |
| 2000/11/27 v 0.5 jschelte - closed last issue, fixed typo in Usage |
| 2000/11/30 v 0.6 jschelte - replaced "blend matrices" with |
| "palette matrices" |
| - cleared up some confusion in the |
| naming of the enum for the current |
| indices and the current palette |
| matrix for load/get. |
| 2004/04/02 v 0.7 Thomas Roell - added GLX protocol |
| |
| Addendum: Using this extension. |
| |
| // Get the implementation's capabilities |
| glGetIntegerv(MAX_VERTEX_UNITS_ARB, *max_blends); |
| glGetIntegerv(MAX_PALETTE_MATRICES_ARB, *max_matrices); |
| |
| //validate that max_blends and max_matrices are sufficient here. |
| |
| // enable the units |
| glEnable(VERTEX_UNIT_0_ARB); |
| glEnable(VERTEX_UNIT_1_ARB); |
| glEnable(VERTEX_UNIT_2_ARB); |
| glEnable(VERTEX_UNIT_3_ARB); |
| |
| // Load the matrix Palette |
| glMatrixMode(MATRIX_PALETTE_ARB); |
| for (i=0; i<palette_size; i++) |
| { |
| glCurrentPaletteMatrix(i); |
| glLoadMatrix(mat[i]); |
| // N.B. |
| // glGetIntegerv(CURRENT_PALETTE_MATRIX_ARB, &index); |
| // .. will return index==i. |
| // glGetFloatv(MATRIX_PALETTE_ARB, &matrix); |
| // .. will return matrix==mat[i]. |
| } |
| |
| // Per vertex array |
| // Enable and define the Vertex Arrays: |
| // e.g. V3F C4UB N3F W4F MI4UB T4F |
| glEnableClientState(VERTEX_ARRAY); |
| glEnableClientState(NORMAL_ARRAY); |
| glEnableClientState(COLOR_ARRAY); |
| glEnableClientState(TEXTURE_COORD_ARRAY); |
| glEnableClientState(WEIGHT_ARRAY_ARB); |
| glEnableClientState(MATRIX_INDEX_ARRAY_ARB); |
| |
| glVertexPointer(3, FLOAT, 3, vertices); |
| glNormalPointer(FLOAT, 3, normals); |
| glColorPointer(4, UNSIGNED_BYTE, 4, colors); |
| glTexCoordPointer(4, FLOAT, 4, texcoords); |
| glWeightPointerARB(4, FLOAT, 4, weights); |
| glMatrixIndexPointerARB(4, UNSIGNED_BYTE, 4, indices); |
| |
| // Draw Primitives from the array |
| glDrawArrays(TRIANGLES, 0, vert_array_size); |
| |
| |
| // **alternatively** |
| typdef struct st_interleaved_vertex { |
| FLOAT position[4]; |
| FLOAT weights[4]; |
| UNSIGNED_BYTE indices[4]; |
| FLOAT normal[3]; |
| FLOAT color[4]; |
| FLOAT texcoord[4]; |
| } interleaved_vertex; |
| interleaved_vertex vertices[NUM_VERTS]; |
| |
| // the rest as above, except the Array Pointer definition: |
| int stride = sizeof(interleaved_vertex); |
| |
| glVertexPointer( 3, FLOAT, stride, &(vertices[0].position) ); |
| glNormalPointer( FLOAT, stride, &(vertices[0].normal) ); |
| glColorPointer( 4, UNSIGNED_BYTE, stride, &(vertices[0].color) ); |
| glTexCoordPointer( 4, FLOAT, stride, &(vertices[0].texcoords) ); |
| glWeightPointerARB( 4, FLOAT, stride, &(vertices[0].weights) ); |
| glMatrixIndexPointerARB( 4, UNSIGNED_BYTE, stride, |
| &(vertices[0].indices) ); |
| |