XXX - not done yet

Name

    SGIX_fragment_lighting_space

Name Strings

    GL_SGIX_fragment_lighting_space

Version

    $Date: 1998/05/12 23:52:07 $ $Revision: 1.14 $

Number

    118

Dependencies

    EXT_fragment_lighting is required.
    EXT_coordinate_frame is required.

Overview

    This extension specifies that the fragment lighting vectors including
    the view vector, light vectors, halfangle vectors and 
    spotlight direction vectors, be transformed into either eye-space, 
    object-space or tangent-space on a per-vertex basis. 
    The default is eye-space. 

    Combined with the ability to take a normal vector from texture memory,
    as specified by the SGIX_light_texture extension, 
    the ability to transform other shading vectors to the same space 
    as the normal vector allows advanced shading effects such as 
    bump mapping to be realized.

    The tangent-space transform uses the per-vertex tangent and binormal
    vector introduced by the EXT_coordinate_frame extension.

Issues

    * A suggestion for a different way to attack this is to introduce the
    concept of a per-vertex matrix which is applied to lighting vectors.
    Coupled with a new matrix-gen function, we could generate the necessary 
    per-vertex matrices.

    * Are we really dependent upon fragment light?

    Theoretically, no, but doing lighting in a space other than 
    eye-space doesn't help one much unless we can do something 
    like get normal vectors from texture.  
    For that reason it doesn't seem to make sense to burden per-vertex
    lighting with this generality.

    * If we are dependent upon fragment light are we not also dependent
    upon SGIX_light_texture? 

    It would seem to make little sense to implement light_space and not
    light texture because the combination of the two of them is what
    makes bump mapping possible. But since there is nothing gained by
    making light_space dependent upon light_texture we won't make it
    dependent upon light_texture

New Procedures and Functions

    FragmentLightSpaceSGIX(enum space);

New Tokens

    Accepted by the <space> parameter of FragmentLightSpaceSGIX:

	EYE_SPACE_SGIX			0x8436
	TANGENT_SPACE_SGIX		0x8437
	OBJECT_SPACE_SGIX		0x8438

    Accepted by the <pname> parameter of GetBooleanv, GetIntegerv,
    GetFloatv, and GetDoublev:

	FRAGMENT_LIGHT_SPACE_SGIX	0x843D

Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)
 
    The fragment_light.spec section 3.9.2 Lighting Operation is amended: 

    If FragmentLightSpaceSGIX specifies 
    EYE_SPACE_SGIX            <default> 
    then calculations are carried out in eye space.

    If FragmentLightSpaceSGIX specifies 
    TANGENT_SPACE_SGIX  
    then calculations are carried out in tangent space  by
    constructing an orthonormal basis from the per-vertex tangent,
    binormal and normal vectors and using that matrix to transform
    eye-space shading vectors into tangent space on a 
    per-vertex basis. The vectors are normalized before being passed
    to the rasterization stage where the fragment lighting calculations 
    are performed.

    The matrix is constructed as follows:

    if NORMALIZE is enabled,
	b = cross(normal,tangent);
	t = cross(b,n);
	t = normalize(t);
	b = normalize(b);
	n = normalize(normal);
    else
	t = tangent
	b = binormal
	n = normal

    the matrix

    M  = ( t - - )
	 ( b - - )
	 ( n - - )

    maps (1,0,0) to t,
         (0,1,0) to b,
         (0,0,1) to n.

    Because it is an orthogonal matrix, its inverse is its transpose:

    Mi = ( t b n )
	 ( | | | )
	 ( | | | )

    and maps t to (1,0,0),
             b to (0,1,0),
             n to (0,0,1), ie, maps vectors to tangent space.

    Any shading vectors required by the fragment lighting rasterization
    stages, which could include the view vector V, light vector VPli, 
    halfangle vector hi and spotlight direction vector, sdli, 
    are first computed in eye space on a per-vertex basis and then 
    transformed by Mi to the tangent space shading vectors, Vts, Ltsi, Htsi, sdltsi.

    if FragmentLightSpaceSGIX specifies 
    OBJECT_SPACE_SGIX  
    then fragment lighting calculations can be carried out in object space 
    by transforming the eye-space shading vectors by the 
    inverse of the current modelview matrix and subsequently normalizing 
    them.

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)

    tables are extended with state values from New State section

Additions to the GLX Specification

    None

GLX Protocol

    XXX - not yet complete

Errors

    INVALID_ENUM is generated if FragmentLightSpaceSGIX parameter
    <space> is not EYE_SPACE_SGIX, OBJECT_SPACE_SGIX, or TANGENT_SPACE_SGIX.

    INVALID_OPERATION is generated if FragmentLightSpaceSGIX is called
    between the execution of Begin and the corresponding execution of End.

New State
    Get Value			Get Command	Type	Initial Value	Attribute
    ---------			-----------	----	-------------	---------
    FRAGMENT_LIGHT_SPACE_SGIX	GetIntegerv	Z3	EYE_SPACE_SGIX	lighting/enable

New Implementation Dependent State

    None

