blob: 6ce5dd3dbbbf55402bd16053f376712c365b4b28 [file] [log] [blame]
//
// Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// validationES2.cpp: Validation functions for OpenGL ES 2.0 entry point parameters
#include "libANGLE/validationES2.h"
#include <cstdint>
#include "common/mathutil.h"
#include "common/string_utils.h"
#include "common/utilities.h"
#include "libANGLE/Context.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/Renderbuffer.h"
#include "libANGLE/Shader.h"
#include "libANGLE/Texture.h"
#include "libANGLE/Uniform.h"
#include "libANGLE/VertexArray.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/validationES.h"
#include "libANGLE/validationES3.h"
namespace gl
{
namespace
{
bool IsPartialBlit(gl::Context *context,
const FramebufferAttachment *readBuffer,
const FramebufferAttachment *writeBuffer,
GLint srcX0,
GLint srcY0,
GLint srcX1,
GLint srcY1,
GLint dstX0,
GLint dstY0,
GLint dstX1,
GLint dstY1)
{
const Extents &writeSize = writeBuffer->getSize();
const Extents &readSize = readBuffer->getSize();
if (srcX0 != 0 || srcY0 != 0 || dstX0 != 0 || dstY0 != 0 || dstX1 != writeSize.width ||
dstY1 != writeSize.height || srcX1 != readSize.width || srcY1 != readSize.height)
{
return true;
}
if (context->getGLState().isScissorTestEnabled())
{
const Rectangle &scissor = context->getGLState().getScissor();
return scissor.x > 0 || scissor.y > 0 || scissor.width < writeSize.width ||
scissor.height < writeSize.height;
}
return false;
}
template <typename T>
bool ValidatePathInstances(gl::Context *context,
GLsizei numPaths,
const void *paths,
GLuint pathBase)
{
const auto *array = static_cast<const T *>(paths);
for (GLsizei i = 0; i < numPaths; ++i)
{
const GLuint pathName = array[i] + pathBase;
if (context->hasPath(pathName) && !context->hasPathData(pathName))
{
context->handleError(gl::Error(GL_INVALID_OPERATION, "No such path object."));
return false;
}
}
return true;
}
bool ValidateInstancedPathParameters(gl::Context *context,
GLsizei numPaths,
GLenum pathNameType,
const void *paths,
GLuint pathBase,
GLenum transformType,
const GLfloat *transformValues)
{
if (!context->getExtensions().pathRendering)
{
context->handleError(
gl::Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available."));
return false;
}
if (paths == nullptr)
{
context->handleError(gl::Error(GL_INVALID_VALUE, "No path name array."));
return false;
}
if (numPaths < 0)
{
context->handleError(gl::Error(GL_INVALID_VALUE, "Invalid (negative) numPaths."));
return false;
}
if (!angle::IsValueInRangeForNumericType<std::uint32_t>(numPaths))
{
context->handleError(gl::Error(GL_INVALID_OPERATION, "Overflow in numPaths."));
return false;
}
std::uint32_t pathNameTypeSize = 0;
std::uint32_t componentCount = 0;
switch (pathNameType)
{
case GL_UNSIGNED_BYTE:
pathNameTypeSize = sizeof(GLubyte);
if (!ValidatePathInstances<GLubyte>(context, numPaths, paths, pathBase))
return false;
break;
case GL_BYTE:
pathNameTypeSize = sizeof(GLbyte);
if (!ValidatePathInstances<GLbyte>(context, numPaths, paths, pathBase))
return false;
break;
case GL_UNSIGNED_SHORT:
pathNameTypeSize = sizeof(GLushort);
if (!ValidatePathInstances<GLushort>(context, numPaths, paths, pathBase))
return false;
break;
case GL_SHORT:
pathNameTypeSize = sizeof(GLshort);
if (!ValidatePathInstances<GLshort>(context, numPaths, paths, pathBase))
return false;
break;
case GL_UNSIGNED_INT:
pathNameTypeSize = sizeof(GLuint);
if (!ValidatePathInstances<GLuint>(context, numPaths, paths, pathBase))
return false;
break;
case GL_INT:
pathNameTypeSize = sizeof(GLint);
if (!ValidatePathInstances<GLint>(context, numPaths, paths, pathBase))
return false;
break;
default:
context->handleError(gl::Error(GL_INVALID_ENUM, "Invalid path name type."));
return false;
}
switch (transformType)
{
case GL_NONE:
componentCount = 0;
break;
case GL_TRANSLATE_X_CHROMIUM:
case GL_TRANSLATE_Y_CHROMIUM:
componentCount = 1;
break;
case GL_TRANSLATE_2D_CHROMIUM:
componentCount = 2;
break;
case GL_TRANSLATE_3D_CHROMIUM:
componentCount = 3;
break;
case GL_AFFINE_2D_CHROMIUM:
case GL_TRANSPOSE_AFFINE_2D_CHROMIUM:
componentCount = 6;
break;
case GL_AFFINE_3D_CHROMIUM:
case GL_TRANSPOSE_AFFINE_3D_CHROMIUM:
componentCount = 12;
break;
default:
context->handleError(gl::Error(GL_INVALID_ENUM, "Invalid transformation."));
return false;
}
if (componentCount != 0 && transformValues == nullptr)
{
context->handleError(gl::Error(GL_INVALID_VALUE, "No transform array given."));
return false;
}
angle::CheckedNumeric<std::uint32_t> checkedSize(0);
checkedSize += (numPaths * pathNameTypeSize);
checkedSize += (numPaths * sizeof(GLfloat) * componentCount);
if (!checkedSize.IsValid())
{
context->handleError(gl::Error(GL_INVALID_OPERATION, "Overflow in num paths."));
return false;
}
return true;
}
bool IsValidCopyTextureFormat(Context *context, GLenum internalFormat)
{
switch (GetUnsizedFormat(internalFormat))
{
case GL_ALPHA:
case GL_LUMINANCE:
case GL_LUMINANCE_ALPHA:
case GL_RGB:
case GL_RGBA:
return true;
case GL_RED:
return context->getClientMajorVersion() >= 3 || context->getExtensions().textureRG;
case GL_BGRA_EXT:
return context->getExtensions().textureFormatBGRA8888;
default:
return false;
}
}
bool IsValidCopyTextureDestinationFormatType(Context *context, GLint internalFormat, GLenum type)
{
switch (internalFormat)
{
case GL_RGB:
case GL_RGBA:
break;
case GL_BGRA_EXT:
return context->getExtensions().textureFormatBGRA8888;
default:
return false;
}
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
default:
return false;
}
return true;
}
bool IsValidCopyTextureDestinationTarget(Context *context, GLenum target)
{
switch (target)
{
case GL_TEXTURE_2D:
return true;
// TODO(geofflang): accept GL_TEXTURE_RECTANGLE_ARB if the texture_rectangle extension is
// supported
default:
return false;
}
}
bool IsValidCopyTextureSourceTarget(Context *context, GLenum target)
{
if (IsValidCopyTextureDestinationTarget(context, target))
{
return true;
}
// TODO(geofflang): accept GL_TEXTURE_EXTERNAL_OES if the texture_external extension is
// supported
return false;
}
bool IsValidStencilFunc(GLenum func)
{
switch (func)
{
case GL_NEVER:
case GL_ALWAYS:
case GL_LESS:
case GL_LEQUAL:
case GL_EQUAL:
case GL_GEQUAL:
case GL_GREATER:
case GL_NOTEQUAL:
return true;
default:
return false;
}
}
bool IsValidStencilFace(GLenum face)
{
switch (face)
{
case GL_FRONT:
case GL_BACK:
case GL_FRONT_AND_BACK:
return true;
default:
return false;
}
}
bool IsValidStencilOp(GLenum op)
{
switch (op)
{
case GL_ZERO:
case GL_KEEP:
case GL_REPLACE:
case GL_INCR:
case GL_DECR:
case GL_INVERT:
case GL_INCR_WRAP:
case GL_DECR_WRAP:
return true;
default:
return false;
}
}
bool ValidateES2CopyTexImageParameters(ValidationContext *context,
GLenum target,
GLint level,
GLenum internalformat,
bool isSubImage,
GLint xoffset,
GLint yoffset,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLint border)
{
if (!ValidTexture2DDestinationTarget(context, target))
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid texture target"));
return false;
}
if (!ValidImageSizeParameters(context, target, level, width, height, 1, isSubImage))
{
context->handleError(Error(GL_INVALID_VALUE, "Invalid texture dimensions."));
return false;
}
Format textureFormat = Format::Invalid();
if (!ValidateCopyTexImageParametersBase(context, target, level, internalformat, isSubImage,
xoffset, yoffset, 0, x, y, width, height, border,
&textureFormat))
{
return false;
}
const gl::Framebuffer *framebuffer = context->getGLState().getReadFramebuffer();
GLenum colorbufferFormat =
framebuffer->getReadColorbuffer()->getFormat().info->sizedInternalFormat;
const auto &formatInfo = *textureFormat.info;
// [OpenGL ES 2.0.24] table 3.9
if (isSubImage)
{
switch (formatInfo.format)
{
case GL_ALPHA:
if (colorbufferFormat != GL_ALPHA8_EXT && colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES &&
colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_LUMINANCE:
if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT &&
colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_RED_EXT:
if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT &&
colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_R32F &&
colorbufferFormat != GL_RG32F && colorbufferFormat != GL_RGB32F &&
colorbufferFormat != GL_RGBA32F && colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_RG_EXT:
if (colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 &&
colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES &&
colorbufferFormat != GL_RG32F && colorbufferFormat != GL_RGB32F &&
colorbufferFormat != GL_RGBA32F && colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_RGB:
if (colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_RGB32F &&
colorbufferFormat != GL_RGBA32F && colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
if (colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_RGBA32F &&
colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return 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:
case GL_ETC1_RGB8_OES:
case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
default:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
if (formatInfo.type == GL_FLOAT && !context->getExtensions().textureFloat)
{
context->handleError(Error(GL_INVALID_OPERATION));
return 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 && colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_LUMINANCE:
if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT &&
colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_RED_EXT:
if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT &&
colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES &&
colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 &&
colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_RG_EXT:
if (colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 &&
colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 &&
colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT &&
colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
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 &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return 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 &&
colorbufferFormat != GL_BGR5_A1_ANGLEX)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (context->getExtensions().textureCompressionDXT1)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (context->getExtensions().textureCompressionDXT3)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (context->getExtensions().textureCompressionDXT5)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_OES:
if (context->getExtensions().compressedETC1RGB8Texture)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
if (context->getExtensions().lossyETCDecode)
{
context->handleError(Error(GL_INVALID_OPERATION,
"ETC lossy decode formats can't be copied to."));
return false;
}
else
{
context->handleError(Error(
GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported."));
return 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->getExtensions().depthTextures)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
default:
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
}
// If width or height is zero, it is a no-op. Return false without setting an error.
return (width > 0 && height > 0);
}
bool ValidCap(const Context *context, GLenum cap, bool queryOnly)
{
switch (cap)
{
// EXT_multisample_compatibility
case GL_MULTISAMPLE_EXT:
case GL_SAMPLE_ALPHA_TO_ONE_EXT:
return context->getExtensions().multisampleCompatibility;
case GL_CULL_FACE:
case GL_POLYGON_OFFSET_FILL:
case GL_SAMPLE_ALPHA_TO_COVERAGE:
case GL_SAMPLE_COVERAGE:
case GL_SCISSOR_TEST:
case GL_STENCIL_TEST:
case GL_DEPTH_TEST:
case GL_BLEND:
case GL_DITHER:
return true;
case GL_PRIMITIVE_RESTART_FIXED_INDEX:
case GL_RASTERIZER_DISCARD:
return (context->getClientMajorVersion() >= 3);
case GL_DEBUG_OUTPUT_SYNCHRONOUS:
case GL_DEBUG_OUTPUT:
return context->getExtensions().debug;
case GL_BIND_GENERATES_RESOURCE_CHROMIUM:
return queryOnly && context->getExtensions().bindGeneratesResource;
case GL_CLIENT_ARRAYS_ANGLE:
return queryOnly && context->getExtensions().clientArrays;
case GL_FRAMEBUFFER_SRGB_EXT:
return context->getExtensions().sRGBWriteControl;
case GL_SAMPLE_MASK:
return context->getClientVersion() >= Version(3, 1);
case GL_CONTEXT_ROBUST_RESOURCE_INITIALIZATION_ANGLE:
return queryOnly && context->getExtensions().robustResourceInitialization;
default:
return false;
}
}
} // anonymous namespace
bool ValidateES2TexImageParameters(Context *context,
GLenum target,
GLint level,
GLenum internalformat,
bool isCompressed,
bool isSubImage,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
GLsizei imageSize,
const void *pixels)
{
if (!ValidTexture2DDestinationTarget(context, target))
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
if (!ValidImageSizeParameters(context, target, level, width, height, 1, isSubImage))
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (level < 0 || xoffset < 0 || std::numeric_limits<GLsizei>::max() - xoffset < width ||
std::numeric_limits<GLsizei>::max() - yoffset < height)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (!isSubImage && !isCompressed && internalformat != format)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
const gl::Caps &caps = context->getCaps();
if (target == GL_TEXTURE_2D)
{
if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) ||
static_cast<GLuint>(height) > (caps.max2DTextureSize >> level))
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
}
else if (IsCubeMapTextureTarget(target))
{
if (!isSubImage && width != height)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (static_cast<GLuint>(width) > (caps.maxCubeMapTextureSize >> level) ||
static_cast<GLuint>(height) > (caps.maxCubeMapTextureSize >> level))
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
gl::Texture *texture =
context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target);
if (!texture)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
if (isSubImage)
{
const InternalFormat &textureInternalFormat = *texture->getFormat(target, level).info;
if (textureInternalFormat.internalFormat == GL_NONE)
{
context->handleError(Error(GL_INVALID_OPERATION, "Texture level does not exist."));
return false;
}
if (format != GL_NONE)
{
if (GetInternalFormatInfo(format, type).sizedInternalFormat !=
textureInternalFormat.sizedInternalFormat)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
}
if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
static_cast<size_t>(yoffset + height) > texture->getHeight(target, level))
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
}
else
{
if (texture->getImmutableFormat())
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
}
// Verify zero border
if (border != 0)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (isCompressed)
{
GLenum actualInternalFormat =
isSubImage ? texture->getFormat(target, level).info->sizedInternalFormat
: internalformat;
switch (actualInternalFormat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (!context->getExtensions().textureCompressionDXT1)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (!context->getExtensions().textureCompressionDXT1)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (!context->getExtensions().textureCompressionDXT5)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
if (!context->getExtensions().textureCompressionS3TCsRGB)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_OES:
if (!context->getExtensions().compressedETC1RGB8Texture)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
if (!context->getExtensions().lossyETCDecode)
{
context->handleError(Error(
GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported"));
return false;
}
break;
default:
context->handleError(
Error(GL_INVALID_ENUM,
"internalformat is not a supported compressed internal format"));
return false;
}
if (isSubImage)
{
if (!ValidCompressedSubImageSize(context, actualInternalFormat, xoffset, yoffset, width,
height, texture->getWidth(target, level),
texture->getHeight(target, level)))
{
context->handleError(
Error(GL_INVALID_OPERATION, "Invalid compressed format dimension."));
return false;
}
if (format != actualInternalFormat)
{
context->handleError(Error(
GL_INVALID_OPERATION, "Format must match the internal format of the texture."));
return false;
}
}
else
{
if (!ValidCompressedImageSize(context, actualInternalFormat, level, width, height))
{
context->handleError(
Error(GL_INVALID_OPERATION, "Invalid compressed format dimension."));
return 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:
context->handleError(Error(GL_INVALID_ENUM));
return 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:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_RED:
case GL_RG:
if (!context->getExtensions().textureRG)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
switch (type)
{
case GL_UNSIGNED_BYTE:
case GL_FLOAT:
case GL_HALF_FLOAT_OES:
break;
default:
context->handleError(Error(GL_INVALID_OPERATION));
return 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:
context->handleError(Error(GL_INVALID_OPERATION));
return 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:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_BGRA_EXT:
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
default:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_SRGB_EXT:
case GL_SRGB_ALPHA_EXT:
if (!context->getExtensions().sRGB)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
switch (type)
{
case GL_UNSIGNED_BYTE:
break;
default:
context->handleError(Error(GL_INVALID_OPERATION));
return 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:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
case GL_DEPTH_STENCIL_OES:
switch (type)
{
case GL_UNSIGNED_INT_24_8_OES:
break;
default:
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
default:
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
switch (format)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (context->getExtensions().textureCompressionDXT1)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (context->getExtensions().textureCompressionDXT3)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (context->getExtensions().textureCompressionDXT5)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_OES:
if (context->getExtensions().compressedETC1RGB8Texture)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
else
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
if (context->getExtensions().lossyETCDecode)
{
context->handleError(
Error(GL_INVALID_OPERATION,
"ETC lossy decode formats can't work with this type."));
return false;
}
else
{
context->handleError(Error(
GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported."));
return false;
}
break;
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
if (!context->getExtensions().depthTextures)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (target != GL_TEXTURE_2D)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
// OES_depth_texture supports loading depth data and multiple levels,
// but ANGLE_depth_texture does not
if (pixels != nullptr || level != 0)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
default:
break;
}
if (type == GL_FLOAT)
{
if (!context->getExtensions().textureFloat)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
}
else if (type == GL_HALF_FLOAT_OES)
{
if (!context->getExtensions().textureHalfFloat)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
}
}
if (!ValidImageDataSize(context, target, width, height, 1, internalformat, type, pixels,
imageSize))
{
return false;
}
return true;
}
bool ValidateES2TexStorageParameters(Context *context,
GLenum target,
GLsizei levels,
GLenum internalformat,
GLsizei width,
GLsizei height)
{
if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
if (width < 1 || height < 1 || levels < 1)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (target == GL_TEXTURE_CUBE_MAP && width != height)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (levels != 1 && levels != gl::log2(std::max(width, height)) + 1)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
const gl::InternalFormat &formatInfo = gl::GetSizedInternalFormatInfo(internalformat);
if (formatInfo.format == GL_NONE || formatInfo.type == GL_NONE)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
const gl::Caps &caps = context->getCaps();
switch (target)
{
case GL_TEXTURE_2D:
if (static_cast<GLuint>(width) > caps.max2DTextureSize ||
static_cast<GLuint>(height) > caps.max2DTextureSize)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
break;
case GL_TEXTURE_CUBE_MAP:
if (static_cast<GLuint>(width) > caps.maxCubeMapTextureSize ||
static_cast<GLuint>(height) > caps.maxCubeMapTextureSize)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
break;
default:
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
if (levels != 1 && !context->getExtensions().textureNPOT)
{
if (!gl::isPow2(width) || !gl::isPow2(height))
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
}
switch (internalformat)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (!context->getExtensions().textureCompressionDXT1)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
if (!context->getExtensions().textureCompressionDXT3)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
if (!context->getExtensions().textureCompressionDXT5)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_OES:
if (!context->getExtensions().compressedETC1RGB8Texture)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
if (!context->getExtensions().lossyETCDecode)
{
context->handleError(
Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported."));
return 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->getExtensions().textureFloat)
{
context->handleError(Error(GL_INVALID_ENUM));
return 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->getExtensions().textureHalfFloat)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_R8_EXT:
case GL_RG8_EXT:
if (!context->getExtensions().textureRG)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_R16F_EXT:
case GL_RG16F_EXT:
if (!context->getExtensions().textureRG || !context->getExtensions().textureHalfFloat)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_R32F_EXT:
case GL_RG32F_EXT:
if (!context->getExtensions().textureRG || !context->getExtensions().textureFloat)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
break;
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT32_OES:
case GL_DEPTH24_STENCIL8_OES:
if (!context->getExtensions().depthTextures)
{
context->handleError(Error(GL_INVALID_ENUM));
return false;
}
if (target != GL_TEXTURE_2D)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
// ANGLE_depth_texture only supports 1-level textures
if (levels != 1)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
break;
default:
break;
}
gl::Texture *texture = context->getTargetTexture(target);
if (!texture || texture->id() == 0)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
if (texture->getImmutableFormat())
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
return true;
}
bool ValidateDiscardFramebufferEXT(Context *context,
GLenum target,
GLsizei numAttachments,
const GLenum *attachments)
{
if (!context->getExtensions().discardFramebuffer)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
bool defaultFramebuffer = false;
switch (target)
{
case GL_FRAMEBUFFER:
defaultFramebuffer =
(context->getGLState().getTargetFramebuffer(GL_FRAMEBUFFER)->id() == 0);
break;
default:
context->handleError(Error(GL_INVALID_ENUM, "Invalid framebuffer target"));
return false;
}
return ValidateDiscardFramebufferBase(context, target, numAttachments, attachments,
defaultFramebuffer);
}
bool ValidateBindVertexArrayOES(Context *context, GLuint array)
{
if (!context->getExtensions().vertexArrayObject)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
return ValidateBindVertexArrayBase(context, array);
}
bool ValidateDeleteVertexArraysOES(Context *context, GLsizei n)
{
if (!context->getExtensions().vertexArrayObject)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
return ValidateGenOrDelete(context, n);
}
bool ValidateGenVertexArraysOES(Context *context, GLsizei n)
{
if (!context->getExtensions().vertexArrayObject)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
return ValidateGenOrDelete(context, n);
}
bool ValidateIsVertexArrayOES(Context *context)
{
if (!context->getExtensions().vertexArrayObject)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
return true;
}
bool ValidateProgramBinaryOES(Context *context,
GLuint program,
GLenum binaryFormat,
const void *binary,
GLint length)
{
if (!context->getExtensions().getProgramBinary)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
return ValidateProgramBinaryBase(context, program, binaryFormat, binary, length);
}
bool ValidateGetProgramBinaryOES(Context *context,
GLuint program,
GLsizei bufSize,
GLsizei *length,
GLenum *binaryFormat,
void *binary)
{
if (!context->getExtensions().getProgramBinary)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
return ValidateGetProgramBinaryBase(context, program, bufSize, length, binaryFormat, binary);
}
static bool ValidDebugSource(GLenum source, bool mustBeThirdPartyOrApplication)
{
switch (source)
{
case GL_DEBUG_SOURCE_API:
case GL_DEBUG_SOURCE_SHADER_COMPILER:
case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
case GL_DEBUG_SOURCE_OTHER:
// Only THIRD_PARTY and APPLICATION sources are allowed to be manually inserted
return !mustBeThirdPartyOrApplication;
case GL_DEBUG_SOURCE_THIRD_PARTY:
case GL_DEBUG_SOURCE_APPLICATION:
return true;
default:
return false;
}
}
static bool ValidDebugType(GLenum type)
{
switch (type)
{
case GL_DEBUG_TYPE_ERROR:
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
case GL_DEBUG_TYPE_PERFORMANCE:
case GL_DEBUG_TYPE_PORTABILITY:
case GL_DEBUG_TYPE_OTHER:
case GL_DEBUG_TYPE_MARKER:
case GL_DEBUG_TYPE_PUSH_GROUP:
case GL_DEBUG_TYPE_POP_GROUP:
return true;
default:
return false;
}
}
static bool ValidDebugSeverity(GLenum severity)
{
switch (severity)
{
case GL_DEBUG_SEVERITY_HIGH:
case GL_DEBUG_SEVERITY_MEDIUM:
case GL_DEBUG_SEVERITY_LOW:
case GL_DEBUG_SEVERITY_NOTIFICATION:
return true;
default:
return false;
}
}
bool ValidateDebugMessageControlKHR(Context *context,
GLenum source,
GLenum type,
GLenum severity,
GLsizei count,
const GLuint *ids,
GLboolean enabled)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (!ValidDebugSource(source, false) && source != GL_DONT_CARE)
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source."));
return false;
}
if (!ValidDebugType(type) && type != GL_DONT_CARE)
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid debug type."));
return false;
}
if (!ValidDebugSeverity(severity) && severity != GL_DONT_CARE)
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid debug severity."));
return false;
}
if (count > 0)
{
if (source == GL_DONT_CARE || type == GL_DONT_CARE)
{
context->handleError(Error(
GL_INVALID_OPERATION,
"If count is greater than zero, source and severity cannot be GL_DONT_CARE."));
return false;
}
if (severity != GL_DONT_CARE)
{
context->handleError(
Error(GL_INVALID_OPERATION,
"If count is greater than zero, severity must be GL_DONT_CARE."));
return false;
}
}
return true;
}
bool ValidateDebugMessageInsertKHR(Context *context,
GLenum source,
GLenum type,
GLuint id,
GLenum severity,
GLsizei length,
const GLchar *buf)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (!context->getGLState().getDebug().isOutputEnabled())
{
// If the DEBUG_OUTPUT state is disabled calls to DebugMessageInsert are discarded and do
// not generate an error.
return false;
}
if (!ValidDebugSeverity(severity))
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid debug severity."));
return false;
}
if (!ValidDebugType(type))
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid debug type."));
return false;
}
if (!ValidDebugSource(source, true))
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source."));
return false;
}
size_t messageLength = (length < 0) ? strlen(buf) : length;
if (messageLength > context->getExtensions().maxDebugMessageLength)
{
context->handleError(
Error(GL_INVALID_VALUE, "Message length is larger than GL_MAX_DEBUG_MESSAGE_LENGTH."));
return false;
}
return true;
}
bool ValidateDebugMessageCallbackKHR(Context *context,
GLDEBUGPROCKHR callback,
const void *userParam)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
return true;
}
bool ValidateGetDebugMessageLogKHR(Context *context,
GLuint count,
GLsizei bufSize,
GLenum *sources,
GLenum *types,
GLuint *ids,
GLenum *severities,
GLsizei *lengths,
GLchar *messageLog)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (bufSize < 0 && messageLog != nullptr)
{
context->handleError(
Error(GL_INVALID_VALUE, "bufSize must be positive if messageLog is not null."));
return false;
}
return true;
}
bool ValidatePushDebugGroupKHR(Context *context,
GLenum source,
GLuint id,
GLsizei length,
const GLchar *message)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (!ValidDebugSource(source, true))
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source."));
return false;
}
size_t messageLength = (length < 0) ? strlen(message) : length;
if (messageLength > context->getExtensions().maxDebugMessageLength)
{
context->handleError(
Error(GL_INVALID_VALUE, "Message length is larger than GL_MAX_DEBUG_MESSAGE_LENGTH."));
return false;
}
size_t currentStackSize = context->getGLState().getDebug().getGroupStackDepth();
if (currentStackSize >= context->getExtensions().maxDebugGroupStackDepth)
{
context->handleError(
Error(GL_STACK_OVERFLOW,
"Cannot push more than GL_MAX_DEBUG_GROUP_STACK_DEPTH debug groups."));
return false;
}
return true;
}
bool ValidatePopDebugGroupKHR(Context *context)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
size_t currentStackSize = context->getGLState().getDebug().getGroupStackDepth();
if (currentStackSize <= 1)
{
context->handleError(Error(GL_STACK_UNDERFLOW, "Cannot pop the default debug group."));
return false;
}
return true;
}
static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier, GLuint name)
{
switch (identifier)
{
case GL_BUFFER:
if (context->getBuffer(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid buffer."));
return false;
}
return true;
case GL_SHADER:
if (context->getShader(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid shader."));
return false;
}
return true;
case GL_PROGRAM:
if (context->getProgram(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid program."));
return false;
}
return true;
case GL_VERTEX_ARRAY:
if (context->getVertexArray(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid vertex array."));
return false;
}
return true;
case GL_QUERY:
if (context->getQuery(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid query."));
return false;
}
return true;
case GL_TRANSFORM_FEEDBACK:
if (context->getTransformFeedback(name) == nullptr)
{
context->handleError(
Error(GL_INVALID_VALUE, "name is not a valid transform feedback."));
return false;
}
return true;
case GL_SAMPLER:
if (context->getSampler(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid sampler."));
return false;
}
return true;
case GL_TEXTURE:
if (context->getTexture(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid texture."));
return false;
}
return true;
case GL_RENDERBUFFER:
if (context->getRenderbuffer(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid renderbuffer."));
return false;
}
return true;
case GL_FRAMEBUFFER:
if (context->getFramebuffer(name) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid framebuffer."));
return false;
}
return true;
default:
context->handleError(Error(GL_INVALID_ENUM, "Invalid identifier."));
return false;
}
}
static bool ValidateLabelLength(Context *context, GLsizei length, const GLchar *label)
{
size_t labelLength = 0;
if (length < 0)
{
if (label != nullptr)
{
labelLength = strlen(label);
}
}
else
{
labelLength = static_cast<size_t>(length);
}
if (labelLength > context->getExtensions().maxLabelLength)
{
context->handleError(
Error(GL_INVALID_VALUE, "Label length is larger than GL_MAX_LABEL_LENGTH."));
return false;
}
return true;
}
bool ValidateObjectLabelKHR(Context *context,
GLenum identifier,
GLuint name,
GLsizei length,
const GLchar *label)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (!ValidateObjectIdentifierAndName(context, identifier, name))
{
return false;
}
if (!ValidateLabelLength(context, length, label))
{
return false;
}
return true;
}
bool ValidateGetObjectLabelKHR(Context *context,
GLenum identifier,
GLuint name,
GLsizei bufSize,
GLsizei *length,
GLchar *label)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (bufSize < 0)
{
context->handleError(Error(GL_INVALID_VALUE, "bufSize cannot be negative."));
return false;
}
if (!ValidateObjectIdentifierAndName(context, identifier, name))
{
return false;
}
return true;
}
static bool ValidateObjectPtrName(Context *context, const void *ptr)
{
if (context->getFenceSync(reinterpret_cast<GLsync>(const_cast<void *>(ptr))) == nullptr)
{
context->handleError(Error(GL_INVALID_VALUE, "name is not a valid sync."));
return false;
}
return true;
}
bool ValidateObjectPtrLabelKHR(Context *context,
const void *ptr,
GLsizei length,
const GLchar *label)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (!ValidateObjectPtrName(context, ptr))
{
return false;
}
if (!ValidateLabelLength(context, length, label))
{
return false;
}
return true;
}
bool ValidateGetObjectPtrLabelKHR(Context *context,
const void *ptr,
GLsizei bufSize,
GLsizei *length,
GLchar *label)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
if (bufSize < 0)
{
context->handleError(Error(GL_INVALID_VALUE, "bufSize cannot be negative."));
return false;
}
if (!ValidateObjectPtrName(context, ptr))
{
return false;
}
return true;
}
bool ValidateGetPointervKHR(Context *context, GLenum pname, void **params)
{
if (!context->getExtensions().debug)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled"));
return false;
}
// TODO: represent this in Context::getQueryParameterInfo.
switch (pname)
{
case GL_DEBUG_CALLBACK_FUNCTION:
case GL_DEBUG_CALLBACK_USER_PARAM:
break;
default:
context->handleError(Error(GL_INVALID_ENUM, "Invalid pname."));
return false;
}
return true;
}
bool ValidateBlitFramebufferANGLE(Context *context,
GLint srcX0,
GLint srcY0,
GLint srcX1,
GLint srcY1,
GLint dstX0,
GLint dstY0,
GLint dstX1,
GLint dstY1,
GLbitfield mask,
GLenum filter)
{
if (!context->getExtensions().framebufferBlit)
{
context->handleError(Error(GL_INVALID_OPERATION, "Blit extension not available."));
return false;
}
if (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0)
{
// TODO(jmadill): Determine if this should be available on other implementations.
context->handleError(Error(
GL_INVALID_OPERATION,
"Scaling and flipping in BlitFramebufferANGLE not supported by this implementation."));
return false;
}
if (filter == GL_LINEAR)
{
context->handleError(Error(GL_INVALID_ENUM, "Linear blit not supported in this extension"));
return false;
}
Framebuffer *readFramebuffer = context->getGLState().getReadFramebuffer();
Framebuffer *drawFramebuffer = context->getGLState().getDrawFramebuffer();
if (mask & GL_COLOR_BUFFER_BIT)
{
const FramebufferAttachment *readColorAttachment = readFramebuffer->getReadColorbuffer();
const FramebufferAttachment *drawColorAttachment = drawFramebuffer->getFirstColorbuffer();
if (readColorAttachment && drawColorAttachment)
{
if (!(readColorAttachment->type() == GL_TEXTURE &&
readColorAttachment->getTextureImageIndex().type == GL_TEXTURE_2D) &&
readColorAttachment->type() != GL_RENDERBUFFER &&
readColorAttachment->type() != GL_FRAMEBUFFER_DEFAULT)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
for (size_t drawbufferIdx = 0;
drawbufferIdx < drawFramebuffer->getDrawbufferStateCount(); ++drawbufferIdx)
{
const FramebufferAttachment *attachment =
drawFramebuffer->getDrawBuffer(drawbufferIdx);
if (attachment)
{
if (!(attachment->type() == GL_TEXTURE &&
attachment->getTextureImageIndex().type == GL_TEXTURE_2D) &&
attachment->type() != GL_RENDERBUFFER &&
attachment->type() != GL_FRAMEBUFFER_DEFAULT)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
// Return an error if the destination formats do not match
if (!Format::SameSized(attachment->getFormat(),
readColorAttachment->getFormat()))
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
}
}
if (readFramebuffer->getSamples(context) != 0 &&
IsPartialBlit(context, readColorAttachment, drawColorAttachment, srcX0, srcY0,
srcX1, srcY1, dstX0, dstY0, dstX1, dstY1))
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
}
}
GLenum masks[] = {GL_DEPTH_BUFFER_BIT, GL_STENCIL_BUFFER_BIT};
GLenum attachments[] = {GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT};
for (size_t i = 0; i < 2; i++)
{
if (mask & masks[i])
{
const FramebufferAttachment *readBuffer =
readFramebuffer->getAttachment(attachments[i]);
const FramebufferAttachment *drawBuffer =
drawFramebuffer->getAttachment(attachments[i]);
if (readBuffer && drawBuffer)
{
if (IsPartialBlit(context, readBuffer, drawBuffer, srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1))
{
// only whole-buffer copies are permitted
context->handleError(Error(GL_INVALID_OPERATION,
"Only whole-buffer depth and stencil blits are "
"supported by this extension."));
return false;
}
if (readBuffer->getSamples() != 0 || drawBuffer->getSamples() != 0)
{
context->handleError(Error(GL_INVALID_OPERATION));
return false;
}
}
}
}
return ValidateBlitFramebufferParameters(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
dstX1, dstY1, mask, filter);
}
bool ValidateClear(ValidationContext *context, GLbitfield mask)
{
auto fbo = context->getGLState().getDrawFramebuffer();
if (fbo->checkStatus(context) != GL_FRAMEBUFFER_COMPLETE)
{
context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
return false;
}
if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0)
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
if (context->getExtensions().webglCompatibility && (mask & GL_COLOR_BUFFER_BIT) != 0)
{
constexpr GLenum validComponentTypes[] = {GL_FLOAT, GL_UNSIGNED_NORMALIZED,
GL_SIGNED_NORMALIZED};
for (GLuint drawBufferIdx = 0; drawBufferIdx < context->getCaps().maxDrawBuffers;
drawBufferIdx++)
{
if (!ValidateWebGLFramebufferAttachmentClearType(
context, drawBufferIdx, validComponentTypes, ArraySize(validComponentTypes)))
{
return false;
}
}
}
return true;
}
bool ValidateDrawBuffersEXT(ValidationContext *context, GLsizei n, const GLenum *bufs)
{
if (!context->getExtensions().drawBuffers)
{
context->handleError(Error(GL_INVALID_OPERATION, "Extension not supported."));
return false;
}
return ValidateDrawBuffersBase(context, n, bufs);
}
bool ValidateTexImage2D(Context *context,
GLenum target,
GLint level,
GLint internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
const void *pixels)
{
if (context->getClientMajorVersion() < 3)
{
return ValidateES2TexImageParameters(context, target, level, internalformat, false, false,
0, 0, width, height, border, format, type, -1, pixels);
}
ASSERT(context->getClientMajorVersion() >= 3);
return ValidateES3TexImage2DParameters(context, target, level, internalformat, false, false, 0,
0, 0, width, height, 1, border, format, type, -1,
pixels);
}
bool ValidateTexImage2DRobust(Context *context,
GLenum target,
GLint level,
GLint internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
GLsizei bufSize,
const void *pixels)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
if (context->getClientMajorVersion() < 3)
{
return ValidateES2TexImageParameters(context, target, level, internalformat, false, false,
0, 0, width, height, border, format, type, bufSize,
pixels);
}
ASSERT(context->getClientMajorVersion() >= 3);
return ValidateES3TexImage2DParameters(context, target, level, internalformat, false, false, 0,
0, 0, width, height, 1, border, format, type, bufSize,
pixels);
}
bool ValidateTexSubImage2D(Context *context,
GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
const void *pixels)
{
if (context->getClientMajorVersion() < 3)
{
return ValidateES2TexImageParameters(context, target, level, GL_NONE, false, true, xoffset,
yoffset, width, height, 0, format, type, -1, pixels);
}
ASSERT(context->getClientMajorVersion() >= 3);
return ValidateES3TexImage2DParameters(context, target, level, GL_NONE, false, true, xoffset,
yoffset, 0, width, height, 1, 0, format, type, -1,
pixels);
}
bool ValidateTexSubImage2DRobustANGLE(Context *context,
GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
const void *pixels)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
if (context->getClientMajorVersion() < 3)
{
return ValidateES2TexImageParameters(context, target, level, GL_NONE, false, true, xoffset,
yoffset, width, height, 0, format, type, bufSize,
pixels);
}
ASSERT(context->getClientMajorVersion() >= 3);
return ValidateES3TexImage2DParameters(context, target, level, GL_NONE, false, true, xoffset,
yoffset, 0, width, height, 1, 0, format, type, bufSize,
pixels);
}
bool ValidateCompressedTexImage2D(Context *context,
GLenum target,
GLint level,
GLenum internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLsizei imageSize,
const void *data)
{
if (context->getClientMajorVersion() < 3)
{
if (!ValidateES2TexImageParameters(context, target, level, internalformat, true, false, 0,
0, width, height, border, GL_NONE, GL_NONE, -1, data))
{
return false;
}
}
else
{
ASSERT(context->getClientMajorVersion() >= 3);
if (!ValidateES3TexImage2DParameters(context, target, level, internalformat, true, false, 0,
0, 0, width, height, 1, border, GL_NONE, GL_NONE, -1,
data))
{
return false;
}
}
const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalformat);
auto blockSizeOrErr =
formatInfo.computeCompressedImageSize(GL_UNSIGNED_BYTE, gl::Extents(width, height, 1));
if (blockSizeOrErr.isError())
{
context->handleError(blockSizeOrErr.getError());
return false;
}
if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSizeOrErr.getResult())
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
return true;
}
bool ValidateCompressedTexImage2DRobustANGLE(Context *context,
GLenum target,
GLint level,
GLenum internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLsizei imageSize,
GLsizei dataSize,
const void *data)
{
if (!ValidateRobustCompressedTexImageBase(context, imageSize, dataSize))
{
return false;
}
return ValidateCompressedTexImage2D(context, target, level, internalformat, width, height,
border, imageSize, data);
}
bool ValidateCompressedTexSubImage2DRobustANGLE(Context *context,
GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLsizei imageSize,
GLsizei dataSize,
const void *data)
{
if (!ValidateRobustCompressedTexImageBase(context, imageSize, dataSize))
{
return false;
}
return ValidateCompressedTexSubImage2D(context, target, level, xoffset, yoffset, width, height,
format, imageSize, data);
}
bool ValidateCompressedTexSubImage2D(Context *context,
GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLsizei imageSize,
const void *data)
{
if (context->getClientMajorVersion() < 3)
{
if (!ValidateES2TexImageParameters(context, target, level, GL_NONE, true, true, xoffset,
yoffset, width, height, 0, format, GL_NONE, -1, data))
{
return false;
}
}
else
{
ASSERT(context->getClientMajorVersion() >= 3);
if (!ValidateES3TexImage2DParameters(context, target, level, GL_NONE, true, true, xoffset,
yoffset, 0, width, height, 1, 0, format, GL_NONE, -1,
data))
{
return false;
}
}
const InternalFormat &formatInfo = GetSizedInternalFormatInfo(format);
auto blockSizeOrErr =
formatInfo.computeCompressedImageSize(GL_UNSIGNED_BYTE, gl::Extents(width, height, 1));
if (blockSizeOrErr.isError())
{
context->handleError(blockSizeOrErr.getError());
return false;
}
if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSizeOrErr.getResult())
{
context->handleError(Error(GL_INVALID_VALUE));
return false;
}
return true;
}
bool ValidateGetBufferPointervOES(Context *context, GLenum target, GLenum pname, void **params)
{
return ValidateGetBufferPointervBase(context, target, pname, nullptr, params);
}
bool ValidateMapBufferOES(Context *context, GLenum target, GLenum access)
{
if (!context->getExtensions().mapBuffer)
{
context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
return false;
}
if (!ValidBufferTarget(context, target))
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid buffer target."));
return false;
}
Buffer *buffer = context->getGLState().getTargetBuffer(target);
if (buffer == nullptr)
{
context->handleError(Error(GL_INVALID_OPERATION, "Attempted to map buffer object zero."));
return false;
}
if (access != GL_WRITE_ONLY_OES)
{
context->handleError(Error(GL_INVALID_ENUM, "Non-write buffer mapping not supported."));
return false;
}
if (buffer->isMapped())
{
context->handleError(Error(GL_INVALID_OPERATION, "Buffer is already mapped."));
return false;
}
return true;
}
bool ValidateUnmapBufferOES(Context *context, GLenum target)
{
if (!context->getExtensions().mapBuffer)
{
context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available."));
return false;
}
return ValidateUnmapBufferBase(context, target);
}
bool ValidateMapBufferRangeEXT(Context *context,
GLenum target,
GLintptr offset,
GLsizeiptr length,
GLbitfield access)
{
if (!context->getExtensions().mapBufferRange)
{
context->handleError(
Error(GL_INVALID_OPERATION, "Map buffer range extension not available."));
return false;
}
return ValidateMapBufferRangeBase(context, target, offset, length, access);
}
bool ValidateFlushMappedBufferRangeEXT(Context *context,
GLenum target,
GLintptr offset,
GLsizeiptr length)
{
if (!context->getExtensions().mapBufferRange)
{
context->handleError(
Error(GL_INVALID_OPERATION, "Map buffer range extension not available."));
return false;
}
return ValidateFlushMappedBufferRangeBase(context, target, offset, length);
}
bool ValidateBindTexture(Context *context, GLenum target, GLuint texture)
{
Texture *textureObject = context->getTexture(texture);
if (textureObject && textureObject->getTarget() != target && texture != 0)
{
context->handleError(Error(GL_INVALID_OPERATION, "Invalid texture"));
return false;
}
if (!context->getGLState().isBindGeneratesResourceEnabled() &&
!context->isTextureGenerated(texture))
{
context->handleError(Error(GL_INVALID_OPERATION, "Texture was not generated"));
return false;
}
switch (target)
{
case GL_TEXTURE_2D:
case GL_TEXTURE_CUBE_MAP:
break;
case GL_TEXTURE_3D:
case GL_TEXTURE_2D_ARRAY:
if (context->getClientMajorVersion() < 3)
{
context->handleError(Error(GL_INVALID_ENUM, "GLES 3.0 disabled"));
return false;
}
break;
case GL_TEXTURE_2D_MULTISAMPLE:
if (context->getClientVersion() < Version(3, 1))
{
context->handleError(Error(GL_INVALID_ENUM, "Context does not support GLES3.1"));
return false;
}
break;
case GL_TEXTURE_EXTERNAL_OES:
if (!context->getExtensions().eglImageExternal &&
!context->getExtensions().eglStreamConsumerExternal)
{
context->handleError(
Error(GL_INVALID_ENUM, "External texture extension not enabled"));
return false;
}
break;
default:
context->handleError(Error(GL_INVALID_ENUM, "Invalid target"));
return false;
}
return true;
}
bool ValidateBindUniformLocationCHROMIUM(Context *context,
GLuint program,
GLint location,
const GLchar *name)
{
if (!context->getExtensions().bindUniformLocation)
{
context->handleError(
Error(GL_INVALID_OPERATION, "GL_CHROMIUM_bind_uniform_location is not available."));
return false;
}
Program *programObject = GetValidProgram(context, program);
if (!programObject)
{
return false;
}
if (location < 0)
{
context->handleError(Error(GL_INVALID_VALUE, "Location cannot be less than 0."));
return false;
}
const Caps &caps = context->getCaps();
if (static_cast<size_t>(location) >=
(caps.maxVertexUniformVectors + caps.maxFragmentUniformVectors) * 4)
{
context->handleError(Error(GL_INVALID_VALUE,
"Location must be less than (MAX_VERTEX_UNIFORM_VECTORS + "
"MAX_FRAGMENT_UNIFORM_VECTORS) * 4"));
return false;
}
if (strncmp(name, "gl_", 3) == 0)
{
context->handleError(
Error(GL_INVALID_OPERATION, "Name cannot start with the reserved \"gl_\" prefix."));
return false;
}
return true;
}
bool ValidateCoverageModulationCHROMIUM(Context *context, GLenum components)
{
if (!context->getExtensions().framebufferMixedSamples)
{
context->handleError(
Error(GL_INVALID_OPERATION, "GL_CHROMIUM_framebuffer_mixed_samples is not available."));
return false;
}
switch (components)
{
case GL_RGB:
case GL_RGBA:
case GL_ALPHA:
case GL_NONE:
break;
default:
context->handleError(
Error(GL_INVALID_ENUM,
"GLenum components is not one of GL_RGB, GL_RGBA, GL_ALPHA or GL_NONE."));
return false;
}
return true;
}
// CHROMIUM_path_rendering
bool ValidateMatrix(Context *context, GLenum matrixMode, const GLfloat *matrix)
{
if (!context->getExtensions().pathRendering)
{
context->handleError(
Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available."));
return false;
}
if (matrixMode != GL_PATH_MODELVIEW_CHROMIUM && matrixMode != GL_PATH_PROJECTION_CHROMIUM)
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid matrix mode."));
return false;
}
if (matrix == nullptr)
{
context->handleError(Error(GL_INVALID_OPERATION, "Invalid matrix."));
return false;
}
return true;
}
bool ValidateMatrixMode(Context *context, GLenum matrixMode)
{
if (!context->getExtensions().pathRendering)
{
context->handleError(
Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available."));
return false;
}
if (matrixMode != GL_PATH_MODELVIEW_CHROMIUM && matrixMode != GL_PATH_PROJECTION_CHROMIUM)
{
context->handleError(Error(GL_INVALID_ENUM, "Invalid matrix mode."));
return false;
}
return true;
}
bool ValidateGenPaths(Context *context, GLsizei range)
{
if (!context->getExtensions().pathRendering)
{
context->handleError(
Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available."));
return false;
}
// range = 0 is undefined in NV_path_rendering.
// we add stricter semantic check here and require a non zero positive range.
if (range <= 0)
{
context->handleError(Error(GL_INVALID_VALUE, "Invalid range."));
return false;
}
if (!angle::IsValueInRangeForNumericType<std::uint32_t>(range))
{
context->handleError(Error(GL_INVALID_OPERATION, "Range overflow."));
return false;
}
return true;
}
bool ValidateDeletePaths(Context *context, GLuint path, GLsizei range)
{
if (!context->getExtensions().pathRendering)
{
context->handleError(
Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available."));
return false;
}
// range = 0 is undefined in NV_path_rendering.
// we add stricter semantic check here and require a non zero positive range.
if (range <= 0)
{
context->handleError(Error(GL_INVALID_VALUE, "Invalid range."));
return false;
}
angle::CheckedNumeric<std::uint32_t> checkedRange(path);
checkedRange += range;
if (!angle::IsValueInRangeForNumericType<std::uint32_t>(range) || !checkedRange.IsValid())
{
context->handleError(Error(GL_INVALID_OPERATION, "Range overflow."));
return false;
}
return true;
}
bool ValidatePathCommands(Context *context,
GLuint path,
GLsizei numCommands,
const GLubyte *commands,
GLsizei numCoords,
GLenum coordType,
const void *coords)
{
if (!context->getExtensions().pathRendering)
{
context->handleError(
Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available."));
return false;
}
if (!context->hasPath(path))
{
context->handleError(Error(GL_INVALID_OPERATION, "No such path object."));
return false;
}
if (numCommands < 0)
{
context->handleError(Error(GL_INVALID_VALUE, "Invalid number of commands."));
return false;
}
else if (numCommands > 0)
{
if (!commands)
{
context->handleError(Error(GL_INVALID_VALUE, "No commands array given."));
return false;
}
}
if (numCoords < 0)
{