| INCOMPLETE - DO NOT RELEASE IMPLEMENTATIONS OF THIS EXTENSION |
| |
| Name |
| |
| EXT_fragment_lighting |
| |
| Name Strings |
| |
| GL_EXT_fragment_lighting |
| |
| Version |
| |
| $Date: 1998/09/26 02:49:31 $ $Revision: 1.26 $ |
| |
| Number |
| |
| 102 |
| |
| 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 'per-pixel lighting'. Fragment lighting |
| applies to fragments generated by all primitives including pixel images. |
| This extension doesn't eliminate vertex lighting, but can be used to |
| complement it. For example, the diffuse contribution can be evaluated |
| at each vertex, and the specular contribution can be evaluated at each |
| fragment with the results being summed together to generate the final |
| result. |
| Ct Cf |
| | |-------------------------------+ |
| | | | |
| ---------- | |
| | | | |
| | TexEnv | | |
| | | | |
| ---------- | |
| | | |
| ---------- | |
| | Clamp | Nf Lf Hf Ff | |
| ---------- | | | | | FragmentColorMaterial |
| | ----------------- | |
| | | | v |
| Cf' | FragmentLight |<-o-<- Material {Am,Em,Dm,Sm,Nm,...} |
| | | | |
| | ----------------- |
| | | |
| | --------- |
| | | Clamp | |
| | --------- |
| | Cl | |
| | +---------------- |
| v v |
| ------------ |
| | | |
| | LightEnv | |
| | | |
| ------------ |
| | |
| --------- |
| | Clamp | |
| --------- |
| | |
| Cf'' |
| | |
| v |
| ------- |
| | | |
| | Fog | |
| | | |
| ------- |
| | |
| v |
| |
| Patent Note |
| |
| To the extent that SGI has patent rights that are unavoidably |
| infringed by all implementations of this extension, SGI will, upon |
| request, grant a license under such patent rights to the requesting |
| party subject to reasonable terms and conditions, and without |
| incremental charge or fee. Such license shall be non-exclusive, and |
| non-transferable, and shall be limited to implementations of the |
| extension in combination with any conformance certified |
| implementation of the OpenGL API. Such license is expressly |
| contingent upon a grant back of a non-exclusive, royalty-free, |
| perpetual, worldwide license to SGI and its OpenGL licensees under |
| the requesting party's patent rights that are unavoidably infringed |
| by all implementations of this extension or OpenGL. |
| |
| Issues |
| |
| * We specify a complete model and don't allow subsetting. if |
| portions of the model aren't supported with hardware acceleration |
| then a software implementation of the complete model is |
| necessary. There should be sufficient mechanism for an |
| implementation to include partial acceleration and easily |
| identify when it can be used. The alternative is to |
| allow subsetting and a mechanisms for enumerating the capability |
| would this be any better? |
| |
| I don't think so. Lighting will be an important area of |
| growth for OpenGL. I think we owe it to our developers |
| to force a consistent growth direction by trying to look |
| ahead a little. |
| |
| * We apply texture environment before lighting so that decals |
| can be lighted correctly. The spec does not provide a |
| mechanism for applying texture after lighting. There are |
| applications where it would be useful to apply texture after |
| lighting (e.g. shadows or spotlight effects), but we deliberately |
| leave them out. Instead we will add binding posts in another |
| extension to allow textures to be bound to the attenuation |
| term, specular exponent, environment term, normal perturbation, |
| etc. |
| |
| * Should the FragmentColorMaterial command really be done through |
| texture binding posts and TexEnv moved after lighting? |
| |
| No. |
| |
| * New LightModel parameters? |
| yes, NORMAL_INTERPOLATION control |
| |
| * We deliberately chose to decouple the control of normal interpolation |
| for fragment lighting from ShadeModel, choosing to put it in the |
| FragmentLightModel command. We chose not to provide any mechanism to |
| allow flat coloring before vertex lighting, so FlatShading continues |
| to mean that the vertex color after vertex lighting is used to |
| provide a constant color across the face of a primitive. |
| |
| * Material parameters are not interpolated. If FragmentMaterial is |
| enabled then the interpolated color parameter will be used as one or |
| more of the material parameters, but there is no equivalent notion |
| to per-vertex materials. If a material change occurs between a |
| Begin/End sequence, then only the last material specified before the |
| provoking vertex will affect the shading computation. |
| |
| * overload ColorMaterial & Material face param with FRAGMENT_FRONT, |
| FRAGMENT_BACK, and FRAGMENT_FRONT_AND_BACK rather than separate commands? |
| |
| since the behaviour is somewhat different (not persistent) so it feels |
| like it should be a different command |
| |
| * proxy mechanism for subsetting? proxy mechanism for determining |
| what is supported in hardware. NO. |
| |
| * add some comments about where lighting parameters are sampled |
| (fragment centers, pixel centers, ...) |
| |
| * shadow term is not quite right. removed it. |
| |
| * should the material be undefined after color material is disabled |
| |
| it should be well defined. fragment color material should be |
| thought of as a switch which causes the material parameters to be |
| sourced from the fragment material 'register' or from the fragment |
| color. At all times queries to the fragment material refer to the |
| material 'register' and whenever fragment color material is |
| disabled, material parameters are sourced from the unperturbed |
| fragment material 'register' |
| |
| * disallow fragment material changes between begin/end? |
| seems okay, since we added a new command! - DONE |
| |
| * add a total number of lights so that implementations can |
| share state between vertex and fragment lights yet be more flexible |
| about whether the state is used for a vertex or fragment light |
| (vimal). |
| |
| Yes. MAX_ACTIVE_LIGHTS_EXT |
| |
| * is the flatshading definition correct? unlike flatshading for |
| vertex lighting, the color will not be constant, just the normal |
| so N.L will vary across the face. Yes, it is what we want. |
| There is now a mechanism which allows flat or smooth color with |
| flat or smooth fragment lighting (flat or smooth normals). |
| |
| * treatment of alpha? |
| |
| alpha comes from the diffuse material if fragment lighting |
| is enabled. |
| |
| * the state of FrontFace affects the interpretation of two-sided |
| lighting. Should there be separate state for vertex and fragment |
| lighting? |
| |
| No. its a property of the geometry and shouldn't different for the |
| two light source types. |
| |
| New Procedures and Functions |
| |
| void FragmentLightModeliEXT(enum pname, int param); |
| void FragmentLightModelfEXT(enum pname, float param); |
| void FragmentLightModelivEXT(enum pname, int *params); |
| void FragmentLightModelfvEXT(enum pname, float *params); |
| |
| void FragmentLightiEXT(enum light, enum pname, int param); |
| void FragmentLightfEXT(enum light, enum pname, float param); |
| void FragmentLightivEXT(enum light, enum pname, int *params); |
| void FragmentLightfvEXT(enum light, enum pname, float *params); |
| |
| void GetFragmentLightivEXT(enum light, enum pname, int *params); |
| void GetFragmentLightfvEXT(enum light, enum pname, float *params); |
| |
| void FragmentMaterialfEXT(enum face, enum pname, const float param); |
| void FragmentMaterialiEXT(enum face, enum pname, const int param); |
| void FragmentMaterialfvEXT(enum face, enum pname, const float *params); |
| void FragmentMaterialivEXT(enum face, enum pname, const int *params); |
| |
| void FragmentColorMaterialEXT(enum face, enum mode); |
| |
| void GetFragmentMaterialfvEXT(enum face, enum pname, const float *params); |
| void GetFragmentMaterialivEXT(enum face, enum pname, const int *params); |
| |
| void LightEnviEXT(enum pname, int param); |
| |
| |
| New Tokens |
| |
| Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, by |
| the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and |
| GetDoublev: |
| |
| FRAGMENT_LIGHTING_EXT 0x8400 |
| FRAGMENT_COLOR_MATERIAL_EXT 0x8401 |
| |
| Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, |
| and GetDoublev: |
| |
| FRAGMENT_COLOR_MATERIAL_FACE_EXT 0x8402 |
| FRAGMENT_COLOR_MATERIAL_PARAMETER_EXT 0x8403 |
| MAX_FRAGMENT_LIGHTS_EXT 0x8404 |
| MAX_ACTIVE_LIGHTS_EXT 0x8405 |
| CURRENT_RASTER_NORMAL_EXT 0x8406 |
| |
| |
| Accepted by the <pname> parameter of LightEnviEXT, by |
| the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and |
| GetDoublev: |
| |
| LIGHT_ENV_MODE_EXT 0x8407 |
| |
| Accepted by the <pname> parameter of FragmentLightModeliEXT, |
| FragmentLightModelfEXT, FragmentLightModelivEXT, |
| FragmentLightModelfvEXT, GetBooleanv, GetIntegerv, GetFloatv, and |
| GetDoublev: |
| |
| FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT 0x8408 |
| FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT 0x8409 |
| FRAGMENT_LIGHT_MODEL_AMBIENT_EXT 0x840A |
| FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT 0x840B |
| |
| Accepted by the <light> parameter of FragmentLightfEXT, |
| FragmentLightiEXT, FragmentLightfvEXT, and FragmentLightivEXT, and by |
| the <cap> parameter of Enable, Disable, and IsEnabled, and by the <light> |
| parameter of GetFragmentLightfvEXT and GetFragmentLightivEXT: |
| |
| FRAGMENT_LIGHT0_EXT 0x840C |
| . |
| . |
| . |
| FRAGMENT_LIGHT7_EXT 0x8413 |
| <reserve enums for 32> |
| |
| 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 combining the rasterized fragment's post-texturing color and |
| a color computed from the current fragment lighting parameters. The |
| two colors are combined according to the function defined |
| by Lighting Environment described below. |
| |
| Fragment lighting is turned either on or off using the generic Enable or |
| Disable commands with the symbolic value FRAGMENT_LIGHTING_EXT. |
| |
| 3.9.1 Lighting Environment |
| |
| The command |
| |
| void LightEnviEXT(enum pname, int param); |
| |
| sets parameters of the lighting environment that specifies how the computed |
| illumination value is combined with the post-texturing fragment color. |
| <pname> is a symbolic constant indicating the parameter to be set, <param> |
| is a value to which to set a single valued parameter. The possible |
| environment parameter is LIGHT_ENV_MODE_EXT. LIGHT_ENV_MODE_EXT may be |
| set to one of REPLACE, MODULATE, or ADD. |
| |
| The value of LIGHT_ENV_MODE_EXT specifies an environment function. |
| The result of this function depends on the post-texturing fragment color |
| (Cf) and the color computed (Cl) in equation (3.2) below. The functions |
| are specified in Table 3.3 |
| |
| REPLACE MODULATE ADD |
| |
| Rv = Rl Rv = RfRl Rv = Rf+Rl |
| Gv = Gl Gv = GfGl Gv = Gf+Gl |
| Bv = Bl Bv = BfBl Bv = Bf+Bl |
| Av = Al Av = AfAl Av = Af+Al |
| |
| Table 3.3 Light environment functions |
| |
| |
| 3.9.2 Lighting Operation |
| |
| The equation for the fragment illumination model is: |
| |
| C = 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*(f_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 |
| f_i is as defined in equation (2.2) |
| n is the specular exponent (shininess) |
| |
| Rewrite the equation as: |
| |
| I[i] = Atten_i*SpotL_i*(Am*Al_i + Dm*Dl_i*(N.L_i) + Sm*Sl*(f_i)(N.H_i)^n) (3.1) |
| |
| and |
| |
| I' = SUM{i = 0 through Nf-1} I[i] |
| |
| C = Em + Am*As + I' (3.2) |
| |
| Equation (3.1) is the same as the vertex lighting equation described in |
| section 2.13.1 for a single light source. Similar to vertex lighting, |
| equation 3.2 is only evaluated for the R, G, and B components and the A |
| component of C is determined from the alpha component of Dm. |
| |
| 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. |
| |
| 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. 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_EXT. |
| |
| 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_EXT, 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.1 is evaluated for each light source and the resulting |
| colors are summed. This result is added to the material emissive and |
| scene ambient terms as in equation 3.2 to produce the R, G, and B |
| color components. The A component is determined from the diffuse |
| material's A component. 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 |
| |
| The fragment material state can be set with the commands |
| FragmentMaterialfEXT, FragmentMaterialfvEXT, FragmentMaterialiEXT, |
| FragmentMaterialivEXT using the values AMBIENT, DIFFUSE, SPECULAR, |
| SHININESS and EMISSION. This state can be queried using the commands |
| GetFragmentMaterialfvEXT and GetFragmentMaterialivEXT. |
| |
| Lighting parameters for fragment light i can be modified by issuing the |
| commands FragmentLightfEXT, FragmentLightiEXT, FragmentLightfvEXT, and |
| FragmentLightivEXT with the <light> parameter |
| set to FRAGMENT_LIGHTi_EXT. The lighting parameters for fragment light i |
| can be queried by issuing the commands GetFragmentLightfvEXT and |
| GetFragmentLightivEXT with the <light> parameter set to FRAGMENT_LIGHTi_EXT. |
| |
| Lighting model parameters for fragment lighting can be modified using the |
| commands FragmentLightModel{T}EXT, FragmentLightModel{T}vEXT. 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_EXT, FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT, |
| FRAGMENT_LIGHT_MODEL_AMBIENT_EXT or FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT. |
| |
| |
| 3.9.4 FragmentColorMaterial |
| |
| One or more fragment material properties in Equation 3.2 can be |
| replaced 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. |
| |
| 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_EXT. This limit can be queried using the Get command |
| with <pname> parameter MAX_ACTIVE_LIGHTS_EXT. 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_EXT through FRAGMENT_LIGHT<m>_EXT where <m> is equal |
| to MAX_FRAGMENT_LIGHTS_EXT. |
| |
| |
| 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}EXT, |
| FragmentMaterial{T}vEXT, or FragmentColorMaterialEXT, parameter <face> is |
| not FRONT, BACK or FRONT_AND_BACK. |
| |
| INVALID_ENUM is generated if FragmentMaterial{T}EXT or |
| FragmentMaterial{T}vEXT parameter <pname> is not AMBIENT, DIFFUSE, |
| SPECULAR, EMISSION, SHININESS, or AMBIENT_AND_DIFFUSE. |
| |
| INVALID_ENUM is generated if GetFragmentMaterial{T}vEXT parameter <face> |
| is not FRONT or BACK. |
| |
| INVALID_ENUM is generated if GetFragmentMaterial{T}vEXT parameter <pname> |
| is not AMBIENT, DIFFUSE, SPECULAR, EMISSION, or SHININESS, |
| |
| INVALID_ENUM if FragmentColorMaterialEXT parameter <mode> is not EMISSION, |
| AMBIENT, DIFFUSE, SPECULAR, or AMBIENT_AND_DIFFUSE |
| |
| INVALID_ENUM if LightEnviEXT parameter <pname> is not LIGHT_ENV_MODE_EXT |
| or if parameter <mode> is not REPLACE, MODULATE, or ADD. |
| |
| INVALID_ENUM is generated if FragmentLightModel{T}EXT <pname> is not |
| FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT, FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT |
| or FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT or if |
| FragmentLightModel{T}vEXT, parameter <pname> is not |
| FRAGMENT_LIGHT_MODEL_AMBIENT_EXT, FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT |
| FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT or |
| FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT. |
| |
| INVALID_ENUM is generated if FragmentLight{T}EXT, FragmentLight{T}vEXT, |
| or GetFragmentLight{T}vEXT parameter <light> is not FRAGMENT_LIGHT0_EXT |
| ... FRAGMENT_LIGHT<n>_EXT where n is one minus the number of supported |
| fragment lights, or if FragmentLight{T}EXT parameter <pname> is not |
| SPOT_EXPONENT, SPOT_CUTOFF, CONSTANT_ATTENUATION, LINEAR_ATTENUATION, or |
| QUADRATIC_ATTENUATION, or if FragmentLight{T}vEXT or |
| GetFragmentLight{T}vEXT 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}EXT or FragmentLight{T}vEXT |
| 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}EXT, |
| FragmentMaterial{T}vEXT, FragmentColorMaterialEXT, |
| GetFragmentMaterial{T}vEXT, LightEnviEXT, FragmentLight{T}EXT, |
| FragmentLight{T}vEXT, FragmentLightModel{T}EXT, |
| FragmentLightModel{T}vEXT or GetFragmentLight{T}vEXT is executed between |
| execution of Begin and the corresponding execution of End. |
| |
| New State |
| |
| Get Value Get Command Type Initial Value Attribute |
| --------- ----------- ---- ------------- --------- |
| |
| FRAGMENT_LIGHTING_EXT IsEnabled B False lighting/enable |
| FRAGMENT_COLOR_MATERIAL_EXT IsEnabled B False lighting/enable |
| FRAGMENT_COLOR_MATERIAL_PARAMETER_EXT GetIntegerv Z5 AMBIENT_AND_DIFFUSE lighting |
| FRAGMENT_COLOR_MATERIAL_FACE_EXT GetIntegerv Z3 FRONT_AND_BACK lighting |
| AMBIENT GetFragmentMaterialfvEXT 2xC (0.2,0.2,0.2,1.0) lighting |
| DIFFUSE GetFragmentMaterialfvEXT 2xC (0.8,0.8,0.8,1.0) lighting |
| SPECULAR GetFragmentMaterialfvEXT 2xC (0.0,0.0,0.0,1.0) lighting |
| EMISSION GetFragmentMaterialfvEXT 2xC (0.0,0.0,0.0,1.0) lighting |
| SHININESS GetFragmentMaterialfvEXT 2xR 0.0 lighting |
| FRAGMENT_LIGHT_MODEL_AMBIENT_EXT GetFloatv C (0.2,0.2,0.2,0.2) lighting |
| FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT GetBooleanv B False lighting |
| FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT GetBooleanv B False lighting |
| FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT GetIntegerv Z2 SMOOTH lighting |
| AMBIENT GetFragmentLightfvEXT 1*xC (0.0,0.0,0.0,1.0) lighting |
| DIFFUSE GetFragmentLightfvEXT 1*xC see 3.x lighting |
| SPECULAR GetFragmentLightfvEXT 1*xC see 3.x lighting |
| POSITION GetFragmentLightfvEXT 1*xP (0.0,0.0,1.0,0.0) lighting |
| CONSTANT_ATTENUATION GetFragmentLightfvEXT 1*xR 1.0 lighting |
| LINEAR_ATTENUATION GetFragmentLightfvEXT 1*xR+ 0.0 lighting |
| QUADRATIC_ATTENUATION GetFragmentLightfvEXT 1*xR+ 0.0 lighting |
| SPOT_DIRECTION GetFragmentLightfvEXT 1*xD (0.0,0.0,-1.0) lighting |
| SPOT_EXPONENT GetFragmentLightfvEXT 1*xR+ 0.0 lighting |
| SPOT_CUTOFF GetFragmentLightfvEXT 1*xR+ 180.0 lighting |
| FRAGMENT_LIGHTi_EXT IsEnabled 1*xB False lighting/enable |
| LIGHT_ENV_MODE_EXT GetIntegerv Z3 REPLACE lighting |
| |
| CURRENT_RASTER_NORMAL_EXT GetFloatv N (0,0,1) current |
| |
| New Implementation Dependent State |
| |
| Get Value Get Command Type Minimum Value |
| --------- ----------- ---- ------------- |
| MAX_FRAGMENT_LIGHTS_EXT GetIntegerv Z+ 1 |
| MAX_ACTIVE_LIGHTS_EXT GetIntegerv z+ MAX_LIGHTS |
