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 "vbo/vbo.h"
  33
  34
  35 /**
  36  * \return  number of bytes in array [count] of type.
  37  */
  38 static GLsizei
  39 index_bytes(GLenum type, GLsizei count)
  40 {
  41    if (type == GL_UNSIGNED_INT) {
  42       return count * sizeof(GLuint);
  43    }
  44    else if (type == GL_UNSIGNED_BYTE) {
  45       return count * sizeof(GLubyte);
  46    }
  47    else {
  48       ASSERT(type == GL_UNSIGNED_SHORT);
  49       return count * sizeof(GLushort);
  50    }
  51 }
  52
  53
  54 /**
  55  * Find the max index in the given element/index buffer
  56  */
  57 GLuint
  58 _mesa_max_buffer_index(struct gl_context *ctx, GLuint count, GLenum type,
  59                        const void *indices,
  60                        struct gl_buffer_object *elementBuf)
  61 {
  62    const GLubyte *map = NULL;
  63    GLuint max = 0;
  64    GLuint i;
  65
  66    if (_mesa_is_bufferobj(elementBuf)) {
  67       /* elements are in a user-defined buffer object.  need to map it */
  68       map = ctx->Driver.MapBufferRange(ctx, 0, elementBuf->Size,
  69                                        GL_MAP_READ_BIT, elementBuf);
  70       /* Actual address is the sum of pointers */
  71       indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices);
  72    }
  73
  74    if (type == GL_UNSIGNED_INT) {
  75       for (i = 0; i < count; i++)
  76          if (((GLuint *) indices)[i] > max)
  77             max = ((GLuint *) indices)[i];
  78    }
  79    else if (type == GL_UNSIGNED_SHORT) {
  80       for (i = 0; i < count; i++)
  81          if (((GLushort *) indices)[i] > max)
  82             max = ((GLushort *) indices)[i];
  83    }
  84    else {
  85       ASSERT(type == GL_UNSIGNED_BYTE);
  86       for (i = 0; i < count; i++)
  87          if (((GLubyte *) indices)[i] > max)
  88             max = ((GLubyte *) indices)[i];
  89    }
  90
  91    if (map) {
  92       ctx->Driver.UnmapBuffer(ctx, elementBuf);
  93    }
  94
  95    return max;
  96 }
  97
  98
  99 /**
 100  * Check if OK to draw arrays/elements.
 101  */
 102 static GLboolean
 103 check_valid_to_render(struct gl_context *ctx, const char *function)
 104 {
 105    if (!_mesa_valid_to_render(ctx, function)) {
 106       return GL_FALSE;
 107    }
 108
 109    switch (ctx->API) {
 110 #if FEATURE_es2_glsl
 111    case API_OPENGLES2:
 112       /* For ES2, we can draw if any vertex array is enabled (and we
 113        * should always have a vertex program/shader). */
 114       if (ctx->Array.ArrayObj->_Enabled == 0x0 || !ctx->VertexProgram._Current)
 115          return GL_FALSE;
 116       break;
 117 #endif
 118
 119 #if FEATURE_ES1
 120    case API_OPENGLES:
 121       /* For OpenGL ES, only draw if we have vertex positions
 122        */
 123       if (!ctx->Array.ArrayObj->Vertex.Enabled)
 124          return GL_FALSE;
 125       break;
 126 #endif
 127
 128 #if FEATURE_GL
 129    case API_OPENGL:
 130       {
 131          const struct gl_shader_program *vsProg =
 132             ctx->Shader.CurrentVertexProgram;
 133          GLboolean haveVertexShader = (vsProg && vsProg->LinkStatus);
 134          GLboolean haveVertexProgram = ctx->VertexProgram._Enabled;
 135          if (haveVertexShader || haveVertexProgram) {
 136             /* Draw regardless of whether or not we have any vertex arrays.
 137              * (Ex: could draw a point using a constant vertex pos)
 138              */
 139             return GL_TRUE;
 140          }
 141          else {
 142             /* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
 143              * array [0]).
 144              */
 145             return (ctx->Array.ArrayObj->Vertex.Enabled ||
 146                     ctx->Array.ArrayObj->VertexAttrib[0].Enabled);
 147          }
 148       }
 149       break;
 150 #endif
 151
 152    default:
 153       ASSERT_NO_FEATURE();
 154    }
 155
 156    return GL_TRUE;
 157 }
 158
 159
 160 /**
 161  * Do bounds checking on array element indexes.  Check that the vertices
 162  * pointed to by the indices don't lie outside buffer object bounds.
 163  * \return GL_TRUE if OK, GL_FALSE if any indexed vertex goes is out of bounds
 164  */
 165 static GLboolean
 166 check_index_bounds(struct gl_context *ctx, GLsizei count, GLenum type,
 167                    const GLvoid *indices, GLint basevertex)
 168 {
 169    struct _mesa_prim prim;
 170    struct _mesa_index_buffer ib;
 171    GLuint min, max;
 172
 173    /* Only the X Server needs to do this -- otherwise, accessing outside
 174     * array/BO bounds allows application termination.
 175     */
 176    if (!ctx->Const.CheckArrayBounds)
 177       return GL_TRUE;
 178
 179    memset(&prim, 0, sizeof(prim));
 180    prim.count = count;
 181
 182    memset(&ib, 0, sizeof(ib));
 183    ib.type = type;
 184    ib.ptr = indices;
 185    ib.obj = ctx->Array.ElementArrayBufferObj;
 186
 187    vbo_get_minmax_index(ctx, &prim, &ib, &min, &max);
 188
 189    if ((int)(min + basevertex) < 0 ||
 190        max + basevertex > ctx->Array.ArrayObj->_MaxElement) {
 191       /* the max element is out of bounds of one or more enabled arrays */
 192       _mesa_warning(ctx, "glDrawElements() index=%u is out of bounds (max=%u)",
 193                     max, ctx->Array.ArrayObj->_MaxElement);
 194       return GL_FALSE;
 195    }
 196
 197    return GL_TRUE;
 198 }
 199
 200
 201 /**
 202  * Error checking for glDrawElements().  Includes parameter checking
 203  * and VBO bounds checking.
 204  * \return GL_TRUE if OK to render, GL_FALSE if error found
 205  */
 206 GLboolean
 207 _mesa_validate_DrawElements(struct gl_context *ctx,
 208                             GLenum mode, GLsizei count, GLenum type,
 209                             const GLvoid *indices, GLint basevertex)
 210 {
 211    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 212
 213    if (count <= 0) {
 214       if (count < 0)
 215          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
 216       return GL_FALSE;
 217    }
 218
 219    if (mode > GL_TRIANGLE_STRIP_ADJACENCY_ARB) {
 220       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(mode)" );
 221       return GL_FALSE;
 222    }
 223
 224    if (type != GL_UNSIGNED_INT &&
 225        type != GL_UNSIGNED_BYTE &&
 226        type != GL_UNSIGNED_SHORT)
 227    {
 228       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
 229       return GL_FALSE;
 230    }
 231
 232    if (!check_valid_to_render(ctx, "glDrawElements"))
 233       return GL_FALSE;
 234
 235    /* Vertex buffer object tests */
 236    if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
 237       /* use indices in the buffer object */
 238       /* make sure count doesn't go outside buffer bounds */
 239       if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) {
 240          _mesa_warning(ctx, "glDrawElements index out of buffer bounds");
 241          return GL_FALSE;
 242       }
 243    }
 244    else {
 245       /* not using a VBO */
 246       if (!indices)
 247          return GL_FALSE;
 248    }
 249
 250    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 251       return GL_FALSE;
 252
 253    return GL_TRUE;
 254 }
 255
 256
 257 /**
 258  * Error checking for glDrawRangeElements().  Includes parameter checking
 259  * and VBO bounds checking.
 260  * \return GL_TRUE if OK to render, GL_FALSE if error found
 261  */
 262 GLboolean
 263 _mesa_validate_DrawRangeElements(struct gl_context *ctx, GLenum mode,
 264                                  GLuint start, GLuint end,
 265                                  GLsizei count, GLenum type,
 266                                  const GLvoid *indices, GLint basevertex)
 267 {
 268    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 269
 270    if (count <= 0) {
 271       if (count < 0)
 272          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(count)" );
 273       return GL_FALSE;
 274    }
 275
 276    if (mode > GL_TRIANGLE_STRIP_ADJACENCY_ARB) {
 277       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(mode)" );
 278       return GL_FALSE;
 279    }
 280
 281    if (end < start) {
 282       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(end<start)");
 283       return GL_FALSE;
 284    }
 285
 286    if (type != GL_UNSIGNED_INT &&
 287        type != GL_UNSIGNED_BYTE &&
 288        type != GL_UNSIGNED_SHORT) {
 289       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(type)" );
 290       return GL_FALSE;
 291    }
 292
 293    if (!check_valid_to_render(ctx, "glDrawRangeElements"))
 294       return GL_FALSE;
 295
 296    /* Vertex buffer object tests */
 297    if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
 298       /* use indices in the buffer object */
 299       /* make sure count doesn't go outside buffer bounds */
 300       if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) {
 301          _mesa_warning(ctx, "glDrawRangeElements index out of buffer bounds");
 302          return GL_FALSE;
 303       }
 304    }
 305    else {
 306       /* not using a VBO */
 307       if (!indices)
 308          return GL_FALSE;
 309    }
 310
 311    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 312       return GL_FALSE;
 313
 314    return GL_TRUE;
 315 }
 316
 317
 318 /**
 319  * Called from the tnl module to error check the function parameters and
 320  * verify that we really can draw something.
 321  * \return GL_TRUE if OK to render, GL_FALSE if error found
 322  */
 323 GLboolean
 324 _mesa_validate_DrawArrays(struct gl_context *ctx,
 325                           GLenum mode, GLint start, GLsizei count)
 326 {
 327    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 328
 329    if (count <= 0) {
 330       if (count < 0)
 331          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
 332       return GL_FALSE;
 333    }
 334
 335    if (mode > GL_TRIANGLE_STRIP_ADJACENCY_ARB) {
 336       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
 337       return GL_FALSE;
 338    }
 339
 340    if (!check_valid_to_render(ctx, "glDrawArrays"))
 341       return GL_FALSE;
 342
 343    if (ctx->Const.CheckArrayBounds) {
 344       if (start + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
 345          return GL_FALSE;
 346    }
 347
 348    return GL_TRUE;
 349 }
 350
 351
 352 GLboolean
 353 _mesa_validate_DrawArraysInstanced(struct gl_context *ctx, GLenum mode, GLint first,
 354                                    GLsizei count, GLsizei numInstances)
 355 {
 356    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 357
 358    if (count <= 0) {
 359       if (count < 0)
 360          _mesa_error(ctx, GL_INVALID_VALUE,
 361                      "glDrawArraysInstanced(count=%d)", count);
 362       return GL_FALSE;
 363    }
 364
 365    if (mode > GL_TRIANGLE_STRIP_ADJACENCY_ARB) {
 366       _mesa_error(ctx, GL_INVALID_ENUM,
 367                   "glDrawArraysInstanced(mode=0x%x)", mode);
 368       return GL_FALSE;
 369    }
 370
 371    if (numInstances <= 0) {
 372       if (numInstances < 0)
 373          _mesa_error(ctx, GL_INVALID_VALUE,
 374                      "glDrawArraysInstanced(numInstances=%d)", numInstances);
 375       return GL_FALSE;
 376    }
 377
 378    if (!check_valid_to_render(ctx, "glDrawArraysInstanced(invalid to render)"))
 379       return GL_FALSE;
 380
 381    if (ctx->CompileFlag) {
 382       _mesa_error(ctx, GL_INVALID_OPERATION,
 383                   "glDrawArraysInstanced(display list");
 384       return GL_FALSE;
 385    }
 386
 387    if (ctx->Const.CheckArrayBounds) {
 388       if (first + count > (GLint) ctx->Array.ArrayObj->_MaxElement)
 389          return GL_FALSE;
 390    }
 391
 392    return GL_TRUE;
 393 }
 394
 395
 396 GLboolean
 397 _mesa_validate_DrawElementsInstanced(struct gl_context *ctx,
 398                                      GLenum mode, GLsizei count, GLenum type,
 399                                      const GLvoid *indices, GLsizei numInstances,
 400                                      GLint basevertex)
 401 {
 402    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 403
 404    if (count <= 0) {
 405       if (count < 0)
 406          _mesa_error(ctx, GL_INVALID_VALUE,
 407                      "glDrawElementsInstanced(count=%d)", count);
 408       return GL_FALSE;
 409    }
 410
 411    if (mode > GL_TRIANGLE_STRIP_ADJACENCY_ARB) {
 412       _mesa_error(ctx, GL_INVALID_ENUM,
 413                   "glDrawElementsInstanced(mode = 0x%x)", mode);
 414       return GL_FALSE;
 415    }
 416
 417    if (type != GL_UNSIGNED_INT &&
 418        type != GL_UNSIGNED_BYTE &&
 419        type != GL_UNSIGNED_SHORT) {
 420       _mesa_error(ctx, GL_INVALID_ENUM,
 421                   "glDrawElementsInstanced(type=0x%x)", type);
 422       return GL_FALSE;
 423    }
 424
 425    if (numInstances <= 0) {
 426       if (numInstances < 0)
 427          _mesa_error(ctx, GL_INVALID_VALUE,
 428                      "glDrawElementsInstanced(numInstances=%d)", numInstances);
 429       return GL_FALSE;
 430    }
 431
 432    if (!check_valid_to_render(ctx, "glDrawElementsInstanced"))
 433       return GL_FALSE;
 434
 435    /* Vertex buffer object tests */
 436    if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
 437       /* use indices in the buffer object */
 438       /* make sure count doesn't go outside buffer bounds */
 439       if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) {
 440          _mesa_warning(ctx,
 441                        "glDrawElementsInstanced index out of buffer bounds");
 442          return GL_FALSE;
 443       }
 444    }
 445    else {
 446       /* not using a VBO */
 447       if (!indices)
 448          return GL_FALSE;
 449    }
 450
 451    if (!check_index_bounds(ctx, count, type, indices, basevertex))
 452       return GL_FALSE;
 453
 454    return GL_TRUE;
 455 }