| XXX - Dead -- couldn't convince the ARB. Use fragment_lighting & |
| XXX separate_specular_color instead. |
| XXX - Not complete yet!!! |
| |
| Name |
| |
| SGIX_fragment_specular_lighting |
| |
| Name Strings |
| |
| GL_SGIX_fragment_specular_lighting |
| |
| Version |
| |
| $Date: 1998/07/06 19:51:38 $ $Revision: 1.2 $ |
| |
| Number |
| |
| ?? |
| |
| Dependencies |
| |
| OpenGL 1.1 is required. |
| SGIX_color_range affects the definition of this extension. |
| |
| Overview |
| |
| This extension adds a new lighting stage to the OpenGL pipeline. This |
| stage occurs during fragment processing after the texture environment |
| has been applied and before fog has been applied. The extension |
| provides a mechanism for computing a post-texture specular lighting term. |
| This extension doesn't eliminate the specular term in vertex lighting, but |
| can be used to augment it. This extension provides the state framework for a |
| more general lighting model, but only includes the equation for computing |
| the specular contribution. The more general version is described in |
| SGIX_fragment_lighting. |
| |
| |
| |
| Ct Cf |
| | |-------------------------------+ |
| | | | |
| ---------- | |
| | | | |
| | TexEnv | | |
| | | | |
| ---------- | |
| | | |
| ---------- | |
| | Clamp | Nf Lf Hf Ff | |
| ---------- | | | | | |
| | ----------------- | FragmentColorMaterial |
| | | | v |
| Cf' | FragmentLight |--o-<- Material {Sm,...} |
| | | | |
| | ----------------- |
| | | |
| | --------- |
| | | Clamp | |
| | --------- |
| | Cl | |
| | +---------------- |
| v v |
| ------------ |
| | | |
| | SUM | |
| | | |
| ------------ |
| | |
| --------- |
| | Clamp | |
| --------- |
| | |
| Cf'' |
| | |
| v |
| ------- |
| | | |
| | Fog | |
| | | |
| ------- |
| | |
| v |
| |
| IP Status |
| |
| Silicon Graphics has filed for patent protection for some of the |
| techniques described in this extension document. |
| |
| Issues |
| |
| * does this spec enable a reasonable evolution from a post-texture |
| specular highlight to a full blown per-pixel lighting computation? |
| |
| * can we eliminate some commands and state now and allow the generality |
| to show up later? It doesn't seem like there is much harm in maintaining |
| extra state for computations that isn't actually used since it can be |
| maintained on the host. We eliminate the Lighting environment term |
| since it provides extra capability for how the lighting term is combined. |
| It can show up with the fragment_lighting extension. |
| |
| * given the relaxation in the requirements for how the specular term is |
| computed, it is possible to support multiple specular lights but much |
| less likely to be able to support the same number of full blown fragment |
| lights. |
| |
| |
| New Procedures and Functions |
| |
| void FragmentLightModeliSGIX(enum pname, int param); |
| void FragmentLightModelfSGIX(enum pname, float param); |
| void FragmentLightModelivSGIX(enum pname, int *params); |
| void FragmentLightModelfvSGIX(enum pname, float *params); |
| |
| void FragmentLightiSGIX(enum light, enum pname, int param); |
| void FragmentLightfSGIX(enum light, enum pname, float param); |
| void FragmentLightivSGIX(enum light, enum pname, int *params); |
| void FragmentLightfvSGIX(enum light, enum pname, float *params); |
| |
| void GetFragmentLightivSGIX(enum light, enum value, int *data); |
| void GetFragmentLightfvSGIX(enum light, enum value, float *data); |
| |
| void FragmentMaterialfSGIX(enum face, enum pname, const float param); |
| void FragmentMaterialiSGIX(enum face, enum pname, const int param); |
| void FragmentMaterialfvSGIX(enum face, enum pname, const float *params); |
| void FragmentMaterialivSGIX(enum face, enum pname, const int *params); |
| |
| void FragmentColorMaterialSGIX(enum face, enum mode); |
| |
| void GetFragmentMaterialfvSGIX(enum face, enum pname, float *data); |
| void GetFragmentMaterialivSGIX(enum face, enum pname, int *data); |
| |
| New Tokens |
| |
| Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, by |
| the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and |
| GetDoublev: |
| |
| FRAGMENT_LIGHTING_SGIX XXXX |
| FRAGMENT_COLOR_MATERIAL_SGIX XXXX |
| FRAGMENT_COLOR_MATERIAL_FACE_SGIX XXXX |
| FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX XXXX |
| |
| Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, |
| and GetDoublev: |
| |
| MAX_FRAGMENT_LIGHTS_SGIX XXXX |
| MAX_ACTIVE_LIGHTS_SGIX XXXX |
| CURRENT_RASTER_NORMAL_SGIX XXXX |
| |
| Accepted by the <light> parameter of FragmentLightfSGIX, |
| FragmentLightiSGIX, FragmentLightfvSGIX, and FragmentLightivSGIX, and by |
| the <cap> parameter of Enable, Disable, and IsEnabled, and by the <light> |
| parameter of GetFragmentLightfvSGIX and GetFragmentLightivSGIX: |
| |
| FRAGMENT_LIGHT0_SGIX XXXX |
| . |
| . |
| . |
| FRAGMENT_LIGHT7_SGIX XXXX |
| |
| Accepted by the <pname> parameter of FragmentLightModeliSGIX, |
| FragmentLightModelfSGIX, FragmentLightModelivSGIX, |
| FragmentLightModelfvSGIX, GetBooleanv, GetIntegerv, GetFloatv, and |
| GetDoublev: |
| |
| FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX XXXX |
| FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX XXXX |
| FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX XXXX |
| FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX XXXX |
| |
| Additions to Chapter 2 of the 1.1 Specification (OpenGL Operation) |
| |
| Section 2.12 Current Raster Position |
| |
| ... <paragraph 2> |
| The current raster position consists of three window coordinates xw, yw, |
| and zw, a clip corrdinate wc value, an eye coordinate distance, a valid |
| bit, and associated data consisting of a color, normal, and texture |
| coordinates. It is set ... |
| |
| ... <paragraph 5> |
| The current raster position requires five single-precision floating point |
| values for its xw, yw, and zw window coordinates, its wc clip coordinate, |
| and its eye coordinate distance, a single valid bit, a color (RGBA and color |
| index), normal, and texture coordinates for associated data. In the initial |
| state, the coordinates and texture coordinates are both (0,0,0,1), the eye |
| coordinate distance is 0, the valid bit is set, the associated RGBA color is |
| (1,1,1,1), the associated color index is 1, and the associated normal is |
| (0,0,1). In RGBA mode, the associated color index always has its initial |
| value; in color index mode, the RGBA color always maintains its initial |
| value. |
| |
| Section 2.13 Colors and Coloring |
| |
| ... |
| Next vertex lighting, if enabled produces a color. If vertex lighting is |
| disabled, the current color is used in further processing. After vertex |
| lighting, RGBA colors are clamped to the range [0,1]. A color index is |
| converted to fixed-point and then its integer portion is masked (see |
| section 2.13.16). After clamping or masking, a primitive may be flatshaded, |
| indicating that all vertices of the primitive are to have the same color |
| (and normal). Finally, a primitive is clipped, then colors (texture |
| coordinates and normals) must be computed at the vertices introduced or |
| modified by clipping. |
| |
| Additions to Chapter 3 of the 1.1 Specification (Rasterization) |
| |
| Section 3.6.3 Rasterization of Pixel Rectangles |
| |
| Conversion to Fragments |
| |
| ... <paragraph 2> |
| A fragment arising from a group consisting of color data takes on the color |
| index or color components of the group; the depth, normal and texture |
| coordinates are taken from the current raster position's associated data. |
| A fragment arising from a depth component takes the component's depth |
| value; the color, normal, and texture coordinate are given by those associated |
| with the current raster position. In both cases texture coordinates s, t, |
| and r are preplaced with s/q, t/q, and r/q, respectively. If q is less than |
| or equal to zero the results are undefined. Groups arising from DrawPixels |
| with a <format> of STENCIL_INDEX are treated specially and are described in |
| section 4.3.1. |
| |
| |
| Before Section 3.9 Fog insert: |
| |
| Section 3.9 Fragment Lighting |
| |
| If enabled, fragment lighting computes a color for each rasterized fragment |
| by applying an equation defined by a client-specified lighting model to |
| a collection of parameters that can include the fragment coordinates, the |
| coordinates of one or more light sources, the fragment normal, and |
| parameters defining the characteristics of the light source and current |
| fragment material. Fragment lighting is only defined for RGBA mode, it |
| has no effect in color index mode. |
| |
| Fragment lighting may be in one of two states: |
| |
| 1. Lighting Off. In this state the color assigned to a fragment is the |
| rasterized fragment's post-texturing color. |
| |
| 2. Lighting On. In this state the color assigned to a fragment is the |
| result of summing the rasterized fragment's post-texturing color and |
| a color computed from the current fragment lighting parameters. |
| |
| Fragment lighting is turned either on or off using the generic Enable or |
| Disable commands with the symbolic value FRAGMENT_LIGHTING_SGIX. |
| |
| 3.9.2 Lighting Operation |
| |
| 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 |
| } |
| } |
| |
| 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) |
| |
| Subset the equation to the specular term: |
| |
| I[i] = Sm*Sl*(N.H_i)^n) |
| |
| and |
| |
| I' = SUM{i = 0 through Nf-1} I[i] (3.1) |
| |
| |
| Equation (3.1) is essentially the same as the specular term of the vertex |
| lighting equation described in section 2.13.1 for a single light source. |
| |
| In order to compute the illumination terms for each fragment, the eye |
| coordinates of the fragment can be used to compute the light direction, |
| half angle vector, and attenuation factor in a manner similar to that used |
| in the vertex lighting computations. It is permissible for an |
| implementation to approximate these by computing these values as well as |
| the normal vector at the vertices and interpolating and renormalizing the |
| results, or by computing the entire equation at the vertices and |
| interpolating the color. |
| |
| Fragment material state is maintained which is distinct from the |
| vertex material state. The fragment material state consists of |
| emission, ambient, diffuse, specular and shininess terms for both |
| the front and back face of a primitive though only the specular and |
| shininess terms are used by this extension. Unlike vertex lighting, the |
| fragment material state is constant across a primitive since |
| it is resolved during rasterization. The results of the back face |
| computation described in section 3.5.1 are used to determine whether |
| the front material or back material is used when two sided lighting |
| is enabled. |
| |
| There is separate state for each fragment light source. The |
| fragment light source parameters are the same as the vertex light |
| source parameters described in section 2.13.1. The minimum number of |
| fragment light sources is 1. The number of available fragment light |
| sources can be queried by issuing the Get command with the <pname> |
| parameter set to MAX_FRAGMENT_LIGHTS_SGIX. |
| |
| Distinct lighting model state is also maintained for vertex lighting and |
| fragment lighting. The lighting model state is described in section |
| 2.13.1. Fragment lighting model state includes one additional parameter, |
| FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX, which controls how normals |
| are selected for use in the fragment lighting computations for a primitive. |
| If FLAT is selected for the lighting model, the normal from the provoking |
| vertex (as described in Section 2.13.7 Flatshading) of the primitive for all |
| fragment lighting computations for the primitive. If SMOOTH is specified |
| a normal is computed for each fragment using the normals from all of the |
| vertices of the primitive. |
| |
| Fragment lighting differs from vertex lighting in that all components |
| of lighting parameters which are of type color in Table 2.7 are clamped |
| to the range [0,1] when they are specified. |
| |
| Equation 3.2 is evaluated for each light source and the resulting |
| colors are summed. The resulting color components are clamped to the |
| range [0,1] and then passed to the lighting environment computation. |
| |
| |
| 3.9.3 Lighting Parameter Specification |
| |
| GetFragmentMaterialfvSGIX and GetFragmentMaterialivSGIX. |
| The fragment material state can be set with the commands |
| FragmentMaterialfSGIX, FragmentMaterialfvSGIX, FragmentMaterialiSGIX, |
| FragmentMaterialivSGIX using the values AMBIENT, DIFFUSE, SPECULAR, |
| SHININESS and EMISSION. This state can be queried using the commands |
| GetFragmentMaterialfvSGIX and GetFragmentMaterialivSGIX. |
| |
| Lighting parameters for fragment light i can be modified by issuing the |
| commands FragmentLightfSGIX, FragmentLightiSGIX, FragmentLightfvSGIX, and |
| FragmentLightivSGIX with the <light> parameter |
| set to FRAGMENT_LIGHTi_SGIX. The lighting parameters for fragment light i |
| can be queried by issuing the commands GetFragmentLightfvSGIX and |
| GetFragmentLightivSGIX with the <light> parameter set to FRAGMENT_LIGHTi_SGIX. |
| |
| Lighting model parameters for fragment lighting can be modified using the |
| commands FragmentLightModel{T}SGIX, FragmentLightModel{T}vSGIX. The |
| lighting model parameters can be queried by issuing the Get command <pname> |
| parameter set to the appropriate fragment lighting model parameter: |
| FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX, FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX, |
| FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX or FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX. |
| |
| |
| 3.9.4 FragmentColorMaterial |
| |
| It is possible to replace one or more fragment material properties terms in |
| Equation 3.1 with the fragment's pre-texturing color, causing these color |
| values to be used during the lighting computation. This behavior is enabled |
| and disabled by calling Enable and Disable with the symbolic value |
| FRAGMENT_COLOR_MATERIAL. |
| |
| The command that controls which of these modes is selected is |
| |
| void FragmentColorMaterial(enum face, enum mode); |
| |
| <face> is one of FRONT, BACK, or FRONT_AND_BACK, indicating whether |
| the front material, back material, or both are affected by the |
| pre-texturing color. <mode> is one of EMISSION, AMBIENT, DIFFUSE, |
| SPECULAR, or AMBIENT_AND_DIFFUSE and specifies which material property |
| or properties are subsituted with the pre-texturing color. The substutions |
| do not affect the material state. When FragmentColorMaterial |
| is disabled the values in the fragment material state are used. |
| GetFragmentMaterial returns the fragment material last specified with |
| FragmentMaterial, regardless of whether FragmentColorMaterial is enabled. |
| Although all of the fragment material parameters may be substituted, only |
| substituting the SPECULAR material property will affect the result of |
| the lighting computation. |
| |
| 3.9.5 Interactions with Vertex Lighting |
| |
| In order to allow implementions to share resources for vertex lighting and |
| fragment lighting, an implementation may limit the maximum number of combined |
| vertex and fragment lights to a number less than the sum of MAX_LIGHTS and |
| MAX_FRAGMENT_LIGHTS_SGIX. This limit can be queried using the Get command |
| with <pname> parameter MAX_ACTIVE_LIGHTS_SGIX. State for all |
| fragment and vertex lights is always maintained. When multiple |
| lights are enabled, priority is given to vertex lights starting with |
| LIGHT0 through LIGHT<n> where <n> is equal to MAX_LIGHTS, followed by |
| FRAGMENT_LIGHT0_SGIX through FRAGMENT_LIGHT<m>_SGIX where <m> is equal |
| to MAX_FRAGMENT_LIGHTS_SGIX. |
| |
| |
| Additions to Chapter 4 of the 1.1 Specification (Per-Fragment Operations |
| and the Frame Buffer) |
| |
| 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) |
| |
| TBD |
| |
| Additions to the GLX Specification |
| |
| TBD |
| |
| Dependencies on SGIX_color_range |
| |
| If SGIX_color_range is implemented, then the components of lighting |
| parameters of type color, the result of evaluating the lighting |
| equation and the results of evaluating the lighting environment |
| are clamped to the extended color range rather than [0,1]. |
| |
| |
| Errors |
| INVALID_ENUM is generated if FragmentMaterial{T}SGIX, |
| FragmentMaterial{T}vSGIX, or FragmentColorMaterialSGIX, parameter <face> is |
| not FRONT, BACK or FRONT_AND_BACK. |
| |
| INVALID_ENUM is generated if FragmentMaterial{T}SGIX or |
| FragmentMaterial{T}vSGIX parameter <pname> is not AMBIENT, DIFFUSE, |
| SPECULAR, EMISSION, SHININESS, or AMBIENT_AND_DIFFUSE. |
| |
| INVALID_ENUM is generated if GetFragmentMaterial{T}vSGIX parameter <face> |
| is not FRONT or BACK. |
| |
| INVALID_ENUM is generated if GetFragmentMaterial{T}vSGIX parameter <pname> |
| is not AMBIENT, DIFFUSE, SPECULAR, EMISSION, or SHININESS, |
| |
| INVALID_ENUM if FragmentColorMaterialSGIX parameter <mode> is not EMISSION, |
| AMBIENT, DIFFUSE, SPECULAR, or AMBIENT_AND_DIFFUSE |
| |
| INVALID_ENUM if LightEnviSGIX parameter <pname> is not LIGHT_ENV_MODE_SGIX |
| or if parameter <mode> is not REPLACE, MODULATE, or ADD. |
| |
| INVALID_ENUM is generated if FragmentLightModel{T}SGIX <pname> is not |
| FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX, FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX |
| or FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX or if |
| FragmentLightModel{T}vSGIX, parameter <pname> is not |
| FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX, FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX |
| FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX or |
| FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX. |
| |
| INVALID_ENUM is generated if FragmentLight{T}SGIX, FragmentLight{T}vSGIX, |
| or GetFragmentLight{T}vSGIX parameter <light> is not FRAGMENT_LIGHT0_SGIX |
| ... FRAGMENT_LIGHT<n>_SGIX where n is one minus the number of supported |
| fragment lights, or if FragmentLight{T}SGIX parameter <pname> is not |
| SPOT_EXPONENT, SPOT_CUTOFF, CONSTANT_ATTENUATION, LINEAR_ATTENUATION, or |
| QUADRATIC_ATTENUATION, or if FragmentLight{T}vSGIX or |
| GetFragmentLight{T}vSGIX parameter <pname> is not AMBIENT, DIFFUSE, |
| SPECULAR, POSITION, SPOT_DIRECTION, SPOT_EXPONENT, SPOT_CUTOFF, |
| CONSTANT_ATTENUATION, LINEAR_ATTENUATION, or QUADRATIC_ATTENUATION. |
| |
| INVALID_VALUE is generated if FragmentLight{T}SGIX or FragmentLight{T}vSGIX |
| parameter <param> if a spot exponent value is specified outside the range |
| [0,128], or if spot cutoff is specified outside the range [0,90] (except |
| for the special value 180), or if a negative attenuation factor is |
| specified. |
| |
| INVALID_OPERATION is generated if FragmentMaterial{T}SGIX, |
| FragmentMaterial{T}vSGIX, FragmentColorMaterialSGIX, |
| GetFragmentMaterial{T}vSGIX, LightEnviSGIX, FragmentLight{T}SGIX, |
| FragmentLight{T}vSGIX, FragmentLightModel{T}SGIX, |
| FragmentLightModel{T}vSGIX or GetFragmentLight{T}vSGIX is executed between |
| execution of Begin and the corresponding execution of End. |
| |
| New State |
| |
| Get Value Get Command Type Initial Value Attribute |
| --------- ----------- ---- ------------- --------- |
| |
| FRAGMENT_LIGHTING_SGIX IsEnabled B False lighting/enable |
| FRAGMENT_COLOR_MATERIAL_SGIX IsEnabled B False lighting/enable |
| FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX GetIntegerv Z5 AMBIENT_AND_DIFFUSE lighting |
| FRAGMENT_COLOR_MATERIAL_FACE_SGIX GetIntegerv Z3 FRONT_AND_BACK lighting |
| AMBIENT GetFragmentMaterialfvSGIX 2xC (0.2,0.2,0.2,1.0) lighting |
| DIFFUSE GetFragmentMaterialfvSGIX 2xC (0.8,0.8,0.8,1.0) lighting |
| SPECULAR GetFragmentMaterialfvSGIX 2xC (0.0,0.0,0.0,1.0) lighting |
| EMISSION GetFragmentMaterialfvSGIX 2xC (0.0,0.0,0.0,1.0) lighting |
| SHININESS GetFragmentMaterialfvSGIX 2xR 0.0 lighting |
| FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX GetFloatv C (0.2,0.2,0.2,0.2) lighting |
| FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX GetBooleanv B False lighting |
| FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX GetBooleanv B False lighting |
| FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX GetIntegerv Z2 SMOOTH lighting |
| AMBIENT GetFragmentLightfvSGIX 1*xC (0.0,0.0,0.0,1.0) lighting |
| DIFFUSE GetFragmentLightfvSGIX 1*xC see 3.x lighting |
| SPECULAR GetFragmentLightfvSGIX 1*xC see 3.x lighting |
| POSITION GetFragmentLightfvSGIX 1*xP (0.0,0.0,1.0,0.0) lighting |
| CONSTANT_ATTENUATION GetFragmentLightfvSGIX 1*xR 1.0 lighting |
| LINEAR_ATTENUATION GetFragmentLightfvSGIX 1*xR+ 0.0 lighting |
| QUADRATIC_ATTENUATION GetFragmentLightfvSGIX 1*xR+ 0.0 lighting |
| SPOT_DIRECTION GetFragmentLightfvSGIX 1*xD (0.0,0.0,-1.0) lighting |
| SPOT_EXPONENT GetFragmentLightfvSGIX 1*xR+ 0.0 lighting |
| SPOT_CUTOFF GetFragmentLightfvSGIX 1*xR+ 180.0 lighting |
| FRAGMENT_LIGHTi_SGIX IsEnabled 1*xB False lighting/enable |
| LIGHT_ENV_MODE_SGIX GetIntegerv Z3 REPLACE lighting |
| |
| CURRENT_RASTER_NORMAL_SGIX GetFloatv N (0,0,1) current |
| |
| New Implementation Dependent State |
| |
| Get Value Get Command Type Minimum Value |
| --------- ----------- ---- ------------- |
| MAX_FRAGMENT_LIGHTS_SGIX GetIntegerv Z+ 1 |
| MAX_ACTIVE_LIGHTS_SGIX GetIntegerv z+ MAX_LIGHTS |