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_vbo().
  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/bufferobj.h"
  46 #include "main/macros.h"
  47 #include "main/mfeatures.h"
  48
  49 #include "vbo/vbo.h"
  50
  51 #include "st_context.h"
  52 #include "st_atom.h"
  53 #include "st_cb_bufferobjects.h"
  54 #include "st_cb_xformfb.h"
  55 #include "st_draw.h"
  56 #include "st_program.h"
  57
  58 #include "pipe/p_context.h"
  59 #include "pipe/p_defines.h"
  60 #include "util/u_inlines.h"
  61 #include "util/u_format.h"
  62 #include "util/u_prim.h"
  63 #include "util/u_draw_quad.h"
  64 #include "util/u_upload_mgr.h"
  65 #include "draw/draw_context.h"
  66 #include "cso_cache/cso_context.h"
  67
  68 #include "../glsl/ir_uniform.h"
  69
  70
  71 static GLuint double_types[4] = {
  72    PIPE_FORMAT_R64_FLOAT,
  73    PIPE_FORMAT_R64G64_FLOAT,
  74    PIPE_FORMAT_R64G64B64_FLOAT,
  75    PIPE_FORMAT_R64G64B64A64_FLOAT
  76 };
  77
  78 static GLuint float_types[4] = {
  79    PIPE_FORMAT_R32_FLOAT,
  80    PIPE_FORMAT_R32G32_FLOAT,
  81    PIPE_FORMAT_R32G32B32_FLOAT,
  82    PIPE_FORMAT_R32G32B32A32_FLOAT
  83 };
  84
  85 static GLuint half_float_types[4] = {
  86    PIPE_FORMAT_R16_FLOAT,
  87    PIPE_FORMAT_R16G16_FLOAT,
  88    PIPE_FORMAT_R16G16B16_FLOAT,
  89    PIPE_FORMAT_R16G16B16A16_FLOAT
  90 };
  91
  92 static GLuint uint_types_norm[4] = {
  93    PIPE_FORMAT_R32_UNORM,
  94    PIPE_FORMAT_R32G32_UNORM,
  95    PIPE_FORMAT_R32G32B32_UNORM,
  96    PIPE_FORMAT_R32G32B32A32_UNORM
  97 };
  98
  99 static GLuint uint_types_scale[4] = {
 100    PIPE_FORMAT_R32_USCALED,
 101    PIPE_FORMAT_R32G32_USCALED,
 102    PIPE_FORMAT_R32G32B32_USCALED,
 103    PIPE_FORMAT_R32G32B32A32_USCALED
 104 };
 105
 106 static GLuint uint_types_int[4] = {
 107    PIPE_FORMAT_R32_UINT,
 108    PIPE_FORMAT_R32G32_UINT,
 109    PIPE_FORMAT_R32G32B32_UINT,
 110    PIPE_FORMAT_R32G32B32A32_UINT
 111 };
 112
 113 static GLuint int_types_norm[4] = {
 114    PIPE_FORMAT_R32_SNORM,
 115    PIPE_FORMAT_R32G32_SNORM,
 116    PIPE_FORMAT_R32G32B32_SNORM,
 117    PIPE_FORMAT_R32G32B32A32_SNORM
 118 };
 119
 120 static GLuint int_types_scale[4] = {
 121    PIPE_FORMAT_R32_SSCALED,
 122    PIPE_FORMAT_R32G32_SSCALED,
 123    PIPE_FORMAT_R32G32B32_SSCALED,
 124    PIPE_FORMAT_R32G32B32A32_SSCALED
 125 };
 126
 127 static GLuint int_types_int[4] = {
 128    PIPE_FORMAT_R32_SINT,
 129    PIPE_FORMAT_R32G32_SINT,
 130    PIPE_FORMAT_R32G32B32_SINT,
 131    PIPE_FORMAT_R32G32B32A32_SINT
 132 };
 133
 134 static GLuint ushort_types_norm[4] = {
 135    PIPE_FORMAT_R16_UNORM,
 136    PIPE_FORMAT_R16G16_UNORM,
 137    PIPE_FORMAT_R16G16B16_UNORM,
 138    PIPE_FORMAT_R16G16B16A16_UNORM
 139 };
 140
 141 static GLuint ushort_types_scale[4] = {
 142    PIPE_FORMAT_R16_USCALED,
 143    PIPE_FORMAT_R16G16_USCALED,
 144    PIPE_FORMAT_R16G16B16_USCALED,
 145    PIPE_FORMAT_R16G16B16A16_USCALED
 146 };
 147
 148 static GLuint ushort_types_int[4] = {
 149    PIPE_FORMAT_R16_UINT,
 150    PIPE_FORMAT_R16G16_UINT,
 151    PIPE_FORMAT_R16G16B16_UINT,
 152    PIPE_FORMAT_R16G16B16A16_UINT
 153 };
 154
 155 static GLuint short_types_norm[4] = {
 156    PIPE_FORMAT_R16_SNORM,
 157    PIPE_FORMAT_R16G16_SNORM,
 158    PIPE_FORMAT_R16G16B16_SNORM,
 159    PIPE_FORMAT_R16G16B16A16_SNORM
 160 };
 161
 162 static GLuint short_types_scale[4] = {
 163    PIPE_FORMAT_R16_SSCALED,
 164    PIPE_FORMAT_R16G16_SSCALED,
 165    PIPE_FORMAT_R16G16B16_SSCALED,
 166    PIPE_FORMAT_R16G16B16A16_SSCALED
 167 };
 168
 169 static GLuint short_types_int[4] = {
 170    PIPE_FORMAT_R16_SINT,
 171    PIPE_FORMAT_R16G16_SINT,
 172    PIPE_FORMAT_R16G16B16_SINT,
 173    PIPE_FORMAT_R16G16B16A16_SINT
 174 };
 175
 176 static GLuint ubyte_types_norm[4] = {
 177    PIPE_FORMAT_R8_UNORM,
 178    PIPE_FORMAT_R8G8_UNORM,
 179    PIPE_FORMAT_R8G8B8_UNORM,
 180    PIPE_FORMAT_R8G8B8A8_UNORM
 181 };
 182
 183 static GLuint ubyte_types_scale[4] = {
 184    PIPE_FORMAT_R8_USCALED,
 185    PIPE_FORMAT_R8G8_USCALED,
 186    PIPE_FORMAT_R8G8B8_USCALED,
 187    PIPE_FORMAT_R8G8B8A8_USCALED
 188 };
 189
 190 static GLuint ubyte_types_int[4] = {
 191    PIPE_FORMAT_R8_UINT,
 192    PIPE_FORMAT_R8G8_UINT,
 193    PIPE_FORMAT_R8G8B8_UINT,
 194    PIPE_FORMAT_R8G8B8A8_UINT
 195 };
 196
 197 static GLuint byte_types_norm[4] = {
 198    PIPE_FORMAT_R8_SNORM,
 199    PIPE_FORMAT_R8G8_SNORM,
 200    PIPE_FORMAT_R8G8B8_SNORM,
 201    PIPE_FORMAT_R8G8B8A8_SNORM
 202 };
 203
 204 static GLuint byte_types_scale[4] = {
 205    PIPE_FORMAT_R8_SSCALED,
 206    PIPE_FORMAT_R8G8_SSCALED,
 207    PIPE_FORMAT_R8G8B8_SSCALED,
 208    PIPE_FORMAT_R8G8B8A8_SSCALED
 209 };
 210
 211 static GLuint byte_types_int[4] = {
 212    PIPE_FORMAT_R8_SINT,
 213    PIPE_FORMAT_R8G8_SINT,
 214    PIPE_FORMAT_R8G8B8_SINT,
 215    PIPE_FORMAT_R8G8B8A8_SINT
 216 };
 217
 218 static GLuint fixed_types[4] = {
 219    PIPE_FORMAT_R32_FIXED,
 220    PIPE_FORMAT_R32G32_FIXED,
 221    PIPE_FORMAT_R32G32B32_FIXED,
 222    PIPE_FORMAT_R32G32B32A32_FIXED
 223 };
 224
 225
 226
 227 /**
 228  * Return a PIPE_FORMAT_x for the given GL datatype and size.
 229  */
 230 enum pipe_format
 231 st_pipe_vertex_format(GLenum type, GLuint size, GLenum format,
 232                       GLboolean normalized, GLboolean integer)
 233 {
 234    assert((type >= GL_BYTE && type <= GL_DOUBLE) ||
 235           type == GL_FIXED || type == GL_HALF_FLOAT ||
 236           type == GL_INT_2_10_10_10_REV ||
 237           type == GL_UNSIGNED_INT_2_10_10_10_REV);
 238    assert(size >= 1);
 239    assert(size <= 4);
 240    assert(format == GL_RGBA || format == GL_BGRA);
 241
 242    if (type == GL_INT_2_10_10_10_REV ||
 243        type == GL_UNSIGNED_INT_2_10_10_10_REV) {
 244       assert(size == 4);
 245       assert(!integer);
 246
 247       if (format == GL_BGRA) {
 248          if (type == GL_INT_2_10_10_10_REV) {
 249             if (normalized)
 250                return PIPE_FORMAT_B10G10R10A2_SNORM;
 251             else
 252                return PIPE_FORMAT_B10G10R10A2_SSCALED;
 253          } else {
 254             if (normalized)
 255                return PIPE_FORMAT_B10G10R10A2_UNORM;
 256             else
 257                return PIPE_FORMAT_B10G10R10A2_USCALED;
 258          }
 259       } else {
 260          if (type == GL_INT_2_10_10_10_REV) {
 261             if (normalized)
 262                return PIPE_FORMAT_R10G10B10A2_SNORM;
 263             else
 264                return PIPE_FORMAT_R10G10B10A2_SSCALED;
 265          } else {
 266             if (normalized)
 267                return PIPE_FORMAT_R10G10B10A2_UNORM;
 268             else
 269                return PIPE_FORMAT_R10G10B10A2_USCALED;
 270          }
 271       }
 272    }
 273
 274    if (format == GL_BGRA) {
 275       /* this is an odd-ball case */
 276       assert(type == GL_UNSIGNED_BYTE);
 277       assert(normalized);
 278       return PIPE_FORMAT_B8G8R8A8_UNORM;
 279    }
 280
 281    if (integer) {
 282       switch (type) {
 283       case GL_INT: return int_types_int[size-1];
 284       case GL_SHORT: return short_types_int[size-1];
 285       case GL_BYTE: return byte_types_int[size-1];
 286       case GL_UNSIGNED_INT: return uint_types_int[size-1];
 287       case GL_UNSIGNED_SHORT: return ushort_types_int[size-1];
 288       case GL_UNSIGNED_BYTE: return ubyte_types_int[size-1];
 289       default: assert(0); return 0;
 290       }
 291    }
 292    else if (normalized) {
 293       switch (type) {
 294       case GL_DOUBLE: return double_types[size-1];
 295       case GL_FLOAT: return float_types[size-1];
 296       case GL_HALF_FLOAT: return half_float_types[size-1];
 297       case GL_INT: return int_types_norm[size-1];
 298       case GL_SHORT: return short_types_norm[size-1];
 299       case GL_BYTE: return byte_types_norm[size-1];
 300       case GL_UNSIGNED_INT: return uint_types_norm[size-1];
 301       case GL_UNSIGNED_SHORT: return ushort_types_norm[size-1];
 302       case GL_UNSIGNED_BYTE: return ubyte_types_norm[size-1];
 303       case GL_FIXED: return fixed_types[size-1];
 304       default: assert(0); return 0;
 305       }
 306    }
 307    else {
 308       switch (type) {
 309       case GL_DOUBLE: return double_types[size-1];
 310       case GL_FLOAT: return float_types[size-1];
 311       case GL_HALF_FLOAT: return half_float_types[size-1];
 312       case GL_INT: return int_types_scale[size-1];
 313       case GL_SHORT: return short_types_scale[size-1];
 314       case GL_BYTE: return byte_types_scale[size-1];
 315       case GL_UNSIGNED_INT: return uint_types_scale[size-1];
 316       case GL_UNSIGNED_SHORT: return ushort_types_scale[size-1];
 317       case GL_UNSIGNED_BYTE: return ubyte_types_scale[size-1];
 318       case GL_FIXED: return fixed_types[size-1];
 319       default: assert(0); return 0;
 320       }
 321    }
 322    return PIPE_FORMAT_NONE; /* silence compiler warning */
 323 }
 324
 325
 326 /**
 327  * This is very similar to vbo_all_varyings_in_vbos() but we are
 328  * only interested in per-vertex data.  See bug 38626.
 329  */
 330 static GLboolean
 331 all_varyings_in_vbos(const struct gl_client_array *arrays[])
 332 {
 333    GLuint i;
 334
 335    for (i = 0; i < VERT_ATTRIB_MAX; i++)
 336       if (arrays[i]->StrideB &&
 337           !arrays[i]->InstanceDivisor &&
 338           !_mesa_is_bufferobj(arrays[i]->BufferObj))
 339          return GL_FALSE;
 340
 341    return GL_TRUE;
 342 }
 343
 344
 345 /**
 346  * Examine the active arrays to determine if we have interleaved
 347  * vertex arrays all living in one VBO, or all living in user space.
 348  */
 349 static GLboolean
 350 is_interleaved_arrays(const struct st_vertex_program *vp,
 351                       const struct st_vp_variant *vpv,
 352                       const struct gl_client_array **arrays)
 353 {
 354    GLuint attr;
 355    const struct gl_buffer_object *firstBufObj = NULL;
 356    GLint firstStride = -1;
 357    const GLubyte *firstPtr = NULL;
 358    GLboolean userSpaceBuffer = GL_FALSE;
 359
 360    for (attr = 0; attr < vpv->num_inputs; attr++) {
 361       const GLuint mesaAttr = vp->index_to_input[attr];
 362       const struct gl_client_array *array = arrays[mesaAttr];
 363       const struct gl_buffer_object *bufObj = array->BufferObj;
 364       const GLsizei stride = array->StrideB; /* in bytes */
 365
 366       if (attr == 0) {
 367          /* save info about the first array */
 368          firstStride = stride;
 369          firstPtr = array->Ptr;
 370          firstBufObj = bufObj;
 371          userSpaceBuffer = !bufObj || !bufObj->Name;
 372       }
 373       else {
 374          /* check if other arrays interleave with the first, in same buffer */
 375          if (stride != firstStride)
 376             return GL_FALSE; /* strides don't match */
 377
 378          if (bufObj != firstBufObj)
 379             return GL_FALSE; /* arrays in different VBOs */
 380
 381          if (abs(array->Ptr - firstPtr) > firstStride)
 382             return GL_FALSE; /* arrays start too far apart */
 383
 384          if ((!_mesa_is_bufferobj(bufObj)) != userSpaceBuffer)
 385             return GL_FALSE; /* mix of VBO and user-space arrays */
 386       }
 387    }
 388
 389    return GL_TRUE;
 390 }
 391
 392
 393 /**
 394  * Set up for drawing interleaved arrays that all live in one VBO
 395  * or all live in user space.
 396  * \param vbuffer  returns vertex buffer info
 397  * \param velements  returns vertex element info
 398  * \return GL_TRUE for success, GL_FALSE otherwise (probably out of memory)
 399  */
 400 static GLboolean
 401 setup_interleaved_attribs(struct gl_context *ctx,
 402                           const struct st_vertex_program *vp,
 403                           const struct st_vp_variant *vpv,
 404                           const struct gl_client_array **arrays,
 405                           struct pipe_vertex_buffer *vbuffer,
 406                           struct pipe_vertex_element velements[])
 407 {
 408    GLuint attr;
 409    const GLubyte *low_addr = NULL;
 410    GLboolean usingVBO;      /* all arrays in a VBO? */
 411    struct gl_buffer_object *bufobj;
 412    GLsizei stride;
 413
 414    /* Find the lowest address of the arrays we're drawing,
 415     * Init bufobj and stride.
 416     */
 417    if (vpv->num_inputs) {
 418       const GLuint mesaAttr0 = vp->index_to_input[0];
 419       const struct gl_client_array *array = arrays[mesaAttr0];
 420
 421       /* Since we're doing interleaved arrays, we know there'll be at most
 422        * one buffer object and the stride will be the same for all arrays.
 423        * Grab them now.
 424        */
 425       bufobj = array->BufferObj;
 426       stride = array->StrideB;
 427
 428       low_addr = arrays[vp->index_to_input[0]]->Ptr;
 429
 430       for (attr = 1; attr < vpv->num_inputs; attr++) {
 431          const GLubyte *start = arrays[vp->index_to_input[attr]]->Ptr;
 432          low_addr = MIN2(low_addr, start);
 433       }
 434    }
 435    else {
 436       /* not sure we'll ever have zero inputs, but play it safe */
 437       bufobj = NULL;
 438       stride = 0;
 439       low_addr = 0;
 440    }
 441
 442    /* are the arrays in user space? */
 443    usingVBO = _mesa_is_bufferobj(bufobj);
 444
 445    for (attr = 0; attr < vpv->num_inputs; attr++) {
 446       const GLuint mesaAttr = vp->index_to_input[attr];
 447       const struct gl_client_array *array = arrays[mesaAttr];
 448       unsigned src_offset = (unsigned) (array->Ptr - low_addr);
 449       GLuint element_size = array->_ElementSize;
 450
 451       assert(element_size == array->Size * _mesa_sizeof_type(array->Type));
 452
 453       velements[attr].src_offset = src_offset;
 454       velements[attr].instance_divisor = array->InstanceDivisor;
 455       velements[attr].vertex_buffer_index = 0;
 456       velements[attr].src_format = st_pipe_vertex_format(array->Type,
 457                                                          array->Size,
 458                                                          array->Format,
 459                                                          array->Normalized,
 460                                                          array->Integer);
 461       assert(velements[attr].src_format);
 462    }
 463
 464    /*
 465     * Return the vbuffer info and setup user-space attrib info, if needed.
 466     */
 467    if (vpv->num_inputs == 0) {
 468       /* just defensive coding here */
 469       vbuffer->buffer = NULL;
 470       vbuffer->user_buffer = NULL;
 471       vbuffer->buffer_offset = 0;
 472       vbuffer->stride = 0;
 473    }
 474    else if (usingVBO) {
 475       /* all interleaved arrays in a VBO */
 476       struct st_buffer_object *stobj = st_buffer_object(bufobj);
 477
 478       if (!stobj || !stobj->buffer) {
 479          /* probably out of memory (or zero-sized buffer) */
 480          return GL_FALSE;
 481       }
 482
 483       vbuffer->buffer = stobj->buffer;
 484       vbuffer->user_buffer = NULL;
 485       vbuffer->buffer_offset = pointer_to_offset(low_addr);
 486       vbuffer->stride = stride;
 487    }
 488    else {
 489       /* all interleaved arrays in user memory */
 490       vbuffer->buffer = NULL;
 491       vbuffer->user_buffer = low_addr;
 492       vbuffer->buffer_offset = 0;
 493       vbuffer->stride = stride;
 494    }
 495
 496    return GL_TRUE;
 497 }
 498
 499
 500 /**
 501  * Set up a separate pipe_vertex_buffer and pipe_vertex_element for each
 502  * vertex attribute.
 503  * \param vbuffer  returns vertex buffer info
 504  * \param velements  returns vertex element info
 505  * \return GL_TRUE for success, GL_FALSE otherwise (probably out of memory)
 506  */
 507 static GLboolean
 508 setup_non_interleaved_attribs(struct gl_context *ctx,
 509                               const struct st_vertex_program *vp,
 510                               const struct st_vp_variant *vpv,
 511                               const struct gl_client_array **arrays,
 512                               struct pipe_vertex_buffer vbuffer[],
 513                               struct pipe_vertex_element velements[])
 514 {
 515    GLuint attr;
 516
 517    for (attr = 0; attr < vpv->num_inputs; attr++) {
 518       const GLuint mesaAttr = vp->index_to_input[attr];
 519       const struct gl_client_array *array = arrays[mesaAttr];
 520       struct gl_buffer_object *bufobj = array->BufferObj;
 521       GLsizei stride = array->StrideB;
 522
 523       assert(array->_ElementSize == array->Size * _mesa_sizeof_type(array->Type));
 524
 525       if (_mesa_is_bufferobj(bufobj)) {
 526          /* Attribute data is in a VBO.
 527           * Recall that for VBOs, the gl_client_array->Ptr field is
 528           * really an offset from the start of the VBO, not a pointer.
 529           */
 530          struct st_buffer_object *stobj = st_buffer_object(bufobj);
 531
 532          if (!stobj || !stobj->buffer) {
 533             /* probably out of memory (or zero-sized buffer) */
 534             return GL_FALSE;
 535          }
 536
 537          vbuffer[attr].buffer = stobj->buffer;
 538          vbuffer[attr].user_buffer = NULL;
 539          vbuffer[attr].buffer_offset = pointer_to_offset(array->Ptr);
 540       }
 541       else {
 542          /* wrap user data */
 543          void *ptr;
 544
 545          if (array->Ptr) {
 546             ptr = (void *) array->Ptr;
 547          }
 548          else {
 549             /* no array, use ctx->Current.Attrib[] value */
 550             ptr = (void *) ctx->Current.Attrib[mesaAttr];
 551             stride = 0;
 552          }
 553
 554          assert(ptr);
 555
 556          vbuffer[attr].buffer = NULL;
 557          vbuffer[attr].user_buffer = ptr;
 558          vbuffer[attr].buffer_offset = 0;
 559       }
 560
 561       /* common-case setup */
 562       vbuffer[attr].stride = stride; /* in bytes */
 563
 564       velements[attr].src_offset = 0;
 565       velements[attr].instance_divisor = array->InstanceDivisor;
 566       velements[attr].vertex_buffer_index = attr;
 567       velements[attr].src_format = st_pipe_vertex_format(array->Type,
 568                                                          array->Size,
 569                                                          array->Format,
 570                                                          array->Normalized,
 571                                                          array->Integer);
 572       assert(velements[attr].src_format);
 573    }
 574
 575    return GL_TRUE;
 576 }
 577
 578
 579 static void
 580 setup_index_buffer(struct st_context *st,
 581                    const struct _mesa_index_buffer *ib,
 582                    struct pipe_index_buffer *ibuffer)
 583 {
 584    struct gl_buffer_object *bufobj = ib->obj;
 585
 586    ibuffer->index_size = vbo_sizeof_ib_type(ib->type);
 587
 588    /* get/create the index buffer object */
 589    if (_mesa_is_bufferobj(bufobj)) {
 590       /* indices are in a real VBO */
 591       ibuffer->buffer = st_buffer_object(bufobj)->buffer;
 592       ibuffer->offset = pointer_to_offset(ib->ptr);
 593    }
 594    else if (st->indexbuf_uploader) {
 595       u_upload_data(st->indexbuf_uploader, 0, ib->count * ibuffer->index_size,
 596                     ib->ptr, &ibuffer->offset, &ibuffer->buffer);
 597       u_upload_unmap(st->indexbuf_uploader);
 598    }
 599    else {
 600       /* indices are in user space memory */
 601       ibuffer->user_buffer = ib->ptr;
 602    }
 603
 604    cso_set_index_buffer(st->cso_context, ibuffer);
 605 }
 606
 607
 608 /**
 609  * Prior to drawing, check that any uniforms referenced by the
 610  * current shader have been set.  If a uniform has not been set,
 611  * issue a warning.
 612  */
 613 static void
 614 check_uniforms(struct gl_context *ctx)
 615 {
 616    struct gl_shader_program *shProg[3] = {
 617       ctx->Shader.CurrentVertexProgram,
 618       ctx->Shader.CurrentGeometryProgram,
 619       ctx->Shader.CurrentFragmentProgram,
 620    };
 621    unsigned j;
 622
 623    for (j = 0; j < 3; j++) {
 624       unsigned i;
 625
 626       if (shProg[j] == NULL || !shProg[j]->LinkStatus)
 627          continue;
 628
 629       for (i = 0; i < shProg[j]->NumUserUniformStorage; i++) {
 630          const struct gl_uniform_storage *u = &shProg[j]->UniformStorage[i];
 631          if (!u->initialized) {
 632             _mesa_warning(ctx,
 633                           "Using shader with uninitialized uniform: %s",
 634                           u->name);
 635          }
 636       }
 637    }
 638 }
 639
 640
 641 /**
 642  * Translate OpenGL primtive type (GL_POINTS, GL_TRIANGLE_STRIP, etc) to
 643  * the corresponding Gallium type.
 644  */
 645 static unsigned
 646 translate_prim(const struct gl_context *ctx, unsigned prim)
 647 {
 648    /* GL prims should match Gallium prims, spot-check a few */
 649    assert(GL_POINTS == PIPE_PRIM_POINTS);
 650    assert(GL_QUADS == PIPE_PRIM_QUADS);
 651    assert(GL_TRIANGLE_STRIP_ADJACENCY == PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY);
 652
 653    /* Avoid quadstrips if it's easy to do so:
 654     * Note: it's important to do the correct trimming if we change the
 655     * prim type!  We do that wherever this function is called.
 656     */
 657    if (prim == GL_QUAD_STRIP &&
 658        ctx->Light.ShadeModel != GL_FLAT &&
 659        ctx->Polygon.FrontMode == GL_FILL &&
 660        ctx->Polygon.BackMode == GL_FILL)
 661       prim = GL_TRIANGLE_STRIP;
 662
 663    return prim;
 664 }
 665
 666
 667 /**
 668  * Setup vertex arrays and buffers prior to drawing.
 669  * \return GL_TRUE for success, GL_FALSE otherwise (probably out of memory)
 670  */
 671 static GLboolean
 672 st_validate_varrays(struct gl_context *ctx,
 673                     const struct gl_client_array **arrays)
 674 {
 675    struct st_context *st = st_context(ctx);
 676    const struct st_vertex_program *vp;
 677    const struct st_vp_variant *vpv;
 678    struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
 679    struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
 680    unsigned num_vbuffers, num_velements;
 681
 682    /* must get these after state validation! */
 683    vp = st->vp;
 684    vpv = st->vp_variant;
 685
 686    memset(velements, 0, sizeof(struct pipe_vertex_element) * vpv->num_inputs);
 687
 688    /*
 689     * Setup the vbuffer[] and velements[] arrays.
 690     */
 691    if (is_interleaved_arrays(vp, vpv, arrays)) {
 692       if (!setup_interleaved_attribs(ctx, vp, vpv, arrays, vbuffer,
 693                                      velements)) {
 694          return GL_FALSE;
 695       }
 696
 697       num_vbuffers = 1;
 698       num_velements = vpv->num_inputs;
 699       if (num_velements == 0)
 700          num_vbuffers = 0;
 701    }
 702    else {
 703       if (!setup_non_interleaved_attribs(ctx, vp, vpv, arrays,
 704                                          vbuffer, velements)) {
 705          return GL_FALSE;
 706       }
 707
 708       num_vbuffers = vpv->num_inputs;
 709       num_velements = vpv->num_inputs;
 710    }
 711
 712    cso_set_vertex_buffers(st->cso_context, num_vbuffers, vbuffer);
 713    cso_set_vertex_elements(st->cso_context, num_velements, velements);
 714
 715    return GL_TRUE;
 716 }
 717
 718
 719 /**
 720  * This function gets plugged into the VBO module and is called when
 721  * we have something to render.
 722  * Basically, translate the information into the format expected by gallium.
 723  */
 724 void
 725 st_draw_vbo(struct gl_context *ctx,
 726             const struct _mesa_prim *prims,
 727             GLuint nr_prims,
 728             const struct _mesa_index_buffer *ib,
 729             GLboolean index_bounds_valid,
 730             GLuint min_index,
 731             GLuint max_index,
 732             struct gl_transform_feedback_object *tfb_vertcount)
 733 {
 734    struct st_context *st = st_context(ctx);
 735    struct pipe_index_buffer ibuffer = {0};
 736    struct pipe_draw_info info;
 737    const struct gl_client_array **arrays = ctx->Array._DrawArrays;
 738    unsigned i;
 739    GLboolean new_array;
 740
 741    /* Mesa core state should have been validated already */
 742    assert(ctx->NewState == 0x0);
 743
 744    /* Get Mesa driver state. */
 745    st->dirty.st |= ctx->NewDriverState;
 746    ctx->NewDriverState = 0;
 747
 748    new_array =
 749       (st->dirty.st & (ST_NEW_VERTEX_ARRAYS | ST_NEW_VERTEX_PROGRAM)) ||
 750       (st->dirty.mesa & (_NEW_PROGRAM | _NEW_BUFFER_OBJECT)) != 0;
 751
 752    /* Validate state. */
 753    if (st->dirty.st) {
 754       GLboolean vertDataEdgeFlags;
 755
 756       vertDataEdgeFlags = arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj &&
 757                           arrays[VERT_ATTRIB_EDGEFLAG]->BufferObj->Name;
 758       if (vertDataEdgeFlags != st->vertdata_edgeflags) {
 759          st->vertdata_edgeflags = vertDataEdgeFlags;
 760          st->dirty.st |= ST_NEW_EDGEFLAGS_DATA;
 761       }
 762
 763       st_validate_state(st);
 764
 765       if (new_array) {
 766          if (!st_validate_varrays(ctx, arrays)) {
 767             /* probably out of memory, no-op the draw call */
 768             return;
 769          }
 770       }
 771
 772 #if 0
 773       if (MESA_VERBOSE & VERBOSE_GLSL) {
 774          check_uniforms(ctx);
 775       }
 776 #else
 777       (void) check_uniforms;
 778 #endif
 779    }
 780
 781    util_draw_init_info(&info);
 782    if (ib) {
 783       /* Get index bounds for user buffers. */
 784       if (!index_bounds_valid)
 785          if (!all_varyings_in_vbos(arrays))
 786             vbo_get_minmax_indices(ctx, prims, ib, &min_index, &max_index,
 787                                    nr_prims);
 788
 789       setup_index_buffer(st, ib, &ibuffer);
 790
 791       info.indexed = TRUE;
 792       if (min_index != ~0 && max_index != ~0) {
 793          info.min_index = min_index;
 794          info.max_index = max_index;
 795       }
 796
 797       /* The VBO module handles restart for the non-indexed GLDrawArrays
 798        * so we only set these fields for indexed drawing:
 799        */
 800       info.primitive_restart = ctx->Array.PrimitiveRestart;
 801       info.restart_index = ctx->Array.RestartIndex;
 802    }
 803    else {
 804       /* Transform feedback drawing is always non-indexed. */
 805       /* Set info.count_from_stream_output. */
 806       if (tfb_vertcount) {
 807          st_transform_feedback_draw_init(tfb_vertcount, &info);
 808       }
 809    }
 810
 811    /* do actual drawing */
 812    for (i = 0; i < nr_prims; i++) {
 813       info.mode = translate_prim( ctx, prims[i].mode );
 814       info.start = prims[i].start;
 815       info.count = prims[i].count;
 816       info.instance_count = prims[i].num_instances;
 817       info.index_bias = prims[i].basevertex;
 818       if (!ib) {
 819          info.min_index = info.start;
 820          info.max_index = info.start + info.count - 1;
 821       }
 822
 823       if (info.count_from_stream_output) {
 824          cso_draw_vbo(st->cso_context, &info);
 825       }
 826       else if (info.primitive_restart) {
 827          /* don't trim, restarts might be inside index list */
 828          cso_draw_vbo(st->cso_context, &info);
 829       }
 830       else if (u_trim_pipe_prim(info.mode, &info.count))
 831          cso_draw_vbo(st->cso_context, &info);
 832    }
 833
 834    if (ib && st->indexbuf_uploader && !_mesa_is_bufferobj(ib->obj)) {
 835       pipe_resource_reference(&ibuffer.buffer, NULL);
 836    }
 837 }
 838
 839
 840 void
 841 st_init_draw(struct st_context *st)
 842 {
 843    struct gl_context *ctx = st->ctx;
 844
 845    vbo_set_draw_func(ctx, st_draw_vbo);
 846
 847 #if FEATURE_feedback || FEATURE_rastpos
 848    st->draw = draw_create(st->pipe); /* for selection/feedback */
 849
 850    /* Disable draw options that might convert points/lines to tris, etc.
 851     * as that would foul-up feedback/selection mode.
 852     */
 853    draw_wide_line_threshold(st->draw, 1000.0f);
 854    draw_wide_point_threshold(st->draw, 1000.0f);
 855    draw_enable_line_stipple(st->draw, FALSE);
 856    draw_enable_point_sprites(st->draw, FALSE);
 857 #endif
 858 }
 859
 860
 861 void
 862 st_destroy_draw(struct st_context *st)
 863 {
 864 #if FEATURE_feedback || FEATURE_rastpos
 865    draw_destroy(st->draw);
 866 #endif
 867 }