-#include "precompiled.h"
//
// Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
namespace gl
{
-// ES3 has a specific set of permutations of internal formats, formats and types which are acceptable.
struct ES3FormatCombination
{
GLenum internalFormat;
const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
// The type and format are valid if any supported internal format has that type and format
if (!typeSupported || !formatSupported)
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
// Check if this is a valid format combination to load texture data
if (es3FormatSet.find(searchFormat) == es3FormatSet.end())
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
return true;
}
-bool ValidateES3TexImageParameters(gl::Context *context, GLenum target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage,
+bool ValidateES3TexImageParameters(Context *context, GLenum target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage,
GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
if (!ValidTexture2DDestinationTarget(context, target))
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
// Validate image size
if (!ValidImageSize(context, target, level, width, height, depth))
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
// Verify zero border
if (border != 0)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (xoffset < 0 || yoffset < 0 || zoffset < 0 ||
std::numeric_limits<GLsizei>::max() - yoffset < height ||
std::numeric_limits<GLsizei>::max() - zoffset < depth)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
const gl::Caps &caps = context->getCaps();
if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) ||
static_cast<GLuint>(height) > (caps.max2DTextureSize >> level))
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
gl::Texture2D *texture2d = context->getTexture2D();
{
if (!isSubImage && width != height)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (static_cast<GLuint>(width) > (caps.maxCubeMapTextureSize >> level))
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
static_cast<GLuint>(height) > (caps.max3DTextureSize >> level) ||
static_cast<GLuint>(depth) > (caps.max3DTextureSize >> level))
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
gl::Texture3D *texture3d = context->getTexture3D();
static_cast<GLuint>(height) > (caps.max2DTextureSize >> level) ||
static_cast<GLuint>(depth) > (caps.maxArrayTextureLayers >> level))
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
gl::Texture2DArray *texture2darray = context->getTexture2DArray();
break;
default:
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
if (!texture)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
if (texture->isImmutable() && !isSubImage)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
// Validate texture formats
{
if (!ValidCompressedImageSize(context, actualInternalFormat, width, height))
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
if (!actualFormatInfo.compressed)
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
if (target == GL_TEXTURE_3D)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
else
if (target == GL_TEXTURE_3D && (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL))
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
{
if (isCompressed != textureCompressed)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
if (isCompressed)
if ((width % 4 != 0 && width != textureLevelWidth) ||
(height % 4 != 0 && height != textureLevelHeight))
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
if (xoffset < 0 || yoffset < 0 || zoffset < 0)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (std::numeric_limits<GLsizei>::max() - xoffset < width ||
std::numeric_limits<GLsizei>::max() - yoffset < height ||
std::numeric_limits<GLsizei>::max() - zoffset < depth)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (xoffset + width > textureLevelWidth ||
yoffset + height > textureLevelHeight ||
zoffset + depth > textureLevelDepth)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
}
!rx::IsUnsignedMultiplicationSafe(widthSize * heightSize * depthSize, pixelBytes))
{
// Overflow past the end of the buffer
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
size_t copyBytes = widthSize * heightSize * depthSize * pixelBytes;
((offset + copyBytes) > static_cast<size_t>(pixelUnpackBuffer->getSize())))
{
// Overflow past the end of the buffer
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
// ...data is not evenly divisible into the number of bytes needed to store in memory a datum
if ((offset % dataBytesPerPixel) != 0)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
// ...the buffer object's data store is currently mapped.
if (pixelUnpackBuffer->isMapped())
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
return false;
}
-bool ValidateES3CopyTexImageParameters(gl::Context *context, GLenum target, GLint level, GLenum internalformat,
+bool ValidateES3CopyTexImageParameters(Context *context, GLenum target, GLint level, GLenum internalformat,
bool isSubImage, GLint xoffset, GLint yoffset, GLint zoffset,
GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
- return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
+ context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+ return false;
}
if (context->getState().getReadFramebuffer()->id() != 0 && framebuffer->getSamples() != 0)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
gl::FramebufferAttachment *source = framebuffer->getReadColorbuffer();
if (!IsValidES3CopyTexImageCombination(textureInternalFormat, colorbufferInternalFormat,
context->getState().getReadFramebuffer()->id()))
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
else
if (!gl::IsValidES3CopyTexImageCombination(internalformat, colorbufferInternalFormat,
context->getState().getReadFramebuffer()->id()))
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
return (width > 0 && height > 0);
}
-bool ValidateES3TexStorageParameters(gl::Context *context, GLenum target, GLsizei levels, GLenum internalformat,
+bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei levels, GLenum internalformat,
GLsizei width, GLsizei height, GLsizei depth)
{
if (width < 1 || height < 1 || depth < 1 || levels < 1)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (levels > gl::log2(std::max(std::max(width, height), depth)) + 1)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
const gl::Caps &caps = context->getCaps();
if (static_cast<GLuint>(width) > caps.max2DTextureSize ||
static_cast<GLuint>(height) > caps.max2DTextureSize)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
}
break;
if (width != height)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (static_cast<GLuint>(width) > caps.maxCubeMapTextureSize)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
}
break;
static_cast<GLuint>(height) > caps.max3DTextureSize ||
static_cast<GLuint>(depth) > caps.max3DTextureSize)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
}
break;
static_cast<GLuint>(height) > caps.max2DTextureSize ||
static_cast<GLuint>(depth) > caps.maxArrayTextureLayers)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
}
break;
default:
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
if (!texture || texture->id() == 0)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
if (texture->isImmutable())
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
if (formatInfo.pixelBytes == 0)
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
return true;
}
-bool ValidateFramebufferTextureLayer(const gl::Context *context, GLenum target, GLenum attachment,
+bool ValidateFramebufferTextureLayer(Context *context, GLenum target, GLenum attachment,
GLuint texture, GLint level, GLint layer)
{
if (context->getClientVersion() < 3)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
if (layer < 0)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (!ValidateFramebufferTextureBase(context, target, attachment, texture, level))
{
if (level > gl::log2(caps.max2DTextureSize))
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (static_cast<GLuint>(layer) >= caps.maxArrayTextureLayers)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
gl::Texture2DArray *texArray = static_cast<gl::Texture2DArray *>(tex);
if (texArray->isCompressed(level))
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
break;
{
if (level > gl::log2(caps.max3DTextureSize))
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
if (static_cast<GLuint>(layer) >= caps.max3DTextureSize)
{
- return gl::error(GL_INVALID_VALUE, false);
+ context->recordError(Error(GL_INVALID_VALUE));
+ return false;
}
gl::Texture3D *tex3d = static_cast<gl::Texture3D *>(tex);
if (tex3d->isCompressed(level))
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
break;
default:
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
return true;
}
-bool ValidES3ReadFormatType(gl::Context *context, GLenum internalFormat, GLenum format, GLenum type)
+bool ValidES3ReadFormatType(Context *context, GLenum internalFormat, GLenum format, GLenum type)
{
const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat);
return true;
}
-bool ValidateInvalidateFramebufferParameters(gl::Context *context, GLenum target, GLsizei numAttachments,
+bool ValidateInvalidateFramebufferParameters(Context *context, GLenum target, GLsizei numAttachments,
const GLenum* attachments)
{
bool defaultFramebuffer = false;
defaultFramebuffer = context->getState().getReadFramebuffer()->id() == 0;
break;
default:
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
for (int i = 0; i < numAttachments; ++i)
{
if (defaultFramebuffer)
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
if (attachments[i] >= GL_COLOR_ATTACHMENT0 + context->getCaps().maxColorAttachments)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
}
else
case GL_DEPTH_STENCIL_ATTACHMENT:
if (defaultFramebuffer)
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
break;
case GL_COLOR:
case GL_STENCIL:
if (!defaultFramebuffer)
{
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
break;
default:
- return gl::error(GL_INVALID_ENUM, false);
+ context->recordError(Error(GL_INVALID_ENUM));
+ return false;
}
}
}
return true;
}
-bool ValidateClearBuffer(const gl::Context *context)
+bool ValidateClearBuffer(Context *context)
{
if (context->getClientVersion() < 3)
{
- return gl::error(GL_INVALID_OPERATION, false);
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
}
const gl::Framebuffer *fbo = context->getState().getDrawFramebuffer();
if (!fbo || fbo->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
- return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
+ context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
+ return false;
}
return true;
}
+bool ValidateGetUniformuiv(Context *context, GLuint program, GLint location, GLuint* params)
+{
+ if (context->getClientVersion() < 3)
+ {
+ context->recordError(Error(GL_INVALID_OPERATION));
+ return false;
+ }
+
+ return ValidateGetUniformBase(context, program, location);
+}
+
}