2008-10-11 13:27:07 +01:00
|
|
|
/* -*- mode: c; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 3; coding: utf-8-unix -*- */
|
2005-02-22 22:36:31 +00:00
|
|
|
/*
|
|
|
|
* (C) Copyright IBM Corporation 2004, 2005
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sub license,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* IBM,
|
|
|
|
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
|
|
|
|
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
* SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
2005-02-28 19:37:10 +00:00
|
|
|
#include "glxclient.h"
|
|
|
|
#include "indirect.h"
|
2005-02-22 22:36:31 +00:00
|
|
|
#include <GL/glxproto.h>
|
|
|
|
#include "glxextensions.h"
|
|
|
|
#include "indirect_vertex_array.h"
|
2008-04-18 15:28:53 +01:00
|
|
|
#include "indirect_vertex_array_priv.h"
|
2005-02-22 22:36:31 +00:00
|
|
|
|
2005-02-28 19:37:10 +00:00
|
|
|
#define __GLX_PAD(n) (((n)+3) & ~3)
|
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
/**
|
|
|
|
* \file indirect_vertex_array.c
|
|
|
|
* Implement GLX protocol for vertex arrays and vertex buffer objects.
|
|
|
|
*
|
|
|
|
* The most important function in this fill is \c fill_array_info_cache.
|
|
|
|
* The \c array_state_vector contains a cache of the ARRAY_INFO data sent
|
|
|
|
* in the DrawArrays protocol. Certain operations, such as enabling or
|
|
|
|
* disabling an array, can invalidate this cache. \c fill_array_info_cache
|
|
|
|
* fills-in this data. Additionally, it examines the enabled state and
|
|
|
|
* other factors to determine what "version" of DrawArrays protocoal can be
|
|
|
|
* used.
|
|
|
|
*
|
|
|
|
* Current, only two versions of DrawArrays protocol are implemented. The
|
|
|
|
* first version is the "none" protocol. This is the fallback when the
|
|
|
|
* server does not support GL 1.1 / EXT_vertex_arrays. It is implemented
|
|
|
|
* by sending batches of immediate mode commands that are equivalent to the
|
|
|
|
* DrawArrays protocol.
|
|
|
|
*
|
|
|
|
* The other protocol that is currently implemented is the "old" protocol.
|
|
|
|
* This is the GL 1.1 DrawArrays protocol. The only difference between GL
|
|
|
|
* 1.1 and EXT_vertex_arrays is the opcode used for the DrawArrays command.
|
|
|
|
* This protocol is called "old" because the ARB is in the process of
|
|
|
|
* defining a new protocol, which will probably be called wither "new" or
|
|
|
|
* "vbo", to support multiple texture coordinate arrays, generic attributes,
|
|
|
|
* and vertex buffer objects.
|
|
|
|
*
|
2008-07-15 19:06:31 +01:00
|
|
|
* \author Ian Romanick <ian.d.romanick@intel.com>
|
2005-02-22 22:36:31 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static void emit_DrawArrays_none( GLenum mode, GLint first, GLsizei count );
|
|
|
|
static void emit_DrawArrays_old ( GLenum mode, GLint first, GLsizei count );
|
|
|
|
|
|
|
|
static void emit_DrawElements_none( GLenum mode, GLsizei count, GLenum type,
|
|
|
|
const GLvoid *indices );
|
|
|
|
static void emit_DrawElements_old ( GLenum mode, GLsizei count, GLenum type,
|
|
|
|
const GLvoid *indices );
|
|
|
|
|
|
|
|
|
|
|
|
static GLubyte * emit_element_none( GLubyte * dst,
|
|
|
|
const struct array_state_vector * arrays, unsigned index );
|
|
|
|
static GLubyte * emit_element_old( GLubyte * dst,
|
|
|
|
const struct array_state_vector * arrays, unsigned index );
|
|
|
|
static struct array_state * get_array_entry(
|
|
|
|
const struct array_state_vector * arrays, GLenum key, unsigned index );
|
|
|
|
static void fill_array_info_cache( struct array_state_vector * arrays );
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
static GLboolean validate_mode(__GLXcontext *gc, GLenum mode);
|
|
|
|
static GLboolean validate_count(__GLXcontext *gc, GLsizei count);
|
2005-02-28 19:37:10 +00:00
|
|
|
static GLboolean validate_type(__GLXcontext *gc, GLenum type);
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Table of sizes, in bytes, of a GL types. All of the type enums are be in
|
|
|
|
* the range 0x1400 - 0x140F. That includes types added by extensions (i.e.,
|
|
|
|
* \c GL_HALF_FLOAT_NV). This elements of this table correspond to the
|
|
|
|
* type enums masked with 0x0f.
|
|
|
|
*
|
|
|
|
* \notes
|
|
|
|
* \c GL_HALF_FLOAT_NV is not included. Neither are \c GL_2_BYTES,
|
|
|
|
* \c GL_3_BYTES, or \c GL_4_BYTES.
|
|
|
|
*/
|
|
|
|
const GLuint __glXTypeSize_table[16] = {
|
|
|
|
1, 1, 2, 2, 4, 4, 4, 0, 0, 0, 8, 0, 0, 0, 0, 0
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-08-20 22:18:38 +01:00
|
|
|
/**
|
|
|
|
* Free the per-context array state that was allocated with
|
|
|
|
* __glXInitVertexArrayState().
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
__glXFreeVertexArrayState( __GLXcontext * gc )
|
|
|
|
{
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector* arrays = state->array_state;
|
|
|
|
|
|
|
|
if (arrays) {
|
|
|
|
if (arrays->stack) {
|
|
|
|
free(arrays->stack);
|
|
|
|
arrays->stack = NULL;
|
|
|
|
}
|
|
|
|
if (arrays->arrays) {
|
|
|
|
free(arrays->arrays);
|
|
|
|
arrays->arrays = NULL;
|
|
|
|
}
|
|
|
|
free(arrays);
|
|
|
|
state->array_state = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize vertex array state of a GLX context.
|
|
|
|
*
|
|
|
|
* \param gc GLX context whose vertex array state is to be initialized.
|
|
|
|
*
|
|
|
|
* \warning
|
|
|
|
* This function may only be called after __GLXcontext::gl_extension_bits,
|
|
|
|
* __GLXcontext::server_minor, and __GLXcontext::server_major have been
|
|
|
|
* initialized. These values are used to determine what vertex arrays are
|
|
|
|
* supported.
|
|
|
|
*
|
|
|
|
* \bug
|
|
|
|
* Return values from malloc are not properly tested.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
__glXInitVertexArrayState( __GLXcontext * gc )
|
|
|
|
{
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays;
|
|
|
|
|
|
|
|
unsigned array_count;
|
2006-11-02 23:58:27 +00:00
|
|
|
int texture_units = 1, vertex_program_attribs = 0;
|
|
|
|
unsigned i, j;
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
GLboolean got_fog = GL_FALSE;
|
|
|
|
GLboolean got_secondary_color = GL_FALSE;
|
|
|
|
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
arrays = calloc( 1, sizeof( struct array_state_vector ) );
|
2005-02-22 22:36:31 +00:00
|
|
|
state->array_state = arrays;
|
|
|
|
|
|
|
|
arrays->old_DrawArrays_possible = !state->NoDrawArraysProtocol;
|
|
|
|
arrays->new_DrawArrays_possible = GL_FALSE;
|
|
|
|
arrays->DrawArrays = NULL;
|
|
|
|
|
|
|
|
arrays->active_texture_unit = 0;
|
|
|
|
|
|
|
|
|
|
|
|
/* Determine how many arrays are actually needed. Only arrays that
|
|
|
|
* are supported by the server are create. For example, if the server
|
|
|
|
* supports only 2 texture units, then only 2 texture coordinate arrays
|
|
|
|
* are created.
|
|
|
|
*
|
|
|
|
* At the very least, GL_VERTEX_ARRAY, GL_NORMAL_ARRAY,
|
|
|
|
* GL_COLOR_ARRAY, GL_INDEX_ARRAY, GL_TEXTURE_COORD_ARRAY, and
|
|
|
|
* GL_EDGE_FLAG_ARRAY are supported.
|
|
|
|
*/
|
2005-03-17 20:36:20 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
array_count = 5;
|
|
|
|
|
|
|
|
if ( __glExtensionBitIsEnabled( gc, GL_EXT_fog_coord_bit )
|
|
|
|
|| (gc->server_major > 1) || (gc->server_minor >= 4) ) {
|
|
|
|
got_fog = GL_TRUE;
|
|
|
|
array_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( __glExtensionBitIsEnabled( gc, GL_EXT_secondary_color_bit )
|
|
|
|
|| (gc->server_major > 1) || (gc->server_minor >= 4) ) {
|
|
|
|
got_secondary_color = GL_TRUE;
|
|
|
|
array_count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( __glExtensionBitIsEnabled( gc, GL_ARB_multitexture_bit )
|
|
|
|
|| (gc->server_major > 1) || (gc->server_minor >= 3) ) {
|
2005-02-28 19:37:10 +00:00
|
|
|
__indirect_glGetIntegerv( GL_MAX_TEXTURE_UNITS, & texture_units );
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
if ( __glExtensionBitIsEnabled( gc, GL_ARB_vertex_program_bit ) ) {
|
2005-02-28 19:37:10 +00:00
|
|
|
__indirect_glGetProgramivARB( GL_VERTEX_PROGRAM_ARB,
|
|
|
|
GL_MAX_PROGRAM_ATTRIBS_ARB,
|
|
|
|
& vertex_program_attribs );
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
}
|
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
arrays->num_texture_units = texture_units;
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
arrays->num_vertex_program_attribs = vertex_program_attribs;
|
|
|
|
array_count += texture_units + vertex_program_attribs;
|
2005-02-22 22:36:31 +00:00
|
|
|
arrays->num_arrays = array_count;
|
2005-03-17 20:13:09 +00:00
|
|
|
arrays->arrays = calloc( array_count, sizeof( struct array_state ) );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
arrays->arrays[0].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[0].count = 3;
|
|
|
|
arrays->arrays[0].key = GL_NORMAL_ARRAY;
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
arrays->arrays[0].normalized = GL_TRUE;
|
2005-02-22 22:36:31 +00:00
|
|
|
arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;
|
|
|
|
|
|
|
|
arrays->arrays[1].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[1].count = 4;
|
|
|
|
arrays->arrays[1].key = GL_COLOR_ARRAY;
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
arrays->arrays[1].normalized = GL_TRUE;
|
2005-02-22 22:36:31 +00:00
|
|
|
arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;
|
|
|
|
|
|
|
|
arrays->arrays[2].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[2].count = 1;
|
|
|
|
arrays->arrays[2].key = GL_INDEX_ARRAY;
|
|
|
|
arrays->arrays[2].old_DrawArrays_possible = GL_TRUE;
|
|
|
|
|
|
|
|
arrays->arrays[3].data_type = GL_UNSIGNED_BYTE;
|
|
|
|
arrays->arrays[3].count = 1;
|
|
|
|
arrays->arrays[3].key = GL_EDGE_FLAG_ARRAY;
|
|
|
|
arrays->arrays[3].old_DrawArrays_possible = GL_TRUE;
|
|
|
|
|
|
|
|
for ( i = 0 ; i < texture_units ; i++ ) {
|
|
|
|
arrays->arrays[4 + i].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[4 + i].count = 4;
|
|
|
|
arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
|
|
|
|
arrays->arrays[4 + i].index = i;
|
|
|
|
|
|
|
|
arrays->arrays[4 + i].header[1] = i + GL_TEXTURE0;
|
|
|
|
}
|
|
|
|
|
|
|
|
i = 4 + texture_units;
|
|
|
|
|
|
|
|
if ( got_fog ) {
|
|
|
|
arrays->arrays[i].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[i].count = 1;
|
|
|
|
arrays->arrays[i].key = GL_FOG_COORDINATE_ARRAY;
|
|
|
|
arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( got_secondary_color ) {
|
|
|
|
arrays->arrays[i].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[i].count = 3;
|
|
|
|
arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
|
|
|
|
arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
arrays->arrays[i].normalized = GL_TRUE;
|
2005-02-22 22:36:31 +00:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
for ( j = 0 ; j < vertex_program_attribs ; j++ ) {
|
|
|
|
const unsigned idx = (vertex_program_attribs - (j + 1));
|
|
|
|
|
|
|
|
|
|
|
|
arrays->arrays[idx + i].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[idx + i].count = 4;
|
|
|
|
arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;
|
|
|
|
|
|
|
|
arrays->arrays[idx + i].old_DrawArrays_possible = 0;
|
|
|
|
arrays->arrays[idx + i].index = idx;
|
|
|
|
|
|
|
|
arrays->arrays[idx + i].header[1] = idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
i += vertex_program_attribs;
|
|
|
|
|
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
/* Vertex array *must* be last becuase of the way that
|
|
|
|
* emit_DrawArrays_none works.
|
|
|
|
*/
|
|
|
|
|
|
|
|
arrays->arrays[i].data_type = GL_FLOAT;
|
|
|
|
arrays->arrays[i].count = 4;
|
|
|
|
arrays->arrays[i].key = GL_VERTEX_ARRAY;
|
|
|
|
arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
assert( (i + 1) == arrays->num_arrays );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
arrays->stack_index = 0;
|
|
|
|
arrays->stack = malloc( sizeof( struct array_stack_state )
|
|
|
|
* arrays->num_arrays );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Calculate the size of a single vertex for the "none" protocol. This is
|
|
|
|
* essentially the size of all the immediate-mode commands required to
|
|
|
|
* implement the enabled vertex arrays.
|
|
|
|
*/
|
|
|
|
static size_t
|
|
|
|
calculate_single_vertex_size_none( const struct array_state_vector * arrays )
|
|
|
|
{
|
|
|
|
size_t single_vertex_size = 0;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
if ( arrays->arrays[i].enabled ) {
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
single_vertex_size += ((uint16_t *)arrays->arrays[i].header)[0];
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return single_vertex_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Emit a single element using non-DrawArrays protocol.
|
|
|
|
*/
|
|
|
|
GLubyte *
|
|
|
|
emit_element_none( GLubyte * dst,
|
|
|
|
const struct array_state_vector * arrays,
|
|
|
|
unsigned index )
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
if ( arrays->arrays[i].enabled ) {
|
|
|
|
const size_t offset = index * arrays->arrays[i].true_stride;
|
|
|
|
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
/* The generic attributes can have more data than is in the
|
|
|
|
* elements. This is because a vertex array can be a 2 element,
|
|
|
|
* normalized, unsigned short, but the "closest" immediate mode
|
|
|
|
* protocol is for a 4Nus. Since the sizes are small, the
|
|
|
|
* performance impact on modern processors should be negligible.
|
|
|
|
*/
|
|
|
|
(void) memset( dst, 0,
|
|
|
|
((uint16_t *)arrays->arrays[i].header)[0] );
|
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
(void) memcpy( dst, arrays->arrays[i].header,
|
|
|
|
arrays->arrays[i].header_size );
|
|
|
|
|
|
|
|
dst += arrays->arrays[i].header_size;
|
|
|
|
|
|
|
|
(void) memcpy( dst, ((GLubyte *) arrays->arrays[i].data) + offset,
|
|
|
|
arrays->arrays[i].element_size );
|
|
|
|
|
|
|
|
dst += __GLX_PAD( arrays->arrays[i].element_size );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Emit a single element using "old" DrawArrays protocol from
|
|
|
|
* EXT_vertex_arrays / OpenGL 1.1.
|
|
|
|
*/
|
|
|
|
GLubyte *
|
|
|
|
emit_element_old( GLubyte * dst,
|
|
|
|
const struct array_state_vector * arrays,
|
|
|
|
unsigned index )
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
if ( arrays->arrays[i].enabled ) {
|
|
|
|
const size_t offset = index * arrays->arrays[i].true_stride;
|
|
|
|
|
|
|
|
(void) memcpy( dst, ((GLubyte *) arrays->arrays[i].data) + offset,
|
|
|
|
arrays->arrays[i].element_size );
|
|
|
|
|
|
|
|
dst += __GLX_PAD( arrays->arrays[i].element_size );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
struct array_state *
|
|
|
|
get_array_entry( const struct array_state_vector * arrays,
|
|
|
|
GLenum key, unsigned index )
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
if ( (arrays->arrays[i].key == key)
|
|
|
|
&& (arrays->arrays[i].index == index) ) {
|
|
|
|
return & arrays->arrays[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static GLboolean
|
|
|
|
allocate_array_info_cache( struct array_state_vector * arrays,
|
|
|
|
size_t required_size )
|
|
|
|
{
|
2005-03-17 20:36:20 +00:00
|
|
|
#define MAX_HEADER_SIZE 20
|
2005-02-22 22:36:31 +00:00
|
|
|
if ( arrays->array_info_cache_buffer_size < required_size ) {
|
2005-08-19 19:53:26 +01:00
|
|
|
GLubyte * temp = realloc( arrays->array_info_cache_base,
|
|
|
|
required_size + MAX_HEADER_SIZE );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( temp == NULL ) {
|
|
|
|
return GL_FALSE;
|
|
|
|
}
|
|
|
|
|
2005-08-19 19:53:26 +01:00
|
|
|
arrays->array_info_cache_base = temp;
|
2005-03-17 20:36:20 +00:00
|
|
|
arrays->array_info_cache = temp + MAX_HEADER_SIZE;
|
2005-02-22 22:36:31 +00:00
|
|
|
arrays->array_info_cache_buffer_size = required_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->array_info_cache_size = required_size;
|
|
|
|
return GL_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
fill_array_info_cache( struct array_state_vector * arrays )
|
|
|
|
{
|
|
|
|
GLboolean old_DrawArrays_possible;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
|
|
|
|
/* Determine how many arrays are enabled.
|
|
|
|
*/
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
arrays->enabled_client_array_count = 0;
|
2005-02-22 22:36:31 +00:00
|
|
|
old_DrawArrays_possible = arrays->old_DrawArrays_possible;
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
if ( arrays->arrays[i].enabled ) {
|
2005-03-17 20:13:09 +00:00
|
|
|
arrays->enabled_client_array_count++;
|
2005-02-22 22:36:31 +00:00
|
|
|
old_DrawArrays_possible &= arrays->arrays[i].old_DrawArrays_possible;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( arrays->new_DrawArrays_possible ) {
|
|
|
|
assert( ! arrays->new_DrawArrays_possible );
|
|
|
|
}
|
|
|
|
else if ( old_DrawArrays_possible ) {
|
2005-03-17 20:13:09 +00:00
|
|
|
const size_t required_size = arrays->enabled_client_array_count * 12;
|
2005-02-22 22:36:31 +00:00
|
|
|
uint32_t * info;
|
|
|
|
|
|
|
|
|
|
|
|
if ( ! allocate_array_info_cache( arrays, required_size ) ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
info = (uint32_t *) arrays->array_info_cache;
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
if ( arrays->arrays[i].enabled ) {
|
|
|
|
*(info++) = arrays->arrays[i].data_type;
|
|
|
|
*(info++) = arrays->arrays[i].count;
|
|
|
|
*(info++) = arrays->arrays[i].key;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->DrawArrays = emit_DrawArrays_old;
|
|
|
|
arrays->DrawElements = emit_DrawElements_old;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
arrays->DrawArrays = emit_DrawArrays_none;
|
|
|
|
arrays->DrawElements = emit_DrawElements_none;
|
|
|
|
}
|
2005-03-17 20:13:09 +00:00
|
|
|
|
|
|
|
arrays->array_info_cache_valid = GL_TRUE;
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Emit a \c glDrawArrays command using the "none" protocol. That is,
|
|
|
|
* emit immediate-mode commands that are equivalent to the requiested
|
|
|
|
* \c glDrawArrays command. This is used with servers that don't support
|
|
|
|
* the OpenGL 1.1 / EXT_vertex_arrays DrawArrays protocol or in cases where
|
|
|
|
* vertex state is enabled that is not compatible with that protocol.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
emit_DrawArrays_none( GLenum mode, GLint first, GLsizei count )
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
|
|
|
|
size_t single_vertex_size;
|
|
|
|
GLubyte * pc;
|
|
|
|
unsigned i;
|
|
|
|
static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
|
|
|
|
static const uint16_t end_cmd[2] = { 4, X_GLrop_End };
|
|
|
|
|
|
|
|
|
|
|
|
single_vertex_size = calculate_single_vertex_size_none( arrays );
|
|
|
|
|
|
|
|
pc = gc->pc;
|
|
|
|
|
|
|
|
(void) memcpy( pc, begin_cmd, 4 );
|
|
|
|
*(int *)(pc + 4) = mode;
|
|
|
|
|
|
|
|
pc += 8;
|
|
|
|
|
|
|
|
for ( i = 0 ; i < count ; i++ ) {
|
|
|
|
if ( (pc + single_vertex_size) >= gc->bufEnd ) {
|
2008-01-22 15:40:29 +00:00
|
|
|
pc = __glXFlushRenderBuffer(gc, pc);
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pc = emit_element_none( pc, arrays, first + i );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( (pc + 4) >= gc->bufEnd ) {
|
2008-01-22 15:40:29 +00:00
|
|
|
pc = __glXFlushRenderBuffer(gc, pc);
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
(void) memcpy( pc, end_cmd, 4 );
|
|
|
|
pc += 4;
|
|
|
|
|
|
|
|
gc->pc = pc;
|
|
|
|
if ( gc->pc > gc->limit ) {
|
|
|
|
(void) __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Emit the header data for the GL 1.1 / EXT_vertex_arrays DrawArrays
|
|
|
|
* protocol.
|
|
|
|
*
|
|
|
|
* \param gc GLX context.
|
|
|
|
* \param arrays Array state.
|
|
|
|
* \param elements_per_request Location to store the number of elements that
|
|
|
|
* can fit in a single Render / RenderLarge
|
|
|
|
* command.
|
|
|
|
* \param total_request Total number of requests for a RenderLarge
|
|
|
|
* command. If a Render command is used, this
|
|
|
|
* will be zero.
|
|
|
|
* \param mode Drawing mode.
|
|
|
|
* \param count Number of vertices.
|
|
|
|
*
|
|
|
|
* \returns
|
|
|
|
* A pointer to the buffer for array data.
|
|
|
|
*/
|
|
|
|
static GLubyte *
|
|
|
|
emit_DrawArrays_header_old( __GLXcontext * gc,
|
|
|
|
struct array_state_vector * arrays,
|
|
|
|
size_t * elements_per_request,
|
2007-08-27 17:47:32 +01:00
|
|
|
unsigned int * total_requests,
|
2005-02-22 22:36:31 +00:00
|
|
|
GLenum mode, GLsizei count )
|
|
|
|
{
|
|
|
|
size_t command_size;
|
|
|
|
size_t single_vertex_size;
|
|
|
|
const unsigned header_size = 16;
|
|
|
|
unsigned i;
|
|
|
|
GLubyte * pc;
|
|
|
|
|
|
|
|
|
|
|
|
/* Determine the size of the whole command. This includes the header,
|
|
|
|
* the ARRAY_INFO data and the array data. Once this size is calculated,
|
|
|
|
* it will be known whether a Render or RenderLarge command is needed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
single_vertex_size = 0;
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
if ( arrays->arrays[i].enabled ) {
|
|
|
|
single_vertex_size += __GLX_PAD( arrays->arrays[i].element_size );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
command_size = arrays->array_info_cache_size + header_size
|
|
|
|
+ (single_vertex_size * count);
|
|
|
|
|
|
|
|
|
|
|
|
/* Write the header for either a Render command or a RenderLarge
|
|
|
|
* command. After the header is written, write the ARRAY_INFO data.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ( command_size > gc->maxSmallRenderCommandSize ) {
|
|
|
|
/* maxSize is the maximum amount of data can be stuffed into a single
|
|
|
|
* packet. sz_xGLXRenderReq is added because bufSize is the maximum
|
|
|
|
* packet size minus sz_xGLXRenderReq.
|
|
|
|
*/
|
|
|
|
const size_t maxSize = (gc->bufSize + sz_xGLXRenderReq)
|
|
|
|
- sz_xGLXRenderLargeReq;
|
|
|
|
unsigned vertex_requests;
|
|
|
|
|
|
|
|
|
|
|
|
/* Calculate the number of data packets that will be required to send
|
|
|
|
* the whole command. To do this, the number of verticies that
|
|
|
|
* will fit in a single buffer must be calculated.
|
|
|
|
*
|
|
|
|
* The important value here is elements_per_request. This is the
|
|
|
|
* number of complete array elements that will fit in a single
|
|
|
|
* buffer. There may be some wasted space at the end of the buffer,
|
|
|
|
* but splitting elements across buffer boundries would be painful.
|
|
|
|
*/
|
|
|
|
|
|
|
|
elements_per_request[0] = maxSize / single_vertex_size;
|
|
|
|
|
|
|
|
vertex_requests = (count + elements_per_request[0] - 1)
|
|
|
|
/ elements_per_request[0];
|
|
|
|
|
|
|
|
*total_requests = vertex_requests + 1;
|
|
|
|
|
|
|
|
|
|
|
|
__glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
|
|
|
|
command_size += 4;
|
|
|
|
|
2005-03-17 20:36:20 +00:00
|
|
|
pc = ((GLubyte *) arrays->array_info_cache) - (header_size + 4);
|
2005-02-22 22:36:31 +00:00
|
|
|
*(uint32_t *)(pc + 0) = command_size;
|
|
|
|
*(uint32_t *)(pc + 4) = X_GLrop_DrawArrays;
|
|
|
|
*(uint32_t *)(pc + 8) = count;
|
2005-03-17 20:13:09 +00:00
|
|
|
*(uint32_t *)(pc + 12) = arrays->enabled_client_array_count;
|
2005-02-22 22:36:31 +00:00
|
|
|
*(uint32_t *)(pc + 16) = mode;
|
|
|
|
|
|
|
|
__glXSendLargeChunk( gc, 1, *total_requests, pc,
|
|
|
|
header_size + 4 + arrays->array_info_cache_size );
|
|
|
|
|
|
|
|
pc = gc->pc;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if ( (gc->pc + command_size) >= gc->bufEnd ) {
|
|
|
|
(void) __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pc = gc->pc;
|
|
|
|
*(uint16_t *)(pc + 0) = command_size;
|
|
|
|
*(uint16_t *)(pc + 2) = X_GLrop_DrawArrays;
|
|
|
|
*(uint32_t *)(pc + 4) = count;
|
2005-03-17 20:13:09 +00:00
|
|
|
*(uint32_t *)(pc + 8) = arrays->enabled_client_array_count;
|
2005-02-22 22:36:31 +00:00
|
|
|
*(uint32_t *)(pc + 12) = mode;
|
|
|
|
|
|
|
|
pc += header_size;
|
|
|
|
|
|
|
|
(void) memcpy( pc, arrays->array_info_cache,
|
|
|
|
arrays->array_info_cache_size );
|
|
|
|
pc += arrays->array_info_cache_size;
|
2005-03-17 20:13:09 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
*elements_per_request = count;
|
|
|
|
*total_requests = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return pc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
emit_DrawArrays_old( GLenum mode, GLint first, GLsizei count )
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
|
|
|
|
GLubyte * pc;
|
|
|
|
size_t elements_per_request;
|
2007-08-27 17:47:32 +01:00
|
|
|
unsigned total_requests = 0;
|
2005-02-22 22:36:31 +00:00
|
|
|
unsigned i;
|
|
|
|
size_t total_sent = 0;
|
|
|
|
|
|
|
|
|
|
|
|
pc = emit_DrawArrays_header_old( gc, arrays, & elements_per_request,
|
|
|
|
& total_requests, mode, count);
|
|
|
|
|
|
|
|
|
|
|
|
/* Write the arrays.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if ( total_requests == 0 ) {
|
|
|
|
assert( elements_per_request >= count );
|
|
|
|
|
|
|
|
for ( i = 0 ; i < count ; i++ ) {
|
|
|
|
pc = emit_element_old( pc, arrays, i + first );
|
|
|
|
}
|
|
|
|
|
|
|
|
assert( pc <= gc->bufEnd );
|
|
|
|
|
|
|
|
gc->pc = pc;
|
|
|
|
if ( gc->pc > gc->limit ) {
|
|
|
|
(void) __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
unsigned req;
|
|
|
|
|
|
|
|
|
|
|
|
for ( req = 2 ; req <= total_requests ; req++ ) {
|
|
|
|
if ( count < elements_per_request ) {
|
|
|
|
elements_per_request = count;
|
|
|
|
}
|
|
|
|
|
|
|
|
pc = gc->pc;
|
|
|
|
for ( i = 0 ; i < elements_per_request ; i++ ) {
|
|
|
|
pc = emit_element_old( pc, arrays, i + first );
|
|
|
|
}
|
|
|
|
|
|
|
|
first += elements_per_request;
|
|
|
|
|
|
|
|
total_sent += (size_t) (pc - gc->pc);
|
|
|
|
__glXSendLargeChunk( gc, req, total_requests, gc->pc,
|
|
|
|
pc - gc->pc );
|
|
|
|
|
|
|
|
count -= elements_per_request;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
emit_DrawElements_none( GLenum mode, GLsizei count, GLenum type,
|
|
|
|
const GLvoid *indices )
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
static const uint16_t begin_cmd[2] = { 8, X_GLrop_Begin };
|
|
|
|
static const uint16_t end_cmd[2] = { 4, X_GLrop_End };
|
|
|
|
|
|
|
|
GLubyte * pc;
|
|
|
|
size_t single_vertex_size;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
|
|
|
|
single_vertex_size = calculate_single_vertex_size_none( arrays );
|
|
|
|
|
|
|
|
|
|
|
|
if ( (gc->pc + single_vertex_size) >= gc->bufEnd ) {
|
|
|
|
gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
pc = gc->pc;
|
|
|
|
|
|
|
|
(void) memcpy( pc, begin_cmd, 4 );
|
|
|
|
*(int *)(pc + 4) = mode;
|
|
|
|
|
|
|
|
pc += 8;
|
|
|
|
|
|
|
|
for ( i = 0 ; i < count ; i++ ) {
|
2005-02-28 19:37:10 +00:00
|
|
|
unsigned index = 0;
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( (pc + single_vertex_size) >= gc->bufEnd ) {
|
2008-01-22 15:40:29 +00:00
|
|
|
pc = __glXFlushRenderBuffer(gc, pc);
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch( type ) {
|
|
|
|
case GL_UNSIGNED_INT:
|
|
|
|
index = (unsigned) (((GLuint *) indices)[i]);
|
|
|
|
break;
|
|
|
|
case GL_UNSIGNED_SHORT:
|
|
|
|
index = (unsigned) (((GLushort *) indices)[i]);
|
|
|
|
break;
|
|
|
|
case GL_UNSIGNED_BYTE:
|
|
|
|
index = (unsigned) (((GLubyte *) indices)[i]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
pc = emit_element_none( pc, arrays, index );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( (pc + 4) >= gc->bufEnd ) {
|
2008-01-22 15:40:29 +00:00
|
|
|
pc = __glXFlushRenderBuffer(gc, pc);
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
(void) memcpy( pc, end_cmd, 4 );
|
|
|
|
pc += 4;
|
|
|
|
|
|
|
|
gc->pc = pc;
|
|
|
|
if ( gc->pc > gc->limit ) {
|
|
|
|
(void) __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
emit_DrawElements_old( GLenum mode, GLsizei count, GLenum type,
|
|
|
|
const GLvoid *indices )
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
|
|
|
|
GLubyte * pc;
|
|
|
|
size_t elements_per_request;
|
2007-08-27 17:47:32 +01:00
|
|
|
unsigned total_requests = 0;
|
2005-02-22 22:36:31 +00:00
|
|
|
unsigned i;
|
|
|
|
unsigned req;
|
2007-08-27 17:47:32 +01:00
|
|
|
unsigned req_element=0;
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
|
|
|
|
pc = emit_DrawArrays_header_old( gc, arrays, & elements_per_request,
|
|
|
|
& total_requests, mode, count);
|
|
|
|
|
|
|
|
|
|
|
|
/* Write the arrays.
|
|
|
|
*/
|
|
|
|
|
|
|
|
req = 2;
|
|
|
|
while ( count > 0 ) {
|
|
|
|
if ( count < elements_per_request ) {
|
|
|
|
elements_per_request = count;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch( type ) {
|
2005-03-17 20:36:20 +00:00
|
|
|
case GL_UNSIGNED_INT: {
|
2007-08-27 17:47:32 +01:00
|
|
|
const GLuint * ui_ptr = (const GLuint *) indices + req_element;
|
2005-03-17 20:36:20 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
for ( i = 0 ; i < elements_per_request ; i++ ) {
|
|
|
|
const GLint index = (GLint) *(ui_ptr++);
|
|
|
|
pc = emit_element_old( pc, arrays, index );
|
|
|
|
}
|
|
|
|
break;
|
2005-03-17 20:36:20 +00:00
|
|
|
}
|
|
|
|
case GL_UNSIGNED_SHORT: {
|
2007-08-27 17:47:32 +01:00
|
|
|
const GLushort * us_ptr = (const GLushort *) indices + req_element;
|
2005-03-17 20:36:20 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
for ( i = 0 ; i < elements_per_request ; i++ ) {
|
|
|
|
const GLint index = (GLint) *(us_ptr++);
|
|
|
|
pc = emit_element_old( pc, arrays, index );
|
|
|
|
}
|
|
|
|
break;
|
2005-03-17 20:36:20 +00:00
|
|
|
}
|
|
|
|
case GL_UNSIGNED_BYTE: {
|
2007-08-27 17:47:32 +01:00
|
|
|
const GLubyte * ub_ptr = (const GLubyte *) indices + req_element;
|
2005-03-17 20:36:20 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
for ( i = 0 ; i < elements_per_request ; i++ ) {
|
|
|
|
const GLint index = (GLint) *(ub_ptr++);
|
|
|
|
pc = emit_element_old( pc, arrays, index );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2005-03-17 20:36:20 +00:00
|
|
|
}
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( total_requests != 0 ) {
|
|
|
|
__glXSendLargeChunk( gc, req, total_requests, gc->pc,
|
|
|
|
pc - gc->pc );
|
|
|
|
pc = gc->pc;
|
|
|
|
req++;
|
|
|
|
}
|
|
|
|
|
|
|
|
count -= elements_per_request;
|
2007-08-27 17:47:32 +01:00
|
|
|
req_element += elements_per_request;
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
assert( (total_requests == 0) || ((req - 1) == total_requests) );
|
|
|
|
|
|
|
|
if ( total_requests == 0 ) {
|
|
|
|
assert( pc <= gc->bufEnd );
|
|
|
|
|
|
|
|
gc->pc = pc;
|
|
|
|
if ( gc->pc > gc->limit ) {
|
|
|
|
(void) __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Validate that the \c mode parameter to \c glDrawArrays, et. al. is valid.
|
|
|
|
* If it is not valid, then an error code is set in the GLX context.
|
|
|
|
*
|
|
|
|
* \returns
|
|
|
|
* \c GL_TRUE if the argument is valid, \c GL_FALSE if is not.
|
|
|
|
*/
|
|
|
|
static GLboolean
|
|
|
|
validate_mode(__GLXcontext *gc, GLenum mode)
|
|
|
|
{
|
|
|
|
switch(mode) {
|
|
|
|
case GL_POINTS:
|
|
|
|
case GL_LINE_STRIP:
|
|
|
|
case GL_LINE_LOOP:
|
|
|
|
case GL_LINES:
|
|
|
|
case GL_TRIANGLE_STRIP:
|
|
|
|
case GL_TRIANGLE_FAN:
|
|
|
|
case GL_TRIANGLES:
|
|
|
|
case GL_QUAD_STRIP:
|
|
|
|
case GL_QUADS:
|
|
|
|
case GL_POLYGON:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return GL_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Validate that the \c count parameter to \c glDrawArrays, et. al. is valid.
|
|
|
|
* A value less than zero is invalid and will result in \c GL_INVALID_VALUE
|
|
|
|
* being set. A value of zero will not result in an error being set, but
|
|
|
|
* will result in \c GL_FALSE being returned.
|
|
|
|
*
|
|
|
|
* \returns
|
|
|
|
* \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.
|
|
|
|
*/
|
|
|
|
static GLboolean
|
|
|
|
validate_count(__GLXcontext *gc, GLsizei count)
|
|
|
|
{
|
|
|
|
if (count < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (count > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-28 19:37:10 +00:00
|
|
|
/**
|
|
|
|
* Validate that the \c type parameter to \c glDrawElements, et. al. is
|
|
|
|
* valid. Only \c GL_UNSIGNED_BYTE, \c GL_UNSIGNED_SHORT, and
|
|
|
|
* \c GL_UNSIGNED_INT are valid.
|
|
|
|
*
|
|
|
|
* \returns
|
|
|
|
* \c GL_TRUE if the argument is valid, \c GL_FALSE if it is not.
|
|
|
|
*/
|
|
|
|
static GLboolean validate_type(__GLXcontext *gc, GLenum type)
|
|
|
|
{
|
|
|
|
switch( type ) {
|
|
|
|
case GL_UNSIGNED_INT:
|
|
|
|
case GL_UNSIGNED_SHORT:
|
|
|
|
case GL_UNSIGNED_BYTE:
|
|
|
|
return GL_TRUE;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
void __indirect_glDrawArrays(GLenum mode, GLint first, GLsizei count)
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
|
|
|
|
|
|
|
|
if ( validate_mode(gc, mode) && validate_count(gc, count) ) {
|
|
|
|
if ( ! arrays->array_info_cache_valid ) {
|
|
|
|
fill_array_info_cache( arrays );
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->DrawArrays(mode, first, count);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glArrayElement(GLint index)
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
|
|
|
|
size_t single_vertex_size;
|
|
|
|
|
|
|
|
|
|
|
|
single_vertex_size = calculate_single_vertex_size_none( arrays );
|
|
|
|
|
|
|
|
if ( (gc->pc + single_vertex_size) >= gc->bufEnd ) {
|
|
|
|
gc->pc = __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
|
|
|
|
gc->pc = emit_element_none( gc->pc, arrays, index );
|
|
|
|
|
|
|
|
if ( gc->pc > gc->limit ) {
|
|
|
|
(void) __glXFlushRenderBuffer(gc, gc->pc);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glDrawElements(GLenum mode, GLsizei count, GLenum type,
|
|
|
|
const GLvoid *indices)
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
|
|
|
|
|
2005-02-28 19:37:10 +00:00
|
|
|
if ( validate_mode(gc, mode) && validate_count(gc, count)
|
|
|
|
&& validate_type(gc, type) ) {
|
2005-02-22 22:36:31 +00:00
|
|
|
if ( ! arrays->array_info_cache_valid ) {
|
|
|
|
fill_array_info_cache( arrays );
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->DrawElements(mode, count, type, indices);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
|
|
|
|
GLsizei count, GLenum type,
|
|
|
|
const GLvoid *indices)
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
|
|
|
|
|
2005-02-28 19:37:10 +00:00
|
|
|
if ( validate_mode(gc, mode) && validate_count(gc, count)
|
|
|
|
&& validate_type(gc, type) ) {
|
2005-02-22 22:36:31 +00:00
|
|
|
if (end < start) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( ! arrays->array_info_cache_valid ) {
|
|
|
|
fill_array_info_cache( arrays );
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->DrawElements(mode, count, type, indices);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count,
|
|
|
|
GLsizei primcount)
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
GLsizei i;
|
|
|
|
|
|
|
|
|
|
|
|
if ( validate_mode(gc, mode) ) {
|
|
|
|
if ( ! arrays->array_info_cache_valid ) {
|
|
|
|
fill_array_info_cache( arrays );
|
|
|
|
}
|
|
|
|
|
|
|
|
for ( i = 0 ; i < primcount ; i++ ) {
|
|
|
|
if ( validate_count( gc, count[i] ) ) {
|
|
|
|
arrays->DrawArrays(mode, first[i], count[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count,
|
|
|
|
GLenum type, const GLvoid ** indices,
|
|
|
|
GLsizei primcount)
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
const __GLXattribute * state =
|
|
|
|
(const __GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
GLsizei i;
|
|
|
|
|
|
|
|
|
2005-02-28 19:37:10 +00:00
|
|
|
if ( validate_mode(gc, mode) && validate_type(gc, type) ) {
|
2005-02-22 22:36:31 +00:00
|
|
|
if ( ! arrays->array_info_cache_valid ) {
|
|
|
|
fill_array_info_cache( arrays );
|
|
|
|
}
|
|
|
|
|
|
|
|
for ( i = 0 ; i < primcount ; i++ ) {
|
|
|
|
if ( validate_count( gc, count[i] ) ) {
|
|
|
|
arrays->DrawElements(mode, count[i], type, indices[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
#define COMMON_ARRAY_DATA_INIT(a, PTR, TYPE, STRIDE, COUNT, NORMALIZED, HDR_SIZE, OPCODE) \
|
2005-02-22 22:36:31 +00:00
|
|
|
do { \
|
|
|
|
(a)->data = PTR; \
|
|
|
|
(a)->data_type = TYPE; \
|
|
|
|
(a)->user_stride = STRIDE; \
|
|
|
|
(a)->count = COUNT; \
|
2005-03-17 20:13:09 +00:00
|
|
|
(a)->normalized = NORMALIZED; \
|
2005-02-22 22:36:31 +00:00
|
|
|
\
|
|
|
|
(a)->element_size = __glXTypeSize( TYPE ) * COUNT; \
|
|
|
|
(a)->true_stride = (STRIDE == 0) \
|
|
|
|
? (a)->element_size : STRIDE; \
|
|
|
|
\
|
|
|
|
(a)->header_size = HDR_SIZE; \
|
|
|
|
((uint16_t *) (a)->header)[0] = __GLX_PAD((a)->header_size + (a)->element_size); \
|
|
|
|
((uint16_t *) (a)->header)[1] = OPCODE; \
|
|
|
|
} while(0)
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glVertexPointer( GLint size, GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
static const uint16_t short_ops[5] = {
|
|
|
|
0, 0, X_GLrop_Vertex2sv, X_GLrop_Vertex3sv, X_GLrop_Vertex4sv
|
|
|
|
};
|
|
|
|
static const uint16_t int_ops[5] = {
|
|
|
|
0, 0, X_GLrop_Vertex2iv, X_GLrop_Vertex3iv, X_GLrop_Vertex4iv
|
|
|
|
};
|
|
|
|
static const uint16_t float_ops[5] = {
|
|
|
|
0, 0, X_GLrop_Vertex2fv, X_GLrop_Vertex3fv, X_GLrop_Vertex4fv
|
|
|
|
};
|
|
|
|
static const uint16_t double_ops[5] = {
|
|
|
|
0, 0, X_GLrop_Vertex2dv, X_GLrop_Vertex3dv, X_GLrop_Vertex4dv
|
|
|
|
};
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
|
|
|
if (size < 2 || size > 4 || stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ( type ) {
|
|
|
|
case GL_SHORT: opcode = short_ops[size]; break;
|
|
|
|
case GL_INT: opcode = int_ops[size]; break;
|
|
|
|
case GL_FLOAT: opcode = float_ops[size]; break;
|
|
|
|
case GL_DOUBLE: opcode = double_ops[size]; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_VERTEX_ARRAY, 0 );
|
|
|
|
assert( a != NULL );
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_FALSE, 4,
|
|
|
|
opcode );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glNormalPointer( GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
|
|
|
if (stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
2005-03-17 20:13:09 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
switch ( type ) {
|
|
|
|
case GL_BYTE: opcode = X_GLrop_Normal3bv; break;
|
|
|
|
case GL_SHORT: opcode = X_GLrop_Normal3sv; break;
|
|
|
|
case GL_INT: opcode = X_GLrop_Normal3iv; break;
|
|
|
|
case GL_FLOAT: opcode = X_GLrop_Normal3fv; break;
|
|
|
|
case GL_DOUBLE: opcode = X_GLrop_Normal3dv; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_NORMAL_ARRAY, 0 );
|
|
|
|
assert( a != NULL );
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 3, GL_TRUE, 4,
|
|
|
|
opcode );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glColorPointer( GLint size, GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
static const uint16_t byte_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3bv, X_GLrop_Color4bv
|
|
|
|
};
|
|
|
|
static const uint16_t ubyte_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3ubv, X_GLrop_Color4ubv
|
|
|
|
};
|
|
|
|
static const uint16_t short_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3sv, X_GLrop_Color4sv
|
|
|
|
};
|
|
|
|
static const uint16_t ushort_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3usv, X_GLrop_Color4usv
|
|
|
|
};
|
|
|
|
static const uint16_t int_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3iv, X_GLrop_Color4iv
|
|
|
|
};
|
|
|
|
static const uint16_t uint_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3uiv, X_GLrop_Color4uiv
|
|
|
|
};
|
|
|
|
static const uint16_t float_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3fv, X_GLrop_Color4fv
|
|
|
|
};
|
|
|
|
static const uint16_t double_ops[5] = {
|
|
|
|
0, 0, 0, X_GLrop_Color3dv, X_GLrop_Color4dv
|
|
|
|
};
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
|
|
|
if (size < 3 || size > 4 || stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ( type ) {
|
|
|
|
case GL_BYTE: opcode = byte_ops[size]; break;
|
|
|
|
case GL_UNSIGNED_BYTE: opcode = ubyte_ops[size]; break;
|
|
|
|
case GL_SHORT: opcode = short_ops[size]; break;
|
|
|
|
case GL_UNSIGNED_SHORT: opcode = ushort_ops[size]; break;
|
|
|
|
case GL_INT: opcode = int_ops[size]; break;
|
|
|
|
case GL_UNSIGNED_INT: opcode = uint_ops[size]; break;
|
|
|
|
case GL_FLOAT: opcode = float_ops[size]; break;
|
|
|
|
case GL_DOUBLE: opcode = double_ops[size]; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_COLOR_ARRAY, 0 );
|
|
|
|
assert( a != NULL );
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_TRUE, 4,
|
|
|
|
opcode );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glIndexPointer( GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
|
|
|
if (stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ( type ) {
|
|
|
|
case GL_UNSIGNED_BYTE: opcode = X_GLrop_Indexubv; break;
|
|
|
|
case GL_SHORT: opcode = X_GLrop_Indexsv; break;
|
|
|
|
case GL_INT: opcode = X_GLrop_Indexiv; break;
|
|
|
|
case GL_FLOAT: opcode = X_GLrop_Indexfv; break;
|
|
|
|
case GL_DOUBLE: opcode = X_GLrop_Indexdv; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_INDEX_ARRAY, 0 );
|
|
|
|
assert( a != NULL );
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, GL_FALSE, 4,
|
|
|
|
opcode );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glEdgeFlagPointer( GLsizei stride, const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
|
|
|
if (stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_EDGE_FLAG_ARRAY, 0 );
|
|
|
|
assert( a != NULL );
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, GL_UNSIGNED_BYTE, stride, 1, GL_FALSE,
|
|
|
|
4, X_GLrop_EdgeFlagv );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glTexCoordPointer( GLint size, GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
static const uint16_t short_ops[5] = {
|
|
|
|
0, X_GLrop_TexCoord1sv, X_GLrop_TexCoord2sv, X_GLrop_TexCoord3sv, X_GLrop_TexCoord4sv
|
|
|
|
};
|
|
|
|
static const uint16_t int_ops[5] = {
|
|
|
|
0, X_GLrop_TexCoord1iv, X_GLrop_TexCoord2iv, X_GLrop_TexCoord3iv, X_GLrop_TexCoord4iv
|
|
|
|
};
|
|
|
|
static const uint16_t float_ops[5] = {
|
|
|
|
0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2fv, X_GLrop_TexCoord3fv, X_GLrop_TexCoord4fv
|
|
|
|
};
|
|
|
|
static const uint16_t double_ops[5] = {
|
|
|
|
0, X_GLrop_TexCoord1dv, X_GLrop_TexCoord2dv, X_GLrop_TexCoord3dv, X_GLrop_TexCoord4dv
|
|
|
|
};
|
|
|
|
|
|
|
|
static const uint16_t mshort_ops[5] = {
|
|
|
|
0, X_GLrop_MultiTexCoord1svARB, X_GLrop_MultiTexCoord2svARB, X_GLrop_MultiTexCoord3svARB, X_GLrop_MultiTexCoord4svARB
|
|
|
|
};
|
|
|
|
static const uint16_t mint_ops[5] = {
|
|
|
|
0, X_GLrop_MultiTexCoord1ivARB, X_GLrop_MultiTexCoord2ivARB, X_GLrop_MultiTexCoord3ivARB, X_GLrop_MultiTexCoord4ivARB
|
|
|
|
};
|
|
|
|
static const uint16_t mfloat_ops[5] = {
|
|
|
|
0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2fvARB, X_GLrop_MultiTexCoord3fvARB, X_GLrop_MultiTexCoord4fvARB
|
|
|
|
};
|
|
|
|
static const uint16_t mdouble_ops[5] = {
|
|
|
|
0, X_GLrop_MultiTexCoord1dvARB, X_GLrop_MultiTexCoord2dvARB, X_GLrop_MultiTexCoord3dvARB, X_GLrop_MultiTexCoord4dvARB
|
|
|
|
};
|
|
|
|
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
unsigned header_size;
|
|
|
|
unsigned index;
|
|
|
|
|
|
|
|
|
|
|
|
if (size < 1 || size > 4 || stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
index = arrays->active_texture_unit;
|
|
|
|
if ( index == 0 ) {
|
|
|
|
switch ( type ) {
|
|
|
|
case GL_SHORT: opcode = short_ops[size]; break;
|
|
|
|
case GL_INT: opcode = int_ops[size]; break;
|
|
|
|
case GL_FLOAT: opcode = float_ops[size]; break;
|
|
|
|
case GL_DOUBLE: opcode = double_ops[size]; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
header_size = 4;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
switch ( type ) {
|
|
|
|
case GL_SHORT: opcode = mshort_ops[size]; break;
|
|
|
|
case GL_INT: opcode = mint_ops[size]; break;
|
|
|
|
case GL_FLOAT: opcode = mfloat_ops[size]; break;
|
|
|
|
case GL_DOUBLE: opcode = mdouble_ops[size]; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
header_size = 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_TEXTURE_COORD_ARRAY, index );
|
|
|
|
assert( a != NULL );
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_FALSE,
|
|
|
|
header_size, opcode );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
|
|
|
if (size != 3 || stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch ( type ) {
|
|
|
|
case GL_BYTE: opcode = 4126; break;
|
|
|
|
case GL_UNSIGNED_BYTE: opcode = 4131; break;
|
|
|
|
case GL_SHORT: opcode = 4127; break;
|
|
|
|
case GL_UNSIGNED_SHORT: opcode = 4132; break;
|
|
|
|
case GL_INT: opcode = 4128; break;
|
|
|
|
case GL_UNSIGNED_INT: opcode = 4133; break;
|
|
|
|
case GL_FLOAT: opcode = 4129; break;
|
|
|
|
case GL_DOUBLE: opcode = 4130; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_SECONDARY_COLOR_ARRAY, 0 );
|
|
|
|
if ( a == NULL ) {
|
|
|
|
__glXSetError(gc, GL_INVALID_OPERATION);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_TRUE, 4,
|
|
|
|
opcode );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __indirect_glFogCoordPointerEXT( GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer )
|
|
|
|
{
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
|
|
|
if (stride < 0) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
2005-03-17 20:13:09 +00:00
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
switch ( type ) {
|
|
|
|
case GL_FLOAT: opcode = 4124; break;
|
|
|
|
case GL_DOUBLE: opcode = 4125; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_FOG_COORD_ARRAY, 0 );
|
|
|
|
if ( a == NULL ) {
|
|
|
|
__glXSetError(gc, GL_INVALID_OPERATION);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, GL_FALSE, 4,
|
|
|
|
opcode );
|
2005-02-22 22:36:31 +00:00
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
void __indirect_glVertexAttribPointerARB(GLuint index, GLint size,
|
|
|
|
GLenum type, GLboolean normalized,
|
|
|
|
GLsizei stride,
|
|
|
|
const GLvoid * pointer)
|
|
|
|
{
|
|
|
|
static const uint16_t short_ops[5] = { 0, 4189, 4190, 4191, 4192 };
|
|
|
|
static const uint16_t float_ops[5] = { 0, 4193, 4194, 4195, 4196 };
|
|
|
|
static const uint16_t double_ops[5] = { 0, 4197, 4198, 4199, 4200 };
|
|
|
|
|
|
|
|
uint16_t opcode;
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
unsigned true_immediate_count;
|
|
|
|
unsigned true_immediate_size;
|
|
|
|
|
|
|
|
|
|
|
|
if ( (size < 1) || (size > 4) || (stride < 0)
|
|
|
|
|| (index > arrays->num_vertex_program_attribs) ){
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( normalized && (type != GL_FLOAT) && (type != GL_DOUBLE)) {
|
|
|
|
switch( type ) {
|
|
|
|
case GL_BYTE: opcode = X_GLrop_VertexAttrib4NbvARB; break;
|
|
|
|
case GL_UNSIGNED_BYTE: opcode = X_GLrop_VertexAttrib4NubvARB; break;
|
|
|
|
case GL_SHORT: opcode = X_GLrop_VertexAttrib4NsvARB; break;
|
|
|
|
case GL_UNSIGNED_SHORT: opcode = X_GLrop_VertexAttrib4NusvARB; break;
|
|
|
|
case GL_INT: opcode = X_GLrop_VertexAttrib4NivARB; break;
|
|
|
|
case GL_UNSIGNED_INT: opcode = X_GLrop_VertexAttrib4NuivARB; break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
true_immediate_count = 4;
|
|
|
|
}
|
|
|
|
else {
|
2005-02-28 19:37:10 +00:00
|
|
|
true_immediate_count = size;
|
|
|
|
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
switch( type ) {
|
|
|
|
case GL_BYTE:
|
|
|
|
opcode = X_GLrop_VertexAttrib4bvARB;
|
|
|
|
true_immediate_count = 4;
|
|
|
|
break;
|
|
|
|
case GL_UNSIGNED_BYTE:
|
|
|
|
opcode = X_GLrop_VertexAttrib4ubvARB;
|
|
|
|
true_immediate_count = 4;
|
|
|
|
break;
|
|
|
|
case GL_SHORT:
|
|
|
|
opcode = short_ops[size];
|
|
|
|
break;
|
|
|
|
case GL_UNSIGNED_SHORT:
|
|
|
|
opcode = X_GLrop_VertexAttrib4usvARB;
|
|
|
|
true_immediate_count = 4;
|
|
|
|
break;
|
|
|
|
case GL_INT:
|
|
|
|
opcode = X_GLrop_VertexAttrib4ivARB;
|
|
|
|
true_immediate_count = 4;
|
|
|
|
break;
|
|
|
|
case GL_UNSIGNED_INT:
|
|
|
|
opcode = X_GLrop_VertexAttrib4uivARB;
|
|
|
|
true_immediate_count = 4;
|
|
|
|
break;
|
|
|
|
case GL_FLOAT:
|
|
|
|
opcode = float_ops[size];
|
|
|
|
break;
|
|
|
|
case GL_DOUBLE:
|
|
|
|
opcode = double_ops[size];
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index );
|
|
|
|
if ( a == NULL ) {
|
|
|
|
__glXSetError(gc, GL_INVALID_OPERATION);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, normalized, 8,
|
|
|
|
opcode );
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
|
|
|
|
true_immediate_size = __glXTypeSize(type) * true_immediate_count;
|
|
|
|
((uint16_t *) (a)->header)[0] = __GLX_PAD(a->header_size
|
|
|
|
+ true_immediate_size);
|
|
|
|
|
|
|
|
if ( a->enabled ) {
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* I don't have 100% confidence that this is correct. The different rules
|
|
|
|
* about whether or not generic vertex attributes alias "classic" vertex
|
|
|
|
* attributes (i.e., attrib1 ?= primary color) between ARB_vertex_program,
|
|
|
|
* ARB_vertex_shader, and NV_vertex_program are a bit confusing. My
|
|
|
|
* feeling is that the client-side doesn't have to worry about it. The
|
|
|
|
* client just sends all the data to the server and lets the server deal
|
|
|
|
* with it.
|
|
|
|
*/
|
|
|
|
void __indirect_glVertexAttribPointerNV( GLuint index, GLint size,
|
|
|
|
GLenum type, GLsizei stride,
|
|
|
|
const GLvoid * pointer)
|
|
|
|
{
|
|
|
|
__GLXcontext *gc = __glXGetCurrentContext();
|
|
|
|
GLboolean normalized = GL_FALSE;
|
|
|
|
|
|
|
|
|
|
|
|
switch( type ) {
|
|
|
|
case GL_UNSIGNED_BYTE:
|
|
|
|
if ( size != 4 ) {
|
|
|
|
__glXSetError(gc, GL_INVALID_VALUE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
normalized = GL_TRUE;
|
|
|
|
|
|
|
|
case GL_SHORT:
|
|
|
|
case GL_FLOAT:
|
|
|
|
case GL_DOUBLE:
|
|
|
|
__indirect_glVertexAttribPointerARB(index, size, type,
|
|
|
|
normalized,
|
|
|
|
stride, pointer);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-02-22 22:36:31 +00:00
|
|
|
void __indirect_glClientActiveTextureARB(GLenum texture)
|
|
|
|
{
|
|
|
|
__GLXcontext * const gc = __glXGetCurrentContext();
|
|
|
|
__GLXattribute * const state = (__GLXattribute *)(gc->client_state_private);
|
|
|
|
struct array_state_vector * const arrays = state->array_state;
|
|
|
|
const GLint unit = (GLint) texture - GL_TEXTURE0;
|
|
|
|
|
|
|
|
|
2006-05-09 15:36:58 +01:00
|
|
|
if ( (unit < 0) || (unit >= arrays->num_texture_units) ) {
|
2005-02-22 22:36:31 +00:00
|
|
|
__glXSetError(gc, GL_INVALID_ENUM);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->active_texture_unit = unit;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
2008-07-15 19:06:04 +01:00
|
|
|
* Modify the enable state for the selected array
|
2005-02-22 22:36:31 +00:00
|
|
|
*/
|
|
|
|
GLboolean
|
2008-07-15 19:06:04 +01:00
|
|
|
__glXSetArrayEnable(__GLXattribute *state, GLenum key, unsigned index,
|
|
|
|
GLboolean enable)
|
2005-02-22 22:36:31 +00:00
|
|
|
{
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_state * a;
|
|
|
|
|
|
|
|
|
2008-07-15 19:06:04 +01:00
|
|
|
/* Texture coordinate arrays have an implict index set when the
|
|
|
|
* application calls glClientActiveTexture.
|
|
|
|
*/
|
|
|
|
if (key == GL_TEXTURE_COORD_ARRAY) {
|
|
|
|
index = arrays->active_texture_unit;
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
a = get_array_entry( arrays, key, index );
|
|
|
|
|
|
|
|
if ( (a != NULL) && (a->enabled != enable) ) {
|
|
|
|
a->enabled = enable;
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (a != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
__glXArrayDisableAll( __GLXattribute * state )
|
|
|
|
{
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
arrays->arrays[i].enabled = GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->array_info_cache_valid = GL_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
GLboolean
|
|
|
|
__glXGetArrayEnable( const __GLXattribute * const state,
|
|
|
|
GLenum key, unsigned index, GLintptr * dest )
|
|
|
|
{
|
|
|
|
const struct array_state_vector * arrays = state->array_state;
|
|
|
|
const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
|
|
|
|
key, index );
|
|
|
|
|
|
|
|
if ( a != NULL ) {
|
|
|
|
*dest = (GLintptr) a->enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (a != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
GLboolean
|
|
|
|
__glXGetArrayType( const __GLXattribute * const state,
|
|
|
|
GLenum key, unsigned index, GLintptr * dest )
|
|
|
|
{
|
|
|
|
const struct array_state_vector * arrays = state->array_state;
|
|
|
|
const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
|
|
|
|
key, index );
|
|
|
|
|
|
|
|
if ( a != NULL ) {
|
2007-05-14 16:37:48 +01:00
|
|
|
*dest = (GLintptr) a->data_type;
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (a != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
GLboolean
|
|
|
|
__glXGetArraySize( const __GLXattribute * const state,
|
|
|
|
GLenum key, unsigned index, GLintptr * dest )
|
|
|
|
{
|
|
|
|
const struct array_state_vector * arrays = state->array_state;
|
|
|
|
const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
|
|
|
|
key, index );
|
|
|
|
|
|
|
|
if ( a != NULL ) {
|
|
|
|
*dest = (GLintptr) a->count;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (a != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
GLboolean
|
|
|
|
__glXGetArrayStride( const __GLXattribute * const state,
|
|
|
|
GLenum key, unsigned index, GLintptr * dest )
|
|
|
|
{
|
|
|
|
const struct array_state_vector * arrays = state->array_state;
|
|
|
|
const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
|
|
|
|
key, index );
|
|
|
|
|
|
|
|
if ( a != NULL ) {
|
|
|
|
*dest = (GLintptr) a->user_stride;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (a != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
GLboolean
|
|
|
|
__glXGetArrayPointer( const __GLXattribute * const state,
|
|
|
|
GLenum key, unsigned index, void ** dest )
|
|
|
|
{
|
|
|
|
const struct array_state_vector * arrays = state->array_state;
|
|
|
|
const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
|
|
|
|
key, index );
|
|
|
|
|
|
|
|
|
|
|
|
if ( a != NULL ) {
|
Add GLX protocol support for ARB_fragement_program,
ARB_fragment_program_shadow, ARB_vertex_program, NV_fragment_program,
NV_fragment_program_option, NV_fragment_program2, NV_vertex_program,
NV_vertex_program1_1, NV_vertex_program2, NV_vertex_program2_option,
NV_vertex_program3, and ATI_text_fragment_shader.
2005-02-25 22:46:30 +00:00
|
|
|
*dest = (void *) (a->data);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (a != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
GLboolean
|
|
|
|
__glXGetArrayNormalized( const __GLXattribute * const state,
|
|
|
|
GLenum key, unsigned index, GLintptr * dest )
|
|
|
|
{
|
|
|
|
const struct array_state_vector * arrays = state->array_state;
|
|
|
|
const struct array_state * a = get_array_entry( (struct array_state_vector *) arrays,
|
|
|
|
key, index );
|
|
|
|
|
|
|
|
|
|
|
|
if ( a != NULL ) {
|
|
|
|
*dest = (GLintptr) a->normalized;
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (a != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
*/
|
|
|
|
GLuint
|
|
|
|
__glXGetActiveTextureUnit( const __GLXattribute * const state )
|
|
|
|
{
|
|
|
|
return state->array_state->active_texture_unit;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
__glXPushArrayState( __GLXattribute * state )
|
|
|
|
{
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_stack_state * stack = & arrays->stack[ (arrays->stack_index * arrays->num_arrays)];
|
|
|
|
unsigned i;
|
|
|
|
|
2006-05-11 17:27:39 +01:00
|
|
|
/* XXX are we pushing _all_ the necessary fields? */
|
2005-02-22 22:36:31 +00:00
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
stack[i].data = arrays->arrays[i].data;
|
|
|
|
stack[i].data_type = arrays->arrays[i].data_type;
|
|
|
|
stack[i].user_stride = arrays->arrays[i].user_stride;
|
|
|
|
stack[i].count = arrays->arrays[i].count;
|
|
|
|
stack[i].key = arrays->arrays[i].key;
|
2006-05-11 17:27:39 +01:00
|
|
|
stack[i].index = arrays->arrays[i].index;
|
2005-02-22 22:36:31 +00:00
|
|
|
stack[i].enabled = arrays->arrays[i].enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
arrays->active_texture_unit_stack[ arrays->stack_index ] =
|
|
|
|
arrays->active_texture_unit;
|
|
|
|
|
|
|
|
arrays->stack_index++;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
__glXPopArrayState( __GLXattribute * state )
|
|
|
|
{
|
|
|
|
struct array_state_vector * arrays = state->array_state;
|
|
|
|
struct array_stack_state * stack;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
|
|
|
|
arrays->stack_index--;
|
|
|
|
stack = & arrays->stack[ (arrays->stack_index * arrays->num_arrays) ];
|
|
|
|
|
|
|
|
for ( i = 0 ; i < arrays->num_arrays ; i++ ) {
|
|
|
|
switch ( stack[i].key ) {
|
|
|
|
case GL_NORMAL_ARRAY:
|
|
|
|
__indirect_glNormalPointer( stack[i].data_type,
|
|
|
|
stack[i].user_stride,
|
|
|
|
stack[i].data );
|
|
|
|
break;
|
|
|
|
case GL_COLOR_ARRAY:
|
|
|
|
__indirect_glColorPointer( stack[i].count,
|
|
|
|
stack[i].data_type,
|
|
|
|
stack[i].user_stride,
|
|
|
|
stack[i].data );
|
|
|
|
break;
|
|
|
|
case GL_INDEX_ARRAY:
|
|
|
|
__indirect_glIndexPointer( stack[i].data_type,
|
|
|
|
stack[i].user_stride,
|
|
|
|
stack[i].data );
|
|
|
|
break;
|
|
|
|
case GL_EDGE_FLAG_ARRAY:
|
|
|
|
__indirect_glEdgeFlagPointer( stack[i].user_stride,
|
|
|
|
stack[i].data );
|
|
|
|
break;
|
|
|
|
case GL_TEXTURE_COORD_ARRAY:
|
|
|
|
arrays->active_texture_unit = stack[i].index;
|
|
|
|
__indirect_glTexCoordPointer( stack[i].count,
|
|
|
|
stack[i].data_type,
|
|
|
|
stack[i].user_stride,
|
|
|
|
stack[i].data );
|
|
|
|
break;
|
|
|
|
case GL_SECONDARY_COLOR_ARRAY:
|
|
|
|
__indirect_glSecondaryColorPointerEXT( stack[i].count,
|
|
|
|
stack[i].data_type,
|
|
|
|
stack[i].user_stride,
|
|
|
|
stack[i].data );
|
|
|
|
break;
|
|
|
|
case GL_FOG_COORDINATE_ARRAY:
|
|
|
|
__indirect_glFogCoordPointerEXT( stack[i].data_type,
|
|
|
|
stack[i].user_stride,
|
|
|
|
stack[i].data );
|
|
|
|
break;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
__glXSetArrayEnable( state, stack[i].key, stack[i].index,
|
|
|
|
stack[i].enabled );
|
|
|
|
}
|
|
|
|
|
2005-03-17 20:13:09 +00:00
|
|
|
arrays->active_texture_unit =
|
|
|
|
arrays->active_texture_unit_stack[ arrays->stack_index ];
|
2005-02-22 22:36:31 +00:00
|
|
|
}
|