src/mesa/main/api_validate.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  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 BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <stdbool.h>
  26 #include "glheader.h"
  27 #include "api_validate.h"
  28 #include "bufferobj.h"
  29 #include "context.h"
  30 #include "imports.h"
  31 #include "mtypes.h"
  32 #include "enums.h"
  33 #include "vbo/vbo.h"
  34 #include "transformfeedback.h"
  35 #include <stdbool.h>
  36
  37
  38 /**
  39  * \return  number of bytes in array [count] of type.
  40  */
  41 static GLsizei
  42 index_bytes(GLenum type, GLsizei count)
  43 {
  44    if (type == GL_UNSIGNED_INT) {
  45       return count * sizeof(GLuint);
  46    }
  47    else if (type == GL_UNSIGNED_BYTE) {
  48       return count * sizeof(GLubyte);
  49    }
  50    else {
  51       ASSERT(type == GL_UNSIGNED_SHORT);
  52       return count * sizeof(GLushort);
  53    }
  54 }
  55
  56
  57 /**
  58  * Find the max index in the given element/index buffer
  59  */
  60 GLuint
  61 _mesa_max_buffer_index(struct gl_context *ctx, GLuint count, GLenum type,
  62                        const void *indices,
  63                        struct gl_buffer_object *elementBuf)
  64 {
  65    const GLubyte *map = NULL;
  66    GLuint max = 0;
  67    GLuint i;
  68
  69    if (_mesa_is_bufferobj(elementBuf)) {
  70       /* elements are in a user-defined buffer object.  need to map it */
  71       map = ctx->Driver.MapBufferRange(ctx, 0, elementBuf->Size,
  72                                        GL_MAP_READ_BIT, elementBuf);
  73       /* Actual address is the sum of pointers */
  74       indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices);
  75    }
  76
  77    if (type == GL_UNSIGNED_INT) {
  78       for (i = 0; i < count; i++)
  79          if (((GLuint *) indices)[i] > max)
  80             max = ((GLuint *) indices)[i];
  81    }
  82    else if (type == GL_UNSIGNED_SHORT) {
  83       for (i = 0; i < count; i++)
  84          if (((GLushort *) indices)[i] > max)
  85             max = ((GLushort *) indices)[i];
  86    }
  87    else {
  88       ASSERT(type == GL_UNSIGNED_BYTE);
  89       for (i = 0; i < count; i++)
  90          if (((GLubyte *) indices)[i] > max)
  91             max = ((GLubyte *) indices)[i];
  92    }
  93
  94    if (map) {
  95       ctx->Driver.UnmapBuffer(ctx, elementBuf);
  96    }
  97
  98    return max;
  99 }
 100
 101
 102 /**
 103  * Check if OK to draw arrays/elements.
 104  */
 105 static GLboolean
 106 check_valid_to_render(struct gl_context *ctx, const char *function)
 107 {
 108    if (!_mesa_valid_to_render(ctx, function)) {
 109       return GL_FALSE;
 110    }
 111
 112    switch (ctx->API) {
 113    case API_OPENGLES2:
 114       /* For ES2, we can draw if any vertex array is enabled (and we
 115        * should always have a vertex program/shader). */
 116       if (ctx->Array.ArrayObj->_Enabled == 0x0 || !ctx->VertexProgram._Current)
 117          return GL_FALSE;
 118       break;
 119
 120    case API_OPENGLES:
 121       /* For OpenGL ES, only draw if we have vertex positions
 122        */
 123       if (!ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled)
 124          return GL_FALSE;
 125       break;
 126
 127    case API_OPENGL_COMPAT:
 128    case API_OPENGL_CORE:
 129       {
 130          const struct gl_shader_program *vsProg =
 131             ctx->Shader.CurrentVertexProgram;
 132          GLboolean haveVertexShader = (vsProg && vsProg->LinkStatus);
 133          GLboolean haveVertexProgram = ctx->VertexProgram._Enabled;
 134          if (haveVertexShader || haveVertexProgram) {
 135             /* Draw regardless of whether or not we have any vertex arrays.
 136              * (Ex: could draw a point using a constant vertex pos)
 137              */
 138             return GL_TRUE;
 139          }
 140          else {
 141             /* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
 142              * array [0]).
 143              */
 144             return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled ||
 145                     ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled);
 146          }
 147       }
 148       break;
 149
 150    default:
 151       assert(!"Invalid API value in check_valid_to_render()");
 152    }
 153
 154    return GL_TRUE;
 155 }
 156
 157
 158 /**
 159  * Do bounds checking on array element indexes.  Check that the vertices
 160  * pointed to by the indices don't lie outside buffer object bounds.
 161  * \return GL_TRUE if OK, GL_FALSE if any indexed vertex goes is out of bounds
 162  */
 163 static GLboolean
 164 check_index_bounds(struct gl_context *ctx, GLsizei count, GLenum type,
 165                    const GLvoid *indices, GLint basevertex)
 166 {
 167    struct _mesa_prim prim;
 168    struct _mesa_index_buffer ib;
 169    GLuint min, max;
 170
 171    /* Only the X Server needs to do this -- otherwise, accessing outside
 172     * array/BO bounds allows application termination.
 173     */
 174    if (!ctx->Const.CheckArrayBounds)
 175       return GL_TRUE;
 176
 177    memset(&prim, 0, sizeof(prim));
 178    prim.count = count;
 179
 180    memset(&ib, 0, sizeof(ib));
 181    ib.type = type;
 182    ib.ptr = indices;
 183    ib.obj = ctx->Array.ArrayObj->ElementArrayBufferObj;
 184
 185    vbo_get_minmax_indices(ctx, &prim, &ib, &min, &max, 1);
 186
 187    if ((int)(min + basevertex) < 0 ||
 188        max + basevertex >= ctx->Array.ArrayObj->_MaxElement) {
 189       /* the max element is out of bounds of one or more enabled arrays */
 190       _mesa_warning(ctx, "glDrawElements() index=%u is out of bounds (max=%u)",
 191                     max, ctx->Array.ArrayObj->_MaxElement);
 192       return GL_FALSE;
 193    }
 194
 195    return GL_TRUE;
 196 }
 197
 198
 199 /**
 200  * Is 'mode' a valid value for glBegin(), glDrawArrays(), glDrawElements(),
 201  * etc?  The set of legal values depends on whether geometry shaders/programs
 202  * are supported.
 203  */
 204 GLboolean
 205 _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
 206 {
 207    bool valid_enum;
 208
 209    switch (mode) {
 210    case GL_POINTS:
 211    case GL_LINES:
 212    case GL_LINE_LOOP:
 213    case GL_LINE_STRIP:
 214    case GL_TRIANGLES:
 215    case GL_TRIANGLE_STRIP:
 216    case GL_TRIANGLE_FAN:
 217       valid_enum = true;
 218       break;
 219    case GL_QUADS:
 220    case GL_QUAD_STRIP:
 221    case GL_POLYGON:
 222       valid_enum = (ctx->API == API_OPENGL_COMPAT);
 223       break;
 224    case GL_LINES_ADJACENCY:
 225    case GL_LINE_STRIP_ADJACENCY:
 226    case GL_TRIANGLES_ADJACENCY:
 227    case GL_TRIANGLE_STRIP_ADJACENCY:
 228       valid_enum = _mesa_is_desktop_gl(ctx)
 229          && ctx->Extensions.ARB_geometry_shader4;
 230       break;
 231    default:
 232       valid_enum = false;
 233       break;
 234    }
 235
 236    if (!valid_enum) {
 237       _mesa_error(ctx, GL_INVALID_ENUM, "%s(mode=%x)", name, mode);
 238       return GL_FALSE;
 239    }
 240
 241    /* From the GL_EXT_transform_feedback spec:
 242     *
 243     *     "The error INVALID_OPERATION is generated if Begin, or any command
 244     *      that performs an explicit Begin, is called when:
 245     *
 246     *      * a geometry shader is not active and <mode> does not match the
 247     *        allowed begin modes for the current transform feedback state as
 248     *        given by table X.1.
 249     *
 250     *      * a geometry shader is active and the output primitive type of the
 251     *        geometry shader does not match the allowed begin modes for the
 252     *        current transform feedback state as given by table X.1.
 253     *
 254     */
 255    if (_mesa_is_xfb_active_and_unpaused(ctx)) {
 256       GLboolean pass = GL_TRUE;
 257
 258       switch (mode) {
 259       case GL_POINTS:
 260          pass = ctx->TransformFeedback.Mode == GL_POINTS;
 261          break;
 262       case GL_LINES:
 263       case GL_LINE_STRIP:
 264       case GL_LINE_LOOP:
 265          pass = ctx->TransformFeedback.Mode == GL_LINES;
 266          break;
 267       default:
 268          pass = ctx->TransformFeedback.Mode == GL_TRIANGLES;
 269          break;
 270       }
 271       if (!pass) {
 272          _mesa_error(ctx, GL_INVALID_OPERATION,
 273                      "%s(mode=%s vs transform feedback %s)",
 274                      name,
 275                      _mesa_lookup_prim_by_nr(mode),
 276                      _mesa_lookup_prim_by_nr(ctx->TransformFeedback.Mode));
 277          return GL_FALSE;
 278       }
 279    }
 280
 281    return GL_TRUE;
 282 }
 283
 284 /**
 285  * Verify that the element type is valid.
 286  *
 287  * Generates \c GL_INVALID_ENUM and returns \c false if it is not.
 288  */
 289 static bool
 290 valid_elements_type(struct gl_context *ctx, GLenum type, const char *name)
 291 {
 292    switch (type) {
 293    case GL_UNSIGNED_BYTE:
 294    case GL_UNSIGNED_SHORT:
 295    case GL_UNSIGNED_INT:
 296       return true;
 297
 298    default:
 299       _mesa_error(ctx, GL_INVALID_ENUM, "%s(type = %s)", name,
 300                   _mesa_lookup_enum_by_nr(type));
 301       return false;
 302    }
 303 }
 304
 305 /**
 306  * Error checking for glDrawElements().  Includes parameter checking
 307  * and VBO bounds checking.
 308  * \return GL_TRUE if OK to render, GL_FALSE if error found
 309  */
 310 GLboolean
 311 _mesa_validate_DrawElements(struct gl_context *ctx,
 312                             GLenum mode, GLsizei count, GLenum type,
 313                             const GLvoid *indices, GLint basevertex)
 314 {
 315    FLUSH_CURRENT(ctx, 0);
 316
 317    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 318     * Primitive Capture):
 319     *
 320     *   The error INVALID_OPERATION is also generated by DrawElements,
 321     *   DrawElementsInstanced, and DrawRangeElements while transform feedback
 322     *   is active and not paused, regardless of mode.
 323     */
 324    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 325       _mesa_error(ctx, GL_INVALID_OPERATION,
 326                   "glDrawElements(transform feedback active)");
 327       return GL_FALSE;
 328    }
 329
 330    if (count <= 0) {
 331       if (count < 0)
 332          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
 333       return GL_FALSE;
 334    }
 335
 336    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawElements")) {
 337       return GL_FALSE;
 338    }
 339
 340    if (!valid_elements_type(ctx, type, "glDrawElements"))
 341       return GL_FALSE;
 342
 343    if (!check_valid_to_render(ctx, "glDrawElements"))
 344       return GL_FALSE;
 345
 346    /* Vertex buffer object tests */
 347    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 348       /* use indices in the buffer object */
 349       /* make sure count doesn't go outside buffer bounds */
 350       if (index_bytes(type, count) > ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 351          _mesa_warning(ctx, "glDrawElements index out of buffer bounds");
 352          return GL_FALSE;
 353       }
 354    }
 355    else {
 356       /* not using a VBO */
 357       if (!indices)
 358          return GL_FALSE;
 359    }
 360
 361    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 362       return GL_FALSE;
 363
 364    return GL_TRUE;
 365 }
 366
 367
 368 /**
 369  * Error checking for glMultiDrawElements().  Includes parameter checking
 370  * and VBO bounds checking.
 371  * \return GL_TRUE if OK to render, GL_FALSE if error found
 372  */
 373 GLboolean
 374 _mesa_validate_MultiDrawElements(struct gl_context *ctx,
 375                                  GLenum mode, const GLsizei *count,
 376                                  GLenum type, const GLvoid * const *indices,
 377                                  GLuint primcount, const GLint *basevertex)
 378 {
 379    unsigned i;
 380
 381    FLUSH_CURRENT(ctx, 0);
 382
 383    for (i = 0; i < primcount; i++) {
 384       if (count[i] <= 0) {
 385          if (count[i] < 0)
 386             _mesa_error(ctx, GL_INVALID_VALUE,
 387                         "glMultiDrawElements(count)" );
 388          return GL_FALSE;
 389       }
 390    }
 391
 392    if (!_mesa_valid_prim_mode(ctx, mode, "glMultiDrawElements")) {
 393       return GL_FALSE;
 394    }
 395
 396    if (!valid_elements_type(ctx, type, "glMultiDrawElements"))
 397       return GL_FALSE;
 398
 399    if (!check_valid_to_render(ctx, "glMultiDrawElements"))
 400       return GL_FALSE;
 401
 402    /* Vertex buffer object tests */
 403    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 404       /* use indices in the buffer object */
 405       /* make sure count doesn't go outside buffer bounds */
 406       for (i = 0; i < primcount; i++) {
 407          if (index_bytes(type, count[i]) >
 408              ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 409             _mesa_warning(ctx,
 410                           "glMultiDrawElements index out of buffer bounds");
 411             return GL_FALSE;
 412          }
 413       }
 414    }
 415    else {
 416       /* not using a VBO */
 417       for (i = 0; i < primcount; i++) {
 418          if (!indices[i])
 419             return GL_FALSE;
 420       }
 421    }
 422
 423    for (i = 0; i < primcount; i++) {
 424       if (!check_index_bounds(ctx, count[i], type, indices[i],
 425                               basevertex ? basevertex[i] : 0))
 426          return GL_FALSE;
 427    }
 428
 429    return GL_TRUE;
 430 }
 431
 432
 433 /**
 434  * Error checking for glDrawRangeElements().  Includes parameter checking
 435  * and VBO bounds checking.
 436  * \return GL_TRUE if OK to render, GL_FALSE if error found
 437  */
 438 GLboolean
 439 _mesa_validate_DrawRangeElements(struct gl_context *ctx, GLenum mode,
 440                                  GLuint start, GLuint end,
 441                                  GLsizei count, GLenum type,
 442                                  const GLvoid *indices, GLint basevertex)
 443 {
 444    FLUSH_CURRENT(ctx, 0);
 445
 446    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 447     * Primitive Capture):
 448     *
 449     *   The error INVALID_OPERATION is also generated by DrawElements,
 450     *   DrawElementsInstanced, and DrawRangeElements while transform feedback
 451     *   is active and not paused, regardless of mode.
 452     */
 453    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 454       _mesa_error(ctx, GL_INVALID_OPERATION,
 455                   "glDrawElements(transform feedback active)");
 456       return GL_FALSE;
 457    }
 458
 459    if (count <= 0) {
 460       if (count < 0)
 461          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(count)" );
 462       return GL_FALSE;
 463    }
 464
 465    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawRangeElements")) {
 466       return GL_FALSE;
 467    }
 468
 469    if (end < start) {
 470       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(end<start)");
 471       return GL_FALSE;
 472    }
 473
 474    if (!valid_elements_type(ctx, type, "glDrawRangeElements"))
 475       return GL_FALSE;
 476
 477    if (!check_valid_to_render(ctx, "glDrawRangeElements"))
 478       return GL_FALSE;
 479
 480    /* Vertex buffer object tests */
 481    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 482       /* use indices in the buffer object */
 483       /* make sure count doesn't go outside buffer bounds */
 484       if (index_bytes(type, count) > ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 485          _mesa_warning(ctx, "glDrawRangeElements index out of buffer bounds");
 486          return GL_FALSE;
 487       }
 488    }
 489    else {
 490       /* not using a VBO */
 491       if (!indices)
 492          return GL_FALSE;
 493    }
 494
 495    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 496       return GL_FALSE;
 497
 498    return GL_TRUE;
 499 }
 500
 501
 502 /**
 503  * Called from the tnl module to error check the function parameters and
 504  * verify that we really can draw something.
 505  * \return GL_TRUE if OK to render, GL_FALSE if error found
 506  */
 507 GLboolean
 508 _mesa_validate_DrawArrays(struct gl_context *ctx,
 509                           GLenum mode, GLint start, GLsizei count)
 510 {
 511    struct gl_transform_feedback_object *xfb_obj
 512       = ctx->TransformFeedback.CurrentObject;
 513    FLUSH_CURRENT(ctx, 0);
 514
 515    if (count <= 0) {
 516       if (count < 0)
 517          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
 518       return GL_FALSE;
 519    }
 520
 521    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawArrays")) {
 522       return GL_FALSE;
 523    }
 524
 525    if (!check_valid_to_render(ctx, "glDrawArrays"))
 526       return GL_FALSE;
 527
 528    if (ctx->Const.CheckArrayBounds) {
 529       if (start + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
 530          return GL_FALSE;
 531    }
 532
 533    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 534     * Primitive Capture):
 535     *
 536     *   The error INVALID_OPERATION is generated by DrawArrays and
 537     *   DrawArraysInstanced if recording the vertices of a primitive to the
 538     *   buffer objects being used for transform feedback purposes would result
 539     *   in either exceeding the limits of any buffer object’s size, or in
 540     *   exceeding the end position offset + size − 1, as set by
 541     *   BindBufferRange.
 542     *
 543     * This is in contrast to the behaviour of desktop GL, where the extra
 544     * primitives are silently dropped from the transform feedback buffer.
 545     */
 546    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 547       size_t prim_count = vbo_count_tessellated_primitives(mode, count, 1);
 548       if (xfb_obj->GlesRemainingPrims < prim_count) {
 549          _mesa_error(ctx, GL_INVALID_OPERATION,
 550                      "glDrawArrays(exceeds transform feedback size)");
 551          return GL_FALSE;
 552       }
 553       xfb_obj->GlesRemainingPrims -= prim_count;
 554    }
 555
 556    return GL_TRUE;
 557 }
 558
 559
 560 GLboolean
 561 _mesa_validate_DrawArraysInstanced(struct gl_context *ctx, GLenum mode, GLint first,
 562                                    GLsizei count, GLsizei numInstances)
 563 {
 564    struct gl_transform_feedback_object *xfb_obj
 565       = ctx->TransformFeedback.CurrentObject;
 566    FLUSH_CURRENT(ctx, 0);
 567
 568    if (count <= 0) {
 569       if (count < 0)
 570          _mesa_error(ctx, GL_INVALID_VALUE,
 571                      "glDrawArraysInstanced(count=%d)", count);
 572       return GL_FALSE;
 573    }
 574
 575    if (first < 0) {
 576       _mesa_error(ctx, GL_INVALID_VALUE,
 577                   "glDrawArraysInstanced(start=%d)", first);
 578       return GL_FALSE;
 579    }
 580
 581    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawArraysInstanced")) {
 582       return GL_FALSE;
 583    }
 584
 585    if (numInstances <= 0) {
 586       if (numInstances < 0)
 587          _mesa_error(ctx, GL_INVALID_VALUE,
 588                      "glDrawArraysInstanced(numInstances=%d)", numInstances);
 589       return GL_FALSE;
 590    }
 591
 592    if (!check_valid_to_render(ctx, "glDrawArraysInstanced(invalid to render)"))
 593       return GL_FALSE;
 594
 595    if (ctx->Const.CheckArrayBounds) {
 596       if (first + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
 597          return GL_FALSE;
 598    }
 599
 600    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 601     * Primitive Capture):
 602     *
 603     *   The error INVALID_OPERATION is generated by DrawArrays and
 604     *   DrawArraysInstanced if recording the vertices of a primitive to the
 605     *   buffer objects being used for transform feedback purposes would result
 606     *   in either exceeding the limits of any buffer object’s size, or in
 607     *   exceeding the end position offset + size − 1, as set by
 608     *   BindBufferRange.
 609     *
 610     * This is in contrast to the behaviour of desktop GL, where the extra
 611     * primitives are silently dropped from the transform feedback buffer.
 612     */
 613    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 614       size_t prim_count
 615          = vbo_count_tessellated_primitives(mode, count, numInstances);
 616       if (xfb_obj->GlesRemainingPrims < prim_count) {
 617          _mesa_error(ctx, GL_INVALID_OPERATION,
 618                      "glDrawArraysInstanced(exceeds transform feedback size)");
 619          return GL_FALSE;
 620       }
 621       xfb_obj->GlesRemainingPrims -= prim_count;
 622    }
 623
 624    return GL_TRUE;
 625 }
 626
 627
 628 GLboolean
 629 _mesa_validate_DrawElementsInstanced(struct gl_context *ctx,
 630                                      GLenum mode, GLsizei count, GLenum type,
 631                                      const GLvoid *indices, GLsizei numInstances,
 632                                      GLint basevertex)
 633 {
 634    FLUSH_CURRENT(ctx, 0);
 635
 636    /* From the GLES3 specification, section 2.14.2 (Transform Feedback
 637     * Primitive Capture):
 638     *
 639     *   The error INVALID_OPERATION is also generated by DrawElements,
 640     *   DrawElementsInstanced, and DrawRangeElements while transform feedback
 641     *   is active and not paused, regardless of mode.
 642     */
 643    if (_mesa_is_gles3(ctx) && _mesa_is_xfb_active_and_unpaused(ctx)) {
 644       _mesa_error(ctx, GL_INVALID_OPERATION,
 645                   "glDrawElements(transform feedback active)");
 646       return GL_FALSE;
 647    }
 648
 649    if (count <= 0) {
 650       if (count < 0)
 651          _mesa_error(ctx, GL_INVALID_VALUE,
 652                      "glDrawElementsInstanced(count=%d)", count);
 653       return GL_FALSE;
 654    }
 655
 656    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawElementsInstanced")) {
 657       return GL_FALSE;
 658    }
 659
 660    if (!valid_elements_type(ctx, type, "glDrawElementsInstanced"))
 661       return GL_FALSE;
 662
 663    if (numInstances <= 0) {
 664       if (numInstances < 0)
 665          _mesa_error(ctx, GL_INVALID_VALUE,
 666                      "glDrawElementsInstanced(numInstances=%d)", numInstances);
 667       return GL_FALSE;
 668    }
 669
 670    if (!check_valid_to_render(ctx, "glDrawElementsInstanced"))
 671       return GL_FALSE;
 672
 673    /* Vertex buffer object tests */
 674    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 675       /* use indices in the buffer object */
 676       /* make sure count doesn't go outside buffer bounds */
 677       if (index_bytes(type, count) > ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 678          _mesa_warning(ctx,
 679                        "glDrawElementsInstanced index out of buffer bounds");
 680          return GL_FALSE;
 681       }
 682    }
 683    else {
 684       /* not using a VBO */
 685       if (!indices)
 686          return GL_FALSE;
 687    }
 688
 689    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 690       return GL_FALSE;
 691
 692    return GL_TRUE;
 693 }
 694
 695
 696 GLboolean
 697 _mesa_validate_DrawTransformFeedback(struct gl_context *ctx,
 698                                      GLenum mode,
 699                                      struct gl_transform_feedback_object *obj,
 700                                      GLuint stream,
 701                                      GLsizei numInstances)
 702 {
 703    FLUSH_CURRENT(ctx, 0);
 704
 705    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawTransformFeedback*(mode)")) {
 706       return GL_FALSE;
 707    }
 708
 709    if (!obj) {
 710       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawTransformFeedback*(name)");
 711       return GL_FALSE;
 712    }
 713
 714    if (!obj->EndedAnytime) {
 715       _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawTransformFeedback*");
 716       return GL_FALSE;
 717    }
 718
 719    if (stream >= ctx->Const.MaxVertexStreams) {
 720       _mesa_error(ctx, GL_INVALID_VALUE,
 721                   "glDrawTransformFeedbackStream*(index>=MaxVertexStream)");
 722       return GL_FALSE;
 723    }
 724
 725    if (numInstances <= 0) {
 726       if (numInstances < 0)
 727          _mesa_error(ctx, GL_INVALID_VALUE,
 728                      "glDrawTransformFeedback*Instanced(numInstances=%d)",
 729                      numInstances);
 730       return GL_FALSE;
 731    }
 732
 733    if (!check_valid_to_render(ctx, "glDrawTransformFeedback*")) {
 734       return GL_FALSE;
 735    }
 736
 737    return GL_TRUE;
 738 }