Name 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 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). New Procedures and Functions 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); New Tokens Accepted by the parameter of Enable, Disable, and IsEnabled, and by the parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev: PARALLEL_ARRAYS_INTEL 0x83F4 Accepted by the 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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 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*)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; Normal3v ((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 (){ case 3: Color (*(color_type*)pr, *(color_type*)pg, *(color_type*)pb); break; case 4: pa = (byte*)color_a_pointer + i * sizeof(color_type); Color (*(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; Colorv ((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; Indexv ((index_type*)p); } if (TEXTURE_COORD_ARRAY_EXT) { if (PARALLEL_ARRAYS) { pu = (byte*)texcoord_u_pointer + i * sizeof(texcoord_type); switch (){ case 1: TexCoord (*(texcoord_type*)pu); break; case 2: pv = (byte*)texcoord_v_pointer + i * sizeof(texcoord_type); TexCoord (*(texcoord_type*)pu, *(texcoord_type*)pv); break; case 3: ps = (byte*)texcoord_s_pointer + i * sizeof(texcoord_type); TexCoord (*(texcoord_type*)pu, *(texcoord_type*)pv, *(texcoord_type*)ps); break; case 4: pt = (byte*)texcoord_t_pointer + i * sizeof(texcoord_type); TexCoord (*(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; TexCoordv ((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*)px, (normal_type*)py, (normal_type*)pz); switch (){ case 2: Vertex (*(vertex_type*)px, *(vertex_type*)py); case 3: pz = (byte*)vertex_z_pointer + i * sizeof(vertex_type); Vertex (*(vertex_type*)px, *(vertex_type*)py, *(vertex_type*)pz); case 4: pw = (byte*)vertex_w_pointer + i * sizeof(vertex_type); Vertex (*(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; Vertexv ((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 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 the array pointer value specified by . GetPointerv additional accepts the following values for VERTEX_ARRAY_PARALLEL_POINTERS_INTEL, NORMAL_ARRAY_PARALLEL_POINTERS_INTEL, COLOR_ARRAY_PARALLEL_POINTERS_INTEL, TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL. In this case, will return an array of pointers. Additions to the GLX Specification None GLX Protocol None Errors INVALID_VALUE is generated if VertexPointervINTEL parameter is not 2, 3, or 4. INVALID_ENUM is generated if VertexPointervINTEL parameter is not SHORT, INT, FLOAT, or DOUBLE. INVALID_ENUM is generated if NormalPointervINTEL parameter is not BYTE, SHORT, INT, FLOAT, or DOUBLE. INVALID_VALUE is generated if ColorPointervINTEL parameter is not 3 or 4. INVALID_ENUM is generated if ColorPointervINTEL parameter is not BYTE, UNSIGNED_BYTE, SHORT, UNSIGNED_SHORT, INT, UNSIGNED_INT, FLOAT, or DOUBLE. INVALID_VALUE is generated if TexCoordPointervINTEL parameter is not 1, 2, 3, or 4. INVALID_ENUM is generated if TexCoordPointervINTEL parameter is not SHORT, INT, FLOAT, or DOUBLE. INVALID_ENUM is generated if GetPointerv parameter 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