Back to the OpenGL extension cross reference
GL_EXT_vertex_weighting
EXT_vertex_weighting
Name Strings
GL_EXT_vertex_weighting
Contact
Mark J. Kilgard, NVIDIA Corporation (mjk 'at' nvidia.com)
Notice
Copyright NVIDIA Corporation, 1999, 2000.
Status
Discontinued.
NVIDIA no longer supports this extension in driver updates
after November 2002. Instead, use either ARB_vertex_program &
NV_vertex_program.
Version
NVIDIA Date: January 3, 2003
$Date$ $Revision$
Number
188
Dependencies
None
Written based on the wording of the OpenGL 1.2 specification but not
dependent on it.
Overview
The intent of this extension is to provide a means for blending
geometry based on two slightly differing modelview matrices.
The blending is based on a vertex weighting that can change on a
per-vertex basis. This provides a primitive form of skinning.
A second modelview matrix transform is introduced. When vertex
weighting is enabled, the incoming vertex object coordinates are
transformed by both the primary and secondary modelview matrices;
likewise, the incoming normal coordinates are transformed by the
inverses of both the primary and secondary modelview matrices.
The resulting two position coordinates and two normal coordinates
are blended based on the per-vertex vertex weight and then combined
by addition. The transformed, weighted, and combined vertex position
and normal are then used by OpenGL as the eye-space position and
normal for lighting, texture coordinate, generation, clipping,
and further vertex transformation.
Issues
Should the extension be written to extend to more than two vertex
weights and modelview matrices?
RESOLUTION: NO. Supports only one vertex weight and two modelview
matrices. If more than two is useful, that can be handled with
another extension.
Should the weighting factor be GLclampf instead of GLfloat?
RESOLUTION: GLfloat. Though the value of a weighting factors
outside the range of zero to one (and even weights that do not add
to one) is dubious, there is no reason to limit the implementation
to values between zero and one.
Should the weights and modelview matrices be labeled 1 & 2 or 0 & 1?
RESOLUTION: 0 & 1. This is consistent with the way lights and
texture units are named in OpenGL. Make GL_MODELVIEW0_EXT
be an alias for GL_MODELVIEW. Note that the GL_MODELVIEW0_EXT+1
will not be GL_MODELVIEW1_EXT as is the case with GL_LIGHT0 and
GL_LIGHT1.
Should there be a way to simultaneously Rotate, Translate, Scale,
LoadMatrix, MultMatrix, etc. the two modelview matrices together?
RESOLUTION: NO. The application must use MatrixMode and repeated
calls to keep the matrices in sync if desired.
Should the secondary modelview matrix stack be as deep as the primary
matrix stack or can they be different sizes?
RESOLUTION: Must be the SAME size. This wastes a lot of memory
that will be probably never be used (the modelview matrix stack
must have at least 32 entries), but memory is cheap.
The value returned by MAX_MODELVIEW_STACK_DEPTH applies to both
modelview matrices.
Should there be any vertex array support for vertex weights.
RESOLUTION: YES.
Should we have a VertexWeight2fEXT that takes has two weight values?
RESOLUTION: NO. The weights are always vw and 1-vw.
What is the "correct" way to blend matrices, particularly when wo is
not one or the modelview matrix is projective?
RESOLUTION: While it may not be 100% correct, the extension blends
the vertices based on transforming the object coordinates by
both M0 and M1, but the resulting w coordinate comes from simply
transforming the object coordinates by M0 and extracting the w.
Another option would be to simply blend the two sets of eye
coordinates without any special handling of w. This is harder.
Another option would be to divide by w before blending the two
sets of eye coordinates. This is awkward because if the weight
is 1.0 with vertex weighting enabled, the result is not the
same as disabling vertex weighting since EYE_LINEAR texgen
is based of of the non-perspective corrected eye coordinates.
As specified, the normal weighting and combination is performed on
unnormalized normals. Would the math work better if the normals
were normalized before weighting and combining?
RESOLUTION: Vertex weighting of normals is after the
GL_RESCALE_NORMAL step and before the GL_NORMALIZE step.
As specified, feedback and selection should apply vertex weighting
if enabled. Yuck, that would mean that we need software code for
vertex weighting.
RESOLUTION: YES, it should work with feedback and selection.
Sometimes it would be useful to mirror changes in both modelview
matrices. For example, the viewing transforms are likely to be
different, just the final modeling transforms would be different.
Should there be an API support for mirroring transformations into
both matrices?
RESOLUTION: NO. Such support is likely to complicate the
matrix management in the OpenGL. Applications can do a
Get matrix from modelview0 and then a LoadMatrix into modelview1
manually if they need to mirror things.
I also worry that if we had a mirrored matrix mode, it would
double the transform concatenation work if used naively.
Many of the changes to the two modelview matrices will be the same.
For example, the initial view transform loaded into each will be the
same. Should there be a way to "mirror" changes to both modelview
matrices?
RESOLUTION: NO. Mirroring matrix changes would complicate the
driver's management of matrices. Also, I am worried that naive
users would mirror all transforms and lead to lots of redundant
matrix concatenations. The most efficient way to handle the
slight differences between the modelview matrices is simply
to GetFloat the primary matrix, LoadMatrix the values in the
secondary modelview matrix, and then perform the "extra" transform
to the secondary modelview matrix.
Ideally, a glCopyMatrix(GLenum src, GLenum dst) type OpenGL
command could make this more efficient. There are similiar cases
where you want the modelview matrix mirrored in the texture matrix.
This is not the extension to solve this minor problem.
The post-vertex weighting normal is unlikely to be normalized.
Should this extension automatically enable normalization?
RESOLUTION: NO. Normalization should operate as specified.
The user is responsible for enabling GL_RESCALE_NORMAL or
GL_NORMALIZE as needed.
You could imagine cases where the application only sent
vertex weights of either zero or one and pre-normalized normals
so that GL_NORMALIZE would not strictly be required.
Note that the vertex weighting of transformed normals occurs
BEFORE normalize and AFTER rescaling. See the issue below for
why this can make a difference.
How does vertex weighting interact with OpenGL 1.2's GL_RESCALE_NORMAL
enable?
RESOLUTION: Vertex weighting of transformed normals occurs
BEFORE normalize and AFTER rescaling.
OpenGL 1.2 permits normal rescaling to behave just like normalize
and because normalize immediately follows rescaling, enabling
rescaling can be implementied by simply always enabling normalize.
Vertex weighting changes this. If one or both of the modelview
matrices has a non-uniform scale, it may be useful to enable
rescaling and normalize and this operates differently than
simply enabling normalize. The difference is that rescaling
occurs before the normal vertex weighting.
An implementation that truly treated rescaling as a normalize
would support both a pre-weighting normalize and a post-weighting
normalize. Arguably, this is a good thing.
For implementations that perform simply rescaling and not a full
normalize to implement rescaling, the rescaling factor can be
concatenated into each particular inverse modelview matrix.
void VertexWeightfEXT(float weight);
void VertexWeightfvEXT(float *weight);
void VertexWeightPointerEXT(int size, enum type, sizei stride, void *pointer);
Accepted by the <target> parameter of Enable:
VERTEX_WEIGHTING_EXT 0x8509
Accepted by the <mode> parameter of MatrixMode:
MODELVIEW0_EXT 0x1700 (alias to MODELVIEW enumerant)
MODELVIEW1_EXT 0x850A
Accepted by the <pname> parameter of GetBooleanv, GetIntegerv,
GetFloatv, and GetDoublev:
VERTEX_WEIGHTING_EXT
MODELVIEW0_EXT
MODELVIEW1_EXT
MODELVIEW0_MATRIX_EXT 0x0BA6 (alias to MODELVIEW_MATRIX)
MODELVIEW1_MATRIX_EXT 0x8506
CURRENT_VERTEX_WEIGHT_EXT 0x850B
VERTEX_WEIGHT_ARRAY_EXT 0x850C
VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D
VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E
VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F
MODELVIEW0_STACK_DEPTH_EXT 0x0BA3 (alias to MODELVIEW_STACK_DEPTH)
MODELVIEW1_STACK_DEPTH_EXT 0x8502
Accepted by the <pname> parameter of GetPointerv:
VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510
Additions to Chapter 2 of the OpenGL 1.2.1 Specification (OpenGL Operation)
-- Section 2.6. 2nd paragraph changed:
"Each vertex is specified with two, three, or four coordinates.
In addition, a current normal, current texture coordinates, current
color, and current vertex weight may be used in processing each
vertex."
-- Section 2.6. New paragraph after the 3rd paragraph:
"A vertex weight is associated with each vertex. When vertex
weighting is enabled, this weight is used as a blending factor
to blend the position and normals transformed by the primary and
secondary modelview matrix transforms. The vertex weighting
functionality takes place completely in the "vertex / normal
transformation" stage of Figure 2.2."
-- Section 2.6.3. First paragraph changed to
"The only GL commands that are allowed within any Begin/End pairs are
the commands for specifying vertex coordinates, vertex colors, normal
coordinates, and texture coordinates (Vertex, Color, VertexWeightEXT,
Index, Normal, TexCoord)..."
-- Section 2.7. New paragraph after the 4th paragraph:
"The current vertex weight is set using
void VertexWeightfEXT(float weight);
void VertexWeightfvEXT(float *weight);
This weight is used when vertex weighting is enabled."
-- Section 2.7. The last paragraph changes from
"... and one floating-point value to store the current color index."
to:
"... one floating-point number to store the vertex weight, and one
floating-point value to store the current color index."
-- Section 2.8. Change 1st paragraph to say:
"The client may specify up to seven arrays: one each to store edge
flags, texture coordinates, colors, color indices, vertex weights,
normals, and vertices. The commands"
Add to functions listed following first paragraph:
void VertexWeightPointerEXT(int size, enum type, sizei stride, void *pointer);
Add to table 2.4 (p. 22):
Command Sizes Types
---------------------- ----- -----
VertexWeightPointerEXT 1 float
Starting with the second paragraph on p. 23, change to add
VERTEX_WEIGHT_ARRAY_EXT:
"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, VERTEX_ARRAY_WEIGHT_EXT, NORMAL_ARRAY, or VERTEX_ARRAY,
for the edge flag, texture coordinate, color, secondary color,
color index, normal, or vertex array, respectively.
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 section 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, secondary color, color index, and normal
arrays are EdgeFlagv, TexCoord<size><type>v, Color<size><type>v,
Index<type>v, VertexWeightfvEXT, and Normal<type>v, respectively..."
Change pseudocode on p. 27 to disable vertex weight array for canned
interleaved array formats. After the lines
DisableClientState(EDGE_FLAG_ARRAY);
DisableClientState(INDEX_ARRAY);
insert the line
DisableClientState(VERTEX_WEIGHT_ARRAY_EXT);
Substitute "seven" for every occurrence of "six" in the final
paragraph on p. 27.
-- Section 2.10. Change the sentence:
"The model-view matrix is applied to these coordinates to yield eye
coordinates."
to:
"The primary modelview matrix is applied to these coordinates to
yield eye coordinates. When vertex weighting is enabled, a secondary
modelview matrix is also applied to the vertex coordinates, the
result of the two modelview transformations are weighted by its
respective vertex weighting factor and combined by addition to yield
the true eye coordinates. Vertex weighting is enabled or disabled
using Enable and Disable (see section 2.10.3) with an argument of
VERTEX_WEIGHTING_EXT."
Change the 4th paragraph to:
"If vertex weighting is disabled and a vertex in object coordinates
is given by ( xo yo zo wo )' and the primary model-view matrix is
M0, then the vertex's eye coordinates are found as
(xe ye ze we)' = M0 (xo yo zo wo)'
If vertex weighting is enabled, then the vertex's eye coordinates
are found as
(xe0 ye0 ze0 we0)' = M0 (xo yo zo wo)'
(xe1 ye1 ze1 we1)' = M1 (xo yo zo wo)'
(xe,ye,ze)' = vw*(xe0,ye0,ze0)' + (1-vw) * (xe1,ye1,ze1)'
we = we0
where M1 is the secondary modelview matrix and vw is the current
vertex weight."
-- Section 2.10.2 Change the 1st paragraph to say:
"The projection matrix and the primary and secondary modelview
matrices are set and modified 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 four pre-defined constants TEXTURE,
MODELVIEW0, MODELVIEW1, or PROJECTION (note that MODELVIEW is an
alias for MODELVIEW0). TEXTURE is described later. If the current
matrix is MODELVIEW0, then matrix operations apply to the primary
modelview matrix; if MODELVIEW1, then matrix operations apply to
the secondary modelview matrix; if PROJECTION, then they apply to
the projection matrix."
Change the 9th paragraph to say:
"There is a stack of matrices for each of the matrix modes. For the
MODELVIEW0 and MODELVIEW1 modes, the stack is at least 32 (that is,
there is a stack of at least 32 modelview matrices). ..."
Change the last paragraph to say:
"The state required to implement transformations consists of a
four-valued integer indicating the current matrix mode, a stack of
at least two 4x4 matrices for each of PROJECTION and TEXTURE with
associated stack pointers, and two stacks of at least 32 4x4 matrices
with an associated stack pointer for MODELVIEW0 and MODELVIEW1.
Initially, there is only one matrix on each stack, and all matrices
are set to the identity. The initial matrix mode is MODELVIEW0."
-- Section 2.10.3 Change the 2nd and 7th paragraphs to say:
"For a modelview matrix M, the normal for this matrix is transformed
to eye coordinates by:
(nx' ny' nz' q') = (nx ny nz q) * M^-1
where, if (x y z w)' are the associated vertex coordinates, then
/ 0, w= 0
|
q = | -(nx ny nz) (x y z)' (2.1)
| --------------------, w != 0
\ w
Implementations may choose instead to transform (x y z)' to eye
coordinates using
(nx' ny' nz') = (nx ny nz) * Mu^-1
Where Mu is the upper leftmost 3x3 matrix taken from M.
Rescale multiplies the transformed normals by a scale factor
( nx" ny" nz" ) = f (nx' ny' nz')
If rescaling is disabled, then f = 1. If rescaling is enabled, then
f is computed as (mij denotes the matrix element in row i and column j
of M^-1, numbering the topmost row of the matrix as row 1 and the leftmost column
as column 1
1
f = ---------------------------
sqrt(m31^2 + m32^2 + m33^2)
Note that if the normals sent to GL were unit length and the model-view
matrix uniformly scales space, the rescale make sthe transformed normals
unit length.
Alternatively, an implementation may chose f as
1
f = ---------------------------
sqrt(nx'^2 + ny'^2 + nz'^2)
recomputing f for each normal. This makes all non-zero length
normals unit length regardless of their input length and the nature
of the modelview matrix.
After rescaling, the final transformed normal used in lighting, nf,
depends on whether vertex weighting is enabled or not.
When vertex weighting is disabled, nf is computed as
nf = m * ( nx"0 ny"0 nz"0 )
where (nx"0 ny"0 nz"0) is the normal transformed as described
above using the primary modelview matrix for M.
If normalization is enabled m=1. Otherwise
1
m = ------------------------------
sqrt(nx"0^2 + ny"0^2 + nz"0^2)
However when vertex weighting is enabled, the normal is transformed
twice as described above, once by the primary modelview matrix and
again by the secondary modelview matrix, weighted using the current
per-vertex weight, and normalized. So nf is computed as
nf = m * ( nx"w ny"w nz"w )
where nw is the weighting normal computed as
nw = vw * ( nx"0 ny"0 nz"0 ) + (1-vw) * (nx"1 ny"1 nz"1)
where (nx"0 ny"0 nz"0) is the normal transformed as described
above using the primary modelview matrix for M, and (nx"1 ny"1 nz"1) is the
normal transformed as described above using the secondary modelview matrix for
M, and vw is the current pver-vertex weight."
-- Section 2.12. Changes the 3rd paragraph:
"The coordinates are treated as if they were specified in a
Vertex command. The x, y, z, and w coordinates are transformed
by the current primary modelview and perspective matrices. These
coordinates, along with current values, are used to generate a
color and texture coordinates just as done for a vertex, except
that vertex weighting is always treated as if it is disabled."
Additions to Chapter 3 of the OpenGL 1.2.1 Specification (Rasterization)
None
Additions to Chapter 4 of the OpenGL 1.2.1 Specification (Per-Fragment Operations
and the Framebuffer)
None
Additions to Chapter 5 of the OpenGL 1.2.1 Specification (Special Functions)
None
Additions to Chapter 6 of the OpenGL 1.2.1 Specification (State and State Requests)
None
Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance)
None
Additions to the AGL/GLX/WGL Specifications
None
GLX Protocol
A new GL rendering command is added. The following command is sent
to the server as part of a glXRender request:
VertexWeightfvEXT
2 8 rendering command length
2 4135 rendering command opcode
4 FLOAT32 weight0
To support vertex arrays, the DrawArrays rendering command (sent via
a glXRender or glXRenderLarge request) is amended as follows:
The list of arrays listed for the third element in the ARRAY_INFO
structure is amended to include:
0x850c j=1 VERTEX_WEIGHT_ARRAY_EXT
The VERTEX_DATA description is amended to include:
If the vertex weight array is enabled:
ws LISTofBYTE vertex weight array element
wp unused, wp=pad(ws)
with the following paragraph amended to read:
"where ns, cs, is, ts, es, vs, ws is the size of the normal, color,
index, texture, edge, vertex, and vertex weight array elements and
np, cp, ip, tp, ep, vp, wp is the padding for the normal, color,
index, texture, edge, vertex, and vertex weight array elements,
respectively."
Errors
The current vertex weight can be updated at any time. In particular
WeightVertexEXT can be called between a call to Begin and the
corresponding call to End.
INVALID_VALUE is generated if VertexWeightPointerEXT parameter <size>
is not 1.
INVALID_ENUM is generated if VertexWeightPointerEXT parameter <type>
is not FLOAT.
INVALID_VALUE is generated if VertexWeightPointerEXT parameter <stride>
is negative.
New State
(table 6.5, p196)
Get Value Type Get Command Initial Value Description Sec Attribute
--------- ---- ----------- ------------- ----------- --- ---------
CURRENT_VERTEX_WEIGHT_EXT F GetFloatv 1 Current 2.8 current
vertex weight
(table 6.6, p197)
Get Value Type Get Command Initial Value Description Sec Attribute
--------- ---- ----------- ------------- ----------- --- ---------
VERTEX_WEIGHT_ARRAY_EXT B IsEnabled False Vertex weight enable 2.8 vertex-array
VERTEX_WEIGHT_ARRAY_SIZE_EXT Z+ GetIntegerv 1 Weights per vertex 2.8 vertex-array
VERTEX_WEIGHT_ARRAY_TYPE_EXT Z1 GetIntegerv FLOAT Type of weights 2.8 vertex-array
VERTEX_WEIGHT_ARRAY_STRIDE_EXT Z GetIntegerv 0 Stride between weights 2.8 vertex-array
VERTEX_WEIGHT_ARRAY_POINTER_EXT Y GetPointerv 0 Pointer to vertex weight array 2.8 vertex-array
(table 6.7, p198)
Get Value Type Get Command Initial Value Description Sec Attribute
--------- ---- ----------- ------------- ----------- ------ ---------
MODELVIEW0_MATRIX_EXT 32*xM4 GetFloatv Identity Primary modelview 2.10.2 -
stack
MODELVIEW1_MATRIX_EXT 32*xM4 GetFloatv Identity Secondary modelview 2.10.2 -
stack
MODELVIEW0_STACK_DEPTH_EXT Z+ GetIntegerv 1 Primary modelview 2.10.2 -
stack depth
MODELVIEW1_STACK_DEPTH_EXT Z+ GetIntegerv 1 Secondary modelview 2.10.2 -
stack depth
MATRIX_MODE Z4 GetIntegerv MODELVIEW0 Current matrix mode 2.10.2 transform
VERTEX_WEIGHTING_EXT B IsEnabled False Vertex weighting 2.10.2 transform/enable
on/off
NOTE: MODELVIEW_MATRIX is an alias for MODELVIEW0_MATRIX_EXT
MODELVIEW_STACK_DEPTH is an alias for MODELVIEW0_STACK_DEPTH_EXT
New Implementation Dependent State
None
Revision History
12/16/2000 amended to include GLX protocol for vertex arrays
5/25/2000 added missing MODELVIEW#_MATRIX_EXT token values
1/3/2003 changed status to "discontinued"
Implementation Support
List of OpenGL implementations supporting the GL_EXT_vertex_weighting extension
Original File
Original text file for the GL_EXT_vertex_weighting extension
Page generated on Sun Nov 20 18:37:50 2005