EXT_packed_float
GL_EXT_packed_float
WGL_EXT_pixel_format_packed_float
GLX_EXT_fbconfig_packed_float
Mark J. Kilgard, NVIDIA Corporation (mjk 'at' nvidia.com)
Preliminary
Date: February 15, 2006
Revision: 0.3
???
OpenGL 1.1 required
ARB_color_buffer_float affects this extension.
EXT_texture_shared_exponent trivially affects this extension.
EXT_framebuffer_object affects this extension.
WGL_ARB_pixel_format is required for use with WGL.
WGL_ARB_pbuffer affects WGL pbuffer support for this extension.
GLX 1.3 is required for use with GLX.
This extension is written against the OpenGL 2.0 (September 7,
2004) specification.
This extension adds a new 3-component floating-point texture format
that fits within a single 32-bit word. This format stores 5 bits
of biased exponent per component in the same manner as 16-bit
floating-point formats, but rather than 10 mantissa bits, the red,
green, and blue components have 6, 6, and 5 bits respectively.
Each mantissa is assumed to have an implied leading one except in the
denorm exponent case. There is no sign bit so only non-negative
values can be represented. Positive infinity, positive denorms,
and positive NaN values are representable. The value of the fourth
component returned by a texture fetch is always 1.0.
This extension also provides support for rendering into an unsigned
floating-point rendering format with the assumption that the texture
format described above could also be advertised as an unsigned
floating-point format for rendering.
The extension also provides a pixel external format for specifying
packed float values directly.
   New Procedures and Functions |
None
Accepted by the <internalformat> parameter of TexImage1D,
TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and
RenderbufferStorageEXT:
R11F_G11F_B10F_EXT 0x8C3A
Accepted by the <type> parameter of DrawPixels, ReadPixels,
TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D,
TexSubImage2D, TexSubImage3D, GetHistogram, GetMinmax,
ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D,
GetConvolutionFilter, SeparableFilter2D, GetSeparableFilter,
ColorTable, ColorSubTable, and GetColorTable:
UNSIGNED_INT_10F_11F_11F_REV_EXT 0x8C3B
Accepted by the <pname> parameters of GetIntegerv, GetFloatv, and
GetDoublev:
RGBA_SIGNED_COMPONENTS_EXT 0x8C3C
Accepted as a value in the <piAttribIList> and <pfAttribFList>
parameter arrays of wglChoosePixelFormatARB, and returned in the
<piValues> parameter array of wglGetPixelFormatAttribivARB, and the
<pfValues> parameter array of wglGetPixelFormatAttribfvARB:
WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
Accepted as values of the <render_type> arguments in the
glXCreateNewContext and glXCreateContext functions
GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT 0x20B1
Returned by glXGetFBConfigAttrib (when <attribute> is set to
GLX_RENDER_TYPE) and accepted by the <attrib_list> parameter of
glXChooseFBConfig (following the GLX_RENDER_TYPE token):
GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT 0x00000008
| Additions to Chapter 2 of the 2.0 Specification (OpenGL Operation) |
-- Add two new sections after Section 2.1.2, (page 6):
2.1.A Unsigned 11-Bit Floating-Point Numbers
An unsigned 11-bit floating-point number has no sign bit, a 5-bit
exponent (E), and a 6-bit mantissa (M). The value of an unsigned
11-bit floating-point number (represented as an 11-bit unsigned
integer N) is determined by the following:
0.0, if E == 0 and M == 0,
2^-14 * (M / 64), if E == 0 and M != 0,
2^(E-15) * (1 + M/64), if 0 < E < 31,
INF, if E == 31 and M == 0, or
NaN, if E == 31 and M != 0,
where
E = floor(N / 64), and
M = N mod 64.
Implementations are also allowed to use any of the following
alternative encodings:
0.0, if E == 0 and M != 0
2^(E-15) * (1 + M/64) if E == 31 and M == 0
2^(E-15) * (1 + M/64) if E == 31 and M != 0
When a floating-point value is converted to an unsigned 11-bit
floating-point representation, finite values are rounded to the closet
representable finite value. While less accurate, implementations
are allowed to always round in the direction of zero. This means
negative values are converted to zero. Likewise, finite positive
values greater than 65024 (the maximum finite representable unsigned
11-bit floating-point value) are converted to 65024. Additionally:
negative infinity is converted to zero; positive infinity is converted
to positive infinity; and both positive and negative NaN are converted
to positive NaN.
Any representable unsigned 11-bit floating-point value is legal
as input to a GL command that accepts 11-bit floating-point data.
The result of providing a value that is not a floating-point number
(such as infinity or NaN) to such a command is unspecified, but must
not lead to GL interruption or termination. Providing a denormalized
number or negative zero to GL must yield predictable results.
2.1.B Unsigned 10-Bit Floating-Point Numbers
An unsigned 10-bit floating-point number has no sign bit, a 5-bit
exponent (E), and a 5-bit mantissa (M). The value of an unsigned
10-bit floating-point number (represented as an 10-bit unsigned
integer N) is determined by the following:
0.0, if E == 0 and M == 0,
2^-14 * (M / 32), if E == 0 and M != 0,
2^(E-15) * (1 + M/32), if 0 < E < 31,
INF, if E == 31 and M == 0, or
NaN, if E == 31 and M != 0,
where
E = floor(N / 32), and
M = N mod 32.
When a floating-point value is converted to an unsigned 10-bit
floating-point representation, finite values are rounded to the closet
representable finite value. While less accurate, implementations
are allowed to always round in the direction of zero. This means
negative values are converted to zero. Likewise, finite positive
values greater than 64512 (the maximum finite representable unsigned
10-bit floating-point value) are converted to 64512. Additionally:
negative infinity is converted to zero; positive infinity is converted
to positive infinity; and both positive and negative NaN are converted
to positive NaN.
Any representable unsigned 10-bit floating-point value is legal
as input to a GL command that accepts 10-bit floating-point data.
The result of providing a value that is not a floating-point number
(such as infinity or NaN) to such a command is unspecified, but must
not lead to GL interruption or termination. Providing a denormalized
number or negative zero to GL must yield predictable results.
| Additions to Chapter 3 of the 2.0 Specification (Rasterization) |
-- Section 3.6.4, Rasterization of Pixel Rectangles
Add a new row to Table 3.5 (page 128):
type Parameter Corresponding Special
Token Name GL Data Type Interpretation
-------------------------------- ------------- --------------
UNSIGNED_INT_10F_11F_11F_REV_EXT uint yes
Add a new row to table 3.8: Packed pixel formats (page 132):
type Parameter GL Data Number of Matching
Token Name Type Components Pixel Formats
-------------------------------- ------- ---------- -------------
UNSIGNED_INT_10F_11F_11F_REV_EXT uint 3 RGB
Add a new entry to table 3.11: UNSIGNED_INT formats (page 134):
UNSIGNED_INT_10F_11F_11F_REV_EXT:
31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+----------------------------+--------------------------------+---------------------------------+
| 3rd | 2nd | 1st |
+----------------------------+--------------------------------+---------------------------------+
Add to the end of the 2nd paragraph starting "Pixels are draw using":
"If type is UNSIGNED_INT_10F_11F_11F_REV_EXT and format is not RGB
then the error INVALID_ENUM occurs."
Add UNSIGNED_INT_10F_11F_11F_REV_EXT to the list of packed formats
in the 10th paragraph after the "Packing" subsection (page 130).
Add before the 3rd paragraph (page 135, starting "Calling DrawPixels
with a type of BITMAP...") from the end of the "Packing" subsection:
"Calling DrawPixels with a type of UNSIGNED_INT_10F_11F_11F_REV_EXT
and format of RGB is a special case in which the data are a series
of GL uint values. Each uint value specifies 3 packed components
as shown in table 3.11. The 1st, 2nd, and 3rd components are
called f_red (11 bits), f_green (11 bits), and f_blue (10 bits)
respectively.
f_red and f_green are treated as unsigned 11-bit floating-point values
and converted to floating-point red and green components respectively
as described in section 2.1.A. f_blue is treated as an unsigned
10-bit floating-point value and converted to a floating-point blue
component as described in section 2.1.B."
-- Section 3.8.1, Texture Image Specification:
"Alternatively if the internalformat is R11F_G11F_B10F_EXT, the red,
green, and blue bits are converted to unsigned 11-bit, unsigned
11-bit, and unsigned 10-bit floating-point values as described
in sections 2.1.A and 2.1.B. These encoded values can be later
decoded back to floating-point values due to texture image sampling
or querying."
Add a new row to Table 3.16 (page 154).
Sized Base R G B A L I D
Internal Format Internal Format bits bits bits bits bits bits bits
--------------------- --------------- ---- ---- ---- ---- ---- ---- ----
R11F_G11F_B10F_EXT RGB 11 11 10
| Additions to Chapter 4 of the 2.0 Specification (Per-Fragment Operations and the Frame Buffer) |
-- Modify Chapter 4 Introduction, (page 198)
Modify first sentence of third paragraph (page 198):
"Color buffers consist of either signed or unsigned integer color
indices, R, G, B and optionally A signed or unsigned integer values,
or R, G, B, and optionally A signed or unsigned floating-point
values."
-- Section 4.3.2, Reading Pixels
Add a row to table 4.7 (page 224);
Component
type Parameter GL Data Type Conversion Formula
-------------------------------- ------------ ------------------
UNSIGNED_INT_10F_11F_11F_REV_EXT uint special
Replace second paragraph of "Final Conversion" (page 222) to read:
For an RGBA color, if <type> is not one of FLOAT,
UNSIGNED_INT_5_9_9_9_REV_EXT, or UNSIGNED_INT_10F_11F_11F_REV_EXT,
or if the CLAMP_READ_COLOR_ARB is TRUE, or CLAMP_READ_COLOR_ARB
is FIXED_ONLY_ARB and the selected color (or texture) buffer is
a fixed-point buffer, each component is first clamped to [0,1].
Then the appropriate conversion formula from table 4.7 is applied
the component."
Add a paragraph after the second paragraph of "Final Conversion"
(page 222):
"In the special case when calling ReadPixels with a type of
UNSIGNED_INT_10F_11F_11F_REV_EXT and format of RGB, the conversion
is done as follows: The returned data are packed into a series of
GL uint values. The red, green, and blue components are converted
to unsigned 11-bit floating-point, unsigned 11-bit floating-point,
and unsigned 10-bit floating point as described in section
2.1.A and 2.1.B. The resulting red 11 bits, green 11 bits, and blue
10 bits are then packed as the 1st, 2nd, and 3rd components of the
UNSIGNED_INT_10F_11F_11F_REV_EXT format as shown in table 3.11."
| Additions to Chapter 5 of the 2.0 Specification (Special Functions) |
None
| Additions to Chapter 6 of the 2.0 Specification (State and State Requests) |
None
| Additions to the OpenGL Shading Language specification |
None
| Additions to Chapter 3 of the GLX 1.3 Specification (Functions and Errors) |
Replace Section 3.3.3 (p.12) Paragraph 4 to:
The attribute GLX_RENDER_TYPE has as its value a mask indicating
what type of GLXContext a drawable created with the corresponding
GLXFBConfig can be bound to. The following bit settings are supported:
GLX_RGBA_BIT, GLX_RGBA_FLOAT_BIT, GLX_RGBA_UNSIGNED_FLOAT_BIT,
GLX_COLOR_INDEX_BIT. If combinations of bits are set in the mask
then drawables created with the GLXFBConfig can be bound to those
corresponding types of rendering contexts.
Add to Section 3.3.3 (p.15) after first paragraph:
Note that unsigned floating point rendering is only supported
for GLXPbuffer drawables. The GLX_DRAWABLE_TYPE attribute of
the GLXFBConfig must have the GLX_PBUFFER_BIT bit set and the
GLX_RENDER_TYPE attribute must have the GLX_RGBA_UNSIGNED_FLOAT_BIT
set. Unsigned floating point rendering assumes the framebuffer
format has no sign bits so all component values are non-negative.
In contrast, conventional floating point rendering assumes signed
components.
Modify Section 3.3.7 (p.25 Rendering Contexts) remove period
at end of second paragraph and replace with:
; if render_type is set to GLX_RGBA_UNSIGNED_FLOAT_TYPE then a
context that supports unsigned floating point RGBA rendering is
created.
None.
| Additions to the WGL Specification |
Modify the values accepted by WGL_PIXEL_TYPE_ARB to:
WGL_PIXEL_TYPE_ARB
The type of pixel data. This can be set to WGL_TYPE_RGBA_ARB,
WGL_TYPE_RGBA_FLOAT_ARB, WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT,
or WGL_TYPE_COLORINDEX_ARB.
Add this explanation of unsigned floating point rendering:
"Unsigned floating point rendering assumes the framebuffer format has
no sign bits so all component values are non-negative. In contrast,
conventional floating point rendering assumes signed components."
| Dependencies on WGL_ARB_pbuffer |
Ignore the "Additions to the WGL Specification" section if
WGL_ARB_pbuffer is not supported.
| Dependencies on WGL_ARB_pixel_format |
The WGL_ARB_pixel_format extension must be used to determine a
pixel format with unsigned float components.
| Dependencies on ARB_color_buffer_float |
If ARB_color_buffer_float is not supported, replace this amended
sentence from 4.3.2 above
For an RGBA color, if <type> is not one of FLOAT,
UNSIGNED_INT_5_9_9_9_REV_EXT, or UNSIGNED_INT_10F_11F_11F_REV_EXT,
or if the CLAMP_READ_COLOR_ARB is TRUE, or CLAMP_READ_COLOR_ARB
is FIXED_ONLY_ARB and the selected color (or texture) buffer is
a fixed-point buffer, each component is first clamped to [0,1]."
with
"For an RGBA color, if <type> is not one of FLOAT,
UNSIGNED_INT_5_9_9_9_REV_EXT, or UNSIGNED_INT_10F_11F_11F_REV_EXT
and the selected color buffer (or texture image for GetTexImage)
is a fixed-point buffer (or texture image for GetTexImage), each
component is first clamped to [0,1]."
| Dependencies on EXT_texture_shared_exponent |
If EXT_texture_shared_exponent is not supported, delete the reference
to UNSIGNED_INT_5_9_9_9_REV_EXT in section 4.3.2.
| Dependencies on EXT_framebuffer_object |
If EXT_framebuffer_object is not supported, then
RenderbufferStorageEXT is not supported and the R11F_G11F_B10F_EXT
internalformat is therefore not supported by RenderbufferStorageEXT.
If EXT_framebuffer_object is supported, glRenderbufferStorageEXT
accepts GL_RG11F_B10F_EXT for its internalformat parameter because
GL_RG11F_B10F_EXT has a base internal format of GL_RGB that is listed
as color-renderable by the EXT_framebuffer_object specification.
Relaxation of INVALID_ENUM errors
---------------------------------
TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D,
and RenderbufferStorageEXT accept the new R11F_G11F_B10F_EXT token
for internalformat.
DrawPixels, ReadPixels, TexImage1D, TexImage2D, GetTexImage,
TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D,
GetHistogram, GetMinmax, ConvolutionFilter1D, ConvolutionFilter2D,
ConvolutionFilter3D, GetConvolutionFilter, SeparableFilter2D,
GetSeparableFilter, ColorTable, ColorSubTable, and GetColorTable
accept the new UNSIGNED_INT_10F_11F_11F_REV_EXT token for type.
New errors
----------
INVALID_OPERATION is generated by DrawPixels, ReadPixels, TexImage1D,
TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, TexSubImage2D,
TexSubImage3D, GetHistogram, GetMinmax, ConvolutionFilter1D,
ConvolutionFilter2D, ConvolutionFilter3D, GetConvolutionFilter,
SeparableFilter2D, GetSeparableFilter, ColorTable, ColorSubTable,
and GetColorTable if <type> is UNSIGNED_INT_10F_11F_11F_REV_EXT and
<format> is not RGB.
In table 6.17, Textures (page 278), increment the 42 in "n x Z42*"
by 1 for the R11F_G11F_B10F_EXT format.
[NOTE: The OpenGL 2.0 specification actually should read "n x Z48*"
because of the 6 generic compressed internal formats in table 3.18.]
(modify table 6.33, p. 294)
Initial
Get Value Type Get Command Value Description Sec. Attribute
-------------------------- ---- ----------- ------- ------------------ ---- ----------
RGBA_SIGNED_COMPONENTS_EXT 4xB GetIntegerv - True if respective 4 -
R, G, B, and A
components are
signed
| New Implementation Dependent State |
None
1) What should this extension be called?
RESOLVED: EXT_packed_float
This extension provides a new 3-component packed float format
for use as a texture internal format, pixel external format,
and framebuffer color format.
"packed" indicates the extension is packing components
at reduced precisions (similar to EXT_packed_pixels or
NV_packed_depth_stencil).
EXT_r11f_g11f_b10f_float was considered but there's no precedent
for extension names to be so explicit (or cryptic?) about format
specifics in the extension name.
2) Should there be an rgb11f_b10f framebuffer format?
RESOLVED: Yes. Unsigned floating-point rendering formats for GLX
and WGL are provided. The assumption is that this functionality
could be used to advertise a pixel format with 11 bits of unsigned
floating-point red, 11 bits of unsigned floating-point green,
and 10 bits of floating-point blue.
In theory, an implementation could advertise other component sizes
other than 11/11/10 for an unsigned floating-point framebuffer
format but that is not expected.
3) Should there be GLX and WGL extension strings?
RESOLVED: Yes, there are WGL and GLX tokens added to
support querying unsigned floating-point color buffer
formats named WGL_EXT_pixel_format_packed_float and
GLX_EXT_fbconfig_packed_float respectively.
4) Should there be an unequal distribution of red, green, and blue
mantissa bits?
RESOLVED: Yes. A 6-bit mantissa for red and green is unbalanced
with the 5-bit mantissa for blue, but this allows all the bits of
a 32 bit word (6+6+5+3*5=32) to be used. The blue component is
chosen to have fewer bits because 1) it is the third component,
and 2) there's a belief that the human eye is less sensitive
to blue variations..
Developers should be aware that subtle yellowing or bluing
of gray-scale values is possible because of the extra bit of
mantissa in the red and green components.
5) Should there be an external format for r11f_g11f_b10f?
RESOLVED: Yes. This makes it fast to load GL_R11F_G11F_B10F_EXT
textures without any translation by the driver.
6) What is the exponent bias?
RESOLVED: 15, just like 16-bit half-precision floating-point
values.
7) Can s10e5 floating-point filtering be used to filter
r11f_g11f_b10f values? If so, how?
RESOLVED: Yes. It is easy to promote r11f_g11f_b10f values to
s10e5 components.
8) Should automatic mipmap generation be supported for r11f_g11f_b10f
textures?
RESOLVED: Yes.
9) Should non-texture and non-framebuffer commands for loading
pixel data accept the GL_UNSIGNED_INT_10F_11F_11F_REV_EXT type?
RESOLVED: Yes.
Once the pixel path has to support the new type/format combination
of GL_UNSIGNED_INT_5_9_9_9_REV_EXT / GL_RGB for specifying and
querying texture images, it might as well be supported for all
commands that pack and unpack RGB pixel data.
The specification is written such that the glDrawPixels
type/format parameters are accepted by glReadPixels,
glTexGetImage, glTexImage2D, and other commands that are specified
in terms of glDrawPixels.
10) Should non-texture internal formats (such as for color tables,
convolution kernels, histogram bins, and min/max tables) accept
GL_R11F_G11F_B10F_EXT format?
RESOLVED: No.
That's pointless. No hardware is ever likely to support
GL_R11F_G11F_B10F_EXT internal formats for anything other than
textures and maybe color buffers in the future. This format is
not interesting for color tables, convolution kernels, etc.
11) Should a format be supported with sign bits for each component?
RESOLVED: No. A sign bit for each of the three components would
steal too many bits from the mantissa. This format is intended
for storing radiance and irradiance values that are physically
non-negative.
12) Should we support a non-REV version of the
GL_UNSIGNED_INT_10F_11F_11F_REV_EXT token?
RESOLVED: No. We don't want to promote different arrangements
of the bitfields for r11f_g11f_b10f values.
13) Can you use the GL_UNSIGNED_INT_10F_11F_11F_REV_EXT format with
just any format?
RESOLVED: You can only use the
GL_UNSIGNED_INT_10F_11F_11F_REV_EXT format with GL_RGB.
Otherwise, the GL generates an GL_INVALID_OPERATION error.
Just as the GL_UNSIGNED_BYTE_3_3_2 format just works with GL_RGB
(or else the GL generates an GL_INVALID_OPERATION error), so
should GL_UNSIGNED_INT_10F_11F_11F_REV_EXT.
14) Should blending be supported for a packed float framebuffer
format?
RESOLVED: Yes. Blending is required for other floating-point
framebuffer formats introduced by ARB_color_buffer_float.
The equations for blending should be evaluated with signed
floating-point math but the result will have to be clamped to
non-negative values to be stored back into the packed float
format of the color buffer.
15) Should unsigned floating-point framebuffers be queried
differently from conventional (signed) floating-point
framebuffers?
RESOLVED: Yes. An existing application using
ARB_color_buffer_float can rightfully expect a floating-point
color buffer format to provide signed components. The packed
float format does not provide a sign bit. Simply treating packed
float color buffer formats as floating-point might break some
existing applications that depend on a float color buffer to be
signed.
For this reason, there are new WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT
(for WGL) and GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT (for GLX)
framebuffer format parameters.
16) What should glGet of GL_RGBA_FLOAT_MODE_ARB return for unsigned
float color buffer formats?
RESOLVED. GL_RGBA_FLOAT_MODE_ARB should return true. The packed
float components are unsigned but still floating-point.
17) Can you query with glGet to determine if the color buffer has
unsigned float components?
RESOLVED: Yes. Call glGetIntegerv
on GL_RGBA_SIGNED_COMPONENTS_EXT. The value returned is
a 4-element array. Element 0 corresponds to red, element 1
corresponds to green, element 2 corresponds to blue, and element
3 corresponds to alpha. If a color component is signed, its
corresponding element is true (GL_TRUE). This is the same way
the GL_COLOR_WRITEMASK bits are formatted.
For the packed float format, all the elements are zeroed since
the red, green, and blue components are unsigned and the alpha
component is non-existent. All elements are also zeroed for
conventional fixed-point color buffer formats. Elements are
set for signed floating-point formats such as those introduced
by ARB_color_buffer_float. If a component (such as alpha) has
zero bits, the component should not be considered signed and so
the bit for the respective component should be zeroed.
This generality allows a future extension to specify float
color buffer formats that had a mixture of signed and unsigned
floating-point components. However, this extension only provides
a packed float color format with all unsigned components.
18) How many bits of alpha should GL_ALPHA_BITS return for the packed
float color buffer format?
RESOLVED: Zero.
19) Can you render to a packed float texture with the
EXT_framebuffer_object functionality?
RESOLVED: Yes.
Potentially an implementation could return
GL_FRAMEBUFFER_UNSUPPORTED_EXT when glCheckFramebufferStatusEXT
for a framebuffer object including a packed float color buffer,
but implementations are likely to support (and strongly encouraged
to support) the packed float format for use with a framebuffer
object because the packed float format is expected to be a
memory-efficient floating-point color format well-suited for
rendering, particularly rendering involving high-dynamic range.
20) This extension is for a particular packed float format. What if
new packed float formats come along?
RESOLVED: A new extension could be introduced with a name like
EXT_packed_float2, but at this time, no other such extensions
are expected except for the EXT_texture_shared_exponent
extension. It simply hard to justify packing three or more
components into a single 32-bit word in lots of different ways
since any approach is going to be a compromise of some sort.
For two-component or one-component floating-point formats, the
existing ARB_texture_float formats fit nicely into 16 or 32 bits
by simply using half precision floating-point. If 64 bits are
allowed for a pixel, the GL_RGBA16F_ARB is a good choice.
The packed float format is similar to the format introduced by
the EXT_texture_shared_exponent extension, but that extension
is not a pure packed float format. Unlike the packed float
format, the EXT_texture_shared_exponent format shares a single
exponent between the RGB components rather than providing
an independent exponent for each component. Because the
EXT_texture_shared_exponent uses fewer bits to store exponent
values, more mantissa precision is provided.
21) Should this extension provide pbuffer support?
RESOLVED: Yes. Pbuffers are core GLX 1.3 functionality.
While using FBO is probably the preferred way to render to
r11f_g11f_b10f framebuffers but pbuffer support is natural
to provide. WGL should have r11f_g11f_b10f pbuffer support too.
22) Must an implementation support NaN, Infinity, and/or denorms?
RESOLVED: The preferred implementation is to support NaN,
Infinity, and denorms. Implementations are allowed to flush
denorms to zero, and treat NaN and Infinity values as large
finite values.
This allowance flushes denorms to zero:
0.0, if E == 0 and M != 0
This allowance treats Infinity as a finite value:
2^16 if E == 31 and M == 0
This allowance treats NaN encodings as finite values:
2^16 * (1 + M/64) if E == 31 and M != 0
The expectation is that mainstream GPUs will support NaN,
Infinity, and denorms while low-end implementations such as for
OpenGL ES 2.0 will likely support denorms but neither NaN nor
Infinity.
There is not an indication of how these floating-point special
values are treated (though an application could test an
implementation if necessary).
23) Should this extension interoperate with framebuffer objects?
RESOLVED: Definitely. No particular specification language is
required.
In particular, glRenderbufferStorageEXT should accept
GL_R11F_G11F_B10F_EXT for its internalformat parameter (true
because this extension adds a new format to Table 3.16).
24) Are negative color components clamped to zero when written into
an unsigned floating-point color buffer? If so, do we need to
say in the Blending or Dithering language that negative color
components are clamped to zero?
RESOLVED: Yes, negative color components are clamped to zero when
written to an unsigned floating-point color buffer. No specification
language is required for this behavior because the ARB_color_buffer_float
extension says
"In RGBA mode dithering selects, for each color component, either
the most positive representable color value (for that particular
color component) that is less than or equal to the incoming
color component value, c, or the most negative representable
color value that is greater than or equal to c.
If dithering is disabled, then each incoming color component
c is replaced with the most positive representable color value
(for that particular component) that is less than or equal to c,
or by the most negative representable value, if no representable
value is less than or equal to c;"
The most negative representable value for unsigned
floating-point values is zero. So the existing language from
ARB_color_buffer_float already indicates that negative values
are clamped to zero for unsigned floating-point color buffers.
No additional specification language is required.
25) Prior texture internal formats have generic formats (example:
GL_RGB) and corresponding sized formats (GL_RGB8, GL_RGB10,
etc.). Should we add a generic format corresponding to
GL_R11F_G11F_B10F_EXT?
RESOLVED: No. It's unlikely there will be any other unsigned
floating-point texture formats.
None
None
 |  | Last update: November 14, 2006.
Cette page doit être lue avec un navigateur récent respectant le standard XHTML 1.1.
|
