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  * BRIAN PAUL 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 "glheader.h"
  26 #include "api_validate.h"
  27 #include "bufferobj.h"
  28 #include "context.h"
  29 #include "imports.h"
  30 #include "mfeatures.h"
  31 #include "mtypes.h"
  32 #include "enums.h"
  33 #include "vbo/vbo.h"
  34
  35
  36 /**
  37  * \return  number of bytes in array [count] of type.
  38  */
  39 static GLsizei
  40 index_bytes(GLenum type, GLsizei count)
  41 {
  42    if (type == GL_UNSIGNED_INT) {
  43       return count * sizeof(GLuint);
  44    }
  45    else if (type == GL_UNSIGNED_BYTE) {
  46       return count * sizeof(GLubyte);
  47    }
  48    else {
  49       ASSERT(type == GL_UNSIGNED_SHORT);
  50       return count * sizeof(GLushort);
  51    }
  52 }
  53
  54
  55 /**
  56  * Find the max index in the given element/index buffer
  57  */
  58 GLuint
  59 _mesa_max_buffer_index(struct gl_context *ctx, GLuint count, GLenum type,
  60                        const void *indices,
  61                        struct gl_buffer_object *elementBuf)
  62 {
  63    const GLubyte *map = NULL;
  64    GLuint max = 0;
  65    GLuint i;
  66
  67    if (_mesa_is_bufferobj(elementBuf)) {
  68       /* elements are in a user-defined buffer object.  need to map it */
  69       map = ctx->Driver.MapBufferRange(ctx, 0, elementBuf->Size,
  70                                        GL_MAP_READ_BIT, elementBuf);
  71       /* Actual address is the sum of pointers */
  72       indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices);
  73    }
  74
  75    if (type == GL_UNSIGNED_INT) {
  76       for (i = 0; i < count; i++)
  77          if (((GLuint *) indices)[i] > max)
  78             max = ((GLuint *) indices)[i];
  79    }
  80    else if (type == GL_UNSIGNED_SHORT) {
  81       for (i = 0; i < count; i++)
  82          if (((GLushort *) indices)[i] > max)
  83             max = ((GLushort *) indices)[i];
  84    }
  85    else {
  86       ASSERT(type == GL_UNSIGNED_BYTE);
  87       for (i = 0; i < count; i++)
  88          if (((GLubyte *) indices)[i] > max)
  89             max = ((GLubyte *) indices)[i];
  90    }
  91
  92    if (map) {
  93       ctx->Driver.UnmapBuffer(ctx, elementBuf);
  94    }
  95
  96    return max;
  97 }
  98
  99
 100 /**
 101  * Check if OK to draw arrays/elements.
 102  */
 103 static GLboolean
 104 check_valid_to_render(struct gl_context *ctx, const char *function)
 105 {
 106    if (!_mesa_valid_to_render(ctx, function)) {
 107       return GL_FALSE;
 108    }
 109
 110    switch (ctx->API) {
 111 #if FEATURE_es2_glsl
 112    case API_OPENGLES2:
 113       /* For ES2, we can draw if any vertex array is enabled (and we
 114        * should always have a vertex program/shader). */
 115       if (ctx->Array.ArrayObj->_Enabled == 0x0 || !ctx->VertexProgram._Current)
 116          return GL_FALSE;
 117       break;
 118 #endif
 119
 120 #if FEATURE_ES1
 121    case API_OPENGLES:
 122       /* For OpenGL ES, only draw if we have vertex positions
 123        */
 124       if (!ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled)
 125          return GL_FALSE;
 126       break;
 127 #endif
 128
 129 #if FEATURE_GL
 130    case API_OPENGL:
 131       {
 132          const struct gl_shader_program *vsProg =
 133             ctx->Shader.CurrentVertexProgram;
 134          GLboolean haveVertexShader = (vsProg && vsProg->LinkStatus);
 135          GLboolean haveVertexProgram = ctx->VertexProgram._Enabled;
 136          if (haveVertexShader || haveVertexProgram) {
 137             /* Draw regardless of whether or not we have any vertex arrays.
 138              * (Ex: could draw a point using a constant vertex pos)
 139              */
 140             return GL_TRUE;
 141          }
 142          else {
 143             /* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
 144              * array [0]).
 145              */
 146             return (ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_POS].Enabled ||
 147                     ctx->Array.ArrayObj->VertexAttrib[VERT_ATTRIB_GENERIC0].Enabled);
 148          }
 149       }
 150       break;
 151 #endif
 152
 153    default:
 154       ASSERT_NO_FEATURE();
 155    }
 156
 157    return GL_TRUE;
 158 }
 159
 160
 161 /**
 162  * Do bounds checking on array element indexes.  Check that the vertices
 163  * pointed to by the indices don't lie outside buffer object bounds.
 164  * \return GL_TRUE if OK, GL_FALSE if any indexed vertex goes is out of bounds
 165  */
 166 static GLboolean
 167 check_index_bounds(struct gl_context *ctx, GLsizei count, GLenum type,
 168                    const GLvoid *indices, GLint basevertex)
 169 {
 170    struct _mesa_prim prim;
 171    struct _mesa_index_buffer ib;
 172    GLuint min, max;
 173
 174    /* Only the X Server needs to do this -- otherwise, accessing outside
 175     * array/BO bounds allows application termination.
 176     */
 177    if (!ctx->Const.CheckArrayBounds)
 178       return GL_TRUE;
 179
 180    memset(&prim, 0, sizeof(prim));
 181    prim.count = count;
 182
 183    memset(&ib, 0, sizeof(ib));
 184    ib.type = type;
 185    ib.ptr = indices;
 186    ib.obj = ctx->Array.ArrayObj->ElementArrayBufferObj;
 187
 188    vbo_get_minmax_indices(ctx, &prim, &ib, &min, &max, 1);
 189
 190    if ((int)(min + basevertex) < 0 ||
 191        max + basevertex >= ctx->Array.ArrayObj->_MaxElement) {
 192       /* the max element is out of bounds of one or more enabled arrays */
 193       _mesa_warning(ctx, "glDrawElements() index=%u is out of bounds (max=%u)",
 194                     max, ctx->Array.ArrayObj->_MaxElement);
 195       return GL_FALSE;
 196    }
 197
 198    return GL_TRUE;
 199 }
 200
 201
 202 /**
 203  * Is 'mode' a valid value for glBegin(), glDrawArrays(), glDrawElements(),
 204  * etc?  The set of legal values depends on whether geometry shaders/programs
 205  * are supported.
 206  */
 207 GLboolean
 208 _mesa_valid_prim_mode(struct gl_context *ctx, GLenum mode, const char *name)
 209 {
 210    if (ctx->Extensions.ARB_geometry_shader4 &&
 211        mode > GL_TRIANGLE_STRIP_ADJACENCY_ARB) {
 212       _mesa_error(ctx, GL_INVALID_ENUM, "%s(mode=%x)", name, mode);
 213       return GL_FALSE;
 214    }
 215    else if (mode > GL_POLYGON) {
 216       _mesa_error(ctx, GL_INVALID_ENUM, "%s(mode=%x)", name, mode);
 217       return GL_FALSE;
 218    }
 219
 220    /* From the GL_EXT_transform_feedback spec:
 221     *
 222     *     "The error INVALID_OPERATION is generated if Begin, or any command
 223     *      that performs an explicit Begin, is called when:
 224     *
 225     *      * a geometry shader is not active and <mode> does not match the
 226     *        allowed begin modes for the current transform feedback state as
 227     *        given by table X.1.
 228     *
 229     *      * a geometry shader is active and the output primitive type of the
 230     *        geometry shader does not match the allowed begin modes for the
 231     *        current transform feedback state as given by table X.1.
 232     *
 233     */
 234    if (ctx->TransformFeedback.CurrentObject->Active &&
 235        !ctx->TransformFeedback.CurrentObject->Paused) {
 236       GLboolean pass = GL_TRUE;
 237
 238       switch (mode) {
 239       case GL_POINTS:
 240          pass = ctx->TransformFeedback.Mode == GL_POINTS;
 241          break;
 242       case GL_LINES:
 243       case GL_LINE_STRIP:
 244       case GL_LINE_LOOP:
 245          pass = ctx->TransformFeedback.Mode == GL_LINES;
 246          break;
 247       default:
 248          pass = ctx->TransformFeedback.Mode == GL_TRIANGLES;
 249          break;
 250       }
 251       if (!pass) {
 252          _mesa_error(ctx, GL_INVALID_OPERATION,
 253                      "%s(mode=%s vs transform feedback %s)",
 254                      name,
 255                      _mesa_lookup_prim_by_nr(mode),
 256                      _mesa_lookup_prim_by_nr(ctx->TransformFeedback.Mode));
 257          return GL_FALSE;
 258       }
 259    }
 260
 261    return GL_TRUE;
 262 }
 263
 264
 265 /**
 266  * Error checking for glDrawElements().  Includes parameter checking
 267  * and VBO bounds checking.
 268  * \return GL_TRUE if OK to render, GL_FALSE if error found
 269  */
 270 GLboolean
 271 _mesa_validate_DrawElements(struct gl_context *ctx,
 272                             GLenum mode, GLsizei count, GLenum type,
 273                             const GLvoid *indices, GLint basevertex)
 274 {
 275    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 276    FLUSH_CURRENT(ctx, 0);
 277
 278    if (count <= 0) {
 279       if (count < 0)
 280          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
 281       return GL_FALSE;
 282    }
 283
 284    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawElements")) {
 285       return GL_FALSE;
 286    }
 287
 288    if (type != GL_UNSIGNED_INT &&
 289        type != GL_UNSIGNED_BYTE &&
 290        type != GL_UNSIGNED_SHORT)
 291    {
 292       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
 293       return GL_FALSE;
 294    }
 295
 296    if (!check_valid_to_render(ctx, "glDrawElements"))
 297       return GL_FALSE;
 298
 299    /* Vertex buffer object tests */
 300    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 301       /* use indices in the buffer object */
 302       /* make sure count doesn't go outside buffer bounds */
 303       if (index_bytes(type, count) > ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 304          _mesa_warning(ctx, "glDrawElements index out of buffer bounds");
 305          return GL_FALSE;
 306       }
 307    }
 308    else {
 309       /* not using a VBO */
 310       if (!indices)
 311          return GL_FALSE;
 312    }
 313
 314    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 315       return GL_FALSE;
 316
 317    return GL_TRUE;
 318 }
 319
 320
 321 /**
 322  * Error checking for glMultiDrawElements().  Includes parameter checking
 323  * and VBO bounds checking.
 324  * \return GL_TRUE if OK to render, GL_FALSE if error found
 325  */
 326 GLboolean
 327 _mesa_validate_MultiDrawElements(struct gl_context *ctx,
 328                                  GLenum mode, const GLsizei *count,
 329                                  GLenum type, const GLvoid * const *indices,
 330                                  GLuint primcount, const GLint *basevertex)
 331 {
 332    unsigned i;
 333
 334    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 335    FLUSH_CURRENT(ctx, 0);
 336
 337    for (i = 0; i < primcount; i++) {
 338       if (count[i] <= 0) {
 339          if (count[i] < 0)
 340             _mesa_error(ctx, GL_INVALID_VALUE,
 341                         "glMultiDrawElements(count)" );
 342          return GL_FALSE;
 343       }
 344    }
 345
 346    if (!_mesa_valid_prim_mode(ctx, mode, "glMultiDrawElements")) {
 347       return GL_FALSE;
 348    }
 349
 350    if (type != GL_UNSIGNED_INT &&
 351        type != GL_UNSIGNED_BYTE &&
 352        type != GL_UNSIGNED_SHORT)
 353    {
 354       _mesa_error(ctx, GL_INVALID_ENUM, "glMultiDrawElements(type)" );
 355       return GL_FALSE;
 356    }
 357
 358    if (!check_valid_to_render(ctx, "glMultiDrawElements"))
 359       return GL_FALSE;
 360
 361    /* Vertex buffer object tests */
 362    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 363       /* use indices in the buffer object */
 364       /* make sure count doesn't go outside buffer bounds */
 365       for (i = 0; i < primcount; i++) {
 366          if (index_bytes(type, count[i]) >
 367              ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 368             _mesa_warning(ctx,
 369                           "glMultiDrawElements index out of buffer bounds");
 370             return GL_FALSE;
 371          }
 372       }
 373    }
 374    else {
 375       /* not using a VBO */
 376       for (i = 0; i < primcount; i++) {
 377          if (!indices[i])
 378             return GL_FALSE;
 379       }
 380    }
 381
 382    for (i = 0; i < primcount; i++) {
 383       if (!check_index_bounds(ctx, count[i], type, indices[i],
 384                               basevertex ? basevertex[i] : 0))
 385          return GL_FALSE;
 386    }
 387
 388    return GL_TRUE;
 389 }
 390
 391
 392 /**
 393  * Error checking for glDrawRangeElements().  Includes parameter checking
 394  * and VBO bounds checking.
 395  * \return GL_TRUE if OK to render, GL_FALSE if error found
 396  */
 397 GLboolean
 398 _mesa_validate_DrawRangeElements(struct gl_context *ctx, GLenum mode,
 399                                  GLuint start, GLuint end,
 400                                  GLsizei count, GLenum type,
 401                                  const GLvoid *indices, GLint basevertex)
 402 {
 403    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 404    FLUSH_CURRENT(ctx, 0);
 405
 406    if (count <= 0) {
 407       if (count < 0)
 408          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(count)" );
 409       return GL_FALSE;
 410    }
 411
 412    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawRangeElements")) {
 413       return GL_FALSE;
 414    }
 415
 416    if (end < start) {
 417       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(end<start)");
 418       return GL_FALSE;
 419    }
 420
 421    if (type != GL_UNSIGNED_INT &&
 422        type != GL_UNSIGNED_BYTE &&
 423        type != GL_UNSIGNED_SHORT) {
 424       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(type)" );
 425       return GL_FALSE;
 426    }
 427
 428    if (!check_valid_to_render(ctx, "glDrawRangeElements"))
 429       return GL_FALSE;
 430
 431    /* Vertex buffer object tests */
 432    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 433       /* use indices in the buffer object */
 434       /* make sure count doesn't go outside buffer bounds */
 435       if (index_bytes(type, count) > ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 436          _mesa_warning(ctx, "glDrawRangeElements index out of buffer bounds");
 437          return GL_FALSE;
 438       }
 439    }
 440    else {
 441       /* not using a VBO */
 442       if (!indices)
 443          return GL_FALSE;
 444    }
 445
 446    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 447       return GL_FALSE;
 448
 449    return GL_TRUE;
 450 }
 451
 452
 453 /**
 454  * Called from the tnl module to error check the function parameters and
 455  * verify that we really can draw something.
 456  * \return GL_TRUE if OK to render, GL_FALSE if error found
 457  */
 458 GLboolean
 459 _mesa_validate_DrawArrays(struct gl_context *ctx,
 460                           GLenum mode, GLint start, GLsizei count)
 461 {
 462    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 463    FLUSH_CURRENT(ctx, 0);
 464
 465    if (count <= 0) {
 466       if (count < 0)
 467          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
 468       return GL_FALSE;
 469    }
 470
 471    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawArrays")) {
 472       return GL_FALSE;
 473    }
 474
 475    if (!check_valid_to_render(ctx, "glDrawArrays"))
 476       return GL_FALSE;
 477
 478    if (ctx->Const.CheckArrayBounds) {
 479       if (start + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
 480          return GL_FALSE;
 481    }
 482
 483    return GL_TRUE;
 484 }
 485
 486
 487 GLboolean
 488 _mesa_validate_DrawArraysInstanced(struct gl_context *ctx, GLenum mode, GLint first,
 489                                    GLsizei count, GLsizei numInstances)
 490 {
 491    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 492    FLUSH_CURRENT(ctx, 0);
 493
 494    if (count <= 0) {
 495       if (count < 0)
 496          _mesa_error(ctx, GL_INVALID_VALUE,
 497                      "glDrawArraysInstanced(count=%d)", count);
 498       return GL_FALSE;
 499    }
 500
 501    if (first < 0) {
 502       _mesa_error(ctx, GL_INVALID_VALUE,
 503                   "glDrawArraysInstanced(start=%d)", first);
 504       return GL_FALSE;
 505    }
 506
 507    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawArraysInstanced")) {
 508       return GL_FALSE;
 509    }
 510
 511    if (numInstances <= 0) {
 512       if (numInstances < 0)
 513          _mesa_error(ctx, GL_INVALID_VALUE,
 514                      "glDrawArraysInstanced(numInstances=%d)", numInstances);
 515       return GL_FALSE;
 516    }
 517
 518    if (!check_valid_to_render(ctx, "glDrawArraysInstanced(invalid to render)"))
 519       return GL_FALSE;
 520
 521    if (ctx->Const.CheckArrayBounds) {
 522       if (first + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
 523          return GL_FALSE;
 524    }
 525
 526    return GL_TRUE;
 527 }
 528
 529
 530 GLboolean
 531 _mesa_validate_DrawElementsInstanced(struct gl_context *ctx,
 532                                      GLenum mode, GLsizei count, GLenum type,
 533                                      const GLvoid *indices, GLsizei numInstances,
 534                                      GLint basevertex)
 535 {
 536    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 537    FLUSH_CURRENT(ctx, 0);
 538
 539    if (count <= 0) {
 540       if (count < 0)
 541          _mesa_error(ctx, GL_INVALID_VALUE,
 542                      "glDrawElementsInstanced(count=%d)", count);
 543       return GL_FALSE;
 544    }
 545
 546    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawElementsInstanced")) {
 547       return GL_FALSE;
 548    }
 549
 550    if (type != GL_UNSIGNED_INT &&
 551        type != GL_UNSIGNED_BYTE &&
 552        type != GL_UNSIGNED_SHORT) {
 553       _mesa_error(ctx, GL_INVALID_ENUM,
 554                   "glDrawElementsInstanced(type=0x%x)", type);
 555       return GL_FALSE;
 556    }
 557
 558    if (numInstances <= 0) {
 559       if (numInstances < 0)
 560          _mesa_error(ctx, GL_INVALID_VALUE,
 561                      "glDrawElementsInstanced(numInstances=%d)", numInstances);
 562       return GL_FALSE;
 563    }
 564
 565    if (!check_valid_to_render(ctx, "glDrawElementsInstanced"))
 566       return GL_FALSE;
 567
 568    /* Vertex buffer object tests */
 569    if (_mesa_is_bufferobj(ctx->Array.ArrayObj->ElementArrayBufferObj)) {
 570       /* use indices in the buffer object */
 571       /* make sure count doesn't go outside buffer bounds */
 572       if (index_bytes(type, count) > ctx->Array.ArrayObj->ElementArrayBufferObj->Size) {
 573          _mesa_warning(ctx,
 574                        "glDrawElementsInstanced index out of buffer bounds");
 575          return GL_FALSE;
 576       }
 577    }
 578    else {
 579       /* not using a VBO */
 580       if (!indices)
 581          return GL_FALSE;
 582    }
 583
 584    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 585       return GL_FALSE;
 586
 587    return GL_TRUE;
 588 }
 589
 590
 591 #if FEATURE_EXT_transform_feedback
 592
 593 GLboolean
 594 _mesa_validate_DrawTransformFeedback(struct gl_context *ctx,
 595                                      GLenum mode,
 596                                      struct gl_transform_feedback_object *obj)
 597 {
 598    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 599    FLUSH_CURRENT(ctx, 0);
 600
 601    if (!_mesa_valid_prim_mode(ctx, mode, "glDrawTransformFeedback")) {
 602       return GL_FALSE;
 603    }
 604
 605    if (!obj) {
 606       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawTransformFeedback(name)");
 607       return GL_FALSE;
 608    }
 609
 610    if (!obj->EndedAnytime) {
 611       _mesa_error(ctx, GL_INVALID_OPERATION, "glDrawTransformFeedback");
 612       return GL_FALSE;
 613    }
 614
 615    if (!check_valid_to_render(ctx, "glDrawTransformFeedback")) {
 616       return GL_FALSE;
 617    }
 618
 619    return GL_TRUE;
 620 }
 621
 622 #endif