src/mesa/tnl/t_array_api.c

   1 /* $Id: t_array_api.c,v 1.24 2002/01/22 14:35:16 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  4.1
   6  *
   7  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 /**
  28  * \file vpexec.c
  29  * \brief Vertex array API functions (glDrawArrays, etc)
  30  * \author Keith Whitwell
  31  */
  32
  33 #include "glheader.h"
  34 #include "api_validate.h"
  35 #include "context.h"
  36 #include "macros.h"
  37 #include "mmath.h"
  38 #include "mem.h"
  39 #include "state.h"
  40 #include "mtypes.h"
  41
  42 #include "array_cache/acache.h"
  43
  44 #include "t_array_api.h"
  45 #include "t_array_import.h"
  46 #include "t_imm_api.h"
  47 #include "t_imm_exec.h"
  48 #include "t_context.h"
  49 #include "t_pipeline.h"
  50
  51 static void fallback_drawarrays( GLcontext *ctx, GLenum mode, GLint start,
  52                                  GLsizei count )
  53 {
  54    if (_tnl_hard_begin( ctx, mode )) {
  55       GLint i;
  56       for (i = start; i < count; i++) {
  57          _tnl_array_element( ctx, i );
  58       }
  59       _tnl_end( ctx );
  60    }
  61 }
  62
  63
  64 static void fallback_drawelements( GLcontext *ctx, GLenum mode, GLsizei count,
  65                                    const GLuint *indices)
  66 {
  67    /* Simple version of the above code.
  68     */
  69    if (_tnl_hard_begin(ctx, mode)) {
  70       GLint i;
  71       for (i = 0 ; i < count ; i++)
  72          _tnl_array_element( ctx, indices[i] );
  73       _tnl_end( ctx );
  74    }
  75 }
  76
  77
  78 static void _tnl_draw_range_elements( GLcontext *ctx, GLenum mode,
  79                                       GLuint start, GLuint end,
  80                                       GLsizei count, const GLuint *indices )
  81
  82 {
  83    TNLcontext *tnl = TNL_CONTEXT(ctx);
  84    FLUSH_CURRENT( ctx, 0 );
  85
  86    _tnl_vb_bind_arrays( ctx, start, end );
  87
  88    tnl->vb.FirstPrimitive = 0;
  89    tnl->vb.Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
  90    tnl->vb.PrimitiveLength[0] = count;
  91    tnl->vb.Elts = (GLuint *)indices;
  92
  93    if (ctx->Array.LockCount)
  94       tnl->Driver.RunPipeline( ctx );
  95    else {
  96       /* Note that arrays may have changed before/after execution.
  97        */
  98       tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
  99       tnl->Driver.RunPipeline( ctx );
 100       tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
 101    }
 102 }
 103
 104
 105
 106 /**
 107  * Called via the GL API dispatcher.
 108  */
 109 void
 110 _tnl_DrawArrays(GLenum mode, GLint start, GLsizei count)
 111 {
 112    GET_CURRENT_CONTEXT(ctx);
 113    TNLcontext *tnl = TNL_CONTEXT(ctx);
 114    struct vertex_buffer *VB = &tnl->vb;
 115
 116 /*     fprintf(stderr, "%s %d %d\n", __FUNCTION__, start, count); */
 117
 118    /* Check arguments, etc.
 119     */
 120    if (!_mesa_validate_DrawArrays( ctx, mode, start, count ))
 121       return;
 122
 123    if (tnl->pipeline.build_state_changes)
 124       _tnl_validate_pipeline( ctx );
 125
 126    if (ctx->CompileFlag) {
 127       fallback_drawarrays( ctx, mode, start, start + count );
 128    }
 129    else if (ctx->Array.LockCount &&
 130             count < (GLint) ctx->Const.MaxArrayLockSize) {
 131
 132       /* Small primitives which can fit in a single vertex buffer:
 133        */
 134       FLUSH_CURRENT( ctx, 0 );
 135
 136       if (start < (GLint) ctx->Array.LockFirst)
 137          start = ctx->Array.LockFirst;
 138       if (start + count > (GLint) ctx->Array.LockCount)
 139          count = ctx->Array.LockCount - start;
 140
 141       /* Locked drawarrays.  Reuse any previously transformed data.
 142        */
 143       _tnl_vb_bind_arrays( ctx, ctx->Array.LockFirst, ctx->Array.LockCount );
 144       VB->FirstPrimitive = start;
 145       VB->Primitive[start] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
 146       VB->PrimitiveLength[start] = count;
 147       tnl->Driver.RunPipeline( ctx );
 148    }
 149    else {
 150       int bufsz = 256;          /* Use a small buffer for cache goodness */
 151       int j, nr;
 152       int minimum, modulo, skip;
 153
 154       /* Large primitives requiring decomposition to multiple vertex
 155        * buffers:
 156        */
 157       switch (mode) {
 158       case GL_POINTS:
 159          minimum = 0;
 160          modulo = 1;
 161          skip = 0;
 162       case GL_LINES:
 163          minimum = 1;
 164          modulo = 2;
 165          skip = 1;
 166       case GL_LINE_STRIP:
 167          minimum = 1;
 168          modulo = 1;
 169          skip = 0;
 170          break;
 171       case GL_TRIANGLES:
 172          minimum = 2;
 173          modulo = 3;
 174          skip = 2;
 175          break;
 176       case GL_TRIANGLE_STRIP:
 177          minimum = 2;
 178          modulo = 1;
 179          skip = 0;
 180          break;
 181       case GL_QUADS:
 182          minimum = 3;
 183          modulo = 4;
 184          skip = 3;
 185          break;
 186       case GL_QUAD_STRIP:
 187          minimum = 3;
 188          modulo = 2;
 189          skip = 0;
 190          break;
 191       case GL_LINE_LOOP:
 192       case GL_TRIANGLE_FAN:
 193       case GL_POLYGON:
 194       default:
 195          /* Primitives requiring a copied vertex (fan-like primitives)
 196           * must use the slow path if they cannot fit in a single
 197           * vertex buffer.
 198           */
 199          if (count < (GLint) ctx->Const.MaxArrayLockSize) {
 200             bufsz = ctx->Const.MaxArrayLockSize;
 201             minimum = 0;
 202             modulo = 1;
 203             skip = 0;
 204          }
 205          else {
 206             fallback_drawarrays( ctx, mode, start, start + count );
 207             return;
 208          }
 209       }
 210
 211       FLUSH_CURRENT( ctx, 0 );
 212
 213 /*        fprintf(stderr, "start %d count %d min %d modulo %d skip %d\n", */
 214 /*            start, count, minimum, modulo, skip); */
 215
 216
 217       bufsz -= bufsz % modulo;
 218       bufsz -= minimum;
 219       count += start;
 220
 221       for (j = start + minimum ; j < count ; j += nr + skip ) {
 222
 223          nr = MIN2( bufsz, count - j );
 224
 225 /*       fprintf(stderr, "%d..%d\n", j - minimum, j+nr); */
 226
 227          _tnl_vb_bind_arrays( ctx, j - minimum, j + nr );
 228
 229          VB->FirstPrimitive = 0;
 230          VB->Primitive[0] = mode | PRIM_BEGIN | PRIM_END | PRIM_LAST;
 231          VB->PrimitiveLength[0] = nr + minimum;
 232          tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
 233          tnl->Driver.RunPipeline( ctx );
 234          tnl->pipeline.run_input_changes |= ctx->Array._Enabled;
 235       }
 236    }
 237 }
 238
 239
 240 /**
 241  * Called via the GL API dispatcher.
 242  */
 243 void
 244 _tnl_DrawRangeElements(GLenum mode,
 245                        GLuint start, GLuint end,
 246                        GLsizei count, GLenum type, const GLvoid *indices)
 247 {
 248    GET_CURRENT_CONTEXT(ctx);
 249    TNLcontext *tnl = TNL_CONTEXT(ctx);
 250    GLuint *ui_indices;
 251
 252 /*     fprintf(stderr, "%s\n", __FUNCTION__); */
 253
 254    /* Check arguments, etc.
 255     */
 256    if (!_mesa_validate_DrawRangeElements( ctx, mode, start, end, count,
 257                                           type, indices ))
 258       return;
 259
 260    if (tnl->pipeline.build_state_changes)
 261       _tnl_validate_pipeline( ctx );
 262
 263    ui_indices = (GLuint *)_ac_import_elements( ctx, GL_UNSIGNED_INT,
 264                                                count, type, indices );
 265
 266
 267    if (ctx->CompileFlag) {
 268       /* Can't do anything when compiling:
 269        */
 270       fallback_drawelements( ctx, mode, count, ui_indices );
 271    }
 272    else if (ctx->Array.LockCount) {
 273       /* Are the arrays already locked?  If so we currently have to look
 274        * at the whole locked range.
 275        */
 276       if (start >= ctx->Array.LockFirst && end <= ctx->Array.LockCount)
 277          _tnl_draw_range_elements( ctx, mode,
 278                                    ctx->Array.LockFirst,
 279                                    ctx->Array.LockCount,
 280                                    count, ui_indices );
 281       else {
 282          /* The spec says referencing elements outside the locked
 283           * range is undefined.  I'm going to make it a noop this time
 284           * round, maybe come up with something beter before 3.6.
 285           *
 286           * May be able to get away with just setting LockCount==0,
 287           * though this raises the problems of dependent state.  May
 288           * have to call glUnlockArrays() directly?
 289           *
 290           * Or scan the list and replace bad indices?
 291           */
 292          _mesa_problem( ctx,
 293                      "DrawRangeElements references "
 294                      "elements outside locked range.");
 295       }
 296    }
 297    else if (end + 1 - start < ctx->Const.MaxArrayLockSize) {
 298       /* The arrays aren't locked but we can still fit them inside a
 299        * single vertexbuffer.
 300        */
 301       _tnl_draw_range_elements( ctx, mode, start, end + 1, count, ui_indices );
 302    } else {
 303       /* Range is too big to optimize:
 304        */
 305       fallback_drawelements( ctx, mode, count, ui_indices );
 306    }
 307 }
 308
 309
 310
 311 /**
 312  * Called via the GL API dispatcher.
 313  */
 314 void
 315 _tnl_DrawElements(GLenum mode, GLsizei count, GLenum type,
 316                   const GLvoid *indices)
 317 {
 318    GET_CURRENT_CONTEXT(ctx);
 319    TNLcontext *tnl = TNL_CONTEXT(ctx);
 320    GLuint *ui_indices;
 321
 322 /*     fprintf(stderr, "%s\n", __FUNCTION__); */
 323
 324    /* Check arguments, etc.
 325     */
 326    if (!_mesa_validate_DrawElements( ctx, mode, count, type, indices ))
 327       return;
 328
 329    if (tnl->pipeline.build_state_changes)
 330       _tnl_validate_pipeline( ctx );
 331
 332    ui_indices = (GLuint *)_ac_import_elements( ctx, GL_UNSIGNED_INT,
 333                                                count, type, indices );
 334
 335    if (ctx->CompileFlag) {
 336       /* Can't do anything when compiling:
 337        */
 338       fallback_drawelements( ctx, mode, count, ui_indices );
 339    }
 340    else if (ctx->Array.LockCount) {
 341       _tnl_draw_range_elements( ctx, mode,
 342                                 ctx->Array.LockFirst,
 343                                 ctx->Array.LockCount,
 344                                 count, ui_indices );
 345    }
 346    else {
 347       /* Scan the index list and see if we can use the locked path anyway.
 348        */
 349       GLuint max_elt = 0;
 350       GLint i;
 351
 352       for (i = 0 ; i < count ; i++)
 353          if (ui_indices[i] > max_elt)
 354             max_elt = ui_indices[i];
 355
 356       if (max_elt < ctx->Const.MaxArrayLockSize && /* can we use it? */
 357           max_elt < (GLuint) count)                /* do we want to use it? */
 358          _tnl_draw_range_elements( ctx, mode, 0, max_elt+1, count, ui_indices );
 359       else
 360          fallback_drawelements( ctx, mode, count, ui_indices );
 361    }
 362 }
 363
 364
 365 /**
 366  * Initialize context's vertex array fields.  Called during T 'n L context
 367  * creation.
 368  */
 369 void _tnl_array_init( GLcontext *ctx )
 370 {
 371    TNLcontext *tnl = TNL_CONTEXT(ctx);
 372    struct vertex_arrays *tmp = &tnl->array_inputs;
 373    GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt);
 374    GLuint i;
 375
 376    vfmt->DrawArrays = _tnl_DrawArrays;
 377    vfmt->DrawElements = _tnl_DrawElements;
 378    vfmt->DrawRangeElements = _tnl_DrawRangeElements;
 379
 380    /* Setup vector pointers that will be used to bind arrays to VB's.
 381     */
 382    _mesa_vector4f_init( &tmp->Obj, 0, 0 );
 383    _mesa_vector4f_init( &tmp->Normal, 0, 0 );
 384    _mesa_vector4f_init( &tmp->FogCoord, 0, 0 );
 385    _mesa_vector1ui_init( &tmp->Index, 0, 0 );
 386    _mesa_vector1ub_init( &tmp->EdgeFlag, 0, 0 );
 387
 388    for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
 389       _mesa_vector4f_init( &tmp->TexCoord[i], 0, 0);
 390
 391    tnl->tmp_primitive = (GLuint *)MALLOC(sizeof(GLuint)*tnl->vb.Size);
 392    tnl->tmp_primitive_length = (GLuint *)MALLOC(sizeof(GLuint)*tnl->vb.Size);
 393 }
 394
 395
 396 /**
 397  * Destroy the context's vertex array stuff.
 398  * Called during T 'n L context destruction.
 399  */
 400 void _tnl_array_destroy( GLcontext *ctx )
 401 {
 402    TNLcontext *tnl = TNL_CONTEXT(ctx);
 403    if (tnl->tmp_primitive_length) FREE(tnl->tmp_primitive_length);
 404    if (tnl->tmp_primitive) FREE(tnl->tmp_primitive);
 405 }