Home | History | Annotate | Download | only in vbo
      1 
      2 /*
      3  * Mesa 3-D graphics library
      4  *
      5  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
      6  *
      7  * Permission is hereby granted, free of charge, to any person obtaining a
      8  * copy of this software and associated documentation files (the "Software"),
      9  * to deal in the Software without restriction, including without limitation
     10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
     11  * and/or sell copies of the Software, and to permit persons to whom the
     12  * Software is furnished to do so, subject to the following conditions:
     13  *
     14  * The above copyright notice and this permission notice shall be included
     15  * in all copies or substantial portions of the Software.
     16  *
     17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
     20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
     21  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
     22  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     23  * OTHER DEALINGS IN THE SOFTWARE.
     24  *
     25  * Authors:
     26  *    Keith Whitwell <keithw (at) vmware.com>
     27  */
     28 
     29 /* Helper for drivers which find themselves rendering a range of
     30  * indices starting somewhere above zero.  Typically the application
     31  * is issuing multiple DrawArrays() or DrawElements() to draw
     32  * successive primitives layed out linearly in the vertex arrays.
     33  * Unless the vertex arrays are all in a VBO, the OpenGL semantics
     34  * imply that we need to re-upload the vertex data on each draw call.
     35  * In that case, we want to avoid starting the upload at zero, as it
     36  * will mean every draw call uploads an increasing amount of not-used
     37  * vertex data.  Worse - in the software tnl module, all those
     38  * vertices will be transformed and lit.
     39  *
     40  * If we just upload the new data, however, the indices will be
     41  * incorrect as we tend to upload each set of vertex data to a new
     42  * region.
     43  *
     44  * This file provides a helper to adjust the arrays, primitives and
     45  * indices of a draw call so that it can be re-issued with a min_index
     46  * of zero.
     47  */
     48 
     49 #include <stdio.h>
     50 #include "main/glheader.h"
     51 #include "main/imports.h"
     52 #include "main/mtypes.h"
     53 
     54 #include "vbo.h"
     55 
     56 
     57 #define REBASE(TYPE) 						\
     58 static void *rebase_##TYPE( const void *ptr,			\
     59 			  GLuint count, 			\
     60 			  TYPE min_index )			\
     61 {								\
     62    GLuint i;							\
     63    const TYPE *in = (TYPE *)ptr;				\
     64    TYPE *tmp_indices = malloc(count * sizeof(TYPE));		\
     65 								\
     66    if (tmp_indices == NULL) {                                   \
     67       _mesa_error_no_memory(__func__);                          \
     68       return NULL;                                              \
     69    }                                                            \
     70 								\
     71    for (i = 0; i < count; i++)  				\
     72       tmp_indices[i] = in[i] - min_index;			\
     73 								\
     74    return (void *)tmp_indices;					\
     75 }
     76 
     77 
     78 REBASE(GLuint)
     79 REBASE(GLushort)
     80 REBASE(GLubyte)
     81 
     82 GLboolean vbo_all_varyings_in_vbos( const struct gl_vertex_array *arrays[] )
     83 {
     84    GLuint i;
     85 
     86    for (i = 0; i < VERT_ATTRIB_MAX; i++)
     87       if (arrays[i]->StrideB &&
     88 	  arrays[i]->BufferObj->Name == 0)
     89 	 return GL_FALSE;
     90 
     91    return GL_TRUE;
     92 }
     93 
     94 GLboolean vbo_any_varyings_in_vbos( const struct gl_vertex_array *arrays[] )
     95 {
     96    GLuint i;
     97 
     98    for (i = 0; i < VERT_ATTRIB_MAX; i++)
     99       if (arrays[i]->BufferObj->Name != 0)
    100 	 return GL_TRUE;
    101 
    102    return GL_FALSE;
    103 }
    104 
    105 /* Adjust primitives, indices and vertex definitions so that min_index
    106  * becomes zero. There are lots of reasons for wanting to do this, eg:
    107  *
    108  * Software tnl:
    109  *    - any time min_index != 0, otherwise unused vertices lower than
    110  *      min_index will be transformed.
    111  *
    112  * Hardware tnl:
    113  *    - if ib != NULL and min_index != 0, otherwise vertices lower than
    114  *      min_index will be uploaded.  Requires adjusting index values.
    115  *
    116  *    - if ib == NULL and min_index != 0, just for convenience so this doesn't
    117  *      have to be handled within the driver.
    118  *
    119  * Hardware tnl with VBO support:
    120  *    - as above, but only when vertices are not (all?) in VBO's.
    121  *    - can't save time by trying to upload half a vbo - typically it is
    122  *      all or nothing.
    123  */
    124 void vbo_rebase_prims( struct gl_context *ctx,
    125 		       const struct gl_vertex_array *arrays[],
    126 		       const struct _mesa_prim *prim,
    127 		       GLuint nr_prims,
    128 		       const struct _mesa_index_buffer *ib,
    129 		       GLuint min_index,
    130 		       GLuint max_index,
    131 		       vbo_draw_func draw )
    132 {
    133    struct gl_vertex_array tmp_arrays[VERT_ATTRIB_MAX];
    134    const struct gl_vertex_array *tmp_array_pointers[VERT_ATTRIB_MAX];
    135 
    136    struct _mesa_index_buffer tmp_ib;
    137    struct _mesa_prim *tmp_prims = NULL;
    138    const struct gl_vertex_array **saved_arrays = ctx->Array._DrawArrays;
    139    void *tmp_indices = NULL;
    140    GLuint i;
    141 
    142    assert(min_index != 0);
    143 
    144    if (0)
    145       printf("%s %d..%d\n", __func__, min_index, max_index);
    146 
    147 
    148    /* XXX this path is disabled for now.
    149     * There's rendering corruption in some apps when it's enabled.
    150     */
    151    if (0 && ib && ctx->Extensions.ARB_draw_elements_base_vertex) {
    152       /* If we can just tell the hardware or the TNL to interpret our
    153        * indices with a different base, do so.
    154        */
    155       tmp_prims = malloc(sizeof(*prim) * nr_prims);
    156 
    157       if (tmp_prims == NULL) {
    158          _mesa_error_no_memory(__func__);
    159          return;
    160       }
    161 
    162       for (i = 0; i < nr_prims; i++) {
    163 	 tmp_prims[i] = prim[i];
    164 	 tmp_prims[i].basevertex -= min_index;
    165       }
    166 
    167       prim = tmp_prims;
    168    } else if (ib) {
    169       /* Unfortunately need to adjust each index individually.
    170        */
    171       GLboolean map_ib = ib->obj->Name &&
    172                          !ib->obj->Mappings[MAP_INTERNAL].Pointer;
    173       void *ptr;
    174 
    175       if (map_ib)
    176 	 ctx->Driver.MapBufferRange(ctx, 0, ib->obj->Size, GL_MAP_READ_BIT,
    177 				    ib->obj, MAP_INTERNAL);
    178 
    179 
    180       ptr = ADD_POINTERS(ib->obj->Mappings[MAP_INTERNAL].Pointer, ib->ptr);
    181 
    182       /* Some users might prefer it if we translated elements to
    183        * GLuints here.  Others wouldn't...
    184        */
    185       switch (ib->index_size) {
    186       case 4:
    187 	 tmp_indices = rebase_GLuint( ptr, ib->count, min_index );
    188 	 break;
    189       case 2:
    190 	 tmp_indices = rebase_GLushort( ptr, ib->count, min_index );
    191 	 break;
    192       case 1:
    193 	 tmp_indices = rebase_GLubyte( ptr, ib->count, min_index );
    194 	 break;
    195       }
    196 
    197       if (map_ib)
    198 	 ctx->Driver.UnmapBuffer(ctx, ib->obj, MAP_INTERNAL);
    199 
    200       if (tmp_indices == NULL) {
    201          return;
    202       }
    203 
    204       tmp_ib.obj = ctx->Shared->NullBufferObj;
    205       tmp_ib.ptr = tmp_indices;
    206       tmp_ib.count = ib->count;
    207       tmp_ib.index_size = ib->index_size;
    208 
    209       ib = &tmp_ib;
    210    }
    211    else {
    212       /* Otherwise the primitives need adjustment.
    213        */
    214       tmp_prims = malloc(sizeof(*prim) * nr_prims);
    215 
    216       if (tmp_prims == NULL) {
    217          _mesa_error_no_memory(__func__);
    218          return;
    219       }
    220 
    221       for (i = 0; i < nr_prims; i++) {
    222 	 /* If this fails, it could indicate an application error:
    223 	  */
    224 	 assert(prim[i].start >= min_index);
    225 
    226 	 tmp_prims[i] = prim[i];
    227 	 tmp_prims[i].start -= min_index;
    228       }
    229 
    230       prim = tmp_prims;
    231    }
    232 
    233    /* Just need to adjust the pointer values on each incoming array.
    234     * This works for VBO and non-vbo rendering and shouldn't pesimize
    235     * VBO-based upload schemes.  However this may still not be a fast
    236     * path for hardware tnl for VBO based rendering as most machines
    237     * will be happier if you just specify a starting vertex value in
    238     * each primitive.
    239     *
    240     * For drivers with hardware tnl, you only want to do this if you
    241     * are forced to, eg non-VBO indexed rendering with start != 0.
    242     */
    243    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
    244       tmp_arrays[i] = *arrays[i];
    245       tmp_arrays[i].Ptr += min_index * tmp_arrays[i].StrideB;
    246       tmp_array_pointers[i] = &tmp_arrays[i];
    247    }
    248 
    249    /* Re-issue the draw call.
    250     */
    251    ctx->Array._DrawArrays = tmp_array_pointers;
    252    ctx->NewDriverState |= ctx->DriverFlags.NewArray;
    253 
    254    draw( ctx,
    255 	 prim,
    256 	 nr_prims,
    257 	 ib,
    258 	 GL_TRUE,
    259 	 0,
    260 	 max_index - min_index,
    261 	 NULL, 0, NULL );
    262 
    263    ctx->Array._DrawArrays = saved_arrays;
    264    ctx->NewDriverState |= ctx->DriverFlags.NewArray;
    265 
    266    free(tmp_indices);
    267 
    268    free(tmp_prims);
    269 }
    270 
    271 
    272 
    273