| Name |
| |
| EXT_fog_coord |
| |
| Name Strings |
| |
| GL_EXT_fog_coord |
| |
| Contact |
| |
| Jon Leech, Silicon Graphics (ljp 'at' sgi.com) |
| |
| Status |
| |
| Shipping (version 1.6) |
| |
| Version |
| |
| $Date: 1999/06/21 19:57:19 $ $Revision: 1.11 $ |
| |
| Number |
| |
| 149 |
| |
| Dependencies |
| |
| OpenGL 1.1 is required. |
| The extension is written against the OpenGL 1.2 Specification. |
| |
| Overview |
| |
| This extension allows specifying an explicit per-vertex fog |
| coordinate to be used in fog computations, rather than using a |
| fragment depth-based fog equation. |
| |
| Issues |
| |
| * Should the specified value be used directly as the fog weighting |
| factor, or in place of the z input to the fog equations? |
| |
| As the z input; more flexible and meets ISV requests. |
| |
| * Do we want vertex array entry points? Interleaved array formats? |
| |
| Yes for entry points, no for interleaved formats, following the |
| argument for secondary_color. |
| |
| * Which scalar types should FogCoord accept? The full range, or just |
| the unsigned and float versions? At the moment it follows Index(), |
| which takes unsigned byte, signed short, signed int, float, and |
| double. |
| |
| Since we're now specifying a number which behaves like an |
| eye-space distance, rather than a [0,1] quantity, integer types |
| are less useful. However, restricting the commands to floating |
| point forms only introduces some nonorthogonality. |
| |
| Restrict to only float and double, for now. |
| |
| * Interpolation of the fog coordinate may be perspective-correct or |
| not. Should this be affected by PERSPECTIVE_CORRECTION_HINT, |
| FOG_HINT, or another to-be-defined hint? |
| |
| PERSPECTIVE_CORRECTION_HINT; this is already defined to affect |
| all interpolated parameters. Admittedly this is a loss of |
| orthogonality. |
| |
| * Should the current fog coordinate be queryable? |
| |
| Yes, but it's not returned by feedback. |
| |
| * Control the fog coordinate source via an Enable instead of a fog |
| parameter? |
| |
| No. We might want to add more sources later. |
| |
| * Should the fog coordinate be restricted to non-negative values? |
| |
| Perhaps. Eye-coordinate distance of fragments will be |
| non-negative due to clipping. Specifying explicit negative |
| coordinates may result in very large computed f values, although |
| they are defined to be clipped after computation. |
| |
| * Use existing DEPTH enum instead of FRAGMENT_DEPTH? Change name of |
| FRAGMENT_DEPTH_EXT to FOG_FRAGMENT_DEPTH_EXT? |
| |
| Use FRAGMENT_DEPTH_EXT; FOG_FRAGMENT_DEPTH_EXT is somewhat |
| misleading, since fragment depth itself has no dependence on |
| fog. |
| |
| New Procedures and Functions |
| |
| void FogCoord[fd]EXT(T coord) |
| void FogCoord[fd]vEXT(T coord) |
| void FogCoordPointerEXT(enum type, sizei stride, void *pointer) |
| |
| New Tokens |
| |
| Accepted by the <pname> parameter of Fogi and Fogf: |
| |
| FOG_COORDINATE_SOURCE_EXT 0x8450 |
| |
| Accepted by the <param> parameter of Fogi and Fogf: |
| |
| FOG_COORDINATE_EXT 0x8451 |
| FRAGMENT_DEPTH_EXT 0x8452 |
| |
| Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, |
| GetFloatv, and GetDoublev: |
| |
| CURRENT_FOG_COORDINATE_EXT 0x8453 |
| FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454 |
| FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455 |
| |
| Accepted by the <pname> parameter of GetPointerv: |
| |
| FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456 |
| |
| Accepted by the <array> parameter of EnableClientState and |
| DisableClientState: |
| |
| FOG_COORDINATE_ARRAY_EXT 0x8457 |
| |
| Additions to Chapter 2 of the OpenGL 1.2 Specification (OpenGL Operation) |
| |
| These changes describe a new current state type, the fog coordinate, |
| and the commands to specify it: |
| |
| - (2.6, p. 12) Second paragraph changed to: |
| |
| "Each vertex is specified with two, three, or four coordinates. |
| In addition, a current normal, current texture coordinates, |
| current color, and current fog coordinate may be used in |
| processing each vertex." |
| |
| - 2.6.3, p. 19) First paragraph changed to |
| |
| "The only GL commands that are allowed within any Begin/End |
| pairs are the commands for specifying vertex coordinates, vertex |
| colors, normal coordinates, texture coordinates, and fog |
| coordinates (Vertex, Color, Index, Normal, TexCoord, |
| FogCoord)..." |
| |
| - (2.7, p. 20) Insert the following paragraph following the third |
| paragraph describing current normals: |
| |
| " The current fog coodinate is set using |
| void FogCoord[fd]EXT(T coord) |
| void FogCoord[fd]vEXT(T coord)." |
| |
| The last paragraph is changed to read: |
| |
| "The state required to support vertex specification consists of |
| four floating-point numbers to store the current texture |
| coordinates s, t, r, and q, one floating-point value to store |
| the current fog coordinate, four floating-point values to store |
| the current RGBA color, and one floating-point value to store |
| the current color index. There is no notion of a current vertex, |
| so no state is devoted to vertex coordinates. The initial values |
| of s, t, and r of the current texture coordinates are zero; the |
| initial value of q is one. The initial fog coordinate is zero. |
| The initial current normal has coordinates (0,0,1). The initial |
| RGBA color is (R,G,B,A) = (1,1,1,1). The initial color index is |
| 1." |
| |
| - (2.8, p. 21) Added fog coordinate command for vertex arrays: |
| |
| Change first paragraph to read: |
| |
| "The vertex specification commands described in section 2.7 |
| accept data in almost any format, but their use requires many |
| command executions to specify even simple geometry. Vertex data |
| may also be placed into arrays that are stored in the client's |
| address space. Blocks of data in these arrays may then be used |
| to specify multiple geometric primitives through the execution |
| of a single GL command. The client may specify up to seven |
| arrays: one each to store edge flags, texture coordinates, fog |
| coordinates, colors, color indices, normals, and vertices. The |
| commands" |
| |
| Add to functions listed following first paragraph: |
| |
| void FogCoordPointerEXT(enum type, sizei stride, void *pointer) |
| |
| Add to table 2.4 (p. 22): |
| |
| Command Sizes Types |
| ------- ----- ----- |
| FogCoordPointerEXT 1 float,double |
| |
| Starting with the second paragraph on p. 23, change to add |
| FOG_COORDINATE_ARRAY_EXT: |
| |
| "An individual array is enabled or disabled by calling one of |
| |
| void EnableClientState(enum array) |
| void DisableClientState(enum array) |
| |
| with array set to EDGE_FLAG_ARRAY, TEXTURE_COORD_ARRAY, |
| FOG_COORDINATE_ARRAY_EXT, COLOR_ARRAY, INDEX_ARRAY, |
| NORMAL_ARRAY, or VERTEX_ARRAY, for the edge flag, texture |
| coordinate, fog coordinate, color, color index, normal, or |
| vertex array, respectively. |
| |
| The ith element of every enabled array is transferred to the GL |
| by calling |
| |
| void ArrayElement(int i) |
| |
| For each enabled array, it is as though the corresponding |
| command from section 2.7 or section 2.6.2 were called with a |
| pointer to element i. For the vertex array, the corresponding |
| command is Vertex<size><type>v, where <size> is one of [2,3,4], |
| and <type> is one of [s,i,f,d], corresponding to array types |
| short, int, float, and double respectively. The corresponding |
| commands for the edge flag, texture coordinate, fog coordinate, |
| color, color, color index, and normal arrays are EdgeFlagv, |
| TexCoord<size><type>v, FogCoord<type>v, Color<size><type>v, |
| Index<type>v, and Normal<type>v, respectively..." |
| |
| Change pseudocode on p. 27 to disable fog coordinate array for |
| canned interleaved array formats. After the lines |
| |
| DisableClientState(EDGE_FLAG_ARRAY); |
| DisableClientState(INDEX_ARRAY); |
| |
| insert the line |
| |
| DisableClientState(FOG_COORDINATE_ARRAY_EXT); |
| |
| Substitute "seven" for every occurence of "six" in the final |
| paragraph on p. 27. |
| |
| - (2.12, p. 41) Add fog coordinate to the current rasterpos state. |
| |
| Change the first sentence of the first paragraph to read |
| |
| "The state required for the current raster position consists of |
| three window coordinates x_w, y_w, and z_w, a clip coordinate |
| w_c value, an eye coordinate distance, a fog coordinate, a valid |
| bit, and associated data consisting of a color and texture |
| coordinates." |
| |
| Change the last paragraph to read |
| |
| "The current raster position requires six single-precision |
| floating-point values for its x_w, y_w, and z_w window |
| coordinates, its w_c clip coordinate, its eye coordinate |
| distance, and its fog coordinate, a single valid bit, a color |
| (RGBA color and color index), and texture coordinates for |
| associated data. In the initial state, the coordinates and |
| texture coordinates are both (0,0,0,1), the fog coordinate is 0, |
| the eye coordinate distance is 0, the valid bit is set, the |
| associated RGBA color is (1,1,1,1), and the associated color |
| index color is 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." |
| |
| - (3.10, p. 139) Change the second and third paragraphs to read |
| |
| "This factor f may be computed according to one of three |
| equations:" |
| |
| f = exp(-d*c) (3.24) |
| f = exp(-(d*c)^2) (3.25) |
| f = (e-c)/(e-s) (3.26) |
| |
| If the fog source (as defined below) is FRAGMENT_DEPTH_EXT, then |
| c is the eye-coordinate distance from the eye, (0 0 0 1) in eye |
| coordinates, to the fragment center. If the fog source is |
| FOG_COORDINATE_EXT, then c is the interpolated value of the fog |
| coordinate for this fragment. The equation and the fog source, |
| along with either d or e and s, is specified with |
| |
| void Fog{if}(enum pname, T param); |
| void Fog{if}v(enum pname, T params); |
| |
| If <pname> is FOG_MODE, then <param> must be, or <param> must |
| point to an integer that is one of the symbolic constants EXP, |
| EXP2, or LINEAR, in which case equation 3.24, 3.25, or 3.26,, |
| respectively, is selected for the fog calculation (if, when 3.26 |
| is selected, e = s, results are undefined). If <pname> is |
| FOG_COORDINATE_SOURCE_EXT, then <param> is or <params> points to |
| an integer that is one of the symbolic constants |
| FRAGMENT_DEPTH_EXT or FOG_COORDINATE_EXT. If <pname> is |
| FOG_DENSITY, FOG_START, or FOG_END, then <param> is or <params> |
| points to a value that is d, s, or e, respectively. If d is |
| specified less than zero, the error INVALID_VALUE results." |
| |
| - (3.10, p. 140) Change the last paragraph preceding section 3.11 |
| to read |
| |
| "The state required for fog consists of a three valued integer |
| to select the fog equation, three floating-point values d, e, |
| and s, an RGBA fog color and a fog color index, a two-valued |
| integer to select the fog coordinate source, and a single bit to |
| indicate whether or not fog is enabled. In the initial state, |
| fog is disabled, FOG_COORDINATE_SOURCE_EXT is |
| FRAGMENT_DEPTH_EXT, FOG_MODE is EXP, d = 1.0, e = 1.0, and s = |
| 0.0; C_f = (0,0,0,0) and i_f=0." |
| |
| Additions to Chapter 3 of the OpenGL 1.2.1 Specification (Rasterization) |
| |
| None |
| |
| Additions to Chapter 4 of the OpenGL 1.2.1 Specification (Per-Fragment |
| Operations and the Frame Buffer) |
| |
| None |
| |
| Additions to Chapter 5 of the OpenGL 1.2.1 Specification (Special Functions) |
| |
| None |
| |
| Additions to Chapter 6 of the OpenGL 1.2 Specification (State and State |
| Requests) |
| |
| None |
| |
| Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance) |
| |
| None |
| |
| Additions to the GLX / WGL / AGL Specifications |
| |
| None |
| |
| GLX Protocol |
| |
| Two new GL rendering commands are added. The following commands are |
| sent to the server as part of a glXRender request: |
| |
| FogCoordfvEXT |
| 2 8 rendering command length |
| 2 4124 rendering command opcode |
| 4 FLOAT32 v[0] |
| |
| FogCoorddvEXT |
| 2 12 rendering command length |
| 2 4125 rendering command opcode |
| 8 FLOAT64 v[0] |
| |
| Errors |
| |
| INVALID_ENUM is generated if FogCoordPointerEXT parameter <type> is |
| not FLOAT or DOUBLE. |
| |
| INVALID_VALUE is generated if FogCoordPointerEXT parameter <stride> |
| is negative. |
| |
| New State |
| |
| (table 6.5, p. 195) |
| Get Value Type Get Command Initial Value Description Sec Attribute |
| --------- ---- ----------- ------------- ----------- --- --------- |
| CURRENT_FOG_COORDINATE_EXT R GetIntegerv, 0 Current 2.7 current |
| GetFloatv fog coordinate |
| |
| (table 6.6, p. 197) |
| Get Value Type Get Command Initial Value Description Sec Attribute |
| --------- ---- ----------- ------------- ----------- --- --------- |
| FOG_COORDINATE_ARRAY_EXT B IsEnabled False Fog coord array enable 2.8 vertex-array |
| FOG_COORDINATE_ARRAY_TYPE_EXT Z8 GetIntegerv FLOAT Type of fog coordinate 2.8 vertex-array |
| FOG_COORDINATE_ARRAY_STRIDE_EXT Z+ GetIntegerv 0 Stride between fog coords 2.8 vertex-array |
| FOG_COORDINATE_ARRAY_POINTER_EXT Y GetPointerv 0 Pointer to the fog coord array 2.8 vertex-array |
| |
| |
| (table 6.8, p. 198) |
| Get Value Type Get Command Initial Value Description Sec Attribute |
| --------- ---- ----------- ------------- ----------- --- --------- |
| FOG_COORDINATE_SOURCE_EXT Z2 GetIntegerv, FRAGMENT_DEPTH_EXT Source of fog 3.10 fog |
| GetFloatv coordinate for |
| fog calculation |
| |
| Revision History |
| |
| * Revision 1.6 - Functionality complete |
| |
| * Revision 1.7-1.9 - Fix typos and add fields to bring up to date with |
| the new extension template. No functionality changes. |
