api_validate.c revision d8c6719f95b1543296ac954f95d13b048ae48634
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 "context.h" 28#include "imports.h" 29#include "mtypes.h" 30#include "state.h" 31 32 33/** 34 * Find the max index in the given element/index buffer 35 */ 36static GLuint 37max_buffer_index(GLcontext *ctx, GLuint count, GLenum type, 38 const void *indices, 39 struct gl_buffer_object *elementBuf) 40{ 41 const GLubyte *map = NULL; 42 GLuint max = 0; 43 GLint i; 44 45 if (elementBuf->Name) { 46 /* elements are in a user-defined buffer object. need to map it */ 47 map = ctx->Driver.MapBuffer(ctx, 48 GL_ELEMENT_ARRAY_BUFFER_ARB, 49 GL_READ_ONLY, 50 elementBuf); 51 /* Actual address is the sum of pointers */ 52 indices = (const GLvoid *) ADD_POINTERS(map, (const GLubyte *) indices); 53 } 54 55 if (type == GL_UNSIGNED_INT) { 56 for (i = 0; i < count; i++) 57 if (((GLuint *) indices)[i] > max) 58 max = ((GLuint *) indices)[i]; 59 } 60 else if (type == GL_UNSIGNED_SHORT) { 61 for (i = 0; i < count; i++) 62 if (((GLushort *) indices)[i] > max) 63 max = ((GLushort *) indices)[i]; 64 } 65 else { 66 ASSERT(type == GL_UNSIGNED_BYTE); 67 for (i = 0; i < count; i++) 68 if (((GLubyte *) indices)[i] > max) 69 max = ((GLubyte *) indices)[i]; 70 } 71 72 if (map) { 73 ctx->Driver.UnmapBuffer(ctx, 74 GL_ELEMENT_ARRAY_BUFFER_ARB, 75 ctx->Array.ElementArrayBufferObj); 76 } 77 78 return max; 79} 80 81 82GLboolean 83_mesa_validate_DrawElements(GLcontext *ctx, 84 GLenum mode, GLsizei count, GLenum type, 85 const GLvoid *indices) 86{ 87 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); 88 89 if (count <= 0) { 90 if (count < 0) 91 _mesa_error(ctx, GL_INVALID_VALUE, "glDrawElements(count)" ); 92 return GL_FALSE; 93 } 94 95 if (mode > GL_POLYGON) { 96 _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(mode)" ); 97 return GL_FALSE; 98 } 99 100 if (type != GL_UNSIGNED_INT && 101 type != GL_UNSIGNED_BYTE && 102 type != GL_UNSIGNED_SHORT) 103 { 104 _mesa_error(ctx, GL_INVALID_ENUM, "glDrawElements(type)" ); 105 return GL_FALSE; 106 } 107 108 if (ctx->NewState) 109 _mesa_update_state(ctx); 110 111 /* Always need vertex positions */ 112 if (!ctx->Array.ArrayObj->Vertex.Enabled 113 && !(ctx->VertexProgram._Enabled 114 && ctx->Array.ArrayObj->VertexAttrib[0].Enabled)) 115 return GL_FALSE; 116 117 /* Vertex buffer object tests */ 118 if (ctx->Array.ElementArrayBufferObj->Name) { 119 /* use indices in the buffer object */ 120 GLuint indexBytes; 121 122 if (type == GL_UNSIGNED_INT) { 123 indexBytes = count * sizeof(GLuint); 124 } 125 else if (type == GL_UNSIGNED_BYTE) { 126 indexBytes = count * sizeof(GLubyte); 127 } 128 else { 129 ASSERT(type == GL_UNSIGNED_SHORT); 130 indexBytes = count * sizeof(GLushort); 131 } 132 133 /* make sure count doesn't go outside buffer bounds */ 134 if (indexBytes > ctx->Array.ElementArrayBufferObj->Size) { 135 _mesa_warning(ctx, "glDrawElements index out of buffer bounds"); 136 return GL_FALSE; 137 } 138 } 139 else { 140 /* not using a VBO */ 141 if (!indices) 142 return GL_FALSE; 143 } 144 145 if (ctx->Const.CheckArrayBounds) { 146 /* find max array index */ 147 GLuint max = max_buffer_index(ctx, count, type, indices, 148 ctx->Array.ElementArrayBufferObj); 149 if (max >= ctx->Array._MaxElement) { 150 /* the max element is out of bounds of one or more enabled arrays */ 151 return GL_FALSE; 152 } 153 } 154 155 return GL_TRUE; 156} 157 158 159GLboolean 160_mesa_validate_DrawRangeElements(GLcontext *ctx, GLenum mode, 161 GLuint start, GLuint end, 162 GLsizei count, GLenum type, 163 const GLvoid *indices) 164{ 165 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); 166 167 if (count <= 0) { 168 if (count < 0) 169 _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(count)" ); 170 return GL_FALSE; 171 } 172 173 if (mode > GL_POLYGON) { 174 _mesa_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(mode)" ); 175 return GL_FALSE; 176 } 177 178 if (end < start) { 179 _mesa_error(ctx, GL_INVALID_VALUE, "glDrawRangeElements(end<start)"); 180 return GL_FALSE; 181 } 182 183 if (type != GL_UNSIGNED_INT && 184 type != GL_UNSIGNED_BYTE && 185 type != GL_UNSIGNED_SHORT) { 186 _mesa_error(ctx, GL_INVALID_ENUM, "glDrawRangeElements(type)" ); 187 return GL_FALSE; 188 } 189 190 if (ctx->NewState) 191 _mesa_update_state(ctx); 192 193 /* Always need vertex positions */ 194 if (!ctx->Array.ArrayObj->Vertex.Enabled 195 && !(ctx->VertexProgram._Enabled 196 && ctx->Array.ArrayObj->VertexAttrib[0].Enabled)) 197 return GL_FALSE; 198 199 /* Vertex buffer object tests */ 200 if (ctx->Array.ElementArrayBufferObj->Name) { 201 /* use indices in the buffer object */ 202 GLuint indexBytes; 203 204 if (type == GL_UNSIGNED_INT) { 205 indexBytes = count * sizeof(GLuint); 206 } 207 else if (type == GL_UNSIGNED_BYTE) { 208 indexBytes = count * sizeof(GLubyte); 209 } 210 else { 211 ASSERT(type == GL_UNSIGNED_SHORT); 212 indexBytes = count * sizeof(GLushort); 213 } 214 215 /* make sure count doesn't go outside buffer bounds */ 216 if (indexBytes > ctx->Array.ElementArrayBufferObj->Size) { 217 _mesa_warning(ctx, "glDrawElements index out of buffer bounds"); 218 return GL_FALSE; 219 } 220 } 221 else { 222 /* not using a VBO */ 223 if (!indices) 224 return GL_FALSE; 225 } 226 227 if (ctx->Const.CheckArrayBounds) { 228 GLuint max = max_buffer_index(ctx, count, type, indices, 229 ctx->Array.ElementArrayBufferObj); 230 if (max >= ctx->Array._MaxElement) { 231 /* the max element is out of bounds of one or more enabled arrays */ 232 return GL_FALSE; 233 } 234 } 235 236 return GL_TRUE; 237} 238 239 240/** 241 * Called from the tnl module to error check the function parameters and 242 * verify that we really can draw something. 243 */ 244GLboolean 245_mesa_validate_DrawArrays(GLcontext *ctx, 246 GLenum mode, GLint start, GLsizei count) 247{ 248 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); 249 250 if (count < 0) { 251 _mesa_error(ctx, GL_INVALID_VALUE, "glDrawArrays(count)" ); 252 return GL_FALSE; 253 } 254 255 if (mode > GL_POLYGON) { 256 _mesa_error(ctx, GL_INVALID_ENUM, "glDrawArrays(mode)" ); 257 return GL_FALSE; 258 } 259 260 if (ctx->NewState) 261 _mesa_update_state(ctx); 262 263 /* Always need vertex positions */ 264 if (!ctx->Array.ArrayObj->Vertex.Enabled 265 && !ctx->Array.ArrayObj->VertexAttrib[0].Enabled) 266 return GL_FALSE; 267 268 if (ctx->Const.CheckArrayBounds) { 269 if (start + count > (GLint) ctx->Array._MaxElement) 270 return GL_FALSE; 271 } 272 273 return GL_TRUE; 274} 275