1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/gfx/angle/src/libGLESv2/libGLESv2.cpp Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,7108 @@
1.4 +#include "precompiled.h"
1.5 +//
1.6 +// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
1.7 +// Use of this source code is governed by a BSD-style license that can be
1.8 +// found in the LICENSE file.
1.9 +//
1.10 +
1.11 +// libGLESv2.cpp: Implements the exported OpenGL ES 2.0 functions.
1.12 +
1.13 +#include "common/version.h"
1.14 +
1.15 +#include <algorithm>
1.16 +
1.17 +#include "libGLESv2/main.h"
1.18 +#include "libGLESv2/utilities.h"
1.19 +#include "libGLESv2/Buffer.h"
1.20 +#include "libGLESv2/Fence.h"
1.21 +#include "libGLESv2/Framebuffer.h"
1.22 +#include "libGLESv2/Renderbuffer.h"
1.23 +#include "libGLESv2/Program.h"
1.24 +#include "libGLESv2/ProgramBinary.h"
1.25 +#include "libGLESv2/Texture.h"
1.26 +#include "libGLESv2/Query.h"
1.27 +#include "libGLESv2/Context.h"
1.28 +
1.29 +bool validImageSize(GLint level, GLsizei width, GLsizei height)
1.30 +{
1.31 + if (level < 0 || width < 0 || height < 0)
1.32 + {
1.33 + return false;
1.34 + }
1.35 +
1.36 + if (gl::getContext() && gl::getContext()->supportsNonPower2Texture())
1.37 + {
1.38 + return true;
1.39 + }
1.40 +
1.41 + if (level == 0)
1.42 + {
1.43 + return true;
1.44 + }
1.45 +
1.46 + if (gl::isPow2(width) && gl::isPow2(height))
1.47 + {
1.48 + return true;
1.49 + }
1.50 +
1.51 + return false;
1.52 +}
1.53 +
1.54 +// Verify that format/type are one of the combinations from table 3.4.
1.55 +bool checkTextureFormatType(GLenum format, GLenum type)
1.56 +{
1.57 + // validate <format> by itself (used as secondary key below)
1.58 + switch (format)
1.59 + {
1.60 + case GL_RGBA:
1.61 + case GL_BGRA_EXT:
1.62 + case GL_RGB:
1.63 + case GL_ALPHA:
1.64 + case GL_LUMINANCE:
1.65 + case GL_LUMINANCE_ALPHA:
1.66 + case GL_DEPTH_COMPONENT:
1.67 + case GL_DEPTH_STENCIL_OES:
1.68 + break;
1.69 + default:
1.70 + return gl::error(GL_INVALID_ENUM, false);
1.71 + }
1.72 +
1.73 + // invalid <type> -> sets INVALID_ENUM
1.74 + // invalid <format>+<type> combination -> sets INVALID_OPERATION
1.75 + switch (type)
1.76 + {
1.77 + case GL_UNSIGNED_BYTE:
1.78 + switch (format)
1.79 + {
1.80 + case GL_RGBA:
1.81 + case GL_BGRA_EXT:
1.82 + case GL_RGB:
1.83 + case GL_ALPHA:
1.84 + case GL_LUMINANCE:
1.85 + case GL_LUMINANCE_ALPHA:
1.86 + return true;
1.87 + default:
1.88 + return gl::error(GL_INVALID_OPERATION, false);
1.89 + }
1.90 +
1.91 + case GL_FLOAT:
1.92 + case GL_HALF_FLOAT_OES:
1.93 + switch (format)
1.94 + {
1.95 + case GL_RGBA:
1.96 + case GL_RGB:
1.97 + case GL_ALPHA:
1.98 + case GL_LUMINANCE:
1.99 + case GL_LUMINANCE_ALPHA:
1.100 + return true;
1.101 + default:
1.102 + return gl::error(GL_INVALID_OPERATION, false);
1.103 + }
1.104 +
1.105 + case GL_UNSIGNED_SHORT_4_4_4_4:
1.106 + case GL_UNSIGNED_SHORT_5_5_5_1:
1.107 + switch (format)
1.108 + {
1.109 + case GL_RGBA:
1.110 + return true;
1.111 + default:
1.112 + return gl::error(GL_INVALID_OPERATION, false);
1.113 + }
1.114 +
1.115 + case GL_UNSIGNED_SHORT_5_6_5:
1.116 + switch (format)
1.117 + {
1.118 + case GL_RGB:
1.119 + return true;
1.120 + default:
1.121 + return gl::error(GL_INVALID_OPERATION, false);
1.122 + }
1.123 +
1.124 + case GL_UNSIGNED_SHORT:
1.125 + case GL_UNSIGNED_INT:
1.126 + switch (format)
1.127 + {
1.128 + case GL_DEPTH_COMPONENT:
1.129 + return true;
1.130 + default:
1.131 + return gl::error(GL_INVALID_OPERATION, false);
1.132 + }
1.133 +
1.134 + case GL_UNSIGNED_INT_24_8_OES:
1.135 + switch (format)
1.136 + {
1.137 + case GL_DEPTH_STENCIL_OES:
1.138 + return true;
1.139 + default:
1.140 + return gl::error(GL_INVALID_OPERATION, false);
1.141 + }
1.142 +
1.143 + default:
1.144 + return gl::error(GL_INVALID_ENUM, false);
1.145 + }
1.146 +}
1.147 +
1.148 +bool validateSubImageParams2D(bool compressed, GLsizei width, GLsizei height,
1.149 + GLint xoffset, GLint yoffset, GLint level, GLenum format, GLenum type,
1.150 + gl::Texture2D *texture)
1.151 +{
1.152 + if (!texture)
1.153 + {
1.154 + return gl::error(GL_INVALID_OPERATION, false);
1.155 + }
1.156 +
1.157 + if (compressed != texture->isCompressed(level))
1.158 + {
1.159 + return gl::error(GL_INVALID_OPERATION, false);
1.160 + }
1.161 +
1.162 + if (format != GL_NONE)
1.163 + {
1.164 + GLenum internalformat = gl::ConvertSizedInternalFormat(format, type);
1.165 + if (internalformat != texture->getInternalFormat(level))
1.166 + {
1.167 + return gl::error(GL_INVALID_OPERATION, false);
1.168 + }
1.169 + }
1.170 +
1.171 + if (compressed)
1.172 + {
1.173 + if ((width % 4 != 0 && width != texture->getWidth(0)) ||
1.174 + (height % 4 != 0 && height != texture->getHeight(0)))
1.175 + {
1.176 + return gl::error(GL_INVALID_OPERATION, false);
1.177 + }
1.178 + }
1.179 +
1.180 + if (xoffset + width > texture->getWidth(level) ||
1.181 + yoffset + height > texture->getHeight(level))
1.182 + {
1.183 + return gl::error(GL_INVALID_VALUE, false);
1.184 + }
1.185 +
1.186 + return true;
1.187 +}
1.188 +
1.189 +bool validateSubImageParamsCube(bool compressed, GLsizei width, GLsizei height,
1.190 + GLint xoffset, GLint yoffset, GLenum target, GLint level, GLenum format, GLenum type,
1.191 + gl::TextureCubeMap *texture)
1.192 +{
1.193 + if (!texture)
1.194 + {
1.195 + return gl::error(GL_INVALID_OPERATION, false);
1.196 + }
1.197 +
1.198 + if (compressed != texture->isCompressed(target, level))
1.199 + {
1.200 + return gl::error(GL_INVALID_OPERATION, false);
1.201 + }
1.202 +
1.203 + if (format != GL_NONE)
1.204 + {
1.205 + GLenum internalformat = gl::ConvertSizedInternalFormat(format, type);
1.206 + if (internalformat != texture->getInternalFormat(target, level))
1.207 + {
1.208 + return gl::error(GL_INVALID_OPERATION, false);
1.209 + }
1.210 + }
1.211 +
1.212 + if (compressed)
1.213 + {
1.214 + if ((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
1.215 + (height % 4 != 0 && height != texture->getHeight(target, 0)))
1.216 + {
1.217 + return gl::error(GL_INVALID_OPERATION, false);
1.218 + }
1.219 + }
1.220 +
1.221 + if (xoffset + width > texture->getWidth(target, level) ||
1.222 + yoffset + height > texture->getHeight(target, level))
1.223 + {
1.224 + return gl::error(GL_INVALID_VALUE, false);
1.225 + }
1.226 +
1.227 + return true;
1.228 +}
1.229 +
1.230 +// check for combinations of format and type that are valid for ReadPixels
1.231 +bool validReadFormatType(GLenum format, GLenum type)
1.232 +{
1.233 + switch (format)
1.234 + {
1.235 + case GL_RGBA:
1.236 + switch (type)
1.237 + {
1.238 + case GL_UNSIGNED_BYTE:
1.239 + break;
1.240 + default:
1.241 + return false;
1.242 + }
1.243 + break;
1.244 + case GL_BGRA_EXT:
1.245 + switch (type)
1.246 + {
1.247 + case GL_UNSIGNED_BYTE:
1.248 + case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
1.249 + case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
1.250 + break;
1.251 + default:
1.252 + return false;
1.253 + }
1.254 + break;
1.255 + default:
1.256 + return false;
1.257 + }
1.258 + return true;
1.259 +}
1.260 +
1.261 +extern "C"
1.262 +{
1.263 +
1.264 +void __stdcall glActiveTexture(GLenum texture)
1.265 +{
1.266 + EVENT("(GLenum texture = 0x%X)", texture);
1.267 +
1.268 + try
1.269 + {
1.270 + gl::Context *context = gl::getNonLostContext();
1.271 +
1.272 + if (context)
1.273 + {
1.274 + if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + context->getMaximumCombinedTextureImageUnits() - 1)
1.275 + {
1.276 + return gl::error(GL_INVALID_ENUM);
1.277 + }
1.278 +
1.279 + context->setActiveSampler(texture - GL_TEXTURE0);
1.280 + }
1.281 + }
1.282 + catch(std::bad_alloc&)
1.283 + {
1.284 + return gl::error(GL_OUT_OF_MEMORY);
1.285 + }
1.286 +}
1.287 +
1.288 +void __stdcall glAttachShader(GLuint program, GLuint shader)
1.289 +{
1.290 + EVENT("(GLuint program = %d, GLuint shader = %d)", program, shader);
1.291 +
1.292 + try
1.293 + {
1.294 + gl::Context *context = gl::getNonLostContext();
1.295 +
1.296 + if (context)
1.297 + {
1.298 + gl::Program *programObject = context->getProgram(program);
1.299 + gl::Shader *shaderObject = context->getShader(shader);
1.300 +
1.301 + if (!programObject)
1.302 + {
1.303 + if (context->getShader(program))
1.304 + {
1.305 + return gl::error(GL_INVALID_OPERATION);
1.306 + }
1.307 + else
1.308 + {
1.309 + return gl::error(GL_INVALID_VALUE);
1.310 + }
1.311 + }
1.312 +
1.313 + if (!shaderObject)
1.314 + {
1.315 + if (context->getProgram(shader))
1.316 + {
1.317 + return gl::error(GL_INVALID_OPERATION);
1.318 + }
1.319 + else
1.320 + {
1.321 + return gl::error(GL_INVALID_VALUE);
1.322 + }
1.323 + }
1.324 +
1.325 + if (!programObject->attachShader(shaderObject))
1.326 + {
1.327 + return gl::error(GL_INVALID_OPERATION);
1.328 + }
1.329 + }
1.330 + }
1.331 + catch(std::bad_alloc&)
1.332 + {
1.333 + return gl::error(GL_OUT_OF_MEMORY);
1.334 + }
1.335 +}
1.336 +
1.337 +void __stdcall glBeginQueryEXT(GLenum target, GLuint id)
1.338 +{
1.339 + EVENT("(GLenum target = 0x%X, GLuint %d)", target, id);
1.340 +
1.341 + try
1.342 + {
1.343 + switch (target)
1.344 + {
1.345 + case GL_ANY_SAMPLES_PASSED_EXT:
1.346 + case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
1.347 + break;
1.348 + default:
1.349 + return gl::error(GL_INVALID_ENUM);
1.350 + }
1.351 +
1.352 + if (id == 0)
1.353 + {
1.354 + return gl::error(GL_INVALID_OPERATION);
1.355 + }
1.356 +
1.357 + gl::Context *context = gl::getNonLostContext();
1.358 +
1.359 + if (context)
1.360 + {
1.361 + context->beginQuery(target, id);
1.362 + }
1.363 + }
1.364 + catch(std::bad_alloc&)
1.365 + {
1.366 + return gl::error(GL_OUT_OF_MEMORY);
1.367 + }
1.368 +}
1.369 +
1.370 +void __stdcall glBindAttribLocation(GLuint program, GLuint index, const GLchar* name)
1.371 +{
1.372 + EVENT("(GLuint program = %d, GLuint index = %d, const GLchar* name = 0x%0.8p)", program, index, name);
1.373 +
1.374 + try
1.375 + {
1.376 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.377 + {
1.378 + return gl::error(GL_INVALID_VALUE);
1.379 + }
1.380 +
1.381 + gl::Context *context = gl::getNonLostContext();
1.382 +
1.383 + if (context)
1.384 + {
1.385 + gl::Program *programObject = context->getProgram(program);
1.386 +
1.387 + if (!programObject)
1.388 + {
1.389 + if (context->getShader(program))
1.390 + {
1.391 + return gl::error(GL_INVALID_OPERATION);
1.392 + }
1.393 + else
1.394 + {
1.395 + return gl::error(GL_INVALID_VALUE);
1.396 + }
1.397 + }
1.398 +
1.399 + if (strncmp(name, "gl_", 3) == 0)
1.400 + {
1.401 + return gl::error(GL_INVALID_OPERATION);
1.402 + }
1.403 +
1.404 + programObject->bindAttributeLocation(index, name);
1.405 + }
1.406 + }
1.407 + catch(std::bad_alloc&)
1.408 + {
1.409 + return gl::error(GL_OUT_OF_MEMORY);
1.410 + }
1.411 +}
1.412 +
1.413 +void __stdcall glBindBuffer(GLenum target, GLuint buffer)
1.414 +{
1.415 + EVENT("(GLenum target = 0x%X, GLuint buffer = %d)", target, buffer);
1.416 +
1.417 + try
1.418 + {
1.419 + gl::Context *context = gl::getNonLostContext();
1.420 +
1.421 + if (context)
1.422 + {
1.423 + switch (target)
1.424 + {
1.425 + case GL_ARRAY_BUFFER:
1.426 + context->bindArrayBuffer(buffer);
1.427 + return;
1.428 + case GL_ELEMENT_ARRAY_BUFFER:
1.429 + context->bindElementArrayBuffer(buffer);
1.430 + return;
1.431 + default:
1.432 + return gl::error(GL_INVALID_ENUM);
1.433 + }
1.434 + }
1.435 + }
1.436 + catch(std::bad_alloc&)
1.437 + {
1.438 + return gl::error(GL_OUT_OF_MEMORY);
1.439 + }
1.440 +}
1.441 +
1.442 +void __stdcall glBindFramebuffer(GLenum target, GLuint framebuffer)
1.443 +{
1.444 + EVENT("(GLenum target = 0x%X, GLuint framebuffer = %d)", target, framebuffer);
1.445 +
1.446 + try
1.447 + {
1.448 + if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
1.449 + {
1.450 + return gl::error(GL_INVALID_ENUM);
1.451 + }
1.452 +
1.453 + gl::Context *context = gl::getNonLostContext();
1.454 +
1.455 + if (context)
1.456 + {
1.457 + if (target == GL_READ_FRAMEBUFFER_ANGLE || target == GL_FRAMEBUFFER)
1.458 + {
1.459 + context->bindReadFramebuffer(framebuffer);
1.460 + }
1.461 +
1.462 + if (target == GL_DRAW_FRAMEBUFFER_ANGLE || target == GL_FRAMEBUFFER)
1.463 + {
1.464 + context->bindDrawFramebuffer(framebuffer);
1.465 + }
1.466 + }
1.467 + }
1.468 + catch(std::bad_alloc&)
1.469 + {
1.470 + return gl::error(GL_OUT_OF_MEMORY);
1.471 + }
1.472 +}
1.473 +
1.474 +void __stdcall glBindRenderbuffer(GLenum target, GLuint renderbuffer)
1.475 +{
1.476 + EVENT("(GLenum target = 0x%X, GLuint renderbuffer = %d)", target, renderbuffer);
1.477 +
1.478 + try
1.479 + {
1.480 + if (target != GL_RENDERBUFFER)
1.481 + {
1.482 + return gl::error(GL_INVALID_ENUM);
1.483 + }
1.484 +
1.485 + gl::Context *context = gl::getNonLostContext();
1.486 +
1.487 + if (context)
1.488 + {
1.489 + context->bindRenderbuffer(renderbuffer);
1.490 + }
1.491 + }
1.492 + catch(std::bad_alloc&)
1.493 + {
1.494 + return gl::error(GL_OUT_OF_MEMORY);
1.495 + }
1.496 +}
1.497 +
1.498 +void __stdcall glBindTexture(GLenum target, GLuint texture)
1.499 +{
1.500 + EVENT("(GLenum target = 0x%X, GLuint texture = %d)", target, texture);
1.501 +
1.502 + try
1.503 + {
1.504 + gl::Context *context = gl::getNonLostContext();
1.505 +
1.506 + if (context)
1.507 + {
1.508 + gl::Texture *textureObject = context->getTexture(texture);
1.509 +
1.510 + if (textureObject && textureObject->getTarget() != target && texture != 0)
1.511 + {
1.512 + return gl::error(GL_INVALID_OPERATION);
1.513 + }
1.514 +
1.515 + switch (target)
1.516 + {
1.517 + case GL_TEXTURE_2D:
1.518 + context->bindTexture2D(texture);
1.519 + return;
1.520 + case GL_TEXTURE_CUBE_MAP:
1.521 + context->bindTextureCubeMap(texture);
1.522 + return;
1.523 + default:
1.524 + return gl::error(GL_INVALID_ENUM);
1.525 + }
1.526 + }
1.527 + }
1.528 + catch(std::bad_alloc&)
1.529 + {
1.530 + return gl::error(GL_OUT_OF_MEMORY);
1.531 + }
1.532 +}
1.533 +
1.534 +void __stdcall glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1.535 +{
1.536 + EVENT("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
1.537 + red, green, blue, alpha);
1.538 +
1.539 + try
1.540 + {
1.541 + gl::Context* context = gl::getNonLostContext();
1.542 +
1.543 + if (context)
1.544 + {
1.545 + context->setBlendColor(gl::clamp01(red), gl::clamp01(green), gl::clamp01(blue), gl::clamp01(alpha));
1.546 + }
1.547 + }
1.548 + catch(std::bad_alloc&)
1.549 + {
1.550 + return gl::error(GL_OUT_OF_MEMORY);
1.551 + }
1.552 +}
1.553 +
1.554 +void __stdcall glBlendEquation(GLenum mode)
1.555 +{
1.556 + glBlendEquationSeparate(mode, mode);
1.557 +}
1.558 +
1.559 +void __stdcall glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
1.560 +{
1.561 + EVENT("(GLenum modeRGB = 0x%X, GLenum modeAlpha = 0x%X)", modeRGB, modeAlpha);
1.562 +
1.563 + try
1.564 + {
1.565 + switch (modeRGB)
1.566 + {
1.567 + case GL_FUNC_ADD:
1.568 + case GL_FUNC_SUBTRACT:
1.569 + case GL_FUNC_REVERSE_SUBTRACT:
1.570 + break;
1.571 + default:
1.572 + return gl::error(GL_INVALID_ENUM);
1.573 + }
1.574 +
1.575 + switch (modeAlpha)
1.576 + {
1.577 + case GL_FUNC_ADD:
1.578 + case GL_FUNC_SUBTRACT:
1.579 + case GL_FUNC_REVERSE_SUBTRACT:
1.580 + break;
1.581 + default:
1.582 + return gl::error(GL_INVALID_ENUM);
1.583 + }
1.584 +
1.585 + gl::Context *context = gl::getNonLostContext();
1.586 +
1.587 + if (context)
1.588 + {
1.589 + context->setBlendEquation(modeRGB, modeAlpha);
1.590 + }
1.591 + }
1.592 + catch(std::bad_alloc&)
1.593 + {
1.594 + return gl::error(GL_OUT_OF_MEMORY);
1.595 + }
1.596 +}
1.597 +
1.598 +void __stdcall glBlendFunc(GLenum sfactor, GLenum dfactor)
1.599 +{
1.600 + glBlendFuncSeparate(sfactor, dfactor, sfactor, dfactor);
1.601 +}
1.602 +
1.603 +void __stdcall glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
1.604 +{
1.605 + EVENT("(GLenum srcRGB = 0x%X, GLenum dstRGB = 0x%X, GLenum srcAlpha = 0x%X, GLenum dstAlpha = 0x%X)",
1.606 + srcRGB, dstRGB, srcAlpha, dstAlpha);
1.607 +
1.608 + try
1.609 + {
1.610 + switch (srcRGB)
1.611 + {
1.612 + case GL_ZERO:
1.613 + case GL_ONE:
1.614 + case GL_SRC_COLOR:
1.615 + case GL_ONE_MINUS_SRC_COLOR:
1.616 + case GL_DST_COLOR:
1.617 + case GL_ONE_MINUS_DST_COLOR:
1.618 + case GL_SRC_ALPHA:
1.619 + case GL_ONE_MINUS_SRC_ALPHA:
1.620 + case GL_DST_ALPHA:
1.621 + case GL_ONE_MINUS_DST_ALPHA:
1.622 + case GL_CONSTANT_COLOR:
1.623 + case GL_ONE_MINUS_CONSTANT_COLOR:
1.624 + case GL_CONSTANT_ALPHA:
1.625 + case GL_ONE_MINUS_CONSTANT_ALPHA:
1.626 + case GL_SRC_ALPHA_SATURATE:
1.627 + break;
1.628 + default:
1.629 + return gl::error(GL_INVALID_ENUM);
1.630 + }
1.631 +
1.632 + switch (dstRGB)
1.633 + {
1.634 + case GL_ZERO:
1.635 + case GL_ONE:
1.636 + case GL_SRC_COLOR:
1.637 + case GL_ONE_MINUS_SRC_COLOR:
1.638 + case GL_DST_COLOR:
1.639 + case GL_ONE_MINUS_DST_COLOR:
1.640 + case GL_SRC_ALPHA:
1.641 + case GL_ONE_MINUS_SRC_ALPHA:
1.642 + case GL_DST_ALPHA:
1.643 + case GL_ONE_MINUS_DST_ALPHA:
1.644 + case GL_CONSTANT_COLOR:
1.645 + case GL_ONE_MINUS_CONSTANT_COLOR:
1.646 + case GL_CONSTANT_ALPHA:
1.647 + case GL_ONE_MINUS_CONSTANT_ALPHA:
1.648 + break;
1.649 + default:
1.650 + return gl::error(GL_INVALID_ENUM);
1.651 + }
1.652 +
1.653 + switch (srcAlpha)
1.654 + {
1.655 + case GL_ZERO:
1.656 + case GL_ONE:
1.657 + case GL_SRC_COLOR:
1.658 + case GL_ONE_MINUS_SRC_COLOR:
1.659 + case GL_DST_COLOR:
1.660 + case GL_ONE_MINUS_DST_COLOR:
1.661 + case GL_SRC_ALPHA:
1.662 + case GL_ONE_MINUS_SRC_ALPHA:
1.663 + case GL_DST_ALPHA:
1.664 + case GL_ONE_MINUS_DST_ALPHA:
1.665 + case GL_CONSTANT_COLOR:
1.666 + case GL_ONE_MINUS_CONSTANT_COLOR:
1.667 + case GL_CONSTANT_ALPHA:
1.668 + case GL_ONE_MINUS_CONSTANT_ALPHA:
1.669 + case GL_SRC_ALPHA_SATURATE:
1.670 + break;
1.671 + default:
1.672 + return gl::error(GL_INVALID_ENUM);
1.673 + }
1.674 +
1.675 + switch (dstAlpha)
1.676 + {
1.677 + case GL_ZERO:
1.678 + case GL_ONE:
1.679 + case GL_SRC_COLOR:
1.680 + case GL_ONE_MINUS_SRC_COLOR:
1.681 + case GL_DST_COLOR:
1.682 + case GL_ONE_MINUS_DST_COLOR:
1.683 + case GL_SRC_ALPHA:
1.684 + case GL_ONE_MINUS_SRC_ALPHA:
1.685 + case GL_DST_ALPHA:
1.686 + case GL_ONE_MINUS_DST_ALPHA:
1.687 + case GL_CONSTANT_COLOR:
1.688 + case GL_ONE_MINUS_CONSTANT_COLOR:
1.689 + case GL_CONSTANT_ALPHA:
1.690 + case GL_ONE_MINUS_CONSTANT_ALPHA:
1.691 + break;
1.692 + default:
1.693 + return gl::error(GL_INVALID_ENUM);
1.694 + }
1.695 +
1.696 + bool constantColorUsed = (srcRGB == GL_CONSTANT_COLOR || srcRGB == GL_ONE_MINUS_CONSTANT_COLOR ||
1.697 + dstRGB == GL_CONSTANT_COLOR || dstRGB == GL_ONE_MINUS_CONSTANT_COLOR);
1.698 +
1.699 + bool constantAlphaUsed = (srcRGB == GL_CONSTANT_ALPHA || srcRGB == GL_ONE_MINUS_CONSTANT_ALPHA ||
1.700 + dstRGB == GL_CONSTANT_ALPHA || dstRGB == GL_ONE_MINUS_CONSTANT_ALPHA);
1.701 +
1.702 + if (constantColorUsed && constantAlphaUsed)
1.703 + {
1.704 + ERR("Simultaneous use of GL_CONSTANT_ALPHA/GL_ONE_MINUS_CONSTANT_ALPHA and GL_CONSTANT_COLOR/GL_ONE_MINUS_CONSTANT_COLOR invalid under WebGL");
1.705 + return gl::error(GL_INVALID_OPERATION);
1.706 + }
1.707 +
1.708 + gl::Context *context = gl::getNonLostContext();
1.709 +
1.710 + if (context)
1.711 + {
1.712 + context->setBlendFactors(srcRGB, dstRGB, srcAlpha, dstAlpha);
1.713 + }
1.714 + }
1.715 + catch(std::bad_alloc&)
1.716 + {
1.717 + return gl::error(GL_OUT_OF_MEMORY);
1.718 + }
1.719 +}
1.720 +
1.721 +void __stdcall glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
1.722 +{
1.723 + EVENT("(GLenum target = 0x%X, GLsizeiptr size = %d, const GLvoid* data = 0x%0.8p, GLenum usage = %d)",
1.724 + target, size, data, usage);
1.725 +
1.726 + try
1.727 + {
1.728 + if (size < 0)
1.729 + {
1.730 + return gl::error(GL_INVALID_VALUE);
1.731 + }
1.732 +
1.733 + switch (usage)
1.734 + {
1.735 + case GL_STREAM_DRAW:
1.736 + case GL_STATIC_DRAW:
1.737 + case GL_DYNAMIC_DRAW:
1.738 + break;
1.739 + default:
1.740 + return gl::error(GL_INVALID_ENUM);
1.741 + }
1.742 +
1.743 + gl::Context *context = gl::getNonLostContext();
1.744 +
1.745 + if (context)
1.746 + {
1.747 + gl::Buffer *buffer;
1.748 +
1.749 + switch (target)
1.750 + {
1.751 + case GL_ARRAY_BUFFER:
1.752 + buffer = context->getArrayBuffer();
1.753 + break;
1.754 + case GL_ELEMENT_ARRAY_BUFFER:
1.755 + buffer = context->getElementArrayBuffer();
1.756 + break;
1.757 + default:
1.758 + return gl::error(GL_INVALID_ENUM);
1.759 + }
1.760 +
1.761 + if (!buffer)
1.762 + {
1.763 + return gl::error(GL_INVALID_OPERATION);
1.764 + }
1.765 +
1.766 + buffer->bufferData(data, size, usage);
1.767 + }
1.768 + }
1.769 + catch(std::bad_alloc&)
1.770 + {
1.771 + return gl::error(GL_OUT_OF_MEMORY);
1.772 + }
1.773 +}
1.774 +
1.775 +void __stdcall glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
1.776 +{
1.777 + EVENT("(GLenum target = 0x%X, GLintptr offset = %d, GLsizeiptr size = %d, const GLvoid* data = 0x%0.8p)",
1.778 + target, offset, size, data);
1.779 +
1.780 + try
1.781 + {
1.782 + if (size < 0 || offset < 0)
1.783 + {
1.784 + return gl::error(GL_INVALID_VALUE);
1.785 + }
1.786 +
1.787 + if (data == NULL)
1.788 + {
1.789 + return;
1.790 + }
1.791 +
1.792 + gl::Context *context = gl::getNonLostContext();
1.793 +
1.794 + if (context)
1.795 + {
1.796 + gl::Buffer *buffer;
1.797 +
1.798 + switch (target)
1.799 + {
1.800 + case GL_ARRAY_BUFFER:
1.801 + buffer = context->getArrayBuffer();
1.802 + break;
1.803 + case GL_ELEMENT_ARRAY_BUFFER:
1.804 + buffer = context->getElementArrayBuffer();
1.805 + break;
1.806 + default:
1.807 + return gl::error(GL_INVALID_ENUM);
1.808 + }
1.809 +
1.810 + if (!buffer)
1.811 + {
1.812 + return gl::error(GL_INVALID_OPERATION);
1.813 + }
1.814 +
1.815 + if ((size_t)size + offset > buffer->size())
1.816 + {
1.817 + return gl::error(GL_INVALID_VALUE);
1.818 + }
1.819 +
1.820 + buffer->bufferSubData(data, size, offset);
1.821 + }
1.822 + }
1.823 + catch(std::bad_alloc&)
1.824 + {
1.825 + return gl::error(GL_OUT_OF_MEMORY);
1.826 + }
1.827 +}
1.828 +
1.829 +GLenum __stdcall glCheckFramebufferStatus(GLenum target)
1.830 +{
1.831 + EVENT("(GLenum target = 0x%X)", target);
1.832 +
1.833 + try
1.834 + {
1.835 + if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
1.836 + {
1.837 + return gl::error(GL_INVALID_ENUM, 0);
1.838 + }
1.839 +
1.840 + gl::Context *context = gl::getNonLostContext();
1.841 +
1.842 + if (context)
1.843 + {
1.844 + gl::Framebuffer *framebuffer = NULL;
1.845 + if (target == GL_READ_FRAMEBUFFER_ANGLE)
1.846 + {
1.847 + framebuffer = context->getReadFramebuffer();
1.848 + }
1.849 + else
1.850 + {
1.851 + framebuffer = context->getDrawFramebuffer();
1.852 + }
1.853 +
1.854 + return framebuffer->completeness();
1.855 + }
1.856 + }
1.857 + catch(std::bad_alloc&)
1.858 + {
1.859 + return gl::error(GL_OUT_OF_MEMORY, 0);
1.860 + }
1.861 +
1.862 + return 0;
1.863 +}
1.864 +
1.865 +void __stdcall glClear(GLbitfield mask)
1.866 +{
1.867 + EVENT("(GLbitfield mask = %X)", mask);
1.868 +
1.869 + try
1.870 + {
1.871 + gl::Context *context = gl::getNonLostContext();
1.872 +
1.873 + if (context)
1.874 + {
1.875 + context->clear(mask);
1.876 + }
1.877 + }
1.878 + catch(std::bad_alloc&)
1.879 + {
1.880 + return gl::error(GL_OUT_OF_MEMORY);
1.881 + }
1.882 +}
1.883 +
1.884 +void __stdcall glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
1.885 +{
1.886 + EVENT("(GLclampf red = %f, GLclampf green = %f, GLclampf blue = %f, GLclampf alpha = %f)",
1.887 + red, green, blue, alpha);
1.888 +
1.889 + try
1.890 + {
1.891 + gl::Context *context = gl::getNonLostContext();
1.892 +
1.893 + if (context)
1.894 + {
1.895 + context->setClearColor(red, green, blue, alpha);
1.896 + }
1.897 + }
1.898 + catch(std::bad_alloc&)
1.899 + {
1.900 + return gl::error(GL_OUT_OF_MEMORY);
1.901 + }
1.902 +}
1.903 +
1.904 +void __stdcall glClearDepthf(GLclampf depth)
1.905 +{
1.906 + EVENT("(GLclampf depth = %f)", depth);
1.907 +
1.908 + try
1.909 + {
1.910 + gl::Context *context = gl::getNonLostContext();
1.911 +
1.912 + if (context)
1.913 + {
1.914 + context->setClearDepth(depth);
1.915 + }
1.916 + }
1.917 + catch(std::bad_alloc&)
1.918 + {
1.919 + return gl::error(GL_OUT_OF_MEMORY);
1.920 + }
1.921 +}
1.922 +
1.923 +void __stdcall glClearStencil(GLint s)
1.924 +{
1.925 + EVENT("(GLint s = %d)", s);
1.926 +
1.927 + try
1.928 + {
1.929 + gl::Context *context = gl::getNonLostContext();
1.930 +
1.931 + if (context)
1.932 + {
1.933 + context->setClearStencil(s);
1.934 + }
1.935 + }
1.936 + catch(std::bad_alloc&)
1.937 + {
1.938 + return gl::error(GL_OUT_OF_MEMORY);
1.939 + }
1.940 +}
1.941 +
1.942 +void __stdcall glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
1.943 +{
1.944 + EVENT("(GLboolean red = %d, GLboolean green = %d, GLboolean blue = %d, GLboolean alpha = %d)",
1.945 + red, green, blue, alpha);
1.946 +
1.947 + try
1.948 + {
1.949 + gl::Context *context = gl::getNonLostContext();
1.950 +
1.951 + if (context)
1.952 + {
1.953 + context->setColorMask(red == GL_TRUE, green == GL_TRUE, blue == GL_TRUE, alpha == GL_TRUE);
1.954 + }
1.955 + }
1.956 + catch(std::bad_alloc&)
1.957 + {
1.958 + return gl::error(GL_OUT_OF_MEMORY);
1.959 + }
1.960 +}
1.961 +
1.962 +void __stdcall glCompileShader(GLuint shader)
1.963 +{
1.964 + EVENT("(GLuint shader = %d)", shader);
1.965 +
1.966 + try
1.967 + {
1.968 + gl::Context *context = gl::getNonLostContext();
1.969 +
1.970 + if (context)
1.971 + {
1.972 + gl::Shader *shaderObject = context->getShader(shader);
1.973 +
1.974 + if (!shaderObject)
1.975 + {
1.976 + if (context->getProgram(shader))
1.977 + {
1.978 + return gl::error(GL_INVALID_OPERATION);
1.979 + }
1.980 + else
1.981 + {
1.982 + return gl::error(GL_INVALID_VALUE);
1.983 + }
1.984 + }
1.985 +
1.986 + shaderObject->compile();
1.987 + }
1.988 + }
1.989 + catch(std::bad_alloc&)
1.990 + {
1.991 + return gl::error(GL_OUT_OF_MEMORY);
1.992 + }
1.993 +}
1.994 +
1.995 +void __stdcall glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height,
1.996 + GLint border, GLsizei imageSize, const GLvoid* data)
1.997 +{
1.998 + EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, GLsizei width = %d, "
1.999 + "GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, const GLvoid* data = 0x%0.8p)",
1.1000 + target, level, internalformat, width, height, border, imageSize, data);
1.1001 +
1.1002 + try
1.1003 + {
1.1004 + if (!validImageSize(level, width, height) || border != 0 || imageSize < 0)
1.1005 + {
1.1006 + return gl::error(GL_INVALID_VALUE);
1.1007 + }
1.1008 +
1.1009 + switch (internalformat)
1.1010 + {
1.1011 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.1012 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.1013 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.1014 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.1015 + break;
1.1016 + default:
1.1017 + return gl::error(GL_INVALID_ENUM);
1.1018 + }
1.1019 +
1.1020 + if (border != 0)
1.1021 + {
1.1022 + return gl::error(GL_INVALID_OPERATION);
1.1023 + }
1.1024 +
1.1025 + if (width != 1 && width != 2 && width % 4 != 0)
1.1026 + {
1.1027 + return gl::error(GL_INVALID_OPERATION);
1.1028 + }
1.1029 +
1.1030 + if (height != 1 && height != 2 && height % 4 != 0)
1.1031 + {
1.1032 + return gl::error(GL_INVALID_OPERATION);
1.1033 + }
1.1034 +
1.1035 + gl::Context *context = gl::getNonLostContext();
1.1036 +
1.1037 + if (context)
1.1038 + {
1.1039 + if (level > context->getMaximumTextureLevel())
1.1040 + {
1.1041 + return gl::error(GL_INVALID_VALUE);
1.1042 + }
1.1043 +
1.1044 + switch (target)
1.1045 + {
1.1046 + case GL_TEXTURE_2D:
1.1047 + if (width > (context->getMaximumTextureDimension() >> level) ||
1.1048 + height > (context->getMaximumTextureDimension() >> level))
1.1049 + {
1.1050 + return gl::error(GL_INVALID_VALUE);
1.1051 + }
1.1052 + break;
1.1053 + case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1.1054 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1.1055 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1.1056 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1.1057 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1.1058 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1.1059 + if (width != height)
1.1060 + {
1.1061 + return gl::error(GL_INVALID_VALUE);
1.1062 + }
1.1063 +
1.1064 + if (width > (context->getMaximumCubeTextureDimension() >> level) ||
1.1065 + height > (context->getMaximumCubeTextureDimension() >> level))
1.1066 + {
1.1067 + return gl::error(GL_INVALID_VALUE);
1.1068 + }
1.1069 + break;
1.1070 + default:
1.1071 + return gl::error(GL_INVALID_ENUM);
1.1072 + }
1.1073 +
1.1074 + switch (internalformat) {
1.1075 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.1076 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.1077 + if (!context->supportsDXT1Textures())
1.1078 + {
1.1079 + return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
1.1080 + }
1.1081 + break;
1.1082 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.1083 + if (!context->supportsDXT3Textures())
1.1084 + {
1.1085 + return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
1.1086 + }
1.1087 + break;
1.1088 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.1089 + if (!context->supportsDXT5Textures())
1.1090 + {
1.1091 + return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
1.1092 + }
1.1093 + break;
1.1094 + default: UNREACHABLE();
1.1095 + }
1.1096 +
1.1097 + if (imageSize != gl::ComputeCompressedSize(width, height, internalformat))
1.1098 + {
1.1099 + return gl::error(GL_INVALID_VALUE);
1.1100 + }
1.1101 +
1.1102 + if (target == GL_TEXTURE_2D)
1.1103 + {
1.1104 + gl::Texture2D *texture = context->getTexture2D();
1.1105 +
1.1106 + if (!texture)
1.1107 + {
1.1108 + return gl::error(GL_INVALID_OPERATION);
1.1109 + }
1.1110 +
1.1111 + if (texture->isImmutable())
1.1112 + {
1.1113 + return gl::error(GL_INVALID_OPERATION);
1.1114 + }
1.1115 +
1.1116 + texture->setCompressedImage(level, internalformat, width, height, imageSize, data);
1.1117 + }
1.1118 + else
1.1119 + {
1.1120 + gl::TextureCubeMap *texture = context->getTextureCubeMap();
1.1121 +
1.1122 + if (!texture)
1.1123 + {
1.1124 + return gl::error(GL_INVALID_OPERATION);
1.1125 + }
1.1126 +
1.1127 + if (texture->isImmutable())
1.1128 + {
1.1129 + return gl::error(GL_INVALID_OPERATION);
1.1130 + }
1.1131 +
1.1132 + switch (target)
1.1133 + {
1.1134 + case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1.1135 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1.1136 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1.1137 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1.1138 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1.1139 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1.1140 + texture->setCompressedImage(target, level, internalformat, width, height, imageSize, data);
1.1141 + break;
1.1142 + default: UNREACHABLE();
1.1143 + }
1.1144 + }
1.1145 + }
1.1146 +
1.1147 + }
1.1148 + catch(std::bad_alloc&)
1.1149 + {
1.1150 + return gl::error(GL_OUT_OF_MEMORY);
1.1151 + }
1.1152 +}
1.1153 +
1.1154 +void __stdcall glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
1.1155 + GLenum format, GLsizei imageSize, const GLvoid* data)
1.1156 +{
1.1157 + EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
1.1158 + "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, "
1.1159 + "GLsizei imageSize = %d, const GLvoid* data = 0x%0.8p)",
1.1160 + target, level, xoffset, yoffset, width, height, format, imageSize, data);
1.1161 +
1.1162 + try
1.1163 + {
1.1164 + if (!gl::IsInternalTextureTarget(target))
1.1165 + {
1.1166 + return gl::error(GL_INVALID_ENUM);
1.1167 + }
1.1168 +
1.1169 + if (xoffset < 0 || yoffset < 0 || !validImageSize(level, width, height) || imageSize < 0)
1.1170 + {
1.1171 + return gl::error(GL_INVALID_VALUE);
1.1172 + }
1.1173 +
1.1174 + switch (format)
1.1175 + {
1.1176 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.1177 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.1178 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.1179 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.1180 + break;
1.1181 + default:
1.1182 + return gl::error(GL_INVALID_ENUM);
1.1183 + }
1.1184 +
1.1185 + if (width == 0 || height == 0 || data == NULL)
1.1186 + {
1.1187 + return;
1.1188 + }
1.1189 +
1.1190 + gl::Context *context = gl::getNonLostContext();
1.1191 +
1.1192 + if (context)
1.1193 + {
1.1194 + if (level > context->getMaximumTextureLevel())
1.1195 + {
1.1196 + return gl::error(GL_INVALID_VALUE);
1.1197 + }
1.1198 +
1.1199 + switch (format) {
1.1200 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.1201 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.1202 + if (!context->supportsDXT1Textures())
1.1203 + {
1.1204 + return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
1.1205 + }
1.1206 + break;
1.1207 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.1208 + if (!context->supportsDXT3Textures())
1.1209 + {
1.1210 + return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
1.1211 + }
1.1212 + break;
1.1213 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.1214 + if (!context->supportsDXT5Textures())
1.1215 + {
1.1216 + return gl::error(GL_INVALID_ENUM); // in this case, it's as though the internal format switch failed
1.1217 + }
1.1218 + break;
1.1219 + default: UNREACHABLE();
1.1220 + }
1.1221 +
1.1222 + if (imageSize != gl::ComputeCompressedSize(width, height, format))
1.1223 + {
1.1224 + return gl::error(GL_INVALID_VALUE);
1.1225 + }
1.1226 +
1.1227 + if (xoffset % 4 != 0 || yoffset % 4 != 0)
1.1228 + {
1.1229 + return gl::error(GL_INVALID_OPERATION); // we wait to check the offsets until this point, because the multiple-of-four restriction
1.1230 + // does not exist unless DXT textures are supported.
1.1231 + }
1.1232 +
1.1233 + if (target == GL_TEXTURE_2D)
1.1234 + {
1.1235 + gl::Texture2D *texture = context->getTexture2D();
1.1236 + if (validateSubImageParams2D(true, width, height, xoffset, yoffset, level, format, GL_NONE, texture))
1.1237 + {
1.1238 + texture->subImageCompressed(level, xoffset, yoffset, width, height, format, imageSize, data);
1.1239 + }
1.1240 + }
1.1241 + else if (gl::IsCubemapTextureTarget(target))
1.1242 + {
1.1243 + gl::TextureCubeMap *texture = context->getTextureCubeMap();
1.1244 + if (validateSubImageParamsCube(true, width, height, xoffset, yoffset, target, level, format, GL_NONE, texture))
1.1245 + {
1.1246 + texture->subImageCompressed(target, level, xoffset, yoffset, width, height, format, imageSize, data);
1.1247 + }
1.1248 + }
1.1249 + else
1.1250 + {
1.1251 + UNREACHABLE();
1.1252 + }
1.1253 + }
1.1254 + }
1.1255 + catch(std::bad_alloc&)
1.1256 + {
1.1257 + return gl::error(GL_OUT_OF_MEMORY);
1.1258 + }
1.1259 +}
1.1260 +
1.1261 +void __stdcall glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
1.1262 +{
1.1263 + EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
1.1264 + "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLint border = %d)",
1.1265 + target, level, internalformat, x, y, width, height, border);
1.1266 +
1.1267 + try
1.1268 + {
1.1269 + if (!validImageSize(level, width, height))
1.1270 + {
1.1271 + return gl::error(GL_INVALID_VALUE);
1.1272 + }
1.1273 +
1.1274 + if (border != 0)
1.1275 + {
1.1276 + return gl::error(GL_INVALID_VALUE);
1.1277 + }
1.1278 +
1.1279 + gl::Context *context = gl::getNonLostContext();
1.1280 +
1.1281 + if (context)
1.1282 + {
1.1283 + if (level > context->getMaximumTextureLevel())
1.1284 + {
1.1285 + return gl::error(GL_INVALID_VALUE);
1.1286 + }
1.1287 +
1.1288 + switch (target)
1.1289 + {
1.1290 + case GL_TEXTURE_2D:
1.1291 + if (width > (context->getMaximumTextureDimension() >> level) ||
1.1292 + height > (context->getMaximumTextureDimension() >> level))
1.1293 + {
1.1294 + return gl::error(GL_INVALID_VALUE);
1.1295 + }
1.1296 + break;
1.1297 + case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1.1298 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1.1299 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1.1300 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1.1301 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1.1302 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1.1303 + if (width != height)
1.1304 + {
1.1305 + return gl::error(GL_INVALID_VALUE);
1.1306 + }
1.1307 +
1.1308 + if (width > (context->getMaximumCubeTextureDimension() >> level) ||
1.1309 + height > (context->getMaximumCubeTextureDimension() >> level))
1.1310 + {
1.1311 + return gl::error(GL_INVALID_VALUE);
1.1312 + }
1.1313 + break;
1.1314 + default:
1.1315 + return gl::error(GL_INVALID_ENUM);
1.1316 + }
1.1317 +
1.1318 + gl::Framebuffer *framebuffer = context->getReadFramebuffer();
1.1319 +
1.1320 + if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
1.1321 + {
1.1322 + return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
1.1323 + }
1.1324 +
1.1325 + if (context->getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
1.1326 + {
1.1327 + return gl::error(GL_INVALID_OPERATION);
1.1328 + }
1.1329 +
1.1330 + gl::Renderbuffer *source = framebuffer->getReadColorbuffer();
1.1331 + GLenum colorbufferFormat = source->getInternalFormat();
1.1332 +
1.1333 + // [OpenGL ES 2.0.24] table 3.9
1.1334 + switch (internalformat)
1.1335 + {
1.1336 + case GL_ALPHA:
1.1337 + if (colorbufferFormat != GL_ALPHA8_EXT &&
1.1338 + colorbufferFormat != GL_RGBA4 &&
1.1339 + colorbufferFormat != GL_RGB5_A1 &&
1.1340 + colorbufferFormat != GL_BGRA8_EXT &&
1.1341 + colorbufferFormat != GL_RGBA8_OES)
1.1342 + {
1.1343 + return gl::error(GL_INVALID_OPERATION);
1.1344 + }
1.1345 + break;
1.1346 + case GL_LUMINANCE:
1.1347 + case GL_RGB:
1.1348 + if (colorbufferFormat != GL_RGB565 &&
1.1349 + colorbufferFormat != GL_RGB8_OES &&
1.1350 + colorbufferFormat != GL_RGBA4 &&
1.1351 + colorbufferFormat != GL_RGB5_A1 &&
1.1352 + colorbufferFormat != GL_BGRA8_EXT &&
1.1353 + colorbufferFormat != GL_RGBA8_OES)
1.1354 + {
1.1355 + return gl::error(GL_INVALID_OPERATION);
1.1356 + }
1.1357 + break;
1.1358 + case GL_LUMINANCE_ALPHA:
1.1359 + case GL_RGBA:
1.1360 + if (colorbufferFormat != GL_RGBA4 &&
1.1361 + colorbufferFormat != GL_RGB5_A1 &&
1.1362 + colorbufferFormat != GL_BGRA8_EXT &&
1.1363 + colorbufferFormat != GL_RGBA8_OES)
1.1364 + {
1.1365 + return gl::error(GL_INVALID_OPERATION);
1.1366 + }
1.1367 + break;
1.1368 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.1369 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.1370 + if (context->supportsDXT1Textures())
1.1371 + {
1.1372 + return gl::error(GL_INVALID_OPERATION);
1.1373 + }
1.1374 + else
1.1375 + {
1.1376 + return gl::error(GL_INVALID_ENUM);
1.1377 + }
1.1378 + break;
1.1379 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.1380 + if (context->supportsDXT3Textures())
1.1381 + {
1.1382 + return gl::error(GL_INVALID_OPERATION);
1.1383 + }
1.1384 + else
1.1385 + {
1.1386 + return gl::error(GL_INVALID_ENUM);
1.1387 + }
1.1388 + break;
1.1389 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.1390 + if (context->supportsDXT5Textures())
1.1391 + {
1.1392 + return gl::error(GL_INVALID_OPERATION);
1.1393 + }
1.1394 + else
1.1395 + {
1.1396 + return gl::error(GL_INVALID_ENUM);
1.1397 + }
1.1398 + break;
1.1399 + case GL_DEPTH_COMPONENT:
1.1400 + case GL_DEPTH_COMPONENT16:
1.1401 + case GL_DEPTH_COMPONENT32_OES:
1.1402 + case GL_DEPTH_STENCIL_OES:
1.1403 + case GL_DEPTH24_STENCIL8_OES:
1.1404 + if (context->supportsDepthTextures())
1.1405 + {
1.1406 + return gl::error(GL_INVALID_OPERATION);
1.1407 + }
1.1408 + else
1.1409 + {
1.1410 + return gl::error(GL_INVALID_ENUM);
1.1411 + }
1.1412 + default:
1.1413 + return gl::error(GL_INVALID_ENUM);
1.1414 + }
1.1415 +
1.1416 + if (target == GL_TEXTURE_2D)
1.1417 + {
1.1418 + gl::Texture2D *texture = context->getTexture2D();
1.1419 +
1.1420 + if (!texture)
1.1421 + {
1.1422 + return gl::error(GL_INVALID_OPERATION);
1.1423 + }
1.1424 +
1.1425 + if (texture->isImmutable())
1.1426 + {
1.1427 + return gl::error(GL_INVALID_OPERATION);
1.1428 + }
1.1429 +
1.1430 + texture->copyImage(level, internalformat, x, y, width, height, framebuffer);
1.1431 + }
1.1432 + else if (gl::IsCubemapTextureTarget(target))
1.1433 + {
1.1434 + gl::TextureCubeMap *texture = context->getTextureCubeMap();
1.1435 +
1.1436 + if (!texture)
1.1437 + {
1.1438 + return gl::error(GL_INVALID_OPERATION);
1.1439 + }
1.1440 +
1.1441 + if (texture->isImmutable())
1.1442 + {
1.1443 + return gl::error(GL_INVALID_OPERATION);
1.1444 + }
1.1445 +
1.1446 + texture->copyImage(target, level, internalformat, x, y, width, height, framebuffer);
1.1447 + }
1.1448 + else UNREACHABLE();
1.1449 + }
1.1450 + }
1.1451 + catch(std::bad_alloc&)
1.1452 + {
1.1453 + return gl::error(GL_OUT_OF_MEMORY);
1.1454 + }
1.1455 +}
1.1456 +
1.1457 +void __stdcall glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1.1458 +{
1.1459 + EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
1.1460 + "GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)",
1.1461 + target, level, xoffset, yoffset, x, y, width, height);
1.1462 +
1.1463 + try
1.1464 + {
1.1465 + if (!gl::IsInternalTextureTarget(target))
1.1466 + {
1.1467 + return gl::error(GL_INVALID_ENUM);
1.1468 + }
1.1469 +
1.1470 + if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
1.1471 + {
1.1472 + return gl::error(GL_INVALID_VALUE);
1.1473 + }
1.1474 +
1.1475 + if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
1.1476 + {
1.1477 + return gl::error(GL_INVALID_VALUE);
1.1478 + }
1.1479 +
1.1480 + if (width == 0 || height == 0)
1.1481 + {
1.1482 + return;
1.1483 + }
1.1484 +
1.1485 + gl::Context *context = gl::getNonLostContext();
1.1486 +
1.1487 + if (context)
1.1488 + {
1.1489 + if (level > context->getMaximumTextureLevel())
1.1490 + {
1.1491 + return gl::error(GL_INVALID_VALUE);
1.1492 + }
1.1493 +
1.1494 + gl::Framebuffer *framebuffer = context->getReadFramebuffer();
1.1495 +
1.1496 + if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
1.1497 + {
1.1498 + return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION);
1.1499 + }
1.1500 +
1.1501 + if (context->getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
1.1502 + {
1.1503 + return gl::error(GL_INVALID_OPERATION);
1.1504 + }
1.1505 +
1.1506 + gl::Renderbuffer *source = framebuffer->getReadColorbuffer();
1.1507 + GLenum colorbufferFormat = source->getInternalFormat();
1.1508 + gl::Texture *texture = NULL;
1.1509 + GLenum textureFormat = GL_RGBA;
1.1510 +
1.1511 + if (target == GL_TEXTURE_2D)
1.1512 + {
1.1513 + gl::Texture2D *tex2d = context->getTexture2D();
1.1514 +
1.1515 + if (!validateSubImageParams2D(false, width, height, xoffset, yoffset, level, GL_NONE, GL_NONE, tex2d))
1.1516 + {
1.1517 + return; // error already registered by validateSubImageParams
1.1518 + }
1.1519 + textureFormat = gl::ExtractFormat(tex2d->getInternalFormat(level));
1.1520 + texture = tex2d;
1.1521 + }
1.1522 + else if (gl::IsCubemapTextureTarget(target))
1.1523 + {
1.1524 + gl::TextureCubeMap *texcube = context->getTextureCubeMap();
1.1525 +
1.1526 + if (!validateSubImageParamsCube(false, width, height, xoffset, yoffset, target, level, GL_NONE, GL_NONE, texcube))
1.1527 + {
1.1528 + return; // error already registered by validateSubImageParams
1.1529 + }
1.1530 + textureFormat = gl::ExtractFormat(texcube->getInternalFormat(target, level));
1.1531 + texture = texcube;
1.1532 + }
1.1533 + else UNREACHABLE();
1.1534 +
1.1535 + // [OpenGL ES 2.0.24] table 3.9
1.1536 + switch (textureFormat)
1.1537 + {
1.1538 + case GL_ALPHA:
1.1539 + if (colorbufferFormat != GL_ALPHA8_EXT &&
1.1540 + colorbufferFormat != GL_RGBA4 &&
1.1541 + colorbufferFormat != GL_RGB5_A1 &&
1.1542 + colorbufferFormat != GL_RGBA8_OES)
1.1543 + {
1.1544 + return gl::error(GL_INVALID_OPERATION);
1.1545 + }
1.1546 + break;
1.1547 + case GL_LUMINANCE:
1.1548 + case GL_RGB:
1.1549 + if (colorbufferFormat != GL_RGB565 &&
1.1550 + colorbufferFormat != GL_RGB8_OES &&
1.1551 + colorbufferFormat != GL_RGBA4 &&
1.1552 + colorbufferFormat != GL_RGB5_A1 &&
1.1553 + colorbufferFormat != GL_RGBA8_OES)
1.1554 + {
1.1555 + return gl::error(GL_INVALID_OPERATION);
1.1556 + }
1.1557 + break;
1.1558 + case GL_LUMINANCE_ALPHA:
1.1559 + case GL_RGBA:
1.1560 + if (colorbufferFormat != GL_RGBA4 &&
1.1561 + colorbufferFormat != GL_RGB5_A1 &&
1.1562 + colorbufferFormat != GL_RGBA8_OES)
1.1563 + {
1.1564 + return gl::error(GL_INVALID_OPERATION);
1.1565 + }
1.1566 + break;
1.1567 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.1568 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.1569 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.1570 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.1571 + return gl::error(GL_INVALID_OPERATION);
1.1572 + case GL_DEPTH_COMPONENT:
1.1573 + case GL_DEPTH_STENCIL_OES:
1.1574 + return gl::error(GL_INVALID_OPERATION);
1.1575 + default:
1.1576 + return gl::error(GL_INVALID_OPERATION);
1.1577 + }
1.1578 +
1.1579 + texture->copySubImage(target, level, xoffset, yoffset, x, y, width, height, framebuffer);
1.1580 + }
1.1581 + }
1.1582 +
1.1583 + catch(std::bad_alloc&)
1.1584 + {
1.1585 + return gl::error(GL_OUT_OF_MEMORY);
1.1586 + }
1.1587 +}
1.1588 +
1.1589 +GLuint __stdcall glCreateProgram(void)
1.1590 +{
1.1591 + EVENT("()");
1.1592 +
1.1593 + try
1.1594 + {
1.1595 + gl::Context *context = gl::getNonLostContext();
1.1596 +
1.1597 + if (context)
1.1598 + {
1.1599 + return context->createProgram();
1.1600 + }
1.1601 + }
1.1602 + catch(std::bad_alloc&)
1.1603 + {
1.1604 + return gl::error(GL_OUT_OF_MEMORY, 0);
1.1605 + }
1.1606 +
1.1607 + return 0;
1.1608 +}
1.1609 +
1.1610 +GLuint __stdcall glCreateShader(GLenum type)
1.1611 +{
1.1612 + EVENT("(GLenum type = 0x%X)", type);
1.1613 +
1.1614 + try
1.1615 + {
1.1616 + gl::Context *context = gl::getNonLostContext();
1.1617 +
1.1618 + if (context)
1.1619 + {
1.1620 + switch (type)
1.1621 + {
1.1622 + case GL_FRAGMENT_SHADER:
1.1623 + case GL_VERTEX_SHADER:
1.1624 + return context->createShader(type);
1.1625 + default:
1.1626 + return gl::error(GL_INVALID_ENUM, 0);
1.1627 + }
1.1628 + }
1.1629 + }
1.1630 + catch(std::bad_alloc&)
1.1631 + {
1.1632 + return gl::error(GL_OUT_OF_MEMORY, 0);
1.1633 + }
1.1634 +
1.1635 + return 0;
1.1636 +}
1.1637 +
1.1638 +void __stdcall glCullFace(GLenum mode)
1.1639 +{
1.1640 + EVENT("(GLenum mode = 0x%X)", mode);
1.1641 +
1.1642 + try
1.1643 + {
1.1644 + switch (mode)
1.1645 + {
1.1646 + case GL_FRONT:
1.1647 + case GL_BACK:
1.1648 + case GL_FRONT_AND_BACK:
1.1649 + {
1.1650 + gl::Context *context = gl::getNonLostContext();
1.1651 +
1.1652 + if (context)
1.1653 + {
1.1654 + context->setCullMode(mode);
1.1655 + }
1.1656 + }
1.1657 + break;
1.1658 + default:
1.1659 + return gl::error(GL_INVALID_ENUM);
1.1660 + }
1.1661 + }
1.1662 + catch(std::bad_alloc&)
1.1663 + {
1.1664 + return gl::error(GL_OUT_OF_MEMORY);
1.1665 + }
1.1666 +}
1.1667 +
1.1668 +void __stdcall glDeleteBuffers(GLsizei n, const GLuint* buffers)
1.1669 +{
1.1670 + EVENT("(GLsizei n = %d, const GLuint* buffers = 0x%0.8p)", n, buffers);
1.1671 +
1.1672 + try
1.1673 + {
1.1674 + if (n < 0)
1.1675 + {
1.1676 + return gl::error(GL_INVALID_VALUE);
1.1677 + }
1.1678 +
1.1679 + gl::Context *context = gl::getNonLostContext();
1.1680 +
1.1681 + if (context)
1.1682 + {
1.1683 + for (int i = 0; i < n; i++)
1.1684 + {
1.1685 + context->deleteBuffer(buffers[i]);
1.1686 + }
1.1687 + }
1.1688 + }
1.1689 + catch(std::bad_alloc&)
1.1690 + {
1.1691 + return gl::error(GL_OUT_OF_MEMORY);
1.1692 + }
1.1693 +}
1.1694 +
1.1695 +void __stdcall glDeleteFencesNV(GLsizei n, const GLuint* fences)
1.1696 +{
1.1697 + EVENT("(GLsizei n = %d, const GLuint* fences = 0x%0.8p)", n, fences);
1.1698 +
1.1699 + try
1.1700 + {
1.1701 + if (n < 0)
1.1702 + {
1.1703 + return gl::error(GL_INVALID_VALUE);
1.1704 + }
1.1705 +
1.1706 + gl::Context *context = gl::getNonLostContext();
1.1707 +
1.1708 + if (context)
1.1709 + {
1.1710 + for (int i = 0; i < n; i++)
1.1711 + {
1.1712 + context->deleteFence(fences[i]);
1.1713 + }
1.1714 + }
1.1715 + }
1.1716 + catch(std::bad_alloc&)
1.1717 + {
1.1718 + return gl::error(GL_OUT_OF_MEMORY);
1.1719 + }
1.1720 +}
1.1721 +
1.1722 +void __stdcall glDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
1.1723 +{
1.1724 + EVENT("(GLsizei n = %d, const GLuint* framebuffers = 0x%0.8p)", n, framebuffers);
1.1725 +
1.1726 + try
1.1727 + {
1.1728 + if (n < 0)
1.1729 + {
1.1730 + return gl::error(GL_INVALID_VALUE);
1.1731 + }
1.1732 +
1.1733 + gl::Context *context = gl::getNonLostContext();
1.1734 +
1.1735 + if (context)
1.1736 + {
1.1737 + for (int i = 0; i < n; i++)
1.1738 + {
1.1739 + if (framebuffers[i] != 0)
1.1740 + {
1.1741 + context->deleteFramebuffer(framebuffers[i]);
1.1742 + }
1.1743 + }
1.1744 + }
1.1745 + }
1.1746 + catch(std::bad_alloc&)
1.1747 + {
1.1748 + return gl::error(GL_OUT_OF_MEMORY);
1.1749 + }
1.1750 +}
1.1751 +
1.1752 +void __stdcall glDeleteProgram(GLuint program)
1.1753 +{
1.1754 + EVENT("(GLuint program = %d)", program);
1.1755 +
1.1756 + try
1.1757 + {
1.1758 + if (program == 0)
1.1759 + {
1.1760 + return;
1.1761 + }
1.1762 +
1.1763 + gl::Context *context = gl::getNonLostContext();
1.1764 +
1.1765 + if (context)
1.1766 + {
1.1767 + if (!context->getProgram(program))
1.1768 + {
1.1769 + if(context->getShader(program))
1.1770 + {
1.1771 + return gl::error(GL_INVALID_OPERATION);
1.1772 + }
1.1773 + else
1.1774 + {
1.1775 + return gl::error(GL_INVALID_VALUE);
1.1776 + }
1.1777 + }
1.1778 +
1.1779 + context->deleteProgram(program);
1.1780 + }
1.1781 + }
1.1782 + catch(std::bad_alloc&)
1.1783 + {
1.1784 + return gl::error(GL_OUT_OF_MEMORY);
1.1785 + }
1.1786 +}
1.1787 +
1.1788 +void __stdcall glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
1.1789 +{
1.1790 + EVENT("(GLsizei n = %d, const GLuint *ids = 0x%0.8p)", n, ids);
1.1791 +
1.1792 + try
1.1793 + {
1.1794 + if (n < 0)
1.1795 + {
1.1796 + return gl::error(GL_INVALID_VALUE);
1.1797 + }
1.1798 +
1.1799 + gl::Context *context = gl::getNonLostContext();
1.1800 +
1.1801 + if (context)
1.1802 + {
1.1803 + for (int i = 0; i < n; i++)
1.1804 + {
1.1805 + context->deleteQuery(ids[i]);
1.1806 + }
1.1807 + }
1.1808 + }
1.1809 + catch(std::bad_alloc&)
1.1810 + {
1.1811 + return gl::error(GL_OUT_OF_MEMORY);
1.1812 + }
1.1813 +}
1.1814 +
1.1815 +void __stdcall glDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
1.1816 +{
1.1817 + EVENT("(GLsizei n = %d, const GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
1.1818 +
1.1819 + try
1.1820 + {
1.1821 + if (n < 0)
1.1822 + {
1.1823 + return gl::error(GL_INVALID_VALUE);
1.1824 + }
1.1825 +
1.1826 + gl::Context *context = gl::getNonLostContext();
1.1827 +
1.1828 + if (context)
1.1829 + {
1.1830 + for (int i = 0; i < n; i++)
1.1831 + {
1.1832 + context->deleteRenderbuffer(renderbuffers[i]);
1.1833 + }
1.1834 + }
1.1835 + }
1.1836 + catch(std::bad_alloc&)
1.1837 + {
1.1838 + return gl::error(GL_OUT_OF_MEMORY);
1.1839 + }
1.1840 +}
1.1841 +
1.1842 +void __stdcall glDeleteShader(GLuint shader)
1.1843 +{
1.1844 + EVENT("(GLuint shader = %d)", shader);
1.1845 +
1.1846 + try
1.1847 + {
1.1848 + if (shader == 0)
1.1849 + {
1.1850 + return;
1.1851 + }
1.1852 +
1.1853 + gl::Context *context = gl::getNonLostContext();
1.1854 +
1.1855 + if (context)
1.1856 + {
1.1857 + if (!context->getShader(shader))
1.1858 + {
1.1859 + if(context->getProgram(shader))
1.1860 + {
1.1861 + return gl::error(GL_INVALID_OPERATION);
1.1862 + }
1.1863 + else
1.1864 + {
1.1865 + return gl::error(GL_INVALID_VALUE);
1.1866 + }
1.1867 + }
1.1868 +
1.1869 + context->deleteShader(shader);
1.1870 + }
1.1871 + }
1.1872 + catch(std::bad_alloc&)
1.1873 + {
1.1874 + return gl::error(GL_OUT_OF_MEMORY);
1.1875 + }
1.1876 +}
1.1877 +
1.1878 +void __stdcall glDeleteTextures(GLsizei n, const GLuint* textures)
1.1879 +{
1.1880 + EVENT("(GLsizei n = %d, const GLuint* textures = 0x%0.8p)", n, textures);
1.1881 +
1.1882 + try
1.1883 + {
1.1884 + if (n < 0)
1.1885 + {
1.1886 + return gl::error(GL_INVALID_VALUE);
1.1887 + }
1.1888 +
1.1889 + gl::Context *context = gl::getNonLostContext();
1.1890 +
1.1891 + if (context)
1.1892 + {
1.1893 + for (int i = 0; i < n; i++)
1.1894 + {
1.1895 + if (textures[i] != 0)
1.1896 + {
1.1897 + context->deleteTexture(textures[i]);
1.1898 + }
1.1899 + }
1.1900 + }
1.1901 + }
1.1902 + catch(std::bad_alloc&)
1.1903 + {
1.1904 + return gl::error(GL_OUT_OF_MEMORY);
1.1905 + }
1.1906 +}
1.1907 +
1.1908 +void __stdcall glDepthFunc(GLenum func)
1.1909 +{
1.1910 + EVENT("(GLenum func = 0x%X)", func);
1.1911 +
1.1912 + try
1.1913 + {
1.1914 + switch (func)
1.1915 + {
1.1916 + case GL_NEVER:
1.1917 + case GL_ALWAYS:
1.1918 + case GL_LESS:
1.1919 + case GL_LEQUAL:
1.1920 + case GL_EQUAL:
1.1921 + case GL_GREATER:
1.1922 + case GL_GEQUAL:
1.1923 + case GL_NOTEQUAL:
1.1924 + break;
1.1925 + default:
1.1926 + return gl::error(GL_INVALID_ENUM);
1.1927 + }
1.1928 +
1.1929 + gl::Context *context = gl::getNonLostContext();
1.1930 +
1.1931 + if (context)
1.1932 + {
1.1933 + context->setDepthFunc(func);
1.1934 + }
1.1935 + }
1.1936 + catch(std::bad_alloc&)
1.1937 + {
1.1938 + return gl::error(GL_OUT_OF_MEMORY);
1.1939 + }
1.1940 +}
1.1941 +
1.1942 +void __stdcall glDepthMask(GLboolean flag)
1.1943 +{
1.1944 + EVENT("(GLboolean flag = %d)", flag);
1.1945 +
1.1946 + try
1.1947 + {
1.1948 + gl::Context *context = gl::getNonLostContext();
1.1949 +
1.1950 + if (context)
1.1951 + {
1.1952 + context->setDepthMask(flag != GL_FALSE);
1.1953 + }
1.1954 + }
1.1955 + catch(std::bad_alloc&)
1.1956 + {
1.1957 + return gl::error(GL_OUT_OF_MEMORY);
1.1958 + }
1.1959 +}
1.1960 +
1.1961 +void __stdcall glDepthRangef(GLclampf zNear, GLclampf zFar)
1.1962 +{
1.1963 + EVENT("(GLclampf zNear = %f, GLclampf zFar = %f)", zNear, zFar);
1.1964 +
1.1965 + try
1.1966 + {
1.1967 + gl::Context *context = gl::getNonLostContext();
1.1968 +
1.1969 + if (context)
1.1970 + {
1.1971 + context->setDepthRange(zNear, zFar);
1.1972 + }
1.1973 + }
1.1974 + catch(std::bad_alloc&)
1.1975 + {
1.1976 + return gl::error(GL_OUT_OF_MEMORY);
1.1977 + }
1.1978 +}
1.1979 +
1.1980 +void __stdcall glDetachShader(GLuint program, GLuint shader)
1.1981 +{
1.1982 + EVENT("(GLuint program = %d, GLuint shader = %d)", program, shader);
1.1983 +
1.1984 + try
1.1985 + {
1.1986 + gl::Context *context = gl::getNonLostContext();
1.1987 +
1.1988 + if (context)
1.1989 + {
1.1990 +
1.1991 + gl::Program *programObject = context->getProgram(program);
1.1992 + gl::Shader *shaderObject = context->getShader(shader);
1.1993 +
1.1994 + if (!programObject)
1.1995 + {
1.1996 + gl::Shader *shaderByProgramHandle;
1.1997 + shaderByProgramHandle = context->getShader(program);
1.1998 + if (!shaderByProgramHandle)
1.1999 + {
1.2000 + return gl::error(GL_INVALID_VALUE);
1.2001 + }
1.2002 + else
1.2003 + {
1.2004 + return gl::error(GL_INVALID_OPERATION);
1.2005 + }
1.2006 + }
1.2007 +
1.2008 + if (!shaderObject)
1.2009 + {
1.2010 + gl::Program *programByShaderHandle = context->getProgram(shader);
1.2011 + if (!programByShaderHandle)
1.2012 + {
1.2013 + return gl::error(GL_INVALID_VALUE);
1.2014 + }
1.2015 + else
1.2016 + {
1.2017 + return gl::error(GL_INVALID_OPERATION);
1.2018 + }
1.2019 + }
1.2020 +
1.2021 + if (!programObject->detachShader(shaderObject))
1.2022 + {
1.2023 + return gl::error(GL_INVALID_OPERATION);
1.2024 + }
1.2025 + }
1.2026 + }
1.2027 + catch(std::bad_alloc&)
1.2028 + {
1.2029 + return gl::error(GL_OUT_OF_MEMORY);
1.2030 + }
1.2031 +}
1.2032 +
1.2033 +void __stdcall glDisable(GLenum cap)
1.2034 +{
1.2035 + EVENT("(GLenum cap = 0x%X)", cap);
1.2036 +
1.2037 + try
1.2038 + {
1.2039 + gl::Context *context = gl::getNonLostContext();
1.2040 +
1.2041 + if (context)
1.2042 + {
1.2043 + switch (cap)
1.2044 + {
1.2045 + case GL_CULL_FACE: context->setCullFace(false); break;
1.2046 + case GL_POLYGON_OFFSET_FILL: context->setPolygonOffsetFill(false); break;
1.2047 + case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverage(false); break;
1.2048 + case GL_SAMPLE_COVERAGE: context->setSampleCoverage(false); break;
1.2049 + case GL_SCISSOR_TEST: context->setScissorTest(false); break;
1.2050 + case GL_STENCIL_TEST: context->setStencilTest(false); break;
1.2051 + case GL_DEPTH_TEST: context->setDepthTest(false); break;
1.2052 + case GL_BLEND: context->setBlend(false); break;
1.2053 + case GL_DITHER: context->setDither(false); break;
1.2054 + default:
1.2055 + return gl::error(GL_INVALID_ENUM);
1.2056 + }
1.2057 + }
1.2058 + }
1.2059 + catch(std::bad_alloc&)
1.2060 + {
1.2061 + return gl::error(GL_OUT_OF_MEMORY);
1.2062 + }
1.2063 +}
1.2064 +
1.2065 +void __stdcall glDisableVertexAttribArray(GLuint index)
1.2066 +{
1.2067 + EVENT("(GLuint index = %d)", index);
1.2068 +
1.2069 + try
1.2070 + {
1.2071 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.2072 + {
1.2073 + return gl::error(GL_INVALID_VALUE);
1.2074 + }
1.2075 +
1.2076 + gl::Context *context = gl::getNonLostContext();
1.2077 +
1.2078 + if (context)
1.2079 + {
1.2080 + context->setEnableVertexAttribArray(index, false);
1.2081 + }
1.2082 + }
1.2083 + catch(std::bad_alloc&)
1.2084 + {
1.2085 + return gl::error(GL_OUT_OF_MEMORY);
1.2086 + }
1.2087 +}
1.2088 +
1.2089 +void __stdcall glDrawArrays(GLenum mode, GLint first, GLsizei count)
1.2090 +{
1.2091 + EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d)", mode, first, count);
1.2092 +
1.2093 + try
1.2094 + {
1.2095 + if (count < 0 || first < 0)
1.2096 + {
1.2097 + return gl::error(GL_INVALID_VALUE);
1.2098 + }
1.2099 +
1.2100 + gl::Context *context = gl::getNonLostContext();
1.2101 +
1.2102 + if (context)
1.2103 + {
1.2104 + context->drawArrays(mode, first, count, 0);
1.2105 + }
1.2106 + }
1.2107 + catch(std::bad_alloc&)
1.2108 + {
1.2109 + return gl::error(GL_OUT_OF_MEMORY);
1.2110 + }
1.2111 +}
1.2112 +
1.2113 +void __stdcall glDrawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
1.2114 +{
1.2115 + EVENT("(GLenum mode = 0x%X, GLint first = %d, GLsizei count = %d, GLsizei primcount = %d)", mode, first, count, primcount);
1.2116 +
1.2117 + try
1.2118 + {
1.2119 + if (count < 0 || first < 0 || primcount < 0)
1.2120 + {
1.2121 + return gl::error(GL_INVALID_VALUE);
1.2122 + }
1.2123 +
1.2124 + if (primcount > 0)
1.2125 + {
1.2126 + gl::Context *context = gl::getNonLostContext();
1.2127 +
1.2128 + if (context)
1.2129 + {
1.2130 + context->drawArrays(mode, first, count, primcount);
1.2131 + }
1.2132 + }
1.2133 + }
1.2134 + catch(std::bad_alloc&)
1.2135 + {
1.2136 + return gl::error(GL_OUT_OF_MEMORY);
1.2137 + }
1.2138 +}
1.2139 +
1.2140 +void __stdcall glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
1.2141 +{
1.2142 + EVENT("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = 0x%0.8p)",
1.2143 + mode, count, type, indices);
1.2144 +
1.2145 + try
1.2146 + {
1.2147 + if (count < 0)
1.2148 + {
1.2149 + return gl::error(GL_INVALID_VALUE);
1.2150 + }
1.2151 +
1.2152 + gl::Context *context = gl::getNonLostContext();
1.2153 +
1.2154 + if (context)
1.2155 + {
1.2156 + switch (type)
1.2157 + {
1.2158 + case GL_UNSIGNED_BYTE:
1.2159 + case GL_UNSIGNED_SHORT:
1.2160 + break;
1.2161 + case GL_UNSIGNED_INT:
1.2162 + if (!context->supports32bitIndices())
1.2163 + {
1.2164 + return gl::error(GL_INVALID_ENUM);
1.2165 + }
1.2166 + break;
1.2167 + default:
1.2168 + return gl::error(GL_INVALID_ENUM);
1.2169 + }
1.2170 +
1.2171 + context->drawElements(mode, count, type, indices, 0);
1.2172 + }
1.2173 + }
1.2174 + catch(std::bad_alloc&)
1.2175 + {
1.2176 + return gl::error(GL_OUT_OF_MEMORY);
1.2177 + }
1.2178 +}
1.2179 +
1.2180 +void __stdcall glDrawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount)
1.2181 +{
1.2182 + EVENT("(GLenum mode = 0x%X, GLsizei count = %d, GLenum type = 0x%X, const GLvoid* indices = 0x%0.8p, GLsizei primcount = %d)",
1.2183 + mode, count, type, indices, primcount);
1.2184 +
1.2185 + try
1.2186 + {
1.2187 + if (count < 0 || primcount < 0)
1.2188 + {
1.2189 + return gl::error(GL_INVALID_VALUE);
1.2190 + }
1.2191 +
1.2192 + if (primcount > 0)
1.2193 + {
1.2194 + gl::Context *context = gl::getNonLostContext();
1.2195 +
1.2196 + if (context)
1.2197 + {
1.2198 + switch (type)
1.2199 + {
1.2200 + case GL_UNSIGNED_BYTE:
1.2201 + case GL_UNSIGNED_SHORT:
1.2202 + break;
1.2203 + case GL_UNSIGNED_INT:
1.2204 + if (!context->supports32bitIndices())
1.2205 + {
1.2206 + return gl::error(GL_INVALID_ENUM);
1.2207 + }
1.2208 + break;
1.2209 + default:
1.2210 + return gl::error(GL_INVALID_ENUM);
1.2211 + }
1.2212 +
1.2213 + context->drawElements(mode, count, type, indices, primcount);
1.2214 + }
1.2215 + }
1.2216 + }
1.2217 + catch(std::bad_alloc&)
1.2218 + {
1.2219 + return gl::error(GL_OUT_OF_MEMORY);
1.2220 + }
1.2221 +}
1.2222 +
1.2223 +void __stdcall glEnable(GLenum cap)
1.2224 +{
1.2225 + EVENT("(GLenum cap = 0x%X)", cap);
1.2226 +
1.2227 + try
1.2228 + {
1.2229 + gl::Context *context = gl::getNonLostContext();
1.2230 +
1.2231 + if (context)
1.2232 + {
1.2233 + switch (cap)
1.2234 + {
1.2235 + case GL_CULL_FACE: context->setCullFace(true); break;
1.2236 + case GL_POLYGON_OFFSET_FILL: context->setPolygonOffsetFill(true); break;
1.2237 + case GL_SAMPLE_ALPHA_TO_COVERAGE: context->setSampleAlphaToCoverage(true); break;
1.2238 + case GL_SAMPLE_COVERAGE: context->setSampleCoverage(true); break;
1.2239 + case GL_SCISSOR_TEST: context->setScissorTest(true); break;
1.2240 + case GL_STENCIL_TEST: context->setStencilTest(true); break;
1.2241 + case GL_DEPTH_TEST: context->setDepthTest(true); break;
1.2242 + case GL_BLEND: context->setBlend(true); break;
1.2243 + case GL_DITHER: context->setDither(true); break;
1.2244 + default:
1.2245 + return gl::error(GL_INVALID_ENUM);
1.2246 + }
1.2247 + }
1.2248 + }
1.2249 + catch(std::bad_alloc&)
1.2250 + {
1.2251 + return gl::error(GL_OUT_OF_MEMORY);
1.2252 + }
1.2253 +}
1.2254 +
1.2255 +void __stdcall glEnableVertexAttribArray(GLuint index)
1.2256 +{
1.2257 + EVENT("(GLuint index = %d)", index);
1.2258 +
1.2259 + try
1.2260 + {
1.2261 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.2262 + {
1.2263 + return gl::error(GL_INVALID_VALUE);
1.2264 + }
1.2265 +
1.2266 + gl::Context *context = gl::getNonLostContext();
1.2267 +
1.2268 + if (context)
1.2269 + {
1.2270 + context->setEnableVertexAttribArray(index, true);
1.2271 + }
1.2272 + }
1.2273 + catch(std::bad_alloc&)
1.2274 + {
1.2275 + return gl::error(GL_OUT_OF_MEMORY);
1.2276 + }
1.2277 +}
1.2278 +
1.2279 +void __stdcall glEndQueryEXT(GLenum target)
1.2280 +{
1.2281 + EVENT("GLenum target = 0x%X)", target);
1.2282 +
1.2283 + try
1.2284 + {
1.2285 + switch (target)
1.2286 + {
1.2287 + case GL_ANY_SAMPLES_PASSED_EXT:
1.2288 + case GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT:
1.2289 + break;
1.2290 + default:
1.2291 + return gl::error(GL_INVALID_ENUM);
1.2292 + }
1.2293 +
1.2294 + gl::Context *context = gl::getNonLostContext();
1.2295 +
1.2296 + if (context)
1.2297 + {
1.2298 + context->endQuery(target);
1.2299 + }
1.2300 + }
1.2301 + catch(std::bad_alloc&)
1.2302 + {
1.2303 + return gl::error(GL_OUT_OF_MEMORY);
1.2304 + }
1.2305 +}
1.2306 +
1.2307 +void __stdcall glFinishFenceNV(GLuint fence)
1.2308 +{
1.2309 + EVENT("(GLuint fence = %d)", fence);
1.2310 +
1.2311 + try
1.2312 + {
1.2313 + gl::Context *context = gl::getNonLostContext();
1.2314 +
1.2315 + if (context)
1.2316 + {
1.2317 + gl::Fence* fenceObject = context->getFence(fence);
1.2318 +
1.2319 + if (fenceObject == NULL)
1.2320 + {
1.2321 + return gl::error(GL_INVALID_OPERATION);
1.2322 + }
1.2323 +
1.2324 + fenceObject->finishFence();
1.2325 + }
1.2326 + }
1.2327 + catch(std::bad_alloc&)
1.2328 + {
1.2329 + return gl::error(GL_OUT_OF_MEMORY);
1.2330 + }
1.2331 +}
1.2332 +
1.2333 +void __stdcall glFinish(void)
1.2334 +{
1.2335 + EVENT("()");
1.2336 +
1.2337 + try
1.2338 + {
1.2339 + gl::Context *context = gl::getNonLostContext();
1.2340 +
1.2341 + if (context)
1.2342 + {
1.2343 + context->sync(true);
1.2344 + }
1.2345 + }
1.2346 + catch(std::bad_alloc&)
1.2347 + {
1.2348 + return gl::error(GL_OUT_OF_MEMORY);
1.2349 + }
1.2350 +}
1.2351 +
1.2352 +void __stdcall glFlush(void)
1.2353 +{
1.2354 + EVENT("()");
1.2355 +
1.2356 + try
1.2357 + {
1.2358 + gl::Context *context = gl::getNonLostContext();
1.2359 +
1.2360 + if (context)
1.2361 + {
1.2362 + context->sync(false);
1.2363 + }
1.2364 + }
1.2365 + catch(std::bad_alloc&)
1.2366 + {
1.2367 + return gl::error(GL_OUT_OF_MEMORY);
1.2368 + }
1.2369 +}
1.2370 +
1.2371 +void __stdcall glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
1.2372 +{
1.2373 + EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum renderbuffertarget = 0x%X, "
1.2374 + "GLuint renderbuffer = %d)", target, attachment, renderbuffertarget, renderbuffer);
1.2375 +
1.2376 + try
1.2377 + {
1.2378 + if ((target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
1.2379 + || (renderbuffertarget != GL_RENDERBUFFER && renderbuffer != 0))
1.2380 + {
1.2381 + return gl::error(GL_INVALID_ENUM);
1.2382 + }
1.2383 +
1.2384 + gl::Context *context = gl::getNonLostContext();
1.2385 +
1.2386 + if (context)
1.2387 + {
1.2388 + gl::Framebuffer *framebuffer = NULL;
1.2389 + GLuint framebufferHandle = 0;
1.2390 + if (target == GL_READ_FRAMEBUFFER_ANGLE)
1.2391 + {
1.2392 + framebuffer = context->getReadFramebuffer();
1.2393 + framebufferHandle = context->getReadFramebufferHandle();
1.2394 + }
1.2395 + else
1.2396 + {
1.2397 + framebuffer = context->getDrawFramebuffer();
1.2398 + framebufferHandle = context->getDrawFramebufferHandle();
1.2399 + }
1.2400 +
1.2401 + if (!framebuffer || (framebufferHandle == 0 && renderbuffer != 0))
1.2402 + {
1.2403 + return gl::error(GL_INVALID_OPERATION);
1.2404 + }
1.2405 +
1.2406 + if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
1.2407 + {
1.2408 + const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
1.2409 +
1.2410 + if (colorAttachment >= context->getMaximumRenderTargets())
1.2411 + {
1.2412 + return gl::error(GL_INVALID_VALUE);
1.2413 + }
1.2414 +
1.2415 + framebuffer->setColorbuffer(colorAttachment, GL_RENDERBUFFER, renderbuffer);
1.2416 + }
1.2417 + else
1.2418 + {
1.2419 + switch (attachment)
1.2420 + {
1.2421 + case GL_DEPTH_ATTACHMENT:
1.2422 + framebuffer->setDepthbuffer(GL_RENDERBUFFER, renderbuffer);
1.2423 + break;
1.2424 + case GL_STENCIL_ATTACHMENT:
1.2425 + framebuffer->setStencilbuffer(GL_RENDERBUFFER, renderbuffer);
1.2426 + break;
1.2427 + default:
1.2428 + return gl::error(GL_INVALID_ENUM);
1.2429 + }
1.2430 + }
1.2431 + }
1.2432 + }
1.2433 + catch(std::bad_alloc&)
1.2434 + {
1.2435 + return gl::error(GL_OUT_OF_MEMORY);
1.2436 + }
1.2437 +}
1.2438 +
1.2439 +void __stdcall glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
1.2440 +{
1.2441 + EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum textarget = 0x%X, "
1.2442 + "GLuint texture = %d, GLint level = %d)", target, attachment, textarget, texture, level);
1.2443 +
1.2444 + try
1.2445 + {
1.2446 + if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
1.2447 + {
1.2448 + return gl::error(GL_INVALID_ENUM);
1.2449 + }
1.2450 +
1.2451 + gl::Context *context = gl::getNonLostContext();
1.2452 +
1.2453 + if (context)
1.2454 + {
1.2455 + if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
1.2456 + {
1.2457 + const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
1.2458 +
1.2459 + if (colorAttachment >= context->getMaximumRenderTargets())
1.2460 + {
1.2461 + return gl::error(GL_INVALID_VALUE);
1.2462 + }
1.2463 + }
1.2464 + else
1.2465 + {
1.2466 + switch (attachment)
1.2467 + {
1.2468 + case GL_DEPTH_ATTACHMENT:
1.2469 + case GL_STENCIL_ATTACHMENT:
1.2470 + break;
1.2471 + default:
1.2472 + return gl::error(GL_INVALID_ENUM);
1.2473 + }
1.2474 + }
1.2475 +
1.2476 + if (texture == 0)
1.2477 + {
1.2478 + textarget = GL_NONE;
1.2479 + }
1.2480 + else
1.2481 + {
1.2482 + gl::Texture *tex = context->getTexture(texture);
1.2483 +
1.2484 + if (tex == NULL)
1.2485 + {
1.2486 + return gl::error(GL_INVALID_OPERATION);
1.2487 + }
1.2488 +
1.2489 + switch (textarget)
1.2490 + {
1.2491 + case GL_TEXTURE_2D:
1.2492 + {
1.2493 + if (tex->getTarget() != GL_TEXTURE_2D)
1.2494 + {
1.2495 + return gl::error(GL_INVALID_OPERATION);
1.2496 + }
1.2497 + gl::Texture2D *tex2d = static_cast<gl::Texture2D *>(tex);
1.2498 + if (tex2d->isCompressed(0))
1.2499 + {
1.2500 + return gl::error(GL_INVALID_OPERATION);
1.2501 + }
1.2502 + break;
1.2503 + }
1.2504 +
1.2505 + case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1.2506 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1.2507 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1.2508 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1.2509 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1.2510 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1.2511 + {
1.2512 + if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
1.2513 + {
1.2514 + return gl::error(GL_INVALID_OPERATION);
1.2515 + }
1.2516 + gl::TextureCubeMap *texcube = static_cast<gl::TextureCubeMap *>(tex);
1.2517 + if (texcube->isCompressed(textarget, level))
1.2518 + {
1.2519 + return gl::error(GL_INVALID_OPERATION);
1.2520 + }
1.2521 + break;
1.2522 + }
1.2523 +
1.2524 + default:
1.2525 + return gl::error(GL_INVALID_ENUM);
1.2526 + }
1.2527 +
1.2528 + if (level != 0)
1.2529 + {
1.2530 + return gl::error(GL_INVALID_VALUE);
1.2531 + }
1.2532 + }
1.2533 +
1.2534 + gl::Framebuffer *framebuffer = NULL;
1.2535 + GLuint framebufferHandle = 0;
1.2536 + if (target == GL_READ_FRAMEBUFFER_ANGLE)
1.2537 + {
1.2538 + framebuffer = context->getReadFramebuffer();
1.2539 + framebufferHandle = context->getReadFramebufferHandle();
1.2540 + }
1.2541 + else
1.2542 + {
1.2543 + framebuffer = context->getDrawFramebuffer();
1.2544 + framebufferHandle = context->getDrawFramebufferHandle();
1.2545 + }
1.2546 +
1.2547 + if (framebufferHandle == 0 || !framebuffer)
1.2548 + {
1.2549 + return gl::error(GL_INVALID_OPERATION);
1.2550 + }
1.2551 +
1.2552 + if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
1.2553 + {
1.2554 + const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
1.2555 +
1.2556 + if (colorAttachment >= context->getMaximumRenderTargets())
1.2557 + {
1.2558 + return gl::error(GL_INVALID_VALUE);
1.2559 + }
1.2560 +
1.2561 + framebuffer->setColorbuffer(colorAttachment, textarget, texture);
1.2562 + }
1.2563 + else
1.2564 + {
1.2565 + switch (attachment)
1.2566 + {
1.2567 + case GL_DEPTH_ATTACHMENT: framebuffer->setDepthbuffer(textarget, texture); break;
1.2568 + case GL_STENCIL_ATTACHMENT: framebuffer->setStencilbuffer(textarget, texture); break;
1.2569 + }
1.2570 + }
1.2571 + }
1.2572 + }
1.2573 + catch(std::bad_alloc&)
1.2574 + {
1.2575 + return gl::error(GL_OUT_OF_MEMORY);
1.2576 + }
1.2577 +}
1.2578 +
1.2579 +void __stdcall glFrontFace(GLenum mode)
1.2580 +{
1.2581 + EVENT("(GLenum mode = 0x%X)", mode);
1.2582 +
1.2583 + try
1.2584 + {
1.2585 + switch (mode)
1.2586 + {
1.2587 + case GL_CW:
1.2588 + case GL_CCW:
1.2589 + {
1.2590 + gl::Context *context = gl::getNonLostContext();
1.2591 +
1.2592 + if (context)
1.2593 + {
1.2594 + context->setFrontFace(mode);
1.2595 + }
1.2596 + }
1.2597 + break;
1.2598 + default:
1.2599 + return gl::error(GL_INVALID_ENUM);
1.2600 + }
1.2601 + }
1.2602 + catch(std::bad_alloc&)
1.2603 + {
1.2604 + return gl::error(GL_OUT_OF_MEMORY);
1.2605 + }
1.2606 +}
1.2607 +
1.2608 +void __stdcall glGenBuffers(GLsizei n, GLuint* buffers)
1.2609 +{
1.2610 + EVENT("(GLsizei n = %d, GLuint* buffers = 0x%0.8p)", n, buffers);
1.2611 +
1.2612 + try
1.2613 + {
1.2614 + if (n < 0)
1.2615 + {
1.2616 + return gl::error(GL_INVALID_VALUE);
1.2617 + }
1.2618 +
1.2619 + gl::Context *context = gl::getNonLostContext();
1.2620 +
1.2621 + if (context)
1.2622 + {
1.2623 + for (int i = 0; i < n; i++)
1.2624 + {
1.2625 + buffers[i] = context->createBuffer();
1.2626 + }
1.2627 + }
1.2628 + }
1.2629 + catch(std::bad_alloc&)
1.2630 + {
1.2631 + return gl::error(GL_OUT_OF_MEMORY);
1.2632 + }
1.2633 +}
1.2634 +
1.2635 +void __stdcall glGenerateMipmap(GLenum target)
1.2636 +{
1.2637 + EVENT("(GLenum target = 0x%X)", target);
1.2638 +
1.2639 + try
1.2640 + {
1.2641 + gl::Context *context = gl::getNonLostContext();
1.2642 +
1.2643 + if (context)
1.2644 + {
1.2645 + switch (target)
1.2646 + {
1.2647 + case GL_TEXTURE_2D:
1.2648 + {
1.2649 + gl::Texture2D *tex2d = context->getTexture2D();
1.2650 +
1.2651 + if (tex2d->isCompressed(0))
1.2652 + {
1.2653 + return gl::error(GL_INVALID_OPERATION);
1.2654 + }
1.2655 + if (tex2d->isDepth(0))
1.2656 + {
1.2657 + return gl::error(GL_INVALID_OPERATION);
1.2658 + }
1.2659 +
1.2660 + tex2d->generateMipmaps();
1.2661 + break;
1.2662 + }
1.2663 +
1.2664 + case GL_TEXTURE_CUBE_MAP:
1.2665 + {
1.2666 + gl::TextureCubeMap *texcube = context->getTextureCubeMap();
1.2667 +
1.2668 + if (texcube->isCompressed(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0))
1.2669 + {
1.2670 + return gl::error(GL_INVALID_OPERATION);
1.2671 + }
1.2672 +
1.2673 + texcube->generateMipmaps();
1.2674 + break;
1.2675 + }
1.2676 +
1.2677 + default:
1.2678 + return gl::error(GL_INVALID_ENUM);
1.2679 + }
1.2680 + }
1.2681 + }
1.2682 + catch(std::bad_alloc&)
1.2683 + {
1.2684 + return gl::error(GL_OUT_OF_MEMORY);
1.2685 + }
1.2686 +}
1.2687 +
1.2688 +void __stdcall glGenFencesNV(GLsizei n, GLuint* fences)
1.2689 +{
1.2690 + EVENT("(GLsizei n = %d, GLuint* fences = 0x%0.8p)", n, fences);
1.2691 +
1.2692 + try
1.2693 + {
1.2694 + if (n < 0)
1.2695 + {
1.2696 + return gl::error(GL_INVALID_VALUE);
1.2697 + }
1.2698 +
1.2699 + gl::Context *context = gl::getNonLostContext();
1.2700 +
1.2701 + if (context)
1.2702 + {
1.2703 + for (int i = 0; i < n; i++)
1.2704 + {
1.2705 + fences[i] = context->createFence();
1.2706 + }
1.2707 + }
1.2708 + }
1.2709 + catch(std::bad_alloc&)
1.2710 + {
1.2711 + return gl::error(GL_OUT_OF_MEMORY);
1.2712 + }
1.2713 +}
1.2714 +
1.2715 +void __stdcall glGenFramebuffers(GLsizei n, GLuint* framebuffers)
1.2716 +{
1.2717 + EVENT("(GLsizei n = %d, GLuint* framebuffers = 0x%0.8p)", n, framebuffers);
1.2718 +
1.2719 + try
1.2720 + {
1.2721 + if (n < 0)
1.2722 + {
1.2723 + return gl::error(GL_INVALID_VALUE);
1.2724 + }
1.2725 +
1.2726 + gl::Context *context = gl::getNonLostContext();
1.2727 +
1.2728 + if (context)
1.2729 + {
1.2730 + for (int i = 0; i < n; i++)
1.2731 + {
1.2732 + framebuffers[i] = context->createFramebuffer();
1.2733 + }
1.2734 + }
1.2735 + }
1.2736 + catch(std::bad_alloc&)
1.2737 + {
1.2738 + return gl::error(GL_OUT_OF_MEMORY);
1.2739 + }
1.2740 +}
1.2741 +
1.2742 +void __stdcall glGenQueriesEXT(GLsizei n, GLuint* ids)
1.2743 +{
1.2744 + EVENT("(GLsizei n = %d, GLuint* ids = 0x%0.8p)", n, ids);
1.2745 +
1.2746 + try
1.2747 + {
1.2748 + if (n < 0)
1.2749 + {
1.2750 + return gl::error(GL_INVALID_VALUE);
1.2751 + }
1.2752 +
1.2753 + gl::Context *context = gl::getNonLostContext();
1.2754 +
1.2755 + if (context)
1.2756 + {
1.2757 + for (int i = 0; i < n; i++)
1.2758 + {
1.2759 + ids[i] = context->createQuery();
1.2760 + }
1.2761 + }
1.2762 + }
1.2763 + catch(std::bad_alloc&)
1.2764 + {
1.2765 + return gl::error(GL_OUT_OF_MEMORY);
1.2766 + }
1.2767 +}
1.2768 +
1.2769 +void __stdcall glGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
1.2770 +{
1.2771 + EVENT("(GLsizei n = %d, GLuint* renderbuffers = 0x%0.8p)", n, renderbuffers);
1.2772 +
1.2773 + try
1.2774 + {
1.2775 + if (n < 0)
1.2776 + {
1.2777 + return gl::error(GL_INVALID_VALUE);
1.2778 + }
1.2779 +
1.2780 + gl::Context *context = gl::getNonLostContext();
1.2781 +
1.2782 + if (context)
1.2783 + {
1.2784 + for (int i = 0; i < n; i++)
1.2785 + {
1.2786 + renderbuffers[i] = context->createRenderbuffer();
1.2787 + }
1.2788 + }
1.2789 + }
1.2790 + catch(std::bad_alloc&)
1.2791 + {
1.2792 + return gl::error(GL_OUT_OF_MEMORY);
1.2793 + }
1.2794 +}
1.2795 +
1.2796 +void __stdcall glGenTextures(GLsizei n, GLuint* textures)
1.2797 +{
1.2798 + EVENT("(GLsizei n = %d, GLuint* textures = 0x%0.8p)", n, textures);
1.2799 +
1.2800 + try
1.2801 + {
1.2802 + if (n < 0)
1.2803 + {
1.2804 + return gl::error(GL_INVALID_VALUE);
1.2805 + }
1.2806 +
1.2807 + gl::Context *context = gl::getNonLostContext();
1.2808 +
1.2809 + if (context)
1.2810 + {
1.2811 + for (int i = 0; i < n; i++)
1.2812 + {
1.2813 + textures[i] = context->createTexture();
1.2814 + }
1.2815 + }
1.2816 + }
1.2817 + catch(std::bad_alloc&)
1.2818 + {
1.2819 + return gl::error(GL_OUT_OF_MEMORY);
1.2820 + }
1.2821 +}
1.2822 +
1.2823 +void __stdcall glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
1.2824 +{
1.2825 + EVENT("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, GLsizei *length = 0x%0.8p, "
1.2826 + "GLint *size = 0x%0.8p, GLenum *type = %0.8p, GLchar *name = %0.8p)",
1.2827 + program, index, bufsize, length, size, type, name);
1.2828 +
1.2829 + try
1.2830 + {
1.2831 + if (bufsize < 0)
1.2832 + {
1.2833 + return gl::error(GL_INVALID_VALUE);
1.2834 + }
1.2835 +
1.2836 + gl::Context *context = gl::getNonLostContext();
1.2837 +
1.2838 + if (context)
1.2839 + {
1.2840 + gl::Program *programObject = context->getProgram(program);
1.2841 +
1.2842 + if (!programObject)
1.2843 + {
1.2844 + if (context->getShader(program))
1.2845 + {
1.2846 + return gl::error(GL_INVALID_OPERATION);
1.2847 + }
1.2848 + else
1.2849 + {
1.2850 + return gl::error(GL_INVALID_VALUE);
1.2851 + }
1.2852 + }
1.2853 +
1.2854 + if (index >= (GLuint)programObject->getActiveAttributeCount())
1.2855 + {
1.2856 + return gl::error(GL_INVALID_VALUE);
1.2857 + }
1.2858 +
1.2859 + programObject->getActiveAttribute(index, bufsize, length, size, type, name);
1.2860 + }
1.2861 + }
1.2862 + catch(std::bad_alloc&)
1.2863 + {
1.2864 + return gl::error(GL_OUT_OF_MEMORY);
1.2865 + }
1.2866 +}
1.2867 +
1.2868 +void __stdcall glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name)
1.2869 +{
1.2870 + EVENT("(GLuint program = %d, GLuint index = %d, GLsizei bufsize = %d, "
1.2871 + "GLsizei* length = 0x%0.8p, GLint* size = 0x%0.8p, GLenum* type = 0x%0.8p, GLchar* name = 0x%0.8p)",
1.2872 + program, index, bufsize, length, size, type, name);
1.2873 +
1.2874 + try
1.2875 + {
1.2876 + if (bufsize < 0)
1.2877 + {
1.2878 + return gl::error(GL_INVALID_VALUE);
1.2879 + }
1.2880 +
1.2881 + gl::Context *context = gl::getNonLostContext();
1.2882 +
1.2883 + if (context)
1.2884 + {
1.2885 + gl::Program *programObject = context->getProgram(program);
1.2886 +
1.2887 + if (!programObject)
1.2888 + {
1.2889 + if (context->getShader(program))
1.2890 + {
1.2891 + return gl::error(GL_INVALID_OPERATION);
1.2892 + }
1.2893 + else
1.2894 + {
1.2895 + return gl::error(GL_INVALID_VALUE);
1.2896 + }
1.2897 + }
1.2898 +
1.2899 + if (index >= (GLuint)programObject->getActiveUniformCount())
1.2900 + {
1.2901 + return gl::error(GL_INVALID_VALUE);
1.2902 + }
1.2903 +
1.2904 + programObject->getActiveUniform(index, bufsize, length, size, type, name);
1.2905 + }
1.2906 + }
1.2907 + catch(std::bad_alloc&)
1.2908 + {
1.2909 + return gl::error(GL_OUT_OF_MEMORY);
1.2910 + }
1.2911 +}
1.2912 +
1.2913 +void __stdcall glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
1.2914 +{
1.2915 + EVENT("(GLuint program = %d, GLsizei maxcount = %d, GLsizei* count = 0x%0.8p, GLuint* shaders = 0x%0.8p)",
1.2916 + program, maxcount, count, shaders);
1.2917 +
1.2918 + try
1.2919 + {
1.2920 + if (maxcount < 0)
1.2921 + {
1.2922 + return gl::error(GL_INVALID_VALUE);
1.2923 + }
1.2924 +
1.2925 + gl::Context *context = gl::getNonLostContext();
1.2926 +
1.2927 + if (context)
1.2928 + {
1.2929 + gl::Program *programObject = context->getProgram(program);
1.2930 +
1.2931 + if (!programObject)
1.2932 + {
1.2933 + if (context->getShader(program))
1.2934 + {
1.2935 + return gl::error(GL_INVALID_OPERATION);
1.2936 + }
1.2937 + else
1.2938 + {
1.2939 + return gl::error(GL_INVALID_VALUE);
1.2940 + }
1.2941 + }
1.2942 +
1.2943 + return programObject->getAttachedShaders(maxcount, count, shaders);
1.2944 + }
1.2945 + }
1.2946 + catch(std::bad_alloc&)
1.2947 + {
1.2948 + return gl::error(GL_OUT_OF_MEMORY);
1.2949 + }
1.2950 +}
1.2951 +
1.2952 +int __stdcall glGetAttribLocation(GLuint program, const GLchar* name)
1.2953 +{
1.2954 + EVENT("(GLuint program = %d, const GLchar* name = %s)", program, name);
1.2955 +
1.2956 + try
1.2957 + {
1.2958 + gl::Context *context = gl::getNonLostContext();
1.2959 +
1.2960 + if (context)
1.2961 + {
1.2962 +
1.2963 + gl::Program *programObject = context->getProgram(program);
1.2964 +
1.2965 + if (!programObject)
1.2966 + {
1.2967 + if (context->getShader(program))
1.2968 + {
1.2969 + return gl::error(GL_INVALID_OPERATION, -1);
1.2970 + }
1.2971 + else
1.2972 + {
1.2973 + return gl::error(GL_INVALID_VALUE, -1);
1.2974 + }
1.2975 + }
1.2976 +
1.2977 + gl::ProgramBinary *programBinary = programObject->getProgramBinary();
1.2978 + if (!programObject->isLinked() || !programBinary)
1.2979 + {
1.2980 + return gl::error(GL_INVALID_OPERATION, -1);
1.2981 + }
1.2982 +
1.2983 + return programBinary->getAttributeLocation(name);
1.2984 + }
1.2985 + }
1.2986 + catch(std::bad_alloc&)
1.2987 + {
1.2988 + return gl::error(GL_OUT_OF_MEMORY, -1);
1.2989 + }
1.2990 +
1.2991 + return -1;
1.2992 +}
1.2993 +
1.2994 +void __stdcall glGetBooleanv(GLenum pname, GLboolean* params)
1.2995 +{
1.2996 + EVENT("(GLenum pname = 0x%X, GLboolean* params = 0x%0.8p)", pname, params);
1.2997 +
1.2998 + try
1.2999 + {
1.3000 + gl::Context *context = gl::getNonLostContext();
1.3001 +
1.3002 + if (context)
1.3003 + {
1.3004 + if (!(context->getBooleanv(pname, params)))
1.3005 + {
1.3006 + GLenum nativeType;
1.3007 + unsigned int numParams = 0;
1.3008 + if (!context->getQueryParameterInfo(pname, &nativeType, &numParams))
1.3009 + return gl::error(GL_INVALID_ENUM);
1.3010 +
1.3011 + if (numParams == 0)
1.3012 + return; // it is known that the pname is valid, but there are no parameters to return
1.3013 +
1.3014 + if (nativeType == GL_FLOAT)
1.3015 + {
1.3016 + GLfloat *floatParams = NULL;
1.3017 + floatParams = new GLfloat[numParams];
1.3018 +
1.3019 + context->getFloatv(pname, floatParams);
1.3020 +
1.3021 + for (unsigned int i = 0; i < numParams; ++i)
1.3022 + {
1.3023 + if (floatParams[i] == 0.0f)
1.3024 + params[i] = GL_FALSE;
1.3025 + else
1.3026 + params[i] = GL_TRUE;
1.3027 + }
1.3028 +
1.3029 + delete [] floatParams;
1.3030 + }
1.3031 + else if (nativeType == GL_INT)
1.3032 + {
1.3033 + GLint *intParams = NULL;
1.3034 + intParams = new GLint[numParams];
1.3035 +
1.3036 + context->getIntegerv(pname, intParams);
1.3037 +
1.3038 + for (unsigned int i = 0; i < numParams; ++i)
1.3039 + {
1.3040 + if (intParams[i] == 0)
1.3041 + params[i] = GL_FALSE;
1.3042 + else
1.3043 + params[i] = GL_TRUE;
1.3044 + }
1.3045 +
1.3046 + delete [] intParams;
1.3047 + }
1.3048 + }
1.3049 + }
1.3050 + }
1.3051 + catch(std::bad_alloc&)
1.3052 + {
1.3053 + return gl::error(GL_OUT_OF_MEMORY);
1.3054 + }
1.3055 +}
1.3056 +
1.3057 +void __stdcall glGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
1.3058 +{
1.3059 + EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
1.3060 +
1.3061 + try
1.3062 + {
1.3063 + gl::Context *context = gl::getNonLostContext();
1.3064 +
1.3065 + if (context)
1.3066 + {
1.3067 + gl::Buffer *buffer;
1.3068 +
1.3069 + switch (target)
1.3070 + {
1.3071 + case GL_ARRAY_BUFFER:
1.3072 + buffer = context->getArrayBuffer();
1.3073 + break;
1.3074 + case GL_ELEMENT_ARRAY_BUFFER:
1.3075 + buffer = context->getElementArrayBuffer();
1.3076 + break;
1.3077 + default: return gl::error(GL_INVALID_ENUM);
1.3078 + }
1.3079 +
1.3080 + if (!buffer)
1.3081 + {
1.3082 + // A null buffer means that "0" is bound to the requested buffer target
1.3083 + return gl::error(GL_INVALID_OPERATION);
1.3084 + }
1.3085 +
1.3086 + switch (pname)
1.3087 + {
1.3088 + case GL_BUFFER_USAGE:
1.3089 + *params = buffer->usage();
1.3090 + break;
1.3091 + case GL_BUFFER_SIZE:
1.3092 + *params = buffer->size();
1.3093 + break;
1.3094 + default: return gl::error(GL_INVALID_ENUM);
1.3095 + }
1.3096 + }
1.3097 + }
1.3098 + catch(std::bad_alloc&)
1.3099 + {
1.3100 + return gl::error(GL_OUT_OF_MEMORY);
1.3101 + }
1.3102 +}
1.3103 +
1.3104 +GLenum __stdcall glGetError(void)
1.3105 +{
1.3106 + EVENT("()");
1.3107 +
1.3108 + gl::Context *context = gl::getContext();
1.3109 +
1.3110 + if (context)
1.3111 + {
1.3112 + return context->getError();
1.3113 + }
1.3114 +
1.3115 + return GL_NO_ERROR;
1.3116 +}
1.3117 +
1.3118 +void __stdcall glGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
1.3119 +{
1.3120 + EVENT("(GLuint fence = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", fence, pname, params);
1.3121 +
1.3122 + try
1.3123 + {
1.3124 +
1.3125 + gl::Context *context = gl::getNonLostContext();
1.3126 +
1.3127 + if (context)
1.3128 + {
1.3129 + gl::Fence *fenceObject = context->getFence(fence);
1.3130 +
1.3131 + if (fenceObject == NULL)
1.3132 + {
1.3133 + return gl::error(GL_INVALID_OPERATION);
1.3134 + }
1.3135 +
1.3136 + fenceObject->getFenceiv(pname, params);
1.3137 + }
1.3138 + }
1.3139 + catch(std::bad_alloc&)
1.3140 + {
1.3141 + return gl::error(GL_OUT_OF_MEMORY);
1.3142 + }
1.3143 +}
1.3144 +
1.3145 +void __stdcall glGetFloatv(GLenum pname, GLfloat* params)
1.3146 +{
1.3147 + EVENT("(GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", pname, params);
1.3148 +
1.3149 + try
1.3150 + {
1.3151 + gl::Context *context = gl::getNonLostContext();
1.3152 +
1.3153 + if (context)
1.3154 + {
1.3155 + if (!(context->getFloatv(pname, params)))
1.3156 + {
1.3157 + GLenum nativeType;
1.3158 + unsigned int numParams = 0;
1.3159 + if (!context->getQueryParameterInfo(pname, &nativeType, &numParams))
1.3160 + return gl::error(GL_INVALID_ENUM);
1.3161 +
1.3162 + if (numParams == 0)
1.3163 + return; // it is known that the pname is valid, but that there are no parameters to return.
1.3164 +
1.3165 + if (nativeType == GL_BOOL)
1.3166 + {
1.3167 + GLboolean *boolParams = NULL;
1.3168 + boolParams = new GLboolean[numParams];
1.3169 +
1.3170 + context->getBooleanv(pname, boolParams);
1.3171 +
1.3172 + for (unsigned int i = 0; i < numParams; ++i)
1.3173 + {
1.3174 + if (boolParams[i] == GL_FALSE)
1.3175 + params[i] = 0.0f;
1.3176 + else
1.3177 + params[i] = 1.0f;
1.3178 + }
1.3179 +
1.3180 + delete [] boolParams;
1.3181 + }
1.3182 + else if (nativeType == GL_INT)
1.3183 + {
1.3184 + GLint *intParams = NULL;
1.3185 + intParams = new GLint[numParams];
1.3186 +
1.3187 + context->getIntegerv(pname, intParams);
1.3188 +
1.3189 + for (unsigned int i = 0; i < numParams; ++i)
1.3190 + {
1.3191 + params[i] = (GLfloat)intParams[i];
1.3192 + }
1.3193 +
1.3194 + delete [] intParams;
1.3195 + }
1.3196 + }
1.3197 + }
1.3198 + }
1.3199 + catch(std::bad_alloc&)
1.3200 + {
1.3201 + return gl::error(GL_OUT_OF_MEMORY);
1.3202 + }
1.3203 +}
1.3204 +
1.3205 +void __stdcall glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
1.3206 +{
1.3207 + EVENT("(GLenum target = 0x%X, GLenum attachment = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)",
1.3208 + target, attachment, pname, params);
1.3209 +
1.3210 + try
1.3211 + {
1.3212 + gl::Context *context = gl::getNonLostContext();
1.3213 +
1.3214 + if (context)
1.3215 + {
1.3216 + if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER_ANGLE && target != GL_READ_FRAMEBUFFER_ANGLE)
1.3217 + {
1.3218 + return gl::error(GL_INVALID_ENUM);
1.3219 + }
1.3220 +
1.3221 + gl::Framebuffer *framebuffer = NULL;
1.3222 + if (target == GL_READ_FRAMEBUFFER_ANGLE)
1.3223 + {
1.3224 + if(context->getReadFramebufferHandle() == 0)
1.3225 + {
1.3226 + return gl::error(GL_INVALID_OPERATION);
1.3227 + }
1.3228 +
1.3229 + framebuffer = context->getReadFramebuffer();
1.3230 + }
1.3231 + else
1.3232 + {
1.3233 + if (context->getDrawFramebufferHandle() == 0)
1.3234 + {
1.3235 + return gl::error(GL_INVALID_OPERATION);
1.3236 + }
1.3237 +
1.3238 + framebuffer = context->getDrawFramebuffer();
1.3239 + }
1.3240 +
1.3241 + GLenum attachmentType;
1.3242 + GLuint attachmentHandle;
1.3243 +
1.3244 + if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
1.3245 + {
1.3246 + const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
1.3247 +
1.3248 + if (colorAttachment >= context->getMaximumRenderTargets())
1.3249 + {
1.3250 + return gl::error(GL_INVALID_ENUM);
1.3251 + }
1.3252 +
1.3253 + attachmentType = framebuffer->getColorbufferType(colorAttachment);
1.3254 + attachmentHandle = framebuffer->getColorbufferHandle(colorAttachment);
1.3255 + }
1.3256 + else
1.3257 + {
1.3258 + switch (attachment)
1.3259 + {
1.3260 + case GL_DEPTH_ATTACHMENT:
1.3261 + attachmentType = framebuffer->getDepthbufferType();
1.3262 + attachmentHandle = framebuffer->getDepthbufferHandle();
1.3263 + break;
1.3264 + case GL_STENCIL_ATTACHMENT:
1.3265 + attachmentType = framebuffer->getStencilbufferType();
1.3266 + attachmentHandle = framebuffer->getStencilbufferHandle();
1.3267 + break;
1.3268 + default: return gl::error(GL_INVALID_ENUM);
1.3269 + }
1.3270 + }
1.3271 +
1.3272 + GLenum attachmentObjectType; // Type category
1.3273 + if (attachmentType == GL_NONE || attachmentType == GL_RENDERBUFFER)
1.3274 + {
1.3275 + attachmentObjectType = attachmentType;
1.3276 + }
1.3277 + else if (gl::IsInternalTextureTarget(attachmentType))
1.3278 + {
1.3279 + attachmentObjectType = GL_TEXTURE;
1.3280 + }
1.3281 + else
1.3282 + {
1.3283 + UNREACHABLE();
1.3284 + return;
1.3285 + }
1.3286 +
1.3287 + switch (pname)
1.3288 + {
1.3289 + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
1.3290 + *params = attachmentObjectType;
1.3291 + break;
1.3292 + case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
1.3293 + if (attachmentObjectType == GL_RENDERBUFFER || attachmentObjectType == GL_TEXTURE)
1.3294 + {
1.3295 + *params = attachmentHandle;
1.3296 + }
1.3297 + else
1.3298 + {
1.3299 + return gl::error(GL_INVALID_ENUM);
1.3300 + }
1.3301 + break;
1.3302 + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
1.3303 + if (attachmentObjectType == GL_TEXTURE)
1.3304 + {
1.3305 + *params = 0; // FramebufferTexture2D will not allow level to be set to anything else in GL ES 2.0
1.3306 + }
1.3307 + else
1.3308 + {
1.3309 + return gl::error(GL_INVALID_ENUM);
1.3310 + }
1.3311 + break;
1.3312 + case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
1.3313 + if (attachmentObjectType == GL_TEXTURE)
1.3314 + {
1.3315 + if (gl::IsCubemapTextureTarget(attachmentType))
1.3316 + {
1.3317 + *params = attachmentType;
1.3318 + }
1.3319 + else
1.3320 + {
1.3321 + *params = 0;
1.3322 + }
1.3323 + }
1.3324 + else
1.3325 + {
1.3326 + return gl::error(GL_INVALID_ENUM);
1.3327 + }
1.3328 + break;
1.3329 + default:
1.3330 + return gl::error(GL_INVALID_ENUM);
1.3331 + }
1.3332 + }
1.3333 + }
1.3334 + catch(std::bad_alloc&)
1.3335 + {
1.3336 + return gl::error(GL_OUT_OF_MEMORY);
1.3337 + }
1.3338 +}
1.3339 +
1.3340 +GLenum __stdcall glGetGraphicsResetStatusEXT(void)
1.3341 +{
1.3342 + EVENT("()");
1.3343 +
1.3344 + try
1.3345 + {
1.3346 + gl::Context *context = gl::getContext();
1.3347 +
1.3348 + if (context)
1.3349 + {
1.3350 + return context->getResetStatus();
1.3351 + }
1.3352 +
1.3353 + return GL_NO_ERROR;
1.3354 + }
1.3355 + catch(std::bad_alloc&)
1.3356 + {
1.3357 + return GL_OUT_OF_MEMORY;
1.3358 + }
1.3359 +}
1.3360 +
1.3361 +void __stdcall glGetIntegerv(GLenum pname, GLint* params)
1.3362 +{
1.3363 + EVENT("(GLenum pname = 0x%X, GLint* params = 0x%0.8p)", pname, params);
1.3364 +
1.3365 + try
1.3366 + {
1.3367 + gl::Context *context = gl::getNonLostContext();
1.3368 +
1.3369 + if (context)
1.3370 + {
1.3371 + if (!(context->getIntegerv(pname, params)))
1.3372 + {
1.3373 + GLenum nativeType;
1.3374 + unsigned int numParams = 0;
1.3375 + if (!context->getQueryParameterInfo(pname, &nativeType, &numParams))
1.3376 + return gl::error(GL_INVALID_ENUM);
1.3377 +
1.3378 + if (numParams == 0)
1.3379 + return; // it is known that pname is valid, but there are no parameters to return
1.3380 +
1.3381 + if (nativeType == GL_BOOL)
1.3382 + {
1.3383 + GLboolean *boolParams = NULL;
1.3384 + boolParams = new GLboolean[numParams];
1.3385 +
1.3386 + context->getBooleanv(pname, boolParams);
1.3387 +
1.3388 + for (unsigned int i = 0; i < numParams; ++i)
1.3389 + {
1.3390 + if (boolParams[i] == GL_FALSE)
1.3391 + params[i] = 0;
1.3392 + else
1.3393 + params[i] = 1;
1.3394 + }
1.3395 +
1.3396 + delete [] boolParams;
1.3397 + }
1.3398 + else if (nativeType == GL_FLOAT)
1.3399 + {
1.3400 + GLfloat *floatParams = NULL;
1.3401 + floatParams = new GLfloat[numParams];
1.3402 +
1.3403 + context->getFloatv(pname, floatParams);
1.3404 +
1.3405 + for (unsigned int i = 0; i < numParams; ++i)
1.3406 + {
1.3407 + if (pname == GL_DEPTH_RANGE || pname == GL_COLOR_CLEAR_VALUE || pname == GL_DEPTH_CLEAR_VALUE || pname == GL_BLEND_COLOR)
1.3408 + {
1.3409 + params[i] = (GLint)(((GLfloat)(0xFFFFFFFF) * floatParams[i] - 1.0f) / 2.0f);
1.3410 + }
1.3411 + else
1.3412 + params[i] = (GLint)(floatParams[i] > 0.0f ? floor(floatParams[i] + 0.5) : ceil(floatParams[i] - 0.5));
1.3413 + }
1.3414 +
1.3415 + delete [] floatParams;
1.3416 + }
1.3417 + }
1.3418 + }
1.3419 + }
1.3420 + catch(std::bad_alloc&)
1.3421 + {
1.3422 + return gl::error(GL_OUT_OF_MEMORY);
1.3423 + }
1.3424 +}
1.3425 +
1.3426 +void __stdcall glGetProgramiv(GLuint program, GLenum pname, GLint* params)
1.3427 +{
1.3428 + EVENT("(GLuint program = %d, GLenum pname = %d, GLint* params = 0x%0.8p)", program, pname, params);
1.3429 +
1.3430 + try
1.3431 + {
1.3432 + gl::Context *context = gl::getNonLostContext();
1.3433 +
1.3434 + if (context)
1.3435 + {
1.3436 + gl::Program *programObject = context->getProgram(program);
1.3437 +
1.3438 + if (!programObject)
1.3439 + {
1.3440 + return gl::error(GL_INVALID_VALUE);
1.3441 + }
1.3442 +
1.3443 + switch (pname)
1.3444 + {
1.3445 + case GL_DELETE_STATUS:
1.3446 + *params = programObject->isFlaggedForDeletion();
1.3447 + return;
1.3448 + case GL_LINK_STATUS:
1.3449 + *params = programObject->isLinked();
1.3450 + return;
1.3451 + case GL_VALIDATE_STATUS:
1.3452 + *params = programObject->isValidated();
1.3453 + return;
1.3454 + case GL_INFO_LOG_LENGTH:
1.3455 + *params = programObject->getInfoLogLength();
1.3456 + return;
1.3457 + case GL_ATTACHED_SHADERS:
1.3458 + *params = programObject->getAttachedShadersCount();
1.3459 + return;
1.3460 + case GL_ACTIVE_ATTRIBUTES:
1.3461 + *params = programObject->getActiveAttributeCount();
1.3462 + return;
1.3463 + case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
1.3464 + *params = programObject->getActiveAttributeMaxLength();
1.3465 + return;
1.3466 + case GL_ACTIVE_UNIFORMS:
1.3467 + *params = programObject->getActiveUniformCount();
1.3468 + return;
1.3469 + case GL_ACTIVE_UNIFORM_MAX_LENGTH:
1.3470 + *params = programObject->getActiveUniformMaxLength();
1.3471 + return;
1.3472 + case GL_PROGRAM_BINARY_LENGTH_OES:
1.3473 + *params = programObject->getProgramBinaryLength();
1.3474 + return;
1.3475 + default:
1.3476 + return gl::error(GL_INVALID_ENUM);
1.3477 + }
1.3478 + }
1.3479 + }
1.3480 + catch(std::bad_alloc&)
1.3481 + {
1.3482 + return gl::error(GL_OUT_OF_MEMORY);
1.3483 + }
1.3484 +}
1.3485 +
1.3486 +void __stdcall glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog)
1.3487 +{
1.3488 + EVENT("(GLuint program = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* infolog = 0x%0.8p)",
1.3489 + program, bufsize, length, infolog);
1.3490 +
1.3491 + try
1.3492 + {
1.3493 + if (bufsize < 0)
1.3494 + {
1.3495 + return gl::error(GL_INVALID_VALUE);
1.3496 + }
1.3497 +
1.3498 + gl::Context *context = gl::getNonLostContext();
1.3499 +
1.3500 + if (context)
1.3501 + {
1.3502 + gl::Program *programObject = context->getProgram(program);
1.3503 +
1.3504 + if (!programObject)
1.3505 + {
1.3506 + return gl::error(GL_INVALID_VALUE);
1.3507 + }
1.3508 +
1.3509 + programObject->getInfoLog(bufsize, length, infolog);
1.3510 + }
1.3511 + }
1.3512 + catch(std::bad_alloc&)
1.3513 + {
1.3514 + return gl::error(GL_OUT_OF_MEMORY);
1.3515 + }
1.3516 +}
1.3517 +
1.3518 +void __stdcall glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
1.3519 +{
1.3520 + EVENT("GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname, params);
1.3521 +
1.3522 + try
1.3523 + {
1.3524 + switch (pname)
1.3525 + {
1.3526 + case GL_CURRENT_QUERY_EXT:
1.3527 + break;
1.3528 + default:
1.3529 + return gl::error(GL_INVALID_ENUM);
1.3530 + }
1.3531 +
1.3532 + gl::Context *context = gl::getNonLostContext();
1.3533 +
1.3534 + if (context)
1.3535 + {
1.3536 + params[0] = context->getActiveQuery(target);
1.3537 + }
1.3538 + }
1.3539 + catch(std::bad_alloc&)
1.3540 + {
1.3541 + return gl::error(GL_OUT_OF_MEMORY);
1.3542 + }
1.3543 +}
1.3544 +
1.3545 +void __stdcall glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
1.3546 +{
1.3547 + EVENT("(GLuint id = %d, GLenum pname = 0x%X, GLuint *params = 0x%0.8p)", id, pname, params);
1.3548 +
1.3549 + try
1.3550 + {
1.3551 + switch (pname)
1.3552 + {
1.3553 + case GL_QUERY_RESULT_EXT:
1.3554 + case GL_QUERY_RESULT_AVAILABLE_EXT:
1.3555 + break;
1.3556 + default:
1.3557 + return gl::error(GL_INVALID_ENUM);
1.3558 + }
1.3559 + gl::Context *context = gl::getNonLostContext();
1.3560 +
1.3561 + if (context)
1.3562 + {
1.3563 + gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
1.3564 +
1.3565 + if (!queryObject)
1.3566 + {
1.3567 + return gl::error(GL_INVALID_OPERATION);
1.3568 + }
1.3569 +
1.3570 + if (context->getActiveQuery(queryObject->getType()) == id)
1.3571 + {
1.3572 + return gl::error(GL_INVALID_OPERATION);
1.3573 + }
1.3574 +
1.3575 + switch(pname)
1.3576 + {
1.3577 + case GL_QUERY_RESULT_EXT:
1.3578 + params[0] = queryObject->getResult();
1.3579 + break;
1.3580 + case GL_QUERY_RESULT_AVAILABLE_EXT:
1.3581 + params[0] = queryObject->isResultAvailable();
1.3582 + break;
1.3583 + default:
1.3584 + ASSERT(false);
1.3585 + }
1.3586 + }
1.3587 + }
1.3588 + catch(std::bad_alloc&)
1.3589 + {
1.3590 + return gl::error(GL_OUT_OF_MEMORY);
1.3591 + }
1.3592 +}
1.3593 +
1.3594 +void __stdcall glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
1.3595 +{
1.3596 + EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
1.3597 +
1.3598 + try
1.3599 + {
1.3600 + gl::Context *context = gl::getNonLostContext();
1.3601 +
1.3602 + if (context)
1.3603 + {
1.3604 + if (target != GL_RENDERBUFFER)
1.3605 + {
1.3606 + return gl::error(GL_INVALID_ENUM);
1.3607 + }
1.3608 +
1.3609 + if (context->getRenderbufferHandle() == 0)
1.3610 + {
1.3611 + return gl::error(GL_INVALID_OPERATION);
1.3612 + }
1.3613 +
1.3614 + gl::Renderbuffer *renderbuffer = context->getRenderbuffer(context->getRenderbufferHandle());
1.3615 +
1.3616 + switch (pname)
1.3617 + {
1.3618 + case GL_RENDERBUFFER_WIDTH: *params = renderbuffer->getWidth(); break;
1.3619 + case GL_RENDERBUFFER_HEIGHT: *params = renderbuffer->getHeight(); break;
1.3620 + case GL_RENDERBUFFER_INTERNAL_FORMAT: *params = renderbuffer->getInternalFormat(); break;
1.3621 + case GL_RENDERBUFFER_RED_SIZE: *params = renderbuffer->getRedSize(); break;
1.3622 + case GL_RENDERBUFFER_GREEN_SIZE: *params = renderbuffer->getGreenSize(); break;
1.3623 + case GL_RENDERBUFFER_BLUE_SIZE: *params = renderbuffer->getBlueSize(); break;
1.3624 + case GL_RENDERBUFFER_ALPHA_SIZE: *params = renderbuffer->getAlphaSize(); break;
1.3625 + case GL_RENDERBUFFER_DEPTH_SIZE: *params = renderbuffer->getDepthSize(); break;
1.3626 + case GL_RENDERBUFFER_STENCIL_SIZE: *params = renderbuffer->getStencilSize(); break;
1.3627 + case GL_RENDERBUFFER_SAMPLES_ANGLE:
1.3628 + if (context->getMaxSupportedSamples() != 0)
1.3629 + {
1.3630 + *params = renderbuffer->getSamples();
1.3631 + }
1.3632 + else
1.3633 + {
1.3634 + return gl::error(GL_INVALID_ENUM);
1.3635 + }
1.3636 + break;
1.3637 + default:
1.3638 + return gl::error(GL_INVALID_ENUM);
1.3639 + }
1.3640 + }
1.3641 + }
1.3642 + catch(std::bad_alloc&)
1.3643 + {
1.3644 + return gl::error(GL_OUT_OF_MEMORY);
1.3645 + }
1.3646 +}
1.3647 +
1.3648 +void __stdcall glGetShaderiv(GLuint shader, GLenum pname, GLint* params)
1.3649 +{
1.3650 + EVENT("(GLuint shader = %d, GLenum pname = %d, GLint* params = 0x%0.8p)", shader, pname, params);
1.3651 +
1.3652 + try
1.3653 + {
1.3654 + gl::Context *context = gl::getNonLostContext();
1.3655 +
1.3656 + if (context)
1.3657 + {
1.3658 + gl::Shader *shaderObject = context->getShader(shader);
1.3659 +
1.3660 + if (!shaderObject)
1.3661 + {
1.3662 + return gl::error(GL_INVALID_VALUE);
1.3663 + }
1.3664 +
1.3665 + switch (pname)
1.3666 + {
1.3667 + case GL_SHADER_TYPE:
1.3668 + *params = shaderObject->getType();
1.3669 + return;
1.3670 + case GL_DELETE_STATUS:
1.3671 + *params = shaderObject->isFlaggedForDeletion();
1.3672 + return;
1.3673 + case GL_COMPILE_STATUS:
1.3674 + *params = shaderObject->isCompiled() ? GL_TRUE : GL_FALSE;
1.3675 + return;
1.3676 + case GL_INFO_LOG_LENGTH:
1.3677 + *params = shaderObject->getInfoLogLength();
1.3678 + return;
1.3679 + case GL_SHADER_SOURCE_LENGTH:
1.3680 + *params = shaderObject->getSourceLength();
1.3681 + return;
1.3682 + case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
1.3683 + *params = shaderObject->getTranslatedSourceLength();
1.3684 + return;
1.3685 + default:
1.3686 + return gl::error(GL_INVALID_ENUM);
1.3687 + }
1.3688 + }
1.3689 + }
1.3690 + catch(std::bad_alloc&)
1.3691 + {
1.3692 + return gl::error(GL_OUT_OF_MEMORY);
1.3693 + }
1.3694 +}
1.3695 +
1.3696 +void __stdcall glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog)
1.3697 +{
1.3698 + EVENT("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* infolog = 0x%0.8p)",
1.3699 + shader, bufsize, length, infolog);
1.3700 +
1.3701 + try
1.3702 + {
1.3703 + if (bufsize < 0)
1.3704 + {
1.3705 + return gl::error(GL_INVALID_VALUE);
1.3706 + }
1.3707 +
1.3708 + gl::Context *context = gl::getNonLostContext();
1.3709 +
1.3710 + if (context)
1.3711 + {
1.3712 + gl::Shader *shaderObject = context->getShader(shader);
1.3713 +
1.3714 + if (!shaderObject)
1.3715 + {
1.3716 + return gl::error(GL_INVALID_VALUE);
1.3717 + }
1.3718 +
1.3719 + shaderObject->getInfoLog(bufsize, length, infolog);
1.3720 + }
1.3721 + }
1.3722 + catch(std::bad_alloc&)
1.3723 + {
1.3724 + return gl::error(GL_OUT_OF_MEMORY);
1.3725 + }
1.3726 +}
1.3727 +
1.3728 +void __stdcall glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
1.3729 +{
1.3730 + EVENT("(GLenum shadertype = 0x%X, GLenum precisiontype = 0x%X, GLint* range = 0x%0.8p, GLint* precision = 0x%0.8p)",
1.3731 + shadertype, precisiontype, range, precision);
1.3732 +
1.3733 + try
1.3734 + {
1.3735 + switch (shadertype)
1.3736 + {
1.3737 + case GL_VERTEX_SHADER:
1.3738 + case GL_FRAGMENT_SHADER:
1.3739 + break;
1.3740 + default:
1.3741 + return gl::error(GL_INVALID_ENUM);
1.3742 + }
1.3743 +
1.3744 + switch (precisiontype)
1.3745 + {
1.3746 + case GL_LOW_FLOAT:
1.3747 + case GL_MEDIUM_FLOAT:
1.3748 + case GL_HIGH_FLOAT:
1.3749 + // Assume IEEE 754 precision
1.3750 + range[0] = 127;
1.3751 + range[1] = 127;
1.3752 + *precision = 23;
1.3753 + break;
1.3754 + case GL_LOW_INT:
1.3755 + case GL_MEDIUM_INT:
1.3756 + case GL_HIGH_INT:
1.3757 + // Some (most) hardware only supports single-precision floating-point numbers,
1.3758 + // which can accurately represent integers up to +/-16777216
1.3759 + range[0] = 24;
1.3760 + range[1] = 24;
1.3761 + *precision = 0;
1.3762 + break;
1.3763 + default:
1.3764 + return gl::error(GL_INVALID_ENUM);
1.3765 + }
1.3766 + }
1.3767 + catch(std::bad_alloc&)
1.3768 + {
1.3769 + return gl::error(GL_OUT_OF_MEMORY);
1.3770 + }
1.3771 +}
1.3772 +
1.3773 +void __stdcall glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
1.3774 +{
1.3775 + EVENT("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* source = 0x%0.8p)",
1.3776 + shader, bufsize, length, source);
1.3777 +
1.3778 + try
1.3779 + {
1.3780 + if (bufsize < 0)
1.3781 + {
1.3782 + return gl::error(GL_INVALID_VALUE);
1.3783 + }
1.3784 +
1.3785 + gl::Context *context = gl::getNonLostContext();
1.3786 +
1.3787 + if (context)
1.3788 + {
1.3789 + gl::Shader *shaderObject = context->getShader(shader);
1.3790 +
1.3791 + if (!shaderObject)
1.3792 + {
1.3793 + return gl::error(GL_INVALID_OPERATION);
1.3794 + }
1.3795 +
1.3796 + shaderObject->getSource(bufsize, length, source);
1.3797 + }
1.3798 + }
1.3799 + catch(std::bad_alloc&)
1.3800 + {
1.3801 + return gl::error(GL_OUT_OF_MEMORY);
1.3802 + }
1.3803 +}
1.3804 +
1.3805 +void __stdcall glGetTranslatedShaderSourceANGLE(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source)
1.3806 +{
1.3807 + EVENT("(GLuint shader = %d, GLsizei bufsize = %d, GLsizei* length = 0x%0.8p, GLchar* source = 0x%0.8p)",
1.3808 + shader, bufsize, length, source);
1.3809 +
1.3810 + try
1.3811 + {
1.3812 + if (bufsize < 0)
1.3813 + {
1.3814 + return gl::error(GL_INVALID_VALUE);
1.3815 + }
1.3816 +
1.3817 + gl::Context *context = gl::getNonLostContext();
1.3818 +
1.3819 + if (context)
1.3820 + {
1.3821 + gl::Shader *shaderObject = context->getShader(shader);
1.3822 +
1.3823 + if (!shaderObject)
1.3824 + {
1.3825 + return gl::error(GL_INVALID_OPERATION);
1.3826 + }
1.3827 +
1.3828 + shaderObject->getTranslatedSource(bufsize, length, source);
1.3829 + }
1.3830 + }
1.3831 + catch(std::bad_alloc&)
1.3832 + {
1.3833 + return gl::error(GL_OUT_OF_MEMORY);
1.3834 + }
1.3835 +}
1.3836 +
1.3837 +const GLubyte* __stdcall glGetString(GLenum name)
1.3838 +{
1.3839 + EVENT("(GLenum name = 0x%X)", name);
1.3840 +
1.3841 + try
1.3842 + {
1.3843 + gl::Context *context = gl::getNonLostContext();
1.3844 +
1.3845 + switch (name)
1.3846 + {
1.3847 + case GL_VENDOR:
1.3848 + return (GLubyte*)"Google Inc.";
1.3849 + case GL_RENDERER:
1.3850 + return (GLubyte*)((context != NULL) ? context->getRendererString() : "ANGLE");
1.3851 + case GL_VERSION:
1.3852 + return (GLubyte*)"OpenGL ES 2.0 (ANGLE " VERSION_STRING ")";
1.3853 + case GL_SHADING_LANGUAGE_VERSION:
1.3854 + return (GLubyte*)"OpenGL ES GLSL ES 1.00 (ANGLE " VERSION_STRING ")";
1.3855 + case GL_EXTENSIONS:
1.3856 + return (GLubyte*)((context != NULL) ? context->getExtensionString() : "");
1.3857 + default:
1.3858 + return gl::error(GL_INVALID_ENUM, (GLubyte*)NULL);
1.3859 + }
1.3860 + }
1.3861 + catch(std::bad_alloc&)
1.3862 + {
1.3863 + return gl::error(GL_OUT_OF_MEMORY, (GLubyte*)NULL);
1.3864 + }
1.3865 +}
1.3866 +
1.3867 +void __stdcall glGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
1.3868 +{
1.3869 + EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", target, pname, params);
1.3870 +
1.3871 + try
1.3872 + {
1.3873 + gl::Context *context = gl::getNonLostContext();
1.3874 +
1.3875 + if (context)
1.3876 + {
1.3877 + gl::Texture *texture;
1.3878 +
1.3879 + switch (target)
1.3880 + {
1.3881 + case GL_TEXTURE_2D:
1.3882 + texture = context->getTexture2D();
1.3883 + break;
1.3884 + case GL_TEXTURE_CUBE_MAP:
1.3885 + texture = context->getTextureCubeMap();
1.3886 + break;
1.3887 + default:
1.3888 + return gl::error(GL_INVALID_ENUM);
1.3889 + }
1.3890 +
1.3891 + switch (pname)
1.3892 + {
1.3893 + case GL_TEXTURE_MAG_FILTER:
1.3894 + *params = (GLfloat)texture->getMagFilter();
1.3895 + break;
1.3896 + case GL_TEXTURE_MIN_FILTER:
1.3897 + *params = (GLfloat)texture->getMinFilter();
1.3898 + break;
1.3899 + case GL_TEXTURE_WRAP_S:
1.3900 + *params = (GLfloat)texture->getWrapS();
1.3901 + break;
1.3902 + case GL_TEXTURE_WRAP_T:
1.3903 + *params = (GLfloat)texture->getWrapT();
1.3904 + break;
1.3905 + case GL_TEXTURE_IMMUTABLE_FORMAT_EXT:
1.3906 + *params = (GLfloat)(texture->isImmutable() ? GL_TRUE : GL_FALSE);
1.3907 + break;
1.3908 + case GL_TEXTURE_USAGE_ANGLE:
1.3909 + *params = (GLfloat)texture->getUsage();
1.3910 + break;
1.3911 + case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1.3912 + if (!context->supportsTextureFilterAnisotropy())
1.3913 + {
1.3914 + return gl::error(GL_INVALID_ENUM);
1.3915 + }
1.3916 + *params = (GLfloat)texture->getMaxAnisotropy();
1.3917 + break;
1.3918 + default:
1.3919 + return gl::error(GL_INVALID_ENUM);
1.3920 + }
1.3921 + }
1.3922 + }
1.3923 + catch(std::bad_alloc&)
1.3924 + {
1.3925 + return gl::error(GL_OUT_OF_MEMORY);
1.3926 + }
1.3927 +}
1.3928 +
1.3929 +void __stdcall glGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
1.3930 +{
1.3931 + EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", target, pname, params);
1.3932 +
1.3933 + try
1.3934 + {
1.3935 + gl::Context *context = gl::getNonLostContext();
1.3936 +
1.3937 + if (context)
1.3938 + {
1.3939 + gl::Texture *texture;
1.3940 +
1.3941 + switch (target)
1.3942 + {
1.3943 + case GL_TEXTURE_2D:
1.3944 + texture = context->getTexture2D();
1.3945 + break;
1.3946 + case GL_TEXTURE_CUBE_MAP:
1.3947 + texture = context->getTextureCubeMap();
1.3948 + break;
1.3949 + default:
1.3950 + return gl::error(GL_INVALID_ENUM);
1.3951 + }
1.3952 +
1.3953 + switch (pname)
1.3954 + {
1.3955 + case GL_TEXTURE_MAG_FILTER:
1.3956 + *params = texture->getMagFilter();
1.3957 + break;
1.3958 + case GL_TEXTURE_MIN_FILTER:
1.3959 + *params = texture->getMinFilter();
1.3960 + break;
1.3961 + case GL_TEXTURE_WRAP_S:
1.3962 + *params = texture->getWrapS();
1.3963 + break;
1.3964 + case GL_TEXTURE_WRAP_T:
1.3965 + *params = texture->getWrapT();
1.3966 + break;
1.3967 + case GL_TEXTURE_IMMUTABLE_FORMAT_EXT:
1.3968 + *params = texture->isImmutable() ? GL_TRUE : GL_FALSE;
1.3969 + break;
1.3970 + case GL_TEXTURE_USAGE_ANGLE:
1.3971 + *params = texture->getUsage();
1.3972 + break;
1.3973 + case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1.3974 + if (!context->supportsTextureFilterAnisotropy())
1.3975 + {
1.3976 + return gl::error(GL_INVALID_ENUM);
1.3977 + }
1.3978 + *params = (GLint)texture->getMaxAnisotropy();
1.3979 + break;
1.3980 + default:
1.3981 + return gl::error(GL_INVALID_ENUM);
1.3982 + }
1.3983 + }
1.3984 + }
1.3985 + catch(std::bad_alloc&)
1.3986 + {
1.3987 + return gl::error(GL_OUT_OF_MEMORY);
1.3988 + }
1.3989 +}
1.3990 +
1.3991 +void __stdcall glGetnUniformfvEXT(GLuint program, GLint location, GLsizei bufSize, GLfloat* params)
1.3992 +{
1.3993 + EVENT("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLfloat* params = 0x%0.8p)",
1.3994 + program, location, bufSize, params);
1.3995 +
1.3996 + try
1.3997 + {
1.3998 + if (bufSize < 0)
1.3999 + {
1.4000 + return gl::error(GL_INVALID_VALUE);
1.4001 + }
1.4002 +
1.4003 + gl::Context *context = gl::getNonLostContext();
1.4004 +
1.4005 + if (context)
1.4006 + {
1.4007 + if (program == 0)
1.4008 + {
1.4009 + return gl::error(GL_INVALID_VALUE);
1.4010 + }
1.4011 +
1.4012 + gl::Program *programObject = context->getProgram(program);
1.4013 +
1.4014 + if (!programObject || !programObject->isLinked())
1.4015 + {
1.4016 + return gl::error(GL_INVALID_OPERATION);
1.4017 + }
1.4018 +
1.4019 + gl::ProgramBinary *programBinary = programObject->getProgramBinary();
1.4020 + if (!programBinary)
1.4021 + {
1.4022 + return gl::error(GL_INVALID_OPERATION);
1.4023 + }
1.4024 +
1.4025 + if (!programBinary->getUniformfv(location, &bufSize, params))
1.4026 + {
1.4027 + return gl::error(GL_INVALID_OPERATION);
1.4028 + }
1.4029 + }
1.4030 + }
1.4031 + catch(std::bad_alloc&)
1.4032 + {
1.4033 + return gl::error(GL_OUT_OF_MEMORY);
1.4034 + }
1.4035 +}
1.4036 +
1.4037 +void __stdcall glGetUniformfv(GLuint program, GLint location, GLfloat* params)
1.4038 +{
1.4039 + EVENT("(GLuint program = %d, GLint location = %d, GLfloat* params = 0x%0.8p)", program, location, params);
1.4040 +
1.4041 + try
1.4042 + {
1.4043 + gl::Context *context = gl::getNonLostContext();
1.4044 +
1.4045 + if (context)
1.4046 + {
1.4047 + if (program == 0)
1.4048 + {
1.4049 + return gl::error(GL_INVALID_VALUE);
1.4050 + }
1.4051 +
1.4052 + gl::Program *programObject = context->getProgram(program);
1.4053 +
1.4054 + if (!programObject || !programObject->isLinked())
1.4055 + {
1.4056 + return gl::error(GL_INVALID_OPERATION);
1.4057 + }
1.4058 +
1.4059 + gl::ProgramBinary *programBinary = programObject->getProgramBinary();
1.4060 + if (!programBinary)
1.4061 + {
1.4062 + return gl::error(GL_INVALID_OPERATION);
1.4063 + }
1.4064 +
1.4065 + if (!programBinary->getUniformfv(location, NULL, params))
1.4066 + {
1.4067 + return gl::error(GL_INVALID_OPERATION);
1.4068 + }
1.4069 + }
1.4070 + }
1.4071 + catch(std::bad_alloc&)
1.4072 + {
1.4073 + return gl::error(GL_OUT_OF_MEMORY);
1.4074 + }
1.4075 +}
1.4076 +
1.4077 +void __stdcall glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint* params)
1.4078 +{
1.4079 + EVENT("(GLuint program = %d, GLint location = %d, GLsizei bufSize = %d, GLint* params = 0x%0.8p)",
1.4080 + program, location, bufSize, params);
1.4081 +
1.4082 + try
1.4083 + {
1.4084 + if (bufSize < 0)
1.4085 + {
1.4086 + return gl::error(GL_INVALID_VALUE);
1.4087 + }
1.4088 +
1.4089 + gl::Context *context = gl::getNonLostContext();
1.4090 +
1.4091 + if (context)
1.4092 + {
1.4093 + if (program == 0)
1.4094 + {
1.4095 + return gl::error(GL_INVALID_VALUE);
1.4096 + }
1.4097 +
1.4098 + gl::Program *programObject = context->getProgram(program);
1.4099 +
1.4100 + if (!programObject || !programObject->isLinked())
1.4101 + {
1.4102 + return gl::error(GL_INVALID_OPERATION);
1.4103 + }
1.4104 +
1.4105 + gl::ProgramBinary *programBinary = programObject->getProgramBinary();
1.4106 + if (!programBinary)
1.4107 + {
1.4108 + return gl::error(GL_INVALID_OPERATION);
1.4109 + }
1.4110 +
1.4111 + if (!programBinary->getUniformiv(location, &bufSize, params))
1.4112 + {
1.4113 + return gl::error(GL_INVALID_OPERATION);
1.4114 + }
1.4115 + }
1.4116 + }
1.4117 + catch(std::bad_alloc&)
1.4118 + {
1.4119 + return gl::error(GL_OUT_OF_MEMORY);
1.4120 + }
1.4121 +}
1.4122 +
1.4123 +void __stdcall glGetUniformiv(GLuint program, GLint location, GLint* params)
1.4124 +{
1.4125 + EVENT("(GLuint program = %d, GLint location = %d, GLint* params = 0x%0.8p)", program, location, params);
1.4126 +
1.4127 + try
1.4128 + {
1.4129 + gl::Context *context = gl::getNonLostContext();
1.4130 +
1.4131 + if (context)
1.4132 + {
1.4133 + if (program == 0)
1.4134 + {
1.4135 + return gl::error(GL_INVALID_VALUE);
1.4136 + }
1.4137 +
1.4138 + gl::Program *programObject = context->getProgram(program);
1.4139 +
1.4140 + if (!programObject || !programObject->isLinked())
1.4141 + {
1.4142 + return gl::error(GL_INVALID_OPERATION);
1.4143 + }
1.4144 +
1.4145 + gl::ProgramBinary *programBinary = programObject->getProgramBinary();
1.4146 + if (!programBinary)
1.4147 + {
1.4148 + return gl::error(GL_INVALID_OPERATION);
1.4149 + }
1.4150 +
1.4151 + if (!programBinary->getUniformiv(location, NULL, params))
1.4152 + {
1.4153 + return gl::error(GL_INVALID_OPERATION);
1.4154 + }
1.4155 + }
1.4156 + }
1.4157 + catch(std::bad_alloc&)
1.4158 + {
1.4159 + return gl::error(GL_OUT_OF_MEMORY);
1.4160 + }
1.4161 +}
1.4162 +
1.4163 +int __stdcall glGetUniformLocation(GLuint program, const GLchar* name)
1.4164 +{
1.4165 + EVENT("(GLuint program = %d, const GLchar* name = 0x%0.8p)", program, name);
1.4166 +
1.4167 + try
1.4168 + {
1.4169 + gl::Context *context = gl::getNonLostContext();
1.4170 +
1.4171 + if (strstr(name, "gl_") == name)
1.4172 + {
1.4173 + return -1;
1.4174 + }
1.4175 +
1.4176 + if (context)
1.4177 + {
1.4178 + gl::Program *programObject = context->getProgram(program);
1.4179 +
1.4180 + if (!programObject)
1.4181 + {
1.4182 + if (context->getShader(program))
1.4183 + {
1.4184 + return gl::error(GL_INVALID_OPERATION, -1);
1.4185 + }
1.4186 + else
1.4187 + {
1.4188 + return gl::error(GL_INVALID_VALUE, -1);
1.4189 + }
1.4190 + }
1.4191 +
1.4192 + gl::ProgramBinary *programBinary = programObject->getProgramBinary();
1.4193 + if (!programObject->isLinked() || !programBinary)
1.4194 + {
1.4195 + return gl::error(GL_INVALID_OPERATION, -1);
1.4196 + }
1.4197 +
1.4198 + return programBinary->getUniformLocation(name);
1.4199 + }
1.4200 + }
1.4201 + catch(std::bad_alloc&)
1.4202 + {
1.4203 + return gl::error(GL_OUT_OF_MEMORY, -1);
1.4204 + }
1.4205 +
1.4206 + return -1;
1.4207 +}
1.4208 +
1.4209 +void __stdcall glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
1.4210 +{
1.4211 + EVENT("(GLuint index = %d, GLenum pname = 0x%X, GLfloat* params = 0x%0.8p)", index, pname, params);
1.4212 +
1.4213 + try
1.4214 + {
1.4215 + gl::Context *context = gl::getNonLostContext();
1.4216 +
1.4217 + if (context)
1.4218 + {
1.4219 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.4220 + {
1.4221 + return gl::error(GL_INVALID_VALUE);
1.4222 + }
1.4223 +
1.4224 + const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
1.4225 +
1.4226 + switch (pname)
1.4227 + {
1.4228 + case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
1.4229 + *params = (GLfloat)(attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
1.4230 + break;
1.4231 + case GL_VERTEX_ATTRIB_ARRAY_SIZE:
1.4232 + *params = (GLfloat)attribState.mSize;
1.4233 + break;
1.4234 + case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
1.4235 + *params = (GLfloat)attribState.mStride;
1.4236 + break;
1.4237 + case GL_VERTEX_ATTRIB_ARRAY_TYPE:
1.4238 + *params = (GLfloat)attribState.mType;
1.4239 + break;
1.4240 + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
1.4241 + *params = (GLfloat)(attribState.mNormalized ? GL_TRUE : GL_FALSE);
1.4242 + break;
1.4243 + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
1.4244 + *params = (GLfloat)attribState.mBoundBuffer.id();
1.4245 + break;
1.4246 + case GL_CURRENT_VERTEX_ATTRIB:
1.4247 + for (int i = 0; i < 4; ++i)
1.4248 + {
1.4249 + params[i] = attribState.mCurrentValue[i];
1.4250 + }
1.4251 + break;
1.4252 + case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE:
1.4253 + *params = (GLfloat)attribState.mDivisor;
1.4254 + break;
1.4255 + default: return gl::error(GL_INVALID_ENUM);
1.4256 + }
1.4257 + }
1.4258 + }
1.4259 + catch(std::bad_alloc&)
1.4260 + {
1.4261 + return gl::error(GL_OUT_OF_MEMORY);
1.4262 + }
1.4263 +}
1.4264 +
1.4265 +void __stdcall glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
1.4266 +{
1.4267 + EVENT("(GLuint index = %d, GLenum pname = 0x%X, GLint* params = 0x%0.8p)", index, pname, params);
1.4268 +
1.4269 + try
1.4270 + {
1.4271 + gl::Context *context = gl::getNonLostContext();
1.4272 +
1.4273 + if (context)
1.4274 + {
1.4275 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.4276 + {
1.4277 + return gl::error(GL_INVALID_VALUE);
1.4278 + }
1.4279 +
1.4280 + const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
1.4281 +
1.4282 + switch (pname)
1.4283 + {
1.4284 + case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
1.4285 + *params = (attribState.mArrayEnabled ? GL_TRUE : GL_FALSE);
1.4286 + break;
1.4287 + case GL_VERTEX_ATTRIB_ARRAY_SIZE:
1.4288 + *params = attribState.mSize;
1.4289 + break;
1.4290 + case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
1.4291 + *params = attribState.mStride;
1.4292 + break;
1.4293 + case GL_VERTEX_ATTRIB_ARRAY_TYPE:
1.4294 + *params = attribState.mType;
1.4295 + break;
1.4296 + case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
1.4297 + *params = (attribState.mNormalized ? GL_TRUE : GL_FALSE);
1.4298 + break;
1.4299 + case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
1.4300 + *params = attribState.mBoundBuffer.id();
1.4301 + break;
1.4302 + case GL_CURRENT_VERTEX_ATTRIB:
1.4303 + for (int i = 0; i < 4; ++i)
1.4304 + {
1.4305 + float currentValue = attribState.mCurrentValue[i];
1.4306 + params[i] = (GLint)(currentValue > 0.0f ? floor(currentValue + 0.5f) : ceil(currentValue - 0.5f));
1.4307 + }
1.4308 + break;
1.4309 + case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE:
1.4310 + *params = (GLint)attribState.mDivisor;
1.4311 + break;
1.4312 + default: return gl::error(GL_INVALID_ENUM);
1.4313 + }
1.4314 + }
1.4315 + }
1.4316 + catch(std::bad_alloc&)
1.4317 + {
1.4318 + return gl::error(GL_OUT_OF_MEMORY);
1.4319 + }
1.4320 +}
1.4321 +
1.4322 +void __stdcall glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** pointer)
1.4323 +{
1.4324 + EVENT("(GLuint index = %d, GLenum pname = 0x%X, GLvoid** pointer = 0x%0.8p)", index, pname, pointer);
1.4325 +
1.4326 + try
1.4327 + {
1.4328 + gl::Context *context = gl::getNonLostContext();
1.4329 +
1.4330 + if (context)
1.4331 + {
1.4332 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.4333 + {
1.4334 + return gl::error(GL_INVALID_VALUE);
1.4335 + }
1.4336 +
1.4337 + if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
1.4338 + {
1.4339 + return gl::error(GL_INVALID_ENUM);
1.4340 + }
1.4341 +
1.4342 + *pointer = const_cast<GLvoid*>(context->getVertexAttribPointer(index));
1.4343 + }
1.4344 + }
1.4345 + catch(std::bad_alloc&)
1.4346 + {
1.4347 + return gl::error(GL_OUT_OF_MEMORY);
1.4348 + }
1.4349 +}
1.4350 +
1.4351 +void __stdcall glHint(GLenum target, GLenum mode)
1.4352 +{
1.4353 + EVENT("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);
1.4354 +
1.4355 + try
1.4356 + {
1.4357 + switch (mode)
1.4358 + {
1.4359 + case GL_FASTEST:
1.4360 + case GL_NICEST:
1.4361 + case GL_DONT_CARE:
1.4362 + break;
1.4363 + default:
1.4364 + return gl::error(GL_INVALID_ENUM);
1.4365 + }
1.4366 +
1.4367 + gl::Context *context = gl::getNonLostContext();
1.4368 + switch (target)
1.4369 + {
1.4370 + case GL_GENERATE_MIPMAP_HINT:
1.4371 + if (context) context->setGenerateMipmapHint(mode);
1.4372 + break;
1.4373 + case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
1.4374 + if (context) context->setFragmentShaderDerivativeHint(mode);
1.4375 + break;
1.4376 + default:
1.4377 + return gl::error(GL_INVALID_ENUM);
1.4378 + }
1.4379 + }
1.4380 + catch(std::bad_alloc&)
1.4381 + {
1.4382 + return gl::error(GL_OUT_OF_MEMORY);
1.4383 + }
1.4384 +}
1.4385 +
1.4386 +GLboolean __stdcall glIsBuffer(GLuint buffer)
1.4387 +{
1.4388 + EVENT("(GLuint buffer = %d)", buffer);
1.4389 +
1.4390 + try
1.4391 + {
1.4392 + gl::Context *context = gl::getNonLostContext();
1.4393 +
1.4394 + if (context && buffer)
1.4395 + {
1.4396 + gl::Buffer *bufferObject = context->getBuffer(buffer);
1.4397 +
1.4398 + if (bufferObject)
1.4399 + {
1.4400 + return GL_TRUE;
1.4401 + }
1.4402 + }
1.4403 + }
1.4404 + catch(std::bad_alloc&)
1.4405 + {
1.4406 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4407 + }
1.4408 +
1.4409 + return GL_FALSE;
1.4410 +}
1.4411 +
1.4412 +GLboolean __stdcall glIsEnabled(GLenum cap)
1.4413 +{
1.4414 + EVENT("(GLenum cap = 0x%X)", cap);
1.4415 +
1.4416 + try
1.4417 + {
1.4418 + gl::Context *context = gl::getNonLostContext();
1.4419 +
1.4420 + if (context)
1.4421 + {
1.4422 + switch (cap)
1.4423 + {
1.4424 + case GL_CULL_FACE: return context->isCullFaceEnabled();
1.4425 + case GL_POLYGON_OFFSET_FILL: return context->isPolygonOffsetFillEnabled();
1.4426 + case GL_SAMPLE_ALPHA_TO_COVERAGE: return context->isSampleAlphaToCoverageEnabled();
1.4427 + case GL_SAMPLE_COVERAGE: return context->isSampleCoverageEnabled();
1.4428 + case GL_SCISSOR_TEST: return context->isScissorTestEnabled();
1.4429 + case GL_STENCIL_TEST: return context->isStencilTestEnabled();
1.4430 + case GL_DEPTH_TEST: return context->isDepthTestEnabled();
1.4431 + case GL_BLEND: return context->isBlendEnabled();
1.4432 + case GL_DITHER: return context->isDitherEnabled();
1.4433 + default:
1.4434 + return gl::error(GL_INVALID_ENUM, false);
1.4435 + }
1.4436 + }
1.4437 + }
1.4438 + catch(std::bad_alloc&)
1.4439 + {
1.4440 + return gl::error(GL_OUT_OF_MEMORY, false);
1.4441 + }
1.4442 +
1.4443 + return false;
1.4444 +}
1.4445 +
1.4446 +GLboolean __stdcall glIsFenceNV(GLuint fence)
1.4447 +{
1.4448 + EVENT("(GLuint fence = %d)", fence);
1.4449 +
1.4450 + try
1.4451 + {
1.4452 + gl::Context *context = gl::getNonLostContext();
1.4453 +
1.4454 + if (context)
1.4455 + {
1.4456 + gl::Fence *fenceObject = context->getFence(fence);
1.4457 +
1.4458 + if (fenceObject == NULL)
1.4459 + {
1.4460 + return GL_FALSE;
1.4461 + }
1.4462 +
1.4463 + return fenceObject->isFence();
1.4464 + }
1.4465 + }
1.4466 + catch(std::bad_alloc&)
1.4467 + {
1.4468 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4469 + }
1.4470 +
1.4471 + return GL_FALSE;
1.4472 +}
1.4473 +
1.4474 +GLboolean __stdcall glIsFramebuffer(GLuint framebuffer)
1.4475 +{
1.4476 + EVENT("(GLuint framebuffer = %d)", framebuffer);
1.4477 +
1.4478 + try
1.4479 + {
1.4480 + gl::Context *context = gl::getNonLostContext();
1.4481 +
1.4482 + if (context && framebuffer)
1.4483 + {
1.4484 + gl::Framebuffer *framebufferObject = context->getFramebuffer(framebuffer);
1.4485 +
1.4486 + if (framebufferObject)
1.4487 + {
1.4488 + return GL_TRUE;
1.4489 + }
1.4490 + }
1.4491 + }
1.4492 + catch(std::bad_alloc&)
1.4493 + {
1.4494 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4495 + }
1.4496 +
1.4497 + return GL_FALSE;
1.4498 +}
1.4499 +
1.4500 +GLboolean __stdcall glIsProgram(GLuint program)
1.4501 +{
1.4502 + EVENT("(GLuint program = %d)", program);
1.4503 +
1.4504 + try
1.4505 + {
1.4506 + gl::Context *context = gl::getNonLostContext();
1.4507 +
1.4508 + if (context && program)
1.4509 + {
1.4510 + gl::Program *programObject = context->getProgram(program);
1.4511 +
1.4512 + if (programObject)
1.4513 + {
1.4514 + return GL_TRUE;
1.4515 + }
1.4516 + }
1.4517 + }
1.4518 + catch(std::bad_alloc&)
1.4519 + {
1.4520 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4521 + }
1.4522 +
1.4523 + return GL_FALSE;
1.4524 +}
1.4525 +
1.4526 +GLboolean __stdcall glIsQueryEXT(GLuint id)
1.4527 +{
1.4528 + EVENT("(GLuint id = %d)", id);
1.4529 +
1.4530 + try
1.4531 + {
1.4532 + if (id == 0)
1.4533 + {
1.4534 + return GL_FALSE;
1.4535 + }
1.4536 +
1.4537 + gl::Context *context = gl::getNonLostContext();
1.4538 +
1.4539 + if (context)
1.4540 + {
1.4541 + gl::Query *queryObject = context->getQuery(id, false, GL_NONE);
1.4542 +
1.4543 + if (queryObject)
1.4544 + {
1.4545 + return GL_TRUE;
1.4546 + }
1.4547 + }
1.4548 + }
1.4549 + catch(std::bad_alloc&)
1.4550 + {
1.4551 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4552 + }
1.4553 +
1.4554 + return GL_FALSE;
1.4555 +}
1.4556 +
1.4557 +GLboolean __stdcall glIsRenderbuffer(GLuint renderbuffer)
1.4558 +{
1.4559 + EVENT("(GLuint renderbuffer = %d)", renderbuffer);
1.4560 +
1.4561 + try
1.4562 + {
1.4563 + gl::Context *context = gl::getNonLostContext();
1.4564 +
1.4565 + if (context && renderbuffer)
1.4566 + {
1.4567 + gl::Renderbuffer *renderbufferObject = context->getRenderbuffer(renderbuffer);
1.4568 +
1.4569 + if (renderbufferObject)
1.4570 + {
1.4571 + return GL_TRUE;
1.4572 + }
1.4573 + }
1.4574 + }
1.4575 + catch(std::bad_alloc&)
1.4576 + {
1.4577 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4578 + }
1.4579 +
1.4580 + return GL_FALSE;
1.4581 +}
1.4582 +
1.4583 +GLboolean __stdcall glIsShader(GLuint shader)
1.4584 +{
1.4585 + EVENT("(GLuint shader = %d)", shader);
1.4586 +
1.4587 + try
1.4588 + {
1.4589 + gl::Context *context = gl::getNonLostContext();
1.4590 +
1.4591 + if (context && shader)
1.4592 + {
1.4593 + gl::Shader *shaderObject = context->getShader(shader);
1.4594 +
1.4595 + if (shaderObject)
1.4596 + {
1.4597 + return GL_TRUE;
1.4598 + }
1.4599 + }
1.4600 + }
1.4601 + catch(std::bad_alloc&)
1.4602 + {
1.4603 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4604 + }
1.4605 +
1.4606 + return GL_FALSE;
1.4607 +}
1.4608 +
1.4609 +GLboolean __stdcall glIsTexture(GLuint texture)
1.4610 +{
1.4611 + EVENT("(GLuint texture = %d)", texture);
1.4612 +
1.4613 + try
1.4614 + {
1.4615 + gl::Context *context = gl::getNonLostContext();
1.4616 +
1.4617 + if (context && texture)
1.4618 + {
1.4619 + gl::Texture *textureObject = context->getTexture(texture);
1.4620 +
1.4621 + if (textureObject)
1.4622 + {
1.4623 + return GL_TRUE;
1.4624 + }
1.4625 + }
1.4626 + }
1.4627 + catch(std::bad_alloc&)
1.4628 + {
1.4629 + return gl::error(GL_OUT_OF_MEMORY, GL_FALSE);
1.4630 + }
1.4631 +
1.4632 + return GL_FALSE;
1.4633 +}
1.4634 +
1.4635 +void __stdcall glLineWidth(GLfloat width)
1.4636 +{
1.4637 + EVENT("(GLfloat width = %f)", width);
1.4638 +
1.4639 + try
1.4640 + {
1.4641 + if (width <= 0.0f)
1.4642 + {
1.4643 + return gl::error(GL_INVALID_VALUE);
1.4644 + }
1.4645 +
1.4646 + gl::Context *context = gl::getNonLostContext();
1.4647 +
1.4648 + if (context)
1.4649 + {
1.4650 + context->setLineWidth(width);
1.4651 + }
1.4652 + }
1.4653 + catch(std::bad_alloc&)
1.4654 + {
1.4655 + return gl::error(GL_OUT_OF_MEMORY);
1.4656 + }
1.4657 +}
1.4658 +
1.4659 +void __stdcall glLinkProgram(GLuint program)
1.4660 +{
1.4661 + EVENT("(GLuint program = %d)", program);
1.4662 +
1.4663 + try
1.4664 + {
1.4665 + gl::Context *context = gl::getNonLostContext();
1.4666 +
1.4667 + if (context)
1.4668 + {
1.4669 + gl::Program *programObject = context->getProgram(program);
1.4670 +
1.4671 + if (!programObject)
1.4672 + {
1.4673 + if (context->getShader(program))
1.4674 + {
1.4675 + return gl::error(GL_INVALID_OPERATION);
1.4676 + }
1.4677 + else
1.4678 + {
1.4679 + return gl::error(GL_INVALID_VALUE);
1.4680 + }
1.4681 + }
1.4682 +
1.4683 + context->linkProgram(program);
1.4684 + }
1.4685 + }
1.4686 + catch(std::bad_alloc&)
1.4687 + {
1.4688 + return gl::error(GL_OUT_OF_MEMORY);
1.4689 + }
1.4690 +}
1.4691 +
1.4692 +void __stdcall glPixelStorei(GLenum pname, GLint param)
1.4693 +{
1.4694 + EVENT("(GLenum pname = 0x%X, GLint param = %d)", pname, param);
1.4695 +
1.4696 + try
1.4697 + {
1.4698 + gl::Context *context = gl::getNonLostContext();
1.4699 +
1.4700 + if (context)
1.4701 + {
1.4702 + switch (pname)
1.4703 + {
1.4704 + case GL_UNPACK_ALIGNMENT:
1.4705 + if (param != 1 && param != 2 && param != 4 && param != 8)
1.4706 + {
1.4707 + return gl::error(GL_INVALID_VALUE);
1.4708 + }
1.4709 +
1.4710 + context->setUnpackAlignment(param);
1.4711 + break;
1.4712 +
1.4713 + case GL_PACK_ALIGNMENT:
1.4714 + if (param != 1 && param != 2 && param != 4 && param != 8)
1.4715 + {
1.4716 + return gl::error(GL_INVALID_VALUE);
1.4717 + }
1.4718 +
1.4719 + context->setPackAlignment(param);
1.4720 + break;
1.4721 +
1.4722 + case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
1.4723 + context->setPackReverseRowOrder(param != 0);
1.4724 + break;
1.4725 +
1.4726 + default:
1.4727 + return gl::error(GL_INVALID_ENUM);
1.4728 + }
1.4729 + }
1.4730 + }
1.4731 + catch(std::bad_alloc&)
1.4732 + {
1.4733 + return gl::error(GL_OUT_OF_MEMORY);
1.4734 + }
1.4735 +}
1.4736 +
1.4737 +void __stdcall glPolygonOffset(GLfloat factor, GLfloat units)
1.4738 +{
1.4739 + EVENT("(GLfloat factor = %f, GLfloat units = %f)", factor, units);
1.4740 +
1.4741 + try
1.4742 + {
1.4743 + gl::Context *context = gl::getNonLostContext();
1.4744 +
1.4745 + if (context)
1.4746 + {
1.4747 + context->setPolygonOffsetParams(factor, units);
1.4748 + }
1.4749 + }
1.4750 + catch(std::bad_alloc&)
1.4751 + {
1.4752 + return gl::error(GL_OUT_OF_MEMORY);
1.4753 + }
1.4754 +}
1.4755 +
1.4756 +void __stdcall glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
1.4757 + GLenum format, GLenum type, GLsizei bufSize,
1.4758 + GLvoid *data)
1.4759 +{
1.4760 + EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
1.4761 + "GLenum format = 0x%X, GLenum type = 0x%X, GLsizei bufSize = 0x%d, GLvoid *data = 0x%0.8p)",
1.4762 + x, y, width, height, format, type, bufSize, data);
1.4763 +
1.4764 + try
1.4765 + {
1.4766 + if (width < 0 || height < 0 || bufSize < 0)
1.4767 + {
1.4768 + return gl::error(GL_INVALID_VALUE);
1.4769 + }
1.4770 +
1.4771 + gl::Context *context = gl::getNonLostContext();
1.4772 +
1.4773 + if (context)
1.4774 + {
1.4775 + GLenum currentFormat, currentType;
1.4776 +
1.4777 + // Failure in getCurrentReadFormatType indicates that no color attachment is currently bound,
1.4778 + // and attempting to read back if that's the case is an error. The error will be registered
1.4779 + // by getCurrentReadFormat.
1.4780 + if (!context->getCurrentReadFormatType(¤tFormat, ¤tType))
1.4781 + return;
1.4782 +
1.4783 + if (!(currentFormat == format && currentType == type) && !validReadFormatType(format, type))
1.4784 + {
1.4785 + return gl::error(GL_INVALID_OPERATION);
1.4786 + }
1.4787 +
1.4788 + context->readPixels(x, y, width, height, format, type, &bufSize, data);
1.4789 + }
1.4790 + }
1.4791 + catch(std::bad_alloc&)
1.4792 + {
1.4793 + return gl::error(GL_OUT_OF_MEMORY);
1.4794 + }
1.4795 +}
1.4796 +
1.4797 +void __stdcall glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
1.4798 + GLenum format, GLenum type, GLvoid* pixels)
1.4799 +{
1.4800 + EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
1.4801 + "GLenum format = 0x%X, GLenum type = 0x%X, GLvoid* pixels = 0x%0.8p)",
1.4802 + x, y, width, height, format, type, pixels);
1.4803 +
1.4804 + try
1.4805 + {
1.4806 + if (width < 0 || height < 0)
1.4807 + {
1.4808 + return gl::error(GL_INVALID_VALUE);
1.4809 + }
1.4810 +
1.4811 + gl::Context *context = gl::getNonLostContext();
1.4812 +
1.4813 + if (context)
1.4814 + {
1.4815 + GLenum currentFormat, currentType;
1.4816 +
1.4817 + // Failure in getCurrentReadFormatType indicates that no color attachment is currently bound,
1.4818 + // and attempting to read back if that's the case is an error. The error will be registered
1.4819 + // by getCurrentReadFormat.
1.4820 + if (!context->getCurrentReadFormatType(¤tFormat, ¤tType))
1.4821 + return;
1.4822 +
1.4823 + if (!(currentFormat == format && currentType == type) && !validReadFormatType(format, type))
1.4824 + {
1.4825 + return gl::error(GL_INVALID_OPERATION);
1.4826 + }
1.4827 +
1.4828 + context->readPixels(x, y, width, height, format, type, NULL, pixels);
1.4829 + }
1.4830 + }
1.4831 + catch(std::bad_alloc&)
1.4832 + {
1.4833 + return gl::error(GL_OUT_OF_MEMORY);
1.4834 + }
1.4835 +}
1.4836 +
1.4837 +void __stdcall glReleaseShaderCompiler(void)
1.4838 +{
1.4839 + EVENT("()");
1.4840 +
1.4841 + try
1.4842 + {
1.4843 + gl::Shader::releaseCompiler();
1.4844 + }
1.4845 + catch(std::bad_alloc&)
1.4846 + {
1.4847 + return gl::error(GL_OUT_OF_MEMORY);
1.4848 + }
1.4849 +}
1.4850 +
1.4851 +void __stdcall glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
1.4852 +{
1.4853 + EVENT("(GLenum target = 0x%X, GLsizei samples = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
1.4854 + target, samples, internalformat, width, height);
1.4855 +
1.4856 + try
1.4857 + {
1.4858 + switch (target)
1.4859 + {
1.4860 + case GL_RENDERBUFFER:
1.4861 + break;
1.4862 + default:
1.4863 + return gl::error(GL_INVALID_ENUM);
1.4864 + }
1.4865 +
1.4866 + if (!gl::IsColorRenderable(internalformat) && !gl::IsDepthRenderable(internalformat) && !gl::IsStencilRenderable(internalformat))
1.4867 + {
1.4868 + return gl::error(GL_INVALID_ENUM);
1.4869 + }
1.4870 +
1.4871 + if (width < 0 || height < 0 || samples < 0)
1.4872 + {
1.4873 + return gl::error(GL_INVALID_VALUE);
1.4874 + }
1.4875 +
1.4876 + gl::Context *context = gl::getNonLostContext();
1.4877 +
1.4878 + if (context)
1.4879 + {
1.4880 + if (width > context->getMaximumRenderbufferDimension() ||
1.4881 + height > context->getMaximumRenderbufferDimension() ||
1.4882 + samples > context->getMaxSupportedSamples())
1.4883 + {
1.4884 + return gl::error(GL_INVALID_VALUE);
1.4885 + }
1.4886 +
1.4887 + GLuint handle = context->getRenderbufferHandle();
1.4888 + if (handle == 0)
1.4889 + {
1.4890 + return gl::error(GL_INVALID_OPERATION);
1.4891 + }
1.4892 +
1.4893 + switch (internalformat)
1.4894 + {
1.4895 + case GL_DEPTH_COMPONENT16:
1.4896 + case GL_RGBA4:
1.4897 + case GL_RGB5_A1:
1.4898 + case GL_RGB565:
1.4899 + case GL_RGB8_OES:
1.4900 + case GL_RGBA8_OES:
1.4901 + case GL_STENCIL_INDEX8:
1.4902 + case GL_DEPTH24_STENCIL8_OES:
1.4903 + context->setRenderbufferStorage(width, height, internalformat, samples);
1.4904 + break;
1.4905 + default:
1.4906 + return gl::error(GL_INVALID_ENUM);
1.4907 + }
1.4908 + }
1.4909 + }
1.4910 + catch(std::bad_alloc&)
1.4911 + {
1.4912 + return gl::error(GL_OUT_OF_MEMORY);
1.4913 + }
1.4914 +}
1.4915 +
1.4916 +void __stdcall glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
1.4917 +{
1.4918 + glRenderbufferStorageMultisampleANGLE(target, 0, internalformat, width, height);
1.4919 +}
1.4920 +
1.4921 +void __stdcall glSampleCoverage(GLclampf value, GLboolean invert)
1.4922 +{
1.4923 + EVENT("(GLclampf value = %f, GLboolean invert = %d)", value, invert);
1.4924 +
1.4925 + try
1.4926 + {
1.4927 + gl::Context* context = gl::getNonLostContext();
1.4928 +
1.4929 + if (context)
1.4930 + {
1.4931 + context->setSampleCoverageParams(gl::clamp01(value), invert == GL_TRUE);
1.4932 + }
1.4933 + }
1.4934 + catch(std::bad_alloc&)
1.4935 + {
1.4936 + return gl::error(GL_OUT_OF_MEMORY);
1.4937 + }
1.4938 +}
1.4939 +
1.4940 +void __stdcall glSetFenceNV(GLuint fence, GLenum condition)
1.4941 +{
1.4942 + EVENT("(GLuint fence = %d, GLenum condition = 0x%X)", fence, condition);
1.4943 +
1.4944 + try
1.4945 + {
1.4946 + if (condition != GL_ALL_COMPLETED_NV)
1.4947 + {
1.4948 + return gl::error(GL_INVALID_ENUM);
1.4949 + }
1.4950 +
1.4951 + gl::Context *context = gl::getNonLostContext();
1.4952 +
1.4953 + if (context)
1.4954 + {
1.4955 + gl::Fence *fenceObject = context->getFence(fence);
1.4956 +
1.4957 + if (fenceObject == NULL)
1.4958 + {
1.4959 + return gl::error(GL_INVALID_OPERATION);
1.4960 + }
1.4961 +
1.4962 + fenceObject->setFence(condition);
1.4963 + }
1.4964 + }
1.4965 + catch(std::bad_alloc&)
1.4966 + {
1.4967 + return gl::error(GL_OUT_OF_MEMORY);
1.4968 + }
1.4969 +}
1.4970 +
1.4971 +void __stdcall glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
1.4972 +{
1.4973 + EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);
1.4974 +
1.4975 + try
1.4976 + {
1.4977 + if (width < 0 || height < 0)
1.4978 + {
1.4979 + return gl::error(GL_INVALID_VALUE);
1.4980 + }
1.4981 +
1.4982 + gl::Context* context = gl::getNonLostContext();
1.4983 +
1.4984 + if (context)
1.4985 + {
1.4986 + context->setScissorParams(x, y, width, height);
1.4987 + }
1.4988 + }
1.4989 + catch(std::bad_alloc&)
1.4990 + {
1.4991 + return gl::error(GL_OUT_OF_MEMORY);
1.4992 + }
1.4993 +}
1.4994 +
1.4995 +void __stdcall glShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length)
1.4996 +{
1.4997 + EVENT("(GLsizei n = %d, const GLuint* shaders = 0x%0.8p, GLenum binaryformat = 0x%X, "
1.4998 + "const GLvoid* binary = 0x%0.8p, GLsizei length = %d)",
1.4999 + n, shaders, binaryformat, binary, length);
1.5000 +
1.5001 + try
1.5002 + {
1.5003 + // No binary shader formats are supported.
1.5004 + return gl::error(GL_INVALID_ENUM);
1.5005 + }
1.5006 + catch(std::bad_alloc&)
1.5007 + {
1.5008 + return gl::error(GL_OUT_OF_MEMORY);
1.5009 + }
1.5010 +}
1.5011 +
1.5012 +void __stdcall glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length)
1.5013 +{
1.5014 + EVENT("(GLuint shader = %d, GLsizei count = %d, const GLchar** string = 0x%0.8p, const GLint* length = 0x%0.8p)",
1.5015 + shader, count, string, length);
1.5016 +
1.5017 + try
1.5018 + {
1.5019 + if (count < 0)
1.5020 + {
1.5021 + return gl::error(GL_INVALID_VALUE);
1.5022 + }
1.5023 +
1.5024 + gl::Context *context = gl::getNonLostContext();
1.5025 +
1.5026 + if (context)
1.5027 + {
1.5028 + gl::Shader *shaderObject = context->getShader(shader);
1.5029 +
1.5030 + if (!shaderObject)
1.5031 + {
1.5032 + if (context->getProgram(shader))
1.5033 + {
1.5034 + return gl::error(GL_INVALID_OPERATION);
1.5035 + }
1.5036 + else
1.5037 + {
1.5038 + return gl::error(GL_INVALID_VALUE);
1.5039 + }
1.5040 + }
1.5041 +
1.5042 + shaderObject->setSource(count, string, length);
1.5043 + }
1.5044 + }
1.5045 + catch(std::bad_alloc&)
1.5046 + {
1.5047 + return gl::error(GL_OUT_OF_MEMORY);
1.5048 + }
1.5049 +}
1.5050 +
1.5051 +void __stdcall glStencilFunc(GLenum func, GLint ref, GLuint mask)
1.5052 +{
1.5053 + glStencilFuncSeparate(GL_FRONT_AND_BACK, func, ref, mask);
1.5054 +}
1.5055 +
1.5056 +void __stdcall glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
1.5057 +{
1.5058 + EVENT("(GLenum face = 0x%X, GLenum func = 0x%X, GLint ref = %d, GLuint mask = %d)", face, func, ref, mask);
1.5059 +
1.5060 + try
1.5061 + {
1.5062 + switch (face)
1.5063 + {
1.5064 + case GL_FRONT:
1.5065 + case GL_BACK:
1.5066 + case GL_FRONT_AND_BACK:
1.5067 + break;
1.5068 + default:
1.5069 + return gl::error(GL_INVALID_ENUM);
1.5070 + }
1.5071 +
1.5072 + switch (func)
1.5073 + {
1.5074 + case GL_NEVER:
1.5075 + case GL_ALWAYS:
1.5076 + case GL_LESS:
1.5077 + case GL_LEQUAL:
1.5078 + case GL_EQUAL:
1.5079 + case GL_GEQUAL:
1.5080 + case GL_GREATER:
1.5081 + case GL_NOTEQUAL:
1.5082 + break;
1.5083 + default:
1.5084 + return gl::error(GL_INVALID_ENUM);
1.5085 + }
1.5086 +
1.5087 + gl::Context *context = gl::getNonLostContext();
1.5088 +
1.5089 + if (context)
1.5090 + {
1.5091 + if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
1.5092 + {
1.5093 + context->setStencilParams(func, ref, mask);
1.5094 + }
1.5095 +
1.5096 + if (face == GL_BACK || face == GL_FRONT_AND_BACK)
1.5097 + {
1.5098 + context->setStencilBackParams(func, ref, mask);
1.5099 + }
1.5100 + }
1.5101 + }
1.5102 + catch(std::bad_alloc&)
1.5103 + {
1.5104 + return gl::error(GL_OUT_OF_MEMORY);
1.5105 + }
1.5106 +}
1.5107 +
1.5108 +void __stdcall glStencilMask(GLuint mask)
1.5109 +{
1.5110 + glStencilMaskSeparate(GL_FRONT_AND_BACK, mask);
1.5111 +}
1.5112 +
1.5113 +void __stdcall glStencilMaskSeparate(GLenum face, GLuint mask)
1.5114 +{
1.5115 + EVENT("(GLenum face = 0x%X, GLuint mask = %d)", face, mask);
1.5116 +
1.5117 + try
1.5118 + {
1.5119 + switch (face)
1.5120 + {
1.5121 + case GL_FRONT:
1.5122 + case GL_BACK:
1.5123 + case GL_FRONT_AND_BACK:
1.5124 + break;
1.5125 + default:
1.5126 + return gl::error(GL_INVALID_ENUM);
1.5127 + }
1.5128 +
1.5129 + gl::Context *context = gl::getNonLostContext();
1.5130 +
1.5131 + if (context)
1.5132 + {
1.5133 + if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
1.5134 + {
1.5135 + context->setStencilWritemask(mask);
1.5136 + }
1.5137 +
1.5138 + if (face == GL_BACK || face == GL_FRONT_AND_BACK)
1.5139 + {
1.5140 + context->setStencilBackWritemask(mask);
1.5141 + }
1.5142 + }
1.5143 + }
1.5144 + catch(std::bad_alloc&)
1.5145 + {
1.5146 + return gl::error(GL_OUT_OF_MEMORY);
1.5147 + }
1.5148 +}
1.5149 +
1.5150 +void __stdcall glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1.5151 +{
1.5152 + glStencilOpSeparate(GL_FRONT_AND_BACK, fail, zfail, zpass);
1.5153 +}
1.5154 +
1.5155 +void __stdcall glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
1.5156 +{
1.5157 + EVENT("(GLenum face = 0x%X, GLenum fail = 0x%X, GLenum zfail = 0x%X, GLenum zpas = 0x%Xs)",
1.5158 + face, fail, zfail, zpass);
1.5159 +
1.5160 + try
1.5161 + {
1.5162 + switch (face)
1.5163 + {
1.5164 + case GL_FRONT:
1.5165 + case GL_BACK:
1.5166 + case GL_FRONT_AND_BACK:
1.5167 + break;
1.5168 + default:
1.5169 + return gl::error(GL_INVALID_ENUM);
1.5170 + }
1.5171 +
1.5172 + switch (fail)
1.5173 + {
1.5174 + case GL_ZERO:
1.5175 + case GL_KEEP:
1.5176 + case GL_REPLACE:
1.5177 + case GL_INCR:
1.5178 + case GL_DECR:
1.5179 + case GL_INVERT:
1.5180 + case GL_INCR_WRAP:
1.5181 + case GL_DECR_WRAP:
1.5182 + break;
1.5183 + default:
1.5184 + return gl::error(GL_INVALID_ENUM);
1.5185 + }
1.5186 +
1.5187 + switch (zfail)
1.5188 + {
1.5189 + case GL_ZERO:
1.5190 + case GL_KEEP:
1.5191 + case GL_REPLACE:
1.5192 + case GL_INCR:
1.5193 + case GL_DECR:
1.5194 + case GL_INVERT:
1.5195 + case GL_INCR_WRAP:
1.5196 + case GL_DECR_WRAP:
1.5197 + break;
1.5198 + default:
1.5199 + return gl::error(GL_INVALID_ENUM);
1.5200 + }
1.5201 +
1.5202 + switch (zpass)
1.5203 + {
1.5204 + case GL_ZERO:
1.5205 + case GL_KEEP:
1.5206 + case GL_REPLACE:
1.5207 + case GL_INCR:
1.5208 + case GL_DECR:
1.5209 + case GL_INVERT:
1.5210 + case GL_INCR_WRAP:
1.5211 + case GL_DECR_WRAP:
1.5212 + break;
1.5213 + default:
1.5214 + return gl::error(GL_INVALID_ENUM);
1.5215 + }
1.5216 +
1.5217 + gl::Context *context = gl::getNonLostContext();
1.5218 +
1.5219 + if (context)
1.5220 + {
1.5221 + if (face == GL_FRONT || face == GL_FRONT_AND_BACK)
1.5222 + {
1.5223 + context->setStencilOperations(fail, zfail, zpass);
1.5224 + }
1.5225 +
1.5226 + if (face == GL_BACK || face == GL_FRONT_AND_BACK)
1.5227 + {
1.5228 + context->setStencilBackOperations(fail, zfail, zpass);
1.5229 + }
1.5230 + }
1.5231 + }
1.5232 + catch(std::bad_alloc&)
1.5233 + {
1.5234 + return gl::error(GL_OUT_OF_MEMORY);
1.5235 + }
1.5236 +}
1.5237 +
1.5238 +GLboolean __stdcall glTestFenceNV(GLuint fence)
1.5239 +{
1.5240 + EVENT("(GLuint fence = %d)", fence);
1.5241 +
1.5242 + try
1.5243 + {
1.5244 + gl::Context *context = gl::getNonLostContext();
1.5245 +
1.5246 + if (context)
1.5247 + {
1.5248 + gl::Fence *fenceObject = context->getFence(fence);
1.5249 +
1.5250 + if (fenceObject == NULL)
1.5251 + {
1.5252 + return gl::error(GL_INVALID_OPERATION, GL_TRUE);
1.5253 + }
1.5254 +
1.5255 + return fenceObject->testFence();
1.5256 + }
1.5257 + }
1.5258 + catch(std::bad_alloc&)
1.5259 + {
1.5260 + gl::error(GL_OUT_OF_MEMORY);
1.5261 + }
1.5262 +
1.5263 + return GL_TRUE;
1.5264 +}
1.5265 +
1.5266 +void __stdcall glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height,
1.5267 + GLint border, GLenum format, GLenum type, const GLvoid* pixels)
1.5268 +{
1.5269 + EVENT("(GLenum target = 0x%X, GLint level = %d, GLint internalformat = %d, GLsizei width = %d, GLsizei height = %d, "
1.5270 + "GLint border = %d, GLenum format = 0x%X, GLenum type = 0x%X, const GLvoid* pixels = 0x%0.8p)",
1.5271 + target, level, internalformat, width, height, border, format, type, pixels);
1.5272 +
1.5273 + try
1.5274 + {
1.5275 + if (!validImageSize(level, width, height))
1.5276 + {
1.5277 + return gl::error(GL_INVALID_VALUE);
1.5278 + }
1.5279 +
1.5280 + if (internalformat != GLint(format))
1.5281 + {
1.5282 + return gl::error(GL_INVALID_OPERATION);
1.5283 + }
1.5284 +
1.5285 + // validate <type> by itself (used as secondary key below)
1.5286 + switch (type)
1.5287 + {
1.5288 + case GL_UNSIGNED_BYTE:
1.5289 + case GL_UNSIGNED_SHORT_5_6_5:
1.5290 + case GL_UNSIGNED_SHORT_4_4_4_4:
1.5291 + case GL_UNSIGNED_SHORT_5_5_5_1:
1.5292 + case GL_UNSIGNED_SHORT:
1.5293 + case GL_UNSIGNED_INT:
1.5294 + case GL_UNSIGNED_INT_24_8_OES:
1.5295 + case GL_HALF_FLOAT_OES:
1.5296 + case GL_FLOAT:
1.5297 + break;
1.5298 + default:
1.5299 + return gl::error(GL_INVALID_ENUM);
1.5300 + }
1.5301 +
1.5302 + // validate <format> + <type> combinations
1.5303 + // - invalid <format> -> sets INVALID_ENUM
1.5304 + // - invalid <format>+<type> combination -> sets INVALID_OPERATION
1.5305 + switch (format)
1.5306 + {
1.5307 + case GL_ALPHA:
1.5308 + case GL_LUMINANCE:
1.5309 + case GL_LUMINANCE_ALPHA:
1.5310 + switch (type)
1.5311 + {
1.5312 + case GL_UNSIGNED_BYTE:
1.5313 + case GL_FLOAT:
1.5314 + case GL_HALF_FLOAT_OES:
1.5315 + break;
1.5316 + default:
1.5317 + return gl::error(GL_INVALID_OPERATION);
1.5318 + }
1.5319 + break;
1.5320 + case GL_RGB:
1.5321 + switch (type)
1.5322 + {
1.5323 + case GL_UNSIGNED_BYTE:
1.5324 + case GL_UNSIGNED_SHORT_5_6_5:
1.5325 + case GL_FLOAT:
1.5326 + case GL_HALF_FLOAT_OES:
1.5327 + break;
1.5328 + default:
1.5329 + return gl::error(GL_INVALID_OPERATION);
1.5330 + }
1.5331 + break;
1.5332 + case GL_RGBA:
1.5333 + switch (type)
1.5334 + {
1.5335 + case GL_UNSIGNED_BYTE:
1.5336 + case GL_UNSIGNED_SHORT_4_4_4_4:
1.5337 + case GL_UNSIGNED_SHORT_5_5_5_1:
1.5338 + case GL_FLOAT:
1.5339 + case GL_HALF_FLOAT_OES:
1.5340 + break;
1.5341 + default:
1.5342 + return gl::error(GL_INVALID_OPERATION);
1.5343 + }
1.5344 + break;
1.5345 + case GL_BGRA_EXT:
1.5346 + switch (type)
1.5347 + {
1.5348 + case GL_UNSIGNED_BYTE:
1.5349 + break;
1.5350 + default:
1.5351 + return gl::error(GL_INVALID_OPERATION);
1.5352 + }
1.5353 + break;
1.5354 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: // error cases for compressed textures are handled below
1.5355 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.5356 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.5357 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.5358 + break;
1.5359 + case GL_DEPTH_COMPONENT:
1.5360 + switch (type)
1.5361 + {
1.5362 + case GL_UNSIGNED_SHORT:
1.5363 + case GL_UNSIGNED_INT:
1.5364 + break;
1.5365 + default:
1.5366 + return gl::error(GL_INVALID_OPERATION);
1.5367 + }
1.5368 + break;
1.5369 + case GL_DEPTH_STENCIL_OES:
1.5370 + switch (type)
1.5371 + {
1.5372 + case GL_UNSIGNED_INT_24_8_OES:
1.5373 + break;
1.5374 + default:
1.5375 + return gl::error(GL_INVALID_OPERATION);
1.5376 + }
1.5377 + break;
1.5378 + default:
1.5379 + return gl::error(GL_INVALID_ENUM);
1.5380 + }
1.5381 +
1.5382 + if (border != 0)
1.5383 + {
1.5384 + return gl::error(GL_INVALID_VALUE);
1.5385 + }
1.5386 +
1.5387 + gl::Context *context = gl::getNonLostContext();
1.5388 +
1.5389 + if (context)
1.5390 + {
1.5391 + if (level > context->getMaximumTextureLevel())
1.5392 + {
1.5393 + return gl::error(GL_INVALID_VALUE);
1.5394 + }
1.5395 +
1.5396 + switch (target)
1.5397 + {
1.5398 + case GL_TEXTURE_2D:
1.5399 + if (width > (context->getMaximumTextureDimension() >> level) ||
1.5400 + height > (context->getMaximumTextureDimension() >> level))
1.5401 + {
1.5402 + return gl::error(GL_INVALID_VALUE);
1.5403 + }
1.5404 + break;
1.5405 + case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1.5406 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1.5407 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1.5408 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1.5409 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1.5410 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1.5411 + if (width != height)
1.5412 + {
1.5413 + return gl::error(GL_INVALID_VALUE);
1.5414 + }
1.5415 +
1.5416 + if (width > (context->getMaximumCubeTextureDimension() >> level) ||
1.5417 + height > (context->getMaximumCubeTextureDimension() >> level))
1.5418 + {
1.5419 + return gl::error(GL_INVALID_VALUE);
1.5420 + }
1.5421 + break;
1.5422 + default:
1.5423 + return gl::error(GL_INVALID_ENUM);
1.5424 + }
1.5425 +
1.5426 + switch (format) {
1.5427 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.5428 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.5429 + if (context->supportsDXT1Textures())
1.5430 + {
1.5431 + return gl::error(GL_INVALID_OPERATION);
1.5432 + }
1.5433 + else
1.5434 + {
1.5435 + return gl::error(GL_INVALID_ENUM);
1.5436 + }
1.5437 + break;
1.5438 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.5439 + if (context->supportsDXT3Textures())
1.5440 + {
1.5441 + return gl::error(GL_INVALID_OPERATION);
1.5442 + }
1.5443 + else
1.5444 + {
1.5445 + return gl::error(GL_INVALID_ENUM);
1.5446 + }
1.5447 + break;
1.5448 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.5449 + if (context->supportsDXT5Textures())
1.5450 + {
1.5451 + return gl::error(GL_INVALID_OPERATION);
1.5452 + }
1.5453 + else
1.5454 + {
1.5455 + return gl::error(GL_INVALID_ENUM);
1.5456 + }
1.5457 + break;
1.5458 + case GL_DEPTH_COMPONENT:
1.5459 + case GL_DEPTH_STENCIL_OES:
1.5460 + if (!context->supportsDepthTextures())
1.5461 + {
1.5462 + return gl::error(GL_INVALID_VALUE);
1.5463 + }
1.5464 + if (target != GL_TEXTURE_2D)
1.5465 + {
1.5466 + return gl::error(GL_INVALID_OPERATION);
1.5467 + }
1.5468 + // OES_depth_texture supports loading depth data and multiple levels,
1.5469 + // but ANGLE_depth_texture does not
1.5470 + if (pixels != NULL || level != 0)
1.5471 + {
1.5472 + return gl::error(GL_INVALID_OPERATION);
1.5473 + }
1.5474 + break;
1.5475 + default:
1.5476 + break;
1.5477 + }
1.5478 +
1.5479 + if (type == GL_FLOAT)
1.5480 + {
1.5481 + if (!context->supportsFloat32Textures())
1.5482 + {
1.5483 + return gl::error(GL_INVALID_ENUM);
1.5484 + }
1.5485 + }
1.5486 + else if (type == GL_HALF_FLOAT_OES)
1.5487 + {
1.5488 + if (!context->supportsFloat16Textures())
1.5489 + {
1.5490 + return gl::error(GL_INVALID_ENUM);
1.5491 + }
1.5492 + }
1.5493 +
1.5494 + if (target == GL_TEXTURE_2D)
1.5495 + {
1.5496 + gl::Texture2D *texture = context->getTexture2D();
1.5497 +
1.5498 + if (!texture)
1.5499 + {
1.5500 + return gl::error(GL_INVALID_OPERATION);
1.5501 + }
1.5502 +
1.5503 + if (texture->isImmutable())
1.5504 + {
1.5505 + return gl::error(GL_INVALID_OPERATION);
1.5506 + }
1.5507 +
1.5508 + texture->setImage(level, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5509 + }
1.5510 + else
1.5511 + {
1.5512 + gl::TextureCubeMap *texture = context->getTextureCubeMap();
1.5513 +
1.5514 + if (!texture)
1.5515 + {
1.5516 + return gl::error(GL_INVALID_OPERATION);
1.5517 + }
1.5518 +
1.5519 + if (texture->isImmutable())
1.5520 + {
1.5521 + return gl::error(GL_INVALID_OPERATION);
1.5522 + }
1.5523 +
1.5524 + switch (target)
1.5525 + {
1.5526 + case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
1.5527 + texture->setImagePosX(level, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5528 + break;
1.5529 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
1.5530 + texture->setImageNegX(level, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5531 + break;
1.5532 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
1.5533 + texture->setImagePosY(level, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5534 + break;
1.5535 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
1.5536 + texture->setImageNegY(level, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5537 + break;
1.5538 + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
1.5539 + texture->setImagePosZ(level, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5540 + break;
1.5541 + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
1.5542 + texture->setImageNegZ(level, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5543 + break;
1.5544 + default: UNREACHABLE();
1.5545 + }
1.5546 + }
1.5547 + }
1.5548 + }
1.5549 + catch(std::bad_alloc&)
1.5550 + {
1.5551 + return gl::error(GL_OUT_OF_MEMORY);
1.5552 + }
1.5553 +}
1.5554 +
1.5555 +void __stdcall glTexParameterf(GLenum target, GLenum pname, GLfloat param)
1.5556 +{
1.5557 + EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %f)", target, pname, param);
1.5558 +
1.5559 + try
1.5560 + {
1.5561 + gl::Context *context = gl::getNonLostContext();
1.5562 +
1.5563 + if (context)
1.5564 + {
1.5565 + gl::Texture *texture;
1.5566 +
1.5567 + switch (target)
1.5568 + {
1.5569 + case GL_TEXTURE_2D:
1.5570 + texture = context->getTexture2D();
1.5571 + break;
1.5572 + case GL_TEXTURE_CUBE_MAP:
1.5573 + texture = context->getTextureCubeMap();
1.5574 + break;
1.5575 + default:
1.5576 + return gl::error(GL_INVALID_ENUM);
1.5577 + }
1.5578 +
1.5579 + switch (pname)
1.5580 + {
1.5581 + case GL_TEXTURE_WRAP_S:
1.5582 + if (!texture->setWrapS((GLenum)param))
1.5583 + {
1.5584 + return gl::error(GL_INVALID_ENUM);
1.5585 + }
1.5586 + break;
1.5587 + case GL_TEXTURE_WRAP_T:
1.5588 + if (!texture->setWrapT((GLenum)param))
1.5589 + {
1.5590 + return gl::error(GL_INVALID_ENUM);
1.5591 + }
1.5592 + break;
1.5593 + case GL_TEXTURE_MIN_FILTER:
1.5594 + if (!texture->setMinFilter((GLenum)param))
1.5595 + {
1.5596 + return gl::error(GL_INVALID_ENUM);
1.5597 + }
1.5598 + break;
1.5599 + case GL_TEXTURE_MAG_FILTER:
1.5600 + if (!texture->setMagFilter((GLenum)param))
1.5601 + {
1.5602 + return gl::error(GL_INVALID_ENUM);
1.5603 + }
1.5604 + break;
1.5605 + case GL_TEXTURE_USAGE_ANGLE:
1.5606 + if (!texture->setUsage((GLenum)param))
1.5607 + {
1.5608 + return gl::error(GL_INVALID_ENUM);
1.5609 + }
1.5610 + break;
1.5611 + case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1.5612 + if (!context->supportsTextureFilterAnisotropy())
1.5613 + {
1.5614 + return gl::error(GL_INVALID_ENUM);
1.5615 + }
1.5616 + if (!texture->setMaxAnisotropy((float)param, context->getTextureMaxAnisotropy()))
1.5617 + {
1.5618 + return gl::error(GL_INVALID_VALUE);
1.5619 + }
1.5620 + break;
1.5621 + default:
1.5622 + return gl::error(GL_INVALID_ENUM);
1.5623 + }
1.5624 + }
1.5625 + }
1.5626 + catch(std::bad_alloc&)
1.5627 + {
1.5628 + return gl::error(GL_OUT_OF_MEMORY);
1.5629 + }
1.5630 +}
1.5631 +
1.5632 +void __stdcall glTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
1.5633 +{
1.5634 + glTexParameterf(target, pname, (GLfloat)*params);
1.5635 +}
1.5636 +
1.5637 +void __stdcall glTexParameteri(GLenum target, GLenum pname, GLint param)
1.5638 +{
1.5639 + EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint param = %d)", target, pname, param);
1.5640 +
1.5641 + try
1.5642 + {
1.5643 + gl::Context *context = gl::getNonLostContext();
1.5644 +
1.5645 + if (context)
1.5646 + {
1.5647 + gl::Texture *texture;
1.5648 +
1.5649 + switch (target)
1.5650 + {
1.5651 + case GL_TEXTURE_2D:
1.5652 + texture = context->getTexture2D();
1.5653 + break;
1.5654 + case GL_TEXTURE_CUBE_MAP:
1.5655 + texture = context->getTextureCubeMap();
1.5656 + break;
1.5657 + default:
1.5658 + return gl::error(GL_INVALID_ENUM);
1.5659 + }
1.5660 +
1.5661 + switch (pname)
1.5662 + {
1.5663 + case GL_TEXTURE_WRAP_S:
1.5664 + if (!texture->setWrapS((GLenum)param))
1.5665 + {
1.5666 + return gl::error(GL_INVALID_ENUM);
1.5667 + }
1.5668 + break;
1.5669 + case GL_TEXTURE_WRAP_T:
1.5670 + if (!texture->setWrapT((GLenum)param))
1.5671 + {
1.5672 + return gl::error(GL_INVALID_ENUM);
1.5673 + }
1.5674 + break;
1.5675 + case GL_TEXTURE_MIN_FILTER:
1.5676 + if (!texture->setMinFilter((GLenum)param))
1.5677 + {
1.5678 + return gl::error(GL_INVALID_ENUM);
1.5679 + }
1.5680 + break;
1.5681 + case GL_TEXTURE_MAG_FILTER:
1.5682 + if (!texture->setMagFilter((GLenum)param))
1.5683 + {
1.5684 + return gl::error(GL_INVALID_ENUM);
1.5685 + }
1.5686 + break;
1.5687 + case GL_TEXTURE_USAGE_ANGLE:
1.5688 + if (!texture->setUsage((GLenum)param))
1.5689 + {
1.5690 + return gl::error(GL_INVALID_ENUM);
1.5691 + }
1.5692 + break;
1.5693 + case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1.5694 + if (!context->supportsTextureFilterAnisotropy())
1.5695 + {
1.5696 + return gl::error(GL_INVALID_ENUM);
1.5697 + }
1.5698 + if (!texture->setMaxAnisotropy((float)param, context->getTextureMaxAnisotropy()))
1.5699 + {
1.5700 + return gl::error(GL_INVALID_VALUE);
1.5701 + }
1.5702 + break;
1.5703 + default:
1.5704 + return gl::error(GL_INVALID_ENUM);
1.5705 + }
1.5706 + }
1.5707 + }
1.5708 + catch(std::bad_alloc&)
1.5709 + {
1.5710 + return gl::error(GL_OUT_OF_MEMORY);
1.5711 + }
1.5712 +}
1.5713 +
1.5714 +void __stdcall glTexParameteriv(GLenum target, GLenum pname, const GLint* params)
1.5715 +{
1.5716 + glTexParameteri(target, pname, *params);
1.5717 +}
1.5718 +
1.5719 +void __stdcall glTexStorage2DEXT(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
1.5720 +{
1.5721 + EVENT("(GLenum target = 0x%X, GLsizei levels = %d, GLenum internalformat = 0x%X, GLsizei width = %d, GLsizei height = %d)",
1.5722 + target, levels, internalformat, width, height);
1.5723 +
1.5724 + try
1.5725 + {
1.5726 + if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP)
1.5727 + {
1.5728 + return gl::error(GL_INVALID_ENUM);
1.5729 + }
1.5730 +
1.5731 + if (width < 1 || height < 1 || levels < 1)
1.5732 + {
1.5733 + return gl::error(GL_INVALID_VALUE);
1.5734 + }
1.5735 +
1.5736 + if (target == GL_TEXTURE_CUBE_MAP && width != height)
1.5737 + {
1.5738 + return gl::error(GL_INVALID_VALUE);
1.5739 + }
1.5740 +
1.5741 + if (levels != 1 && levels != gl::log2(std::max(width, height)) + 1)
1.5742 + {
1.5743 + return gl::error(GL_INVALID_OPERATION);
1.5744 + }
1.5745 +
1.5746 + GLenum format = gl::ExtractFormat(internalformat);
1.5747 + GLenum type = gl::ExtractType(internalformat);
1.5748 +
1.5749 + if (format == GL_NONE || type == GL_NONE)
1.5750 + {
1.5751 + return gl::error(GL_INVALID_ENUM);
1.5752 + }
1.5753 +
1.5754 + gl::Context *context = gl::getNonLostContext();
1.5755 +
1.5756 + if (context)
1.5757 + {
1.5758 + switch (target)
1.5759 + {
1.5760 + case GL_TEXTURE_2D:
1.5761 + if (width > context->getMaximumTextureDimension() ||
1.5762 + height > context->getMaximumTextureDimension())
1.5763 + {
1.5764 + return gl::error(GL_INVALID_VALUE);
1.5765 + }
1.5766 + break;
1.5767 + case GL_TEXTURE_CUBE_MAP:
1.5768 + if (width > context->getMaximumCubeTextureDimension() ||
1.5769 + height > context->getMaximumCubeTextureDimension())
1.5770 + {
1.5771 + return gl::error(GL_INVALID_VALUE);
1.5772 + }
1.5773 + break;
1.5774 + default:
1.5775 + return gl::error(GL_INVALID_ENUM);
1.5776 + }
1.5777 +
1.5778 + if (levels != 1 && !context->supportsNonPower2Texture())
1.5779 + {
1.5780 + if (!gl::isPow2(width) || !gl::isPow2(height))
1.5781 + {
1.5782 + return gl::error(GL_INVALID_OPERATION);
1.5783 + }
1.5784 + }
1.5785 +
1.5786 + switch (internalformat)
1.5787 + {
1.5788 + case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
1.5789 + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
1.5790 + if (!context->supportsDXT1Textures())
1.5791 + {
1.5792 + return gl::error(GL_INVALID_ENUM);
1.5793 + }
1.5794 + break;
1.5795 + case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
1.5796 + if (!context->supportsDXT3Textures())
1.5797 + {
1.5798 + return gl::error(GL_INVALID_ENUM);
1.5799 + }
1.5800 + break;
1.5801 + case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
1.5802 + if (!context->supportsDXT5Textures())
1.5803 + {
1.5804 + return gl::error(GL_INVALID_ENUM);
1.5805 + }
1.5806 + break;
1.5807 + case GL_RGBA32F_EXT:
1.5808 + case GL_RGB32F_EXT:
1.5809 + case GL_ALPHA32F_EXT:
1.5810 + case GL_LUMINANCE32F_EXT:
1.5811 + case GL_LUMINANCE_ALPHA32F_EXT:
1.5812 + if (!context->supportsFloat32Textures())
1.5813 + {
1.5814 + return gl::error(GL_INVALID_ENUM);
1.5815 + }
1.5816 + break;
1.5817 + case GL_RGBA16F_EXT:
1.5818 + case GL_RGB16F_EXT:
1.5819 + case GL_ALPHA16F_EXT:
1.5820 + case GL_LUMINANCE16F_EXT:
1.5821 + case GL_LUMINANCE_ALPHA16F_EXT:
1.5822 + if (!context->supportsFloat16Textures())
1.5823 + {
1.5824 + return gl::error(GL_INVALID_ENUM);
1.5825 + }
1.5826 + break;
1.5827 + case GL_DEPTH_COMPONENT16:
1.5828 + case GL_DEPTH_COMPONENT32_OES:
1.5829 + case GL_DEPTH24_STENCIL8_OES:
1.5830 + if (!context->supportsDepthTextures())
1.5831 + {
1.5832 + return gl::error(GL_INVALID_ENUM);
1.5833 + }
1.5834 + if (target != GL_TEXTURE_2D)
1.5835 + {
1.5836 + return gl::error(GL_INVALID_OPERATION);
1.5837 + }
1.5838 + // ANGLE_depth_texture only supports 1-level textures
1.5839 + if (levels != 1)
1.5840 + {
1.5841 + return gl::error(GL_INVALID_OPERATION);
1.5842 + }
1.5843 + break;
1.5844 + default:
1.5845 + break;
1.5846 + }
1.5847 +
1.5848 + if (target == GL_TEXTURE_2D)
1.5849 + {
1.5850 + gl::Texture2D *texture = context->getTexture2D();
1.5851 +
1.5852 + if (!texture || texture->id() == 0)
1.5853 + {
1.5854 + return gl::error(GL_INVALID_OPERATION);
1.5855 + }
1.5856 +
1.5857 + if (texture->isImmutable())
1.5858 + {
1.5859 + return gl::error(GL_INVALID_OPERATION);
1.5860 + }
1.5861 +
1.5862 + texture->storage(levels, internalformat, width, height);
1.5863 + }
1.5864 + else if (target == GL_TEXTURE_CUBE_MAP)
1.5865 + {
1.5866 + gl::TextureCubeMap *texture = context->getTextureCubeMap();
1.5867 +
1.5868 + if (!texture || texture->id() == 0)
1.5869 + {
1.5870 + return gl::error(GL_INVALID_OPERATION);
1.5871 + }
1.5872 +
1.5873 + if (texture->isImmutable())
1.5874 + {
1.5875 + return gl::error(GL_INVALID_OPERATION);
1.5876 + }
1.5877 +
1.5878 + texture->storage(levels, internalformat, width);
1.5879 + }
1.5880 + else UNREACHABLE();
1.5881 + }
1.5882 + }
1.5883 + catch(std::bad_alloc&)
1.5884 + {
1.5885 + return gl::error(GL_OUT_OF_MEMORY);
1.5886 + }
1.5887 +}
1.5888 +
1.5889 +void __stdcall glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
1.5890 + GLenum format, GLenum type, const GLvoid* pixels)
1.5891 +{
1.5892 + EVENT("(GLenum target = 0x%X, GLint level = %d, GLint xoffset = %d, GLint yoffset = %d, "
1.5893 + "GLsizei width = %d, GLsizei height = %d, GLenum format = 0x%X, GLenum type = 0x%X, "
1.5894 + "const GLvoid* pixels = 0x%0.8p)",
1.5895 + target, level, xoffset, yoffset, width, height, format, type, pixels);
1.5896 +
1.5897 + try
1.5898 + {
1.5899 + if (!gl::IsInternalTextureTarget(target))
1.5900 + {
1.5901 + return gl::error(GL_INVALID_ENUM);
1.5902 + }
1.5903 +
1.5904 + if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
1.5905 + {
1.5906 + return gl::error(GL_INVALID_VALUE);
1.5907 + }
1.5908 +
1.5909 + if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
1.5910 + {
1.5911 + return gl::error(GL_INVALID_VALUE);
1.5912 + }
1.5913 +
1.5914 + if (!checkTextureFormatType(format, type))
1.5915 + {
1.5916 + return; // error is set by helper function
1.5917 + }
1.5918 +
1.5919 + gl::Context *context = gl::getNonLostContext();
1.5920 +
1.5921 + if (context)
1.5922 + {
1.5923 + if (level > context->getMaximumTextureLevel())
1.5924 + {
1.5925 + return gl::error(GL_INVALID_VALUE);
1.5926 + }
1.5927 +
1.5928 + if (format == GL_FLOAT)
1.5929 + {
1.5930 + if (!context->supportsFloat32Textures())
1.5931 + {
1.5932 + return gl::error(GL_INVALID_ENUM);
1.5933 + }
1.5934 + }
1.5935 + else if (format == GL_HALF_FLOAT_OES)
1.5936 + {
1.5937 + if (!context->supportsFloat16Textures())
1.5938 + {
1.5939 + return gl::error(GL_INVALID_ENUM);
1.5940 + }
1.5941 + }
1.5942 + else if (gl::IsDepthTexture(format))
1.5943 + {
1.5944 + if (!context->supportsDepthTextures())
1.5945 + {
1.5946 + return gl::error(GL_INVALID_ENUM);
1.5947 + }
1.5948 + if (target != GL_TEXTURE_2D)
1.5949 + {
1.5950 + return gl::error(GL_INVALID_OPERATION);
1.5951 + }
1.5952 + // OES_depth_texture supports loading depth data, but ANGLE_depth_texture does not
1.5953 + return gl::error(GL_INVALID_OPERATION);
1.5954 + }
1.5955 +
1.5956 + if (width == 0 || height == 0 || pixels == NULL)
1.5957 + {
1.5958 + return;
1.5959 + }
1.5960 +
1.5961 + if (target == GL_TEXTURE_2D)
1.5962 + {
1.5963 + gl::Texture2D *texture = context->getTexture2D();
1.5964 + if (validateSubImageParams2D(false, width, height, xoffset, yoffset, level, format, type, texture))
1.5965 + {
1.5966 + texture->subImage(level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5967 + }
1.5968 + }
1.5969 + else if (gl::IsCubemapTextureTarget(target))
1.5970 + {
1.5971 + gl::TextureCubeMap *texture = context->getTextureCubeMap();
1.5972 + if (validateSubImageParamsCube(false, width, height, xoffset, yoffset, target, level, format, type, texture))
1.5973 + {
1.5974 + texture->subImage(target, level, xoffset, yoffset, width, height, format, type, context->getUnpackAlignment(), pixels);
1.5975 + }
1.5976 + }
1.5977 + else
1.5978 + {
1.5979 + UNREACHABLE();
1.5980 + }
1.5981 + }
1.5982 + }
1.5983 + catch(std::bad_alloc&)
1.5984 + {
1.5985 + return gl::error(GL_OUT_OF_MEMORY);
1.5986 + }
1.5987 +}
1.5988 +
1.5989 +void __stdcall glUniform1f(GLint location, GLfloat x)
1.5990 +{
1.5991 + glUniform1fv(location, 1, &x);
1.5992 +}
1.5993 +
1.5994 +void __stdcall glUniform1fv(GLint location, GLsizei count, const GLfloat* v)
1.5995 +{
1.5996 + EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
1.5997 +
1.5998 + try
1.5999 + {
1.6000 + if (count < 0)
1.6001 + {
1.6002 + return gl::error(GL_INVALID_VALUE);
1.6003 + }
1.6004 +
1.6005 + if (location == -1)
1.6006 + {
1.6007 + return;
1.6008 + }
1.6009 +
1.6010 + gl::Context *context = gl::getNonLostContext();
1.6011 +
1.6012 + if (context)
1.6013 + {
1.6014 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6015 + if (!programBinary)
1.6016 + {
1.6017 + return gl::error(GL_INVALID_OPERATION);
1.6018 + }
1.6019 +
1.6020 + if (!programBinary->setUniform1fv(location, count, v))
1.6021 + {
1.6022 + return gl::error(GL_INVALID_OPERATION);
1.6023 + }
1.6024 + }
1.6025 + }
1.6026 + catch(std::bad_alloc&)
1.6027 + {
1.6028 + return gl::error(GL_OUT_OF_MEMORY);
1.6029 + }
1.6030 +}
1.6031 +
1.6032 +void __stdcall glUniform1i(GLint location, GLint x)
1.6033 +{
1.6034 + glUniform1iv(location, 1, &x);
1.6035 +}
1.6036 +
1.6037 +void __stdcall glUniform1iv(GLint location, GLsizei count, const GLint* v)
1.6038 +{
1.6039 + EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
1.6040 +
1.6041 + try
1.6042 + {
1.6043 + if (count < 0)
1.6044 + {
1.6045 + return gl::error(GL_INVALID_VALUE);
1.6046 + }
1.6047 +
1.6048 + if (location == -1)
1.6049 + {
1.6050 + return;
1.6051 + }
1.6052 +
1.6053 + gl::Context *context = gl::getNonLostContext();
1.6054 +
1.6055 + if (context)
1.6056 + {
1.6057 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6058 + if (!programBinary)
1.6059 + {
1.6060 + return gl::error(GL_INVALID_OPERATION);
1.6061 + }
1.6062 +
1.6063 + if (!programBinary->setUniform1iv(location, count, v))
1.6064 + {
1.6065 + return gl::error(GL_INVALID_OPERATION);
1.6066 + }
1.6067 + }
1.6068 + }
1.6069 + catch(std::bad_alloc&)
1.6070 + {
1.6071 + return gl::error(GL_OUT_OF_MEMORY);
1.6072 + }
1.6073 +}
1.6074 +
1.6075 +void __stdcall glUniform2f(GLint location, GLfloat x, GLfloat y)
1.6076 +{
1.6077 + GLfloat xy[2] = {x, y};
1.6078 +
1.6079 + glUniform2fv(location, 1, (GLfloat*)&xy);
1.6080 +}
1.6081 +
1.6082 +void __stdcall glUniform2fv(GLint location, GLsizei count, const GLfloat* v)
1.6083 +{
1.6084 + EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
1.6085 +
1.6086 + try
1.6087 + {
1.6088 + if (count < 0)
1.6089 + {
1.6090 + return gl::error(GL_INVALID_VALUE);
1.6091 + }
1.6092 +
1.6093 + if (location == -1)
1.6094 + {
1.6095 + return;
1.6096 + }
1.6097 +
1.6098 + gl::Context *context = gl::getNonLostContext();
1.6099 +
1.6100 + if (context)
1.6101 + {
1.6102 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6103 + if (!programBinary)
1.6104 + {
1.6105 + return gl::error(GL_INVALID_OPERATION);
1.6106 + }
1.6107 +
1.6108 + if (!programBinary->setUniform2fv(location, count, v))
1.6109 + {
1.6110 + return gl::error(GL_INVALID_OPERATION);
1.6111 + }
1.6112 + }
1.6113 + }
1.6114 + catch(std::bad_alloc&)
1.6115 + {
1.6116 + return gl::error(GL_OUT_OF_MEMORY);
1.6117 + }
1.6118 +}
1.6119 +
1.6120 +void __stdcall glUniform2i(GLint location, GLint x, GLint y)
1.6121 +{
1.6122 + GLint xy[4] = {x, y};
1.6123 +
1.6124 + glUniform2iv(location, 1, (GLint*)&xy);
1.6125 +}
1.6126 +
1.6127 +void __stdcall glUniform2iv(GLint location, GLsizei count, const GLint* v)
1.6128 +{
1.6129 + EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
1.6130 +
1.6131 + try
1.6132 + {
1.6133 + if (count < 0)
1.6134 + {
1.6135 + return gl::error(GL_INVALID_VALUE);
1.6136 + }
1.6137 +
1.6138 + if (location == -1)
1.6139 + {
1.6140 + return;
1.6141 + }
1.6142 +
1.6143 + gl::Context *context = gl::getNonLostContext();
1.6144 +
1.6145 + if (context)
1.6146 + {
1.6147 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6148 + if (!programBinary)
1.6149 + {
1.6150 + return gl::error(GL_INVALID_OPERATION);
1.6151 + }
1.6152 +
1.6153 + if (!programBinary->setUniform2iv(location, count, v))
1.6154 + {
1.6155 + return gl::error(GL_INVALID_OPERATION);
1.6156 + }
1.6157 + }
1.6158 + }
1.6159 + catch(std::bad_alloc&)
1.6160 + {
1.6161 + return gl::error(GL_OUT_OF_MEMORY);
1.6162 + }
1.6163 +}
1.6164 +
1.6165 +void __stdcall glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
1.6166 +{
1.6167 + GLfloat xyz[3] = {x, y, z};
1.6168 +
1.6169 + glUniform3fv(location, 1, (GLfloat*)&xyz);
1.6170 +}
1.6171 +
1.6172 +void __stdcall glUniform3fv(GLint location, GLsizei count, const GLfloat* v)
1.6173 +{
1.6174 + EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
1.6175 +
1.6176 + try
1.6177 + {
1.6178 + if (count < 0)
1.6179 + {
1.6180 + return gl::error(GL_INVALID_VALUE);
1.6181 + }
1.6182 +
1.6183 + if (location == -1)
1.6184 + {
1.6185 + return;
1.6186 + }
1.6187 +
1.6188 + gl::Context *context = gl::getNonLostContext();
1.6189 +
1.6190 + if (context)
1.6191 + {
1.6192 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6193 + if (!programBinary)
1.6194 + {
1.6195 + return gl::error(GL_INVALID_OPERATION);
1.6196 + }
1.6197 +
1.6198 + if (!programBinary->setUniform3fv(location, count, v))
1.6199 + {
1.6200 + return gl::error(GL_INVALID_OPERATION);
1.6201 + }
1.6202 + }
1.6203 + }
1.6204 + catch(std::bad_alloc&)
1.6205 + {
1.6206 + return gl::error(GL_OUT_OF_MEMORY);
1.6207 + }
1.6208 +}
1.6209 +
1.6210 +void __stdcall glUniform3i(GLint location, GLint x, GLint y, GLint z)
1.6211 +{
1.6212 + GLint xyz[3] = {x, y, z};
1.6213 +
1.6214 + glUniform3iv(location, 1, (GLint*)&xyz);
1.6215 +}
1.6216 +
1.6217 +void __stdcall glUniform3iv(GLint location, GLsizei count, const GLint* v)
1.6218 +{
1.6219 + EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
1.6220 +
1.6221 + try
1.6222 + {
1.6223 + if (count < 0)
1.6224 + {
1.6225 + return gl::error(GL_INVALID_VALUE);
1.6226 + }
1.6227 +
1.6228 + if (location == -1)
1.6229 + {
1.6230 + return;
1.6231 + }
1.6232 +
1.6233 + gl::Context *context = gl::getNonLostContext();
1.6234 +
1.6235 + if (context)
1.6236 + {
1.6237 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6238 + if (!programBinary)
1.6239 + {
1.6240 + return gl::error(GL_INVALID_OPERATION);
1.6241 + }
1.6242 +
1.6243 + if (!programBinary->setUniform3iv(location, count, v))
1.6244 + {
1.6245 + return gl::error(GL_INVALID_OPERATION);
1.6246 + }
1.6247 + }
1.6248 + }
1.6249 + catch(std::bad_alloc&)
1.6250 + {
1.6251 + return gl::error(GL_OUT_OF_MEMORY);
1.6252 + }
1.6253 +}
1.6254 +
1.6255 +void __stdcall glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1.6256 +{
1.6257 + GLfloat xyzw[4] = {x, y, z, w};
1.6258 +
1.6259 + glUniform4fv(location, 1, (GLfloat*)&xyzw);
1.6260 +}
1.6261 +
1.6262 +void __stdcall glUniform4fv(GLint location, GLsizei count, const GLfloat* v)
1.6263 +{
1.6264 + EVENT("(GLint location = %d, GLsizei count = %d, const GLfloat* v = 0x%0.8p)", location, count, v);
1.6265 +
1.6266 + try
1.6267 + {
1.6268 + if (count < 0)
1.6269 + {
1.6270 + return gl::error(GL_INVALID_VALUE);
1.6271 + }
1.6272 +
1.6273 + if (location == -1)
1.6274 + {
1.6275 + return;
1.6276 + }
1.6277 +
1.6278 + gl::Context *context = gl::getNonLostContext();
1.6279 +
1.6280 + if (context)
1.6281 + {
1.6282 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6283 + if (!programBinary)
1.6284 + {
1.6285 + return gl::error(GL_INVALID_OPERATION);
1.6286 + }
1.6287 +
1.6288 + if (!programBinary->setUniform4fv(location, count, v))
1.6289 + {
1.6290 + return gl::error(GL_INVALID_OPERATION);
1.6291 + }
1.6292 + }
1.6293 + }
1.6294 + catch(std::bad_alloc&)
1.6295 + {
1.6296 + return gl::error(GL_OUT_OF_MEMORY);
1.6297 + }
1.6298 +}
1.6299 +
1.6300 +void __stdcall glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
1.6301 +{
1.6302 + GLint xyzw[4] = {x, y, z, w};
1.6303 +
1.6304 + glUniform4iv(location, 1, (GLint*)&xyzw);
1.6305 +}
1.6306 +
1.6307 +void __stdcall glUniform4iv(GLint location, GLsizei count, const GLint* v)
1.6308 +{
1.6309 + EVENT("(GLint location = %d, GLsizei count = %d, const GLint* v = 0x%0.8p)", location, count, v);
1.6310 +
1.6311 + try
1.6312 + {
1.6313 + if (count < 0)
1.6314 + {
1.6315 + return gl::error(GL_INVALID_VALUE);
1.6316 + }
1.6317 +
1.6318 + if (location == -1)
1.6319 + {
1.6320 + return;
1.6321 + }
1.6322 +
1.6323 + gl::Context *context = gl::getNonLostContext();
1.6324 +
1.6325 + if (context)
1.6326 + {
1.6327 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6328 + if (!programBinary)
1.6329 + {
1.6330 + return gl::error(GL_INVALID_OPERATION);
1.6331 + }
1.6332 +
1.6333 + if (!programBinary->setUniform4iv(location, count, v))
1.6334 + {
1.6335 + return gl::error(GL_INVALID_OPERATION);
1.6336 + }
1.6337 + }
1.6338 + }
1.6339 + catch(std::bad_alloc&)
1.6340 + {
1.6341 + return gl::error(GL_OUT_OF_MEMORY);
1.6342 + }
1.6343 +}
1.6344 +
1.6345 +void __stdcall glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1.6346 +{
1.6347 + EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p)",
1.6348 + location, count, transpose, value);
1.6349 +
1.6350 + try
1.6351 + {
1.6352 + if (count < 0 || transpose != GL_FALSE)
1.6353 + {
1.6354 + return gl::error(GL_INVALID_VALUE);
1.6355 + }
1.6356 +
1.6357 + if (location == -1)
1.6358 + {
1.6359 + return;
1.6360 + }
1.6361 +
1.6362 + gl::Context *context = gl::getNonLostContext();
1.6363 +
1.6364 + if (context)
1.6365 + {
1.6366 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6367 + if (!programBinary)
1.6368 + {
1.6369 + return gl::error(GL_INVALID_OPERATION);
1.6370 + }
1.6371 +
1.6372 + if (!programBinary->setUniformMatrix2fv(location, count, value))
1.6373 + {
1.6374 + return gl::error(GL_INVALID_OPERATION);
1.6375 + }
1.6376 + }
1.6377 + }
1.6378 + catch(std::bad_alloc&)
1.6379 + {
1.6380 + return gl::error(GL_OUT_OF_MEMORY);
1.6381 + }
1.6382 +}
1.6383 +
1.6384 +void __stdcall glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1.6385 +{
1.6386 + EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p)",
1.6387 + location, count, transpose, value);
1.6388 +
1.6389 + try
1.6390 + {
1.6391 + if (count < 0 || transpose != GL_FALSE)
1.6392 + {
1.6393 + return gl::error(GL_INVALID_VALUE);
1.6394 + }
1.6395 +
1.6396 + if (location == -1)
1.6397 + {
1.6398 + return;
1.6399 + }
1.6400 +
1.6401 + gl::Context *context = gl::getNonLostContext();
1.6402 +
1.6403 + if (context)
1.6404 + {
1.6405 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6406 + if (!programBinary)
1.6407 + {
1.6408 + return gl::error(GL_INVALID_OPERATION);
1.6409 + }
1.6410 +
1.6411 + if (!programBinary->setUniformMatrix3fv(location, count, value))
1.6412 + {
1.6413 + return gl::error(GL_INVALID_OPERATION);
1.6414 + }
1.6415 + }
1.6416 + }
1.6417 + catch(std::bad_alloc&)
1.6418 + {
1.6419 + return gl::error(GL_OUT_OF_MEMORY);
1.6420 + }
1.6421 +}
1.6422 +
1.6423 +void __stdcall glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
1.6424 +{
1.6425 + EVENT("(GLint location = %d, GLsizei count = %d, GLboolean transpose = %d, const GLfloat* value = 0x%0.8p)",
1.6426 + location, count, transpose, value);
1.6427 +
1.6428 + try
1.6429 + {
1.6430 + if (count < 0 || transpose != GL_FALSE)
1.6431 + {
1.6432 + return gl::error(GL_INVALID_VALUE);
1.6433 + }
1.6434 +
1.6435 + if (location == -1)
1.6436 + {
1.6437 + return;
1.6438 + }
1.6439 +
1.6440 + gl::Context *context = gl::getNonLostContext();
1.6441 +
1.6442 + if (context)
1.6443 + {
1.6444 + gl::ProgramBinary *programBinary = context->getCurrentProgramBinary();
1.6445 + if (!programBinary)
1.6446 + {
1.6447 + return gl::error(GL_INVALID_OPERATION);
1.6448 + }
1.6449 +
1.6450 + if (!programBinary->setUniformMatrix4fv(location, count, value))
1.6451 + {
1.6452 + return gl::error(GL_INVALID_OPERATION);
1.6453 + }
1.6454 + }
1.6455 + }
1.6456 + catch(std::bad_alloc&)
1.6457 + {
1.6458 + return gl::error(GL_OUT_OF_MEMORY);
1.6459 + }
1.6460 +}
1.6461 +
1.6462 +void __stdcall glUseProgram(GLuint program)
1.6463 +{
1.6464 + EVENT("(GLuint program = %d)", program);
1.6465 +
1.6466 + try
1.6467 + {
1.6468 + gl::Context *context = gl::getNonLostContext();
1.6469 +
1.6470 + if (context)
1.6471 + {
1.6472 + gl::Program *programObject = context->getProgram(program);
1.6473 +
1.6474 + if (!programObject && program != 0)
1.6475 + {
1.6476 + if (context->getShader(program))
1.6477 + {
1.6478 + return gl::error(GL_INVALID_OPERATION);
1.6479 + }
1.6480 + else
1.6481 + {
1.6482 + return gl::error(GL_INVALID_VALUE);
1.6483 + }
1.6484 + }
1.6485 +
1.6486 + if (program != 0 && !programObject->isLinked())
1.6487 + {
1.6488 + return gl::error(GL_INVALID_OPERATION);
1.6489 + }
1.6490 +
1.6491 + context->useProgram(program);
1.6492 + }
1.6493 + }
1.6494 + catch(std::bad_alloc&)
1.6495 + {
1.6496 + return gl::error(GL_OUT_OF_MEMORY);
1.6497 + }
1.6498 +}
1.6499 +
1.6500 +void __stdcall glValidateProgram(GLuint program)
1.6501 +{
1.6502 + EVENT("(GLuint program = %d)", program);
1.6503 +
1.6504 + try
1.6505 + {
1.6506 + gl::Context *context = gl::getNonLostContext();
1.6507 +
1.6508 + if (context)
1.6509 + {
1.6510 + gl::Program *programObject = context->getProgram(program);
1.6511 +
1.6512 + if (!programObject)
1.6513 + {
1.6514 + if (context->getShader(program))
1.6515 + {
1.6516 + return gl::error(GL_INVALID_OPERATION);
1.6517 + }
1.6518 + else
1.6519 + {
1.6520 + return gl::error(GL_INVALID_VALUE);
1.6521 + }
1.6522 + }
1.6523 +
1.6524 + programObject->validate();
1.6525 + }
1.6526 + }
1.6527 + catch(std::bad_alloc&)
1.6528 + {
1.6529 + return gl::error(GL_OUT_OF_MEMORY);
1.6530 + }
1.6531 +}
1.6532 +
1.6533 +void __stdcall glVertexAttrib1f(GLuint index, GLfloat x)
1.6534 +{
1.6535 + EVENT("(GLuint index = %d, GLfloat x = %f)", index, x);
1.6536 +
1.6537 + try
1.6538 + {
1.6539 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6540 + {
1.6541 + return gl::error(GL_INVALID_VALUE);
1.6542 + }
1.6543 +
1.6544 + gl::Context *context = gl::getNonLostContext();
1.6545 +
1.6546 + if (context)
1.6547 + {
1.6548 + GLfloat vals[4] = { x, 0, 0, 1 };
1.6549 + context->setVertexAttrib(index, vals);
1.6550 + }
1.6551 + }
1.6552 + catch(std::bad_alloc&)
1.6553 + {
1.6554 + return gl::error(GL_OUT_OF_MEMORY);
1.6555 + }
1.6556 +}
1.6557 +
1.6558 +void __stdcall glVertexAttrib1fv(GLuint index, const GLfloat* values)
1.6559 +{
1.6560 + EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
1.6561 +
1.6562 + try
1.6563 + {
1.6564 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6565 + {
1.6566 + return gl::error(GL_INVALID_VALUE);
1.6567 + }
1.6568 +
1.6569 + gl::Context *context = gl::getNonLostContext();
1.6570 +
1.6571 + if (context)
1.6572 + {
1.6573 + GLfloat vals[4] = { values[0], 0, 0, 1 };
1.6574 + context->setVertexAttrib(index, vals);
1.6575 + }
1.6576 + }
1.6577 + catch(std::bad_alloc&)
1.6578 + {
1.6579 + return gl::error(GL_OUT_OF_MEMORY);
1.6580 + }
1.6581 +}
1.6582 +
1.6583 +void __stdcall glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
1.6584 +{
1.6585 + EVENT("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f)", index, x, y);
1.6586 +
1.6587 + try
1.6588 + {
1.6589 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6590 + {
1.6591 + return gl::error(GL_INVALID_VALUE);
1.6592 + }
1.6593 +
1.6594 + gl::Context *context = gl::getNonLostContext();
1.6595 +
1.6596 + if (context)
1.6597 + {
1.6598 + GLfloat vals[4] = { x, y, 0, 1 };
1.6599 + context->setVertexAttrib(index, vals);
1.6600 + }
1.6601 + }
1.6602 + catch(std::bad_alloc&)
1.6603 + {
1.6604 + return gl::error(GL_OUT_OF_MEMORY);
1.6605 + }
1.6606 +}
1.6607 +
1.6608 +void __stdcall glVertexAttrib2fv(GLuint index, const GLfloat* values)
1.6609 +{
1.6610 + EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
1.6611 +
1.6612 + try
1.6613 + {
1.6614 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6615 + {
1.6616 + return gl::error(GL_INVALID_VALUE);
1.6617 + }
1.6618 +
1.6619 + gl::Context *context = gl::getNonLostContext();
1.6620 +
1.6621 + if (context)
1.6622 + {
1.6623 + GLfloat vals[4] = { values[0], values[1], 0, 1 };
1.6624 + context->setVertexAttrib(index, vals);
1.6625 + }
1.6626 + }
1.6627 + catch(std::bad_alloc&)
1.6628 + {
1.6629 + return gl::error(GL_OUT_OF_MEMORY);
1.6630 + }
1.6631 +}
1.6632 +
1.6633 +void __stdcall glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
1.6634 +{
1.6635 + EVENT("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f)", index, x, y, z);
1.6636 +
1.6637 + try
1.6638 + {
1.6639 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6640 + {
1.6641 + return gl::error(GL_INVALID_VALUE);
1.6642 + }
1.6643 +
1.6644 + gl::Context *context = gl::getNonLostContext();
1.6645 +
1.6646 + if (context)
1.6647 + {
1.6648 + GLfloat vals[4] = { x, y, z, 1 };
1.6649 + context->setVertexAttrib(index, vals);
1.6650 + }
1.6651 + }
1.6652 + catch(std::bad_alloc&)
1.6653 + {
1.6654 + return gl::error(GL_OUT_OF_MEMORY);
1.6655 + }
1.6656 +}
1.6657 +
1.6658 +void __stdcall glVertexAttrib3fv(GLuint index, const GLfloat* values)
1.6659 +{
1.6660 + EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
1.6661 +
1.6662 + try
1.6663 + {
1.6664 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6665 + {
1.6666 + return gl::error(GL_INVALID_VALUE);
1.6667 + }
1.6668 +
1.6669 + gl::Context *context = gl::getNonLostContext();
1.6670 +
1.6671 + if (context)
1.6672 + {
1.6673 + GLfloat vals[4] = { values[0], values[1], values[2], 1 };
1.6674 + context->setVertexAttrib(index, vals);
1.6675 + }
1.6676 + }
1.6677 + catch(std::bad_alloc&)
1.6678 + {
1.6679 + return gl::error(GL_OUT_OF_MEMORY);
1.6680 + }
1.6681 +}
1.6682 +
1.6683 +void __stdcall glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1.6684 +{
1.6685 + EVENT("(GLuint index = %d, GLfloat x = %f, GLfloat y = %f, GLfloat z = %f, GLfloat w = %f)", index, x, y, z, w);
1.6686 +
1.6687 + try
1.6688 + {
1.6689 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6690 + {
1.6691 + return gl::error(GL_INVALID_VALUE);
1.6692 + }
1.6693 +
1.6694 + gl::Context *context = gl::getNonLostContext();
1.6695 +
1.6696 + if (context)
1.6697 + {
1.6698 + GLfloat vals[4] = { x, y, z, w };
1.6699 + context->setVertexAttrib(index, vals);
1.6700 + }
1.6701 + }
1.6702 + catch(std::bad_alloc&)
1.6703 + {
1.6704 + return gl::error(GL_OUT_OF_MEMORY);
1.6705 + }
1.6706 +}
1.6707 +
1.6708 +void __stdcall glVertexAttrib4fv(GLuint index, const GLfloat* values)
1.6709 +{
1.6710 + EVENT("(GLuint index = %d, const GLfloat* values = 0x%0.8p)", index, values);
1.6711 +
1.6712 + try
1.6713 + {
1.6714 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6715 + {
1.6716 + return gl::error(GL_INVALID_VALUE);
1.6717 + }
1.6718 +
1.6719 + gl::Context *context = gl::getNonLostContext();
1.6720 +
1.6721 + if (context)
1.6722 + {
1.6723 + context->setVertexAttrib(index, values);
1.6724 + }
1.6725 + }
1.6726 + catch(std::bad_alloc&)
1.6727 + {
1.6728 + return gl::error(GL_OUT_OF_MEMORY);
1.6729 + }
1.6730 +}
1.6731 +
1.6732 +void __stdcall glVertexAttribDivisorANGLE(GLuint index, GLuint divisor)
1.6733 +{
1.6734 + EVENT("(GLuint index = %d, GLuint divisor = %d)", index, divisor);
1.6735 +
1.6736 + try
1.6737 + {
1.6738 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6739 + {
1.6740 + return gl::error(GL_INVALID_VALUE);
1.6741 + }
1.6742 +
1.6743 + gl::Context *context = gl::getNonLostContext();
1.6744 +
1.6745 + if (context)
1.6746 + {
1.6747 + context->setVertexAttribDivisor(index, divisor);
1.6748 + }
1.6749 + }
1.6750 + catch(std::bad_alloc&)
1.6751 + {
1.6752 + return gl::error(GL_OUT_OF_MEMORY);
1.6753 + }
1.6754 +}
1.6755 +
1.6756 +void __stdcall glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* ptr)
1.6757 +{
1.6758 + EVENT("(GLuint index = %d, GLint size = %d, GLenum type = 0x%X, "
1.6759 + "GLboolean normalized = %d, GLsizei stride = %d, const GLvoid* ptr = 0x%0.8p)",
1.6760 + index, size, type, normalized, stride, ptr);
1.6761 +
1.6762 + try
1.6763 + {
1.6764 + if (index >= gl::MAX_VERTEX_ATTRIBS)
1.6765 + {
1.6766 + return gl::error(GL_INVALID_VALUE);
1.6767 + }
1.6768 +
1.6769 + if (size < 1 || size > 4)
1.6770 + {
1.6771 + return gl::error(GL_INVALID_VALUE);
1.6772 + }
1.6773 +
1.6774 + switch (type)
1.6775 + {
1.6776 + case GL_BYTE:
1.6777 + case GL_UNSIGNED_BYTE:
1.6778 + case GL_SHORT:
1.6779 + case GL_UNSIGNED_SHORT:
1.6780 + case GL_FIXED:
1.6781 + case GL_FLOAT:
1.6782 + break;
1.6783 + default:
1.6784 + return gl::error(GL_INVALID_ENUM);
1.6785 + }
1.6786 +
1.6787 + if (stride < 0)
1.6788 + {
1.6789 + return gl::error(GL_INVALID_VALUE);
1.6790 + }
1.6791 +
1.6792 + gl::Context *context = gl::getNonLostContext();
1.6793 +
1.6794 + if (context)
1.6795 + {
1.6796 + context->setVertexAttribState(index, context->getArrayBuffer(), size, type, (normalized == GL_TRUE), stride, ptr);
1.6797 + }
1.6798 + }
1.6799 + catch(std::bad_alloc&)
1.6800 + {
1.6801 + return gl::error(GL_OUT_OF_MEMORY);
1.6802 + }
1.6803 +}
1.6804 +
1.6805 +void __stdcall glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
1.6806 +{
1.6807 + EVENT("(GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d)", x, y, width, height);
1.6808 +
1.6809 + try
1.6810 + {
1.6811 + if (width < 0 || height < 0)
1.6812 + {
1.6813 + return gl::error(GL_INVALID_VALUE);
1.6814 + }
1.6815 +
1.6816 + gl::Context *context = gl::getNonLostContext();
1.6817 +
1.6818 + if (context)
1.6819 + {
1.6820 + context->setViewportParams(x, y, width, height);
1.6821 + }
1.6822 + }
1.6823 + catch(std::bad_alloc&)
1.6824 + {
1.6825 + return gl::error(GL_OUT_OF_MEMORY);
1.6826 + }
1.6827 +}
1.6828 +
1.6829 +void __stdcall glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
1.6830 + GLbitfield mask, GLenum filter)
1.6831 +{
1.6832 + EVENT("(GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, "
1.6833 + "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, "
1.6834 + "GLbitfield mask = 0x%X, GLenum filter = 0x%X)",
1.6835 + srcX0, srcY0, srcX1, srcX1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1.6836 +
1.6837 + try
1.6838 + {
1.6839 + switch (filter)
1.6840 + {
1.6841 + case GL_NEAREST:
1.6842 + break;
1.6843 + default:
1.6844 + return gl::error(GL_INVALID_ENUM);
1.6845 + }
1.6846 +
1.6847 + if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
1.6848 + {
1.6849 + return gl::error(GL_INVALID_VALUE);
1.6850 + }
1.6851 +
1.6852 + if (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)
1.6853 + {
1.6854 + ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation");
1.6855 + return gl::error(GL_INVALID_OPERATION);
1.6856 + }
1.6857 +
1.6858 + gl::Context *context = gl::getNonLostContext();
1.6859 +
1.6860 + if (context)
1.6861 + {
1.6862 + if (context->getReadFramebufferHandle() == context->getDrawFramebufferHandle())
1.6863 + {
1.6864 + ERR("Blits with the same source and destination framebuffer are not supported by this implementation.");
1.6865 + return gl::error(GL_INVALID_OPERATION);
1.6866 + }
1.6867 +
1.6868 + context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask);
1.6869 + }
1.6870 + }
1.6871 + catch(std::bad_alloc&)
1.6872 + {
1.6873 + return gl::error(GL_OUT_OF_MEMORY);
1.6874 + }
1.6875 +}
1.6876 +
1.6877 +void __stdcall glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
1.6878 + GLint border, GLenum format, GLenum type, const GLvoid* pixels)
1.6879 +{
1.6880 + EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum internalformat = 0x%X, "
1.6881 + "GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, "
1.6882 + "GLenum format = 0x%X, GLenum type = 0x%x, const GLvoid* pixels = 0x%0.8p)",
1.6883 + target, level, internalformat, width, height, depth, border, format, type, pixels);
1.6884 +
1.6885 + try
1.6886 + {
1.6887 + UNIMPLEMENTED(); // FIXME
1.6888 + }
1.6889 + catch(std::bad_alloc&)
1.6890 + {
1.6891 + return gl::error(GL_OUT_OF_MEMORY);
1.6892 + }
1.6893 +}
1.6894 +
1.6895 +void __stdcall glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei *length,
1.6896 + GLenum *binaryFormat, void *binary)
1.6897 +{
1.6898 + EVENT("(GLenum program = 0x%X, bufSize = %d, length = 0x%0.8p, binaryFormat = 0x%0.8p, binary = 0x%0.8p)",
1.6899 + program, bufSize, length, binaryFormat, binary);
1.6900 +
1.6901 + try
1.6902 + {
1.6903 + gl::Context *context = gl::getNonLostContext();
1.6904 +
1.6905 + if (context)
1.6906 + {
1.6907 + gl::Program *programObject = context->getProgram(program);
1.6908 +
1.6909 + if (!programObject || !programObject->isLinked())
1.6910 + {
1.6911 + return gl::error(GL_INVALID_OPERATION);
1.6912 + }
1.6913 +
1.6914 + gl::ProgramBinary *programBinary = programObject->getProgramBinary();
1.6915 +
1.6916 + if (!programBinary)
1.6917 + {
1.6918 + return gl::error(GL_INVALID_OPERATION);
1.6919 + }
1.6920 +
1.6921 + if (!programBinary->save(binary, bufSize, length))
1.6922 + {
1.6923 + return gl::error(GL_INVALID_OPERATION);
1.6924 + }
1.6925 +
1.6926 + *binaryFormat = GL_PROGRAM_BINARY_ANGLE;
1.6927 + }
1.6928 + }
1.6929 + catch(std::bad_alloc&)
1.6930 + {
1.6931 + return gl::error(GL_OUT_OF_MEMORY);
1.6932 + }
1.6933 +}
1.6934 +
1.6935 +void __stdcall glProgramBinaryOES(GLuint program, GLenum binaryFormat,
1.6936 + const void *binary, GLint length)
1.6937 +{
1.6938 + EVENT("(GLenum program = 0x%X, binaryFormat = 0x%x, binary = 0x%0.8p, length = %d)",
1.6939 + program, binaryFormat, binary, length);
1.6940 +
1.6941 + try
1.6942 + {
1.6943 + gl::Context *context = gl::getNonLostContext();
1.6944 +
1.6945 + if (context)
1.6946 + {
1.6947 + if (binaryFormat != GL_PROGRAM_BINARY_ANGLE)
1.6948 + {
1.6949 + return gl::error(GL_INVALID_ENUM);
1.6950 + }
1.6951 +
1.6952 + gl::Program *programObject = context->getProgram(program);
1.6953 +
1.6954 + if (!programObject)
1.6955 + {
1.6956 + return gl::error(GL_INVALID_OPERATION);
1.6957 + }
1.6958 +
1.6959 + context->setProgramBinary(program, binary, length);
1.6960 + }
1.6961 + }
1.6962 + catch(std::bad_alloc&)
1.6963 + {
1.6964 + return gl::error(GL_OUT_OF_MEMORY);
1.6965 + }
1.6966 +}
1.6967 +
1.6968 +void __stdcall glDrawBuffersEXT(GLsizei n, const GLenum *bufs)
1.6969 +{
1.6970 + EVENT("(GLenum n = %d, bufs = 0x%0.8p)", n, bufs);
1.6971 +
1.6972 + try
1.6973 + {
1.6974 + gl::Context *context = gl::getNonLostContext();
1.6975 +
1.6976 + if (context)
1.6977 + {
1.6978 + if (n < 0 || (unsigned int)n > context->getMaximumRenderTargets())
1.6979 + {
1.6980 + return gl::error(GL_INVALID_VALUE);
1.6981 + }
1.6982 +
1.6983 + if (context->getDrawFramebufferHandle() == 0)
1.6984 + {
1.6985 + if (n != 1)
1.6986 + {
1.6987 + return gl::error(GL_INVALID_OPERATION);
1.6988 + }
1.6989 +
1.6990 + if (bufs[0] != GL_NONE && bufs[0] != GL_BACK)
1.6991 + {
1.6992 + return gl::error(GL_INVALID_OPERATION);
1.6993 + }
1.6994 + }
1.6995 + else
1.6996 + {
1.6997 + for (int colorAttachment = 0; colorAttachment < n; colorAttachment++)
1.6998 + {
1.6999 + const GLenum attachment = GL_COLOR_ATTACHMENT0_EXT + colorAttachment;
1.7000 + if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] != attachment)
1.7001 + {
1.7002 + return gl::error(GL_INVALID_OPERATION);
1.7003 + }
1.7004 + }
1.7005 + }
1.7006 +
1.7007 + gl::Framebuffer *framebuffer = context->getDrawFramebuffer();
1.7008 +
1.7009 + for (int colorAttachment = 0; colorAttachment < n; colorAttachment++)
1.7010 + {
1.7011 + framebuffer->setDrawBufferState(colorAttachment, bufs[colorAttachment]);
1.7012 + }
1.7013 +
1.7014 + for (int colorAttachment = n; colorAttachment < (int)context->getMaximumRenderTargets(); colorAttachment++)
1.7015 + {
1.7016 + framebuffer->setDrawBufferState(colorAttachment, GL_NONE);
1.7017 + }
1.7018 + }
1.7019 + }
1.7020 + catch (std::bad_alloc&)
1.7021 + {
1.7022 + return gl::error(GL_OUT_OF_MEMORY);
1.7023 + }
1.7024 +}
1.7025 +
1.7026 +__eglMustCastToProperFunctionPointerType __stdcall glGetProcAddress(const char *procname)
1.7027 +{
1.7028 + struct Extension
1.7029 + {
1.7030 + const char *name;
1.7031 + __eglMustCastToProperFunctionPointerType address;
1.7032 + };
1.7033 +
1.7034 + static const Extension glExtensions[] =
1.7035 + {
1.7036 + {"glTexImage3DOES", (__eglMustCastToProperFunctionPointerType)glTexImage3DOES},
1.7037 + {"glBlitFramebufferANGLE", (__eglMustCastToProperFunctionPointerType)glBlitFramebufferANGLE},
1.7038 + {"glRenderbufferStorageMultisampleANGLE", (__eglMustCastToProperFunctionPointerType)glRenderbufferStorageMultisampleANGLE},
1.7039 + {"glDeleteFencesNV", (__eglMustCastToProperFunctionPointerType)glDeleteFencesNV},
1.7040 + {"glGenFencesNV", (__eglMustCastToProperFunctionPointerType)glGenFencesNV},
1.7041 + {"glIsFenceNV", (__eglMustCastToProperFunctionPointerType)glIsFenceNV},
1.7042 + {"glTestFenceNV", (__eglMustCastToProperFunctionPointerType)glTestFenceNV},
1.7043 + {"glGetFenceivNV", (__eglMustCastToProperFunctionPointerType)glGetFenceivNV},
1.7044 + {"glFinishFenceNV", (__eglMustCastToProperFunctionPointerType)glFinishFenceNV},
1.7045 + {"glSetFenceNV", (__eglMustCastToProperFunctionPointerType)glSetFenceNV},
1.7046 + {"glGetTranslatedShaderSourceANGLE", (__eglMustCastToProperFunctionPointerType)glGetTranslatedShaderSourceANGLE},
1.7047 + {"glTexStorage2DEXT", (__eglMustCastToProperFunctionPointerType)glTexStorage2DEXT},
1.7048 + {"glGetGraphicsResetStatusEXT", (__eglMustCastToProperFunctionPointerType)glGetGraphicsResetStatusEXT},
1.7049 + {"glReadnPixelsEXT", (__eglMustCastToProperFunctionPointerType)glReadnPixelsEXT},
1.7050 + {"glGetnUniformfvEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformfvEXT},
1.7051 + {"glGetnUniformivEXT", (__eglMustCastToProperFunctionPointerType)glGetnUniformivEXT},
1.7052 + {"glGenQueriesEXT", (__eglMustCastToProperFunctionPointerType)glGenQueriesEXT},
1.7053 + {"glDeleteQueriesEXT", (__eglMustCastToProperFunctionPointerType)glDeleteQueriesEXT},
1.7054 + {"glIsQueryEXT", (__eglMustCastToProperFunctionPointerType)glIsQueryEXT},
1.7055 + {"glBeginQueryEXT", (__eglMustCastToProperFunctionPointerType)glBeginQueryEXT},
1.7056 + {"glEndQueryEXT", (__eglMustCastToProperFunctionPointerType)glEndQueryEXT},
1.7057 + {"glGetQueryivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryivEXT},
1.7058 + {"glGetQueryObjectuivEXT", (__eglMustCastToProperFunctionPointerType)glGetQueryObjectuivEXT},
1.7059 + {"glDrawBuffersEXT", (__eglMustCastToProperFunctionPointerType)glDrawBuffersEXT},
1.7060 + {"glVertexAttribDivisorANGLE", (__eglMustCastToProperFunctionPointerType)glVertexAttribDivisorANGLE},
1.7061 + {"glDrawArraysInstancedANGLE", (__eglMustCastToProperFunctionPointerType)glDrawArraysInstancedANGLE},
1.7062 + {"glDrawElementsInstancedANGLE", (__eglMustCastToProperFunctionPointerType)glDrawElementsInstancedANGLE},
1.7063 + {"glGetProgramBinaryOES", (__eglMustCastToProperFunctionPointerType)glGetProgramBinaryOES},
1.7064 + {"glProgramBinaryOES", (__eglMustCastToProperFunctionPointerType)glProgramBinaryOES}, };
1.7065 +
1.7066 + for (unsigned int ext = 0; ext < ArraySize(glExtensions); ext++)
1.7067 + {
1.7068 + if (strcmp(procname, glExtensions[ext].name) == 0)
1.7069 + {
1.7070 + return (__eglMustCastToProperFunctionPointerType)glExtensions[ext].address;
1.7071 + }
1.7072 + }
1.7073 +
1.7074 + return NULL;
1.7075 +}
1.7076 +
1.7077 +// Non-public functions used by EGL
1.7078 +
1.7079 +bool __stdcall glBindTexImage(egl::Surface *surface)
1.7080 +{
1.7081 + EVENT("(egl::Surface* surface = 0x%0.8p)",
1.7082 + surface);
1.7083 +
1.7084 + try
1.7085 + {
1.7086 + gl::Context *context = gl::getNonLostContext();
1.7087 +
1.7088 + if (context)
1.7089 + {
1.7090 + gl::Texture2D *textureObject = context->getTexture2D();
1.7091 +
1.7092 + if (textureObject->isImmutable())
1.7093 + {
1.7094 + return false;
1.7095 + }
1.7096 +
1.7097 + if (textureObject)
1.7098 + {
1.7099 + textureObject->bindTexImage(surface);
1.7100 + }
1.7101 + }
1.7102 + }
1.7103 + catch(std::bad_alloc&)
1.7104 + {
1.7105 + return gl::error(GL_OUT_OF_MEMORY, false);
1.7106 + }
1.7107 +
1.7108 + return true;
1.7109 +}
1.7110 +
1.7111 +}
