Back to the OpenGL extension cross reference
GL_INTEL_parallel_arrays
INTEL_parallel_arrays
Name Strings
GL_INTEL_parallel_arrays
Version
$Date: 1997/05/08 22:57:31 $ $Revision: 1.1 $ INITIAL
Number
136
Dependencies
OpenGL 1.1
Overview
This extension adds the ability to format vertex arrays in a way that's
efficient for SIMD architectures as well as caching. In addition to storing
vertex data in staggered in a single array, or sparsely in separate arrays as
possible with existing vertex arrays, coordinates may be stored in individual
arrays.
The parallel array mode is enabled using Enable(PARALLEL_ARRAYS).
Pointers to the coordinate arrays are specified using new vector versions of the
Pointer functions.
Issues
Should an Enable/Disbale be used to switch to/from parallel arrays, or
just infer it from the last type of Pointer called?
Is stride needed for anything?
Should this be called Coordinate Arrays?
Should the <pointer> to the Pointerv funcions be (void *) or (void **)?
Reasoning
Alternative methods for specifying vertex data are provided for
vertex, normal, color, and texture pointers. Need to put in argument
for why this is faster on some architectures (cache lines, etc).
void VertexPointervINTEL(int size,
enum type,
const void** pointer);
void NormalPointervINTEL(enum type,
const void** pointer);
void ColorPointervINTEL(int size,
enum type,
const void** pointer);
void TexCoordPointervINTEL(int size,
enum type,
const void** pointer);
Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, and
by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and
GetDoublev:
PARALLEL_ARRAYS_INTEL 0x83F4
Accepted by the <pname> parameter of GetPointerv:
VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5
NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6
COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7
TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8
Additions to Chapter 2 of the 1.1 Specification (OpenGL Operation)
Array Specification
-------------------
VertexPointervINTEL specifies the location and data format of an
array of vertex coordinates. <pointer> specifies an array of pointers,
where pointer[0] is a pointer to the x coordinate of the first vertex in the
array, pointer[1] specifies a pointer to the y coordinate of the first
vertex in the array, pointer[2] specifies a pointer to the z coordinate of
the first vertex in the array, and pointer[3] specifies a pointer to the w
coordinate of the first vertex in the array.
<type> specifies the data type of each coordinate in the array, and must be
one of SHORT, INT, FLOAT, or DOUBLE, implying GL data types short, int,
float, and double respectively. <size> specifies the number of coordinates
per vertex, and must be 2, 3, or 4.
NormalPointervINTEL specifies the location and data format of an
array of normals. <pointer> specifies an array of pointers, where
pointer[0] is a pointer to the x coordinate of the first normal in the
array, pointer[1] specifies a pointer to the y coordinate of the first
normal in the array, pointer[2] specifies a pointer to the z coordinate of
the first normal in the array, and pointer[3] specifies a pointer to the w
coordinate of the first normal in the array. <type> specifies the
data type of each coordinate in the array, and must be one of BYTE, SHORT,
INT, FLOAT, or DOUBLE, implying GL data types byte, short, int, float,
and double respectively. It is understood that each normal comprises
three coordinates.
ColorPointervINTEL specifies the location and data format of an
array of color components. <pointer> specifies an array of pointers,
where pointer[0] is a pointer to the r coordinate of the first color in the
array, pointer[1] specifies a pointer to the g coordinate of the first
color in the array, pointer[2] specifies a pointer to the b coordinate of
the first color in the array, and pointer[3] specifies a pointer to the a
coordinate of the first color in the array. <type> specifies the data type
of each component in the array, and must be one of BYTE, UNSIGNED_BYTE,
SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT, or DOUBLE_EXT, implying GL
data types byte, ubyte, short, ushort, int, uint, float, and double
respectively. <size> specifies the number of components per color, and must
be 3 or 4.
TexCoordPointervINTEL specifies the location and data format of an
array of texture coordinates. <pointer> specifies an array of pointers,
where pointer[0] is a pointer to the u coordinate of the first element in
the array, pointer[1] specifies a pointer to the v coordinate of the first
element in the array, pointer[2] specifies a pointer to the s coordinate of
the first element in the array, and pointer[3] specifies a pointer to the t
coordinate of the first element in the array. <type> specifies the data
type of each coordinate in the array, and must be one of SHORT, INT, FLOAT,
or DOUBLE, implying GL data types short, int, float, and double
respectively. <size> specifies the number of coordinates per element, and
must be 1, 2, 3, or 4.
Rendering the Arrays
--------------------
When ArrayElement is called, a single vertex is drawn, using vertex
and attribute data taken from location <i> of the enabled arrays. The
semantics of ArrayElement are defined in the C-code below:
void ArrayElement (int i) {
byte* p, px, py, pz, pw, pr, pg, pb, pa;
if (NORMAL_ARRAY) {
if (PARALLEL_ARRAYS) {
px = (byte*)normal_x_pointer + i * sizeof(normal_type);
py = (byte*)normal_y_pointer + i * sizeof(normal_type);
pz = (byte*)normal_z_pointer + i * sizeof(normal_type);
Normal3<normal_type> (*(normal_type*)px, *(normal_type*)py,
*(normal_type*)pz);
} else {
if (normal_stride == 0)
p = (byte*)normal_pointer + i * 3 *
sizeof(normal_type);
else
p = (byte*)normal_pointer + i * normal_stride;
Normal3<normal_type>v ((normal_type*)p);
}
}
if (COLOR_ARRAY) {
if (PARALLEL_ARRAYS) {
pr = (byte*)color_r_pointer + i * sizeof(color_type);
pg = (byte*)color_g_pointer + i * sizeof(color_type);
pb = (byte*)color_b_pointer + i * sizeof(color_type);
switch (<color_size>){
case 3:
Color<color_size><color_type> (*(color_type*)pr,
*(color_type*)pg, *(color_type*)pb); break;
case 4:
pa = (byte*)color_a_pointer + i *
sizeof(color_type);
Color<color_size><color_type> (*(color_type*)pr,
*(color_type*)pg, *(color_type*)pb,
*(color_type*)pa); break;
}
} else {
if (color_stride == 0)
p = (byte*)color_pointer +
i * color_size * sizeof(color_type);
else
p = (byte*)color_pointer + i * color_stride;
Color<color_size><color_type>v ((color_type*)p);
}
}
if (INDEX_ARRAY) {
if (index_stride == 0)
p = (byte*)index_pointer + i * sizeof(index_type);
else
p = (byte*)index_pointer + i * index_stride;
Index<index_type>v ((index_type*)p);
}
if (TEXTURE_COORD_ARRAY_EXT) {
if (PARALLEL_ARRAYS) {
pu = (byte*)texcoord_u_pointer + i * sizeof(texcoord_type);
switch (<texcoord_size>){
case 1:
TexCoord<texcoord_size><texcoord_type>
(*(texcoord_type*)pu); break;
case 2:
pv = (byte*)texcoord_v_pointer + i *
sizeof(texcoord_type);
TexCoord<texcoord_size><texcoord_type>
(*(texcoord_type*)pu, *(texcoord_type*)pv);
break;
case 3:
ps = (byte*)texcoord_s_pointer + i *
sizeof(texcoord_type);
TexCoord<texcoord_size><texcoord_type>
(*(texcoord_type*)pu, *(texcoord_type*)pv,
*(texcoord_type*)ps); break;
case 4:
pt = (byte*)texcoord_t_pointer + i *
sizeof(texcoord_type);
TexCoord<texcoord_size><texcoord_type>
(*(texcoord_type*)pu, *(texcoord_type*)pv,
*(texcoord_type*)ps, *(texcoord_type*)pt);
break;
}
} else {
if (texcoord_stride == 0)
p = (byte*)texcoord_pointer +
i * texcoord_size * sizeof(texcoord_type);
else
p = (byte*)texcoord_pointer + i * texcoord_stride;
TexCoord<texcoord_size><texcoord_type>v
((texcoord_type*)p);
}
}
if (EDGE_FLAG_ARRAY) {
if (edgeflag_stride == 0)
p = (byte*)edgeflag_pointer + i * sizeof(boolean);
else
p = (byte*)edgeflag_pointer + i * edgeflag_stride;
EdgeFlagv ((boolean*)p);
}
if (VERTEX_ARRAY) {
if (PARALLEL_ARRAYS) {
px = (byte*)vertex_x_pointer + i * sizeof(vertex_type);
py = (byte*)vertex_y_pointer + i * sizeof(vertex_type);
Normal3<normal_type> ((normal_type*)px, (normal_type*)py,
(normal_type*)pz);
switch (<vertex_size>){
case 2:
Vertex<vertex_size><vertex_type> (*(vertex_type*)px,
*(vertex_type*)py);
case 3:
pz = (byte*)vertex_z_pointer + i *
sizeof(vertex_type);
Vertex<vertex_size><vertex_type> (*(vertex_type*)px,
*(vertex_type*)py, *(vertex_type*)pz);
case 4:
pw = (byte*)vertex_w_pointer + i *
sizeof(vertex_type);
Vertex<vertex_size><vertex_type> (*(vertex_type*)px,
*(vertex_type*)py, *(vertex_type*)pz,
*(vertex_type*)pw);
}
} else {
if (vertex_stride == 0)
p = (byte*)vertex_pointer +
i * vertex_size * sizeof(vertex_type);
else
p = (byte*)vertex_pointer + i * vertex_stride;
Vertex<vertex_size><vertex_type>v ((vertex_type*)p);
}
}
}
Additions to Chapter 3 of the 1.0 Specification (Rasterization)
None
Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations
and the Frame buffer)
None
Additions to Chapter 5 of the 1.0 Specification (Special Functions)
Array specification commands VertexParallelPointerINTEL,
NormalParallelPointerINTEL, ColorParallelPointerINTEL, and
TexCoordParallelPointerINTEL specify client side state, and are therefore
not included in display lists. Likewise Enable and Disable, when
called with <cap> set to PARALLEL_ARRAYS_INTEL, are not included in display
lists.
Additions to Chapter 6 of the 1.0 Specification (State and State Requests)
GetPointerv returns in <param> the array pointer value specified
by <pname>. GetPointerv additional accepts the following values for <pname>
VERTEX_ARRAY_PARALLEL_POINTERS_INTEL, NORMAL_ARRAY_PARALLEL_POINTERS_INTEL,
COLOR_ARRAY_PARALLEL_POINTERS_INTEL,
TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL.
In this case, <param> will return an array of pointers.
Additions to the GLX Specification
None
GLX Protocol
None
Errors
INVALID_VALUE is generated if VertexPointervINTEL parameter <size>
is not 2, 3, or 4.
INVALID_ENUM is generated if VertexPointervINTEL parameter <type>
is not SHORT, INT, FLOAT, or DOUBLE.
INVALID_ENUM is generated if NormalPointervINTEL parameter <type> is
not BYTE, SHORT, INT, FLOAT, or DOUBLE.
INVALID_VALUE is generated if ColorPointervINTEL parameter <size> is
not 3 or 4.
INVALID_ENUM is generated if ColorPointervINTEL parameter <type> is
not BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT,
or DOUBLE.
INVALID_VALUE is generated if TexCoordPointervINTEL parameter <size>
is not 1, 2, 3, or 4.
INVALID_ENUM is generated if TexCoordPointervINTEL parameter <type> is not
SHORT, INT, FLOAT, or DOUBLE.
INVALID_ENUM is generated if GetPointerv parameter <pname> is not
VERTEX_ARRAY_POINTER, NORMAL_ARRAY_POINTER,
COLOR_ARRAY_POINTER, INDEX_ARRAY_POINTER,
TEXTURE_COORD_ARRAY_POINTER, EDGE_FLAG_ARRAY_POINTER, or
VERTEX_ARRAY_PARALLEL_POINTERS_INTEL, NORMAL_ARRAY_PARALLEL_POINTERS_INTEL,
COLOR_ARRAY_PARALLEL_POINTERS_INTEL,
TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL
New State
Initial
Get Value Get Command Type Value Attrib
--------- ----------- ---- ------- ------
PARALLEL_ARRAYS_INTEL IsEnabled B False client
VERTEX_ARRAY_PARRALEL_POINTERS_INTEL GetPointerv Z+ 0 client
NORMAL_ARRAY_PARALLEL_POINTERS_INTEL GetPointerv Z+ 0 client
COLOR_ARRAY_PARALLEL_POINTERS_INTEL GetPointervEXT Z+ 0 client
TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL GetPointerv Z+ 0 client
New Implementation Dependent State
None
Implementation Support
List of OpenGL implementations supporting the GL_INTEL_parallel_arrays extension
Original File
Original text file for the GL_INTEL_parallel_arrays extension
Page generated on Sun Nov 20 18:38:58 2005