Name
SGIX_polynomial_ffd
Name Strings
GL_SGIX_polynomial_ffd
Version
$Date: 1996/03/01 22:13:06 $ $Revision: 1.15 $
Number
59
Dependencies
None
Overview
This extension adds the capability to alter vertex coordinates, the
corresponding normal coordinates, and texture coordinates based on a
client-specified trivariate polynomial functions. These functions may be
thought of as a warping of object/texture space (or, alternatively, as a
warping of the object embedded in object/texture space).
Deformations of space are used for a variety of modeling effects, including
character animation. The deformation specified in this extension is one of
a variety of mappings that have been proposed.
Only 3D to 3D deformation are considered. We shall not consider
homogeneous deformations.
Issues
* Mark: Should there also be a 'target' parameter to allow for multiple
(cumulative) deformations in the future? (If yes, we need a new
'get'.)
Ziv: I think we can get away by 'naming' additional deformations as
{GEOMETRY/TEXTURE}_DEFORMATION_XXX_SGIX and still use GetMap.
* Mark: Limited memory may make it problematic to use both high-order
evaluators and deformations at the same time. The available memory could
be traded off between deformations and evaluators (uh-oh --- do I smell an
'evaluator object' extension coming?).
Ziv: The RESOURCE_UNAVAILABLE error mechanism could solves this problem.
Too bad it was reject from 1.1. I am not clear about how we introduce it
into an extension without having another extension.
* Mark: Should deformations of texture, normal, and color coordinates be
included as well.
Ziv: As we already define normal deformations to be derived from the
geometry deformation, independent normal deformations should not be
included. We do need Texture deformation however (e.g., for 3D
textures), as texture and object space are different and are
included. Color, being a non geometric entity does not seem to belong
here.
* Ziv: spec order issue. The natural specification of deformations is in
the Coordinate Transformations section - 2.9. However, deformation use
the description of Bernstein polynomials in evaluator section - 5.1 -
creating an awkward forward reference. In a formal spec the description
of the polynomial would have to move from evaluators to the deformations
sub-section.
New Procedures and Functions
void DeformationMap3{fd}SGIX( enum target,
T u1, T u2, int ustride, int uorder,
T v1, T v2, int vstride, int vorder,
T w1, T w2, int wstride, int worder,
T* points);
void LoadIdentityDeformationMapSGIX( bitfield mask );
void DeformSGIX( bitfield mask );
New Tokens
Accepted by the parameter of DeformationMap3[fd]SGIX, and by the
parameter of GetMap:
GEOMETRY_DEFORMATION_SGIX
TEXTURE_DEFORMATION_SGIX
Accepted by the parameter of DeformSGIX, and
LoadIdentityDeformationMapSGIX:
TEXTURE_DEFORMATION_BIT_SGIX 0x1
GEOMETRY_DEFORMATION_BIT_SGIX 0x2
Accepted by the parameter of GetBooleanv, GetIntegerv,
GetFloatv, and GetDoublev:
DEFORMATIONS_MASK_SGIX
MAX_DEFORMATION_ORDER_SGIX
Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)
Section 2.6.3, "GL Commands within Begin/End", is changed to include
DeformSGIX in the list of commands allowed within Begin/End.
The second paragraph of 2.9, "Coordinate Transformations," is replaced by
(where Figure 2.6 is modified accordingly):
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 enabled geometry deformations (deformations are
described in sub-section XXX, "Deformations") are applied to these
coordinates to yield deformed object coordinates. When no deformations are
enabled it is as if an identity deformation is applied to the object
coordinates. Unless explicitly stated otherwise, in the rest of this
document we will refer to deformed object coordinates as just object
coordinates. The model-view matrix is then applied to the object
coordinates to yield 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.
A new sub-section entitled 'Deformations' is added after section 2.9.1:
Deformations provide a means to use a polynomial mapping to transform
vertex, normal, and texture coordinates. When a deformation is applied to a
4-tuple (c_0,c_1,c_2,c_3) the 3-tuple (c_0,c_1,c2) is transformed by a
trivariate deformation map to another 3-tuple, while the c_3 remains
unchanged. The mapping of normals is not independent of the vertex mapping
but is rather derived from the vertex deformation map.
Let sum_{i=0}^l represent the sum over i from 0 to l.
Consider the R^3-valued function:
p(u,v,w)
= sum_{i=0}^l sum_{j=0}^m sum_{k=0}^n B_i^l(u) B_j^m(v) B_k^n(w) R_ijk
where B_i^j is a Bernstein polynomial as defined in equation 5.1. The R_ijk
are control points (as in equation 5.1); they correspond to the
specified with the DeformationMap3[fd]SGIX command. is one of the
symbolic constants GEOMETRY_DEFORMATION_SGIX or TEXTURE_DEFORMATION_SGIX.
is a pointer to (l+1)(m+1)(n+1) blocks of storage ( = l+1,
= m+1, and = n+1). The error INVALID_VALUE is generated
if any of , , or is less than one, or if their
product is greater than MAX_DEFORMATION_ORDER. The three values comprising
R_ijk are located at
i + j + k
values (either single- or double-precision floating-point, as appropriate)
past the first value pointed to by .
, , , , , and define the pre-image of the
the map; a domain point (u', v', w') is evaluated as
u' - v' - w' -
p'(u',v',w') = p( -----------, -----------, -----------)
- - -
The error INVALID_VALUE is generated if any of , , or
is less than 3, or if is equal to , is equal to
, or if is equal to .
Deformations are enabled and disabled using Deform. The parameter is
a bitwise OR of symbolic constants indicating which deformations are to be
enabled. The symbolic constants GEOMETRY_DEFORMATION_BIT_SGIX and
TEXTURE_DEFORMATION_BIT_SGIX correspond to the geometry and texture
deformations, respectively. When a bit corresponding to a given deformation
is 0, that deformation will be disabled. The error INVALID_VALUE
is generated if the contains bits other than
GEOMETRY_DEFORMATION_BIT_SGIX and TEXTURE_DEFORMATION_BIT_SGIX.
When enabled, geometry deformation maps (currently only one geometry
deformation - GEOMETRY_DEFORMATION_SGIX - is defined) are applied to vertex
coordinates immediately before the application of the model-view matrix.
When a map is applied to a vertex the normal that is associated with that
vertex is transformed as described below. Enabled texture deformation maps
(current only one texture deformation - TEXTURE_DEFORMATION_SGIX is defined)
are applied to texture coordinates immediately prior to the application of
the texture matrix.
Normal coordinates are transformed by each enabled geometry deformation.
The transformation proceeds by first computing the partial Jacobian matrix
J of p' at the point (u', v', w'):
J = ( dp'/du' dp'/dv' dp'/dw' )
(p' is a column of 3 values, so dp'/ds is also).
The transformed normal, n', is found from the untransformed normal,
n = ( nx ny nz ), as
n' = n J^{-1}.
Note, that as deformations are defined to be applied immediately before the
application model-view and texture matrices, they are therefore also applied
to the vertices, normals, and textures resulting from EvalCoord and EvalMesh
commands.
LoadIdentityDeformation provides a quick method for setting
deformations to the identity deformation. The map for the
deformations indicated by the parameter (with the same
interpretation as in Deform) are set to the identity map. The
identity deformation maps are order 2 in each of u, v, and w, with
===0 and ===1, and the control point being
(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1),
(1, 1, 0), and (1, 1, 1).
Note, that unlike Deform, it is not an for the mask to contain
bits other than than GEOMETRY_DEFORMATION_BIT_SGIX and
TEXTURE_DEFORMATION_BIT_SGIX.
The state required for deformations is 2 3-dimensional map specification (as
described by the call to DeformMap[fd]SGIX) and a bit mask indicating
currently enabled deformations. The maximum possible value for
the product of , , and for each deformation type is
implementation dependent but must be at least 1. Initially, all the
deformation maps are the identity map.
Additions to Chapter 3 of the 1.0 Specification (Rasterization)
None
Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations
and the Framebuffer)
None
Additions to Chapter 5 of the 1.0 Specification (Special Functions)
None
Additions to Chapter 6 of the 1.0 Specification (State and State Requests)
None
GLX Protocol
XXX - Not figured out yet.
Dependencies on other extensions
None
Errors
The error INVALID_ENUM is generated if the DeformationMap3[fd]SGIX
parameter is not GEOMETRY_DEFORMATION_SGIX or TEXTURE_DEFORMATION_SGIX.
The error INVALID_VALUE is generated by DeformationMap3[fd]SGIX if:
- any of , , or is less than one, or if their
product is greater than MAX_DEFORMATION_ORDER;
- any of , , or is less than 3;
- is equal to , is equal to , or is equal
to .
The error INVALID_VALUE is generated by DeformSGIX if the
contains bits other than GEOMETRY_DEFORMATION_BIT_SGIX and
TEXTURE_DEFORMATION_BIT_SGIX.
The error INVALID_OPERATION is generated if DeformationMap3[fd]SGIX is
executed between execution of Begin and the corresponding execution of End.
New State
Initial Initial
Get Value Get Command Type Value Attrib
--------- ----------- ---- ------- ------
ORDER GetMap 2 x 3 x Z_1* 1,1,1 -
COEFF GetMap 2 x 1* x 1* x 1* x R3 Sec X(2.9.1+) -
DOMAIN GetMap 2 x 6 x R Sec X(2.9.1+) -
DEFORMATION_MASK GetIntegerv F 0 transform
- F is a new state variable type: a bitfield mask of flags.
New Implementation Dependent State
Minimum
Get Value Get Command Type Value
--------- ----------- ---- -------
MAX_DEFORMATION_ORDER GetInteger Z 2