indirect_vertex_array.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

    }
}


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;


    if ( validate_mode(gc, mode) && validate_count(gc, count)
	 && validate_type(gc, type) ) {
	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;


    if ( validate_mode(gc, mode) && validate_count(gc, count)
	 && validate_type(gc, type) ) {
	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;


    if ( validate_mode(gc, mode) && validate_type(gc, type) ) {
	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]);
	    }
	}
    }
}


#define COMMON_ARRAY_DATA_INIT(a, PTR, TYPE, STRIDE, COUNT, NORMALIZED, HDR_SIZE, OPCODE) \
    do { \
	(a)->data = PTR; \
	(a)->data_type = TYPE; \
	(a)->user_stride = STRIDE; \
	(a)->count = COUNT; \
	(a)->normalized = NORMALIZED; \
	\
	(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 );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_FALSE, 4,
			    opcode );

    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;
    }

    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 );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 3, GL_TRUE, 4,
			    opcode );

    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 );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_TRUE, 4,
			    opcode );

    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 );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, 1, GL_FALSE, 4,
			    opcode );

    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 );
    COMMON_ARRAY_DATA_INIT( a, pointer, GL_UNSIGNED_BYTE, stride, 1, GL_FALSE,
			    4, X_GLrop_EdgeFlagv );

    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 );
    COMMON_ARRAY_DATA_INIT( a, pointer, type, stride, size, GL_FALSE,
			    header_size, opcode );

    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;