Skip to content

A
angle
Commit e8ebe7f6 by Geoff Lang
Options

Refactored entry point validation functions into their own files.

TRAC #23629 Signed-off-by: Nicolas Capens Signed-off-by: Shannon Woods Author: Geoff Lang
parent 5b61c696
Showing with 2528 additions and 2374 deletions
src/libGLESv2/libGLESv2.cpp
......@@ -23,2343 +23,9 @@
#include "libGLESv2/Context.h"
#include "libGLESv2/VertexArray.h"
bool validImageSize(const gl::Context *context, GLint level, GLsizei width, GLsizei height, GLsizei depth)
{
if (level < 0 || width < 0 || height < 0 || depth < 0)
{
return false;
}
if (context->supportsNonPower2Texture())
{
return true;
}
if (level == 0)
{
return true;
}
if (gl::isPow2(width) && gl::isPow2(height) && gl::isPow2(depth))
{
return true;
}
return false;
}
bool validCompressedImageSize(GLsizei width, GLsizei height)
{
if (width != 1 && width != 2 && width % 4 != 0)
{
return false;
}
if (height != 1 && height != 2 && height % 4 != 0)
{
return false;
}
return true;
}
// Verify that format/type are one of the combinations from table 3.4.
bool checkTextureFormatType(GLenum format, GLenum type)
{
// validate <format> by itself (used as secondary key below)
switch (format)
{
case GL_RGBA:
case GL_BGRA_EXT:
case GL_RGB:
case GL_ALPHA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
// invalid <type> -> sets INVALID_ENUM
// invalid <format>+<type> combination -> sets INVALID_OPERATION
switch (type)
{
case GL_UNSIGNED_BYTE:
switch (format)
{
case GL_RGBA:
case GL_BGRA_EXT:
case GL_RGB:
case GL_ALPHA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
return true;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
switch (format)
{
case GL_RGBA:
case GL_RGB:
case GL_ALPHA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
return true;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
switch (format)
{
case GL_RGBA:
return true;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
case GL_UNSIGNED_SHORT_5_6_5:
switch (format)
{
case GL_RGB:
return true;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
switch (format)
{
case GL_DEPTH_COMPONENT:
return true;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
case GL_UNSIGNED_INT_24_8_OES:
switch (format)
{
case GL_DEPTH_STENCIL_OES:
return true;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
bool validateSubImageParams2D(bool compressed, GLsizei width, GLsizei height,
GLint xoffset, GLint yoffset, GLint level, GLenum format, GLenum type,
gl::Texture2D *texture)
{
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (compressed != texture->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (format != GL_NONE)
{
GLenum internalformat = gl::GetSizedInternalFormat(format, type, 2);
if (internalformat != texture->getInternalFormat(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (compressed)
{
if ((width % 4 != 0 && width != texture->getWidth(0)) ||
(height % 4 != 0 && height != texture->getHeight(0)))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (xoffset + width > texture->getWidth(level) ||
yoffset + height > texture->getHeight(level))
{
return gl::error(GL_INVALID_VALUE, false);
}
return true;
}
bool validateSubImageParamsCube(bool compressed, GLsizei width, GLsizei height,
GLint xoffset, GLint yoffset, GLenum target, GLint level, GLenum format, GLenum type,
gl::TextureCubeMap *texture)
{
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (compressed != texture->isCompressed(target, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (format != GL_NONE)
{
GLenum internalformat = gl::GetSizedInternalFormat(format, type, 2);
if (internalformat != texture->getInternalFormat(target, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (compressed)
{
if ((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
(height % 4 != 0 && height != texture->getHeight(target, 0)))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (xoffset + width > texture->getWidth(target, level) ||
yoffset + height > texture->getHeight(target, level))
{
return gl::error(GL_INVALID_VALUE, false);
}
return true;
}
bool validateES2TexImageParameters(gl::Context *context, GLenum target, GLint level, GLint internalformat, bool isCompressed, bool isSubImage,
GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
if (!validImageSize(context, level, width, height, 1))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (isCompressed && !validCompressedImageSize(width, height))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (level < 0 || xoffset < 0 ||
std::numeric_limits<GLsizei>::max() - xoffset < width ||
std::numeric_limits<GLsizei>::max() - yoffset < height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!isSubImage && !isCompressed && internalformat != GLint(format))
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture *texture = NULL;
bool textureCompressed = false;
GLenum textureInternalFormat = GL_NONE;
GLint textureLevelWidth = 0;
GLint textureLevelHeight = 0;
switch (target)
{
case GL_TEXTURE_2D:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2D *tex2d = context->getTexture2D();
if (tex2d)
{
textureCompressed = tex2d->isCompressed(level);
textureInternalFormat = tex2d->getInternalFormat(level);
textureLevelWidth = tex2d->getWidth(level);
textureLevelHeight = tex2d->getHeight(level);
texture = tex2d;
}
if (isSubImage && !validateSubImageParams2D(isCompressed, width, height, xoffset, yoffset,
level, format, type, tex2d))
{
return false;
}
texture = tex2d;
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (!isSubImage && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension() >> level) ||
height > (context->getMaximumCubeTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::TextureCubeMap *texCube = context->getTextureCubeMap();
if (texCube)
{
textureCompressed = texCube->isCompressed(target, level);
textureInternalFormat = texCube->getInternalFormat(target, level);
textureLevelWidth = texCube->getWidth(target, level);
textureLevelHeight = texCube->getHeight(target, level);
texture = texCube;
}
if (isSubImage && !validateSubImageParamsCube(isCompressed, width, height, xoffset, yoffset,
target, level, format, type, texCube))
{
return false;
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (!isSubImage && texture->isImmutable())
{
return gl::error(GL_INVALID_OPERATION, false);
}
// Verify zero border
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
// Verify texture is not requesting more mip levels than are available.
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
GLenum actualInternalFormat = isSubImage ? textureInternalFormat : internalformat;
if (isCompressed)
{
switch (actualInternalFormat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (!context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (!context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (!context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
else
{
// validate <type> by itself (used as secondary key below)
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
case GL_UNSIGNED_INT_24_8_OES:
case GL_HALF_FLOAT_OES:
case GL_FLOAT:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
// validate <format> + <type> combinations
// - invalid <format> -> sets INVALID_ENUM
// - invalid <format>+<type> combination -> sets INVALID_OPERATION
switch (format)
{
case GL_ALPHA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_RGB:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_RGBA:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_BGRA_EXT:
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: // error cases for compressed textures are handled below
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
break;
case GL_DEPTH_COMPONENT:
switch (type)
{
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_DEPTH_STENCIL_OES:
switch (type)
{
case GL_UNSIGNED_INT_24_8_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
switch (format)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
if (!context->supportsDepthTextures())
{
return gl::error(GL_INVALID_VALUE, false);
}
if (target != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// OES_depth_texture supports loading depth data and multiple levels,
// but ANGLE_depth_texture does not
if (pixels != NULL || level != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
default:
break;
}
if (type == GL_FLOAT)
{
if (!context->supportsFloat32Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
}
else if (type == GL_HALF_FLOAT_OES)
{
if (!context->supportsFloat16Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
}
}
return true;
}
bool validateES3TexImageParameters(gl::Context *context, GLenum target, GLint level, GLint internalformat, bool isCompressed, bool isSubImage,
GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLint border, GLenum format, GLenum type)
{
// Validate image size
if (!validImageSize(context, level, width, height, depth))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (isCompressed && !validCompressedImageSize(width, height))
{
return gl::error(GL_INVALID_OPERATION, false);
}
// Verify zero border
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
// Validate dimensions based on Context limits and validate the texture
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture *texture = NULL;
bool textureCompressed = false;
GLenum textureInternalFormat = GL_NONE;
GLint textureLevelWidth = 0;
GLint textureLevelHeight = 0;
GLint textureLevelDepth = 0;
switch (target)
{
case GL_TEXTURE_2D:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2D *texture2d = context->getTexture2D();
if (texture2d)
{
textureCompressed = texture2d->isCompressed(level);
textureInternalFormat = texture2d->getInternalFormat(level);
textureLevelWidth = texture2d->getWidth(level);
textureLevelHeight = texture2d->getHeight(level);
textureLevelDepth = 1;
texture = texture2d;
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (!isSubImage && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
if (textureCube)
{
textureCompressed = textureCube->isCompressed(target, level);
textureInternalFormat = textureCube->getInternalFormat(target, level);
textureLevelWidth = textureCube->getWidth(target, level);
textureLevelHeight = textureCube->getHeight(target, level);
textureLevelDepth = 1;
texture = textureCube;
}
}
break;
case GL_TEXTURE_3D:
{
if (width > (context->getMaximum3DTextureDimension() >> level) ||
height > (context->getMaximum3DTextureDimension() >> level) ||
depth > (context->getMaximum3DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture3D *texture3d = context->getTexture3D();
if (texture3d)
{
textureCompressed = texture3d->isCompressed(level);
textureInternalFormat = texture3d->getInternalFormat(level);
textureLevelWidth = texture3d->getWidth(level);
textureLevelHeight = texture3d->getHeight(level);
textureLevelDepth = texture3d->getDepth(level);
texture = texture3d;
}
}
break;
case GL_TEXTURE_2D_ARRAY:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level) ||
depth > (context->getMaximum2DArrayTextureLayers() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2DArray *texture2darray = context->getTexture2DArray();
if (texture2darray)
{
textureCompressed = texture2darray->isCompressed(level);
textureInternalFormat = texture2darray->getInternalFormat(level);
textureLevelWidth = texture2darray->getWidth(level);
textureLevelHeight = texture2darray->getHeight(level);
textureLevelDepth = texture2darray->getDepth(level);
texture = texture2darray;
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable() && !isSubImage)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// Validate texture formats
GLenum actualInternalFormat = isSubImage ? textureInternalFormat : internalformat;
if (isCompressed)
{
if (!gl::IsFormatCompressed(actualInternalFormat, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (target == GL_TEXTURE_3D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
else
{
if (!gl::IsValidInternalFormat(actualInternalFormat, context) ||
!gl::IsValidFormat(format, context->getClientVersion()) ||
!gl::IsValidType(type, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (!gl::IsValidFormatCombination(actualInternalFormat, format, type, context->getClientVersion()))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (target == GL_TEXTURE_3D && (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
// Validate sub image parameters
if (isSubImage)
{
if (isCompressed != textureCompressed)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (format != GL_NONE)
{
GLenum internalformat = gl::GetSizedInternalFormat(format, type, context->getClientVersion());
if (internalformat != textureInternalFormat)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (isCompressed)
{
if ((width % 4 != 0 && width != textureLevelWidth) ||
(height % 4 != 0 && height != textureLevelHeight))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (width == 0 || height == 0 || depth == 0)
{
return false;
}
if (xoffset < 0 || yoffset < 0 || zoffset < 0)
{
return gl::error(GL_INVALID_VALUE, 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);
}
if (xoffset + width > textureLevelWidth ||
yoffset + height > textureLevelHeight ||
zoffset + depth > textureLevelDepth)
{
return gl::error(GL_INVALID_VALUE, false);
}
}
return true;
}
bool validateES2CopyTexImageParameters(gl::Context* context, GLenum target, GLint level, GLenum internalformat, bool isSubImage,
GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height,
GLint border)
{
if (!gl::IsInternalTextureTarget(target, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width == 0 || height == 0)
{
return false;
}
// Verify zero border
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
// Validate dimensions based on Context limits and validate the texture
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Framebuffer *framebuffer = context->getReadFramebuffer();
if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
}
if (context->getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
GLenum colorbufferFormat = framebuffer->getReadColorbuffer()->getInternalFormat();
gl::Texture *texture = NULL;
GLenum textureFormat = GL_RGBA;
switch (target)
{
case GL_TEXTURE_2D:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2D *tex2d = context->getTexture2D();
if (tex2d)
{
if (isSubImage && !validateSubImageParams2D(false, width, height, xoffset, yoffset, level, GL_NONE, GL_NONE, tex2d))
{
return false; // error already registered by validateSubImageParams
}
texture = tex2d;
textureFormat = gl::GetFormat(tex2d->getInternalFormat(level), context->getClientVersion());
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (!isSubImage && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension() >> level) ||
height > (context->getMaximumCubeTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::TextureCubeMap *texcube = context->getTextureCubeMap();
if (texcube)
{
if (isSubImage && !validateSubImageParamsCube(false, width, height, xoffset, yoffset, target, level, GL_NONE, GL_NONE, texcube))
{
return false; // error already registered by validateSubImageParams
}
texture = texcube;
textureFormat = gl::GetFormat(texcube->getInternalFormat(target, level), context->getClientVersion());
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable() && !isSubImage)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// [OpenGL ES 2.0.24] table 3.9
if (isSubImage)
{
switch (textureFormat)
{
case GL_ALPHA:
if (colorbufferFormat != GL_ALPHA8_EXT &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE:
case GL_RGB:
if (colorbufferFormat != GL_RGB565 &&
colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
if (colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
return gl::error(GL_INVALID_OPERATION, false);
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
return gl::error(GL_INVALID_OPERATION, false);
default:
return gl::error(GL_INVALID_OPERATION, false);
}
}
else
{
switch (internalformat)
{
case GL_ALPHA:
if (colorbufferFormat != GL_ALPHA8_EXT &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE:
case GL_RGB:
if (colorbufferFormat != GL_RGB565 &&
colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
if (colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH_STENCIL_OES:
case GL_DEPTH24_STENCIL8_OES:
if (context->supportsDepthTextures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
return true;
}
bool validateES3CopyTexImageParameters(gl::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 (level < 0 || xoffset < 0 || yoffset < 0 || zoffset < 0 || width < 0 || height < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width == 0 || height == 0)
{
return false;
}
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Framebuffer *framebuffer = context->getReadFramebuffer();
if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
}
if (context->getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Renderbuffer *source = framebuffer->getReadColorbuffer();
GLenum colorbufferInternalFormat = source->getInternalFormat();
gl::Texture *texture = NULL;
GLenum textureInternalFormat = GL_NONE;
bool textureCompressed = false;
bool textureIsDepth = false;
GLint textureLevelWidth = 0;
GLint textureLevelHeight = 0;
GLint textureLevelDepth = 0;
switch (target)
{
case GL_TEXTURE_2D:
{
gl::Texture2D *texture2d = context->getTexture2D();
if (texture2d)
{
textureInternalFormat = texture2d->getInternalFormat(level);
textureCompressed = texture2d->isCompressed(level);
textureIsDepth = texture2d->isDepth(level);
textureLevelWidth = texture2d->getWidth(level);
textureLevelHeight = texture2d->getHeight(level);
textureLevelDepth = 1;
texture = texture2d;
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
if (textureCube)
{
textureInternalFormat = textureCube->getInternalFormat(target, level);
textureCompressed = textureCube->isCompressed(target, level);
textureIsDepth = false;
textureLevelWidth = textureCube->getWidth(target, level);
textureLevelHeight = textureCube->getHeight(target, level);
textureLevelDepth = 1;
texture = textureCube;
}
}
break;
case GL_TEXTURE_2D_ARRAY:
{
gl::Texture2DArray *texture2dArray = context->getTexture2DArray();
if (texture2dArray)
{
textureInternalFormat = texture2dArray->getInternalFormat(level);
textureCompressed = texture2dArray->isCompressed(level);
textureIsDepth = texture2dArray->isDepth(level);
textureLevelWidth = texture2dArray->getWidth(level);
textureLevelHeight = texture2dArray->getHeight(level);
textureLevelDepth = texture2dArray->getDepth(level);
texture = texture2dArray;
}
}
break;
case GL_TEXTURE_3D:
{
gl::Texture3D *texture3d = context->getTexture3D();
if (texture3d)
{
textureInternalFormat = texture3d->getInternalFormat(level);
textureCompressed = texture3d->isCompressed(level);
textureIsDepth = texture3d->isDepth(level);
textureLevelWidth = texture3d->getWidth(level);
textureLevelHeight = texture3d->getHeight(level);
textureLevelDepth = texture3d->getDepth(level);
texture = texture3d;
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable() && !isSubImage)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (textureIsDepth)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (textureCompressed)
{
if ((width % 4 != 0 && width != textureLevelWidth) ||
(height % 4 != 0 && height != textureLevelHeight))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (isSubImage)
{
if (xoffset + width > textureLevelWidth ||
yoffset + height > textureLevelHeight ||
zoffset >= textureLevelDepth)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!gl::IsValidCopyTexImageCombination(textureInternalFormat, colorbufferInternalFormat,
context->getClientVersion()))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
return true;
}
bool validateES2TexStorageParameters(gl::Context *context, GLenum target, GLsizei levels, GLenum internalformat,
GLsizei width, GLsizei height)
{
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (width < 1 || height < 1 || levels < 1)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (target == GL_TEXTURE_CUBE_MAP && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (levels != 1 && levels != gl::log2(std::max(width, height)) + 1)
{
return gl::error(GL_INVALID_OPERATION, false);
}
GLenum format = gl::GetFormat(internalformat, context->getClientVersion());
GLenum type = gl::GetType(internalformat, context->getClientVersion());
if (format == GL_NONE || type == GL_NONE)
{
return gl::error(GL_INVALID_ENUM, false);
}
switch (target)
{
case GL_TEXTURE_2D:
if (width > context->getMaximum2DTextureDimension() ||
height > context->getMaximum2DTextureDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
break;
case GL_TEXTURE_CUBE_MAP:
if (width > context->getMaximumCubeTextureDimension() ||
height > context->getMaximumCubeTextureDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (levels != 1 && !context->supportsNonPower2Texture())
{
if (!gl::isPow2(width) || !gl::isPow2(height))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
switch (internalformat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (!context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (!context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (!context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_RGBA32F_EXT:
case GL_RGB32F_EXT:
case GL_ALPHA32F_EXT:
case GL_LUMINANCE32F_EXT:
case GL_LUMINANCE_ALPHA32F_EXT:
if (!context->supportsFloat32Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_RGBA16F_EXT:
case GL_RGB16F_EXT:
case GL_ALPHA16F_EXT:
case GL_LUMINANCE16F_EXT:
case GL_LUMINANCE_ALPHA16F_EXT:
if (!context->supportsFloat16Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH24_STENCIL8_OES:
if (!context->supportsDepthTextures())
{
return gl::error(GL_INVALID_ENUM, false);
}
if (target != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// ANGLE_depth_texture only supports 1-level textures
if (levels != 1)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
default:
break;
}
gl::Texture *texture = NULL;
switch(target)
{
case GL_TEXTURE_2D:
texture = context->getTexture2D();
break;
case GL_TEXTURE_CUBE_MAP:
texture = context->getTextureCubeMap();
break;
default:
UNREACHABLE();
}
if (!texture || texture->id() == 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable())
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
bool validateES3TexStorageParameters(gl::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);
}
if (levels > gl::log2(std::max(std::max(width, height), depth)) + 1)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture *texture = NULL;
switch (target)
{
case GL_TEXTURE_2D:
{
texture = context->getTexture2D();
if (width > (context->getMaximum2DTextureDimension()) ||
height > (context->getMaximum2DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
texture = context->getTextureCubeMap();
if (width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
case GL_TEXTURE_3D:
{
texture = context->getTexture3D();
if (width > (context->getMaximum3DTextureDimension()) ||
height > (context->getMaximum3DTextureDimension()) ||
depth > (context->getMaximum3DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
case GL_TEXTURE_2D_ARRAY:
{
texture = context->getTexture2DArray();
if (width > (context->getMaximum2DTextureDimension()) ||
height > (context->getMaximum2DTextureDimension()) ||
depth > (context->getMaximum2DArrayTextureLayers()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture || texture->id() == 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable())
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (!gl::IsValidInternalFormat(internalformat, context))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (!gl::IsSizedInternalFormat(internalformat, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
return true;
}
bool validateRenderbufferStorageParameters(const gl::Context *context, GLenum target, GLsizei samples,
GLenum internalformat, GLsizei width, GLsizei height,
bool angleExtension)
{
switch (target)
{
case GL_RENDERBUFFER:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (width < 0 || height < 0 || samples < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!gl::IsValidInternalFormat(internalformat, context))
{
return gl::error(GL_INVALID_ENUM, false);
}
// ANGLE_framebuffer_multisample does not explicitly state that the internal format must be
// sized but it does state that the format must be in the ES2.0 spec table 4.5 which contains
// only sized internal formats. The ES3 spec (section 4.4.2) does, however, state that the
// internal format must be sized and not an integer format if samples is greater than zero.
if (!gl::IsSizedInternalFormat(internalformat, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (gl::IsIntegerFormat(internalformat, context->getClientVersion()) && samples > 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (!gl::IsColorRenderingSupported(internalformat, context) &&
!gl::IsDepthRenderingSupported(internalformat, context) &&
!gl::IsStencilRenderingSupported(internalformat, context))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (std::max(width, height) > context->getMaximumRenderbufferDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
// ANGLE_framebuffer_multisample states that the value of samples must be less than or equal
// to MAX_SAMPLES_ANGLE (Context::getMaxSupportedSamples) while the ES3.0 spec (section 4.4.2)
// states that samples must be less than or equal to the maximum samples for the specified
// internal format.
if (angleExtension)
{
if (samples > context->getMaxSupportedSamples())
{
return gl::error(GL_INVALID_VALUE, false);
}
}
else
{
if (samples > context->getMaxSupportedFormatSamples(internalformat))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
GLuint handle = context->getRenderbufferHandle();
if (handle == 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
bool validateES2FramebufferTextureParameters(gl::Context *context, GLenum target, GLenum attachment,
GLenum textarget, GLuint texture, GLint level)
{
META_ASSERT(GL_DRAW_FRAMEBUFFER == GL_DRAW_FRAMEBUFFER_ANGLE && GL_READ_FRAMEBUFFER == GL_READ_FRAMEBUFFER_ANGLE);
if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER && target != GL_READ_FRAMEBUFFER)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15)
{
const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0);
if (colorAttachment >= context->getMaximumRenderTargets())
{
return gl::error(GL_INVALID_VALUE, false);
}
}
else
{
switch (attachment)
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
if (texture != 0)
{
gl::Texture *tex = context->getTexture(texture);
if (tex == NULL)
{
return gl::error(GL_INVALID_OPERATION, false);
}
switch (textarget)
{
case GL_TEXTURE_2D:
{
if (tex->getTarget() != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture2D *tex2d = static_cast<gl::Texture2D *>(tex);
if (tex2d->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::TextureCubeMap *texcube = static_cast<gl::TextureCubeMap *>(tex);
if (texcube->isCompressed(textarget, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (level != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
}
gl::Framebuffer *framebuffer = NULL;
GLuint framebufferHandle = 0;
if (target == GL_READ_FRAMEBUFFER)
{
framebuffer = context->getReadFramebuffer();
framebufferHandle = context->getReadFramebufferHandle();
}
else
{
framebuffer = context->getDrawFramebuffer();
framebufferHandle = context->getDrawFramebufferHandle();
}
if (framebufferHandle == 0 || !framebuffer)
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
bool validateES3FramebufferTextureParameters(gl::Context *context, GLenum target, GLenum attachment,
GLenum textarget, GLuint texture, GLint level, GLint layer,
bool layerCall)
{
if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER && target != GL_READ_FRAMEBUFFER)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15)
{
const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0);
if (colorAttachment >= context->getMaximumRenderTargets())
{
return gl::error(GL_INVALID_VALUE, false);
}
}
else
{
switch (attachment)
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
case GL_DEPTH_STENCIL_ATTACHMENT:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
if (texture != 0)
{
gl::Texture *tex = context->getTexture(texture);
if (tex == NULL)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (level < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (layer < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!layerCall)
{
switch (textarget)
{
case GL_TEXTURE_2D:
{
if (level > gl::log2(context->getMaximum2DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (tex->getTarget() != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture2D *tex2d = static_cast<gl::Texture2D *>(tex);
if (tex2d->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (level > gl::log2(context->getMaximumCubeTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::TextureCubeMap *texcube = static_cast<gl::TextureCubeMap *>(tex);
if (texcube->isCompressed(textarget, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
else
{
switch (tex->getTarget())
{
case GL_TEXTURE_2D_ARRAY:
{
if (level > gl::log2(context->getMaximum2DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (layer >= context->getMaximum2DArrayTextureLayers())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2DArray *texArray = static_cast<gl::Texture2DArray *>(tex);
if (texArray->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
case GL_TEXTURE_3D:
{
if (level > gl::log2(context->getMaximum3DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (layer >= context->getMaximum3DTextureDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture3D *tex3d = static_cast<gl::Texture3D *>(tex);
if (tex3d->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
default:
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
gl::Framebuffer *framebuffer = NULL;
GLuint framebufferHandle = 0;
if (target == GL_READ_FRAMEBUFFER)
{
framebuffer = context->getReadFramebuffer();
framebufferHandle = context->getReadFramebufferHandle();
}
else
{
framebuffer = context->getDrawFramebuffer();
framebufferHandle = context->getDrawFramebufferHandle();
}
if (framebufferHandle == 0 || !framebuffer)
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
// check for combinations of format and type that are valid for ReadPixels
bool validES2ReadFormatType(GLenum format, GLenum type)
{
switch (format)
{
case GL_RGBA:
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
default:
return false;
}
break;
case GL_BGRA_EXT:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
break;
default:
return false;
}
break;
default:
return false;
}
return true;
}
bool validES3ReadFormatType(GLenum internalFormat, GLenum format, GLenum type)
{
switch (format)
{
case GL_RGBA:
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if (internalFormat != GL_RGB10_A2)
{
return false;
}
break;
default:
return false;
}
break;
case GL_RGBA_INTEGER:
switch (type)
{
case GL_INT:
if (!gl::IsSignedIntegerFormat(internalFormat, 3))
{
return false;
}
break;
case GL_UNSIGNED_INT:
if (!gl::IsUnsignedIntegerFormat(internalFormat, 3))
{
return false;
}
break;
default:
return false;
}
break;
case GL_BGRA_EXT:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
break;
default:
return false;
}
break;
default:
return false;
}
return true;
}
bool validateInvalidateFramebufferParameters(gl::Context *context, GLenum target, GLsizei numAttachments,
const GLenum* attachments)
{
bool defaultFramebuffer = false;
switch (target)
{
case GL_DRAW_FRAMEBUFFER:
case GL_FRAMEBUFFER:
defaultFramebuffer = context->getDrawFramebufferHandle() == 0;
break;
case GL_READ_FRAMEBUFFER:
defaultFramebuffer = context->getReadFramebufferHandle() == 0;
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
for (int i = 0; i < numAttachments; ++i)
{
if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[i] <= GL_COLOR_ATTACHMENT15)
{
if (defaultFramebuffer)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (attachments[i] >= GL_COLOR_ATTACHMENT0 + context->getMaximumRenderTargets())
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
else
{
switch (attachments[i])
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
case GL_DEPTH_STENCIL_ATTACHMENT:
if (defaultFramebuffer)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COLOR:
case GL_DEPTH:
case GL_STENCIL:
if (!defaultFramebuffer)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
}
return true;
}
bool validateBlitFramebufferParameters(gl::Context *context, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
GLenum filter, bool fromAngleExtension)
{
switch (filter)
{
case GL_NEAREST:
break;
case GL_LINEAR:
if (fromAngleExtension)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (mask == 0)
{
// ES3.0 spec, section 4.3.2 specifies that a mask of zero is valid and no
// buffers are copied.
return false;
}
if (fromAngleExtension && (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0))
{
ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false);
}
// ES3.0 spec, section 4.3.2 states that linear filtering is only available for the
// color buffer, leaving only nearest being unfiltered from above
if ((mask & ~GL_COLOR_BUFFER_BIT) != 0 && filter != GL_NEAREST)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (context->getReadFramebufferHandle() == context->getDrawFramebufferHandle())
{
if (fromAngleExtension)
{
ERR("Blits with the same source and destination framebuffer are not supported by this "
"implementation.");
}
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Framebuffer *readFramebuffer = context->getReadFramebuffer();
gl::Framebuffer *drawFramebuffer = context->getDrawFramebuffer();
if (!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
!drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
}
if (drawFramebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Rectangle sourceClippedRect, destClippedRect;
bool partialCopy;
if (!context->clipBlitFramebufferCoordinates(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
&sourceClippedRect, &destClippedRect, &partialCopy))
{
return gl::error(GL_INVALID_OPERATION, false);
}
bool sameBounds = srcX0 == dstX0 && srcY0 == dstY0 && srcX1 == dstX1 && srcY1 == dstY1;
GLuint clientVersion = context->getClientVersion();
if (mask & GL_COLOR_BUFFER_BIT)
{
gl::Renderbuffer *readColorBuffer = readFramebuffer->getReadColorbuffer();
gl::Renderbuffer *drawColorBuffer = drawFramebuffer->getFirstColorbuffer();
if (readColorBuffer && drawColorBuffer)
{
GLint readInternalFormat = readColorBuffer->getActualFormat();
GLint drawInternalFormat = drawColorBuffer->getActualFormat();
for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; i++)
{
if (drawFramebuffer->isEnabledColorAttachment(i))
{
GLint drawbufferAttachmentFormat = drawFramebuffer->getColorbuffer(i)->getActualFormat();
if (gl::IsNormalizedFixedPointFormat(readInternalFormat, clientVersion) &&
!gl::IsNormalizedFixedPointFormat(drawbufferAttachmentFormat, clientVersion))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (gl::IsUnsignedIntegerFormat(readInternalFormat, clientVersion) &&
!gl::IsUnsignedIntegerFormat(drawbufferAttachmentFormat, clientVersion))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (gl::IsSignedIntegerFormat(readInternalFormat, clientVersion) &&
!gl::IsSignedIntegerFormat(drawbufferAttachmentFormat, clientVersion))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (readColorBuffer->getSamples() > 0 && (readInternalFormat != drawbufferAttachmentFormat || !sameBounds))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
if (gl::IsIntegerFormat(readInternalFormat, clientVersion) && filter == GL_LINEAR)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (fromAngleExtension)
{
const GLenum readColorbufferType = readFramebuffer->getReadColorbufferType();
if (readColorbufferType != GL_TEXTURE_2D && readColorbufferType != GL_RENDERBUFFER)
{
return gl::error(GL_INVALID_OPERATION, false);
}
for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
{
if (drawFramebuffer->isEnabledColorAttachment(colorAttachment))
{
if (drawFramebuffer->getColorbufferType(colorAttachment) != GL_TEXTURE_2D &&
drawFramebuffer->getColorbufferType(colorAttachment) != GL_RENDERBUFFER)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (drawFramebuffer->getColorbuffer(colorAttachment)->getActualFormat() != readColorBuffer->getActualFormat())
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
if (partialCopy && readFramebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
}
if (mask & GL_DEPTH_BUFFER_BIT)
{
gl::Renderbuffer *readDepthBuffer = readFramebuffer->getDepthbuffer();
gl::Renderbuffer *drawDepthBuffer = drawFramebuffer->getDepthbuffer();
if (readDepthBuffer && drawDepthBuffer)
{
if (readDepthBuffer->getActualFormat() != drawDepthBuffer->getActualFormat())
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (readDepthBuffer->getSamples() > 0 && !sameBounds)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (fromAngleExtension)
{
if (partialCopy)
{
ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false); // only whole-buffer copies are permitted
}
if (readDepthBuffer->getSamples() != 0 || drawDepthBuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
}
if (mask & GL_STENCIL_BUFFER_BIT)
{
gl::Renderbuffer *readStencilBuffer = readFramebuffer->getStencilbuffer();
gl::Renderbuffer *drawStencilBuffer = drawFramebuffer->getStencilbuffer();
if (fromAngleExtension && partialCopy)
{
ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false); // only whole-buffer copies are permitted
}
if (readStencilBuffer && drawStencilBuffer)
{
if (readStencilBuffer->getActualFormat() != drawStencilBuffer->getActualFormat())
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (readStencilBuffer->getSamples() > 0 && !sameBounds)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (fromAngleExtension)
{
if (partialCopy)
{
ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false); // only whole-buffer copies are permitted
}
if (readStencilBuffer->getSamples() != 0 || drawStencilBuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
}
return true;
}
bool validateGetVertexAttribParameters(GLenum pname, int clientVersion)
{
switch (pname)
{
case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
case GL_VERTEX_ATTRIB_ARRAY_SIZE:
case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
case GL_VERTEX_ATTRIB_ARRAY_TYPE:
case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
case GL_CURRENT_VERTEX_ATTRIB:
return true;
case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
// Don't verify ES3 context because GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE uses
// the same constant.
META_ASSERT(GL_VERTEX_ATTRIB_ARRAY_DIVISOR == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
return true;
case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
return ((clientVersion >= 3) ? true : gl::error(GL_INVALID_ENUM, false));
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
bool validateTexParamParameters(gl::Context *context, GLenum pname, GLint param)
{
switch (pname)
{
case GL_TEXTURE_WRAP_R:
case GL_TEXTURE_SWIZZLE_R:
case GL_TEXTURE_SWIZZLE_G:
case GL_TEXTURE_SWIZZLE_B:
case GL_TEXTURE_SWIZZLE_A:
case GL_TEXTURE_BASE_LEVEL:
case GL_TEXTURE_MAX_LEVEL:
case GL_TEXTURE_COMPARE_MODE:
case GL_TEXTURE_COMPARE_FUNC:
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
if (context->getClientVersion() < 3)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default: break;
}
switch (pname)
{
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
switch (param)
{
case GL_REPEAT:
case GL_CLAMP_TO_EDGE:
case GL_MIRRORED_REPEAT:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
case GL_TEXTURE_MIN_FILTER:
switch (param)
{
case GL_NEAREST:
case GL_LINEAR:
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_MAG_FILTER:
switch (param)
{
case GL_NEAREST:
case GL_LINEAR:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_USAGE_ANGLE:
switch (param)
{
case GL_NONE:
case GL_FRAMEBUFFER_ATTACHMENT_ANGLE:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (!context->supportsTextureFilterAnisotropy())
{
return gl::error(GL_INVALID_ENUM, false);
}
// we assume the parameter passed to this validation method is truncated, not rounded
if (param < 1)
{
return gl::error(GL_INVALID_VALUE, false);
}
return true;
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
// any value is permissible
return true;
case GL_TEXTURE_COMPARE_MODE:
switch (param)
{
case GL_NONE:
case GL_COMPARE_REF_TO_TEXTURE:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_COMPARE_FUNC:
switch (param)
{
case GL_LEQUAL:
case GL_GEQUAL:
case GL_LESS:
case GL_GREATER:
case GL_EQUAL:
case GL_NOTEQUAL:
case GL_ALWAYS:
case GL_NEVER:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_SWIZZLE_R:
case GL_TEXTURE_SWIZZLE_G:
case GL_TEXTURE_SWIZZLE_B:
case GL_TEXTURE_SWIZZLE_A:
case GL_TEXTURE_BASE_LEVEL:
case GL_TEXTURE_MAX_LEVEL:
UNIMPLEMENTED();
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
#include "libGLESv2/validationES.h"
#include "libGLESv2/validationES2.h"
#include "libGLESv2/validationES3.h"
gl::Texture *getTargetTexture(gl::Context *context, GLenum target)
......@@ -2382,25 +48,6 @@ gl::Texture *getTargetTexture(gl::Context *context, GLenum target)
}
}
bool validateSamplerObjectParameter(GLenum pname)
{
switch (pname)
{
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
case GL_TEXTURE_COMPARE_MODE:
case GL_TEXTURE_COMPARE_FUNC:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
extern "C"
{
......@@ -6326,7 +3973,7 @@ void __stdcall glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
if (!validateGetVertexAttribParameters(pname, context->getClientVersion()))
if (!gl::validateGetVertexAttribParameters(pname, context->getClientVersion()))
{
return;
}
......@@ -6368,7 +4015,7 @@ void __stdcall glGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
if (!validateGetVertexAttribParameters(pname, context->getClientVersion()))
if (!gl::validateGetVertexAttribParameters(pname, context->getClientVersion()))
{
return;
}
......@@ -6871,8 +4518,8 @@ void __stdcall glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height,
if (!context->getCurrentReadFormatType(&currentInternalFormat, &currentFormat, &currentType))
return;
bool validReadFormat = (context->getClientVersion() < 3) ? validES2ReadFormatType(format, type) :
validES3ReadFormatType(currentInternalFormat, format, type);
bool validReadFormat = (context->getClientVersion() < 3) ? gl::validES2ReadFormatType(format, type) :
gl::validES3ReadFormatType(currentInternalFormat, format, type);
if (!(currentFormat == format && currentType == type) && !validReadFormat)
{
......@@ -6915,8 +4562,8 @@ void __stdcall glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
if (!context->getCurrentReadFormatType(&currentInternalFormat, &currentFormat, &currentType))
return;
bool validReadFormat = (context->getClientVersion() < 3) ? validES2ReadFormatType(format, type) :
validES3ReadFormatType(currentInternalFormat, format, type);
bool validReadFormat = (context->getClientVersion() < 3) ? gl::validES2ReadFormatType(format, type) :
gl::validES3ReadFormatType(currentInternalFormat, format, type);
if (!(currentFormat == format && currentType == type) && !validReadFormat)
{
......@@ -10075,7 +7722,7 @@ void __stdcall glGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
if (!validateGetVertexAttribParameters(pname, context->getClientVersion()))
if (!gl::validateGetVertexAttribParameters(pname, context->getClientVersion()))
{
return;
}
......@@ -10123,7 +7770,7 @@ void __stdcall glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
const gl::VertexAttribute &attribState = context->getVertexAttribState(index);
if (!validateGetVertexAttribParameters(pname, context->getClientVersion()))
if (!gl::validateGetVertexAttribParameters(pname, context->getClientVersion()))
{
return;
}
......@@ -11661,12 +9308,12 @@ void __stdcall glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
return gl::error(GL_INVALID_OPERATION);
}
if (!validateSamplerObjectParameter(pname))
if (!gl::validateSamplerObjectParameter(pname))
{
return;
}
if (!validateTexParamParameters(context, pname, param))
if (!gl::validateTexParamParameters(context, pname, param))
{
return;
}
......@@ -11705,12 +9352,12 @@ void __stdcall glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
return gl::error(GL_INVALID_OPERATION);
}
if (!validateSamplerObjectParameter(pname))
if (!gl::validateSamplerObjectParameter(pname))
{
return;
}
if (!validateTexParamParameters(context, pname, static_cast<GLint>(param)))
if (!gl::validateTexParamParameters(context, pname, static_cast<GLint>(param)))
{
return;
}
......@@ -11749,7 +9396,7 @@ void __stdcall glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* para
return gl::error(GL_INVALID_OPERATION);
}
if (!validateSamplerObjectParameter(pname))
if (!gl::validateSamplerObjectParameter(pname))
{
return;
}
......@@ -11783,7 +9430,7 @@ void __stdcall glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* pa
return gl::error(GL_INVALID_OPERATION);
}
if (!validateSamplerObjectParameter(pname))
if (!gl::validateSamplerObjectParameter(pname))
{
return;
}
......
src/libGLESv2/libGLESv2.vcxproj
......@@ -316,6 +316,9 @@ copy "$(OutDir)libGLESv2.lib" "$(ProjectDir)..\..\lib\$(Configuration)\"
<ClCompile Include="Shader.cpp" />
<ClCompile Include="Texture.cpp" />
<ClCompile Include="Uniform.cpp" />
<ClCompile Include="validationES.cpp" />
<ClCompile Include="validationES2.cpp" />
<ClCompile Include="validationES3.cpp" />
<ClCompile Include="VertexArray.cpp" />
</ItemGroup>
<ItemGroup>
......@@ -445,6 +448,9 @@ copy "$(OutDir)libGLESv2.lib" "$(ProjectDir)..\..\lib\$(Configuration)\"
<ClInclude Include="Texture.h" />
<ClInclude Include="Uniform.h" />
<ClInclude Include="..\common\version.h" />
<ClInclude Include="validationES.h" />
<ClInclude Include="validationES2.h" />
<ClInclude Include="validationES3.h" />
<ClInclude Include="VertexAttribute.h" />
<ClInclude Include="VertexArray.h" />
</ItemGroup>
......
src/libGLESv2/libGLESv2.vcxproj.filters
......@@ -244,13 +244,22 @@
</ClCompile>
<ClCompile Include="Sampler.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ClCompile>
<ClCompile Include="renderer\IndexRangeCache.cpp">
<Filter>Source Files\Renderer</Filter>
</ClCompile>
</ClCompile>
<ClCompile Include="RenderbufferProxySet.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="validationES2.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="validationES3.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="validationES.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="BinaryStream.h">
......@@ -636,13 +645,22 @@
</ClInclude>
<ClInclude Include="Sampler.h">
<Filter>Header Files</Filter>
</ClInclude>
</ClInclude>
<ClInclude Include="renderer\IndexRangeCache.h">
<Filter>Header Files\Renderer</Filter>
</ClInclude>
</ClInclude>
<ClInclude Include="RenderbufferProxySet.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="validationES2.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="validationES3.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="validationES.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="renderer\shaders\Blit.ps">
......
src/libGLESv2/validationES.cpp 0 → 100644
#include "precompiled.h"
//
// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES.h: Validation functions for generic OpenGL ES entry point parameters
#include "libGLESv2/validationES.h"
#include "libGLESv2/Context.h"
#include "libGLESv2/Texture.h"
#include "libGLESv2/Framebuffer.h"
#include "libGLESv2/Renderbuffer.h"
#include "libGLESv2/formatutils.h"
#include "libGLESv2/main.h"
#include "common/mathutil.h"
#include "common/utilities.h"
namespace gl
{
bool validateRenderbufferStorageParameters(const gl::Context *context, GLenum target, GLsizei samples,
GLenum internalformat, GLsizei width, GLsizei height,
bool angleExtension)
{
switch (target)
{
case GL_RENDERBUFFER:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (width < 0 || height < 0 || samples < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!gl::IsValidInternalFormat(internalformat, context))
{
return gl::error(GL_INVALID_ENUM, false);
}
// ANGLE_framebuffer_multisample does not explicitly state that the internal format must be
// sized but it does state that the format must be in the ES2.0 spec table 4.5 which contains
// only sized internal formats. The ES3 spec (section 4.4.2) does, however, state that the
// internal format must be sized and not an integer format if samples is greater than zero.
if (!gl::IsSizedInternalFormat(internalformat, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (gl::IsIntegerFormat(internalformat, context->getClientVersion()) && samples > 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (!gl::IsColorRenderingSupported(internalformat, context) &&
!gl::IsDepthRenderingSupported(internalformat, context) &&
!gl::IsStencilRenderingSupported(internalformat, context))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (std::max(width, height) > context->getMaximumRenderbufferDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
// ANGLE_framebuffer_multisample states that the value of samples must be less than or equal
// to MAX_SAMPLES_ANGLE (Context::getMaxSupportedSamples) while the ES3.0 spec (section 4.4.2)
// states that samples must be less than or equal to the maximum samples for the specified
// internal format.
if (angleExtension)
{
if (samples > context->getMaxSupportedSamples())
{
return gl::error(GL_INVALID_VALUE, false);
}
}
else
{
if (samples > context->getMaxSupportedFormatSamples(internalformat))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
GLuint handle = context->getRenderbufferHandle();
if (handle == 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
bool validateBlitFramebufferParameters(gl::Context *context, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
GLenum filter, bool fromAngleExtension)
{
switch (filter)
{
case GL_NEAREST:
break;
case GL_LINEAR:
if (fromAngleExtension)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (mask == 0)
{
// ES3.0 spec, section 4.3.2 specifies that a mask of zero is valid and no
// buffers are copied.
return false;
}
if (fromAngleExtension && (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0))
{
ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false);
}
// ES3.0 spec, section 4.3.2 states that linear filtering is only available for the
// color buffer, leaving only nearest being unfiltered from above
if ((mask & ~GL_COLOR_BUFFER_BIT) != 0 && filter != GL_NEAREST)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (context->getReadFramebufferHandle() == context->getDrawFramebufferHandle())
{
if (fromAngleExtension)
{
ERR("Blits with the same source and destination framebuffer are not supported by this "
"implementation.");
}
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Framebuffer *readFramebuffer = context->getReadFramebuffer();
gl::Framebuffer *drawFramebuffer = context->getDrawFramebuffer();
if (!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
!drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
}
if (drawFramebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Rectangle sourceClippedRect, destClippedRect;
bool partialCopy;
if (!context->clipBlitFramebufferCoordinates(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
&sourceClippedRect, &destClippedRect, &partialCopy))
{
return gl::error(GL_INVALID_OPERATION, false);
}
bool sameBounds = srcX0 == dstX0 && srcY0 == dstY0 && srcX1 == dstX1 && srcY1 == dstY1;
GLuint clientVersion = context->getClientVersion();
if (mask & GL_COLOR_BUFFER_BIT)
{
gl::Renderbuffer *readColorBuffer = readFramebuffer->getReadColorbuffer();
gl::Renderbuffer *drawColorBuffer = drawFramebuffer->getFirstColorbuffer();
if (readColorBuffer && drawColorBuffer)
{
GLint readInternalFormat = readColorBuffer->getActualFormat();
GLint drawInternalFormat = drawColorBuffer->getActualFormat();
for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; i++)
{
if (drawFramebuffer->isEnabledColorAttachment(i))
{
GLint drawbufferAttachmentFormat = drawFramebuffer->getColorbuffer(i)->getActualFormat();
if (gl::IsNormalizedFixedPointFormat(readInternalFormat, clientVersion) &&
!gl::IsNormalizedFixedPointFormat(drawbufferAttachmentFormat, clientVersion))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (gl::IsUnsignedIntegerFormat(readInternalFormat, clientVersion) &&
!gl::IsUnsignedIntegerFormat(drawbufferAttachmentFormat, clientVersion))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (gl::IsSignedIntegerFormat(readInternalFormat, clientVersion) &&
!gl::IsSignedIntegerFormat(drawbufferAttachmentFormat, clientVersion))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (readColorBuffer->getSamples() > 0 && (readInternalFormat != drawbufferAttachmentFormat || !sameBounds))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
if (gl::IsIntegerFormat(readInternalFormat, clientVersion) && filter == GL_LINEAR)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (fromAngleExtension)
{
const GLenum readColorbufferType = readFramebuffer->getReadColorbufferType();
if (readColorbufferType != GL_TEXTURE_2D && readColorbufferType != GL_RENDERBUFFER)
{
return gl::error(GL_INVALID_OPERATION, false);
}
for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
{
if (drawFramebuffer->isEnabledColorAttachment(colorAttachment))
{
if (drawFramebuffer->getColorbufferType(colorAttachment) != GL_TEXTURE_2D &&
drawFramebuffer->getColorbufferType(colorAttachment) != GL_RENDERBUFFER)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (drawFramebuffer->getColorbuffer(colorAttachment)->getActualFormat() != readColorBuffer->getActualFormat())
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
if (partialCopy && readFramebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
}
if (mask & GL_DEPTH_BUFFER_BIT)
{
gl::Renderbuffer *readDepthBuffer = readFramebuffer->getDepthbuffer();
gl::Renderbuffer *drawDepthBuffer = drawFramebuffer->getDepthbuffer();
if (readDepthBuffer && drawDepthBuffer)
{
if (readDepthBuffer->getActualFormat() != drawDepthBuffer->getActualFormat())
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (readDepthBuffer->getSamples() > 0 && !sameBounds)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (fromAngleExtension)
{
if (partialCopy)
{
ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false); // only whole-buffer copies are permitted
}
if (readDepthBuffer->getSamples() != 0 || drawDepthBuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
}
if (mask & GL_STENCIL_BUFFER_BIT)
{
gl::Renderbuffer *readStencilBuffer = readFramebuffer->getStencilbuffer();
gl::Renderbuffer *drawStencilBuffer = drawFramebuffer->getStencilbuffer();
if (fromAngleExtension && partialCopy)
{
ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false); // only whole-buffer copies are permitted
}
if (readStencilBuffer && drawStencilBuffer)
{
if (readStencilBuffer->getActualFormat() != drawStencilBuffer->getActualFormat())
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (readStencilBuffer->getSamples() > 0 && !sameBounds)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (fromAngleExtension)
{
if (partialCopy)
{
ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
return gl::error(GL_INVALID_OPERATION, false); // only whole-buffer copies are permitted
}
if (readStencilBuffer->getSamples() != 0 || drawStencilBuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
}
return true;
}
bool validateGetVertexAttribParameters(GLenum pname, int clientVersion)
{
switch (pname)
{
case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
case GL_VERTEX_ATTRIB_ARRAY_SIZE:
case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
case GL_VERTEX_ATTRIB_ARRAY_TYPE:
case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
case GL_CURRENT_VERTEX_ATTRIB:
return true;
case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
// Don't verify ES3 context because GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE uses
// the same constant.
META_ASSERT(GL_VERTEX_ATTRIB_ARRAY_DIVISOR == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
return true;
case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
return ((clientVersion >= 3) ? true : gl::error(GL_INVALID_ENUM, false));
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
bool validateTexParamParameters(gl::Context *context, GLenum pname, GLint param)
{
switch (pname)
{
case GL_TEXTURE_WRAP_R:
case GL_TEXTURE_SWIZZLE_R:
case GL_TEXTURE_SWIZZLE_G:
case GL_TEXTURE_SWIZZLE_B:
case GL_TEXTURE_SWIZZLE_A:
case GL_TEXTURE_BASE_LEVEL:
case GL_TEXTURE_MAX_LEVEL:
case GL_TEXTURE_COMPARE_MODE:
case GL_TEXTURE_COMPARE_FUNC:
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
if (context->getClientVersion() < 3)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default: break;
}
switch (pname)
{
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
switch (param)
{
case GL_REPEAT:
case GL_CLAMP_TO_EDGE:
case GL_MIRRORED_REPEAT:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
case GL_TEXTURE_MIN_FILTER:
switch (param)
{
case GL_NEAREST:
case GL_LINEAR:
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_MAG_FILTER:
switch (param)
{
case GL_NEAREST:
case GL_LINEAR:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_USAGE_ANGLE:
switch (param)
{
case GL_NONE:
case GL_FRAMEBUFFER_ATTACHMENT_ANGLE:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (!context->supportsTextureFilterAnisotropy())
{
return gl::error(GL_INVALID_ENUM, false);
}
// we assume the parameter passed to this validation method is truncated, not rounded
if (param < 1)
{
return gl::error(GL_INVALID_VALUE, false);
}
return true;
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
// any value is permissible
return true;
case GL_TEXTURE_COMPARE_MODE:
switch (param)
{
case GL_NONE:
case GL_COMPARE_REF_TO_TEXTURE:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_COMPARE_FUNC:
switch (param)
{
case GL_LEQUAL:
case GL_GEQUAL:
case GL_LESS:
case GL_GREATER:
case GL_EQUAL:
case GL_NOTEQUAL:
case GL_ALWAYS:
case GL_NEVER:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_TEXTURE_SWIZZLE_R:
case GL_TEXTURE_SWIZZLE_G:
case GL_TEXTURE_SWIZZLE_B:
case GL_TEXTURE_SWIZZLE_A:
case GL_TEXTURE_BASE_LEVEL:
case GL_TEXTURE_MAX_LEVEL:
UNIMPLEMENTED();
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
bool validateSamplerObjectParameter(GLenum pname)
{
switch (pname)
{
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
case GL_TEXTURE_COMPARE_MODE:
case GL_TEXTURE_COMPARE_FUNC:
return true;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
}
src/libGLESv2/validationES.h 0 → 100644
//
// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES.h: Validation functions for generic OpenGL ES entry point parameters
#ifndef LIBGLESV2_VALIDATION_ES_H
#define LIBGLESV2_VALIDATION_ES_H
namespace gl
{
class Context;
bool validateRenderbufferStorageParameters(const gl::Context *context, GLenum target, GLsizei samples,
GLenum internalformat, GLsizei width, GLsizei height,
bool angleExtension);
bool validateBlitFramebufferParameters(gl::Context *context, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
GLenum filter, bool fromAngleExtension);
bool validateGetVertexAttribParameters(GLenum pname, int clientVersion);
bool validateTexParamParameters(gl::Context *context, GLenum pname, GLint param);
bool validateSamplerObjectParameter(GLenum pname);
}
#endif // LIBGLESV2_VALIDATION_ES_H
src/libGLESv2/validationES2.cpp 0 → 100644
#include "precompiled.h"
//
// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES2.cpp: Validation functions for OpenGL ES 2.0 entry point parameters
#include "libGLESv2/validationES2.h"
#include "libGLESv2/Context.h"
#include "libGLESv2/Texture.h"
#include "libGLESv2/Framebuffer.h"
#include "libGLESv2/Renderbuffer.h"
#include "libGLESv2/formatutils.h"
#include "libGLESv2/main.h"
#include "common/mathutil.h"
#include "common/utilities.h"
namespace gl
{
static bool validImageSize(const gl::Context *context, GLint level, GLsizei width, GLsizei height, GLsizei depth)
{
if (level < 0 || width < 0 || height < 0 || depth < 0)
{
return false;
}
if (context->supportsNonPower2Texture())
{
return true;
}
if (level == 0)
{
return true;
}
if (gl::isPow2(width) && gl::isPow2(height) && gl::isPow2(depth))
{
return true;
}
return false;
}
static bool validCompressedImageSize(GLsizei width, GLsizei height)
{
if (width != 1 && width != 2 && width % 4 != 0)
{
return false;
}
if (height != 1 && height != 2 && height % 4 != 0)
{
return false;
}
return true;
}
static bool validateSubImageParams2D(bool compressed, GLsizei width, GLsizei height,
GLint xoffset, GLint yoffset, GLint level, GLenum format, GLenum type,
gl::Texture2D *texture)
{
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (compressed != texture->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (format != GL_NONE)
{
GLenum internalformat = gl::GetSizedInternalFormat(format, type, 2);
if (internalformat != texture->getInternalFormat(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (compressed)
{
if ((width % 4 != 0 && width != texture->getWidth(0)) ||
(height % 4 != 0 && height != texture->getHeight(0)))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (xoffset + width > texture->getWidth(level) ||
yoffset + height > texture->getHeight(level))
{
return gl::error(GL_INVALID_VALUE, false);
}
return true;
}
static bool validateSubImageParamsCube(bool compressed, GLsizei width, GLsizei height,
GLint xoffset, GLint yoffset, GLenum target, GLint level, GLenum format, GLenum type,
gl::TextureCubeMap *texture)
{
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (compressed != texture->isCompressed(target, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (format != GL_NONE)
{
GLenum internalformat = gl::GetSizedInternalFormat(format, type, 2);
if (internalformat != texture->getInternalFormat(target, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (compressed)
{
if ((width % 4 != 0 && width != texture->getWidth(target, 0)) ||
(height % 4 != 0 && height != texture->getHeight(target, 0)))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (xoffset + width > texture->getWidth(target, level) ||
yoffset + height > texture->getHeight(target, level))
{
return gl::error(GL_INVALID_VALUE, false);
}
return true;
}
bool validateES2TexImageParameters(gl::Context *context, GLenum target, GLint level, GLint internalformat, bool isCompressed, bool isSubImage,
GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
if (!validImageSize(context, level, width, height, 1))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (isCompressed && !validCompressedImageSize(width, height))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (level < 0 || xoffset < 0 ||
std::numeric_limits<GLsizei>::max() - xoffset < width ||
std::numeric_limits<GLsizei>::max() - yoffset < height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!isSubImage && !isCompressed && internalformat != GLint(format))
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture *texture = NULL;
bool textureCompressed = false;
GLenum textureInternalFormat = GL_NONE;
GLint textureLevelWidth = 0;
GLint textureLevelHeight = 0;
switch (target)
{
case GL_TEXTURE_2D:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2D *tex2d = context->getTexture2D();
if (tex2d)
{
textureCompressed = tex2d->isCompressed(level);
textureInternalFormat = tex2d->getInternalFormat(level);
textureLevelWidth = tex2d->getWidth(level);
textureLevelHeight = tex2d->getHeight(level);
texture = tex2d;
}
if (isSubImage && !validateSubImageParams2D(isCompressed, width, height, xoffset, yoffset,
level, format, type, tex2d))
{
return false;
}
texture = tex2d;
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (!isSubImage && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension() >> level) ||
height > (context->getMaximumCubeTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::TextureCubeMap *texCube = context->getTextureCubeMap();
if (texCube)
{
textureCompressed = texCube->isCompressed(target, level);
textureInternalFormat = texCube->getInternalFormat(target, level);
textureLevelWidth = texCube->getWidth(target, level);
textureLevelHeight = texCube->getHeight(target, level);
texture = texCube;
}
if (isSubImage && !validateSubImageParamsCube(isCompressed, width, height, xoffset, yoffset,
target, level, format, type, texCube))
{
return false;
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (!isSubImage && texture->isImmutable())
{
return gl::error(GL_INVALID_OPERATION, false);
}
// Verify zero border
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
// Verify texture is not requesting more mip levels than are available.
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
GLenum actualInternalFormat = isSubImage ? textureInternalFormat : internalformat;
if (isCompressed)
{
switch (actualInternalFormat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (!context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (!context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (!context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
else
{
// validate <type> by itself (used as secondary key below)
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
case GL_UNSIGNED_INT_24_8_OES:
case GL_HALF_FLOAT_OES:
case GL_FLOAT:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
// validate <format> + <type> combinations
// - invalid <format> -> sets INVALID_ENUM
// - invalid <format>+<type> combination -> sets INVALID_OPERATION
switch (format)
{
case GL_ALPHA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_RGB:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_RGBA:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_BGRA_EXT:
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: // error cases for compressed textures are handled below
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
break;
case GL_DEPTH_COMPONENT:
switch (type)
{
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_DEPTH_STENCIL_OES:
switch (type)
{
case GL_UNSIGNED_INT_24_8_OES:
break;
default:
return gl::error(GL_INVALID_OPERATION, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
switch (format)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
if (!context->supportsDepthTextures())
{
return gl::error(GL_INVALID_VALUE, false);
}
if (target != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// OES_depth_texture supports loading depth data and multiple levels,
// but ANGLE_depth_texture does not
if (pixels != NULL || level != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
default:
break;
}
if (type == GL_FLOAT)
{
if (!context->supportsFloat32Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
}
else if (type == GL_HALF_FLOAT_OES)
{
if (!context->supportsFloat16Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
}
}
return true;
}
bool validateES2CopyTexImageParameters(gl::Context* context, GLenum target, GLint level, GLenum internalformat, bool isSubImage,
GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height,
GLint border)
{
if (!gl::IsInternalTextureTarget(target, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width == 0 || height == 0)
{
return false;
}
// Verify zero border
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
// Validate dimensions based on Context limits and validate the texture
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Framebuffer *framebuffer = context->getReadFramebuffer();
if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
}
if (context->getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
GLenum colorbufferFormat = framebuffer->getReadColorbuffer()->getInternalFormat();
gl::Texture *texture = NULL;
GLenum textureFormat = GL_RGBA;
switch (target)
{
case GL_TEXTURE_2D:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2D *tex2d = context->getTexture2D();
if (tex2d)
{
if (isSubImage && !validateSubImageParams2D(false, width, height, xoffset, yoffset, level, GL_NONE, GL_NONE, tex2d))
{
return false; // error already registered by validateSubImageParams
}
texture = tex2d;
textureFormat = gl::GetFormat(tex2d->getInternalFormat(level), context->getClientVersion());
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (!isSubImage && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension() >> level) ||
height > (context->getMaximumCubeTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::TextureCubeMap *texcube = context->getTextureCubeMap();
if (texcube)
{
if (isSubImage && !validateSubImageParamsCube(false, width, height, xoffset, yoffset, target, level, GL_NONE, GL_NONE, texcube))
{
return false; // error already registered by validateSubImageParams
}
texture = texcube;
textureFormat = gl::GetFormat(texcube->getInternalFormat(target, level), context->getClientVersion());
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable() && !isSubImage)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// [OpenGL ES 2.0.24] table 3.9
if (isSubImage)
{
switch (textureFormat)
{
case GL_ALPHA:
if (colorbufferFormat != GL_ALPHA8_EXT &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE:
case GL_RGB:
if (colorbufferFormat != GL_RGB565 &&
colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
if (colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
return gl::error(GL_INVALID_OPERATION, false);
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
return gl::error(GL_INVALID_OPERATION, false);
default:
return gl::error(GL_INVALID_OPERATION, false);
}
}
else
{
switch (internalformat)
{
case GL_ALPHA:
if (colorbufferFormat != GL_ALPHA8_EXT &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE:
case GL_RGB:
if (colorbufferFormat != GL_RGB565 &&
colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
if (colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_RGBA8_OES)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH_STENCIL_OES:
case GL_DEPTH24_STENCIL8_OES:
if (context->supportsDepthTextures())
{
return gl::error(GL_INVALID_OPERATION, false);
}
else
{
return gl::error(GL_INVALID_ENUM, false);
}
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
return true;
}
bool validateES2TexStorageParameters(gl::Context *context, GLenum target, GLsizei levels, GLenum internalformat,
GLsizei width, GLsizei height)
{
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (width < 1 || height < 1 || levels < 1)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (target == GL_TEXTURE_CUBE_MAP && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (levels != 1 && levels != gl::log2(std::max(width, height)) + 1)
{
return gl::error(GL_INVALID_OPERATION, false);
}
GLenum format = gl::GetFormat(internalformat, context->getClientVersion());
GLenum type = gl::GetType(internalformat, context->getClientVersion());
if (format == GL_NONE || type == GL_NONE)
{
return gl::error(GL_INVALID_ENUM, false);
}
switch (target)
{
case GL_TEXTURE_2D:
if (width > context->getMaximum2DTextureDimension() ||
height > context->getMaximum2DTextureDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
break;
case GL_TEXTURE_CUBE_MAP:
if (width > context->getMaximumCubeTextureDimension() ||
height > context->getMaximumCubeTextureDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (levels != 1 && !context->supportsNonPower2Texture())
{
if (!gl::isPow2(width) || !gl::isPow2(height))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
switch (internalformat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (!context->supportsDXT1Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (!context->supportsDXT3Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (!context->supportsDXT5Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_RGBA32F_EXT:
case GL_RGB32F_EXT:
case GL_ALPHA32F_EXT:
case GL_LUMINANCE32F_EXT:
case GL_LUMINANCE_ALPHA32F_EXT:
if (!context->supportsFloat32Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_RGBA16F_EXT:
case GL_RGB16F_EXT:
case GL_ALPHA16F_EXT:
case GL_LUMINANCE16F_EXT:
case GL_LUMINANCE_ALPHA16F_EXT:
if (!context->supportsFloat16Textures())
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH24_STENCIL8_OES:
if (!context->supportsDepthTextures())
{
return gl::error(GL_INVALID_ENUM, false);
}
if (target != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// ANGLE_depth_texture only supports 1-level textures
if (levels != 1)
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
default:
break;
}
gl::Texture *texture = NULL;
switch(target)
{
case GL_TEXTURE_2D:
texture = context->getTexture2D();
break;
case GL_TEXTURE_CUBE_MAP:
texture = context->getTextureCubeMap();
break;
default:
UNREACHABLE();
}
if (!texture || texture->id() == 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable())
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
bool validateES2FramebufferTextureParameters(gl::Context *context, GLenum target, GLenum attachment,
GLenum textarget, GLuint texture, GLint level)
{
META_ASSERT(GL_DRAW_FRAMEBUFFER == GL_DRAW_FRAMEBUFFER_ANGLE && GL_READ_FRAMEBUFFER == GL_READ_FRAMEBUFFER_ANGLE);
if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER && target != GL_READ_FRAMEBUFFER)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15)
{
const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0);
if (colorAttachment >= context->getMaximumRenderTargets())
{
return gl::error(GL_INVALID_VALUE, false);
}
}
else
{
switch (attachment)
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
if (texture != 0)
{
gl::Texture *tex = context->getTexture(texture);
if (tex == NULL)
{
return gl::error(GL_INVALID_OPERATION, false);
}
switch (textarget)
{
case GL_TEXTURE_2D:
{
if (tex->getTarget() != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture2D *tex2d = static_cast<gl::Texture2D *>(tex);
if (tex2d->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::TextureCubeMap *texcube = static_cast<gl::TextureCubeMap *>(tex);
if (texcube->isCompressed(textarget, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (level != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
}
gl::Framebuffer *framebuffer = NULL;
GLuint framebufferHandle = 0;
if (target == GL_READ_FRAMEBUFFER)
{
framebuffer = context->getReadFramebuffer();
framebufferHandle = context->getReadFramebufferHandle();
}
else
{
framebuffer = context->getDrawFramebuffer();
framebufferHandle = context->getDrawFramebufferHandle();
}
if (framebufferHandle == 0 || !framebuffer)
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
// check for combinations of format and type that are valid for ReadPixels
bool validES2ReadFormatType(GLenum format, GLenum type)
{
switch (format)
{
case GL_RGBA:
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
default:
return false;
}
break;
case GL_BGRA_EXT:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
break;
default:
return false;
}
break;
default:
return false;
}
return true;
}
}
src/libGLESv2/validationES2.h 0 → 100644
//
// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES2.h: Validation functions for OpenGL ES 2.0 entry point parameters
#ifndef LIBGLESV2_VALIDATION_ES2_H
#define LIBGLESV2_VALIDATION_ES2_H
namespace gl
{
class Context;
bool validateES2TexImageParameters(gl::Context *context, GLenum target, GLint level, GLint internalformat, bool isCompressed, bool isSubImage,
GLint xoffset, GLint yoffset, GLsizei width, GLsizei height,
GLint border, GLenum format, GLenum type, const GLvoid *pixels);
bool validateES2CopyTexImageParameters(gl::Context* context, GLenum target, GLint level, GLenum internalformat, bool isSubImage,
GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height,
GLint border);
bool validateES2TexStorageParameters(gl::Context *context, GLenum target, GLsizei levels, GLenum internalformat,
GLsizei width, GLsizei height);
bool validateES2FramebufferTextureParameters(gl::Context *context, GLenum target, GLenum attachment,
GLenum textarget, GLuint texture, GLint level);
bool validES2ReadFormatType(GLenum format, GLenum type);
}
#endif // LIBGLESV2_VALIDATION_ES2_H
src/libGLESv2/validationES3.cpp 0 → 100644
#include "precompiled.h"
//
// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES3.cpp: Validation functions for OpenGL ES 3.0 entry point parameters
#include "libGLESv2/validationES3.h"
#include "libGLESv2/Context.h"
#include "libGLESv2/Texture.h"
#include "libGLESv2/Framebuffer.h"
#include "libGLESv2/Renderbuffer.h"
#include "libGLESv2/formatutils.h"
#include "libGLESv2/main.h"
#include "common/mathutil.h"
namespace gl
{
static bool validImageSize(const gl::Context *context, GLint level, GLsizei width, GLsizei height, GLsizei depth)
{
if (level < 0 || width < 0 || height < 0 || depth < 0)
{
return false;
}
if (context->supportsNonPower2Texture())
{
return true;
}
if (level == 0)
{
return true;
}
if (gl::isPow2(width) && gl::isPow2(height) && gl::isPow2(depth))
{
return true;
}
return false;
}
static bool validCompressedImageSize(GLsizei width, GLsizei height)
{
if (width != 1 && width != 2 && width % 4 != 0)
{
return false;
}
if (height != 1 && height != 2 && height % 4 != 0)
{
return false;
}
return true;
}
bool validateES3TexImageParameters(gl::Context *context, GLenum target, GLint level, GLint internalformat, bool isCompressed, bool isSubImage,
GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLint border, GLenum format, GLenum type)
{
// Validate image size
if (!validImageSize(context, level, width, height, depth))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (isCompressed && !validCompressedImageSize(width, height))
{
return gl::error(GL_INVALID_OPERATION, false);
}
// Verify zero border
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
// Validate dimensions based on Context limits and validate the texture
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture *texture = NULL;
bool textureCompressed = false;
GLenum textureInternalFormat = GL_NONE;
GLint textureLevelWidth = 0;
GLint textureLevelHeight = 0;
GLint textureLevelDepth = 0;
switch (target)
{
case GL_TEXTURE_2D:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2D *texture2d = context->getTexture2D();
if (texture2d)
{
textureCompressed = texture2d->isCompressed(level);
textureInternalFormat = texture2d->getInternalFormat(level);
textureLevelWidth = texture2d->getWidth(level);
textureLevelHeight = texture2d->getHeight(level);
textureLevelDepth = 1;
texture = texture2d;
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (!isSubImage && width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
if (textureCube)
{
textureCompressed = textureCube->isCompressed(target, level);
textureInternalFormat = textureCube->getInternalFormat(target, level);
textureLevelWidth = textureCube->getWidth(target, level);
textureLevelHeight = textureCube->getHeight(target, level);
textureLevelDepth = 1;
texture = textureCube;
}
}
break;
case GL_TEXTURE_3D:
{
if (width > (context->getMaximum3DTextureDimension() >> level) ||
height > (context->getMaximum3DTextureDimension() >> level) ||
depth > (context->getMaximum3DTextureDimension() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture3D *texture3d = context->getTexture3D();
if (texture3d)
{
textureCompressed = texture3d->isCompressed(level);
textureInternalFormat = texture3d->getInternalFormat(level);
textureLevelWidth = texture3d->getWidth(level);
textureLevelHeight = texture3d->getHeight(level);
textureLevelDepth = texture3d->getDepth(level);
texture = texture3d;
}
}
break;
case GL_TEXTURE_2D_ARRAY:
{
if (width > (context->getMaximum2DTextureDimension() >> level) ||
height > (context->getMaximum2DTextureDimension() >> level) ||
depth > (context->getMaximum2DArrayTextureLayers() >> level))
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2DArray *texture2darray = context->getTexture2DArray();
if (texture2darray)
{
textureCompressed = texture2darray->isCompressed(level);
textureInternalFormat = texture2darray->getInternalFormat(level);
textureLevelWidth = texture2darray->getWidth(level);
textureLevelHeight = texture2darray->getHeight(level);
textureLevelDepth = texture2darray->getDepth(level);
texture = texture2darray;
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable() && !isSubImage)
{
return gl::error(GL_INVALID_OPERATION, false);
}
// Validate texture formats
GLenum actualInternalFormat = isSubImage ? textureInternalFormat : internalformat;
if (isCompressed)
{
if (!gl::IsFormatCompressed(actualInternalFormat, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (target == GL_TEXTURE_3D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
else
{
if (!gl::IsValidInternalFormat(actualInternalFormat, context) ||
!gl::IsValidFormat(format, context->getClientVersion()) ||
!gl::IsValidType(type, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (!gl::IsValidFormatCombination(actualInternalFormat, format, type, context->getClientVersion()))
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (target == GL_TEXTURE_3D && (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
// Validate sub image parameters
if (isSubImage)
{
if (isCompressed != textureCompressed)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (format != GL_NONE)
{
GLenum internalformat = gl::GetSizedInternalFormat(format, type, context->getClientVersion());
if (internalformat != textureInternalFormat)
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (isCompressed)
{
if ((width % 4 != 0 && width != textureLevelWidth) ||
(height % 4 != 0 && height != textureLevelHeight))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (width == 0 || height == 0 || depth == 0)
{
return false;
}
if (xoffset < 0 || yoffset < 0 || zoffset < 0)
{
return gl::error(GL_INVALID_VALUE, 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);
}
if (xoffset + width > textureLevelWidth ||
yoffset + height > textureLevelHeight ||
zoffset + depth > textureLevelDepth)
{
return gl::error(GL_INVALID_VALUE, false);
}
}
return true;
}
bool validateES3CopyTexImageParameters(gl::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 (level < 0 || xoffset < 0 || yoffset < 0 || zoffset < 0 || width < 0 || height < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width == 0 || height == 0)
{
return false;
}
if (border != 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (level > context->getMaximumTextureLevel())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Framebuffer *framebuffer = context->getReadFramebuffer();
if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
{
return gl::error(GL_INVALID_FRAMEBUFFER_OPERATION, false);
}
if (context->getReadFramebufferHandle() != 0 && framebuffer->getSamples() != 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Renderbuffer *source = framebuffer->getReadColorbuffer();
GLenum colorbufferInternalFormat = source->getInternalFormat();
gl::Texture *texture = NULL;
GLenum textureInternalFormat = GL_NONE;
bool textureCompressed = false;
bool textureIsDepth = false;
GLint textureLevelWidth = 0;
GLint textureLevelHeight = 0;
GLint textureLevelDepth = 0;
switch (target)
{
case GL_TEXTURE_2D:
{
gl::Texture2D *texture2d = context->getTexture2D();
if (texture2d)
{
textureInternalFormat = texture2d->getInternalFormat(level);
textureCompressed = texture2d->isCompressed(level);
textureIsDepth = texture2d->isDepth(level);
textureLevelWidth = texture2d->getWidth(level);
textureLevelHeight = texture2d->getHeight(level);
textureLevelDepth = 1;
texture = texture2d;
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
if (textureCube)
{
textureInternalFormat = textureCube->getInternalFormat(target, level);
textureCompressed = textureCube->isCompressed(target, level);
textureIsDepth = false;
textureLevelWidth = textureCube->getWidth(target, level);
textureLevelHeight = textureCube->getHeight(target, level);
textureLevelDepth = 1;
texture = textureCube;
}
}
break;
case GL_TEXTURE_2D_ARRAY:
{
gl::Texture2DArray *texture2dArray = context->getTexture2DArray();
if (texture2dArray)
{
textureInternalFormat = texture2dArray->getInternalFormat(level);
textureCompressed = texture2dArray->isCompressed(level);
textureIsDepth = texture2dArray->isDepth(level);
textureLevelWidth = texture2dArray->getWidth(level);
textureLevelHeight = texture2dArray->getHeight(level);
textureLevelDepth = texture2dArray->getDepth(level);
texture = texture2dArray;
}
}
break;
case GL_TEXTURE_3D:
{
gl::Texture3D *texture3d = context->getTexture3D();
if (texture3d)
{
textureInternalFormat = texture3d->getInternalFormat(level);
textureCompressed = texture3d->isCompressed(level);
textureIsDepth = texture3d->isDepth(level);
textureLevelWidth = texture3d->getWidth(level);
textureLevelHeight = texture3d->getHeight(level);
textureLevelDepth = texture3d->getDepth(level);
texture = texture3d;
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable() && !isSubImage)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (textureIsDepth)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (textureCompressed)
{
if ((width % 4 != 0 && width != textureLevelWidth) ||
(height % 4 != 0 && height != textureLevelHeight))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
if (isSubImage)
{
if (xoffset + width > textureLevelWidth ||
yoffset + height > textureLevelHeight ||
zoffset >= textureLevelDepth)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!gl::IsValidCopyTexImageCombination(textureInternalFormat, colorbufferInternalFormat,
context->getClientVersion()))
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
return true;
}
bool validateES3TexStorageParameters(gl::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);
}
if (levels > gl::log2(std::max(std::max(width, height), depth)) + 1)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture *texture = NULL;
switch (target)
{
case GL_TEXTURE_2D:
{
texture = context->getTexture2D();
if (width > (context->getMaximum2DTextureDimension()) ||
height > (context->getMaximum2DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
texture = context->getTextureCubeMap();
if (width != height)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (width > (context->getMaximumCubeTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
case GL_TEXTURE_3D:
{
texture = context->getTexture3D();
if (width > (context->getMaximum3DTextureDimension()) ||
height > (context->getMaximum3DTextureDimension()) ||
depth > (context->getMaximum3DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
case GL_TEXTURE_2D_ARRAY:
{
texture = context->getTexture2DArray();
if (width > (context->getMaximum2DTextureDimension()) ||
height > (context->getMaximum2DTextureDimension()) ||
depth > (context->getMaximum2DArrayTextureLayers()))
{
return gl::error(GL_INVALID_VALUE, false);
}
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
if (!texture || texture->id() == 0)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (texture->isImmutable())
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (!gl::IsValidInternalFormat(internalformat, context))
{
return gl::error(GL_INVALID_ENUM, false);
}
if (!gl::IsSizedInternalFormat(internalformat, context->getClientVersion()))
{
return gl::error(GL_INVALID_ENUM, false);
}
return true;
}
bool validateES3FramebufferTextureParameters(gl::Context *context, GLenum target, GLenum attachment,
GLenum textarget, GLuint texture, GLint level, GLint layer,
bool layerCall)
{
if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER && target != GL_READ_FRAMEBUFFER)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (attachment >= GL_COLOR_ATTACHMENT0 && attachment <= GL_COLOR_ATTACHMENT15)
{
const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0);
if (colorAttachment >= context->getMaximumRenderTargets())
{
return gl::error(GL_INVALID_VALUE, false);
}
}
else
{
switch (attachment)
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
case GL_DEPTH_STENCIL_ATTACHMENT:
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
if (texture != 0)
{
gl::Texture *tex = context->getTexture(texture);
if (tex == NULL)
{
return gl::error(GL_INVALID_OPERATION, false);
}
if (level < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (layer < 0)
{
return gl::error(GL_INVALID_VALUE, false);
}
if (!layerCall)
{
switch (textarget)
{
case GL_TEXTURE_2D:
{
if (level > gl::log2(context->getMaximum2DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (tex->getTarget() != GL_TEXTURE_2D)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::Texture2D *tex2d = static_cast<gl::Texture2D *>(tex);
if (tex2d->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
{
if (level > gl::log2(context->getMaximumCubeTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
{
return gl::error(GL_INVALID_OPERATION, false);
}
gl::TextureCubeMap *texcube = static_cast<gl::TextureCubeMap *>(tex);
if (texcube->isCompressed(textarget, level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
else
{
switch (tex->getTarget())
{
case GL_TEXTURE_2D_ARRAY:
{
if (level > gl::log2(context->getMaximum2DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (layer >= context->getMaximum2DArrayTextureLayers())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture2DArray *texArray = static_cast<gl::Texture2DArray *>(tex);
if (texArray->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
case GL_TEXTURE_3D:
{
if (level > gl::log2(context->getMaximum3DTextureDimension()))
{
return gl::error(GL_INVALID_VALUE, false);
}
if (layer >= context->getMaximum3DTextureDimension())
{
return gl::error(GL_INVALID_VALUE, false);
}
gl::Texture3D *tex3d = static_cast<gl::Texture3D *>(tex);
if (tex3d->isCompressed(level))
{
return gl::error(GL_INVALID_OPERATION, false);
}
break;
}
default:
return gl::error(GL_INVALID_OPERATION, false);
}
}
}
gl::Framebuffer *framebuffer = NULL;
GLuint framebufferHandle = 0;
if (target == GL_READ_FRAMEBUFFER)
{
framebuffer = context->getReadFramebuffer();
framebufferHandle = context->getReadFramebufferHandle();
}
else
{
framebuffer = context->getDrawFramebuffer();
framebufferHandle = context->getDrawFramebufferHandle();
}
if (framebufferHandle == 0 || !framebuffer)
{
return gl::error(GL_INVALID_OPERATION, false);
}
return true;
}
bool validES3ReadFormatType(GLenum internalFormat, GLenum format, GLenum type)
{
switch (format)
{
case GL_RGBA:
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
if (internalFormat != GL_RGB10_A2)
{
return false;
}
break;
default:
return false;
}
break;
case GL_RGBA_INTEGER:
switch (type)
{
case GL_INT:
if (!gl::IsSignedIntegerFormat(internalFormat, 3))
{
return false;
}
break;
case GL_UNSIGNED_INT:
if (!gl::IsUnsignedIntegerFormat(internalFormat, 3))
{
return false;
}
break;
default:
return false;
}
break;
case GL_BGRA_EXT:
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
break;
default:
return false;
}
break;
default:
return false;
}
return true;
}
bool validateInvalidateFramebufferParameters(gl::Context *context, GLenum target, GLsizei numAttachments,
const GLenum* attachments)
{
bool defaultFramebuffer = false;
switch (target)
{
case GL_DRAW_FRAMEBUFFER:
case GL_FRAMEBUFFER:
defaultFramebuffer = context->getDrawFramebufferHandle() == 0;
break;
case GL_READ_FRAMEBUFFER:
defaultFramebuffer = context->getReadFramebufferHandle() == 0;
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
for (int i = 0; i < numAttachments; ++i)
{
if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[i] <= GL_COLOR_ATTACHMENT15)
{
if (defaultFramebuffer)
{
return gl::error(GL_INVALID_ENUM, false);
}
if (attachments[i] >= GL_COLOR_ATTACHMENT0 + context->getMaximumRenderTargets())
{
return gl::error(GL_INVALID_OPERATION, false);
}
}
else
{
switch (attachments[i])
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
case GL_DEPTH_STENCIL_ATTACHMENT:
if (defaultFramebuffer)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
case GL_COLOR:
case GL_DEPTH:
case GL_STENCIL:
if (!defaultFramebuffer)
{
return gl::error(GL_INVALID_ENUM, false);
}
break;
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
}
return true;
}
}
src/libGLESv2/validationES3.h 0 → 100644
//
// Copyright (c) 2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES3.h: Validation functions for OpenGL ES 3.0 entry point parameters
#ifndef LIBGLESV2_VALIDATION_ES3_H
#define LIBGLESV2_VALIDATION_ES3_H
namespace gl
{
class Context;
bool validateES3TexImageParameters(gl::Context *context, GLenum target, GLint level, GLint internalformat, bool isCompressed, bool isSubImage,
GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
GLint border, GLenum format, GLenum type);
bool validateES3CopyTexImageParameters(gl::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);
bool validateES3TexStorageParameters(gl::Context *context, GLenum target, GLsizei levels, GLenum internalformat,
GLsizei width, GLsizei height, GLsizei depth);
bool validateES3FramebufferTextureParameters(gl::Context *context, GLenum target, GLenum attachment,
GLenum textarget, GLuint texture, GLint level, GLint layer,
bool layerCall);
bool validES3ReadFormatType(GLenum internalFormat, GLenum format, GLenum type);
bool validateInvalidateFramebufferParameters(gl::Context *context, GLenum target, GLsizei numAttachments,
const GLenum* attachments);
}
#endif // LIBGLESV2_VALIDATION_ES3_H
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment