X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Ftnl%2Ft_array_api.c;h=3aa91f9d906f194fda062530cc40c6dea94bab31;hb=5a382001224df9aad6137c825fbfc2d058b220b1;hp=b0228b74c7f61b0485954dc8ca48ebef3f96c6c0;hpb=76692c5ce2a5fab129c91f870e9b9459edd9838e;p=mesa.git

diff --git a/src/mesa/tnl/t_array_api.c b/src/mesa/tnl/t_array_api.c
index b0228b74c7f..3aa91f9d906 100644
--- a/src/mesa/tnl/t_array_api.c
+++ b/src/mesa/tnl/t_array_api.c
@@ -1,8 +1,8 @@
 /*
  * Mesa 3-D graphics library
- * Version:  5.1
+ * Version:  6.1
  *
- * Copyright (C) 1999-2003  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"),
@@ -40,76 +40,84 @@
 
 #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;
-      if (ctx->Array.ElementArrayBufferObj->Name) {
-         /* use indices in the buffer object */
-         ASSERT(ctx->Array.ElementArrayBufferObj->Data);
-         indices = (const GLuint *) ctx->Array.ElementArrayBufferObj->Data;
-      }
-      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, GLuint *indices )
+				      GLuint max_index,
+				      GLsizei index_count, GLuint *indices )
 
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
-   int i;
+   struct tnl_prim prim;
    FLUSH_CURRENT( ctx, 0 );
    
-   /*  _mesa_debug(ctx, "%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.FirstPrimitive = 0;
-   tnl->vb.Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
-   tnl->vb.PrimitiveLength[0] = count;
-   tnl->vb.Elts = (GLuint *)indices;
+   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;
 
-   for (i = 0 ; i < count ; i++)
-      indices[i] -= start;
+   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;
    }
-
-   for (i = 0 ; i < count ; i++)
-      indices[i] += start;
 }
 
 
@@ -122,8 +130,8 @@ _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)
       _mesa_debug(NULL, "_tnl_DrawArrays %d %d\n", start, count); 
@@ -136,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 {
@@ -217,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;
 	 }
       }
@@ -237,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;
       }
    }
 }
@@ -273,7 +302,10 @@ _tnl_DrawRangeElements(GLenum mode,
                        "DrawRangeElements with empty vertex elements buffer!");
          return;
       }
-      indices = (GLvoid *) ctx->Array.ElementArrayBufferObj->Data;
+      /* actual address is the sum of pointers */
+      indices = (const GLvoid *)
+         ADD_POINTERS(ctx->Array.ElementArrayBufferObj->Data,
+                      (const GLubyte *) indices);
    }
 
    /* Check arguments, etc.
@@ -286,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 );
@@ -343,33 +362,29 @@ _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type,
    if (MESA_VERBOSE & VERBOSE_API)
       _mesa_debug(NULL, "_tnl_DrawElements %d\n", count); 
 
-   if (ctx->Array.ElementArrayBufferObj->Name) {
-      /* use indices in the buffer object */
-      if (!ctx->Array.ElementArrayBufferObj->Data) {
-         _mesa_warning(ctx, "DrawElements with empty vertex elements buffer!");
-         return;
-      }
-      indices = (const GLvoid *) ctx->Array.ElementArrayBufferObj->Data;
-   }
-
-   /* 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.
@@ -383,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 );
    }
@@ -397,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;
@@ -407,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);
 }
 
 
@@ -427,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;
 }