3 * Mesa 3-D graphics library
6 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 * Keith Whitwell <keith@tungstengraphics.com>
29 /* Split indexed primitives with per-vertex copying.
32 #include "main/glheader.h"
33 #include "main/imports.h"
34 #include "main/macros.h"
35 #include "main/enums.h"
36 #include "main/mtypes.h"
38 #include "vbo_split.h"
42 #define ELT_TABLE_SIZE 16
44 /* Used for vertex-level splitting of indexed buffers. Note that
45 * non-indexed primitives may be converted to indexed in some cases
46 * (eg loops, fans) in order to use this splitting path.
51 const struct gl_client_array
**array
;
52 const struct _mesa_prim
*prim
;
54 const struct _mesa_index_buffer
*ib
;
57 const struct split_limits
*limits
;
62 const struct gl_client_array
*array
;
63 const GLubyte
*src_ptr
;
65 struct gl_client_array dstarray
;
67 } varying
[VERT_ATTRIB_MAX
];
70 const struct gl_client_array
*dstarray_ptr
[VERT_ATTRIB_MAX
];
71 struct _mesa_index_buffer dstib
;
73 GLuint
*translated_elt_buf
;
76 /* A baby hash table to avoid re-emitting (some) duplicate
77 * vertices when splitting indexed primitives.
82 } vert_cache
[ELT_TABLE_SIZE
];
87 GLubyte
*dstptr
; /* dstptr == dstbuf + dstelt_max * vertsize */
88 GLuint dstbuf_size
; /* in vertices */
89 GLuint dstbuf_nr
; /* count of emitted vertices, also the
90 * largest value in dstelt. Our
99 struct _mesa_prim dstprim
[MAX_PRIM
];
105 static GLuint
type_size( GLenum type
)
108 case GL_BYTE
: return sizeof(GLbyte
);
109 case GL_UNSIGNED_BYTE
: return sizeof(GLubyte
);
110 case GL_SHORT
: return sizeof(GLshort
);
111 case GL_UNSIGNED_SHORT
: return sizeof(GLushort
);
112 case GL_INT
: return sizeof(GLint
);
113 case GL_UNSIGNED_INT
: return sizeof(GLuint
);
114 case GL_FLOAT
: return sizeof(GLfloat
);
115 case GL_DOUBLE
: return sizeof(GLdouble
);
120 static GLuint
attr_size( const struct gl_client_array
*array
)
122 return array
->Size
* type_size(array
->Type
);
126 /* Starts returning true slightly before the buffer fills, to ensure
127 * that there is sufficient room for any remaining vertices to finish
130 static GLboolean
check_flush( struct copy_context
*copy
)
132 if (copy
->dstbuf_nr
+ 4 > copy
->dstbuf_size
)
135 if (copy
->dstelt_nr
+ 4 > copy
->dstelt_size
)
141 static void flush( struct copy_context
*copy
)
145 /* Set some counters:
147 copy
->dstib
.count
= copy
->dstelt_nr
;
149 copy
->draw( copy
->ctx
,
157 /* Reset all pointers:
159 copy
->dstprim_nr
= 0;
162 copy
->dstptr
= copy
->dstbuf
;
164 /* Clear the vertex cache:
166 for (i
= 0; i
< ELT_TABLE_SIZE
; i
++)
167 copy
->vert_cache
[i
].in
= ~0;
172 static void begin( struct copy_context
*copy
, GLenum mode
, GLboolean begin_flag
)
174 struct _mesa_prim
*prim
= ©
->dstprim
[copy
->dstprim_nr
];
176 /* _mesa_printf("begin %s (%d)\n", _mesa_lookup_enum_by_nr(mode), begin_flag); */
179 prim
->begin
= begin_flag
;
183 /* Use a hashtable to attempt to identify recently-emitted vertices
184 * and avoid re-emitting them.
186 static GLuint
elt(struct copy_context
*copy
, GLuint elt_idx
)
188 GLuint elt
= copy
->srcelt
[elt_idx
];
189 GLuint slot
= elt
& (ELT_TABLE_SIZE
-1);
191 /* _mesa_printf("elt %d\n", elt); */
193 /* Look up the incoming element in the vertex cache. Re-emit if
196 if (copy
->vert_cache
[slot
].in
!= elt
) {
197 GLubyte
*csr
= copy
->dstptr
;
200 /* _mesa_printf(" --> emit to dstelt %d\n", copy->dstbuf_nr); */
202 for (i
= 0; i
< copy
->nr_varying
; i
++) {
203 const struct gl_client_array
*srcarray
= copy
->varying
[i
].array
;
204 const GLubyte
*srcptr
= copy
->varying
[i
].src_ptr
+ elt
* srcarray
->StrideB
;
206 memcpy(csr
, srcptr
, copy
->varying
[i
].size
);
207 csr
+= copy
->varying
[i
].size
;
211 const GLuint
*f
= (const GLuint
*)srcptr
;
213 _mesa_printf(" varying %d: ", i
);
214 for(j
= 0; j
< copy
->varying
[i
].size
/ 4; j
++)
215 _mesa_printf("%x ", f
[j
]);
221 copy
->vert_cache
[slot
].in
= elt
;
222 copy
->vert_cache
[slot
].out
= copy
->dstbuf_nr
++;
223 copy
->dstptr
+= copy
->vertex_size
;
225 assert(csr
== copy
->dstptr
);
226 assert(copy
->dstptr
== (copy
->dstbuf
+
231 /* _mesa_printf(" --> reuse vertex\n"); */
233 /* _mesa_printf(" --> emit %d\n", copy->vert_cache[slot].out); */
234 copy
->dstelt
[copy
->dstelt_nr
++] = copy
->vert_cache
[slot
].out
;
235 return check_flush(copy
);
238 static void end( struct copy_context
*copy
, GLboolean end_flag
)
240 struct _mesa_prim
*prim
= ©
->dstprim
[copy
->dstprim_nr
];
242 /* _mesa_printf("end (%d)\n", end_flag); */
244 prim
->end
= end_flag
;
245 prim
->count
= copy
->dstelt_nr
- prim
->start
;
247 if (++copy
->dstprim_nr
== MAX_PRIM
||
254 static void replay_elts( struct copy_context
*copy
)
259 for (i
= 0; i
< copy
->nr_prims
; i
++) {
260 const struct _mesa_prim
*prim
= ©
->prim
[i
];
261 const GLuint start
= prim
->start
;
264 switch (prim
->mode
) {
267 /* Convert to linestrip and emit the final vertex explicitly,
268 * but only in the resultant strip that requires it.
271 while (j
!= prim
->count
) {
272 begin(copy
, GL_LINE_STRIP
, prim
->begin
&& j
== 0);
274 for (split
= GL_FALSE
; j
!= prim
->count
&& !split
; j
++)
275 split
= elt(copy
, start
+ j
);
277 if (j
== prim
->count
) {
278 /* Done, emit final line. Split doesn't matter as
279 * it is always raised a bit early so we can emit
280 * the last verts if necessary!
283 (void)elt(copy
, start
+ 0);
285 end(copy
, prim
->end
);
297 case GL_TRIANGLE_FAN
:
300 while (j
!= prim
->count
) {
301 begin(copy
, prim
->mode
, prim
->begin
&& j
== 0);
303 split
= elt(copy
, start
+0);
306 split
= elt(copy
, start
+j
-1);
309 for (; j
!= prim
->count
&& !split
; j
++)
310 split
= elt(copy
, start
+j
);
312 end(copy
, prim
->end
&& j
== prim
->count
);
314 if (j
!= prim
->count
) {
315 /* Wrapped the primitive, need to repeat some vertices:
323 (void)split_prim_inplace(prim
->mode
, &first
, &incr
);
326 while (j
!= prim
->count
) {
328 begin(copy
, prim
->mode
, prim
->begin
&& j
== 0);
331 for (k
= 0; k
< first
; k
++, j
++)
332 split
|= elt(copy
, start
+j
);
336 for (; j
!= prim
->count
&& !split
; )
337 for (k
= 0; k
< incr
; k
++, j
++)
338 split
|= elt(copy
, start
+j
);
340 end(copy
, prim
->end
&& j
== prim
->count
);
342 if (j
!= prim
->count
) {
343 /* Wrapped the primitive, need to repeat some vertices:
345 assert(j
> first
- incr
);
353 if (copy
->dstprim_nr
)
358 static void replay_init( struct copy_context
*copy
)
360 GLcontext
*ctx
= copy
->ctx
;
363 const GLvoid
*srcptr
;
365 /* Make a list of varying attributes and their vbo's. Also
366 * calculate vertex size.
368 copy
->vertex_size
= 0;
369 for (i
= 0; i
< VERT_ATTRIB_MAX
; i
++) {
370 struct gl_buffer_object
*vbo
= copy
->array
[i
]->BufferObj
;
372 if (copy
->array
[i
]->StrideB
== 0) {
373 copy
->dstarray_ptr
[i
] = copy
->array
[i
];
376 GLuint j
= copy
->nr_varying
++;
378 copy
->varying
[j
].attr
= i
;
379 copy
->varying
[j
].array
= copy
->array
[i
];
380 copy
->varying
[j
].size
= attr_size(copy
->array
[i
]);
381 copy
->vertex_size
+= attr_size(copy
->array
[i
]);
383 if (vbo
->Name
&& !vbo
->Pointer
)
384 ctx
->Driver
.MapBuffer(ctx
,
386 GL_WRITE_ONLY
, /* XXX */
389 copy
->varying
[j
].src_ptr
= ADD_POINTERS(vbo
->Pointer
,
390 copy
->array
[i
]->Ptr
);
392 copy
->dstarray_ptr
[i
] = ©
->varying
[j
].dstarray
;
396 /* There must always be an index buffer. Currently require the
397 * caller convert non-indexed prims to indexed. Could alternately
400 if (copy
->ib
->obj
->Name
&& !copy
->ib
->obj
->Pointer
)
401 ctx
->Driver
.MapBuffer(ctx
,
402 GL_ARRAY_BUFFER_ARB
, /* XXX */
403 GL_WRITE_ONLY
, /* XXX */
406 srcptr
= (const GLubyte
*)ADD_POINTERS(copy
->ib
->obj
->Pointer
, copy
->ib
->ptr
);
408 switch (copy
->ib
->type
) {
409 case GL_UNSIGNED_BYTE
:
410 copy
->translated_elt_buf
= _mesa_malloc(sizeof(GLuint
) * copy
->ib
->count
);
411 copy
->srcelt
= copy
->translated_elt_buf
;
413 for (i
= 0; i
< copy
->ib
->count
; i
++)
414 copy
->translated_elt_buf
[i
] = ((const GLubyte
*)srcptr
)[i
];
417 case GL_UNSIGNED_SHORT
:
418 copy
->translated_elt_buf
= _mesa_malloc(sizeof(GLuint
) * copy
->ib
->count
);
419 copy
->srcelt
= copy
->translated_elt_buf
;
421 for (i
= 0; i
< copy
->ib
->count
; i
++)
422 copy
->translated_elt_buf
[i
] = ((const GLushort
*)srcptr
)[i
];
425 case GL_UNSIGNED_INT
:
426 copy
->translated_elt_buf
= NULL
;
427 copy
->srcelt
= (const GLuint
*)srcptr
;
432 /* Figure out the maximum allowed vertex buffer size:
434 if (copy
->vertex_size
* copy
->limits
->max_verts
<= copy
->limits
->max_vb_size
) {
435 copy
->dstbuf_size
= copy
->limits
->max_verts
;
438 copy
->dstbuf_size
= copy
->limits
->max_vb_size
/ copy
->vertex_size
;
441 /* Allocate an output vertex buffer:
443 * XXX: This should be a VBO!
445 copy
->dstbuf
= _mesa_malloc(copy
->dstbuf_size
*
447 copy
->dstptr
= copy
->dstbuf
;
449 /* Setup new vertex arrays to point into the output buffer:
451 for (offset
= 0, i
= 0; i
< copy
->nr_varying
; i
++) {
452 const struct gl_client_array
*src
= copy
->varying
[i
].array
;
453 struct gl_client_array
*dst
= ©
->varying
[i
].dstarray
;
455 dst
->Size
= src
->Size
;
456 dst
->Type
= src
->Type
;
457 dst
->Stride
= copy
->vertex_size
;
458 dst
->StrideB
= copy
->vertex_size
;
459 dst
->Ptr
= copy
->dstbuf
+ offset
;
460 dst
->Enabled
= GL_TRUE
;
461 dst
->Normalized
= GL_TRUE
;
462 dst
->BufferObj
= ctx
->Array
.NullBufferObj
;
463 dst
->_MaxElement
= copy
->dstbuf_size
; /* may be less! */
465 offset
+= copy
->varying
[i
].size
;
468 /* Allocate an output element list:
470 copy
->dstelt_size
= MIN2(65536,
471 copy
->ib
->count
* 2 + 3);
472 copy
->dstelt_size
= MIN2(copy
->dstelt_size
,
473 copy
->limits
->max_indices
);
474 copy
->dstelt
= _mesa_malloc(sizeof(GLuint
) * copy
->dstelt_size
);
477 /* Setup the new index buffer to point to the allocated element
480 copy
->dstib
.count
= 0; /* duplicates dstelt_nr */
481 copy
->dstib
.type
= GL_UNSIGNED_INT
;
482 copy
->dstib
.obj
= ctx
->Array
.NullBufferObj
;
483 copy
->dstib
.ptr
= copy
->dstelt
;
487 static void replay_finish( struct copy_context
*copy
)
489 GLcontext
*ctx
= copy
->ctx
;
492 /* Free our vertex and index buffers:
494 _mesa_free(copy
->translated_elt_buf
);
495 _mesa_free(copy
->dstbuf
);
496 _mesa_free(copy
->dstelt
);
500 for (i
= 0; i
< copy
->nr_varying
; i
++) {
501 struct gl_buffer_object
*vbo
= copy
->varying
[i
].array
->BufferObj
;
503 if (vbo
->Name
&& vbo
->Pointer
)
504 ctx
->Driver
.UnmapBuffer(ctx
, GL_ARRAY_BUFFER_ARB
, vbo
);
507 /* Unmap index buffer:
509 if (copy
->ib
->obj
->Name
&& copy
->ib
->obj
->Pointer
) {
510 ctx
->Driver
.UnmapBuffer(ctx
,
511 GL_ARRAY_BUFFER_ARB
, /* XXX */
516 void vbo_split_copy( GLcontext
*ctx
,
517 const struct gl_client_array
*arrays
[],
518 const struct _mesa_prim
*prim
,
520 const struct _mesa_index_buffer
*ib
,
522 const struct split_limits
*limits
)
524 struct copy_context copy
;
527 memset(©
, 0, sizeof(copy
));
529 /* Require indexed primitives:
536 copy
.nr_prims
= nr_prims
;
539 copy
.limits
= limits
;
542 /* Clear the vertex cache:
544 for (i
= 0; i
< ELT_TABLE_SIZE
; i
++)
545 copy
.vert_cache
[i
].in
= ~0;
550 replay_finish(©
);