src/mesa/state_tracker/st_draw.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /*
  29  * This file implements the st_draw_vbo() function which is called from
  30  * Mesa's VBO module.  All point/line/triangle rendering is done through
  31  * this function whether the user called glBegin/End, glDrawArrays,
  32  * glDrawElements, glEvalMesh, or glCalList, etc.
  33  *
  34  * We basically convert the VBO's vertex attribute/array information into
  35  * Gallium vertex state, bind the vertex buffer objects and call
  36  * pipe->draw_elements(), pipe->draw_range_elements() or pipe->draw_arrays().
  37  *
  38  * Authors:
  39  *   Keith Whitwell <keith@tungstengraphics.com>
  40  */
  41
  42
  43 #include "main/imports.h"
  44 #include "main/image.h"
  45 #include "main/macros.h"
  46 #include "program/prog_uniform.h"
  47
  48 #include "vbo/vbo.h"
  49
  50 #include "st_context.h"
  51 #include "st_atom.h"
  52 #include "st_cb_bufferobjects.h"
  53 #include "st_draw.h"
  54 #include "st_program.h"
  55
  56 #include "pipe/p_context.h"
  57 #include "pipe/p_defines.h"
  58 #include "util/u_inlines.h"
  59 #include "util/u_format.h"
  60 #include "draw/draw_context.h"
  61 #include "cso_cache/cso_context.h"
  62
  63
  64 static GLuint double_types[4] = {
  65    PIPE_FORMAT_R64_FLOAT,
  66    PIPE_FORMAT_R64G64_FLOAT,
  67    PIPE_FORMAT_R64G64B64_FLOAT,
  68    PIPE_FORMAT_R64G64B64A64_FLOAT
  69 };
  70
  71 static GLuint float_types[4] = {
  72    PIPE_FORMAT_R32_FLOAT,
  73    PIPE_FORMAT_R32G32_FLOAT,
  74    PIPE_FORMAT_R32G32B32_FLOAT,
  75    PIPE_FORMAT_R32G32B32A32_FLOAT
  76 };
  77
  78 static GLuint half_float_types[4] = {
  79    PIPE_FORMAT_R16_FLOAT,
  80    PIPE_FORMAT_R16G16_FLOAT,
  81    PIPE_FORMAT_R16G16B16_FLOAT,
  82    PIPE_FORMAT_R16G16B16A16_FLOAT
  83 };
  84
  85 static GLuint uint_types_norm[4] = {
  86    PIPE_FORMAT_R32_UNORM,
  87    PIPE_FORMAT_R32G32_UNORM,
  88    PIPE_FORMAT_R32G32B32_UNORM,
  89    PIPE_FORMAT_R32G32B32A32_UNORM
  90 };
  91
  92 static GLuint uint_types_scale[4] = {
  93    PIPE_FORMAT_R32_USCALED,
  94    PIPE_FORMAT_R32G32_USCALED,
  95    PIPE_FORMAT_R32G32B32_USCALED,
  96    PIPE_FORMAT_R32G32B32A32_USCALED
  97 };
  98
  99 static GLuint int_types_norm[4] = {
 100    PIPE_FORMAT_R32_SNORM,
 101    PIPE_FORMAT_R32G32_SNORM,
 102    PIPE_FORMAT_R32G32B32_SNORM,
 103    PIPE_FORMAT_R32G32B32A32_SNORM
 104 };
 105
 106 static GLuint int_types_scale[4] = {
 107    PIPE_FORMAT_R32_SSCALED,
 108    PIPE_FORMAT_R32G32_SSCALED,
 109    PIPE_FORMAT_R32G32B32_SSCALED,
 110    PIPE_FORMAT_R32G32B32A32_SSCALED
 111 };
 112
 113 static GLuint ushort_types_norm[4] = {
 114    PIPE_FORMAT_R16_UNORM,
 115    PIPE_FORMAT_R16G16_UNORM,
 116    PIPE_FORMAT_R16G16B16_UNORM,
 117    PIPE_FORMAT_R16G16B16A16_UNORM
 118 };
 119
 120 static GLuint ushort_types_scale[4] = {
 121    PIPE_FORMAT_R16_USCALED,
 122    PIPE_FORMAT_R16G16_USCALED,
 123    PIPE_FORMAT_R16G16B16_USCALED,
 124    PIPE_FORMAT_R16G16B16A16_USCALED
 125 };
 126
 127 static GLuint short_types_norm[4] = {
 128    PIPE_FORMAT_R16_SNORM,
 129    PIPE_FORMAT_R16G16_SNORM,
 130    PIPE_FORMAT_R16G16B16_SNORM,
 131    PIPE_FORMAT_R16G16B16A16_SNORM
 132 };
 133
 134 static GLuint short_types_scale[4] = {
 135    PIPE_FORMAT_R16_SSCALED,
 136    PIPE_FORMAT_R16G16_SSCALED,
 137    PIPE_FORMAT_R16G16B16_SSCALED,
 138    PIPE_FORMAT_R16G16B16A16_SSCALED
 139 };
 140
 141 static GLuint ubyte_types_norm[4] = {
 142    PIPE_FORMAT_R8_UNORM,
 143    PIPE_FORMAT_R8G8_UNORM,
 144    PIPE_FORMAT_R8G8B8_UNORM,
 145    PIPE_FORMAT_R8G8B8A8_UNORM
 146 };
 147
 148 static GLuint ubyte_types_scale[4] = {
 149    PIPE_FORMAT_R8_USCALED,
 150    PIPE_FORMAT_R8G8_USCALED,
 151    PIPE_FORMAT_R8G8B8_USCALED,
 152    PIPE_FORMAT_R8G8B8A8_USCALED
 153 };
 154
 155 static GLuint byte_types_norm[4] = {
 156    PIPE_FORMAT_R8_SNORM,
 157    PIPE_FORMAT_R8G8_SNORM,
 158    PIPE_FORMAT_R8G8B8_SNORM,
 159    PIPE_FORMAT_R8G8B8A8_SNORM
 160 };
 161
 162 static GLuint byte_types_scale[4] = {
 163    PIPE_FORMAT_R8_SSCALED,
 164    PIPE_FORMAT_R8G8_SSCALED,
 165    PIPE_FORMAT_R8G8B8_SSCALED,
 166    PIPE_FORMAT_R8G8B8A8_SSCALED
 167 };
 168
 169 static GLuint fixed_types[4] = {
 170    PIPE_FORMAT_R32_FIXED,
 171    PIPE_FORMAT_R32G32_FIXED,
 172    PIPE_FORMAT_R32G32B32_FIXED,
 173    PIPE_FORMAT_R32G32B32A32_FIXED
 174 };
 175
 176
 177
 178 /**
 179  * Return a PIPE_FORMAT_x for the given GL datatype and size.
 180  */
 181 GLuint
 182 st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
 183                       GLboolean normalized)
 184 {
 185    assert((type >= GL_BYTE && type <= GL_DOUBLE) ||
 186           type == GL_FIXED || type == GL_HALF_FLOAT);
 187    assert(size >= 1);
 188    assert(size <= 4);
 189    assert(format == GL_RGBA || format == GL_BGRA);
 190
 191    if (format == GL_BGRA) {
 192       /* this is an odd-ball case */
 193       assert(type == GL_UNSIGNED_BYTE);
 194       assert(normalized);
 195       return PIPE_FORMAT_B8G8R8A8_UNORM;
 196    }
 197
 198    if (normalized) {
 199       switch (type) {
 200       case GL_DOUBLE: return double_types[size-1];
 201       case GL_FLOAT: return float_types[size-1];
 202       case GL_HALF_FLOAT: return half_float_types[size-1];
 203       case GL_INT: return int_types_norm[size-1];
 204       case GL_SHORT: return short_types_norm[size-1];
 205       case GL_BYTE: return byte_types_norm[size-1];
 206       case GL_UNSIGNED_INT: return uint_types_norm[size-1];
 207       case GL_UNSIGNED_SHORT: return ushort_types_norm[size-1];
 208       case GL_UNSIGNED_BYTE: return ubyte_types_norm[size-1];
 209       case GL_FIXED: return fixed_types[size-1];
 210       default: assert(0); return 0;
 211       }
 212    }
 213    else {
 214       switch (type) {
 215       case GL_DOUBLE: return double_types[size-1];
 216       case GL_FLOAT: return float_types[size-1];
 217       case GL_HALF_FLOAT: return half_float_types[size-1];
 218       case GL_INT: return int_types_scale[size-1];
 219       case GL_SHORT: return short_types_scale[size-1];
 220       case GL_BYTE: return byte_types_scale[size-1];
 221       case GL_UNSIGNED_INT: return uint_types_scale[size-1];
 222       case GL_UNSIGNED_SHORT: return ushort_types_scale[size-1];
 223       case GL_UNSIGNED_BYTE: return ubyte_types_scale[size-1];
 224       case GL_FIXED: return fixed_types[size-1];
 225       default: assert(0); return 0;
 226       }
 227    }
 228    return 0; /* silence compiler warning */
 229 }
 230
 231
 232
 233
 234
 235 /**
 236  * Examine the active arrays to determine if we have interleaved
 237  * vertex arrays all living in one VBO, or all living in user space.
 238  * \param userSpace  returns whether the arrays are in user space.
 239  */
 240 static GLboolean
 241 is_interleaved_arrays(const struct st_vertex_program *vp,
 242                       const struct st_vp_varient *vpv,
 243                       const struct gl_client_array **arrays,
 244                       GLboolean *userSpace)
 245 {
 246    GLuint attr;
 247    const struct gl_buffer_object *firstBufObj = NULL;
 248    GLint firstStride = -1;
 249    GLuint num_client_arrays = 0;
 250    const GLubyte *client_addr = NULL;
 251
 252    for (attr = 0; attr < vpv->num_inputs; attr++) {
 253       const GLuint mesaAttr = vp->index_to_input[attr];
 254       const struct gl_buffer_object *bufObj = arrays[mesaAttr]->BufferObj;
 255       const GLsizei stride = arrays[mesaAttr]->StrideB; /* in bytes */
 256
 257       if (firstStride < 0) {
 258          firstStride = stride;
 259       }
 260       else if (firstStride != stride) {
 261          return GL_FALSE;
 262       }
 263
 264       if (!bufObj || !bufObj->Name) {
 265          num_client_arrays++;
 266          /* Try to detect if the client-space arrays are
 267           * "close" to each other.
 268           */
 269          if (!client_addr) {
 270             client_addr = arrays[mesaAttr]->Ptr;
 271          }
 272          else if (abs(arrays[mesaAttr]->Ptr - client_addr) > firstStride) {
 273             /* arrays start too far apart */
 274             return GL_FALSE;
 275          }
 276       }
 277       else if (!firstBufObj) {
 278          firstBufObj = bufObj;
 279       }
 280       else if (bufObj != firstBufObj) {
 281          return GL_FALSE;
 282       }
 283    }
 284
 285    *userSpace = (num_client_arrays == vpv->num_inputs);
 286    /* debug_printf("user space: %s (%d arrays, %d inputs)\n",
 287       (int)*userSpace ? "Yes" : "No", num_client_arrays, vp->num_inputs); */
 288
 289    return GL_TRUE;
 290 }
 291
 292
 293 /**
 294  * Compute the memory range occupied by the arrays.
 295  */
 296 static void
 297 get_arrays_bounds(const struct st_vertex_program *vp,
 298                   const struct st_vp_varient *vpv,
 299                   const struct gl_client_array **arrays,
 300                   GLuint max_index,
 301                   const GLubyte **low, const GLubyte **high)
 302 {
 303    const GLubyte *low_addr = NULL;
 304    const GLubyte *high_addr = NULL;
 305    GLuint attr;
 306
 307    /* debug_printf("get_arrays_bounds: Handling %u attrs\n", vpv->num_inputs); */
 308
 309    for (attr = 0; attr < vpv->num_inputs; attr++) {
 310       const GLuint mesaAttr = vp->index_to_input[attr];
 311       const GLint stride = arrays[mesaAttr]->StrideB;
 312       const GLubyte *start = arrays[mesaAttr]->Ptr;
 313       const unsigned sz = (arrays[mesaAttr]->Size *
 314                            _mesa_sizeof_type(arrays[mesaAttr]->Type));
 315       const GLubyte *end = start + (max_index * stride) + sz;
 316
 317       /* debug_printf("attr %u: stride %d size %u start %p end %p\n",
 318          attr, stride, sz, start, end); */
 319
 320       if (attr == 0) {
 321          low_addr = start;
 322          high_addr = end;
 323       }
 324       else {
 325          low_addr = MIN2(low_addr, start);
 326          high_addr = MAX2(high_addr, end);
 327       }
 328    }
 329
 330    *low = low_addr;
 331    *high = high_addr;
 332 }
 333
 334
 335 /**
 336  * Set up for drawing interleaved arrays that all live in one VBO
 337  * or all live in user space.
 338  * \param vbuffer  returns vertex buffer info
 339  * \param velements  returns vertex element info
 340  */
 341 static void
 342 setup_interleaved_attribs(GLcontext *ctx,
 343                           const struct st_vertex_program *vp,
 344                           const struct st_vp_varient *vpv,
 345                           const struct gl_client_array **arrays,
 346                           GLuint max_index,
 347                           GLboolean userSpace,
 348                           struct pipe_vertex_buffer *vbuffer,
 349                           struct pipe_vertex_element velements[])
 350 {
 351    struct st_context *st = st_context(ctx);
 352    struct pipe_context *pipe = st->pipe;
 353    GLuint attr;
 354    const GLubyte *offset0 = NULL;
 355
 356    for (attr = 0; attr < vpv->num_inputs; attr++) {
 357       const GLuint mesaAttr = vp->index_to_input[attr];
 358       struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
 359       struct st_buffer_object *stobj = st_buffer_object(bufobj);
 360       GLsizei stride = arrays[mesaAttr]->StrideB;
 361
 362       /*printf("stobj %u = %p\n", attr, (void*)stobj);*/
 363
 364       if (attr == 0) {
 365          const GLubyte *low, *high;
 366
 367          get_arrays_bounds(vp, vpv, arrays, max_index, &low, &high);
 368          /* debug_printf("buffer range: %p %p range %d max index %u\n",
 369             low, high, high - low, max_index); */
 370
 371          offset0 = low;
 372          if (userSpace) {
 373             vbuffer->buffer =
 374                pipe_user_buffer_create(pipe->screen, (void *) low, high - low,
 375                                        PIPE_BIND_VERTEX_BUFFER);
 376             vbuffer->buffer_offset = 0;
 377          }
 378          else {
 379             vbuffer->buffer = NULL;
 380             pipe_resource_reference(&vbuffer->buffer, stobj->buffer);
 381             vbuffer->buffer_offset = pointer_to_offset(low);
 382          }
 383          vbuffer->stride = stride; /* in bytes */
 384          vbuffer->max_index = max_index;
 385       }
 386
 387       velements[attr].src_offset =
 388          (unsigned) (arrays[mesaAttr]->Ptr - offset0);
 389       velements[attr].instance_divisor = 0;
 390       velements[attr].vertex_buffer_index = 0;
 391       velements[attr].src_format =
 392          st_pipe_vertex_format(arrays[mesaAttr]->Type,
 393                                arrays[mesaAttr]->Size,
 394                                arrays[mesaAttr]->Format,
 395                                arrays[mesaAttr]->Normalized);
 396       assert(velements[attr].src_format);
 397    }
 398 }
 399
 400
 401 /**
 402  * Set up a separate pipe_vertex_buffer and pipe_vertex_element for each
 403  * vertex attribute.
 404  * \param vbuffer  returns vertex buffer info
 405  * \param velements  returns vertex element info
 406  */
 407 static void
 408 setup_non_interleaved_attribs(GLcontext *ctx,
 409                               const struct st_vertex_program *vp,
 410                               const struct st_vp_varient *vpv,
 411                               const struct gl_client_array **arrays,
 412                               GLuint max_index,
 413                               GLboolean *userSpace,
 414                               struct pipe_vertex_buffer vbuffer[],
 415                               struct pipe_vertex_element velements[])
 416 {
 417    struct st_context *st = st_context(ctx);
 418    struct pipe_context *pipe = st->pipe;
 419    GLuint attr;
 420
 421    for (attr = 0; attr < vpv->num_inputs; attr++) {
 422       const GLuint mesaAttr = vp->index_to_input[attr];
 423       struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
 424       GLsizei stride = arrays[mesaAttr]->StrideB;
 425
 426       *userSpace = GL_FALSE;
 427
 428       if (bufobj && bufobj->Name) {
 429          /* Attribute data is in a VBO.
 430           * Recall that for VBOs, the gl_client_array->Ptr field is
 431           * really an offset from the start of the VBO, not a pointer.
 432           */
 433          struct st_buffer_object *stobj = st_buffer_object(bufobj);
 434          assert(stobj->buffer);
 435          /*printf("stobj %u = %p\n", attr, (void*) stobj);*/
 436
 437          vbuffer[attr].buffer = NULL;
 438          pipe_resource_reference(&vbuffer[attr].buffer, stobj->buffer);
 439          vbuffer[attr].buffer_offset = pointer_to_offset(arrays[mesaAttr]->Ptr);
 440          velements[attr].src_offset = 0;
 441       }
 442       else {
 443          /* attribute data is in user-space memory, not a VBO */
 444          uint bytes;
 445          /*printf("user-space array %d stride %d\n", attr, stride);*/
 446
 447          *userSpace = GL_TRUE;
 448
 449          /* wrap user data */
 450          if (arrays[mesaAttr]->Ptr) {
 451             /* user's vertex array */
 452             if (arrays[mesaAttr]->StrideB) {
 453                bytes = arrays[mesaAttr]->StrideB * (max_index + 1);
 454             }
 455             else {
 456                bytes = arrays[mesaAttr]->Size
 457                   * _mesa_sizeof_type(arrays[mesaAttr]->Type);
 458             }
 459             vbuffer[attr].buffer =
 460                pipe_user_buffer_create(pipe->screen,
 461                                        (void *) arrays[mesaAttr]->Ptr, bytes,
 462                                        PIPE_BIND_VERTEX_BUFFER);
 463          }
 464          else {
 465             /* no array, use ctx->Current.Attrib[] value */
 466             bytes = sizeof(ctx->Current.Attrib[0]);
 467             vbuffer[attr].buffer =
 468                pipe_user_buffer_create(pipe->screen,
 469                                        (void *) ctx->Current.Attrib[mesaAttr],
 470                                        bytes,
 471                                        PIPE_BIND_VERTEX_BUFFER);
 472             stride = 0;
 473          }
 474
 475          vbuffer[attr].buffer_offset = 0;
 476          velements[attr].src_offset = 0;
 477       }
 478
 479       assert(velements[attr].src_offset <= 2048); /* 11-bit field */
 480
 481       /* common-case setup */
 482       vbuffer[attr].stride = stride; /* in bytes */
 483       vbuffer[attr].max_index = max_index;
 484       velements[attr].instance_divisor = 0;
 485       velements[attr].vertex_buffer_index = attr;
 486       velements[attr].src_format
 487          = st_pipe_vertex_format(arrays[mesaAttr]->Type,
 488                                  arrays[mesaAttr]->Size,
 489                                  arrays[mesaAttr]->Format,
 490                                  arrays[mesaAttr]->Normalized);
 491       assert(velements[attr].src_format);
 492    }
 493 }
 494
 495
 496
 497 /**
 498  * Prior to drawing, check that any uniforms referenced by the
 499  * current shader have been set.  If a uniform has not been set,
 500  * issue a warning.
 501  */
 502 static void
 503 check_uniforms(GLcontext *ctx)
 504 {
 505    const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
 506    if (shProg && shProg->LinkStatus) {
 507       GLuint i;
 508       for (i = 0; i < shProg->Uniforms->NumUniforms; i++) {
 509          const struct gl_uniform *u = &shProg->Uniforms->Uniforms[i];
 510          if (!u->Initialized) {
 511             _mesa_warning(ctx,
 512                           "Using shader with uninitialized uniform: %s",
 513                           u->Name);
 514          }
 515       }
 516    }
 517 }
 518
 519
 520 static unsigned translate_prim( GLcontext *ctx,
 521                                 unsigned prim )
 522 {
 523    /* Avoid quadstrips if it's easy to do so:
 524     */
 525    if (prim == GL_QUAD_STRIP &&
 526        ctx->Light.ShadeModel != GL_FLAT &&
 527        ctx->Polygon.FrontMode == GL_FILL &&
 528        ctx->Polygon.BackMode == GL_FILL)
 529       prim = GL_TRIANGLE_STRIP;
 530
 531    return prim;
 532 }
 533
 534 /**
 535  * This function gets plugged into the VBO module and is called when
 536  * we have something to render.
 537  * Basically, translate the information into the format expected by gallium.
 538  */
 539 void
 540 st_draw_vbo(GLcontext *ctx,
 541             const struct gl_client_array **arrays,
 542             const struct _mesa_prim *prims,
 543             GLuint nr_prims,
 544             const struct _mesa_index_buffer *ib,
 545             GLboolean index_bounds_valid,
 546             GLuint min_index,
 547             GLuint max_index)
 548 {
 549    struct st_context *st = st_context(ctx);
 550    struct pipe_context *pipe = st->pipe;
 551    const struct st_vertex_program *vp;
 552    const struct st_vp_varient *vpv;
 553    struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
 554    GLuint attr;
 555    struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
 556    unsigned num_vbuffers, num_velements;
 557    GLboolean userSpace = GL_FALSE;
 558    GLboolean vertDataEdgeFlags;
 559
 560    /* Mesa core state should have been validated already */
 561    assert(ctx->NewState == 0x0);
 562
 563    /* Gallium probably doesn't want this in some cases. */
 564    if (!index_bounds_valid)
 565       if (!vbo_all_varyings_in_vbos(arrays))
 566          vbo_get_minmax_index(ctx, prims, ib, &min_index, &max_index);
 567
 568    /* sanity check for pointer arithmetic below */
 569    assert(sizeof(arrays[0]->Ptr[0]) == 1);
 570
 571    vertDataEdgeFlags = arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj &&
 572                        arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj->Name;
 573    if (vertDataEdgeFlags != st->vertdata_edgeflags) {
 574       st->vertdata_edgeflags = vertDataEdgeFlags;
 575       st->dirty.st |= ST_NEW_EDGEFLAGS_DATA;
 576    }
 577
 578    st_validate_state(st);
 579
 580    /* must get these after state validation! */
 581    vp = st->vp;
 582    vpv = st->vp_varient;
 583
 584 #if 0
 585    if (MESA_VERBOSE & VERBOSE_GLSL) {
 586       check_uniforms(ctx);
 587    }
 588 #else
 589    (void) check_uniforms;
 590 #endif
 591
 592    memset(velements, 0, sizeof(struct pipe_vertex_element) * vpv->num_inputs);
 593    /*
 594     * Setup the vbuffer[] and velements[] arrays.
 595     */
 596    if (is_interleaved_arrays(vp, vpv, arrays, &userSpace)) {
 597       /*printf("Draw interleaved\n");*/
 598       setup_interleaved_attribs(ctx, vp, vpv, arrays, max_index, userSpace,
 599                                 vbuffer, velements);
 600       num_vbuffers = 1;
 601       num_velements = vpv->num_inputs;
 602       if (num_velements == 0)
 603          num_vbuffers = 0;
 604    }
 605    else {
 606       /*printf("Draw non-interleaved\n");*/
 607       setup_non_interleaved_attribs(ctx, vp, vpv, arrays, max_index,
 608                                     &userSpace, vbuffer, velements);
 609       num_vbuffers = vpv->num_inputs;
 610       num_velements = vpv->num_inputs;
 611    }
 612
 613 #if 0
 614    {
 615       GLuint i;
 616       for (i = 0; i < num_vbuffers; i++) {
 617          printf("buffers[%d].stride = %u\n", i, vbuffer[i].stride);
 618          printf("buffers[%d].max_index = %u\n", i, vbuffer[i].max_index);
 619          printf("buffers[%d].buffer_offset = %u\n", i, vbuffer[i].buffer_offset);
 620          printf("buffers[%d].buffer = %p\n", i, (void*) vbuffer[i].buffer);
 621       }
 622       for (i = 0; i < num_velements; i++) {
 623          printf("vlements[%d].vbuffer_index = %u\n", i, velements[i].vertex_buffer_index);
 624          printf("vlements[%d].src_offset = %u\n", i, velements[i].src_offset);
 625          printf("vlements[%d].format = %s\n", i, util_format_name(velements[i].src_format));
 626       }
 627    }
 628 #endif
 629
 630    pipe->set_vertex_buffers(pipe, num_vbuffers, vbuffer);
 631    cso_set_vertex_elements(st->cso_context, num_velements, velements);
 632
 633    if (num_vbuffers == 0 || num_velements == 0)
 634       return;
 635
 636    /* do actual drawing */
 637    if (ib) {
 638       /* indexed primitive */
 639       struct gl_buffer_object *bufobj = ib->obj;
 640       struct pipe_resource *indexBuf = NULL;
 641       unsigned indexSize, indexOffset, i;
 642       unsigned prim;
 643
 644       switch (ib->type) {
 645       case GL_UNSIGNED_INT:
 646          indexSize = 4;
 647          break;
 648       case GL_UNSIGNED_SHORT:
 649          indexSize = 2;
 650          break;
 651       case GL_UNSIGNED_BYTE:
 652          indexSize = 1;
 653          break;
 654       default:
 655          assert(0);
 656          return;
 657       }
 658
 659       /* get/create the index buffer object */
 660       if (bufobj && bufobj->Name) {
 661          /* elements/indexes are in a real VBO */
 662          struct st_buffer_object *stobj = st_buffer_object(bufobj);
 663          pipe_resource_reference(&indexBuf, stobj->buffer);
 664          indexOffset = pointer_to_offset(ib->ptr) / indexSize;
 665       }
 666       else {
 667          /* element/indicies are in user space memory */
 668          indexBuf = pipe_user_buffer_create(pipe->screen, (void *) ib->ptr,
 669                                             ib->count * indexSize,
 670                                             PIPE_BIND_INDEX_BUFFER);
 671          indexOffset = 0;
 672       }
 673
 674       /* draw */
 675       if (pipe->draw_range_elements && min_index != ~0 && max_index != ~0) {
 676          /* XXX: exercise temporary path to pass min/max directly
 677           * through to driver & draw module.  These interfaces still
 678           * need a bit of work...
 679           */
 680          for (i = 0; i < nr_prims; i++) {
 681             prim = translate_prim( ctx, prims[i].mode );
 682
 683             pipe->draw_range_elements(pipe, indexBuf, indexSize, 0,
 684                                       min_index, max_index, prim,
 685                                       prims[i].start + indexOffset, prims[i].count);
 686          }
 687       }
 688       else {
 689          for (i = 0; i < nr_prims; i++) {
 690             prim = translate_prim( ctx, prims[i].mode );
 691
 692             if (prims[i].num_instances == 1) {
 693                pipe->draw_elements(pipe, indexBuf, indexSize, 0, prim,
 694                                    prims[i].start + indexOffset,
 695                                    prims[i].count);
 696             }
 697             else {
 698                pipe->draw_elements_instanced(pipe, indexBuf, indexSize, 0, prim,
 699                                              prims[i].start + indexOffset,
 700                                              prims[i].count,
 701                                              0, prims[i].num_instances);
 702             }
 703          }
 704       }
 705
 706       pipe_resource_reference(&indexBuf, NULL);
 707    }
 708    else {
 709       /* non-indexed */
 710       GLuint i;
 711       GLuint prim;
 712
 713       for (i = 0; i < nr_prims; i++) {
 714          prim = translate_prim( ctx, prims[i].mode );
 715
 716          if (prims[i].num_instances == 1) {
 717             pipe->draw_arrays(pipe, prim, prims[i].start, prims[i].count);
 718          }
 719          else {
 720             pipe->draw_arrays_instanced(pipe, prim, prims[i].start,
 721                                         prims[i].count,
 722                                         0, prims[i].num_instances);
 723          }
 724       }
 725    }
 726
 727    /* unreference buffers (frees wrapped user-space buffer objects) */
 728    for (attr = 0; attr < num_vbuffers; attr++) {
 729       pipe_resource_reference(&vbuffer[attr].buffer, NULL);
 730       assert(!vbuffer[attr].buffer);
 731    }
 732
 733    if (userSpace)
 734    {
 735       pipe->set_vertex_buffers(pipe, 0, NULL);
 736    }
 737 }
 738
 739
 740 void st_init_draw( struct st_context *st )
 741 {
 742    GLcontext *ctx = st->ctx;
 743
 744    vbo_set_draw_func(ctx, st_draw_vbo);
 745
 746 #if FEATURE_feedback || FEATURE_rastpos
 747    st->draw = draw_create(st->pipe); /* for selection/feedback */
 748
 749    /* Disable draw options that might convert points/lines to tris, etc.
 750     * as that would foul-up feedback/selection mode.
 751     */
 752    draw_wide_line_threshold(st->draw, 1000.0f);
 753    draw_wide_point_threshold(st->draw, 1000.0f);
 754    draw_enable_line_stipple(st->draw, FALSE);
 755    draw_enable_point_sprites(st->draw, FALSE);
 756 #endif
 757 }
 758
 759
 760 void st_destroy_draw( struct st_context *st )
 761 {
 762 #if FEATURE_feedback || FEATURE_rastpos
 763    draw_destroy(st->draw);
 764 #endif
 765 }
 766
 767