X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Ftnl%2Ft_array_api.c;h=3aa91f9d906f194fda062530cc40c6dea94bab31;hb=5a382001224df9aad6137c825fbfc2d058b220b1;hp=9be6c9479375ee36ccc3ec6f2e08b46d665b5080;hpb=7322cccfb9a6b640743ca8cb527f7af922260cb8;p=mesa.git diff --git a/src/mesa/tnl/t_array_api.c b/src/mesa/tnl/t_array_api.c index 9be6c947937..3aa91f9d906 100644 --- a/src/mesa/tnl/t_array_api.c +++ b/src/mesa/tnl/t_array_api.c @@ -1,10 +1,8 @@ -/* $Id: t_array_api.c,v 1.26 2002/04/19 00:45:50 brianp Exp $ */ - /* * Mesa 3-D graphics library - * Version: 4.1 + * Version: 6.1 * - * Copyright (C) 1999-2002 Brian Paul All Rights Reserved. + * Copyright (C) 1999-2004 Brian Paul 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"), @@ -25,7 +23,7 @@ */ /** - * \file vpexec.c + * \file t_array_api.c * \brief Vertex array API functions (glDrawArrays, etc) * \author Keith Whitwell */ @@ -33,72 +31,92 @@ #include "glheader.h" #include "api_validate.h" #include "context.h" +#include "imports.h" #include "macros.h" -#include "mmath.h" -#include "mem.h" -#include "state.h" #include "mtypes.h" +#include "state.h" #include "array_cache/acache.h" #include "t_array_api.h" #include "t_array_import.h" -#include "t_imm_api.h" -#include "t_imm_exec.h" +#include "t_save_api.h" #include "t_context.h" #include "t_pipeline.h" static void fallback_drawarrays( GLcontext *ctx, GLenum mode, GLint start, GLsizei count ) { - if (_tnl_hard_begin( ctx, mode )) { - GLint i; - for (i = start; i < count; i++) - glArrayElement( i ); - glEnd(); - } + GLint i; + + assert(!ctx->CompileFlag); + assert(ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1); + + GL_CALL(Begin)(mode); + for (i = 0; i < count; i++) + GL_CALL(ArrayElement)( start + i ); + GL_CALL(End)(); } static void fallback_drawelements( GLcontext *ctx, GLenum mode, GLsizei count, const GLuint *indices) { - if (_tnl_hard_begin(ctx, mode)) { - GLint i; - for (i = 0 ; i < count ; i++) - glArrayElement( indices[i] ); - glEnd(); + GLint i; + + assert(!ctx->CompileFlag); + assert(ctx->Driver.CurrentExecPrimitive == GL_POLYGON+1); + + /* Here, indices will already reflect the buffer object if active */ + + GL_CALL(Begin)(mode); + for (i = 0 ; i < count ; i++) { + GL_CALL(ArrayElement)( indices[i] ); } + GL_CALL(End)(); } +/* Note this function no longer takes a 'start' value, the range is + * assumed to start at zero. The old trick of subtracting 'start' + * from each index won't work if the indices are not in writeable + * memory. + */ static void _tnl_draw_range_elements( GLcontext *ctx, GLenum mode, - GLuint start, GLuint end, - GLsizei count, const GLuint *indices ) + GLuint max_index, + GLsizei index_count, GLuint *indices ) { TNLcontext *tnl = TNL_CONTEXT(ctx); + struct tnl_prim prim; FLUSH_CURRENT( ctx, 0 ); - /* fprintf(stderr, "%s\n", __FUNCTION__); */ if (tnl->pipeline.build_state_changes) _tnl_validate_pipeline( ctx ); - _tnl_vb_bind_arrays( ctx, start, end ); + _tnl_vb_bind_arrays( ctx, 0, max_index ); + + tnl->vb.Primitive = &prim; + tnl->vb.Primitive[0].mode = mode | PRIM_BEGIN | PRIM_END; + tnl->vb.Primitive[0].start = 0; + tnl->vb.Primitive[0].count = index_count; + tnl->vb.PrimitiveCount = 1; - tnl->vb.FirstPrimitive = 0; - tnl->vb.Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST; - tnl->vb.PrimitiveLength[0] = count; tnl->vb.Elts = (GLuint *)indices; if (ctx->Array.LockCount) tnl->Driver.RunPipeline( ctx ); else { + /* The lower 16 bits represent the conventional arrays while the + * upper 16 bits represent the generic arrays. OR those bits + * together to indicate which vertex attribs are in effect. + */ + GLuint enabledArrays = ctx->Array._Enabled | (ctx->Array._Enabled >> 16); /* Note that arrays may have changed before/after execution. */ - tnl->pipeline.run_input_changes |= ctx->Array._Enabled; + tnl->pipeline.run_input_changes |= enabledArrays & 0xffff; tnl->Driver.RunPipeline( ctx ); - tnl->pipeline.run_input_changes |= ctx->Array._Enabled; + tnl->pipeline.run_input_changes |= enabledArrays & 0xffff; } } @@ -107,16 +125,16 @@ static void _tnl_draw_range_elements( GLcontext *ctx, GLenum mode, /** * Called via the GL API dispatcher. */ -void +void GLAPIENTRY _tnl_DrawArrays(GLenum mode, GLint start, GLsizei count) { GET_CURRENT_CONTEXT(ctx); TNLcontext *tnl = TNL_CONTEXT(ctx); - struct vertex_buffer *VB = &tnl->vb; GLuint thresh = (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES) ? 30 : 10; + GLuint enabledArrays; if (MESA_VERBOSE & VERBOSE_API) - fprintf(stderr, "_tnl_DrawArrays %d %d\n", start, count); + _mesa_debug(NULL, "_tnl_DrawArrays %d %d\n", start, count); /* Check arguments, etc. */ @@ -126,33 +144,34 @@ _tnl_DrawArrays(GLenum mode, GLint start, GLsizei count) if (tnl->pipeline.build_state_changes) _tnl_validate_pipeline( ctx ); - if (ctx->CompileFlag) { - fallback_drawarrays( ctx, mode, start, start + count ); - } - else if (!ctx->Array.LockCount && (GLuint) count < thresh) { + assert(!ctx->CompileFlag); + + if (!ctx->Array.LockCount && (GLuint) count < thresh) { /* Small primitives: attempt to share a vb (at the expense of * using the immediate interface). */ - fallback_drawarrays( ctx, mode, start, start + count ); + fallback_drawarrays( ctx, mode, start, count ); } - else if (ctx->Array.LockCount && - count < (GLint) ctx->Const.MaxArrayLockSize) { + else if (start >= (GLint) ctx->Array.LockFirst && + start + count <= (GLint)(ctx->Array.LockFirst + ctx->Array.LockCount)) { + struct tnl_prim prim; + /* Locked primitives which can fit in a single vertex buffer: */ FLUSH_CURRENT( ctx, 0 ); - if (start < (GLint) ctx->Array.LockFirst) - start = ctx->Array.LockFirst; - if (start + count > (GLint) ctx->Array.LockCount) - count = ctx->Array.LockCount - start; - /* Locked drawarrays. Reuse any previously transformed data. */ - _tnl_vb_bind_arrays( ctx, ctx->Array.LockFirst, ctx->Array.LockCount ); - VB->FirstPrimitive = start; - VB->Primitive[start] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST; - VB->PrimitiveLength[start] = count; + _tnl_vb_bind_arrays( ctx, ctx->Array.LockFirst, + ctx->Array.LockFirst + ctx->Array.LockCount ); + + tnl->vb.Primitive = &prim; + tnl->vb.Primitive[0].mode = mode | PRIM_BEGIN | PRIM_END; + tnl->vb.Primitive[0].start = start; + tnl->vb.Primitive[0].count = count; + tnl->vb.PrimitiveCount = 1; + tnl->Driver.RunPipeline( ctx ); } else { @@ -168,10 +187,12 @@ _tnl_DrawArrays(GLenum mode, GLint start, GLsizei count) minimum = 0; modulo = 1; skip = 0; + break; case GL_LINES: minimum = 1; modulo = 2; skip = 1; + break; case GL_LINE_STRIP: minimum = 1; modulo = 1; @@ -205,14 +226,14 @@ _tnl_DrawArrays(GLenum mode, GLint start, GLsizei count) * must use the slow path if they cannot fit in a single * vertex buffer. */ - if (count < (GLint) ctx->Const.MaxArrayLockSize) { + if (count <= (GLint) ctx->Const.MaxArrayLockSize) { bufsz = ctx->Const.MaxArrayLockSize; minimum = 0; modulo = 1; skip = 0; } else { - fallback_drawarrays( ctx, mode, start, start + count ); + fallback_drawarrays( ctx, mode, start, count ); return; } } @@ -225,16 +246,36 @@ _tnl_DrawArrays(GLenum mode, GLint start, GLsizei count) for (j = start + minimum ; j < count ; j += nr + skip ) { + struct tnl_prim prim; + nr = MIN2( bufsz, count - j ); + /* XXX is the last parameter a count or index into the array??? */ _tnl_vb_bind_arrays( ctx, j - minimum, j + nr ); - VB->FirstPrimitive = 0; - VB->Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST; - VB->PrimitiveLength[0] = nr + minimum; - tnl->pipeline.run_input_changes |= ctx->Array._Enabled; + tnl->vb.Primitive = &prim; + tnl->vb.Primitive[0].mode = mode; + + if (j == start + minimum) + tnl->vb.Primitive[0].mode |= PRIM_BEGIN; + + if (j + nr + skip >= count) + tnl->vb.Primitive[0].mode |= PRIM_END; + + tnl->vb.Primitive[0].start = 0; + tnl->vb.Primitive[0].count = nr + minimum; + tnl->vb.PrimitiveCount = 1; + + /* The lower 16 bits represent the conventional arrays while the + * upper 16 bits represent the generic arrays. OR those bits + * together to indicate which vertex attribs are in effect. + */ + enabledArrays = ctx->Array._Enabled | (ctx->Array._Enabled >> 16); + /* Note that arrays may have changed before/after execution. + */ + tnl->pipeline.run_input_changes |= enabledArrays; tnl->Driver.RunPipeline( ctx ); - tnl->pipeline.run_input_changes |= ctx->Array._Enabled; + tnl->pipeline.run_input_changes |= enabledArrays; } } } @@ -243,7 +284,7 @@ _tnl_DrawArrays(GLenum mode, GLint start, GLsizei count) /** * Called via the GL API dispatcher. */ -void +void GLAPIENTRY _tnl_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) @@ -252,7 +293,20 @@ _tnl_DrawRangeElements(GLenum mode, GLuint *ui_indices; if (MESA_VERBOSE & VERBOSE_API) - fprintf(stderr, "_tnl_DrawRangeElements %d %d %d\n", start, end, count); + _mesa_debug(NULL, "_tnl_DrawRangeElements %d %d %d\n", start, end, count); + + if (ctx->Array.ElementArrayBufferObj->Name) { + /* use indices in the buffer object */ + if (!ctx->Array.ElementArrayBufferObj->Data) { + _mesa_warning(ctx, + "DrawRangeElements with empty vertex elements buffer!"); + return; + } + /* actual address is the sum of pointers */ + indices = (const GLvoid *) + ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Data, + (const GLubyte *) indices); + } /* Check arguments, etc. */ @@ -264,42 +318,29 @@ _tnl_DrawRangeElements(GLenum mode, count, type, indices ); - if (ctx->CompileFlag) { - /* Can't do anything when compiling: - */ - fallback_drawelements( ctx, mode, count, ui_indices ); - } - else if (ctx->Array.LockCount) { + assert(!ctx->CompileFlag); + + if (ctx->Array.LockCount) { /* Are the arrays already locked? If so we currently have to look * at the whole locked range. */ - if (start >= ctx->Array.LockFirst && end <= ctx->Array.LockCount) + + if (start == 0 && ctx->Array.LockFirst == 0 && + end < (ctx->Array.LockFirst + ctx->Array.LockCount)) _tnl_draw_range_elements( ctx, mode, - ctx->Array.LockFirst, ctx->Array.LockCount, count, ui_indices ); else { - /* The spec says referencing elements outside the locked - * range is undefined. I'm going to make it a noop this time - * round, maybe come up with something beter before 3.6. - * - * May be able to get away with just setting LockCount==0, - * though this raises the problems of dependent state. May - * have to call glUnlockArrays() directly? - * - * Or scan the list and replace bad indices? - */ - _mesa_problem( ctx, - "DrawRangeElements references " - "elements outside locked range."); + fallback_drawelements( ctx, mode, count, ui_indices ); } } - else if (end + 1 - start < ctx->Const.MaxArrayLockSize) { + else if (start == 0 && end < ctx->Const.MaxArrayLockSize) { /* The arrays aren't locked but we can still fit them inside a * single vertexbuffer. */ - _tnl_draw_range_elements( ctx, mode, start, end + 1, count, ui_indices ); - } else { + _tnl_draw_range_elements( ctx, mode, end + 1, count, ui_indices ); + } + else { /* Range is too big to optimize: */ fallback_drawelements( ctx, mode, count, ui_indices ); @@ -311,7 +352,7 @@ _tnl_DrawRangeElements(GLenum mode, /** * Called via the GL API dispatcher. */ -void +void GLAPIENTRY _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) { @@ -319,26 +360,31 @@ _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type, GLuint *ui_indices; if (MESA_VERBOSE & VERBOSE_API) - fprintf(stderr, "_tnl_DrawElements %d\n", count); + _mesa_debug(NULL, "_tnl_DrawElements %d\n", count); - /* Check arguments, etc. - */ + /* Check arguments, etc. */ if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices )) return; + if (ctx->Array.ElementArrayBufferObj->Name) { + /* actual address is the sum of pointers */ + indices = (const GLvoid *) + ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Data, + (const GLubyte *) indices); + } + ui_indices = (GLuint *)_ac_import_elements( ctx, GL_UNSIGNED_INT, count, type, indices ); - if (ctx->CompileFlag) { - /* Can't do anything when compiling: - */ - fallback_drawelements( ctx, mode, count, ui_indices ); - } - else if (ctx->Array.LockCount) { - _tnl_draw_range_elements( ctx, mode, - ctx->Array.LockFirst, - ctx->Array.LockCount, - count, ui_indices ); + assert(!ctx->CompileFlag); + + if (ctx->Array.LockCount) { + if (ctx->Array.LockFirst == 0) + _tnl_draw_range_elements( ctx, mode, + ctx->Array.LockCount, + count, ui_indices ); + else + fallback_drawelements( ctx, mode, count, ui_indices ); } else { /* Scan the index list and see if we can use the locked path anyway. @@ -352,7 +398,7 @@ _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type, if (max_elt < ctx->Const.MaxArrayLockSize && /* can we use it? */ max_elt < (GLuint) count) /* do we want to use it? */ - _tnl_draw_range_elements( ctx, mode, 0, max_elt+1, count, ui_indices ); + _tnl_draw_range_elements( ctx, mode, max_elt+1, count, ui_indices ); else fallback_drawelements( ctx, mode, count, ui_indices ); } @@ -366,8 +412,8 @@ _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type, void _tnl_array_init( GLcontext *ctx ) { TNLcontext *tnl = TNL_CONTEXT(ctx); - struct vertex_arrays *tmp = &tnl->array_inputs; - GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt); + struct tnl_vertex_arrays *tmp = &tnl->array_inputs; + GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->exec_vtxfmt); GLuint i; vfmt->DrawArrays = _tnl_DrawArrays; @@ -376,17 +422,13 @@ void _tnl_array_init( GLcontext *ctx ) /* Setup vector pointers that will be used to bind arrays to VB's. */ - _mesa_vector4f_init( &tmp->Obj, 0, 0 ); - _mesa_vector4f_init( &tmp->Normal, 0, 0 ); - _mesa_vector4f_init( &tmp->FogCoord, 0, 0 ); - _mesa_vector1ui_init( &tmp->Index, 0, 0 ); - _mesa_vector1ub_init( &tmp->EdgeFlag, 0, 0 ); + _mesa_vector4f_init( &tmp->Obj, 0, NULL); + _mesa_vector4f_init( &tmp->Normal, 0, NULL); + _mesa_vector4f_init( &tmp->FogCoord, 0, NULL); + _mesa_vector4f_init( &tmp->Index, 0, NULL); for (i = 0; i < ctx->Const.MaxTextureUnits; i++) - _mesa_vector4f_init( &tmp->TexCoord[i], 0, 0); - - tnl->tmp_primitive = (GLuint *)MALLOC(sizeof(GLuint)*tnl->vb.Size); - tnl->tmp_primitive_length = (GLuint *)MALLOC(sizeof(GLuint)*tnl->vb.Size); + _mesa_vector4f_init( &tmp->TexCoord[i], 0, NULL); } @@ -396,7 +438,5 @@ void _tnl_array_init( GLcontext *ctx ) */ void _tnl_array_destroy( GLcontext *ctx ) { - TNLcontext *tnl = TNL_CONTEXT(ctx); - if (tnl->tmp_primitive_length) FREE(tnl->tmp_primitive_length); - if (tnl->tmp_primitive) FREE(tnl->tmp_primitive); + (void) ctx; }