1 files changed, 283 insertions, 283 deletions
diff --git a/mesalib/src/mesa/vbo/vbo_split_inplace.c b/mesalib/src/mesa/vbo/vbo_split_inplace.c
index 2fc866c57..98c32eda5 100644
--- a/mesalib/src/mesa/vbo/vbo_split_inplace.c
+++ b/mesalib/src/mesa/vbo/vbo_split_inplace.c
@@ -1,283 +1,283 @@
-
-/*
- * Mesa 3-D graphics library
- * Version:  6.5
- *
- * Copyright (C) 1999-2006  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"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
- * 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 <keith@tungstengraphics.com>
- */
-
-
-#include "main/mtypes.h"
-#include "main/macros.h"
-#include "main/enums.h"
-#include "main/image.h"
-#include "vbo_split.h"
-
-
-#define MAX_PRIM 32
-
-/* Used for splitting without copying. No attempt is made to handle
- * too large indexed vertex buffers: In general you need to copy to do
- * that.
- */
-struct split_context {
-   GLcontext *ctx;
-   const struct gl_client_array **array;
-   const struct _mesa_prim *prim;
-   GLuint nr_prims;
-   const struct _mesa_index_buffer *ib;
-   GLuint min_index;
-   GLuint max_index;
-   vbo_draw_func draw;
-
-   const struct split_limits *limits;
-   GLuint limit;
-
-   struct _mesa_prim dstprim[MAX_PRIM];
-   GLuint dstprim_nr;
-};
-
-
-
-
-static void flush_vertex( struct split_context *split )
-{
-   struct _mesa_index_buffer ib;
-   GLuint i;
-
-   if (!split->dstprim_nr) 
-      return;
-
-   if (split->ib) {
-      ib = *split->ib;
-
-      ib.count = split->max_index - split->min_index + 1;
-      ib.ptr = (const void *)((const char *)ib.ptr + 
-                              split->min_index * _mesa_sizeof_type(ib.type));
-
-      /* Rebase the primitives to save index buffer entries. */
-      for (i = 0; i < split->dstprim_nr; i++)
-	 split->dstprim[i].start -= split->min_index;
-   }
-
-   assert(split->max_index >= split->min_index);
-
-   split->draw(split->ctx,
-	       split->array,
-	       split->dstprim,
-	       split->dstprim_nr,
-	       split->ib ? &ib : NULL,
-	       !split->ib,
-	       split->min_index,
-	       split->max_index);
-
-   split->dstprim_nr = 0;
-   split->min_index = ~0;
-   split->max_index = 0;
-}
-
-
-static struct _mesa_prim *next_outprim( struct split_context *split )
-{
-   if (split->dstprim_nr == MAX_PRIM-1) {
-      flush_vertex(split);
-   }
-
-   {
-      struct _mesa_prim *prim = &split->dstprim[split->dstprim_nr++];
-      memset(prim, 0, sizeof(*prim));
-      return prim;
-   }
-}
-
-static void update_index_bounds(struct split_context *split,
-				const struct _mesa_prim *prim)
-{
-   split->min_index = MIN2(split->min_index, prim->start);
-   split->max_index = MAX2(split->max_index, prim->start + prim->count - 1);
-}
-
-/* Return the maximum amount of vertices that can be emitted for a
- * primitive starting at 'prim->start', depending on the previous
- * index bounds.
- */
-static GLuint get_max_vertices(struct split_context *split,
-			       const struct _mesa_prim *prim)
-{
-   if ((prim->start > split->min_index &&
-	prim->start - split->min_index >= split->limit) ||
-       (prim->start < split->max_index &&
-        split->max_index - prim->start >= split->limit))
-      /* "prim" starts too far away from the old range. */
-      return 0;
-
-   return MIN2(split->min_index, prim->start) + split->limit - prim->start;
-}
-
-/* Break large primitives into smaller ones.  If not possible, convert
- * the primitive to indexed and pass to split_elts().
- */
-static void split_prims( struct split_context *split) 
-{
-   GLuint i;
-
-   for (i = 0; i < split->nr_prims; i++) {
-      const struct _mesa_prim *prim = &split->prim[i];
-      GLuint first, incr;
-      GLboolean split_inplace = split_prim_inplace(prim->mode, &first, &incr);
-      GLuint available = get_max_vertices(split, prim);
-      GLuint count = prim->count - (prim->count - first) % incr;
-
-      if (prim->count < first)
-	 continue;
-
-      if ((available < count && !split_inplace) ||
-	  (available < first && split_inplace)) {
-	 flush_vertex(split);
-	 available = get_max_vertices(split, prim);
-      }
-      
-      if (available >= count) {
-	 struct _mesa_prim *outprim = next_outprim(split);
-
-	 *outprim = *prim;
-	 update_index_bounds(split, outprim);
-      }
-      else if (split_inplace) {
-	 GLuint j, nr;
-
-	 for (j = 0 ; j < count ; ) {
-	    GLuint remaining = count - j;
-	    struct _mesa_prim *outprim = next_outprim(split);
-
-	    nr = MIN2( available, remaining );
-	    nr -= (nr - first) % incr;
-	    
-	    outprim->mode = prim->mode;
-	    outprim->begin = (j == 0 && prim->begin);
-	    outprim->end = (nr == remaining && prim->end);
-	    outprim->start = prim->start + j;
-	    outprim->count = nr;
-
-	    update_index_bounds(split, outprim);
-
-	    if (nr == remaining) {
-	       /* Finished. 
-		*/
-	       j += nr;
-	    }
-	    else {
-	       /* Wrapped the primitive: 
-		*/
-	       j += nr - (first - incr);
-	       flush_vertex(split);
-	       available = get_max_vertices(split, prim);
-	    }
-	 }
-      }
-      else if (split->ib == NULL) {
-	 /* XXX: could at least send the first max_verts off from the
-	  * inplace buffers.
-	  */
-
-	 /* else convert to indexed primitive and pass to split_elts,
-	  * which will do the necessary copying and turn it back into a
-	  * vertex primitive for rendering...
-	  */
-	 struct _mesa_index_buffer ib;
-	 struct _mesa_prim tmpprim;
-	 GLuint *elts = malloc(count * sizeof(GLuint));
-	 GLuint j;
-	 
-	 for (j = 0; j < count; j++)
-	    elts[j] = prim->start + j;
-
-	 ib.count = count;
-	 ib.type = GL_UNSIGNED_INT;
-	 ib.obj = split->ctx->Shared->NullBufferObj;
-	 ib.ptr = elts;
-	    
-	 tmpprim = *prim;
-	 tmpprim.indexed = 1;
-	 tmpprim.start = 0;
-	 tmpprim.count = count;
-
-	 flush_vertex(split);
-
-	 vbo_split_copy(split->ctx,
-			split->array,
-			&tmpprim, 1, 
-			&ib,
-			split->draw,
-			split->limits);
-	    
-	 free(elts);
-      }
-      else {
-	 flush_vertex(split);
-
-	 vbo_split_copy(split->ctx,
-			split->array,
-			prim, 1, 
-			split->ib,
-			split->draw,
-			split->limits);
-      }
-   }
-
-   flush_vertex(split);
-}
-
-
-void vbo_split_inplace( GLcontext *ctx,
-			const struct gl_client_array *arrays[],
-			const struct _mesa_prim *prim,
-			GLuint nr_prims,
-			const struct _mesa_index_buffer *ib,
-			GLuint min_index,
-			GLuint max_index,
-			vbo_draw_func draw,
-			const struct split_limits *limits )
-{
-   struct split_context split;
-
-   memset(&split, 0, sizeof(split));
-
-   split.ctx = ctx;
-   split.array = arrays;
-   split.prim = prim;
-   split.nr_prims = nr_prims;
-   split.ib = ib;
-
-   /* Empty interval, makes calculations simpler. */
-   split.min_index = ~0;
-   split.max_index = 0;
-
-   split.draw = draw;
-   split.limits = limits;
-   split.limit = ib ? limits->max_indices : limits->max_verts;
-
-   split_prims( &split );
-}
-
-
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  6.5
+ *
+ * Copyright (C) 1999-2006  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"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
+ * 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 <keith@tungstengraphics.com>
+ */
+
+
+#include "main/mtypes.h"
+#include "main/macros.h"
+#include "main/enums.h"
+#include "main/image.h"
+#include "vbo_split.h"
+
+
+#define MAX_PRIM 32
+
+/* Used for splitting without copying. No attempt is made to handle
+ * too large indexed vertex buffers: In general you need to copy to do
+ * that.
+ */
+struct split_context {
+   struct gl_context *ctx;
+   const struct gl_client_array **array;
+   const struct _mesa_prim *prim;
+   GLuint nr_prims;
+   const struct _mesa_index_buffer *ib;
+   GLuint min_index;
+   GLuint max_index;
+   vbo_draw_func draw;
+
+   const struct split_limits *limits;
+   GLuint limit;
+
+   struct _mesa_prim dstprim[MAX_PRIM];
+   GLuint dstprim_nr;
+};
+
+
+
+
+static void flush_vertex( struct split_context *split )
+{
+   struct _mesa_index_buffer ib;
+   GLuint i;
+
+   if (!split->dstprim_nr) 
+      return;
+
+   if (split->ib) {
+      ib = *split->ib;
+
+      ib.count = split->max_index - split->min_index + 1;
+      ib.ptr = (const void *)((const char *)ib.ptr + 
+                              split->min_index * _mesa_sizeof_type(ib.type));
+
+      /* Rebase the primitives to save index buffer entries. */
+      for (i = 0; i < split->dstprim_nr; i++)
+	 split->dstprim[i].start -= split->min_index;
+   }
+
+   assert(split->max_index >= split->min_index);
+
+   split->draw(split->ctx,
+	       split->array,
+	       split->dstprim,
+	       split->dstprim_nr,
+	       split->ib ? &ib : NULL,
+	       !split->ib,
+	       split->min_index,
+	       split->max_index);
+
+   split->dstprim_nr = 0;
+   split->min_index = ~0;
+   split->max_index = 0;
+}
+
+
+static struct _mesa_prim *next_outprim( struct split_context *split )
+{
+   if (split->dstprim_nr == MAX_PRIM-1) {
+      flush_vertex(split);
+   }
+
+   {
+      struct _mesa_prim *prim = &split->dstprim[split->dstprim_nr++];
+      memset(prim, 0, sizeof(*prim));
+      return prim;
+   }
+}
+
+static void update_index_bounds(struct split_context *split,
+				const struct _mesa_prim *prim)
+{
+   split->min_index = MIN2(split->min_index, prim->start);
+   split->max_index = MAX2(split->max_index, prim->start + prim->count - 1);
+}
+
+/* Return the maximum amount of vertices that can be emitted for a
+ * primitive starting at 'prim->start', depending on the previous
+ * index bounds.
+ */
+static GLuint get_max_vertices(struct split_context *split,
+			       const struct _mesa_prim *prim)
+{
+   if ((prim->start > split->min_index &&
+	prim->start - split->min_index >= split->limit) ||
+       (prim->start < split->max_index &&
+        split->max_index - prim->start >= split->limit))
+      /* "prim" starts too far away from the old range. */
+      return 0;
+
+   return MIN2(split->min_index, prim->start) + split->limit - prim->start;
+}
+
+/* Break large primitives into smaller ones.  If not possible, convert
+ * the primitive to indexed and pass to split_elts().
+ */
+static void split_prims( struct split_context *split) 
+{
+   GLuint i;
+
+   for (i = 0; i < split->nr_prims; i++) {
+      const struct _mesa_prim *prim = &split->prim[i];
+      GLuint first, incr;
+      GLboolean split_inplace = split_prim_inplace(prim->mode, &first, &incr);
+      GLuint available = get_max_vertices(split, prim);
+      GLuint count = prim->count - (prim->count - first) % incr;
+
+      if (prim->count < first)
+	 continue;
+
+      if ((available < count && !split_inplace) ||
+	  (available < first && split_inplace)) {
+	 flush_vertex(split);
+	 available = get_max_vertices(split, prim);
+      }
+      
+      if (available >= count) {
+	 struct _mesa_prim *outprim = next_outprim(split);
+
+	 *outprim = *prim;
+	 update_index_bounds(split, outprim);
+      }
+      else if (split_inplace) {
+	 GLuint j, nr;
+
+	 for (j = 0 ; j < count ; ) {
+	    GLuint remaining = count - j;
+	    struct _mesa_prim *outprim = next_outprim(split);
+
+	    nr = MIN2( available, remaining );
+	    nr -= (nr - first) % incr;
+	    
+	    outprim->mode = prim->mode;
+	    outprim->begin = (j == 0 && prim->begin);
+	    outprim->end = (nr == remaining && prim->end);
+	    outprim->start = prim->start + j;
+	    outprim->count = nr;
+
+	    update_index_bounds(split, outprim);
+
+	    if (nr == remaining) {
+	       /* Finished. 
+		*/
+	       j += nr;
+	    }
+	    else {
+	       /* Wrapped the primitive: 
+		*/
+	       j += nr - (first - incr);
+	       flush_vertex(split);
+	       available = get_max_vertices(split, prim);
+	    }
+	 }
+      }
+      else if (split->ib == NULL) {
+	 /* XXX: could at least send the first max_verts off from the
+	  * inplace buffers.
+	  */
+
+	 /* else convert to indexed primitive and pass to split_elts,
+	  * which will do the necessary copying and turn it back into a
+	  * vertex primitive for rendering...
+	  */
+	 struct _mesa_index_buffer ib;
+	 struct _mesa_prim tmpprim;
+	 GLuint *elts = malloc(count * sizeof(GLuint));
+	 GLuint j;
+	 
+	 for (j = 0; j < count; j++)
+	    elts[j] = prim->start + j;
+
+	 ib.count = count;
+	 ib.type = GL_UNSIGNED_INT;
+	 ib.obj = split->ctx->Shared->NullBufferObj;
+	 ib.ptr = elts;
+	    
+	 tmpprim = *prim;
+	 tmpprim.indexed = 1;
+	 tmpprim.start = 0;
+	 tmpprim.count = count;
+
+	 flush_vertex(split);
+
+	 vbo_split_copy(split->ctx,
+			split->array,
+			&tmpprim, 1, 
+			&ib,
+			split->draw,
+			split->limits);
+	    
+	 free(elts);
+      }
+      else {
+	 flush_vertex(split);
+
+	 vbo_split_copy(split->ctx,
+			split->array,
+			prim, 1, 
+			split->ib,
+			split->draw,
+			split->limits);
+      }
+   }
+
+   flush_vertex(split);
+}
+
+
+void vbo_split_inplace( struct gl_context *ctx,
+			const struct gl_client_array *arrays[],
+			const struct _mesa_prim *prim,
+			GLuint nr_prims,
+			const struct _mesa_index_buffer *ib,
+			GLuint min_index,
+			GLuint max_index,
+			vbo_draw_func draw,
+			const struct split_limits *limits )
+{
+   struct split_context split;
+
+   memset(&split, 0, sizeof(split));
+
+   split.ctx = ctx;
+   split.array = arrays;
+   split.prim = prim;
+   split.nr_prims = nr_prims;
+   split.ib = ib;
+
+   /* Empty interval, makes calculations simpler. */
+   split.min_index = ~0;
+   split.max_index = 0;
+
+   split.draw = draw;
+   split.limits = limits;
+   split.limit = ib ? limits->max_indices : limits->max_verts;
+
+   split_prims( &split );
+}
+
+