Back to the OpenGL extension cross reference
GL_OES_fixed_point
Name
OES_fixed_point
Name Strings
GL_OES_fixed_point
Contact
David Blythe (blythe 'at' bluevoid.com)
Status
Ratified by the Khronos BOP, July 23, 2003.
Version
Last Modifed Date: 12 July 2003
Author Revision: 0.7
Number
292
Dependencies
None
The extension is written against the OpenGL 1.3 Specification.
Overview
This extension provides the capability, for platforms that do
not have efficient floating-point support, to input data in a
fixed-point format, i.e., a scaled-integer format. There are
several ways a platform could try to solve the problem, such as
using integer only commands, but there are many OpenGL commands
that have only floating-point or double-precision floating-point
parameters. Also, it is likely that any credible application
running on such a platform will need to perform some computations
and will already be using some form of fixed-point representation.
This extension solves the problem by adding new ``fixed', and
``clamp fixed'' data types based on a a two's complement
S15.16 representation. New versions of commands are created
with an 'x' suffix that take fixed or clampx parameters.
IP Status
None
Issues
* Add double-precision (S31.32) form too?
NO
* Additional InterleavedArray formats?
NO
* Should newly suffixed commands, e.g., PointSize, get an alias with
a float or double suffix for consistency?
NO
* Are enums converted to fixed by scaling by 2^16.
NO. An enums are passed through as if they are already in
S15.16 form. Requiring scaling is too error prone.
NOTE: `T' expands to 'const fixed*' or `fixed' as appropriate
void Vertex{234}x[v]OES(T coords);
void Normal3x[v]OES(T coords);
void TexCoord{1234}x[v]OES(T coords);
void MultiTexCoord{1234}x[v]OES(enum texture, T coords);
void Color{34}x[v]OES(T components);
void Indexx[v]OES(T component);
void RectxOES(fixed x1, fixed y1, fixed x2, fixed y2);
void RectxvOES(const fixed v1[2], const fixed v2[2]);
void DepthRangexOES(clampx n, clampx f);
void LoadMatrixxOES(const fixed m[16]);
void MultMatrixxOES(const fixed m[16]);
void LoadTransposeMatrixxOES(const fixed m[16]);
void MultTransposeMatrixxOES(const fixed m[16]);
void RotatexOES(fixed angle, fixed x, fixed y, fixed z);
void ScalexOES(fixed x, fixed y, fixed z);
void TranslatexOES(fixed x, fixed y, fixed z);
void FrustumxOES(fixed l, fixed r, fixed b, fixed t, fixed n, fixed f);
void OrthoxOES(fixed l, fixed r, fixed b, fixed t, fixed n, fixed f);
void TexGenx[v]OES(enum coord, enum pname, T param);
void GetTexGenxvOES(enum coord, enum pname, T* params);
void ClipPlanexOES(enum plane, const fixed* equation);
void GetClipPlanexOES(enum plane, fixed* equation);
void RasterPos{234}x[v]OES(T coords);
void Materialx[v]OES(enum face, enum pname, T param);
void GetMaterialxOES(enum face, enum pname, T param);
void Lightx[v]OES(enum light, enum pname, T* params);
void GetLightxOES(enum light, enum pname, T* params);
void LightModelx[v]OES(enum pname, T param);
void PointSizexOES(fixed size);
void LineWidthxOES(fixed width);
void PolygonOffsetxOES(fixed factor, fixed units);
void PixelStorex{enum pname, T param);
void PixelTransferxOES(enum pname, T param);
void PixelMapx{enum map int size T* values);
void GetPixelMapxv{enum map int size T* values);
void ConvolutionParameterx[v]OES(enum target, enum pname, T param);
void GetConvolutionParameterxvOES(enum target, enum pname, T* params);
void GetHistogramParameterxvOES(enum target, enum pname, T *params);
void PixelZoomxOES(fixed xfactor, fixed yfactor);
void BitmapxOES(sizei width, sizei height, fixed xorig, fixed yorig,
fixed xmove, fixed ymove, const ubyte* bitmap);
void TexParameterx[v]OES(enum target, enum pname, T param);
void GetTexParameterxvOES(enum target, enum pname, T* params);
void GetTexLevelParameterxvOES(enum target, int level, enum pname, T* params);
void PrioritizeTexturesxOES(sizei n, uint* textures, clampx* priorities);
void TexEnvx[v]OES(enum target, enum pname, T param);
void GetTexEnvxvOES(enum target, enum pname, T* params);
void Fogx[v]OES(enum pname, T param);
void SampleCoverageOES(clampx value, boolean invert);
void AlphaFuncxOES(enum func, clampx ref);
void BlendColorxOES(clampx red, clampx green, clampx blue, clampx alpha);
void ClearColorxOES(clampx red, clampx green, clampx blue, clampx alpha);
void ClearDepthxOES(clampx depth);
void ClearAccumxOES(clampx red, clampx green, clampx blue, clampx alpha);
void AccumxOES(enum op, fixed value);
void Map1xOES(enum target, T u1, T u2, int stride, int order, T points);
void Map2xOES(enum target, T u1, T u2, int ustride, int uorder,
T v1, T v2, int vstride, int vorder, T points);
void MapGrid1xOES(int n, T u1, T u2);
void MapGrid2xOES(int n, T u1, T u2, T v1, T v2);
void GetMapxvOES(enum target, enum query, T* v);
void EvalCoord{12}x[v]OES(T coord);
void FeedbackBufferxOES(sizei n, enum type, fixed* buffer);
void PassThroughxOES(fixed token);
GetFixedvOES(enum pname, fixed* params);
FIXED_OES 0x140C
Additions to Chapter 2 of the OpenGL 1.3 Specification (OpenGL Operation)
Section 2.1.1 Floating-Point Computation
Add the following paragraphs:
On some platforms, floating-point computations are not sufficiently
well supported to be used in an OpenGL implementation. On such
platforms, fixed-point representations may be a viable substitute for
floating-point. Internal computations can use either fixed-point
or floating-point arithmetic. Fixed-point computations must be
accurate to within +/-2^-15. The maximum representable magnitude
for a fixed-point number used to represent positional or normal
coordinates must be at least 2^15; the maximum representable
magnitude for colors or texture coordinates must be at least 2^10.
The maximum representable magnitude for all other fixed-point
values must be at least 2^15. x*0 = 0*x = 0. 1*x = x*1 = x. x +
0 = 0 + x = x. 0^0 = 1. Fixed-point computations may lead to
overflows or underflows. The results of such computations are
undefined, but must not lead to GL interruption or termination.
Section 2.3 GL Command Syntax
Paragraph 3 is updated to include the 'x' suffix and
Table 2.1 is modified to include the row:
---------------
| x | fixed |
---------------
Table 2.2 is modified to include the rows:
--------------------------------------------------------------
| fixed | 32 | signed 2's complement S15.16 scaled integer|
--------------------------------------------------------------
| clampx | 32 | S15.16 scaled integer clamped to [0, 1] |
--------------------------------------------------------------
and the count of the number of rows in the text is changed to 16.
Add paragraph
The mapping of GL data types to data types of a specific
language binding are part of the language binding definition and
may be platform-dependent. Type conversion and type promotion
behavior when mixing actual and formal arguments of different
data types are specific to the language binding and platform.
For example, the C language includes automatic conversion
between integer and floating-point data types, but does not
include automatic conversion between the int and fixed or
float and fixed GL types since the fixed data type is not a
distinct built-in type. Regardless of language binding,
the enum type converts to fixed-point without scaling and
integer types are converted by multiplying by 2^16.
Section 2.7 Vertex Specification
Commands are revised to included 'x' suffix.
Section 2.8 Vertex Arrays
Table 2.4 Vertex Array Sizes is revised to include the 'fixed' type
for all commands except EdgeFlagPointer.
References to Vertex command suffixes are revised to include 'x'.
Section 2.9 Rectangles
Revise to include 'x' suffix.
Section 2.10 Coordinate Transformations
Revise to include 'x' suffix. Section 2.10.1 describes clampx.
Add alternate suffixed versions of Ortho and Frustum.
Section 2.11 Clipping
Add alternate suffixed version of ClipPlane.
Section 2.12 Current Raster Position
Revise to include 'x' suffix.
Section 2.13 Colors and Coloring
Revise to include 'x' suffix and
Table 2.6 is modified to include row:
---------------
| fixed | c |
---------------
Additions to Chapter 3 of the OpenGL 1.3 Specification (Rasterization)
Section 3.3 Points
Add alternate suffixed PointSize command.
Section 3.4 Line Segments
Add alternate suffixed LineWidth command.
Section 3.5 Polygons
Add alternate suffixed PolygonOffset command.
Section 3.6 Pixel Rectangles
Revise to include 'x' suffix on PixelStore, PixelTransfer, PixelMap,
ConvolutionParameter.
Table 3.5 is modified to include row:
----------------------
| FIXED | fixed | No |
----------------------
Add alternate suffixed PixelZoom to Section 3.6.5
Section 3.7 Bitmaps
Add alternate suffixed Bitmap command.
Section 3.8 Texturing
Revise to include 'x' suffix in TexParameter (Section 3.8.4).
Add alternate suffixed PrioritizeTextures command (Section 3.8.11).
Revise to include 'x' suffix in TexEnv (Section 3.8.12).
Section 3.10 Fog
Revise to include ;x; suffix in Fog command.
Additions to Chapter 4 of the OpenGL 1.3 Specification (Per-Fragment
Operations and the Frame Buffer)
Section 4.1 Fragment Operations
Add alternate suffixed SampleCoverage command (Section 4.1.3),
AlphaFunc command (Section 4.1.4), BlendColor command (Section 4.1.7).
Section 4.2 Whole Framebuffer Operations
Add alternate suffixed ClearColor, ClearDepth, and ClearAccum commands
(Section 4.2.3).
Add alternate suffixed Accum command (Section 4.2.4).
Additions to Chapter 5 of the OpenGL 1.3 Specification (Special Functions)
Section 5.1 Evaluators
Revise to include 'x' suffix on Map1, Map2, Map1Grid, and Map2Grid
commands.
Section 5.3 Feedback
Add alternate suffixed FeedbackBuffer and PassThrough commands.
Revise Figure 5.2 to indicate 'f' values may also be 'x' values.
Additions to Chapter 6 of the OpenGL 1.3 Specification (State and
State Requests)
Add GetFixedv to Section 6.1.1. Revise Section 6.1.2 to
include implied conversions for GetFixedv.
Revise to include 'x' suffix for GetClipPlane, GetLightm GetMaterial,
GetTexEnv, GetTexGen, GetTexParameter, GetTexLevelParameter,
GetPixelMap, and GetMap in Section 6.1.3.
Revise to include 'x' suffix for GetHistogramParameter (Section 6.1.9).
Section 6.2 State Tables
Revise intro paragraph to include GetFixedv.
Additions to Appendix A of the OpenGL 1.3 Specification (Invariance)
None
Additions to the AGL/GLX/WGL Specifications
None
Additions to the WGL Specification
None
Additions to the AGL Specification
None
Additions to Chapter 2 of the GLX 1.3 Specification (GLX Operation)
The data representation is client-side only. The GLX layer
performs translation between fixed and float representations.
Additions to Chapter 3 of the GLX 1.3 Specification (Functions and Errors)
Additions to Chapter 4 of the GLX 1.3 Specification (Encoding on the X
Byte Stream)
Additions to Chapter 5 of the GLX 1.3 Specification (Extending OpenGL)
Additions to Chapter 6 of the GLX 1.3 Specification (GLX Versions)
GLX Protocol
Fixed type entry points are mapped on the client-side to the
appropriate floating-point command protocol. To preserve precision,
double-precision protocol is encouraged, but not required.
Errors
None
New State
None
New Implementation Dependent State
None
Revision History
12/15/2002 0.1
- Original draft.
03/31/2003 0.2
- Corrected a typo in GetClipPlanex and FIXED_OES.
04/24/2003 0.3
- Added clarification that enums must be converted to fixed
by scaling when passed in a fixed parameter type. Corrected
some typos.
05/29/2003 0.4
- Changed enums to be passed unscaled when passed to a
fixed formal parameter.
07/08/2003 0.5
- Removed bogus Dependencies on section
- Added extension number and enumerant value
07/11/2003 0.6
- Added OES suffixes
07/12/2003 0.7
- Added note about GLX protocol
Implementation Support
List of OpenGL implementations supporting the GL_OES_fixed_point extension
Original File
Original text file for the GL_OES_fixed_point extension
Page generated on Sun Nov 20 18:40:42 2005