XXX incomplete (but getting close)

Name

    SGIX_cube_map

Name Strings

    GL_SGIX_cube_map

Version

    $Date: 1998/05/12 23:51:59 $ $Revision: 1.17 $

Number

    130

Dependencies

    OpenGL 1.1 is required.
    EXT_light_texture affects the definition of this extension.

    The enums EYE_SPACE_SGIX and OBJECT_SPACE_SGIX
    are defined in the fragment_light_space spec and
    used here. We aren't dependent upon the spec per-se,
    but we do want those enums. If we had this spec without
    fragment_light_space but with fragment_lighing, we'd
    want to define them as part of this spec.

Overview

    This extension introduces a cube map method for performing
    environment mapping and environment map term to the fragment
    light equation.

Issues

    * What is the best way to enable environment mapping in the fragment
    lighting equation? 
    
    I chose to use 

    ApplyTextureEXT(ENV_MAP_SGIX);
    Enable(CUBE_MAP_SGIX);

    * can cube map environment mapping be used with per-vertex lighting?

    Sure, but it is simply a texture in this case, it is not multiplied
    by the specular material. 
    If SGIX_texture_add_env is supported, the cube map environment 
    term can be added to the color computed in per-vertex lighting.

    Use 
    Enable(CUBE_MAP_SGIX); 
    TexEnvi(TEXTURE_ENV,TEXTURE_ENV_MODE,ADD);

    * do we want a way to transform the Reflection vectors by a matrix somehow?
    Or perhaps we generate the R vector relative to the viewer.

    The idea is if we are simulating thin film reflections or something like
    that we want to use the environment map as a lighting map.

    This is handled easily but clumsily with a call to 
    TexParameteri(CUBE_MAP_SGIX, ENV_MAP_SGIX, EYE_SPACE_SGIX) or
    TexParameteri(CUBE_MAP_SGIX, ENV_MAP_SGIX, OBJECT_SPACE_SGIX)

    the first case fixes the environment to the viewers head (needed by thin
    film or lights fixed with the viewer), the second fixes it in the world
    (classic environment mapping).

    An alternative is to introduce a fragment_environment spec and
    perhaps a call like
    EnvironmentMapSpace({ EYE_SPACE_SGIX  | 
			  OBJECT_SPACE_SGIX })
    This spec could also add the notion of multiplying the
    reflected environment value by the specular material to the
    equation in the fragment lighting spec.

    * Do we explicitly include the environment map term in fragment lighting
    equation or use this extension (or maybe texture or light environment) instead.

    This extension adds an environment mapping term to the fragment lighting equation
    If we made a seperate fragment_environment spec we could add the term
    in that spec.

    * We need to deal with PROXY stuff to determine if all the cube map
    faces will fit.

    * if it says somewhere in the GL specification that whenever 1D and 2D
    textures are enabled (I know it says this in the man page, but I can't
    find it in the spec), 2D wins, we need the same type of language here.
    2D wins over cubemapping if both are enabled and there is only one
    texture resource.

    * If we say that reflection vectors are calculated on a per-fragment basis
    this means that bumpy reflections should be possible since N could come
    from a texture. If we further say that the approximation of interpolating
    an per-vertex-calculated R vector is acceptable, this causes a conflict
    because that effect would kill bumpy reflections.

New Procedures and Functions

New Tokens

    Accepted by the <mode> parameter of ApplyTextureEXT, and
    the <pname> parameter of 
    TexParameterf, TexParameterfv, Texparameteri, and TexParameteriv,
    GetTexParameterfv, GetTexParameteriv:

	ENV_MAP_SGIX		0x8340

    Accepted by the <cap> parameter of Enable, Disable and IsEnabled, 
    the <target> parameter of 
    TexParameterf, TexParameterfv, Texparameteri, and TexParameteriv,
    GetTexParameterfv, GetTexParameteriv,
    BindTextureEXT, 
    accepted by the <pname> parameters of GetBooleanv, GetIntegerv:

	CUBE_MAP_SGIX		0x8341

    Accepted by the <target> parameters of GetTexImage,
    GetTexLevelParameterfv, GetTexLevelParameteriv, 
    TexImage2D, TexSubImage2D, CopyTexImage2D, and CopyTexSubImage2D:

	CUBE_MAP_ZP_SGIX	0x8342
	CUBE_MAP_ZN_SGIX	0x8343
	CUBE_MAP_XN_SGIX	0x8344
	CUBE_MAP_XP_SGIX	0x8345
	CUBE_MAP_YN_SGIX	0x8346
	CUBE_MAP_YP_SGIX	0x8347

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

	CUBE_MAP_BINDING_SGIX	0x8348

Additions to Chapter 2 of the 1.1 Specification (OpenGL Operation)


Additions to Chapter 3 of the 1.1 Specification (Rasterization)

    In section 3.8 we should add text that specifies that each of
    the 6 faces of the cube map should be legal textures 
    based on the filtering mode before cube mapping can be enabled
    If they are not it is as if texturing is disabled.

    Before Section 3.8.1 Texture Minification insert a new section 3.8.1
    Environment Map Address Calculation.

    Environment map address calculation may be used to compute texture coordinates
    in an environment map texture. 
    
    The Reflection vector 'r' is computed on
    a per-fragment basis from interpolated view vector(VPe) and 
    interpolated normal 'n' vectors as

    r = (X,Y,Z) = 2*n*dot(n,VPe) - VPe

    If TexParameter is called with <pname> ENV_MAP_SGIX and
    <param> OBJECT_SPACE_SGIX, the view vector 'VPe' is transformed
    by the inverse of the modelview matrix before 'r' is calculated.
    This is the default behavior. If TexParameter is called with
    <pname> ENV_MAP_SGIX and <param> EYE_SPACE_SGIX, the view vector is
    unchanged before the calculation of the reflection vector.

    The calculation of 'r' may be approximated by computing it on a
    per-vertex basis, transforming by the inverse of the modelview matrix 
    if necessary, optionally normalizing it for numerical purposes 
    and then interpolating it on a per-pixel basis. 
    This will lead to unacceptable distortion effects if r varies greatly on a 
    per-vertex basis and will also prevent the use of reflection vector generation
    from a texture derived normal since the calculation of R occurs before
    the texture stage.

    Cube Map Face Selection

    If the environment map is implemented with a cube map, one of the six faces of
    the cube is selected by the major axis of the reflection vector on a per-pixel
    basis. 

    major axis   X                Y                Z
    -----------------------------------------------------------
    <= 0      CUBE_MAP_XN_SGIX CUBE_MAP_YN_SGIX CUBE_MAP_ZN_SGIX
    > 0       CUBE_MAP_XP_SGIX CUBE_MAP_YP_SGIX CUBE_MAP_ZN_SGIX

    Once the face is selected, the s,t texture coordinates are computed 
    from the (X,Y,Z) coordinates of the reflection vector and replace
    any texture coordinates specified with TexCoord or generated by TexGen as:

    map                 s		t		r	q
    -------------------------------------------------------------
    CUBE_MAP_ZN_SGIX    .5 - .5*X/Z     .5 - .5*Y/Z	0.	1.
    CUBE_MAP_ZP_SGIX    .5 - .5*X/Z     .5 + .5*Y/Z	0.	1.

    CUBE_MAP_XN_SGIX    .5 + .5*Z/X     .5 - .5*Y/X	0.	1.
    CUBE_MAP_XP_SGIX    .5 + .5*Z/X     .5 + .5*Y/X	0.	1.

    CUBE_MAP_YN_SGIX    .5 - .5*X/Y     .5 + .5*Z/Y	0.	1.
    CUBE_MAP_YP_SGIX    .5 + .5*X/Y     .5 + .5*Z/Y	0.	1.

    note to spec editor: (see the figure in file cubemap.sho to visualize the mappings.)

    Level of detail should be computed in a manner that corresponds to
    the specification of level of detail for two-dimensional texturing.

    Note that the chain rule can be applied using the above formulas and
    slope information for X,Y,Z (dX/dx, dY/dx, dZ/dx, dX/dy, dY/dy, dZ/dy) 
    to obtain ds/dx, ds/dy, dt/dx, dt/dy.

    e.g.  ds/dx = dX/dx*ds/dX + dY/dx*ds/dY + dZ/dx*ds/dZ 

    We add an enviroment map term to the equation in section 3.9.2 from the
    fragment_lighting spec:

    The desired general equation for the fragment illumination model is:

    Cl =  Em 			emissive
       + Am*As			ambient material*scene ambient color
       SUM{_i = 0 through Nf-1} {
       + Atten_i*SpotL_i*{	distance/spot light attenuation
	    + Am*Al_i		ambient material*ambient light
	    + Dm*Dl_i*(N.L_i)	diffuse material*diffuse light
	    + Sm*Sl_i*(N.H_i)^n	specular material*specular light
	  }
	}
	+Sm*Ev
    
	Nf is the number of fragment light sources
	N is the fragment normal vector 
	L_i is the direction vector from the fragment position to the light source
	H_i is the half angle vector
	n is the specular exponent (shininess)
	Ev is the environment map value.

    Ev is defined to be 0 unless 
    ApplyTextureEXT(ENV_MAP_SGIX) has been called in conjunction
    with an enabled texture in which case the value is
    the value determined from the cube map access as specified above.

Additions to Chapter 4 of the 1.1 Specification (Per-Fragment Operations
and the Framebuffer)

    None

Additions to Chapter 5 of the 1.1 Specification (Special Functions)

    None

Additions to Chapter 6 of the 1.1 Specification (State and State Requests)

    Although many of the parameter values of a set of cube map textures have no
    effect on texture operation, they are maintained and may be queried.
    There is no value associated with the binding points
    CUBE_MAP_ZP_2D_SGIX, 
    CUBE_MAP_ZN_2D_SGIX, 
    CUBE_MAP_XN_2D_SGIX, 
    CUBE_MAP_XP_2D_SGIX, 
    CUBE_MAP_YN_2D_SGIX, 
    CUBE_MAP_YP_2D_SGIX, 
    so they are not accepted as the <pname> parameter
    of GetBooleanv, GetIntegerv, GetFloatv, or GetDoublev.  The name of
    the set of cube map textures that are bound to the above binding posts are queried
    by calling GetBooleanv, GetIntegerv, GetFloatv, or GetDoublev with
    <pname> set to CUBE_MAP_BINDING_SGIX.
    Zero is returned if no texture has been bound.

Additions to the GLX Specification

    None

Dependencies on EXT_light_texture

    If EXT_light_texture is not supported, then references to
    ApplyTextureEXT() are to be ignored.

Errors

    INVALID_VALUE is generated if BindTextureEXT parameter <target> is
    one of CUBE_MAP_SGIX
    and parameter <texture> is not the name of a
    cube map texture, the name of an as yet unbound texture, or zero.

    * more of these *

New State

    Get Value			Get Command		Type	Initial Value		Attribute
    ---------			-----------		----	-------------		---------
    CUBE_MAP_BINDING_SGIX	GetIntegerv		Z+	0			texture
    ENV_MAP_SGIX		GetTexParameteriv	Z2	OBJECT_SPACE_SGIX	texture
    CUBE_MAP                    IsEnabled               XXX?

    
    CUBE_MAP_ZP_2D_SGIX etc XXX (how do we specify this?)

New Implementation Dependent State

    None