| OLD | NEW |
|---|
| (Empty) |
| 1 | |
| 2 // Copyright (c) 2009 The Chromium Authors. All rights reserved. | |
| 3 // Use of this source code is governed by a BSD-style license that can be | |
| 4 // found in the LICENSE file. | |
| 5 | |
| 6 | |
| 7 namespace gpu { | |
| 8 namespace gles2 { | |
| 9 | |
| 10 namespace { | |
| 11 | |
| 12 parse_error::ParseError ValidateActiveTexture( | |
| 13 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum texture) { | |
| 14 return parse_error::kParseNoError; | |
| 15 } | |
| 16 parse_error::ParseError ValidateAttachShader( | |
| 17 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 18 GLuint shader) { | |
| 19 return parse_error::kParseNoError; | |
| 20 } | |
| 21 parse_error::ParseError ValidateBindAttribLocation( | |
| 22 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 23 GLuint index, const char* name) { | |
| 24 if (name == NULL) { | |
| 25 return parse_error::kParseOutOfBounds; | |
| 26 } | |
| 27 return parse_error::kParseNoError; | |
| 28 } | |
| 29 parse_error::ParseError ValidateBindAttribLocationImmediate( | |
| 30 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 31 GLuint index, const char* name) { | |
| 32 if (name == NULL) { | |
| 33 return parse_error::kParseOutOfBounds; | |
| 34 } | |
| 35 return parse_error::kParseNoError; | |
| 36 } | |
| 37 parse_error::ParseError ValidateBindBuffer( | |
| 38 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 39 GLuint buffer) { | |
| 40 return parse_error::kParseNoError; | |
| 41 } | |
| 42 parse_error::ParseError ValidateBindFramebuffer( | |
| 43 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 44 GLuint framebuffer) { | |
| 45 return parse_error::kParseNoError; | |
| 46 } | |
| 47 parse_error::ParseError ValidateBindRenderbuffer( | |
| 48 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 49 GLuint renderbuffer) { | |
| 50 return parse_error::kParseNoError; | |
| 51 } | |
| 52 parse_error::ParseError ValidateBindTexture( | |
| 53 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 54 GLuint texture) { | |
| 55 return parse_error::kParseNoError; | |
| 56 } | |
| 57 parse_error::ParseError ValidateBlendColor( | |
| 58 GLES2Decoder* decoder, uint32 immediate_data_size, GLclampf red, | |
| 59 GLclampf green, GLclampf blue, GLclampf alpha) { | |
| 60 return parse_error::kParseNoError; | |
| 61 } | |
| 62 parse_error::ParseError ValidateBlendEquation( | |
| 63 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum mode) { | |
| 64 return parse_error::kParseNoError; | |
| 65 } | |
| 66 parse_error::ParseError ValidateBlendEquationSeparate( | |
| 67 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum modeRGB, | |
| 68 GLenum modeAlpha) { | |
| 69 return parse_error::kParseNoError; | |
| 70 } | |
| 71 parse_error::ParseError ValidateBlendFunc( | |
| 72 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum sfactor, | |
| 73 GLenum dfactor) { | |
| 74 return parse_error::kParseNoError; | |
| 75 } | |
| 76 parse_error::ParseError ValidateBlendFuncSeparate( | |
| 77 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum srcRGB, | |
| 78 GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { | |
| 79 return parse_error::kParseNoError; | |
| 80 } | |
| 81 parse_error::ParseError ValidateBufferData( | |
| 82 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 83 GLsizeiptr size, const void* data, GLenum usage) { | |
| 84 if (data == NULL) { | |
| 85 return parse_error::kParseOutOfBounds; | |
| 86 } | |
| 87 return parse_error::kParseNoError; | |
| 88 } | |
| 89 parse_error::ParseError ValidateBufferDataImmediate( | |
| 90 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 91 GLsizeiptr size, const void* data, GLenum usage) { | |
| 92 if (data == NULL) { | |
| 93 return parse_error::kParseOutOfBounds; | |
| 94 } | |
| 95 return parse_error::kParseNoError; | |
| 96 } | |
| 97 parse_error::ParseError ValidateBufferSubData( | |
| 98 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 99 GLintptr offset, GLsizeiptr size, const void* data) { | |
| 100 if (data == NULL) { | |
| 101 return parse_error::kParseOutOfBounds; | |
| 102 } | |
| 103 return parse_error::kParseNoError; | |
| 104 } | |
| 105 parse_error::ParseError ValidateBufferSubDataImmediate( | |
| 106 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 107 GLintptr offset, GLsizeiptr size, const void* data) { | |
| 108 if (data == NULL) { | |
| 109 return parse_error::kParseOutOfBounds; | |
| 110 } | |
| 111 return parse_error::kParseNoError; | |
| 112 } | |
| 113 parse_error::ParseError ValidateCheckFramebufferStatus( | |
| 114 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target) { | |
| 115 return parse_error::kParseNoError; | |
| 116 } | |
| 117 parse_error::ParseError ValidateClear( | |
| 118 GLES2Decoder* decoder, uint32 immediate_data_size, GLbitfield mask) { | |
| 119 return parse_error::kParseNoError; | |
| 120 } | |
| 121 parse_error::ParseError ValidateClearColor( | |
| 122 GLES2Decoder* decoder, uint32 immediate_data_size, GLclampf red, | |
| 123 GLclampf green, GLclampf blue, GLclampf alpha) { | |
| 124 return parse_error::kParseNoError; | |
| 125 } | |
| 126 parse_error::ParseError ValidateClearDepthf( | |
| 127 GLES2Decoder* decoder, uint32 immediate_data_size, GLclampf depth) { | |
| 128 return parse_error::kParseNoError; | |
| 129 } | |
| 130 parse_error::ParseError ValidateClearStencil( | |
| 131 GLES2Decoder* decoder, uint32 immediate_data_size, GLint s) { | |
| 132 return parse_error::kParseNoError; | |
| 133 } | |
| 134 parse_error::ParseError ValidateColorMask( | |
| 135 GLES2Decoder* decoder, uint32 immediate_data_size, GLboolean red, | |
| 136 GLboolean green, GLboolean blue, GLboolean alpha) { | |
| 137 return parse_error::kParseNoError; | |
| 138 } | |
| 139 parse_error::ParseError ValidateCompileShader( | |
| 140 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader) { | |
| 141 return parse_error::kParseNoError; | |
| 142 } | |
| 143 parse_error::ParseError ValidateCompressedTexImage2D( | |
| 144 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 145 GLint level, GLenum internalformat, GLsizei width, GLsizei height, | |
| 146 GLint border, GLsizei imageSize, const void* data) { | |
| 147 if (data == NULL) { | |
| 148 return parse_error::kParseOutOfBounds; | |
| 149 } | |
| 150 return parse_error::kParseNoError; | |
| 151 } | |
| 152 parse_error::ParseError ValidateCompressedTexImage2DImmediate( | |
| 153 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 154 GLint level, GLenum internalformat, GLsizei width, GLsizei height, | |
| 155 GLint border, GLsizei imageSize, const void* data) { | |
| 156 if (data == NULL) { | |
| 157 return parse_error::kParseOutOfBounds; | |
| 158 } | |
| 159 return parse_error::kParseNoError; | |
| 160 } | |
| 161 parse_error::ParseError ValidateCompressedTexSubImage2D( | |
| 162 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 163 GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, | |
| 164 GLenum format, GLsizei imageSize, const void* data) { | |
| 165 if (data == NULL) { | |
| 166 return parse_error::kParseOutOfBounds; | |
| 167 } | |
| 168 return parse_error::kParseNoError; | |
| 169 } | |
| 170 parse_error::ParseError ValidateCompressedTexSubImage2DImmediate( | |
| 171 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 172 GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, | |
| 173 GLenum format, GLsizei imageSize, const void* data) { | |
| 174 if (data == NULL) { | |
| 175 return parse_error::kParseOutOfBounds; | |
| 176 } | |
| 177 return parse_error::kParseNoError; | |
| 178 } | |
| 179 parse_error::ParseError ValidateCopyTexImage2D( | |
| 180 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 181 GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, | |
| 182 GLsizei height, GLint border) { | |
| 183 return parse_error::kParseNoError; | |
| 184 } | |
| 185 parse_error::ParseError ValidateCopyTexSubImage2D( | |
| 186 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 187 GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, | |
| 188 GLsizei height) { | |
| 189 return parse_error::kParseNoError; | |
| 190 } | |
| 191 parse_error::ParseError ValidateCreateProgram( | |
| 192 GLES2Decoder* decoder, uint32 immediate_data_size) { | |
| 193 return parse_error::kParseNoError; | |
| 194 } | |
| 195 parse_error::ParseError ValidateCreateShader( | |
| 196 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum type) { | |
| 197 return parse_error::kParseNoError; | |
| 198 } | |
| 199 parse_error::ParseError ValidateCullFace( | |
| 200 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum mode) { | |
| 201 return parse_error::kParseNoError; | |
| 202 } | |
| 203 parse_error::ParseError ValidateDeleteBuffers( | |
| 204 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 205 const GLuint* buffers) { | |
| 206 if (buffers == NULL) { | |
| 207 return parse_error::kParseOutOfBounds; | |
| 208 } | |
| 209 return parse_error::kParseNoError; | |
| 210 } | |
| 211 parse_error::ParseError ValidateDeleteBuffersImmediate( | |
| 212 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 213 const GLuint* buffers) { | |
| 214 if (buffers == NULL) { | |
| 215 return parse_error::kParseOutOfBounds; | |
| 216 } | |
| 217 return parse_error::kParseNoError; | |
| 218 } | |
| 219 parse_error::ParseError ValidateDeleteFramebuffers( | |
| 220 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 221 const GLuint* framebuffers) { | |
| 222 if (framebuffers == NULL) { | |
| 223 return parse_error::kParseOutOfBounds; | |
| 224 } | |
| 225 return parse_error::kParseNoError; | |
| 226 } | |
| 227 parse_error::ParseError ValidateDeleteFramebuffersImmediate( | |
| 228 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 229 const GLuint* framebuffers) { | |
| 230 if (framebuffers == NULL) { | |
| 231 return parse_error::kParseOutOfBounds; | |
| 232 } | |
| 233 return parse_error::kParseNoError; | |
| 234 } | |
| 235 parse_error::ParseError ValidateDeleteProgram( | |
| 236 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program) { | |
| 237 return parse_error::kParseNoError; | |
| 238 } | |
| 239 parse_error::ParseError ValidateDeleteRenderbuffers( | |
| 240 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 241 const GLuint* renderbuffers) { | |
| 242 if (renderbuffers == NULL) { | |
| 243 return parse_error::kParseOutOfBounds; | |
| 244 } | |
| 245 return parse_error::kParseNoError; | |
| 246 } | |
| 247 parse_error::ParseError ValidateDeleteRenderbuffersImmediate( | |
| 248 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 249 const GLuint* renderbuffers) { | |
| 250 if (renderbuffers == NULL) { | |
| 251 return parse_error::kParseOutOfBounds; | |
| 252 } | |
| 253 return parse_error::kParseNoError; | |
| 254 } | |
| 255 parse_error::ParseError ValidateDeleteShader( | |
| 256 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader) { | |
| 257 return parse_error::kParseNoError; | |
| 258 } | |
| 259 parse_error::ParseError ValidateDeleteTextures( | |
| 260 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 261 const GLuint* textures) { | |
| 262 if (textures == NULL) { | |
| 263 return parse_error::kParseOutOfBounds; | |
| 264 } | |
| 265 return parse_error::kParseNoError; | |
| 266 } | |
| 267 parse_error::ParseError ValidateDeleteTexturesImmediate( | |
| 268 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 269 const GLuint* textures) { | |
| 270 if (textures == NULL) { | |
| 271 return parse_error::kParseOutOfBounds; | |
| 272 } | |
| 273 return parse_error::kParseNoError; | |
| 274 } | |
| 275 parse_error::ParseError ValidateDepthFunc( | |
| 276 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum func) { | |
| 277 return parse_error::kParseNoError; | |
| 278 } | |
| 279 parse_error::ParseError ValidateDepthMask( | |
| 280 GLES2Decoder* decoder, uint32 immediate_data_size, GLboolean flag) { | |
| 281 return parse_error::kParseNoError; | |
| 282 } | |
| 283 parse_error::ParseError ValidateDepthRangef( | |
| 284 GLES2Decoder* decoder, uint32 immediate_data_size, GLclampf zNear, | |
| 285 GLclampf zFar) { | |
| 286 return parse_error::kParseNoError; | |
| 287 } | |
| 288 parse_error::ParseError ValidateDetachShader( | |
| 289 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 290 GLuint shader) { | |
| 291 return parse_error::kParseNoError; | |
| 292 } | |
| 293 parse_error::ParseError ValidateDisable( | |
| 294 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum cap) { | |
| 295 return parse_error::kParseNoError; | |
| 296 } | |
| 297 parse_error::ParseError ValidateDisableVertexAttribArray( | |
| 298 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint index) { | |
| 299 return parse_error::kParseNoError; | |
| 300 } | |
| 301 parse_error::ParseError ValidateDrawArrays( | |
| 302 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum mode, GLint first, | |
| 303 GLsizei count) { | |
| 304 return parse_error::kParseNoError; | |
| 305 } | |
| 306 parse_error::ParseError ValidateDrawElements( | |
| 307 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum mode, | |
| 308 GLsizei count, GLenum type, const void* indices) { | |
| 309 if (indices == NULL) { | |
| 310 return parse_error::kParseOutOfBounds; | |
| 311 } | |
| 312 return parse_error::kParseNoError; | |
| 313 } | |
| 314 parse_error::ParseError ValidateEnable( | |
| 315 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum cap) { | |
| 316 return parse_error::kParseNoError; | |
| 317 } | |
| 318 parse_error::ParseError ValidateEnableVertexAttribArray( | |
| 319 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint index) { | |
| 320 return parse_error::kParseNoError; | |
| 321 } | |
| 322 parse_error::ParseError ValidateFinish( | |
| 323 GLES2Decoder* decoder, uint32 immediate_data_size) { | |
| 324 return parse_error::kParseNoError; | |
| 325 } | |
| 326 parse_error::ParseError ValidateFlush( | |
| 327 GLES2Decoder* decoder, uint32 immediate_data_size) { | |
| 328 return parse_error::kParseNoError; | |
| 329 } | |
| 330 parse_error::ParseError ValidateFramebufferRenderbuffer( | |
| 331 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 332 GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { | |
| 333 return parse_error::kParseNoError; | |
| 334 } | |
| 335 parse_error::ParseError ValidateFramebufferTexture2D( | |
| 336 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 337 GLenum attachment, GLenum textarget, GLuint texture, GLint level) { | |
| 338 return parse_error::kParseNoError; | |
| 339 } | |
| 340 parse_error::ParseError ValidateFrontFace( | |
| 341 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum mode) { | |
| 342 return parse_error::kParseNoError; | |
| 343 } | |
| 344 parse_error::ParseError ValidateGenBuffers( | |
| 345 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 346 GLuint* buffers) { | |
| 347 if (buffers == NULL) { | |
| 348 return parse_error::kParseOutOfBounds; | |
| 349 } | |
| 350 return parse_error::kParseNoError; | |
| 351 } | |
| 352 parse_error::ParseError ValidateGenBuffersImmediate( | |
| 353 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 354 GLuint* buffers) { | |
| 355 if (buffers == NULL) { | |
| 356 return parse_error::kParseOutOfBounds; | |
| 357 } | |
| 358 return parse_error::kParseNoError; | |
| 359 } | |
| 360 parse_error::ParseError ValidateGenerateMipmap( | |
| 361 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target) { | |
| 362 return parse_error::kParseNoError; | |
| 363 } | |
| 364 parse_error::ParseError ValidateGenFramebuffers( | |
| 365 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 366 GLuint* framebuffers) { | |
| 367 if (framebuffers == NULL) { | |
| 368 return parse_error::kParseOutOfBounds; | |
| 369 } | |
| 370 return parse_error::kParseNoError; | |
| 371 } | |
| 372 parse_error::ParseError ValidateGenFramebuffersImmediate( | |
| 373 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 374 GLuint* framebuffers) { | |
| 375 if (framebuffers == NULL) { | |
| 376 return parse_error::kParseOutOfBounds; | |
| 377 } | |
| 378 return parse_error::kParseNoError; | |
| 379 } | |
| 380 parse_error::ParseError ValidateGenRenderbuffers( | |
| 381 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 382 GLuint* renderbuffers) { | |
| 383 if (renderbuffers == NULL) { | |
| 384 return parse_error::kParseOutOfBounds; | |
| 385 } | |
| 386 return parse_error::kParseNoError; | |
| 387 } | |
| 388 parse_error::ParseError ValidateGenRenderbuffersImmediate( | |
| 389 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 390 GLuint* renderbuffers) { | |
| 391 if (renderbuffers == NULL) { | |
| 392 return parse_error::kParseOutOfBounds; | |
| 393 } | |
| 394 return parse_error::kParseNoError; | |
| 395 } | |
| 396 parse_error::ParseError ValidateGenTextures( | |
| 397 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 398 GLuint* textures) { | |
| 399 if (textures == NULL) { | |
| 400 return parse_error::kParseOutOfBounds; | |
| 401 } | |
| 402 return parse_error::kParseNoError; | |
| 403 } | |
| 404 parse_error::ParseError ValidateGenTexturesImmediate( | |
| 405 GLES2Decoder* decoder, uint32 immediate_data_size, GLsizei n, | |
| 406 GLuint* textures) { | |
| 407 if (textures == NULL) { | |
| 408 return parse_error::kParseOutOfBounds; | |
| 409 } | |
| 410 return parse_error::kParseNoError; | |
| 411 } | |
| 412 parse_error::ParseError ValidateGetActiveAttrib( | |
| 413 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 414 GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, | |
| 415 char* name) { | |
| 416 if (length == NULL) { | |
| 417 return parse_error::kParseOutOfBounds; | |
| 418 } | |
| 419 if (size == NULL) { | |
| 420 return parse_error::kParseOutOfBounds; | |
| 421 } | |
| 422 if (type == NULL) { | |
| 423 return parse_error::kParseOutOfBounds; | |
| 424 } | |
| 425 if (name == NULL) { | |
| 426 return parse_error::kParseOutOfBounds; | |
| 427 } | |
| 428 return parse_error::kParseNoError; | |
| 429 } | |
| 430 parse_error::ParseError ValidateGetActiveUniform( | |
| 431 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 432 GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, | |
| 433 char* name) { | |
| 434 if (length == NULL) { | |
| 435 return parse_error::kParseOutOfBounds; | |
| 436 } | |
| 437 if (size == NULL) { | |
| 438 return parse_error::kParseOutOfBounds; | |
| 439 } | |
| 440 if (type == NULL) { | |
| 441 return parse_error::kParseOutOfBounds; | |
| 442 } | |
| 443 if (name == NULL) { | |
| 444 return parse_error::kParseOutOfBounds; | |
| 445 } | |
| 446 return parse_error::kParseNoError; | |
| 447 } | |
| 448 parse_error::ParseError ValidateGetAttachedShaders( | |
| 449 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 450 GLsizei maxcount, GLsizei* count, GLuint* shaders) { | |
| 451 if (count == NULL) { | |
| 452 return parse_error::kParseOutOfBounds; | |
| 453 } | |
| 454 if (shaders == NULL) { | |
| 455 return parse_error::kParseOutOfBounds; | |
| 456 } | |
| 457 return parse_error::kParseNoError; | |
| 458 } | |
| 459 parse_error::ParseError ValidateGetAttribLocation( | |
| 460 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 461 const char* name) { | |
| 462 if (name == NULL) { | |
| 463 return parse_error::kParseOutOfBounds; | |
| 464 } | |
| 465 return parse_error::kParseNoError; | |
| 466 } | |
| 467 parse_error::ParseError ValidateGetAttribLocationImmediate( | |
| 468 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 469 const char* name) { | |
| 470 if (name == NULL) { | |
| 471 return parse_error::kParseOutOfBounds; | |
| 472 } | |
| 473 return parse_error::kParseNoError; | |
| 474 } | |
| 475 parse_error::ParseError ValidateGetBooleanv( | |
| 476 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum pname, | |
| 477 GLboolean* params) { | |
| 478 if (params == NULL) { | |
| 479 return parse_error::kParseOutOfBounds; | |
| 480 } | |
| 481 return parse_error::kParseNoError; | |
| 482 } | |
| 483 parse_error::ParseError ValidateGetBufferParameteriv( | |
| 484 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 485 GLenum pname, GLint* params) { | |
| 486 if (params == NULL) { | |
| 487 return parse_error::kParseOutOfBounds; | |
| 488 } | |
| 489 return parse_error::kParseNoError; | |
| 490 } | |
| 491 parse_error::ParseError ValidateGetError( | |
| 492 GLES2Decoder* decoder, uint32 immediate_data_size) { | |
| 493 return parse_error::kParseNoError; | |
| 494 } | |
| 495 parse_error::ParseError ValidateGetFloatv( | |
| 496 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum pname, | |
| 497 GLfloat* params) { | |
| 498 if (params == NULL) { | |
| 499 return parse_error::kParseOutOfBounds; | |
| 500 } | |
| 501 return parse_error::kParseNoError; | |
| 502 } | |
| 503 parse_error::ParseError ValidateGetFramebufferAttachmentParameteriv( | |
| 504 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 505 GLenum attachment, GLenum pname, GLint* params) { | |
| 506 if (params == NULL) { | |
| 507 return parse_error::kParseOutOfBounds; | |
| 508 } | |
| 509 return parse_error::kParseNoError; | |
| 510 } | |
| 511 parse_error::ParseError ValidateGetIntegerv( | |
| 512 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum pname, | |
| 513 GLint* params) { | |
| 514 if (params == NULL) { | |
| 515 return parse_error::kParseOutOfBounds; | |
| 516 } | |
| 517 return parse_error::kParseNoError; | |
| 518 } | |
| 519 parse_error::ParseError ValidateGetProgramiv( | |
| 520 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 521 GLenum pname, GLint* params) { | |
| 522 if (params == NULL) { | |
| 523 return parse_error::kParseOutOfBounds; | |
| 524 } | |
| 525 return parse_error::kParseNoError; | |
| 526 } | |
| 527 parse_error::ParseError ValidateGetProgramInfoLog( | |
| 528 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 529 GLsizei bufsize, GLsizei* length, char* infolog) { | |
| 530 if (length == NULL) { | |
| 531 return parse_error::kParseOutOfBounds; | |
| 532 } | |
| 533 if (infolog == NULL) { | |
| 534 return parse_error::kParseOutOfBounds; | |
| 535 } | |
| 536 return parse_error::kParseNoError; | |
| 537 } | |
| 538 parse_error::ParseError ValidateGetRenderbufferParameteriv( | |
| 539 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 540 GLenum pname, GLint* params) { | |
| 541 if (params == NULL) { | |
| 542 return parse_error::kParseOutOfBounds; | |
| 543 } | |
| 544 return parse_error::kParseNoError; | |
| 545 } | |
| 546 parse_error::ParseError ValidateGetShaderiv( | |
| 547 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader, | |
| 548 GLenum pname, GLint* params) { | |
| 549 if (params == NULL) { | |
| 550 return parse_error::kParseOutOfBounds; | |
| 551 } | |
| 552 return parse_error::kParseNoError; | |
| 553 } | |
| 554 parse_error::ParseError ValidateGetShaderInfoLog( | |
| 555 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader, | |
| 556 GLsizei bufsize, GLsizei* length, char* infolog) { | |
| 557 if (length == NULL) { | |
| 558 return parse_error::kParseOutOfBounds; | |
| 559 } | |
| 560 if (infolog == NULL) { | |
| 561 return parse_error::kParseOutOfBounds; | |
| 562 } | |
| 563 return parse_error::kParseNoError; | |
| 564 } | |
| 565 parse_error::ParseError ValidateGetShaderPrecisionFormat( | |
| 566 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum shadertype, | |
| 567 GLenum precisiontype, GLint* range, GLint* precision) { | |
| 568 if (range == NULL) { | |
| 569 return parse_error::kParseOutOfBounds; | |
| 570 } | |
| 571 if (precision == NULL) { | |
| 572 return parse_error::kParseOutOfBounds; | |
| 573 } | |
| 574 return parse_error::kParseNoError; | |
| 575 } | |
| 576 parse_error::ParseError ValidateGetShaderSource( | |
| 577 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader, | |
| 578 GLsizei bufsize, GLsizei* length, char* source) { | |
| 579 if (length == NULL) { | |
| 580 return parse_error::kParseOutOfBounds; | |
| 581 } | |
| 582 if (source == NULL) { | |
| 583 return parse_error::kParseOutOfBounds; | |
| 584 } | |
| 585 return parse_error::kParseNoError; | |
| 586 } | |
| 587 parse_error::ParseError ValidateGetString( | |
| 588 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum name) { | |
| 589 return parse_error::kParseNoError; | |
| 590 } | |
| 591 parse_error::ParseError ValidateGetTexParameterfv( | |
| 592 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 593 GLenum pname, GLfloat* params) { | |
| 594 if (params == NULL) { | |
| 595 return parse_error::kParseOutOfBounds; | |
| 596 } | |
| 597 return parse_error::kParseNoError; | |
| 598 } | |
| 599 parse_error::ParseError ValidateGetTexParameteriv( | |
| 600 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 601 GLenum pname, GLint* params) { | |
| 602 if (params == NULL) { | |
| 603 return parse_error::kParseOutOfBounds; | |
| 604 } | |
| 605 return parse_error::kParseNoError; | |
| 606 } | |
| 607 parse_error::ParseError ValidateGetUniformfv( | |
| 608 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 609 GLint location, GLfloat* params) { | |
| 610 if (params == NULL) { | |
| 611 return parse_error::kParseOutOfBounds; | |
| 612 } | |
| 613 return parse_error::kParseNoError; | |
| 614 } | |
| 615 parse_error::ParseError ValidateGetUniformiv( | |
| 616 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 617 GLint location, GLint* params) { | |
| 618 if (params == NULL) { | |
| 619 return parse_error::kParseOutOfBounds; | |
| 620 } | |
| 621 return parse_error::kParseNoError; | |
| 622 } | |
| 623 parse_error::ParseError ValidateGetUniformLocation( | |
| 624 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 625 const char* name) { | |
| 626 if (name == NULL) { | |
| 627 return parse_error::kParseOutOfBounds; | |
| 628 } | |
| 629 return parse_error::kParseNoError; | |
| 630 } | |
| 631 parse_error::ParseError ValidateGetUniformLocationImmediate( | |
| 632 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program, | |
| 633 const char* name) { | |
| 634 if (name == NULL) { | |
| 635 return parse_error::kParseOutOfBounds; | |
| 636 } | |
| 637 return parse_error::kParseNoError; | |
| 638 } | |
| 639 parse_error::ParseError ValidateGetVertexAttribfv( | |
| 640 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint index, | |
| 641 GLenum pname, GLfloat* params) { | |
| 642 if (params == NULL) { | |
| 643 return parse_error::kParseOutOfBounds; | |
| 644 } | |
| 645 return parse_error::kParseNoError; | |
| 646 } | |
| 647 parse_error::ParseError ValidateGetVertexAttribiv( | |
| 648 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint index, | |
| 649 GLenum pname, GLint* params) { | |
| 650 if (params == NULL) { | |
| 651 return parse_error::kParseOutOfBounds; | |
| 652 } | |
| 653 return parse_error::kParseNoError; | |
| 654 } | |
| 655 parse_error::ParseError ValidateGetVertexAttribPointerv( | |
| 656 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint index, | |
| 657 GLenum pname, void** pointer) { | |
| 658 if (pointer == NULL) { | |
| 659 return parse_error::kParseOutOfBounds; | |
| 660 } | |
| 661 return parse_error::kParseNoError; | |
| 662 } | |
| 663 parse_error::ParseError ValidateHint( | |
| 664 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 665 GLenum mode) { | |
| 666 return parse_error::kParseNoError; | |
| 667 } | |
| 668 parse_error::ParseError ValidateIsBuffer( | |
| 669 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint buffer) { | |
| 670 return parse_error::kParseNoError; | |
| 671 } | |
| 672 parse_error::ParseError ValidateIsEnabled( | |
| 673 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum cap) { | |
| 674 return parse_error::kParseNoError; | |
| 675 } | |
| 676 parse_error::ParseError ValidateIsFramebuffer( | |
| 677 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint framebuffer) { | |
| 678 return parse_error::kParseNoError; | |
| 679 } | |
| 680 parse_error::ParseError ValidateIsProgram( | |
| 681 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program) { | |
| 682 return parse_error::kParseNoError; | |
| 683 } | |
| 684 parse_error::ParseError ValidateIsRenderbuffer( | |
| 685 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint renderbuffer) { | |
| 686 return parse_error::kParseNoError; | |
| 687 } | |
| 688 parse_error::ParseError ValidateIsShader( | |
| 689 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader) { | |
| 690 return parse_error::kParseNoError; | |
| 691 } | |
| 692 parse_error::ParseError ValidateIsTexture( | |
| 693 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint texture) { | |
| 694 return parse_error::kParseNoError; | |
| 695 } | |
| 696 parse_error::ParseError ValidateLineWidth( | |
| 697 GLES2Decoder* decoder, uint32 immediate_data_size, GLfloat width) { | |
| 698 return parse_error::kParseNoError; | |
| 699 } | |
| 700 parse_error::ParseError ValidateLinkProgram( | |
| 701 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program) { | |
| 702 return parse_error::kParseNoError; | |
| 703 } | |
| 704 parse_error::ParseError ValidatePixelStorei( | |
| 705 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum pname, | |
| 706 GLint param) { | |
| 707 return parse_error::kParseNoError; | |
| 708 } | |
| 709 parse_error::ParseError ValidatePolygonOffset( | |
| 710 GLES2Decoder* decoder, uint32 immediate_data_size, GLfloat factor, | |
| 711 GLfloat units) { | |
| 712 return parse_error::kParseNoError; | |
| 713 } | |
| 714 parse_error::ParseError ValidateReadPixels( | |
| 715 GLES2Decoder* decoder, uint32 immediate_data_size, GLint x, GLint y, | |
| 716 GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) { | |
| 717 if (pixels == NULL) { | |
| 718 return parse_error::kParseOutOfBounds; | |
| 719 } | |
| 720 return parse_error::kParseNoError; | |
| 721 } | |
| 722 parse_error::ParseError ValidateRenderbufferStorage( | |
| 723 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 724 GLenum internalformat, GLsizei width, GLsizei height) { | |
| 725 return parse_error::kParseNoError; | |
| 726 } | |
| 727 parse_error::ParseError ValidateSampleCoverage( | |
| 728 GLES2Decoder* decoder, uint32 immediate_data_size, GLclampf value, | |
| 729 GLboolean invert) { | |
| 730 return parse_error::kParseNoError; | |
| 731 } | |
| 732 parse_error::ParseError ValidateScissor( | |
| 733 GLES2Decoder* decoder, uint32 immediate_data_size, GLint x, GLint y, | |
| 734 GLsizei width, GLsizei height) { | |
| 735 return parse_error::kParseNoError; | |
| 736 } | |
| 737 parse_error::ParseError ValidateShaderSource( | |
| 738 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader, | |
| 739 GLsizei count, const char** string, const GLint* length) { | |
| 740 if (string == NULL) { | |
| 741 return parse_error::kParseOutOfBounds; | |
| 742 } | |
| 743 if (length == NULL) { | |
| 744 return parse_error::kParseOutOfBounds; | |
| 745 } | |
| 746 return parse_error::kParseNoError; | |
| 747 } | |
| 748 parse_error::ParseError ValidateShaderSourceImmediate( | |
| 749 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint shader, | |
| 750 GLsizei count, const char** string, const GLint* length) { | |
| 751 if (string == NULL) { | |
| 752 return parse_error::kParseOutOfBounds; | |
| 753 } | |
| 754 if (length == NULL) { | |
| 755 return parse_error::kParseOutOfBounds; | |
| 756 } | |
| 757 return parse_error::kParseNoError; | |
| 758 } | |
| 759 parse_error::ParseError ValidateStencilFunc( | |
| 760 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum func, GLint ref, | |
| 761 GLuint mask) { | |
| 762 return parse_error::kParseNoError; | |
| 763 } | |
| 764 parse_error::ParseError ValidateStencilFuncSeparate( | |
| 765 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum face, GLenum func, | |
| 766 GLint ref, GLuint mask) { | |
| 767 return parse_error::kParseNoError; | |
| 768 } | |
| 769 parse_error::ParseError ValidateStencilMask( | |
| 770 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint mask) { | |
| 771 return parse_error::kParseNoError; | |
| 772 } | |
| 773 parse_error::ParseError ValidateStencilMaskSeparate( | |
| 774 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum face, | |
| 775 GLuint mask) { | |
| 776 return parse_error::kParseNoError; | |
| 777 } | |
| 778 parse_error::ParseError ValidateStencilOp( | |
| 779 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum fail, | |
| 780 GLenum zfail, GLenum zpass) { | |
| 781 return parse_error::kParseNoError; | |
| 782 } | |
| 783 parse_error::ParseError ValidateStencilOpSeparate( | |
| 784 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum face, GLenum fail, | |
| 785 GLenum zfail, GLenum zpass) { | |
| 786 return parse_error::kParseNoError; | |
| 787 } | |
| 788 parse_error::ParseError ValidateTexImage2D( | |
| 789 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 790 GLint level, GLint internalformat, GLsizei width, GLsizei height, | |
| 791 GLint border, GLenum format, GLenum type, const void* pixels) { | |
| 792 if (pixels == NULL) { | |
| 793 return parse_error::kParseOutOfBounds; | |
| 794 } | |
| 795 return parse_error::kParseNoError; | |
| 796 } | |
| 797 parse_error::ParseError ValidateTexImage2DImmediate( | |
| 798 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 799 GLint level, GLint internalformat, GLsizei width, GLsizei height, | |
| 800 GLint border, GLenum format, GLenum type, const void* pixels) { | |
| 801 if (pixels == NULL) { | |
| 802 return parse_error::kParseOutOfBounds; | |
| 803 } | |
| 804 return parse_error::kParseNoError; | |
| 805 } | |
| 806 parse_error::ParseError ValidateTexParameterf( | |
| 807 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 808 GLenum pname, GLfloat param) { | |
| 809 return parse_error::kParseNoError; | |
| 810 } | |
| 811 parse_error::ParseError ValidateTexParameterfv( | |
| 812 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 813 GLenum pname, const GLfloat* params) { | |
| 814 if (params == NULL) { | |
| 815 return parse_error::kParseOutOfBounds; | |
| 816 } | |
| 817 return parse_error::kParseNoError; | |
| 818 } | |
| 819 parse_error::ParseError ValidateTexParameterfvImmediate( | |
| 820 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 821 GLenum pname, const GLfloat* params) { | |
| 822 if (params == NULL) { | |
| 823 return parse_error::kParseOutOfBounds; | |
| 824 } | |
| 825 if (!CheckImmediateDataSize<TexParameterfvImmediate>( | |
| 826 immediate_data_size, 1, sizeof(GLfloat), 1)) { | |
| 827 return parse_error::kParseOutOfBounds; | |
| 828 } | |
| 829 return parse_error::kParseNoError; | |
| 830 } | |
| 831 parse_error::ParseError ValidateTexParameteri( | |
| 832 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 833 GLenum pname, GLint param) { | |
| 834 return parse_error::kParseNoError; | |
| 835 } | |
| 836 parse_error::ParseError ValidateTexParameteriv( | |
| 837 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 838 GLenum pname, const GLint* params) { | |
| 839 if (params == NULL) { | |
| 840 return parse_error::kParseOutOfBounds; | |
| 841 } | |
| 842 return parse_error::kParseNoError; | |
| 843 } | |
| 844 parse_error::ParseError ValidateTexParameterivImmediate( | |
| 845 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 846 GLenum pname, const GLint* params) { | |
| 847 if (params == NULL) { | |
| 848 return parse_error::kParseOutOfBounds; | |
| 849 } | |
| 850 if (!CheckImmediateDataSize<TexParameterivImmediate>( | |
| 851 immediate_data_size, 1, sizeof(GLint), 1)) { | |
| 852 return parse_error::kParseOutOfBounds; | |
| 853 } | |
| 854 return parse_error::kParseNoError; | |
| 855 } | |
| 856 parse_error::ParseError ValidateTexSubImage2D( | |
| 857 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 858 GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, | |
| 859 GLenum format, GLenum type, const void* pixels) { | |
| 860 if (pixels == NULL) { | |
| 861 return parse_error::kParseOutOfBounds; | |
| 862 } | |
| 863 return parse_error::kParseNoError; | |
| 864 } | |
| 865 parse_error::ParseError ValidateTexSubImage2DImmediate( | |
| 866 GLES2Decoder* decoder, uint32 immediate_data_size, GLenum target, | |
| 867 GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, | |
| 868 GLenum format, GLenum type, const void* pixels) { | |
| 869 if (pixels == NULL) { | |
| 870 return parse_error::kParseOutOfBounds; | |
| 871 } | |
| 872 return parse_error::kParseNoError; | |
| 873 } | |
| 874 parse_error::ParseError ValidateUniform1f( | |
| 875 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 876 GLfloat x) { | |
| 877 return parse_error::kParseNoError; | |
| 878 } | |
| 879 parse_error::ParseError ValidateUniform1fv( | |
| 880 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 881 GLsizei count, const GLfloat* v) { | |
| 882 if (v == NULL) { | |
| 883 return parse_error::kParseOutOfBounds; | |
| 884 } | |
| 885 return parse_error::kParseNoError; | |
| 886 } | |
| 887 parse_error::ParseError ValidateUniform1fvImmediate( | |
| 888 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 889 GLsizei count, const GLfloat* v) { | |
| 890 if (v == NULL) { | |
| 891 return parse_error::kParseOutOfBounds; | |
| 892 } | |
| 893 if (!CheckImmediateDataSize<Uniform1fvImmediate>( | |
| 894 immediate_data_size, count, sizeof(GLfloat), 1)) { | |
| 895 return parse_error::kParseOutOfBounds; | |
| 896 } | |
| 897 return parse_error::kParseNoError; | |
| 898 } | |
| 899 parse_error::ParseError ValidateUniform1i( | |
| 900 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 901 GLint x) { | |
| 902 return parse_error::kParseNoError; | |
| 903 } | |
| 904 parse_error::ParseError ValidateUniform1iv( | |
| 905 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 906 GLsizei count, const GLint* v) { | |
| 907 if (v == NULL) { | |
| 908 return parse_error::kParseOutOfBounds; | |
| 909 } | |
| 910 return parse_error::kParseNoError; | |
| 911 } | |
| 912 parse_error::ParseError ValidateUniform1ivImmediate( | |
| 913 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 914 GLsizei count, const GLint* v) { | |
| 915 if (v == NULL) { | |
| 916 return parse_error::kParseOutOfBounds; | |
| 917 } | |
| 918 if (!CheckImmediateDataSize<Uniform1ivImmediate>( | |
| 919 immediate_data_size, count, sizeof(GLint), 1)) { | |
| 920 return parse_error::kParseOutOfBounds; | |
| 921 } | |
| 922 return parse_error::kParseNoError; | |
| 923 } | |
| 924 parse_error::ParseError ValidateUniform2f( | |
| 925 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 926 GLfloat x, GLfloat y) { | |
| 927 return parse_error::kParseNoError; | |
| 928 } | |
| 929 parse_error::ParseError ValidateUniform2fv( | |
| 930 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 931 GLsizei count, const GLfloat* v) { | |
| 932 if (v == NULL) { | |
| 933 return parse_error::kParseOutOfBounds; | |
| 934 } | |
| 935 return parse_error::kParseNoError; | |
| 936 } | |
| 937 parse_error::ParseError ValidateUniform2fvImmediate( | |
| 938 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 939 GLsizei count, const GLfloat* v) { | |
| 940 if (v == NULL) { | |
| 941 return parse_error::kParseOutOfBounds; | |
| 942 } | |
| 943 if (!CheckImmediateDataSize<Uniform2fvImmediate>( | |
| 944 immediate_data_size, count, sizeof(GLfloat), 2)) { | |
| 945 return parse_error::kParseOutOfBounds; | |
| 946 } | |
| 947 return parse_error::kParseNoError; | |
| 948 } | |
| 949 parse_error::ParseError ValidateUniform2i( | |
| 950 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, GLint x, | |
| 951 GLint y) { | |
| 952 return parse_error::kParseNoError; | |
| 953 } | |
| 954 parse_error::ParseError ValidateUniform2iv( | |
| 955 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 956 GLsizei count, const GLint* v) { | |
| 957 if (v == NULL) { | |
| 958 return parse_error::kParseOutOfBounds; | |
| 959 } | |
| 960 return parse_error::kParseNoError; | |
| 961 } | |
| 962 parse_error::ParseError ValidateUniform2ivImmediate( | |
| 963 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 964 GLsizei count, const GLint* v) { | |
| 965 if (v == NULL) { | |
| 966 return parse_error::kParseOutOfBounds; | |
| 967 } | |
| 968 if (!CheckImmediateDataSize<Uniform2ivImmediate>( | |
| 969 immediate_data_size, count, sizeof(GLint), 2)) { | |
| 970 return parse_error::kParseOutOfBounds; | |
| 971 } | |
| 972 return parse_error::kParseNoError; | |
| 973 } | |
| 974 parse_error::ParseError ValidateUniform3f( | |
| 975 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 976 GLfloat x, GLfloat y, GLfloat z) { | |
| 977 return parse_error::kParseNoError; | |
| 978 } | |
| 979 parse_error::ParseError ValidateUniform3fv( | |
| 980 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 981 GLsizei count, const GLfloat* v) { | |
| 982 if (v == NULL) { | |
| 983 return parse_error::kParseOutOfBounds; | |
| 984 } | |
| 985 return parse_error::kParseNoError; | |
| 986 } | |
| 987 parse_error::ParseError ValidateUniform3fvImmediate( | |
| 988 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 989 GLsizei count, const GLfloat* v) { | |
| 990 if (v == NULL) { | |
| 991 return parse_error::kParseOutOfBounds; | |
| 992 } | |
| 993 if (!CheckImmediateDataSize<Uniform3fvImmediate>( | |
| 994 immediate_data_size, count, sizeof(GLfloat), 3)) { | |
| 995 return parse_error::kParseOutOfBounds; | |
| 996 } | |
| 997 return parse_error::kParseNoError; | |
| 998 } | |
| 999 parse_error::ParseError ValidateUniform3i( | |
| 1000 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, GLint x, | |
| 1001 GLint y, GLint z) { | |
| 1002 return parse_error::kParseNoError; | |
| 1003 } | |
| 1004 parse_error::ParseError ValidateUniform3iv( | |
| 1005 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1006 GLsizei count, const GLint* v) { | |
| 1007 if (v == NULL) { | |
| 1008 return parse_error::kParseOutOfBounds; | |
| 1009 } | |
| 1010 return parse_error::kParseNoError; | |
| 1011 } | |
| 1012 parse_error::ParseError ValidateUniform3ivImmediate( | |
| 1013 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1014 GLsizei count, const GLint* v) { | |
| 1015 if (v == NULL) { | |
| 1016 return parse_error::kParseOutOfBounds; | |
| 1017 } | |
| 1018 if (!CheckImmediateDataSize<Uniform3ivImmediate>( | |
| 1019 immediate_data_size, count, sizeof(GLint), 3)) { | |
| 1020 return parse_error::kParseOutOfBounds; | |
| 1021 } | |
| 1022 return parse_error::kParseNoError; | |
| 1023 } | |
| 1024 parse_error::ParseError ValidateUniform4f( | |
| 1025 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1026 GLfloat x, GLfloat y, GLfloat z, GLfloat w) { | |
| 1027 return parse_error::kParseNoError; | |
| 1028 } | |
| 1029 parse_error::ParseError ValidateUniform4fv( | |
| 1030 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1031 GLsizei count, const GLfloat* v) { | |
| 1032 if (v == NULL) { | |
| 1033 return parse_error::kParseOutOfBounds; | |
| 1034 } | |
| 1035 return parse_error::kParseNoError; | |
| 1036 } | |
| 1037 parse_error::ParseError ValidateUniform4fvImmediate( | |
| 1038 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1039 GLsizei count, const GLfloat* v) { | |
| 1040 if (v == NULL) { | |
| 1041 return parse_error::kParseOutOfBounds; | |
| 1042 } | |
| 1043 if (!CheckImmediateDataSize<Uniform4fvImmediate>( | |
| 1044 immediate_data_size, count, sizeof(GLfloat), 4)) { | |
| 1045 return parse_error::kParseOutOfBounds; | |
| 1046 } | |
| 1047 return parse_error::kParseNoError; | |
| 1048 } | |
| 1049 parse_error::ParseError ValidateUniform4i( | |
| 1050 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, GLint x, | |
| 1051 GLint y, GLint z, GLint w) { | |
| 1052 return parse_error::kParseNoError; | |
| 1053 } | |
| 1054 parse_error::ParseError ValidateUniform4iv( | |
| 1055 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1056 GLsizei count, const GLint* v) { | |
| 1057 if (v == NULL) { | |
| 1058 return parse_error::kParseOutOfBounds; | |
| 1059 } | |
| 1060 return parse_error::kParseNoError; | |
| 1061 } | |
| 1062 parse_error::ParseError ValidateUniform4ivImmediate( | |
| 1063 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1064 GLsizei count, const GLint* v) { | |
| 1065 if (v == NULL) { | |
| 1066 return parse_error::kParseOutOfBounds; | |
| 1067 } | |
| 1068 if (!CheckImmediateDataSize<Uniform4ivImmediate>( | |
| 1069 immediate_data_size, count, sizeof(GLint), 4)) { | |
| 1070 return parse_error::kParseOutOfBounds; | |
| 1071 } | |
| 1072 return parse_error::kParseNoError; | |
| 1073 } | |
| 1074 parse_error::ParseError ValidateUniformMatrix2fv( | |
| 1075 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1076 GLsizei count, GLboolean transpose, const GLfloat* value) { | |
| 1077 if (value == NULL) { | |
| 1078 return parse_error::kParseOutOfBounds; | |
| 1079 } | |
| 1080 return parse_error::kParseNoError; | |
| 1081 } | |
| 1082 parse_error::ParseError ValidateUniformMatrix2fvImmediate( | |
| 1083 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1084 GLsizei count, GLboolean transpose, const GLfloat* value) { | |
| 1085 if (value == NULL) { | |
| 1086 return parse_error::kParseOutOfBounds; | |
| 1087 } | |
| 1088 if (!CheckImmediateDataSize<UniformMatrix2fvImmediate>( | |
| 1089 immediate_data_size, count, sizeof(GLfloat), 4)) { | |
| 1090 return parse_error::kParseOutOfBounds; | |
| 1091 } | |
| 1092 return parse_error::kParseNoError; | |
| 1093 } | |
| 1094 parse_error::ParseError ValidateUniformMatrix3fv( | |
| 1095 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1096 GLsizei count, GLboolean transpose, const GLfloat* value) { | |
| 1097 if (value == NULL) { | |
| 1098 return parse_error::kParseOutOfBounds; | |
| 1099 } | |
| 1100 return parse_error::kParseNoError; | |
| 1101 } | |
| 1102 parse_error::ParseError ValidateUniformMatrix3fvImmediate( | |
| 1103 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1104 GLsizei count, GLboolean transpose, const GLfloat* value) { | |
| 1105 if (value == NULL) { | |
| 1106 return parse_error::kParseOutOfBounds; | |
| 1107 } | |
| 1108 if (!CheckImmediateDataSize<UniformMatrix3fvImmediate>( | |
| 1109 immediate_data_size, count, sizeof(GLfloat), 9)) { | |
| 1110 return parse_error::kParseOutOfBounds; | |
| 1111 } | |
| 1112 return parse_error::kParseNoError; | |
| 1113 } | |
| 1114 parse_error::ParseError ValidateUniformMatrix4fv( | |
| 1115 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1116 GLsizei count, GLboolean transpose, const GLfloat* value) { | |
| 1117 if (value == NULL) { | |
| 1118 return parse_error::kParseOutOfBounds; | |
| 1119 } | |
| 1120 return parse_error::kParseNoError; | |
| 1121 } | |
| 1122 parse_error::ParseError ValidateUniformMatrix4fvImmediate( | |
| 1123 GLES2Decoder* decoder, uint32 immediate_data_size, GLint location, | |
| 1124 GLsizei count, GLboolean transpose, const GLfloat* value) { | |
| 1125 if (value == NULL) { | |
| 1126 return parse_error::kParseOutOfBounds; | |
| 1127 } | |
| 1128 if (!CheckImmediateDataSize<UniformMatrix4fvImmediate>( | |
| 1129 immediate_data_size, count, sizeof(GLfloat), 16)) { | |
| 1130 return parse_error::kParseOutOfBounds; | |
| 1131 } | |
| 1132 return parse_error::kParseNoError; | |
| 1133 } | |
| 1134 parse_error::ParseError ValidateUseProgram( | |
| 1135 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program) { | |
| 1136 return parse_error::kParseNoError; | |
| 1137 } | |
| 1138 parse_error::ParseError ValidateValidateProgram( | |
| 1139 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint program) { | |
| 1140 return parse_error::kParseNoError; | |
| 1141 } | |
| 1142 parse_error::ParseError ValidateVertexAttrib1f( | |
| 1143 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1144 GLfloat x) { | |
| 1145 return parse_error::kParseNoError; | |
| 1146 } | |
| 1147 parse_error::ParseError ValidateVertexAttrib1fv( | |
| 1148 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1149 const GLfloat* values) { | |
| 1150 if (values == NULL) { | |
| 1151 return parse_error::kParseOutOfBounds; | |
| 1152 } | |
| 1153 return parse_error::kParseNoError; | |
| 1154 } | |
| 1155 parse_error::ParseError ValidateVertexAttrib1fvImmediate( | |
| 1156 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1157 const GLfloat* values) { | |
| 1158 if (values == NULL) { | |
| 1159 return parse_error::kParseOutOfBounds; | |
| 1160 } | |
| 1161 if (!CheckImmediateDataSize<VertexAttrib1fvImmediate>( | |
| 1162 immediate_data_size, 1, sizeof(GLfloat), 1)) { | |
| 1163 return parse_error::kParseOutOfBounds; | |
| 1164 } | |
| 1165 return parse_error::kParseNoError; | |
| 1166 } | |
| 1167 parse_error::ParseError ValidateVertexAttrib2f( | |
| 1168 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, GLfloat x, | |
| 1169 GLfloat y) { | |
| 1170 return parse_error::kParseNoError; | |
| 1171 } | |
| 1172 parse_error::ParseError ValidateVertexAttrib2fv( | |
| 1173 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1174 const GLfloat* values) { | |
| 1175 if (values == NULL) { | |
| 1176 return parse_error::kParseOutOfBounds; | |
| 1177 } | |
| 1178 return parse_error::kParseNoError; | |
| 1179 } | |
| 1180 parse_error::ParseError ValidateVertexAttrib2fvImmediate( | |
| 1181 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1182 const GLfloat* values) { | |
| 1183 if (values == NULL) { | |
| 1184 return parse_error::kParseOutOfBounds; | |
| 1185 } | |
| 1186 if (!CheckImmediateDataSize<VertexAttrib2fvImmediate>( | |
| 1187 immediate_data_size, 1, sizeof(GLfloat), 2)) { | |
| 1188 return parse_error::kParseOutOfBounds; | |
| 1189 } | |
| 1190 return parse_error::kParseNoError; | |
| 1191 } | |
| 1192 parse_error::ParseError ValidateVertexAttrib3f( | |
| 1193 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, GLfloat x, | |
| 1194 GLfloat y, GLfloat z) { | |
| 1195 return parse_error::kParseNoError; | |
| 1196 } | |
| 1197 parse_error::ParseError ValidateVertexAttrib3fv( | |
| 1198 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1199 const GLfloat* values) { | |
| 1200 if (values == NULL) { | |
| 1201 return parse_error::kParseOutOfBounds; | |
| 1202 } | |
| 1203 return parse_error::kParseNoError; | |
| 1204 } | |
| 1205 parse_error::ParseError ValidateVertexAttrib3fvImmediate( | |
| 1206 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1207 const GLfloat* values) { | |
| 1208 if (values == NULL) { | |
| 1209 return parse_error::kParseOutOfBounds; | |
| 1210 } | |
| 1211 if (!CheckImmediateDataSize<VertexAttrib3fvImmediate>( | |
| 1212 immediate_data_size, 1, sizeof(GLfloat), 3)) { | |
| 1213 return parse_error::kParseOutOfBounds; | |
| 1214 } | |
| 1215 return parse_error::kParseNoError; | |
| 1216 } | |
| 1217 parse_error::ParseError ValidateVertexAttrib4f( | |
| 1218 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, GLfloat x, | |
| 1219 GLfloat y, GLfloat z, GLfloat w) { | |
| 1220 return parse_error::kParseNoError; | |
| 1221 } | |
| 1222 parse_error::ParseError ValidateVertexAttrib4fv( | |
| 1223 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1224 const GLfloat* values) { | |
| 1225 if (values == NULL) { | |
| 1226 return parse_error::kParseOutOfBounds; | |
| 1227 } | |
| 1228 return parse_error::kParseNoError; | |
| 1229 } | |
| 1230 parse_error::ParseError ValidateVertexAttrib4fvImmediate( | |
| 1231 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, | |
| 1232 const GLfloat* values) { | |
| 1233 if (values == NULL) { | |
| 1234 return parse_error::kParseOutOfBounds; | |
| 1235 } | |
| 1236 if (!CheckImmediateDataSize<VertexAttrib4fvImmediate>( | |
| 1237 immediate_data_size, 1, sizeof(GLfloat), 4)) { | |
| 1238 return parse_error::kParseOutOfBounds; | |
| 1239 } | |
| 1240 return parse_error::kParseNoError; | |
| 1241 } | |
| 1242 parse_error::ParseError ValidateVertexAttribPointer( | |
| 1243 GLES2Decoder* decoder, uint32 immediate_data_size, GLuint indx, GLint size, | |
| 1244 GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) { | |
| 1245 if (ptr == NULL) { | |
| 1246 return parse_error::kParseOutOfBounds; | |
| 1247 } | |
| 1248 return parse_error::kParseNoError; | |
| 1249 } | |
| 1250 parse_error::ParseError ValidateViewport( | |
| 1251 GLES2Decoder* decoder, uint32 immediate_data_size, GLint x, GLint y, | |
| 1252 GLsizei width, GLsizei height) { | |
| 1253 return parse_error::kParseNoError; | |
| 1254 } | |
| 1255 parse_error::ParseError ValidateSwapBuffers( | |
| 1256 GLES2Decoder* decoder, uint32 immediate_data_size) { | |
| 1257 return parse_error::kParseNoError; | |
| 1258 } | |
| 1259 } // anonymous namespace | |
| 1260 } // namespace gles2 | |
| 1261 } // namespace gpu | |
| 1262 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 505016:
Implements Validation for all GLenum arguments and ... (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/