-/* $Id: t_array_api.c,v 1.22 2001/12/03 17:41:58 keithw Exp $ */
-
/*
* Mesa 3-D graphics library
- * Version: 3.5
+ * Version: 6.1
*
- * Copyright (C) 1999-2001 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"),
* BRIAN PAUL 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.
- *
- * Authors:
- * Keith Whitwell <keithw@valinux.com>
+ */
+
+/**
+ * \file t_array_api.c
+ * \brief Vertex array API functions (glDrawArrays, etc)
+ * \author Keith Whitwell
*/
#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++) {
- _tnl_array_element( ctx, i );
- }
- _tnl_end( ctx );
- }
+ 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)
{
- /* Simple version of the above code.
- */
- if (_tnl_hard_begin(ctx, mode)) {
- GLint i;
- for (i = 0 ; i < count ; i++)
- _tnl_array_element( ctx, indices[i] );
- _tnl_end( ctx );
+ 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 );
+
+ 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;
}
}
-
-void
+/**
+ * Called via the GL API dispatcher.
+ */
+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;
-
-/* fprintf(stderr, "%s %d %d\n", __FUNCTION__, start, count); */
+ GLuint thresh = (ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES) ? 30 : 10;
+ GLuint enabledArrays;
+
+ if (MESA_VERBOSE & VERBOSE_API)
+ _mesa_debug(NULL, "_tnl_DrawArrays %d %d\n", start, count);
/* Check arguments, etc.
*/
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 &&
- count < (GLint) ctx->Const.MaxArrayLockSize) {
+ 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, count );
+ }
+ else if (start >= (GLint) ctx->Array.LockFirst &&
+ start + count <= (GLint)(ctx->Array.LockFirst + ctx->Array.LockCount)) {
- /* Small primitives which can fit in a single vertex buffer:
+ 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 {
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;
* 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;
}
}
FLUSH_CURRENT( ctx, 0 );
-/* fprintf(stderr, "start %d count %d min %d modulo %d skip %d\n", */
-/* start, count, minimum, modulo, skip); */
-
-
bufsz -= bufsz % modulo;
bufsz -= minimum;
count += start;
for (j = start + minimum ; j < count ; j += nr + skip ) {
- nr = MIN2( bufsz, count - j );
+ struct tnl_prim prim;
-/* fprintf(stderr, "%d..%d\n", j - minimum, j+nr); */
+ 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;
}
}
}
-void
+/**
+ * Called via the GL API dispatcher.
+ */
+void GLAPIENTRY
_tnl_DrawRangeElements(GLenum mode,
GLuint start, GLuint end,
GLsizei count, GLenum type, const GLvoid *indices)
{
GET_CURRENT_CONTEXT(ctx);
- TNLcontext *tnl = TNL_CONTEXT(ctx);
GLuint *ui_indices;
-
-/* fprintf(stderr, "%s\n", __FUNCTION__); */
+
+ if (MESA_VERBOSE & VERBOSE_API)
+ _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.
*/
type, indices ))
return;
- if (tnl->pipeline.build_state_changes)
- _tnl_validate_pipeline( ctx );
-
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) {
+ 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 );
-void
+/**
+ * Called via the GL API dispatcher.
+ */
+void GLAPIENTRY
_tnl_DrawElements(GLenum mode, GLsizei count, GLenum type,
const GLvoid *indices)
{
GET_CURRENT_CONTEXT(ctx);
- TNLcontext *tnl = TNL_CONTEXT(ctx);
GLuint *ui_indices;
-/* fprintf(stderr, "%s\n", __FUNCTION__); */
+ if (MESA_VERBOSE & VERBOSE_API)
+ _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 (tnl->pipeline.build_state_changes)
- _tnl_validate_pipeline( ctx );
+ 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.
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 );
}
}
+/**
+ * Initialize context's vertex array fields. Called during T 'n L context
+ * creation.
+ */
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;
/* Setup vector pointers that will be used to bind arrays to VB's.
*/
- _mesa_vector4f_init( &tmp->Obj, 0, 0 );
- _mesa_vector3f_init( &tmp->Normal, 0, 0 );
- _mesa_vector1f_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);
}
+/**
+ * Destroy the context's vertex array stuff.
+ * Called during T 'n L context destruction.
+ */
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;
}
projects / mesa.git / blobdiff