Name SGIX_sprite Name Strings GL_SGIX_sprite Version $Date: 1996/04/09 22:54:47 $ $Revision: 1.11 $ Number 52 Dependencies None Overview This extension provides support for viewpoint dependent alignment of geometry, in particular geometry that rotates about a point or a specified axis to face the eye point. The primary use is for quickly rendering roughly cylindrically or spherically symmetric objects, e.g. trees, smoke, clouds, etc. using geometry textured with a partially transparent texture map. Rendering sprite geometry requires applying a transformation to primitives before the current model view. This matrix includes a rotation which is computed based on the current model view matrix and a translation which is specified explicitly (SPRITE_TRANSLATION_SGIX). The current model view matrix itself is not modified. Primitives are first transformed by a rotation, depending on the sprite mode: SPRITE_AXIAL_SGIX: The front of the object is rotated about an axis so that it faces the eye as much as the axis constraint allows. This is used for roughly rendering cylindrical objects such as trees in visual simulation. SPRITE_OBJECT_ALIGNED_SGIX: The front of the object is rotated about a point to face the eye with the remaining rotational degree of freedom specified by aligning the top of the object with a specified axis in object coordinates. This is used for spherical objects and special effects such as smoke which must maintain an alignment in object coordinates for realism. SPRITE_EYE_ALIGNED_SGIX: The front of the object is rotated about a point to face the eye with the remaining rotational degree of freedom specified by aligning the top of the object with a specified axis in eye coordinates. This is used for rendering sprites which must maintain an alignment on the screen, such as 3D annotations. The axis of rotation or alignment, SPRITE_AXIS_SGIX, can be an arbitrary direction to support geocentric coordinate frames in which "up" is not along X, Y or Z. Sprite geometry is modeled in a canonical frame: +Z is the up vector. -Y is the front vector which is rotated to point towards the eye. In the discussion below, the eye vector is the vector to the eye from the origin of the model view frame translated by the sprite position. New Procedures and Functions void SpriteParameteriSGIX(enum pname, int param); void SpriteParameterfSGIX(enum pname, float param); void SpriteParameterivSGIX(enum pname, int* params); void SpriteParameterfvSGIX(enum pname, float* params); Issues * Should the canonical modeling frame of the geometry be specifiable? - requires API for "up" and "front" vectors; additional math * Should sprites for annotation be clip or eye aligned? Clip alignment is a nearly trivial extension of object aligned. However, once the projection matrix assumes rotation things are unpredictable and we should avoid this complexity. New Tokens Accepted by the parameter of Enable, Disable, and IsEnabled, and by the parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev: SPRITE_SGIX Accepted by the parameter of SpriteParameteriSGIX, and SpriteParameterfSGIX: SPRITE_MODE_SGIX Accepted by the parameter of SpriteParameterivSGIX, and SpriteParameterfvSGIX, and by the parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev: SPRITE_MODE_SGIX SPRITE_AXIS_SGIX SPRITE_TRANSLATION_SGIX Accepted by the parameter of SpriteParameteriSGIX and and SpriteParameterfSGIX, and by the parameter of SpriteParameterivSGIX and SpriteParameterfvSGIX, when the parameter is SPRITE_MODE_SGIX: SPRITE_AXIAL_SGIX SPRITE_OBJECT_ALIGNED_SGIX SPRITE_EYE_ALIGNED_SGIX Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation) SPRITE_SGIX is enabled and disabled using Enable and Disable with target equal to SPRITE_SGIX. When SPRITE_SGIX is enabled, the current sprite mode, axis, translation and the ModelView matrix are used to generate a sprite transformation which is applied to subsequent primitives before applying the current model view matrix. When the sprite mode is SPRITE_AXIAL_SGIX, the sprite transformation is arranged such that, after sprite and ModelView transformation, the front vector is pointing as nearly towards the origin of the eye coordinate system as possible. Each primitive is first rotated so that the sprite up vector aligns with the sprite axis which is specified in the current model view frame. Then the primitive is rotated about the axis so its front vector is parallel with the projection of the eye vector into the plane perpendicular to the rotation axis. Then the primitive is translated by the specified translation. There are four unique matrices involved in computing the transformation required for sprite geometry: M - model-view matrix T - sprite translation matrix A - sprite axis rotation matrix R - sprite up vector/axis alignment rotation matrix Note that in SPRITE_AXIAL_SGIX mode, the R matrix is a function of M, T and A since the eye vector is derived from the inverse transpose matrix of the compound (M * T * A). In both the SPRITE_OBJECT_ALIGNED_SGIX and the SPRITE_EYE_ALIGNED_SGIX modes, the eye vector is extracted from the inverse transpose of the compound (M * T). Given the coordinates of SPRITE_TRANSLATION_SGIX the sprite translation matrix (T) is constructed. Both A and R are rotation matrices generated by computing an angle of rotation and the sprite axis (computing sine and cosine of the rotation angle suffices for computing a rotation matrix). The computation of the matrices (T, A, R) are given in Chapter 2.9 of the 1.0 OpenGL Specification (Matrices). The angle and axis of rotation parameters for generating rotation matrix A are computed as follows: cosTheta = (V0 (dot) V1); rotAxis = (V0 (cross) V1); sinTheta = |rotAxis|; V0 is the canonical up vector. V1 is the sprite axis (SPRITE_AXIS_SGIX) when in SPRITE_AXIAL_SGIX mode. In either the SPRITE_OBJECT_ALIGNED_SGIX and the SPRITE_EYE_ALIGNED_SGIX modes V1 is the sprite axis aligned by removing its component along the eye vector. The computation of V1 in the latter cases is as follows: scalar = Eye (dot) spriteAxis; alignedSpriteAxis = spriteAxis - (scalar * Eye); The rotation axis for computing the R matrix is the canonical up vector. The angle of rotation is computed as follows: cosTheta = (Eye (dot) canonicalFront); sinTheta = (Eye (dot) canonicalRight); Sprite primitive geometry is transformed from object coordinates to eye coordinates by the following compound matrix (MM): MM = M * T * A * R Sprite geometry is not limited to vertex based primitives and evaluators may apply as well. Normals associated with sprite geometry are transformed by the inverse transpose of the compound matrix (MM). In general, the user would not want clip planes to be transformed by the compound matrix. In a similar manner, raster position and texture coordinates (for certain texgen modes). The user should be warrant that once glClipPlanes, glTexGen or glRasterPos are called within a glEnable/Disable (SPRITE_SGIX) delimitors, the associated geometry will be transformed by the compound matrix (MM). When the sprite mode is SPRITE_OBJECT_ALIGN or SPRITE_EYE_ALIGN, the sprite transformation rotates the front vector towards the eye while keeping the up vector as aligned as possible with the current sprite axis, i.e. the up vector is rotated to be parallel to the projection of the current sprite axis into the plane perpendicular to the front vector. Depending on the current sprite mode, the sprite axis is taken to be expressed in object (SPRITE_OBJECT_ALIGNED_SGIX) or transformed into eye (SPRITE_EYE_ALIGNED_SGIX) coordinates. The transformation into eye space uses the compound (M * T). Regardless of the sprite transformation mode, the projection matrix obviously assumes no rotation elements. This is again to warrant the user against overriding the sprite transformation. 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 Frame Buffer) 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 Additions to the GLX Specification None Dependencies on SGI_extension_name None Errors INVALID_ENUM is generated if SpriteParameteriSGIX or SpriteParameterfSGIX parameter is not SPRITE_MODE_SGIX. INVALID_ENUM is generated if SpriteParameterivSGIX or SpriteParameterfvSGIX parameter is not SPRITE_AXIS_SGIX or SPRITE_TRANSLATION_SGIX. INVALID_ENUM is generated if SpriteParameteriSGIX or SpriteParameterfSGIX parameter is SPRITE_MODE_SGIX, and parameter is not SPRITE_AXIAL_SGIX, SPRITE_OBJECT_ALIGNED_SGIX, or SPRITE_EYE_ALIGNED_SGIX. INVALID_OPERATION is generated if glSpriteParameterSGIX is executed between the execution of glBegin and the corresponding execution of glEnd. New State Initial Get Value Get Command Type Value Attrib --------- ----------- ---- ------- ------ SPRITE_SGIX IsEnabled B FALSE transform/enable SPRITE_MODE_SGIX GetIntegerv I SPRITE_AXIAL_SGIX transform SPRITE_AXIS_SGIX GetFloatv V (0,0,1) transform SPRITE_TRANSLATION_SGIX GetFloatv V (0,0,0) transform New Implementation Dependent State None