Name
SGIX_fog_patchy
Name Strings
GL_SGIX_fog_patchy
Version
$Date: 1999/03/30 23:13:46 $ $Revision: 1.3 $
Number
XXX
Dependencies
OpenGL 1.2 is required
Overview
Patchy fog is a fog in which intermittent areas of dense fog may
be encoutered. This extension explains how the patchy fog
extension is supported. Patchy fog is needed because both
uniform fog density and fog layers can only specify a constant
density at a given elevation. The SGIX_fog_texture openGL
extension gives a mean to specify a patchy fog texture that will
modulate the fog density at a given elevation. The goal of this
document is to describe the modulation fuction and the fog
equation when patchy fog is enabled. No tokens, states, or
procedures are introduced in this extension.
New Procedures and Functions
None
Issues
- Since there is no API introduction is this extension the
good way to present things?
- Should we introduce an glEnable for patchy fog?
- We should move the description of the patchy fog equation
up to the overview but we do not want to disclose it for the
moment.
New Tokens
None
Additions to Chapter 2 of the 1.2 Specification (OpenGL Operation)
None
Additions to Chapter 3 of the 1.2 Specification (Rasterization)
3.10 Fog
In addition to uniform fog density and fog layers, patchy fog can
be specified. The patchy fog extension gives a mean to modulate
the fog density with a texture.
_____ _____
density (d) ___| | | |
| * |____| * |__ To fog equation
__| | __| | (d*p*r)
| |_____| | |_____|
| |
| |
| |
patchy fog texture (p) __| |
|
|
range (r) ---------------------------|
The product (d*p*r) is used in the computation of the fog blending
factor (f). If the patchy fog texture is not enabled in SGIX_fog_texture,
then the patchy fog texture has no effect (p = 1.0).
The computation of the fog equation when patchy fog is enabled
requires multiple passes. It is hereby described as a 2-pass
approach. If there are more than one patchy fog layer or more
than one patchy fog color, the second pass will be repeated
multiple times.
1) In the first pass: compute an intermediate color at a given
fragment using the fog blending equation. In this first pass,
the fog patchiness is ignored (p=1).
[RGBl] = f1 x [RGBs] + (1-f1) x [RGBfog]
where,
- [RGBl] is the intermediate color stored in the frame buffer.
- f1 is the fog blending factor. It is a function of the fog
density (d) and the distance between the viewpoint and the
fragment in eye space (r).
- [RGBs] is the input fragment that is coming out from fragment
lighting in the rasterization pipeline.
- [RGBfog] is the fog color.
2) In the second pass: compute the final fragment color using the
result of the previous pass. In the second pass, the fog
patchiness is taken into account (p=patchy fog texture)
Destination = f2 * [RGBl] + (1-f2) * [RGBcloud],
where,
- Destination is the final fragment color
- f2 is the fog blending factor. It is a function of the fog
density (d), the distance between the viewpoint and the fragment in eye
space (r), and the patchy fog texture (p). In the hardware, the density
is first multiplied by the patchy fog texture and then
multiplied by the range r.
- [RGBl] is the intermediate color. Color that we would get
without patchy fog.
- [RGBcloud] is the patchy fog color.
Additions to Chapter 4 of the 1.2 Specification (Per-Fragment Operations
and the Framebuffer)
None
Additions to Chapter 5 of the 1.2 Specification (Special Functions)
None
Additions to Chapter 6 of the 1.2 Specification (State and State Requests)
None
Additions to the GLX Specification
None
Errors
None
New State
None
New Implementation Dependent State
None