dll/opengl/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 <precomp.h>
  26
  27 /**
  28  * \return  number of bytes in array [count] of type.
  29  */
  30 static GLsizei
  31 index_bytes(GLenum type, GLsizei count)
  32 {
  33    if (type == GL_UNSIGNED_INT) {
  34       return count * sizeof(GLuint);
  35    }
  36    else if (type == GL_UNSIGNED_BYTE) {
  37       return count * sizeof(GLubyte);
  38    }
  39    else {
  40       ASSERT(type == GL_UNSIGNED_SHORT);
  41       return count * sizeof(GLushort);
  42    }
  43 }
  44
  45
  46 /**
  47  * Find the max index in the given element/index buffer
  48  */
  49 GLuint
  50 _mesa_max_buffer_index(struct gl_context *ctx, GLuint count, GLenum type,
  51                        const void *indices,
  52                        struct gl_buffer_object *elementBuf)
  53 {
  54    const GLubyte *map = NULL;
  55    GLuint max = 0;
  56    GLuint i;
  57
  58    if (_mesa_is_bufferobj(elementBuf)) {
  59       /* elements are in a user-defined buffer object.  need to map it */
  60       map = ctx->Driver.MapBufferRange(ctx, 0, elementBuf->Size,
  61                                        GL_MAP_READ_BIT, elementBuf);
  62       /* Actual address is the sum of pointers */
  63       indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices);
  64    }
  65
  66    if (type == GL_UNSIGNED_INT) {
  67       for (i = 0; i < count; i++)
  68          if (((GLuint *) indices)[i] > max)
  69             max = ((GLuint *) indices)[i];
  70    }
  71    else if (type == GL_UNSIGNED_SHORT) {
  72       for (i = 0; i < count; i++)
  73          if (((GLushort *) indices)[i] > max)
  74             max = ((GLushort *) indices)[i];
  75    }
  76    else {
  77       ASSERT(type == GL_UNSIGNED_BYTE);
  78       for (i = 0; i < count; i++)
  79          if (((GLubyte *) indices)[i] > max)
  80             max = ((GLubyte *) indices)[i];
  81    }
  82
  83    if (map) {
  84       ctx->Driver.UnmapBuffer(ctx, elementBuf);
  85    }
  86
  87    return max;
  88 }
  89
  90
  91 /**
  92  * Check if OK to draw arrays/elements.
  93  */
  94 static GLboolean
  95 check_valid_to_render(struct gl_context *ctx, const char *function)
  96 {
  97    if (!_mesa_valid_to_render(ctx, function)) {
  98       return GL_FALSE;
  99    }
 100
 101    /* Draw if we have vertex positions (GL_VERTEX_ARRAY or generic
 102     * array [0]).
 103     */
 104    return ctx->Array.VertexAttrib[VERT_ATTRIB_POS].Enabled;
 105 }
 106
 107
 108 /**
 109  * Do bounds checking on array element indexes.  Check that the vertices
 110  * pointed to by the indices don't lie outside buffer object bounds.
 111  * \return GL_TRUE if OK, GL_FALSE if any indexed vertex goes is out of bounds
 112  */
 113 static GLboolean
 114 check_index_bounds(struct gl_context *ctx, GLsizei count, GLenum type,
 115                    const GLvoid *indices)
 116 {
 117    struct _mesa_prim prim;
 118    struct _mesa_index_buffer ib;
 119    GLuint min, max;
 120
 121    /* Only the X Server needs to do this -- otherwise, accessing outside
 122     * array/BO bounds allows application termination.
 123     */
 124    if (!ctx->Const.CheckArrayBounds)
 125       return GL_TRUE;
 126
 127    memset(&prim, 0, sizeof(prim));
 128    prim.count = count;
 129
 130    memset(&ib, 0, sizeof(ib));
 131    ib.type = type;
 132    ib.ptr = indices;
 133    ib.obj = ctx->Array.ElementArrayBufferObj;
 134
 135    vbo_get_minmax_index(ctx, &prim, &ib, &min, &max);
 136
 137    if (max >= ctx->Array._MaxElement) {
 138       /* the max element is out of bounds of one or more enabled arrays */
 139       _mesa_warning(ctx, "glDrawElements() index=%u is out of bounds (max=%u)",
 140                     max, ctx->Array._MaxElement);
 141       return GL_FALSE;
 142    }
 143
 144    return GL_TRUE;
 145 }
 146
 147
 148 /**
 149  * Is 'mode' a valid value for glBegin(), glDrawArrays(), glDrawElements(),
 150  * etc?  The set of legal values depends on whether geometry shaders/programs
 151  * are supported.
 152  */
 153 GLboolean
 154 _mesa_valid_prim_mode(const struct gl_context *ctx, GLenum mode)
 155 {
 156    if (mode > GL_POLYGON) {
 157       return GL_FALSE;
 158    }
 159    else {
 160       return GL_TRUE;
 161    }
 162 }
 163
 164
 165 /**
 166  * Error checking for glDrawElements().  Includes parameter checking
 167  * and VBO bounds checking.
 168  * \return GL_TRUE if OK to render, GL_FALSE if error found
 169  */
 170 GLboolean
 171 _mesa_validate_DrawElements(struct gl_context *ctx,
 172                             GLenum mode, GLsizei count, GLenum type,
 173                             const GLvoid *indices)
 174 {
 175    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 176
 177    if (count <= 0) {
 178       if (count < 0)
 179          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawElements(count)" );
 180       return GL_FALSE;
 181    }
 182
 183    if (!_mesa_valid_prim_mode(ctx, mode)) {
 184       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(mode)" );
 185       return GL_FALSE;
 186    }
 187
 188    if (type != GL_UNSIGNED_INT &&
 189        type != GL_UNSIGNED_BYTE &&
 190        type != GL_UNSIGNED_SHORT)
 191    {
 192       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)" );
 193       return GL_FALSE;
 194    }
 195
 196    if (!check_valid_to_render(ctx, "glDrawElements"))
 197       return GL_FALSE;
 198
 199    /* Vertex buffer object tests */
 200    if (_mesa_is_bufferobj(ctx->Array.ElementArrayBufferObj)) {
 201       /* use indices in the buffer object */
 202       /* make sure count doesn't go outside buffer bounds */
 203       if (index_bytes(type, count) > ctx->Array.ElementArrayBufferObj->Size) {
 204          _mesa_warning(ctx, "glDrawElements index out of buffer bounds");
 205          return GL_FALSE;
 206       }
 207    }
 208    else {
 209       /* not using a VBO */
 210       if (!indices)
 211          return GL_FALSE;
 212    }
 213
 214    if (!check_index_bounds(ctx, count, type, indices))
 215       return GL_FALSE;
 216
 217    return GL_TRUE;
 218 }
 219
 220
 221 /**
 222  * Called from the tnl module to error check the function parameters and
 223  * verify that we really can draw something.
 224  * \return GL_TRUE if OK to render, GL_FALSE if error found
 225  */
 226 GLboolean
 227 _mesa_validate_DrawArrays(struct gl_context *ctx,
 228                           GLenum mode, GLint start, GLsizei count)
 229 {
 230    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 231
 232    if (count <= 0) {
 233       if (count < 0)
 234          _mesa_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count)" );
 235       return GL_FALSE;
 236    }
 237
 238    if (!_mesa_valid_prim_mode(ctx, mode)) {
 239       _mesa_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" );
 240       return GL_FALSE;
 241    }
 242
 243    if (!check_valid_to_render(ctx, "glDrawArrays"))
 244       return GL_FALSE;
 245
 246    if (ctx->Const.CheckArrayBounds) {
 247       if (start + count > (GLint) ctx->Array._MaxElement)
 248          return GL_FALSE;
 249    }
 250
 251    return GL_TRUE;
 252 }