| Name |
| |
| OES_matrix_palette |
| |
| Name Strings |
| |
| GL_OES_matrix_palette |
| |
| Contact |
| |
| Aaftab Munshi (amunshi@ati.com) |
| |
| Notice |
| |
| Copyright (c) 2004-2013 The Khronos Group Inc. Copyright terms at |
| http://www.khronos.org/registry/speccopyright.html |
| |
| Specification Update Policy |
| |
| Khronos-approved extension specifications are updated in response to |
| issues and bugs prioritized by the Khronos OpenGL ES Working Group. For |
| extensions which have been promoted to a core Specification, fixes will |
| first appear in the latest version of that core Specification, and will |
| eventually be backported to the extension document. This policy is |
| described in more detail at |
| https://www.khronos.org/registry/OpenGL/docs/update_policy.php |
| |
| Status |
| |
| Ratified by the Khronos BOP, Aug 5, 2004. |
| |
| Version |
| |
| Version 1, August 2004 |
| |
| Number |
| |
| OpenGL ES Extension #12 |
| |
| Dependencies |
| |
| OpenGL ES 1.0 is required. |
| |
| Overview |
| |
| This extension adds the ability to support vertex skinning in OpenGL ES. |
| A simplified version of the ARB_matrix_palette extension is used to |
| define OES_matrix_palette extension. |
| |
| This extension allow OpenGL ES to support a palette of matrices. The matrix |
| palette defines a set of matrices that can be used to transform a vertex. |
| The matrix palette is not part of the model view matrix stack and is enabled |
| by setting the MATRIX_MODE to MATRIX_PALETTE_OES. |
| |
| 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 and weights can be changed for each vertex. |
| |
| 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 this extension be an optional or mandatory extension |
| |
| Will be an optional extension since ARB_matrix_palette didn't |
| see much usage in OpenGL. |
| |
| Should we allow the ability to load the current model view matrix |
| into the matrix palette |
| |
| Yes. This will be very helpful since it makes it very easy |
| to load an object heirarchy. This will also be helpful for JSR184 |
| |
| 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_OES. 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. |
| |
| |
| Should the matrix palette be gettable? |
| |
| No. |
| |
| 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 explicitly, but indexing the matrix palette provides this |
| functionality. (Both units will have the same matrix index.) |
| |
| |
| New Procedures and Functions |
| |
| void CurrentPaletteMatrixOES(uint index) |
| |
| void LoadPaletteFromModelViewMatrixOES() |
| |
| void MatrixIndexPointerOES(int size, enum type, sizei stride, void *pointer) |
| |
| void WeightPointerOES(int size, enum type, sizei stride, void *pointer); |
| |
| New Tokens |
| |
| Accepted by the <mode> parameter of MatrixMode, and by the |
| <cap> parameters of Enable and Disable: |
| |
| MATRIX_PALETTE_OES 0x8840 |
| |
| Accepted by the <pname> parameters of GetIntegerv: |
| |
| MAX_PALETTE_MATRICES_OES 0x8842 |
| MAX_VERTEX_UNITS_OES 0x86A4 |
| CURRENT_PALETTE_MATRIX_OES 0x8843 |
| |
| The default values for MAX_PALETTE_MATRICES_OES and MAX_VERTEX_UNITS_OES |
| are 9 and 3 resp. |
| |
| Accepted by the <cap> parameters of EnableClientState and DisableClientState and |
| by the <pname> parameter of IsEnabled: |
| |
| MATRIX_INDEX_ARRAY_OES 0x8844 |
| WEIGHT_ARRAY_OES 0x86AD |
| |
| Accepted by the <pname> parameter of GetIntegerv: |
| |
| MATRIX_INDEX_ARRAY_SIZE_OES 0x8846 |
| MATRIX_INDEX_ARRAY_TYPE_OES 0x8847 |
| MATRIX_INDEX_ARRAY_STRIDE_OES 0x8848 |
| MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES 0x8B9E |
| |
| WEIGHT_ARRAY_SIZE_OES 0x86AB |
| WEIGHT_ARRAY_TYPE_OES 0x86A9 |
| WEIGHT_ARRAY_STRIDE_OES 0x86AA |
| WEIGHT_ARRAY_BUFFER_BINDING_OES 0x889E |
| |
| Accepted by the <pname> parameter of GetPointerv: |
| |
| MATRIX_INDEX_ARRAY_POINTER_OES 0x8849 |
| WEIGHT_ARRAY_POINTER_OES 0x86AC |
| |
| Additions to Chapter 2 of the OpenGL ES 1.0 Specification |
| |
| - Added to section 2.8 |
| |
| void WeightPointerOES(int size, enum type, sizei stride, void *pointer); |
| |
| void MatrixIndexPointerOES(int size, enum type, sizei stride, void *pointer); |
| |
| WeightPointerOES & MatrixIndexPointerOES are used to describe the weights and |
| matrix indices used to blend corresponding matrices for a given vertex. |
| |
| For implementations supporting matrix palette, note that <size> values for |
| WeightPointerOES & MatrixIndexPointerOES must be less than or equal to the |
| implementation defined value MAX_VERTEX_UNITS_OES. |
| |
| - Added to table in section 2.8 |
| |
| Command Sizes Types |
| ------- ----- ----- |
| WeightPointerOES 1..MAX_VERTEX_UNITS_OES fixed, float |
| MatrixIndexPointerOES 1..MAX_VERTEX_UNITS_OES ubyte |
| |
| |
| - (section 2.8) Extend the cap flags passed to EnableClientState/DisableClientState |
| to include |
| |
| MATRIX_INDEX_ARRAY_OES, or WEIGHT_ARRAY_OES |
| |
| - (section 2.10) Add the following: |
| |
| "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 |
| matrix palette, the matrices specified by the indices per vertex |
| 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." |
| |
| "... 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 MATRIX_PALETTE_OES is enabled, and |
| M_i = MODELVIEW_MATRIX, otherwise. |
| |
| w_i is the Vertex's associated weight for vertex unit i: |
| |
| w_i = weight_i, if MATRIX_PALETTE_OES is enabled, |
| 1, if MATRIX_PALETTE_OES is disabled, |
| |
| and, |
| |
| n = <size> value passed into glMatrixIndexPointerOES." |
| |
| |
| "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, PROJECTION, MATRIX_PALETTE_OES. |
| |
| |
| In implementations supporting OES_matrix_palette, |
| |
| void CurrentPaletteMatrixOES(uint index); |
| |
| defines which of the palette's matrices is affected by |
| subsequent matrix operations when the current matrix mode is |
| MATRIX_PALETTE_OES. CurrentPaletteMatrixOES generates the |
| error INVALID_VALUE if the <index> parameter is not between |
| 0 and MAX_PALETTE_MATRICES_OES - 1. |
| |
| In implementations supporting OES_matrix_palette, |
| |
| void LoadPaletteFromModelViewMatrixOES(); |
| |
| copies the current model view matrix to a matrix in the matrix |
| palette, specified by CurrentPaletteMatrixOES. |
| |
| DrawArrays and DrawElements will not render the primitive if |
| the matrix palette was enabled and the weights and/or matrix |
| index vertex pointers are disabled or are not valid. |
| |
| "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 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_OES matrices of at least 9 |
| 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. |
| |
| "When matrix palette 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 MATRIX_PALETTE_OES is enabled, and |
| M_i = MODELVIEW_MATRIX, otherwise |
| |
| otherwise. |
| |
| weight_i is the vertex's associated weight for vertex unit i, |
| |
| w_i = weight_i |
| |
| and |
| |
| n = <size> value passed into glMatrixIndexPointerOES." |
| |
| |
| Errors |
| |
| INVALID_VALUE is generated if the <size> parameter for |
| MatrixIndexPointerOES or WeightPointerOES is greater |
| than MAX_VERTEX_UNITS_OES. |
| |
| INVALID_VALUE is generated if the <count> parameter to |
| CurrentPaletteMatrixOES is greater than MAX_PALETTE_MATRICES_OES - 1 |
| |
| |
| New State |
| |
| (table 6.6, p. 232) |
| |
| Get Initial |
| Get Value Type Command Value Description |
| --------- ---- ------- ------- ----------- |
| MATRIX_INDEX_ARRAY_OES B IsEnabled False matrix index array enable |
| MATRIX_INDEX_ARRAY_SIZE_OES Z+ GetIntegerv 0 matrix indices per vertex |
| MATRIX_INDEX_ARRAY_TYPE_OES Z+ GetIntegerv UBYTE type of matrix index data |
| MATRIX_INDEX_ARRAY_STRIDE_OES Z+ GetIntegerv 0 stride between |
| matrix indices |
| MATRIX_INDEX_ARRAY_POINTER_OES Y GetPointerv 0 pointer to matrix |
| index array |
| |
| WEIGHT_ARRAY_OES B IsEnabled False weight array enable |
| WEIGHT_ARRAY_SIZE_OES Z+ GetIntegerv 0 weights per vertex |
| WEIGHT_ARRAY_TYPE_OES Z2 GetIntegerv FLOAT type of weight data |
| WEIGHT_ARRAY_STRIDE_OES Z+ GetIntegerv 0 stride between weights |
| per vertex |
| WEIGHT_ARRAY_POINTER_OES Y GetPointerv 0 pointer to weight array |
| |
| |
| (table 6.7, p. 233) |
| |
| Get Initial |
| Get Value Type Command Value Description |
| --------- ---- ------- ----- ----------- |
| |
| MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES Z+ GetIntegerv 0 matrix index array |
| buffer binding |
| |
| WEIGHT_ARRAY_BUFFER_BINDING_OES Z+ GetIntegerv 0 weight array |
| buffer binding |
| |
| (table 6.9, p. 235) |
| |
| Get Initial |
| Get Value Type Command Value Description |
| --------- ---- ------- ------- ----------- |
| |
| MATRIX_PALETTE_OES B IsEnabled False matrix palette enable |
| MAX_PALETTE_MATRICES_OES Z+ GetIntegerv 9 size of matrix palette |
| MAX_VERTEX_UNITS_OES Z+ GetIntegerv 3 number of matrices per vertex |
| CURRENT_PALETTE_MATRIX_OES Z+ GetIntegerv 0 transform index of current |
| modelview matrix in the palette, |
| as set by CurrentPaletteMatrixOES() |
| |
| |
| Revision History |
| |
| |
| |
| Addendum: Using this extension. |
| |
| /* position viewer */ |
| glMatrixMode(GL_MATRIX_PALETTE_OES); |
| glCurrentPaletteMatrixOES(0); |
| glLoadIdentity(); |
| glTranslatef(0.0f, 0.0f, -7.0f); |
| glRotatef(yrot, 0.0f, 1.0f, 0.0f); |
| |
| glCurrentPaletteMatrixOES(1); |
| glLoadIdentity(); |
| glTranslatef(0.0f, 0.0f, -7.0f); |
| |
| glRotatef(yrot, 0.0f, 1.0f, 0.0f); |
| glRotatef(zrot, 0.0f, 0.0f, 1.0f); |
| |
| glEnable(GL_MATRIX_PALETTE_OES); |
| |
| glEnableClientState(GL_VERTEX_ARRAY); |
| glEnableClientState(GL_TEXTURE_COORD_ARRAY); |
| glEnableClientState(GL_MATRIX_INDEX_ARRAY_OES); |
| glEnableClientState(GL_WEIGHT_ARRAY_OES); |
| |
| glVertexPointer(3, GL_FLOAT, 7 * sizeof(GLfloat), vertexdata); |
| glTexCoordPointer(2, GL_FLOAT, 7 * sizeof(GLfloat), vertexdata + 3); |
| glWeightPointerOES(2, GL_FLOAT, 7 * sizeof(GLfloat),vertexdata + 5); |
| glMatrixIndexPointerOES(2, GL_UNSIGNED_BYTE, 0, matrixindexdata); |
| |
| for(int i = 0; i < (numSegments << 2) + 2; i ++) |
| glDrawArrays(GL_TRIANGLE_FAN, i << 2, 4); |
| |