Google Git
Sign in
android / platform / external / angle / 3ae1f3360 / . / src / libANGLE / validationES.cpp
blob: 2867a5f1450d759497f74b9b8d03b1895d49dbb8 [file] [log] [blame]
//
// Copyright 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 "libANGLE/validationES.h"
#include "libANGLE/Context.h"
#include "libANGLE/Display.h"
#include "libANGLE/ErrorStrings.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/Image.h"
#include "libANGLE/Program.h"
#include "libANGLE/Query.h"
#include "libANGLE/Texture.h"
#include "libANGLE/TransformFeedback.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/queryconversions.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/validationES2.h"
#include "libANGLE/validationES3.h"
#include "common/mathutil.h"
#include "common/utilities.h"
using namespace angle;
namespace gl
{
using namespace err;
namespace
{
bool CompressedTextureFormatRequiresExactSize(GLenum internalFormat)
{
// List of compressed format that require that the texture size is smaller than or a multiple of
// the compressed block size.
switch (internalFormat)
{
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_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:
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:
case GL_COMPRESSED_RGBA8_LOSSY_DECODE_ETC2_EAC_ANGLE:
case GL_COMPRESSED_SRGB8_ALPHA8_LOSSY_DECODE_ETC2_EAC_ANGLE:
case GL_COMPRESSED_RED_RGTC1_EXT:
case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
case GL_COMPRESSED_RGBA_BPTC_UNORM_EXT:
case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:
case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT:
case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT:
return true;
default:
return false;
}
}
bool CompressedSubTextureFormatRequiresExactSize(GLenum internalFormat)
{
// Compressed sub textures have additional formats that requires exact size.
// ES 3.1, Section 8.7, Page 171
return CompressedTextureFormatRequiresExactSize(internalFormat) ||
IsETC2EACFormat(internalFormat);
}
bool DifferenceCanOverflow(GLint a, GLint b)
{
CheckedNumeric<GLint> checkedA(a);
checkedA -= b;
// Use negation to make sure that the difference can't overflow regardless of the order.
checkedA = -checkedA;
return !checkedA.IsValid();
}
bool ValidReadPixelsTypeEnum(const Context *context, GLenum type)
{
switch (type)
{
// Types referenced in Table 3.4 of the ES 2.0.25 spec
case GL_UNSIGNED_BYTE:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
case GL_UNSIGNED_SHORT_5_6_5:
return context->getClientVersion() >= ES_2_0;
// Types referenced in Table 3.2 of the ES 3.0.5 spec (Except depth stencil)
case GL_BYTE:
case GL_INT:
case GL_SHORT:
case GL_UNSIGNED_INT:
case GL_UNSIGNED_INT_10F_11F_11F_REV:
case GL_UNSIGNED_INT_24_8:
case GL_UNSIGNED_INT_2_10_10_10_REV:
case GL_UNSIGNED_INT_5_9_9_9_REV:
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
return context->getClientVersion() >= ES_3_0;
case GL_FLOAT:
return context->getClientVersion() >= ES_3_0 ||
context->getExtensions().textureFloatOES ||
context->getExtensions().colorBufferHalfFloat;
case GL_HALF_FLOAT:
return context->getClientVersion() >= ES_3_0 ||
context->getExtensions().textureHalfFloat;
case GL_HALF_FLOAT_OES:
return context->getExtensions().colorBufferHalfFloat;
default:
return false;
}
}
bool ValidReadPixelsFormatEnum(const Context *context, GLenum format)
{
switch (format)
{
// Formats referenced in Table 3.4 of the ES 2.0.25 spec (Except luminance)
case GL_RGBA:
case GL_RGB:
case GL_ALPHA:
return context->getClientVersion() >= ES_2_0;
// Formats referenced in Table 3.2 of the ES 3.0.5 spec
case GL_RG:
case GL_RED:
case GL_RGBA_INTEGER:
case GL_RGB_INTEGER:
case GL_RG_INTEGER:
case GL_RED_INTEGER:
return context->getClientVersion() >= ES_3_0;
case GL_SRGB_ALPHA_EXT:
case GL_SRGB_EXT:
return context->getExtensions().sRGB;
case GL_BGRA_EXT:
return context->getExtensions().readFormatBGRA;
default:
return false;
}
}
bool ValidReadPixelsUnsignedNormalizedDepthType(const Context *context,
const gl::InternalFormat *info,
GLenum type)
{
bool supportsReadDepthNV = (context->getExtensions().readDepthNV && (info->depthBits > 0) &&
(info->componentCount == 1));
switch (type)
{
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
case GL_UNSIGNED_INT_24_8:
return supportsReadDepthNV;
default:
return false;
}
}
bool ValidReadPixelsFloatDepthType(const Context *context,
const gl::InternalFormat *info,
GLenum type)
{
return context->getExtensions().readDepthNV && (type == GL_FLOAT) &&
context->getExtensions().depthBufferFloat2NV && (info->componentCount == 1);
}
bool ValidReadPixelsFormatType(const Context *context,
const gl::InternalFormat *info,
GLenum format,
GLenum type)
{
switch (info->componentType)
{
case GL_UNSIGNED_NORMALIZED:
// TODO(geofflang): Don't accept BGRA here. Some chrome internals appear to try to use
// ReadPixels with BGRA even if the extension is not present
switch (format)
{
case GL_RGBA:
return ((type == GL_UNSIGNED_BYTE) && info->pixelBytes >= 1) ||
(context->getExtensions().textureNorm16 && (type == GL_UNSIGNED_SHORT) &&
info->pixelBytes >= 2);
case GL_BGRA_EXT:
return context->getExtensions().readFormatBGRA && (type == GL_UNSIGNED_BYTE);
case GL_STENCIL_INDEX_OES:
return context->getExtensions().readStencilNV && (type == GL_UNSIGNED_BYTE);
case GL_DEPTH_COMPONENT:
return ValidReadPixelsUnsignedNormalizedDepthType(context, info, type);
default:
return false;
}
case GL_SIGNED_NORMALIZED:
return (format == GL_RGBA && type == GL_BYTE && info->pixelBytes >= 1) ||
(context->getExtensions().textureNorm16 && format == GL_RGBA &&
type == GL_UNSIGNED_SHORT && info->pixelBytes >= 2);
case GL_INT:
return (format == GL_RGBA_INTEGER && type == GL_INT);
case GL_UNSIGNED_INT:
return (format == GL_RGBA_INTEGER && type == GL_UNSIGNED_INT);
case GL_FLOAT:
switch (format)
{
case GL_RGBA:
return (type == GL_FLOAT);
case GL_DEPTH_COMPONENT:
return ValidReadPixelsFloatDepthType(context, info, type);
default:
return false;
}
default:
UNREACHABLE();
return false;
}
}
template <typename ParamType>
bool ValidateTextureWrapModeValue(const Context *context,
const ParamType *params,
bool restrictedWrapModes)
{
switch (ConvertToGLenum(params[0]))
{
case GL_CLAMP_TO_EDGE:
break;
case GL_CLAMP_TO_BORDER:
if (!context->getExtensions().textureBorderClampAny() &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
case GL_REPEAT:
case GL_MIRRORED_REPEAT:
if (restrictedWrapModes)
{
// OES_EGL_image_external and ANGLE_texture_rectangle specifies this error.
context->validationError(GL_INVALID_ENUM, kInvalidWrapModeTexture);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidTextureWrap);
return false;
}
return true;
}
template <typename ParamType>
bool ValidateTextureMinFilterValue(const Context *context,
const ParamType *params,
bool restrictedMinFilter)
{
switch (ConvertToGLenum(params[0]))
{
case GL_NEAREST:
case GL_LINEAR:
break;
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_NEAREST_MIPMAP_LINEAR:
case GL_LINEAR_MIPMAP_LINEAR:
if (restrictedMinFilter)
{
// OES_EGL_image_external specifies this error.
context->validationError(GL_INVALID_ENUM, kInvalidFilterTexture);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidTextureFilterParam);
return false;
}
return true;
}
template <typename ParamType>
bool ValidateTextureMagFilterValue(const Context *context, const ParamType *params)
{
switch (ConvertToGLenum(params[0]))
{
case GL_NEAREST:
case GL_LINEAR:
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidTextureFilterParam);
return false;
}
return true;
}
template <typename ParamType>
bool ValidateTextureCompareModeValue(const Context *context, const ParamType *params)
{
// Acceptable mode parameters from GLES 3.0.2 spec, table 3.17
switch (ConvertToGLenum(params[0]))
{
case GL_NONE:
case GL_COMPARE_REF_TO_TEXTURE:
break;
default:
context->validationError(GL_INVALID_ENUM, kUnknownParameter);
return false;
}
return true;
}
template <typename ParamType>
bool ValidateTextureCompareFuncValue(const Context *context, const ParamType *params)
{
// Acceptable function parameters from GLES 3.0.2 spec, table 3.17
switch (ConvertToGLenum(params[0]))
{
case GL_LEQUAL:
case GL_GEQUAL:
case GL_LESS:
case GL_GREATER:
case GL_EQUAL:
case GL_NOTEQUAL:
case GL_ALWAYS:
case GL_NEVER:
break;
default:
context->validationError(GL_INVALID_ENUM, kUnknownParameter);
return false;
}
return true;
}
template <typename ParamType>
bool ValidateTextureSRGBDecodeValue(const Context *context, const ParamType *params)
{
if (!context->getExtensions().textureSRGBDecode)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
switch (ConvertToGLenum(params[0]))
{
case GL_DECODE_EXT:
case GL_SKIP_DECODE_EXT:
break;
default:
context->validationError(GL_INVALID_ENUM, kUnknownParameter);
return false;
}
return true;
}
template <typename ParamType>
bool ValidateTextureSRGBOverrideValue(const Context *context, const ParamType *params)
{
if (!context->getExtensions().textureSRGBOverride)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
switch (ConvertToGLenum(params[0]))
{
case GL_SRGB:
case GL_NONE:
break;
default:
context->validationError(GL_INVALID_ENUM, kUnknownParameter);
return false;
}
return true;
}
bool ValidateTextureMaxAnisotropyExtensionEnabled(const Context *context)
{
if (!context->getExtensions().textureFilterAnisotropic)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
return true;
}
bool ValidateTextureMaxAnisotropyValue(const Context *context, GLfloat paramValue)
{
if (!ValidateTextureMaxAnisotropyExtensionEnabled(context))
{
return false;
}
GLfloat largest = context->getExtensions().maxTextureAnisotropy;
if (paramValue < 1 || paramValue > largest)
{
context->validationError(GL_INVALID_VALUE, kOutsideOfBounds);
return false;
}
return true;
}
bool ValidateFragmentShaderColorBufferMaskMatch(const Context *context)
{
const Program *program = context->getActiveLinkedProgram();
const Framebuffer *framebuffer = context->getState().getDrawFramebuffer();
auto drawBufferMask = framebuffer->getDrawBufferMask().to_ulong();
auto fragmentOutputMask = program->getActiveOutputVariables().to_ulong();
return drawBufferMask == (drawBufferMask & fragmentOutputMask);
}
bool ValidateFragmentShaderColorBufferTypeMatch(const Context *context)
{
const Program *program = context->getActiveLinkedProgram();
const Framebuffer *framebuffer = context->getState().getDrawFramebuffer();
return ValidateComponentTypeMasks(program->getDrawBufferTypeMask().to_ulong(),
framebuffer->getDrawBufferTypeMask().to_ulong(),
program->getActiveOutputVariables().to_ulong(),
framebuffer->getDrawBufferMask().to_ulong());
}
bool ValidateVertexShaderAttributeTypeMatch(const Context *context)
{
const auto &glState = context->getState();
const Program *program = context->getActiveLinkedProgram();
const VertexArray *vao = context->getState().getVertexArray();
if (!program)
{
return false;
}
unsigned long stateCurrentValuesTypeBits = glState.getCurrentValuesTypeMask().to_ulong();
unsigned long vaoAttribTypeBits = vao->getAttributesTypeMask().to_ulong();
unsigned long vaoAttribEnabledMask = vao->getAttributesMask().to_ulong();
vaoAttribEnabledMask |= vaoAttribEnabledMask << kMaxComponentTypeMaskIndex;
vaoAttribTypeBits = (vaoAttribEnabledMask & vaoAttribTypeBits);
vaoAttribTypeBits |= (~vaoAttribEnabledMask & stateCurrentValuesTypeBits);
const ProgramExecutable &executable = program->getExecutable();
return ValidateComponentTypeMasks(executable.getAttributesTypeMask().to_ulong(),
vaoAttribTypeBits, executable.getAttributesMask().to_ulong(),
0xFFFF);
}
bool IsCompatibleDrawModeWithGeometryShader(PrimitiveMode drawMode,
PrimitiveMode geometryShaderInputPrimitiveType)
{
// [EXT_geometry_shader] Section 11.1gs.1, Geometry Shader Input Primitives
switch (drawMode)
{
case PrimitiveMode::Points:
return geometryShaderInputPrimitiveType == PrimitiveMode::Points;
case PrimitiveMode::Lines:
case PrimitiveMode::LineStrip:
case PrimitiveMode::LineLoop:
return geometryShaderInputPrimitiveType == PrimitiveMode::Lines;
case PrimitiveMode::LinesAdjacency:
case PrimitiveMode::LineStripAdjacency:
return geometryShaderInputPrimitiveType == PrimitiveMode::LinesAdjacency;
case PrimitiveMode::Triangles:
case PrimitiveMode::TriangleFan:
case PrimitiveMode::TriangleStrip:
return geometryShaderInputPrimitiveType == PrimitiveMode::Triangles;
case PrimitiveMode::TrianglesAdjacency:
case PrimitiveMode::TriangleStripAdjacency:
return geometryShaderInputPrimitiveType == PrimitiveMode::TrianglesAdjacency;
default:
UNREACHABLE();
return false;
}
}
// GLES1 texture parameters are a small subset of the others
bool IsValidGLES1TextureParameter(GLenum pname)
{
switch (pname)
{
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
case GL_GENERATE_MIPMAP:
case GL_TEXTURE_CROP_RECT_OES:
return true;
default:
return false;
}
}
unsigned int GetSamplerParameterCount(GLenum pname)
{
return pname == GL_TEXTURE_BORDER_COLOR ? 4 : 1;
}
ANGLE_INLINE const char *ValidateProgramDrawStates(const Context *context,
const Extensions &extensions,
Program *program)
{
const State &state = context->getState();
if (extensions.multiview || extensions.multiview2)
{
const int programNumViews = program->usesMultiview() ? program->getNumViews() : 1;
Framebuffer *framebuffer = state.getDrawFramebuffer();
const int framebufferNumViews = framebuffer->getNumViews();
if (framebufferNumViews != programNumViews)
{
return gl::err::kMultiviewMismatch;
}
if (state.isTransformFeedbackActiveUnpaused() && framebufferNumViews > 1)
{
return gl::err::kMultiviewTransformFeedback;
}
if (extensions.disjointTimerQuery && framebufferNumViews > 1 &&
state.isQueryActive(QueryType::TimeElapsed))
{
return gl::err::kMultiviewTimerQuery;
}
}
// Uniform buffer validation
for (unsigned int uniformBlockIndex = 0;
uniformBlockIndex < program->getActiveUniformBlockCount(); uniformBlockIndex++)
{
const InterfaceBlock &uniformBlock = program->getUniformBlockByIndex(uniformBlockIndex);
GLuint blockBinding = program->getUniformBlockBinding(uniformBlockIndex);
const OffsetBindingPointer<Buffer> &uniformBuffer =
state.getIndexedUniformBuffer(blockBinding);
if (uniformBuffer.get() == nullptr && context->isWebGL())
{
// undefined behaviour
return gl::err::kUniformBufferUnbound;
}
size_t uniformBufferSize = GetBoundBufferAvailableSize(uniformBuffer);
if (uniformBufferSize < uniformBlock.dataSize &&
(context->isWebGL() || context->isBufferAccessValidationEnabled()))
{
// undefined behaviour
return gl::err::kUniformBufferTooSmall;
}
if (extensions.webglCompatibility &&
uniformBuffer->isBoundForTransformFeedbackAndOtherUse())
{
return gl::err::kUniformBufferBoundForTransformFeedback;
}
}
return nullptr;
}
} // anonymous namespace
void SetRobustLengthParam(const GLsizei *length, GLsizei value)
{
if (length)
{
// Currently we modify robust length parameters in the validation layer. We should be only
// doing this in the Context instead.
// TODO(http://anglebug.com/4406): Remove when possible.
*const_cast<GLsizei *>(length) = value;
}
}
bool ValidTextureTarget(const Context *context, TextureType type)
{
switch (type)
{
case TextureType::_2D:
case TextureType::CubeMap:
return true;
case TextureType::Rectangle:
return context->getExtensions().textureRectangle;
case TextureType::_3D:
return ((context->getClientMajorVersion() >= 3) ||
context->getExtensions().texture3DOES);
case TextureType::_2DArray:
return (context->getClientMajorVersion() >= 3);
case TextureType::_2DMultisample:
return (context->getClientVersion() >= Version(3, 1) ||
context->getExtensions().textureMultisample);
case TextureType::_2DMultisampleArray:
return context->getExtensions().textureStorageMultisample2DArrayOES;
case TextureType::CubeMapArray:
return (context->getClientVersion() >= Version(3, 2) ||
context->getExtensions().textureCubeMapArrayAny());
case TextureType::VideoImage:
return context->getExtensions().webglVideoTexture;
case TextureType::Buffer:
return (context->getClientVersion() >= Version(3, 2) ||
context->getExtensions().textureBufferAny());
default:
return false;
}
}
bool ValidTexture2DTarget(const Context *context, TextureType type)
{
switch (type)
{
case TextureType::_2D:
case TextureType::CubeMap:
return true;
case TextureType::Rectangle:
return context->getExtensions().textureRectangle;
default:
return false;
}
}
bool ValidTexture3DTarget(const Context *context, TextureType target)
{
switch (target)
{
case TextureType::_3D:
case TextureType::_2DArray:
return (context->getClientMajorVersion() >= 3);
case TextureType::CubeMapArray:
return (context->getClientVersion() >= Version(3, 2) ||
context->getExtensions().textureCubeMapArrayAny());
default:
return false;
}
}
// Most texture GL calls are not compatible with external textures, so we have a separate validation
// function for use in the GL calls that do
bool ValidTextureExternalTarget(const Context *context, TextureType target)
{
return (target == TextureType::External) &&
(context->getExtensions().eglImageExternalOES ||
context->getExtensions().eglStreamConsumerExternalNV);
}
bool ValidTextureExternalTarget(const Context *context, TextureTarget target)
{
return (target == TextureTarget::External) &&
ValidTextureExternalTarget(context, TextureType::External);
}
// This function differs from ValidTextureTarget in that the target must be
// usable as the destination of a 2D operation-- so a cube face is valid, but
// GL_TEXTURE_CUBE_MAP is not.
// Note: duplicate of IsInternalTextureTarget
bool ValidTexture2DDestinationTarget(const Context *context, TextureTarget target)
{
switch (target)
{
case TextureTarget::_2D:
case TextureTarget::CubeMapNegativeX:
case TextureTarget::CubeMapNegativeY:
case TextureTarget::CubeMapNegativeZ:
case TextureTarget::CubeMapPositiveX:
case TextureTarget::CubeMapPositiveY:
case TextureTarget::CubeMapPositiveZ:
return true;
case TextureTarget::Rectangle:
return context->getExtensions().textureRectangle;
case TextureTarget::VideoImage:
return context->getExtensions().webglVideoTexture;
default:
return false;
}
}
bool ValidateTransformFeedbackPrimitiveMode(const Context *context,
PrimitiveMode transformFeedbackPrimitiveMode,
PrimitiveMode renderPrimitiveMode)
{
ASSERT(context);
if ((!context->getExtensions().geometryShaderAny() ||
!context->getExtensions().tessellationShaderEXT) &&
context->getClientVersion() < ES_3_2)
{
// It is an invalid operation to call DrawArrays or DrawArraysInstanced with a draw mode
// that does not match the current transform feedback object's draw mode (if transform
// feedback is active), (3.0.2, section 2.14, pg 86)
return transformFeedbackPrimitiveMode == renderPrimitiveMode;
}
const ProgramExecutable *executable = context->getState().getProgramExecutable();
ASSERT(executable);
if (executable->hasLinkedShaderStage(ShaderType::Geometry))
{
// If geometry shader is active, transform feedback mode must match what is output from this
// stage.
renderPrimitiveMode = executable->getGeometryShaderOutputPrimitiveType();
}
else if (executable->hasLinkedShaderStage(ShaderType::TessEvaluation))
{
// Similarly with tessellation shaders, but only if no geometry shader is present. With
// tessellation shaders, only triangles are possibly output.
return transformFeedbackPrimitiveMode == PrimitiveMode::Triangles &&
executable->getTessGenMode() == GL_TRIANGLES;
}
// [GL_EXT_geometry_shader] Table 12.1gs
switch (renderPrimitiveMode)
{
case PrimitiveMode::Points:
return transformFeedbackPrimitiveMode == PrimitiveMode::Points;
case PrimitiveMode::Lines:
case PrimitiveMode::LineStrip:
case PrimitiveMode::LineLoop:
return transformFeedbackPrimitiveMode == PrimitiveMode::Lines;
case PrimitiveMode::Triangles:
case PrimitiveMode::TriangleFan:
case PrimitiveMode::TriangleStrip:
return transformFeedbackPrimitiveMode == PrimitiveMode::Triangles;
case PrimitiveMode::Patches:
return transformFeedbackPrimitiveMode == PrimitiveMode::Patches;
default:
UNREACHABLE();
return false;
}
}
bool ValidateDrawElementsInstancedBase(const Context *context,
PrimitiveMode mode,
GLsizei count,
DrawElementsType type,
const void *indices,
GLsizei primcount)
{
if (primcount <= 0)
{
if (primcount < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativePrimcount);
return false;
}
// Early exit.
return ValidateDrawElementsCommon(context, mode, count, type, indices, primcount);
}
if (!ValidateDrawElementsCommon(context, mode, count, type, indices, primcount))
{
return false;
}
if (count == 0)
{
// Early exit.
return true;
}
return ValidateDrawInstancedAttribs(context, primcount);
}
bool ValidateDrawArraysInstancedBase(const Context *context,
PrimitiveMode mode,
GLint first,
GLsizei count,
GLsizei primcount)
{
if (primcount <= 0)
{
if (primcount < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativePrimcount);
return false;
}
// Early exit.
return ValidateDrawArraysCommon(context, mode, first, count, primcount);
}
if (!ValidateDrawArraysCommon(context, mode, first, count, primcount))
{
return false;
}
if (count == 0)
{
// Early exit.
return true;
}
return ValidateDrawInstancedAttribs(context, primcount);
}
bool ValidateDrawInstancedANGLE(const Context *context)
{
// Verify there is at least one active attribute with a divisor of zero
const State &state = context->getState();
const ProgramExecutable *executable = state.getProgramExecutable();
if (!executable)
{
// No executable means there is no Program/PPO bound, which is undefined behavior, but isn't
// an error.
context->getState().getDebug().insertMessage(
GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, 0, GL_DEBUG_SEVERITY_HIGH,
std::string("Attempting to draw without a program"), gl::LOG_WARN);
return true;
}
const auto &attribs = state.getVertexArray()->getVertexAttributes();
const auto &bindings = state.getVertexArray()->getVertexBindings();
for (size_t attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
{
const VertexAttribute &attrib = attribs[attributeIndex];
const VertexBinding &binding = bindings[attrib.bindingIndex];
if (executable->isAttribLocationActive(attributeIndex) && binding.getDivisor() == 0)
{
return true;
}
}
context->validationError(GL_INVALID_OPERATION, kNoZeroDivisor);
return false;
}
bool ValidTexture3DDestinationTarget(const Context *context, TextureTarget target)
{
switch (target)
{
case TextureTarget::_3D:
case TextureTarget::_2DArray:
case TextureTarget::CubeMapArray:
return true;
default:
return false;
}
}
bool ValidTexLevelDestinationTarget(const Context *context, TextureType type)
{
switch (type)
{
case TextureType::_2D:
case TextureType::_2DArray:
case TextureType::_2DMultisample:
case TextureType::CubeMap:
case TextureType::_3D:
return true;
case TextureType::CubeMapArray:
return (context->getClientVersion() >= Version(3, 2) ||
context->getExtensions().textureCubeMapArrayAny());
case TextureType::Rectangle:
return context->getExtensions().textureRectangle;
case TextureType::_2DMultisampleArray:
return context->getExtensions().textureStorageMultisample2DArrayOES;
case TextureType::Buffer:
return (context->getClientVersion() >= Version(3, 2) ||
context->getExtensions().textureBufferAny());
default:
return false;
}
}
bool ValidFramebufferTarget(const Context *context, GLenum target)
{
static_assert(GL_DRAW_FRAMEBUFFER_ANGLE == GL_DRAW_FRAMEBUFFER &&
GL_READ_FRAMEBUFFER_ANGLE == GL_READ_FRAMEBUFFER,
"ANGLE framebuffer enums must equal the ES3 framebuffer enums.");
switch (target)
{
case GL_FRAMEBUFFER:
return true;
case GL_READ_FRAMEBUFFER:
case GL_DRAW_FRAMEBUFFER:
return (context->getExtensions().framebufferBlitAny() ||
context->getClientMajorVersion() >= 3);
default:
return false;
}
}
bool ValidMipLevel(const Context *context, TextureType type, GLint level)
{
const auto &caps = context->getCaps();
int maxDimension = 0;
switch (type)
{
case TextureType::_2D:
case TextureType::_2DArray:
case TextureType::_2DMultisample:
case TextureType::_2DMultisampleArray:
// TODO(http://anglebug.com/2775): It's a bit unclear what the "maximum allowable
// level-of-detail" for multisample textures should be. Could maybe make it zero.
maxDimension = caps.max2DTextureSize;
break;
case TextureType::CubeMap:
case TextureType::CubeMapArray:
maxDimension = caps.maxCubeMapTextureSize;
break;
case TextureType::External:
case TextureType::Rectangle:
case TextureType::VideoImage:
case TextureType::Buffer:
return level == 0;
case TextureType::_3D:
maxDimension = caps.max3DTextureSize;
break;
default:
UNREACHABLE();
}
return level <= log2(maxDimension) && level >= 0;
}
bool ValidImageSizeParameters(const Context *context,
TextureType target,
GLint level,
GLsizei width,
GLsizei height,
GLsizei depth,
bool isSubImage)
{
if (width < 0 || height < 0 || depth < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeSize);
return false;
}
// TexSubImage parameters can be NPOT without textureNPOT extension,
// as long as the destination texture is POT.
bool hasNPOTSupport =
context->getExtensions().textureNPOTOES || context->getClientVersion() >= Version(3, 0);
if (!isSubImage && !hasNPOTSupport &&
(level != 0 && (!isPow2(width) || !isPow2(height) || !isPow2(depth))))
{
context->validationError(GL_INVALID_VALUE, kTextureNotPow2);
return false;
}
if (!ValidMipLevel(context, target, level))
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
return true;
}
bool ValidCompressedDimension(GLsizei size, GLuint blockSize, GLint level)
{
return (level > 0) || (size % blockSize == 0);
}
bool ValidCompressedBaseLevelForWebGL(GLsizei size, GLuint blockSize, GLint level)
{
// Avoid C++ undefined behavior.
constexpr int maxValidShifts = 31;
if (level > maxValidShifts)
return false;
return ((size << level) % blockSize) == 0;
}
bool ValidCompressedImageSize(const Context *context,
GLenum internalFormat,
GLint level,
GLsizei width,
GLsizei height,
GLsizei depth)
{
const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalFormat);
if (!formatInfo.compressed)
{
return false;
}
if (width < 0 || height < 0)
{
return false;
}
// Only PVRTC1 requires dimensions to be powers of two
if (IsPVRTC1Format(internalFormat))
{
if (!isPow2(width) || !isPow2(height))
{
return false;
}
if (context->getLimitations().squarePvrtc1)
{
if (width != height)
{
return false;
}
}
}
if (CompressedTextureFormatRequiresExactSize(internalFormat))
{
// In WebGL compatibility mode, enforce that the base level implied
// by the compressed texture's mip level would conform to the block
// size. This is more strict than the non-WebGL check.
if (context->getExtensions().webglCompatibility)
{
if (!ValidCompressedBaseLevelForWebGL(width, formatInfo.compressedBlockWidth, level) ||
!ValidCompressedBaseLevelForWebGL(height, formatInfo.compressedBlockHeight,
level) ||
!ValidCompressedBaseLevelForWebGL(depth, formatInfo.compressedBlockDepth, level))
{
return false;
}
}
else
{
if (!ValidCompressedDimension(width, formatInfo.compressedBlockWidth, level) ||
!ValidCompressedDimension(height, formatInfo.compressedBlockHeight, level) ||
!ValidCompressedDimension(depth, formatInfo.compressedBlockDepth, level))
{
return false;
}
}
}
return true;
}
bool ValidCompressedSubImageSize(const Context *context,
GLenum internalFormat,
GLint xoffset,
GLint yoffset,
GLint zoffset,
GLsizei width,
GLsizei height,
GLsizei depth,
size_t textureWidth,
size_t textureHeight,
size_t textureDepth)
{
const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalFormat);
if (!formatInfo.compressed)
{
return false;
}
if (xoffset < 0 || yoffset < 0 || zoffset < 0 || width < 0 || height < 0 || depth < 0)
{
return false;
}
bool fillsEntireMip =
xoffset == 0 && yoffset == 0 && static_cast<size_t>(width) == textureWidth &&
static_cast<size_t>(height) == textureHeight && static_cast<size_t>(depth) == textureDepth;
if (CompressedFormatRequiresWholeImage(internalFormat))
{
return fillsEntireMip;
}
if (CompressedSubTextureFormatRequiresExactSize(internalFormat))
{
if (xoffset % formatInfo.compressedBlockWidth != 0 ||
yoffset % formatInfo.compressedBlockHeight != 0 ||
zoffset % formatInfo.compressedBlockDepth != 0)
{
return false;
}
// Allowed to either have data that is a multiple of block size or is smaller than the block
// size but fills the entire mip
bool sizeMultipleOfBlockSize = (width % formatInfo.compressedBlockWidth) == 0 &&
(height % formatInfo.compressedBlockHeight) == 0 &&
(depth % formatInfo.compressedBlockDepth) == 0;
if (!sizeMultipleOfBlockSize && !fillsEntireMip)
{
return false;
}
}
return true;
}
bool ValidImageDataSize(const Context *context,
TextureType texType,
GLsizei width,
GLsizei height,
GLsizei depth,
GLenum format,
GLenum type,
const void *pixels,
GLsizei imageSize)
{
Buffer *pixelUnpackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelUnpack);
if (pixelUnpackBuffer == nullptr && imageSize < 0)
{
// Checks are not required
return true;
}
// ...the data would be unpacked from the buffer object such that the memory reads required
// would exceed the data store size.
const InternalFormat &formatInfo = GetInternalFormatInfo(format, type);
ASSERT(formatInfo.internalFormat != GL_NONE);
const Extents size(width, height, depth);
const auto &unpack = context->getState().getUnpackState();
bool targetIs3D = texType == TextureType::_3D || texType == TextureType::_2DArray;
GLuint endByte = 0;
if (!formatInfo.computePackUnpackEndByte(type, size, unpack, targetIs3D, &endByte))
{
context->validationError(GL_INVALID_OPERATION, kIntegerOverflow);
return false;
}
if (pixelUnpackBuffer)
{
CheckedNumeric<size_t> checkedEndByte(endByte);
CheckedNumeric<size_t> checkedOffset(reinterpret_cast<size_t>(pixels));
checkedEndByte += checkedOffset;
if (!checkedEndByte.IsValid() ||
(checkedEndByte.ValueOrDie() > static_cast<size_t>(pixelUnpackBuffer->getSize())))
{
// Overflow past the end of the buffer
context->validationError(GL_INVALID_OPERATION, kIntegerOverflow);
return false;
}
if (context->getExtensions().webglCompatibility &&
pixelUnpackBuffer->isBoundForTransformFeedbackAndOtherUse())
{
context->validationError(GL_INVALID_OPERATION,
kPixelUnpackBufferBoundForTransformFeedback);
return false;
}
}
else
{
ASSERT(imageSize >= 0);
if (pixels == nullptr && imageSize != 0)
{
context->validationError(GL_INVALID_OPERATION, kImageSizeMustBeZero);
return false;
}
if (pixels != nullptr && endByte > static_cast<GLuint>(imageSize))
{
context->validationError(GL_INVALID_OPERATION, kImageSizeTooSmall);
return false;
}
}
return true;
}
bool ValidQueryType(const Context *context, QueryType queryType)
{
switch (queryType)
{
case QueryType::AnySamples:
case QueryType::AnySamplesConservative:
return context->getClientMajorVersion() >= 3 ||
context->getExtensions().occlusionQueryBoolean;
case QueryType::TransformFeedbackPrimitivesWritten:
return (context->getClientMajorVersion() >= 3);
case QueryType::TimeElapsed:
return context->getExtensions().disjointTimerQuery;
case QueryType::CommandsCompleted:
return context->getExtensions().syncQuery;
case QueryType::PrimitivesGenerated:
return context->getClientVersion() >= ES_3_2 ||
context->getExtensions().geometryShaderAny();
default:
return false;
}
}
bool ValidateWebGLVertexAttribPointer(const Context *context,
VertexAttribType type,
GLboolean normalized,
GLsizei stride,
const void *ptr,
bool pureInteger)
{
ASSERT(context->getExtensions().webglCompatibility);
// WebGL 1.0 [Section 6.11] Vertex Attribute Data Stride
// The WebGL API supports vertex attribute data strides up to 255 bytes. A call to
// vertexAttribPointer will generate an INVALID_VALUE error if the value for the stride
// parameter exceeds 255.
constexpr GLsizei kMaxWebGLStride = 255;
if (stride > kMaxWebGLStride)
{
context->validationError(GL_INVALID_VALUE, kStrideExceedsWebGLLimit);
return false;
}
// WebGL 1.0 [Section 6.4] Buffer Offset and Stride Requirements
// The offset arguments to drawElements and vertexAttribPointer, and the stride argument to
// vertexAttribPointer, must be a multiple of the size of the data type passed to the call,
// or an INVALID_OPERATION error is generated.
angle::FormatID internalType = GetVertexFormatID(type, normalized, 1, pureInteger);
size_t typeSize = GetVertexFormatSize(internalType);
ASSERT(isPow2(typeSize) && typeSize > 0);
size_t sizeMask = (typeSize - 1);
if ((reinterpret_cast<intptr_t>(ptr) & sizeMask) != 0)
{
context->validationError(GL_INVALID_OPERATION, kOffsetMustBeMultipleOfType);
return false;
}
if ((stride & sizeMask) != 0)
{
context->validationError(GL_INVALID_OPERATION, kStrideMustBeMultipleOfType);
return false;
}
return true;
}
Program *GetValidProgramNoResolve(const Context *context, ShaderProgramID id)
{
// ES3 spec (section 2.11.1) -- "Commands that accept shader or program object names will
// generate the error INVALID_VALUE if the provided name is not the name of either a shader
// or program object and INVALID_OPERATION if the provided name identifies an object
// that is not the expected type."
Program *validProgram = context->getProgramNoResolveLink(id);
if (!validProgram)
{
if (context->getShader(id))
{
context->validationError(GL_INVALID_OPERATION, kExpectedProgramName);
}
else
{
context->validationError(GL_INVALID_VALUE, kInvalidProgramName);
}
}
return validProgram;
}
Program *GetValidProgram(const Context *context, ShaderProgramID id)
{
Program *program = GetValidProgramNoResolve(context, id);
if (program)
{
program->resolveLink(context);
}
return program;
}
Shader *GetValidShader(const Context *context, ShaderProgramID id)
{
// See ValidProgram for spec details.
Shader *validShader = context->getShader(id);
if (!validShader)
{
if (context->getProgramNoResolveLink(id))
{
context->validationError(GL_INVALID_OPERATION, kExpectedShaderName);
}
else
{
context->validationError(GL_INVALID_VALUE, kInvalidShaderName);
}
}
return validShader;
}
bool ValidateAttachmentTarget(const Context *context, GLenum attachment)
{
if (attachment >= GL_COLOR_ATTACHMENT1_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
{
if (context->getClientMajorVersion() < 3 && !context->getExtensions().drawBuffers)
{
context->validationError(GL_INVALID_ENUM, kInvalidAttachment);
return false;
}
// Color attachment 0 is validated below because it is always valid
const int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
if (colorAttachment >= context->getCaps().maxColorAttachments)
{
context->validationError(GL_INVALID_OPERATION, kInvalidAttachment);
return false;
}
}
else
{
switch (attachment)
{
case GL_COLOR_ATTACHMENT0:
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
break;
case GL_DEPTH_STENCIL_ATTACHMENT:
if (!context->getExtensions().webglCompatibility &&
context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_ENUM, kInvalidAttachment);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidAttachment);
return false;
}
}
return true;
}
bool ValidateRenderbufferStorageParametersBase(const Context *context,
GLenum target,
GLsizei samples,
GLenum internalformat,
GLsizei width,
GLsizei height)
{
switch (target)
{
case GL_RENDERBUFFER:
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
return false;
}
if (width < 0 || height < 0 || samples < 0)
{
context->validationError(GL_INVALID_VALUE, kInvalidRenderbufferWidthHeight);
return false;
}
// Hack for the special WebGL 1 "DEPTH_STENCIL" internal format.
GLenum convertedInternalFormat = context->getConvertedRenderbufferFormat(internalformat);
const TextureCaps &formatCaps = context->getTextureCaps().get(convertedInternalFormat);
if (!formatCaps.renderbuffer)
{
context->validationError(GL_INVALID_ENUM, kInvalidRenderbufferInternalFormat);
return 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.
const InternalFormat &formatInfo = GetSizedInternalFormatInfo(convertedInternalFormat);
if (formatInfo.internalFormat == GL_NONE)
{
context->validationError(GL_INVALID_ENUM, kInvalidRenderbufferInternalFormat);
return false;
}
if (std::max(width, height) > context->getCaps().maxRenderbufferSize)
{
context->validationError(GL_INVALID_VALUE, kResourceMaxRenderbufferSize);
return false;
}
RenderbufferID id = context->getState().getRenderbufferId();
if (id.value == 0)
{
context->validationError(GL_INVALID_OPERATION, kInvalidRenderbufferTarget);
return false;
}
return true;
}
bool ValidateBlitFramebufferParameters(const Context *context,
GLint srcX0,
GLint srcY0,
GLint srcX1,
GLint srcY1,
GLint dstX0,
GLint dstY0,
GLint dstX1,
GLint dstY1,
GLbitfield mask,
GLenum filter)
{
switch (filter)
{
case GL_NEAREST:
break;
case GL_LINEAR:
break;
default:
context->validationError(GL_INVALID_ENUM, kBlitInvalidFilter);
return false;
}
if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
{
context->validationError(GL_INVALID_VALUE, kBlitInvalidMask);
return 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)
{
context->validationError(GL_INVALID_OPERATION, kBlitOnlyNearestForNonColor);
return false;
}
const auto &glState = context->getState();
Framebuffer *readFramebuffer = glState.getReadFramebuffer();
Framebuffer *drawFramebuffer = glState.getDrawFramebuffer();
if (!readFramebuffer || !drawFramebuffer)
{
context->validationError(GL_INVALID_FRAMEBUFFER_OPERATION, kBlitFramebufferMissing);
return false;
}
if (!ValidateFramebufferComplete(context, readFramebuffer))
{
return false;
}
if (!ValidateFramebufferComplete(context, drawFramebuffer))
{
return false;
}
// EXT_YUV_target disallows blitting to or from a YUV framebuffer
if ((mask & GL_COLOR_BUFFER_BIT) != 0 &&
(readFramebuffer->hasYUVAttachment() || drawFramebuffer->hasYUVAttachment()))
{
context->validationError(GL_INVALID_OPERATION, kBlitYUVFramebuffer);
return false;
}
// The draw and read framebuffers can only match if:
// - They are the default framebuffer AND
// - The read/draw surfaces are different
if ((readFramebuffer->id() == drawFramebuffer->id()) &&
((drawFramebuffer->id() != Framebuffer::kDefaultDrawFramebufferHandle) ||
(context->getCurrentDrawSurface() == context->getCurrentReadSurface())))
{
context->validationError(GL_INVALID_OPERATION, kBlitFeedbackLoop);
return false;
}
// Not allow blitting to MS buffers, therefore if renderToTextureSamples exist,
// consider it MS. checkReadBufferResourceSamples = false
if (!ValidateFramebufferNotMultisampled(context, drawFramebuffer, false))
{
return false;
}
// This validation is specified in the WebGL 2.0 spec and not in the GLES 3.0.5 spec, but we
// always run it in order to avoid triggering driver bugs.
if (DifferenceCanOverflow(srcX0, srcX1) || DifferenceCanOverflow(srcY0, srcY1) ||
DifferenceCanOverflow(dstX0, dstX1) || DifferenceCanOverflow(dstY0, dstY1))
{
context->validationError(GL_INVALID_VALUE, kBlitDimensionsOutOfRange);
return false;
}
bool sameBounds = srcX0 == dstX0 && srcY0 == dstY0 && srcX1 == dstX1 && srcY1 == dstY1;
if (mask & GL_COLOR_BUFFER_BIT)
{
const FramebufferAttachment *readColorBuffer = readFramebuffer->getReadColorAttachment();
const Extensions &extensions = context->getExtensions();
if (readColorBuffer)
{
const Format &readFormat = readColorBuffer->getFormat();
for (size_t drawbufferIdx = 0;
drawbufferIdx < drawFramebuffer->getDrawbufferStateCount(); ++drawbufferIdx)
{
const FramebufferAttachment *attachment =
drawFramebuffer->getDrawBuffer(drawbufferIdx);
if (attachment)
{
const Format &drawFormat = attachment->getFormat();
// The GL ES 3.0.2 spec (pg 193) states that:
// 1) If the read buffer is fixed point format, the draw buffer must be as well
// 2) If the read buffer is an unsigned integer format, the draw buffer must be
// as well
// 3) If the read buffer is a signed integer format, the draw buffer must be as
// well
// Changes with EXT_color_buffer_float:
// Case 1) is changed to fixed point OR floating point
GLenum readComponentType = readFormat.info->componentType;
GLenum drawComponentType = drawFormat.info->componentType;
bool readFixedPoint = (readComponentType == GL_UNSIGNED_NORMALIZED ||
readComponentType == GL_SIGNED_NORMALIZED);
bool drawFixedPoint = (drawComponentType == GL_UNSIGNED_NORMALIZED ||
drawComponentType == GL_SIGNED_NORMALIZED);
if (extensions.colorBufferFloat)
{
bool readFixedOrFloat = (readFixedPoint || readComponentType == GL_FLOAT);
bool drawFixedOrFloat = (drawFixedPoint || drawComponentType == GL_FLOAT);
if (readFixedOrFloat != drawFixedOrFloat)
{
context->validationError(GL_INVALID_OPERATION,
kBlitTypeMismatchFixedOrFloat);
return false;
}
}
else if (readFixedPoint != drawFixedPoint)
{
context->validationError(GL_INVALID_OPERATION, kBlitTypeMismatchFixedPoint);
return false;
}
if (readComponentType == GL_UNSIGNED_INT &&
drawComponentType != GL_UNSIGNED_INT)
{
context->validationError(GL_INVALID_OPERATION,
kBlitTypeMismatchUnsignedInteger);
return false;
}
if (readComponentType == GL_INT && drawComponentType != GL_INT)
{
context->validationError(GL_INVALID_OPERATION,
kBlitTypeMismatchSignedInteger);
return false;
}
if (readColorBuffer->getResourceSamples() > 0 &&
(!Format::EquivalentForBlit(readFormat, drawFormat) || !sameBounds))
{
context->validationError(GL_INVALID_OPERATION,
kBlitMultisampledFormatOrBoundsMismatch);
return false;
}
if (context->getExtensions().webglCompatibility &&
*readColorBuffer == *attachment)
{
context->validationError(GL_INVALID_OPERATION, kBlitSameImageColor);
return false;
}
}
}
if (readFormat.info->isInt() && filter == GL_LINEAR)
{
context->validationError(GL_INVALID_OPERATION, kBlitIntegerWithLinearFilter);
return false;
}
}
// WebGL 2.0 BlitFramebuffer when blitting from a missing attachment
// In OpenGL ES it is undefined what happens when an operation tries to blit from a missing
// attachment and WebGL defines it to be an error. We do the check unconditionally as the
// situation is an application error that would lead to a crash in ANGLE.
else if (drawFramebuffer->hasEnabledDrawBuffer())
{
context->validationError(GL_INVALID_OPERATION, kBlitMissingColor);
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(context, attachments[i]);
const FramebufferAttachment *drawBuffer =
drawFramebuffer->getAttachment(context, attachments[i]);
if (readBuffer && drawBuffer)
{
if (!Format::EquivalentForBlit(readBuffer->getFormat(), drawBuffer->getFormat()))
{
context->validationError(GL_INVALID_OPERATION,
kBlitDepthOrStencilFormatMismatch);
return false;
}
if (readBuffer->getResourceSamples() > 0 && !sameBounds)
{
context->validationError(GL_INVALID_OPERATION, kBlitMultisampledBoundsMismatch);
return false;
}
if (context->getExtensions().webglCompatibility && *readBuffer == *drawBuffer)
{
context->validationError(GL_INVALID_OPERATION, kBlitSameImageDepthOrStencil);
return false;
}
}
// WebGL 2.0 BlitFramebuffer when blitting from a missing attachment
else if (drawBuffer)
{
context->validationError(GL_INVALID_OPERATION, kBlitMissingDepthOrStencil);
return false;
}
}
}
// OVR_multiview2:
// Calling BlitFramebuffer will result in an INVALID_FRAMEBUFFER_OPERATION error if the
// current draw framebuffer isMultiview() or the number of
// views in the current read framebuffer is more than one.
if (readFramebuffer->readDisallowedByMultiview())
{
context->validationError(GL_INVALID_FRAMEBUFFER_OPERATION, kBlitFromMultiview);
return false;
}
if (drawFramebuffer->isMultiview())
{
context->validationError(GL_INVALID_FRAMEBUFFER_OPERATION, kBlitToMultiview);
return false;
}
return true;
}
bool ValidateBindFramebufferBase(const Context *context, GLenum target, FramebufferID framebuffer)
{
if (!ValidFramebufferTarget(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidFramebufferTarget);
return false;
}
if (!context->getState().isBindGeneratesResourceEnabled() &&
!context->isFramebufferGenerated(framebuffer))
{
context->validationError(GL_INVALID_OPERATION, kObjectNotGenerated);
return false;
}
return true;
}
bool ValidateBindRenderbufferBase(const Context *context,
GLenum target,
RenderbufferID renderbuffer)
{
if (target != GL_RENDERBUFFER)
{
context->validationError(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
return false;
}
if (!context->getState().isBindGeneratesResourceEnabled() &&
!context->isRenderbufferGenerated(renderbuffer))
{
context->validationError(GL_INVALID_OPERATION, kObjectNotGenerated);
return false;
}
return true;
}
bool ValidateFramebufferRenderbufferBase(const Context *context,
GLenum target,
GLenum attachment,
GLenum renderbuffertarget,
RenderbufferID renderbuffer)
{
if (!ValidFramebufferTarget(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidFramebufferTarget);
return false;
}
if (renderbuffertarget != GL_RENDERBUFFER)
{
context->validationError(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
return false;
}
Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target);
ASSERT(framebuffer);
if (framebuffer->isDefault())
{
context->validationError(GL_INVALID_OPERATION, kDefaultFramebufferTarget);
return false;
}
if (!ValidateAttachmentTarget(context, attachment))
{
return false;
}
// [OpenGL ES 2.0.25] Section 4.4.3 page 112
// [OpenGL ES 3.0.2] Section 4.4.2 page 201
// 'renderbuffer' must be either zero or the name of an existing renderbuffer object of
// type 'renderbuffertarget', otherwise an INVALID_OPERATION error is generated.
if (renderbuffer.value != 0)
{
if (!context->getRenderbuffer(renderbuffer))
{
context->validationError(GL_INVALID_OPERATION, kInvalidRenderbufferTarget);
return false;
}
}
return true;
}
bool ValidateFramebufferTextureBase(const Context *context,
GLenum target,
GLenum attachment,
TextureID texture,
GLint level)
{
if (!ValidFramebufferTarget(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidFramebufferTarget);
return false;
}
if (!ValidateAttachmentTarget(context, attachment))
{
return false;
}
if (texture.value != 0)
{
Texture *tex = context->getTexture(texture);
if (tex == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kMissingTexture);
return false;
}
if (level < 0)
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
// GLES spec 3.1, Section 9.2.8 "Attaching Texture Images to a Framebuffer"
// An INVALID_VALUE error is generated if texture is not zero and level is
// not a supported texture level for textarget
// Common criteria for not supported texture levels(other criteria are handled case by case
// in non base functions): If texture refers to an immutable-format texture, level must be
// greater than or equal to zero and smaller than the value of TEXTURE_IMMUTABLE_LEVELS for
// texture.
if (tex->getImmutableFormat() && context->getClientVersion() >= ES_3_1)
{
if (level >= static_cast<GLint>(tex->getImmutableLevels()))
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
}
// GLES spec 3.2, Section 9.2.8 "Attaching Texture Images to a Framebuffer"
// An INVALID_OPERATION error is generated if <texture> is the name of a buffer texture.
if ((context->getClientVersion() >= ES_3_2 ||
context->getExtensions().textureBufferAny()) &&
tex->getType() == TextureType::Buffer)
{
context->validationError(GL_INVALID_OPERATION, kInvalidTextureTarget);
return false;
}
}
const Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target);
ASSERT(framebuffer);
if (framebuffer->isDefault())
{
context->validationError(GL_INVALID_OPERATION, kDefaultFramebufferTarget);
return false;
}
return true;
}
bool ValidateGenerateMipmapBase(const Context *context, TextureType target)
{
if (!ValidTextureTarget(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
Texture *texture = context->getTextureByType(target);
if (texture == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kTextureNotBound);
return false;
}
const GLuint effectiveBaseLevel = texture->getTextureState().getEffectiveBaseLevel();
// This error isn't spelled out in the spec in a very explicit way, but we interpret the spec so
// that out-of-range base level has a non-color-renderable / non-texture-filterable format.
if (effectiveBaseLevel >= IMPLEMENTATION_MAX_TEXTURE_LEVELS)
{
context->validationError(GL_INVALID_OPERATION, kBaseLevelOutOfRange);
return false;
}
TextureTarget baseTarget = (target == TextureType::CubeMap)
? TextureTarget::CubeMapPositiveX
: NonCubeTextureTypeToTarget(target);
const auto &format = *(texture->getFormat(baseTarget, effectiveBaseLevel).info);
if (format.sizedInternalFormat == GL_NONE || format.compressed || format.depthBits > 0 ||
format.stencilBits > 0)
{
context->validationError(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
return false;
}
// GenerateMipmap accepts formats that are unsized or both color renderable and filterable.
bool formatUnsized = !format.sized;
bool formatColorRenderableAndFilterable =
format.filterSupport(context->getClientVersion(), context->getExtensions()) &&
format.textureAttachmentSupport(context->getClientVersion(), context->getExtensions());
if (!formatUnsized && !formatColorRenderableAndFilterable)
{
context->validationError(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
return false;
}
// GL_EXT_sRGB adds an unsized SRGB (no alpha) format which has explicitly disabled mipmap
// generation
if (format.colorEncoding == GL_SRGB && format.format == GL_RGB)
{
context->validationError(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
return false;
}
// According to the OpenGL extension spec EXT_sRGB.txt, EXT_SRGB is based on ES 2.0 and
// generateMipmap is not allowed if texture format is SRGB_EXT or SRGB_ALPHA_EXT.
if (context->getClientVersion() < Version(3, 0) && format.colorEncoding == GL_SRGB)
{
context->validationError(GL_INVALID_OPERATION, kGenerateMipmapNotAllowed);
return false;
}
// Non-power of 2 ES2 check
if (context->getClientVersion() < Version(3, 0) && !context->getExtensions().textureNPOTOES &&
(!isPow2(static_cast<int>(texture->getWidth(baseTarget, 0))) ||
!isPow2(static_cast<int>(texture->getHeight(baseTarget, 0)))))
{
ASSERT(target == TextureType::_2D || target == TextureType::Rectangle ||
target == TextureType::CubeMap);
context->validationError(GL_INVALID_OPERATION, kTextureNotPow2);
return false;
}
// Cube completeness check
if (target == TextureType::CubeMap && !texture->getTextureState().isCubeComplete())
{
context->validationError(GL_INVALID_OPERATION, kCubemapIncomplete);
return false;
}
if (context->getExtensions().webglCompatibility &&
(texture->getWidth(baseTarget, effectiveBaseLevel) == 0 ||
texture->getHeight(baseTarget, effectiveBaseLevel) == 0))
{
context->validationError(GL_INVALID_OPERATION, kGenerateMipmapZeroSize);
return false;
}
return true;
}
bool ValidateReadPixelsRobustANGLE(const Context *context,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
const GLsizei *length,
const GLsizei *columns,
const GLsizei *rows,
const void *pixels)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
GLsizei writeColumns = 0;
GLsizei writeRows = 0;
if (!ValidateReadPixelsBase(context, x, y, width, height, format, type, bufSize, &writeLength,
&writeColumns, &writeRows, pixels))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
SetRobustLengthParam(columns, writeColumns);
SetRobustLengthParam(rows, writeRows);
return true;
}
bool ValidateReadnPixelsEXT(const Context *context,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
const void *pixels)
{
if (bufSize < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeBufferSize);
return false;
}
return ValidateReadPixelsBase(context, x, y, width, height, format, type, bufSize, nullptr,
nullptr, nullptr, pixels);
}
bool ValidateReadnPixelsRobustANGLE(const Context *context,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
const GLsizei *length,
const GLsizei *columns,
const GLsizei *rows,
const void *data)
{
GLsizei writeLength = 0;
GLsizei writeColumns = 0;
GLsizei writeRows = 0;
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
if (!ValidateReadPixelsBase(context, x, y, width, height, format, type, bufSize, &writeLength,
&writeColumns, &writeRows, data))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
SetRobustLengthParam(columns, writeColumns);
SetRobustLengthParam(rows, writeRows);
return true;
}
bool ValidateGenQueriesEXT(const Context *context, GLsizei n, const QueryID *ids)
{
if (!context->getExtensions().occlusionQueryBoolean &&
!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
return false;
}
return ValidateGenOrDelete(context, n);
}
bool ValidateDeleteQueriesEXT(const Context *context, GLsizei n, const QueryID *ids)
{
if (!context->getExtensions().occlusionQueryBoolean &&
!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
return false;
}
return ValidateGenOrDelete(context, n);
}
bool ValidateIsQueryEXT(const Context *context, QueryID id)
{
if (!context->getExtensions().occlusionQueryBoolean &&
!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
return false;
}
return true;
}
bool ValidateBeginQueryBase(const Context *context, QueryType target, QueryID id)
{
if (!ValidQueryType(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidQueryType);
return false;
}
if (id.value == 0)
{
context->validationError(GL_INVALID_OPERATION, kInvalidQueryId);
return false;
}
// From EXT_occlusion_query_boolean: If BeginQueryEXT is called with an <id>
// of zero, if the active query object name for <target> is non-zero (for the
// targets ANY_SAMPLES_PASSED_EXT and ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, if
// the active query for either target is non-zero), if <id> is the name of an
// existing query object whose type does not match <target>, or if <id> is the
// active query object name for any query type, the error INVALID_OPERATION is
// generated.
// Ensure no other queries are active
// NOTE: If other queries than occlusion are supported, we will need to check
// separately that:
// a) The query ID passed is not the current active query for any target/type
// b) There are no active queries for the requested target (and in the case
// of GL_ANY_SAMPLES_PASSED_EXT and GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
// no query may be active for either if glBeginQuery targets either.
if (context->getState().isQueryActive(target))
{
context->validationError(GL_INVALID_OPERATION, kOtherQueryActive);
return false;
}
// check that name was obtained with glGenQueries
if (!context->isQueryGenerated(id))
{
context->validationError(GL_INVALID_OPERATION, kInvalidQueryId);
return false;
}
// Check for type mismatch. If query is not yet started we're good to go.
Query *queryObject = context->getQuery(id);
if (queryObject && queryObject->getType() != target)
{
context->validationError(GL_INVALID_OPERATION, kQueryTargetMismatch);
return false;
}
return true;
}
bool ValidateBeginQueryEXT(const Context *context, QueryType target, QueryID id)
{
if (!context->getExtensions().occlusionQueryBoolean &&
!context->getExtensions().disjointTimerQuery && !context->getExtensions().syncQuery)
{
context->validationError(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
return false;
}
return ValidateBeginQueryBase(context, target, id);
}
bool ValidateEndQueryBase(const Context *context, QueryType target)
{
if (!ValidQueryType(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidQueryType);
return false;
}
const Query *queryObject = context->getState().getActiveQuery(target);
if (queryObject == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kQueryInactive);
return false;
}
return true;
}
bool ValidateEndQueryEXT(const Context *context, QueryType target)
{
if (!context->getExtensions().occlusionQueryBoolean &&
!context->getExtensions().disjointTimerQuery && !context->getExtensions().syncQuery)
{
context->validationError(GL_INVALID_OPERATION, kQueryExtensionNotEnabled);
return false;
}
return ValidateEndQueryBase(context, target);
}
bool ValidateQueryCounterEXT(const Context *context, QueryID id, QueryType target)
{
if (!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (target != QueryType::Timestamp)
{
context->validationError(GL_INVALID_ENUM, kInvalidQueryTarget);
return false;
}
if (!context->isQueryGenerated(id))
{
context->validationError(GL_INVALID_OPERATION, kInvalidQueryId);
return false;
}
// If query object is not started, that's fine.
Query *queryObject = context->getQuery(id);
if (queryObject && context->getState().isQueryActive(queryObject))
{
context->validationError(GL_INVALID_OPERATION, kQueryActive);
return false;
}
return true;
}
bool ValidateGetQueryivBase(const Context *context,
QueryType target,
GLenum pname,
GLsizei *numParams)
{
if (numParams)
{
*numParams = 0;
}
if (!ValidQueryType(context, target) && target != QueryType::Timestamp)
{
context->validationError(GL_INVALID_ENUM, kInvalidQueryType);
return false;
}
switch (pname)
{
case GL_CURRENT_QUERY_EXT:
if (target == QueryType::Timestamp)
{
context->validationError(GL_INVALID_ENUM, kInvalidQueryTarget);
return false;
}
break;
case GL_QUERY_COUNTER_BITS_EXT:
if (!context->getExtensions().disjointTimerQuery ||
(target != QueryType::Timestamp && target != QueryType::TimeElapsed))
{
context->validationError(GL_INVALID_ENUM, kInvalidPname);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidPname);
return false;
}
if (numParams)
{
// All queries return only one value
*numParams = 1;
}
return true;
}
bool ValidateGetQueryivEXT(const Context *context,
QueryType target,
GLenum pname,
const GLint *params)
{
if (!context->getExtensions().occlusionQueryBoolean &&
!context->getExtensions().disjointTimerQuery && !context->getExtensions().syncQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
return ValidateGetQueryivBase(context, target, pname, nullptr);
}
bool ValidateGetQueryivRobustANGLE(const Context *context,
QueryType target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetQueryivBase(context, target, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetQueryObjectValueBase(const Context *context,
QueryID id,
GLenum pname,
GLsizei *numParams)
{
if (numParams)
{
*numParams = 1;
}
if (context->isContextLost())
{
context->validationError(GL_CONTEXT_LOST, kContextLost);
if (pname == GL_QUERY_RESULT_AVAILABLE_EXT)
{
// Generate an error but still return true, the context still needs to return a
// value in this case.
return true;
}
else
{
return false;
}
}
Query *queryObject = context->getQuery(id);
if (!queryObject)
{
context->validationError(GL_INVALID_OPERATION, kInvalidQueryId);
return false;
}
if (context->getState().isQueryActive(queryObject))
{
context->validationError(GL_INVALID_OPERATION, kQueryActive);
return false;
}
switch (pname)
{
case GL_QUERY_RESULT_EXT:
case GL_QUERY_RESULT_AVAILABLE_EXT:
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
return true;
}
bool ValidateGetQueryObjectivEXT(const Context *context,
QueryID id,
GLenum pname,
const GLint *params)
{
if (!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
return ValidateGetQueryObjectValueBase(context, id, pname, nullptr);
}
bool ValidateGetQueryObjectivRobustANGLE(const Context *context,
QueryID id,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetQueryObjectValueBase(context, id, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetQueryObjectuivEXT(const Context *context,
QueryID id,
GLenum pname,
const GLuint *params)
{
if (!context->getExtensions().disjointTimerQuery &&
!context->getExtensions().occlusionQueryBoolean && !context->getExtensions().syncQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
return ValidateGetQueryObjectValueBase(context, id, pname, nullptr);
}
bool ValidateGetQueryObjectuivRobustANGLE(const Context *context,
QueryID id,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLuint *params)
{
if (!context->getExtensions().disjointTimerQuery &&
!context->getExtensions().occlusionQueryBoolean && !context->getExtensions().syncQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetQueryObjectValueBase(context, id, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetQueryObjecti64vEXT(const Context *context,
QueryID id,
GLenum pname,
GLint64 *params)
{
if (!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
return ValidateGetQueryObjectValueBase(context, id, pname, nullptr);
}
bool ValidateGetQueryObjecti64vRobustANGLE(const Context *context,
QueryID id,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
GLint64 *params)
{
if (!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetQueryObjectValueBase(context, id, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetQueryObjectui64vEXT(const Context *context,
QueryID id,
GLenum pname,
GLuint64 *params)
{
if (!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
return ValidateGetQueryObjectValueBase(context, id, pname, nullptr);
}
bool ValidateGetQueryObjectui64vRobustANGLE(const Context *context,
QueryID id,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
GLuint64 *params)
{
if (!context->getExtensions().disjointTimerQuery)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetQueryObjectValueBase(context, id, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateUniformCommonBase(const Context *context,
const Program *program,
UniformLocation location,
GLsizei count,
const LinkedUniform **uniformOut)
{
// TODO(Jiajia): Add image uniform check in future.
if (count < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeCount);
return false;
}
if (!program)
{
context->validationError(GL_INVALID_OPERATION, kInvalidProgramName);
return false;
}
if (!program->isLinked())
{
context->validationError(GL_INVALID_OPERATION, kProgramNotLinked);
return false;
}
if (location.value == -1)
{
// Silently ignore the uniform command
return false;
}
const auto &uniformLocations = program->getUniformLocations();
size_t castedLocation = static_cast<size_t>(location.value);
if (castedLocation >= uniformLocations.size())
{
context->validationError(GL_INVALID_OPERATION, kInvalidUniformLocation);
return false;
}
const auto &uniformLocation = uniformLocations[castedLocation];
if (uniformLocation.ignored)
{
// Silently ignore the uniform command
return false;
}
if (!uniformLocation.used())
{
context->validationError(GL_INVALID_OPERATION, kInvalidUniformLocation);
return false;
}
const auto &uniform = program->getUniformByIndex(uniformLocation.index);
// attempting to write an array to a non-array uniform is an INVALID_OPERATION
if (count > 1 && !uniform.isArray())
{
context->validationError(GL_INVALID_OPERATION, kInvalidUniformCount);
return false;
}
*uniformOut = &uniform;
return true;
}
bool ValidateUniform1ivValue(const Context *context,
GLenum uniformType,
GLsizei count,
const GLint *value)
{
// Value type is GL_INT, because we only get here from glUniform1i{v}.
// It is compatible with INT or BOOL.
// Do these cheap tests first, for a little extra speed.
if (GL_INT == uniformType || GL_BOOL == uniformType)
{
return true;
}
if (IsSamplerType(uniformType))
{
// Check that the values are in range.
const GLint max = context->getCaps().maxCombinedTextureImageUnits;
for (GLsizei i = 0; i < count; ++i)
{
if (value[i] < 0 || value[i] >= max)
{
context->validationError(GL_INVALID_VALUE, kSamplerUniformValueOutOfRange);
return false;
}
}
return true;
}
context->validationError(GL_INVALID_OPERATION, kUniformTypeMismatch);
return false;
}
bool ValidateUniformMatrixValue(const Context *context, GLenum valueType, GLenum uniformType)
{
// Check that the value type is compatible with uniform type.
if (valueType == uniformType)
{
return true;
}
context->validationError(GL_INVALID_OPERATION, kUniformTypeMismatch);
return false;
}
bool ValidateUniform(const Context *context,
GLenum valueType,
UniformLocation location,
GLsizei count)
{
const LinkedUniform *uniform = nullptr;
Program *programObject = context->getActiveLinkedProgram();
return ValidateUniformCommonBase(context, programObject, location, count, &uniform) &&
ValidateUniformValue(context, valueType, uniform->type);
}
bool ValidateUniform1iv(const Context *context,
UniformLocation location,
GLsizei count,
const GLint *value)
{
const LinkedUniform *uniform = nullptr;
Program *programObject = context->getActiveLinkedProgram();
return ValidateUniformCommonBase(context, programObject, location, count, &uniform) &&
ValidateUniform1ivValue(context, uniform->type, count, value);
}
bool ValidateUniformMatrix(const Context *context,
GLenum valueType,
UniformLocation location,
GLsizei count,
GLboolean transpose)
{
if (ConvertToBool(transpose) && context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_VALUE, kES3Required);
return false;
}
const LinkedUniform *uniform = nullptr;
Program *programObject = context->getActiveLinkedProgram();
return ValidateUniformCommonBase(context, programObject, location, count, &uniform) &&
ValidateUniformMatrixValue(context, valueType, uniform->type);
}
bool ValidateStateQuery(const Context *context,
GLenum pname,
GLenum *nativeType,
unsigned int *numParams)
{
if (!context->getQueryParameterInfo(pname, nativeType, numParams))
{
context->validationError(GL_INVALID_ENUM, kInvalidPname);
return false;
}
const Caps &caps = context->getCaps();
if (pname >= GL_DRAW_BUFFER0 && pname <= GL_DRAW_BUFFER15)
{
int colorAttachment = (pname - GL_DRAW_BUFFER0);
if (colorAttachment >= caps.maxDrawBuffers)
{
context->validationError(GL_INVALID_OPERATION, kIndexExceedsMaxDrawBuffer);
return false;
}
}
switch (pname)
{
case GL_TEXTURE_BINDING_2D:
case GL_TEXTURE_BINDING_CUBE_MAP:
case GL_TEXTURE_BINDING_3D:
case GL_TEXTURE_BINDING_2D_ARRAY:
case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
break;
case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
if (!context->getExtensions().textureStorageMultisample2DArrayOES)
{
context->validationError(GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
return false;
}
break;
case GL_TEXTURE_BINDING_RECTANGLE_ANGLE:
if (!context->getExtensions().textureRectangle)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_BINDING_EXTERNAL_OES:
if (!context->getExtensions().eglStreamConsumerExternalNV &&
!context->getExtensions().eglImageExternalOES)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_BUFFER_BINDING:
case GL_TEXTURE_BINDING_BUFFER:
case GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
case GL_MAX_TEXTURE_BUFFER_SIZE:
if (context->getClientVersion() < Version(3, 2) &&
!context->getExtensions().textureBufferAny())
{
context->validationError(GL_INVALID_ENUM, kTextureBufferExtensionNotAvailable);
return false;
}
break;
case GL_IMPLEMENTATION_COLOR_READ_TYPE:
case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
{
Framebuffer *readFramebuffer = context->getState().getReadFramebuffer();
ASSERT(readFramebuffer);
if (!ValidateFramebufferComplete<GL_INVALID_OPERATION>(context, readFramebuffer))
{
return false;
}
if (readFramebuffer->getReadBufferState() == GL_NONE)
{
context->validationError(GL_INVALID_OPERATION, kReadBufferNone);
return false;
}
const FramebufferAttachment *attachment = readFramebuffer->getReadColorAttachment();
if (!attachment)
{
context->validationError(GL_INVALID_OPERATION, kReadBufferNotAttached);
return false;
}
}
break;
case GL_PRIMITIVE_BOUNDING_BOX:
if (!context->getExtensions().primitiveBoundingBoxEXT)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
default:
break;
}
// pname is valid, but there are no parameters to return
if (*numParams == 0)
{
return false;
}
return true;
}
bool ValidateGetBooleanvRobustANGLE(const Context *context,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLboolean *params)
{
GLenum nativeType;
unsigned int numParams = 0;
if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetFloatvRobustANGLE(const Context *context,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLfloat *params)
{
GLenum nativeType;
unsigned int numParams = 0;
if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetIntegervRobustANGLE(const Context *context,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *data)
{
GLenum nativeType;
unsigned int numParams = 0;
if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetInteger64vRobustANGLE(const Context *context,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
GLint64 *data)
{
GLenum nativeType;
unsigned int numParams = 0;
if (!ValidateRobustStateQuery(context, pname, bufSize, &nativeType, &numParams))
{
return false;
}
if (nativeType == GL_INT_64_ANGLEX)
{
CastStateValues(context, nativeType, pname, numParams, data);
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateRobustStateQuery(const Context *context,
GLenum pname,
GLsizei bufSize,
GLenum *nativeType,
unsigned int *numParams)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
if (!ValidateStateQuery(context, pname, nativeType, numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, *numParams))
{
return false;
}
return true;
}
bool ValidateCopyImageSubDataTarget(const Context *context, GLuint name, GLenum target)
{
// From EXT_copy_image: INVALID_ENUM is generated if either <srcTarget> or <dstTarget> is not
// RENDERBUFFER or a valid non - proxy texture target, is TEXTURE_BUFFER, or is one of the
// cubemap face selectors described in table 3.17, or if the target does not match the type of
// the object. INVALID_VALUE is generated if either <srcName> or <dstName> does not correspond
// to a valid renderbuffer or texture object according to the corresponding target parameter.
switch (target)
{
case GL_RENDERBUFFER:
{
RenderbufferID renderbuffer = PackParam<RenderbufferID>(name);
if (!context->isRenderbuffer(renderbuffer))
{
context->validationError(GL_INVALID_VALUE, kInvalidRenderbufferName);
return false;
}
break;
}
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_ARRAY_EXT:
{
TextureID texture = PackParam<TextureID>(name);
if (!context->isTexture(texture))
{
context->validationError(GL_INVALID_VALUE, kInvalidTextureName);
return false;
}
Texture *textureObject = context->getTexture(texture);
if (textureObject && textureObject->getType() != PackParam<TextureType>(target))
{
context->validationError(GL_INVALID_ENUM, err::kTextureTypeMismatch);
return false;
}
break;
}
default:
context->validationError(GL_INVALID_ENUM, kInvalidTarget);
return false;
}
return true;
}
bool ValidateCopyImageSubDataLevel(const Context *context, GLenum target, GLint level)
{
switch (target)
{
case GL_RENDERBUFFER:
{
if (level != 0)
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
break;
}
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_ARRAY_EXT:
{
if (!ValidMipLevel(context, PackParam<TextureType>(target), level))
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
break;
}
default:
context->validationError(GL_INVALID_ENUM, kInvalidTarget);
return false;
}
return true;
}
bool ValidateCopyImageSubDataTargetRegion(const Context *context,
GLuint name,
GLenum target,
GLint level,
GLint offsetX,
GLint offsetY,
GLint offsetZ,
GLsizei width,
GLsizei height,
GLsizei *samples)
{
// INVALID_VALUE is generated if the dimensions of the either subregion exceeds the boundaries
// of the corresponding image object.
if (offsetX < 0 || offsetY < 0 || offsetZ < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeOffset);
return false;
}
if (target == GL_RENDERBUFFER)
{
// INVALID_VALUE is generated if the dimensions of the either subregion exceeds the
// boundaries of the corresponding image object
Renderbuffer *buffer = context->getRenderbuffer(PackParam<RenderbufferID>(name));
if ((buffer->getWidth() - offsetX < width) || (buffer->getHeight() - offsetY < height))
{
context->validationError(GL_INVALID_VALUE, kSourceTextureTooSmall);
return false;
}
}
else
{
Texture *texture = context->getTexture(PackParam<TextureID>(name));
// INVALID_OPERATION is generated if either object is a texture and the texture is not
// complete
// This will handle the texture completeness check. Note that this is missing
// completeness validation that ignores format-based compleness rules.
if (!texture->isSamplerComplete(context, nullptr))
{
context->validationError(GL_INVALID_OPERATION, kNotTextureComplete);
return false;
}
GLenum textureTargetToUse = target;
if (target == GL_TEXTURE_CUBE_MAP)
{
// Use GL_TEXTURE_CUBE_MAP_POSITIVE_X to properly gather the textureWidth/textureHeight
textureTargetToUse = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
}
const GLsizei textureWidth = static_cast<GLsizei>(
texture->getWidth(PackParam<TextureTarget>(textureTargetToUse), level));
const GLsizei textureHeight = static_cast<GLsizei>(
texture->getHeight(PackParam<TextureTarget>(textureTargetToUse), level));
// INVALID_VALUE is generated if the dimensions of the either subregion exceeds the
// boundaries of the corresponding image object
if ((textureWidth - offsetX < width) || (textureHeight - offsetY < height))
{
context->validationError(GL_INVALID_VALUE, kSourceTextureTooSmall);
return false;
}
*samples = texture->getSamples(PackParam<TextureTarget>(textureTargetToUse), level);
*samples = (*samples == 0) ? 1 : *samples;
}
return true;
}
bool ValidateCompressedRegion(const Context *context,
const InternalFormat &formatInfo,
GLsizei width,
GLsizei height)
{
ASSERT(formatInfo.compressed);
// INVALID_VALUE is generated if the image format is compressed and the dimensions of the
// subregion fail to meet the alignment constraints of the format.
if ((width % formatInfo.compressedBlockWidth != 0) ||
(height % formatInfo.compressedBlockHeight != 0))
{
context->validationError(GL_INVALID_VALUE, kInvalidCompressedRegionSize);
return false;
}
return true;
}
const InternalFormat &GetTargetFormatInfo(const Context *context,
GLuint name,
GLenum target,
GLint level)
{
static const InternalFormat defaultInternalFormat;
switch (target)
{
case GL_RENDERBUFFER:
{
Renderbuffer *buffer = context->getRenderbuffer(PackParam<RenderbufferID>(name));
return *buffer->getFormat().info;
}
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_ARRAY_EXT:
{
Texture *texture = context->getTexture(PackParam<TextureID>(name));
GLenum textureTargetToUse = target;
if (target == GL_TEXTURE_CUBE_MAP)
{
// Use GL_TEXTURE_CUBE_MAP_POSITIVE_X to properly gather the
// textureWidth/textureHeight
textureTargetToUse = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
}
return *texture->getFormat(PackParam<TextureTarget>(textureTargetToUse), level).info;
}
default:
context->validationError(GL_INVALID_ENUM, kInvalidTarget);
return defaultInternalFormat;
}
}
bool ValidateCopyMixedFormatCompatible(GLenum uncompressedFormat, GLenum compressedFormat)
{
// Validates mixed format compatibility (uncompressed and compressed) from Table 4.X.1 of the
// EXT_copy_image spec.
switch (compressedFormat)
{
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
case GL_COMPRESSED_RGBA_BPTC_UNORM_EXT:
case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:
case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT:
case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT:
case GL_COMPRESSED_RGBA8_ETC2_EAC:
case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
case GL_COMPRESSED_RG11_EAC:
case GL_COMPRESSED_SIGNED_RG11_EAC:
case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES:
case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES:
case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES:
case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES:
case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES:
case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES:
case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES:
case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES:
case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES:
case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES:
case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES:
{
switch (uncompressedFormat)
{
case GL_RGBA32UI:
case GL_RGBA32I:
case GL_RGBA32F:
return true;
default:
return false;
}
}
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RED_RGTC1_EXT:
case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
case GL_COMPRESSED_RGB8_ETC2:
case GL_COMPRESSED_SRGB8_ETC2:
case GL_COMPRESSED_R11_EAC:
case GL_COMPRESSED_SIGNED_R11_EAC:
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
{
switch (uncompressedFormat)
{
case GL_RGBA16UI:
case GL_RGBA16I:
case GL_RGBA16F:
case GL_RG32UI:
case GL_RG32I:
case GL_RG32F:
return true;
default:
return false;
}
}
default:
break;
}
return false;
}
bool ValidateCopyCompressedFormatCompatible(const InternalFormat &srcFormatInfo,
const InternalFormat &dstFormatInfo)
{
// Validates compressed format compatibility from Table 4.X.2 of the EXT_copy_image spec.
ASSERT(srcFormatInfo.internalFormat != dstFormatInfo.internalFormat);
const GLenum srcFormat = srcFormatInfo.internalFormat;
const GLenum dstFormat = dstFormatInfo.internalFormat;
switch (srcFormat)
{
case GL_COMPRESSED_RED_RGTC1_EXT:
return (dstFormat == GL_COMPRESSED_SIGNED_RED_RGTC1_EXT);
case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
return (dstFormat == GL_COMPRESSED_RED_RGTC1_EXT);
case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
return (dstFormat == GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT);
case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
return (dstFormat == GL_COMPRESSED_RED_GREEN_RGTC2_EXT);
case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT:
return (dstFormat == GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT);
case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT:
return (dstFormat == GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT);
case GL_COMPRESSED_R11_EAC:
return (dstFormat == GL_COMPRESSED_SIGNED_R11_EAC);
case GL_COMPRESSED_SIGNED_R11_EAC:
return (dstFormat == GL_COMPRESSED_R11_EAC);
case GL_COMPRESSED_RG11_EAC:
return (dstFormat == GL_COMPRESSED_SIGNED_RG11_EAC);
case GL_COMPRESSED_SIGNED_RG11_EAC:
return (dstFormat == GL_COMPRESSED_RG11_EAC);
default:
break;
}
// Since they can't be the same format and are both compressed formats, one must be linear and
// the other nonlinear.
if (srcFormatInfo.colorEncoding == dstFormatInfo.colorEncoding)
{
return false;
}
const GLenum linearFormat = (srcFormatInfo.colorEncoding == GL_LINEAR) ? srcFormat : dstFormat;
const GLenum nonLinearFormat =
(srcFormatInfo.colorEncoding != GL_LINEAR) ? srcFormat : dstFormat;
switch (linearFormat)
{
case GL_COMPRESSED_RGBA_BPTC_UNORM_EXT:
return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT);
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
return (nonLinearFormat == GL_COMPRESSED_SRGB_S3TC_DXT1_EXT);
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT);
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT);
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
return (nonLinearFormat == GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT);
case GL_COMPRESSED_RGB8_ETC2:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ETC2);
case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2);
case GL_COMPRESSED_RGBA8_ETC2_EAC:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC);
case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR);
case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR);
case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR);
case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR);
case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR);
case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR);
case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR);
case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR);
case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR);
case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR);
case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR);
case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR);
case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR);
case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR);
case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES);
case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES);
case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES);
case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES);
case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES);
case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES);
case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES);
case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES);
case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES);
case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES:
return (nonLinearFormat == GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES);
default:
break;
}
return false;
}
bool ValidateCopyFormatCompatible(const InternalFormat &srcFormatInfo,
const InternalFormat &dstFormatInfo)
{
// Matching source and destination formats are compatible.
if (srcFormatInfo.internalFormat == dstFormatInfo.internalFormat)
{
return true;
}
if (srcFormatInfo.compressed != dstFormatInfo.compressed)
{
GLenum uncompressedFormat = (!srcFormatInfo.compressed) ? srcFormatInfo.internalFormat
: dstFormatInfo.internalFormat;
GLenum compressedFormat = (srcFormatInfo.compressed) ? srcFormatInfo.internalFormat
: dstFormatInfo.internalFormat;
return ValidateCopyMixedFormatCompatible(uncompressedFormat, compressedFormat);
}
if (!srcFormatInfo.compressed)
{
// Source and destination are uncompressed formats.
return (srcFormatInfo.pixelBytes == dstFormatInfo.pixelBytes);
}
return ValidateCopyCompressedFormatCompatible(srcFormatInfo, dstFormatInfo);
}
bool ValidateCopyImageSubDataBase(const Context *context,
GLuint srcName,
GLenum srcTarget,
GLint srcLevel,
GLint srcX,
GLint srcY,
GLint srcZ,
GLuint dstName,
GLenum dstTarget,
GLint dstLevel,
GLint dstX,
GLint dstY,
GLint dstZ,
GLsizei srcWidth,
GLsizei srcHeight,
GLsizei srcDepth)
{
// INVALID_VALUE is generated if the dimensions of the either subregion exceeds the boundaries
// of the corresponding image object
if ((srcWidth < 0) || (srcHeight < 0) || (srcDepth < 0))
{
context->validationError(GL_INVALID_VALUE, kNegativeSize);
return false;
}
if (!ValidateCopyImageSubDataTarget(context, srcName, srcTarget))
{
return false;
}
if (!ValidateCopyImageSubDataTarget(context, dstName, dstTarget))
{
return false;
}
if (!ValidateCopyImageSubDataLevel(context, srcTarget, srcLevel))
{
return false;
}
if (!ValidateCopyImageSubDataLevel(context, dstTarget, dstLevel))
{
return false;
}
const InternalFormat &srcFormatInfo =
GetTargetFormatInfo(context, srcName, srcTarget, srcLevel);
const InternalFormat &dstFormatInfo =
GetTargetFormatInfo(context, dstName, dstTarget, dstLevel);
GLsizei dstWidth = srcWidth;
GLsizei dstHeight = srcHeight;
GLsizei srcSamples = 1;
GLsizei dstSamples = 1;
if (srcFormatInfo.internalFormat == GL_NONE || dstFormatInfo.internalFormat == GL_NONE)
{
context->validationError(GL_INVALID_VALUE, kInvalidTextureLevel);
return false;
}
if (!ValidateCopyImageSubDataTargetRegion(context, srcName, srcTarget, srcLevel, srcX, srcY,
srcZ, srcWidth, srcHeight, &srcSamples))
{
return false;
}
// When copying from a compressed image to an uncompressed image the image texel dimensions
// written to the uncompressed image will be source extent divided by the compressed texel block
// dimensions.
if ((srcFormatInfo.compressed) && (!dstFormatInfo.compressed))
{
ASSERT(srcFormatInfo.compressedBlockWidth != 0);
ASSERT(srcFormatInfo.compressedBlockHeight != 0);
dstWidth /= srcFormatInfo.compressedBlockWidth;
dstHeight /= srcFormatInfo.compressedBlockHeight;
}
// When copying from an uncompressed image to a compressed image the image texel dimensions
// written to the compressed image will be the source extent multiplied by the compressed texel
// block dimensions.
else if ((!srcFormatInfo.compressed) && (dstFormatInfo.compressed))
{
dstWidth *= dstFormatInfo.compressedBlockWidth;
dstHeight *= dstFormatInfo.compressedBlockHeight;
}
if (!ValidateCopyImageSubDataTargetRegion(context, dstName, dstTarget, dstLevel, dstX, dstY,
dstZ, dstWidth, dstHeight, &dstSamples))
{
return false;
}
bool fillsEntireMip = false;
gl::Texture *dstTexture = context->getTexture({dstName});
gl::TextureTarget dstTargetPacked = gl::PackParam<gl::TextureTarget>(dstTarget);
// TODO(http://anglebug.com/5643): Some targets (e.g., GL_TEXTURE_CUBE_MAP, GL_RENDERBUFFER) are
// unsupported when used with compressed formats due to gl::PackParam() returning
// TextureTarget::InvalidEnum.
if (dstTargetPacked != gl::TextureTarget::InvalidEnum)
{
const gl::Extents &dstExtents = dstTexture->getExtents(dstTargetPacked, dstLevel);
fillsEntireMip = dstX == 0 && dstY == 0 && dstZ == 0 && srcWidth == dstExtents.width &&
srcHeight == dstExtents.height && srcDepth == dstExtents.depth;
}
if (srcFormatInfo.compressed && !fillsEntireMip &&
!ValidateCompressedRegion(context, srcFormatInfo, srcWidth, srcHeight))
{
return false;
}
if (dstFormatInfo.compressed && !fillsEntireMip &&
!ValidateCompressedRegion(context, dstFormatInfo, dstWidth, dstHeight))
{
return false;
}
// From EXT_copy_image: INVALID_OPERATION is generated if the source and destination formats
// are not compatible, if one image is compressed and the other is uncompressed and the block
// size of compressed image is not equal to the texel size of the compressed image.
if (!ValidateCopyFormatCompatible(srcFormatInfo, dstFormatInfo))
{
context->validationError(GL_INVALID_OPERATION, kIncompatibleTextures);
return false;
}
// INVALID_OPERATION is generated if the source and destination number of samples do not match
if (srcSamples != dstSamples)
{
context->validationError(GL_INVALID_OPERATION, kSamplesOutOfRange);
return false;
}
return true;
}
bool ValidateCopyTexImageParametersBase(const Context *context,
TextureTarget target,
GLint level,
GLenum internalformat,
bool isSubImage,
GLint xoffset,
GLint yoffset,
GLint zoffset,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLint border,
Format *textureFormatOut)
{
TextureType texType = TextureTargetToType(target);
if (xoffset < 0 || yoffset < 0 || zoffset < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeOffset);
return false;
}
if (width < 0 || height < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeSize);
return false;
}
if (std::numeric_limits<GLsizei>::max() - xoffset < width ||
std::numeric_limits<GLsizei>::max() - yoffset < height)
{
context->validationError(GL_INVALID_VALUE, kOffsetOverflow);
return false;
}
if (border != 0)
{
context->validationError(GL_INVALID_VALUE, kInvalidBorder);
return false;
}
if (!ValidMipLevel(context, texType, level))
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
const State &state = context->getState();
Framebuffer *readFramebuffer = state.getReadFramebuffer();
if (!ValidateFramebufferComplete(context, readFramebuffer))
{
return false;
}
// checkReadBufferResourceSamples = true. Treat renderToTexture textures as single sample since
// they will be resolved before copying.
if (!readFramebuffer->isDefault() &&
!ValidateFramebufferNotMultisampled(context, readFramebuffer, true))
{
return false;
}
if (readFramebuffer->getReadBufferState() == GL_NONE)
{
context->validationError(GL_INVALID_OPERATION, kReadBufferNone);
return false;
}
// WebGL 1.0 [Section 6.26] Reading From a Missing Attachment
// In OpenGL ES it is undefined what happens when an operation tries to read from a missing
// attachment and WebGL defines it to be an error. We do the check unconditionally as the
// situation is an application error that would lead to a crash in ANGLE.
const FramebufferAttachment *source = readFramebuffer->getReadColorAttachment();
if (source == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kMissingReadAttachment);
return false;
}
if (source->isYUV())
{
context->validationError(GL_INVALID_OPERATION, kCopyFromYUVFramebuffer);
return false;
}
// ANGLE_multiview spec, Revision 1:
// Calling CopyTexSubImage3D, CopyTexImage2D, or CopyTexSubImage2D will result in an
// INVALID_FRAMEBUFFER_OPERATION error if the multi-view layout of the current read framebuffer
// is FRAMEBUFFER_MULTIVIEW_SIDE_BY_SIDE_ANGLE or the number of views in the current read
// framebuffer is more than one.
if (readFramebuffer->readDisallowedByMultiview())
{
context->validationError(GL_INVALID_FRAMEBUFFER_OPERATION, kMultiviewReadFramebuffer);
return false;
}
const Caps &caps = context->getCaps();
GLint maxDimension = 0;
switch (texType)
{
case TextureType::_2D:
maxDimension = caps.max2DTextureSize;
break;
case TextureType::CubeMap:
case TextureType::CubeMapArray:
maxDimension = caps.maxCubeMapTextureSize;
break;
case TextureType::Rectangle:
maxDimension = caps.maxRectangleTextureSize;
break;
case TextureType::_2DArray:
maxDimension = caps.max2DTextureSize;
break;
case TextureType::_3D:
maxDimension = caps.max3DTextureSize;
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
Texture *texture = state.getTargetTexture(texType);
if (!texture)
{
context->validationError(GL_INVALID_OPERATION, kTextureNotBound);
return false;
}
if (texture->getImmutableFormat() && !isSubImage)
{
context->validationError(GL_INVALID_OPERATION, kTextureIsImmutable);
return false;
}
const InternalFormat &formatInfo =
isSubImage ? *texture->getFormat(target, level).info
: GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE);
if (formatInfo.depthBits > 0 || formatInfo.compressed)
{
context->validationError(GL_INVALID_OPERATION, kInvalidFormat);
return false;
}
if (isSubImage)
{
if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) ||
static_cast<size_t>(yoffset + height) > texture->getHeight(target, level) ||
static_cast<size_t>(zoffset) >= texture->getDepth(target, level))
{
context->validationError(GL_INVALID_VALUE, kOffsetOverflow);
return false;
}
}
else
{
if ((texType == TextureType::CubeMap || texType == TextureType::CubeMapArray) &&
width != height)
{
context->validationError(GL_INVALID_VALUE, kCubemapIncomplete);
return false;
}
if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
int maxLevelDimension = (maxDimension >> level);
if (static_cast<int>(width) > maxLevelDimension ||
static_cast<int>(height) > maxLevelDimension)
{
context->validationError(GL_INVALID_VALUE, kResourceMaxTextureSize);
return false;
}
}
// Do not leak the previous texture format for non-subImage case.
if (textureFormatOut && isSubImage)
{
*textureFormatOut = texture->getFormat(target, level);
}
// Detect texture copying feedback loops for WebGL.
if (context->getExtensions().webglCompatibility)
{
if (readFramebuffer->formsCopyingFeedbackLoopWith(texture->id(), level, zoffset))
{
context->validationError(GL_INVALID_OPERATION, kFeedbackLoop);
return false;
}
}
return true;
}
const char *ValidateProgramPipelineDrawStates(const Context *context,
const Extensions &extensions,
ProgramPipeline *programPipeline)
{
for (const ShaderType shaderType : gl::AllShaderTypes())
{
Program *program = programPipeline->getShaderProgram(shaderType);
if (program)
{
const char *errorMsg = ValidateProgramDrawStates(context, extensions, program);
if (errorMsg)
{
return errorMsg;
}
}
}
return nullptr;
}
const char *ValidateProgramPipelineAttachedPrograms(ProgramPipeline *programPipeline)
{
// An INVALID_OPERATION error is generated by any command that transfers vertices to the
// GL or launches compute work if the current set of active
// program objects cannot be executed, for reasons including:
// - There is no current program object specified by UseProgram, there is a current program
// pipeline object, and that object is empty (no executable code is installed for any stage).
// - A program object is active for at least one, but not all of the shader
// stages that were present when the program was linked.
if (!programPipeline->getExecutable().getLinkedShaderStages().any())
{
return gl::err::kNoExecutableCodeInstalled;
}
for (const ShaderType shaderType : gl::AllShaderTypes())
{
Program *shaderProgram = programPipeline->getShaderProgram(shaderType);
if (shaderProgram)
{
ProgramExecutable &executable = shaderProgram->getExecutable();
for (const ShaderType programShaderType : executable.getLinkedShaderStages())
{
if (shaderProgram != programPipeline->getShaderProgram(programShaderType))
{
return gl::err::kNotAllStagesOfSeparableProgramUsed;
}
}
}
}
// [EXT_geometry_shader] Section 11.1.gs Geometry Shaders
// A non-separable program object or program pipeline object that includes
// a geometry shader must also include a vertex shader.
// An INVALID_OPERATION error is generated by any command that transfers
// vertices to the GL if the current program state has a geometry shader
// but no vertex shader.
if (!programPipeline->getShaderProgram(ShaderType::Vertex) &&
programPipeline->getShaderProgram(ShaderType::Geometry))
{
return gl::err::kNoActiveGraphicsShaderStage;
}
return nullptr;
}
// Note all errors returned from this function are INVALID_OPERATION except for the draw framebuffer
// completeness check.
const char *ValidateDrawStates(const Context *context)
{
const Extensions &extensions = context->getExtensions();
const State &state = context->getState();
// WebGL buffers cannot be mapped/unmapped because the MapBufferRange, FlushMappedBufferRange,
// and UnmapBuffer entry points are removed from the WebGL 2.0 API.
// https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.14
VertexArray *vertexArray = state.getVertexArray();
ASSERT(vertexArray);
if (!extensions.webglCompatibility && vertexArray->hasInvalidMappedArrayBuffer())
{
return kBufferMapped;
}
// Note: these separate values are not supported in WebGL, due to D3D's limitations. See
// Section 6.10 of the WebGL 1.0 spec.
Framebuffer *framebuffer = state.getDrawFramebuffer();
ASSERT(framebuffer);
if (context->getLimitations().noSeparateStencilRefsAndMasks || extensions.webglCompatibility)
{
ASSERT(framebuffer);
const FramebufferAttachment *dsAttachment =
framebuffer->getStencilOrDepthStencilAttachment();
const GLuint stencilBits = dsAttachment ? dsAttachment->getStencilSize() : 0;
ASSERT(stencilBits <= 8);
const DepthStencilState &depthStencilState = state.getDepthStencilState();
if (depthStencilState.stencilTest && stencilBits > 0)
{
GLuint maxStencilValue = (1 << stencilBits) - 1;
bool differentRefs =
clamp(state.getStencilRef(), 0, static_cast<GLint>(maxStencilValue)) !=
clamp(state.getStencilBackRef(), 0, static_cast<GLint>(maxStencilValue));
bool differentWritemasks = (depthStencilState.stencilWritemask & maxStencilValue) !=
(depthStencilState.stencilBackWritemask & maxStencilValue);
bool differentMasks = (depthStencilState.stencilMask & maxStencilValue) !=
(depthStencilState.stencilBackMask & maxStencilValue);
if (differentRefs || differentWritemasks || differentMasks)
{
if (!extensions.webglCompatibility)
{
WARN() << "This ANGLE implementation does not support separate front/back "
"stencil writemasks, reference values, or stencil mask values.";
}
return kStencilReferenceMaskOrMismatch;
}
}
}
if (!extensions.floatBlend)
{
const DrawBufferMask blendEnabledActiveFloat32ColorAttachmentDrawBufferMask =
state.getBlendEnabledDrawBufferMask() &
framebuffer->getActiveFloat32ColorAttachmentDrawBufferMask();
if (blendEnabledActiveFloat32ColorAttachmentDrawBufferMask.any())
{
return kUnsupportedFloatBlending;
}
}
if (context->getLimitations().noSimultaneousConstantColorAndAlphaBlendFunc ||
extensions.webglCompatibility)
{
if (state.hasSimultaneousConstantColorAndAlphaBlendFunc())
{
if (extensions.webglCompatibility)
{
return kInvalidConstantColor;
}
WARN() << kConstantColorAlphaLimitation;
return kConstantColorAlphaLimitation;
}
}
if (!framebuffer->isComplete(context))
{
// Note: this error should be generated as INVALID_FRAMEBUFFER_OPERATION.
return kDrawFramebufferIncomplete;
}
bool framebufferIsYUV = framebuffer->hasYUVAttachment();
if (framebufferIsYUV)
{
const BlendState &blendState = state.getBlendState();
if (!blendState.colorMaskRed || !blendState.colorMaskGreen || !blendState.colorMaskBlue)
{
// When rendering into a YUV framebuffer, the color mask must have r g and b set to
// true.
return kInvalidColorMaskForYUV;
}
if (blendState.blend)
{
// When rendering into a YUV framebuffer, blending must be disabled.
return kInvalidBlendStateForYUV;
}
}
else
{
if (framebuffer->hasExternalTextureAttachment())
{
// It is an error to render into an external texture that is not YUV.
return kExternalTextureAttachmentNotYUV;
}
}
if (context->getStateCache().hasAnyEnabledClientAttrib())
{
if (extensions.webglCompatibility || !state.areClientArraysEnabled())
{
// [WebGL 1.0] Section 6.5 Enabled Vertex Attributes and Range Checking
// If a vertex attribute is enabled as an array via enableVertexAttribArray but no
// buffer is bound to that attribute via bindBuffer and vertexAttribPointer, then calls
// to drawArrays or drawElements will generate an INVALID_OPERATION error.
return kVertexArrayNoBuffer;
}
if (state.getVertexArray()->hasEnabledNullPointerClientArray())
{
// This is an application error that would normally result in a crash, but we catch it
// and return an error
return kVertexArrayNoBufferPointer;
}
}
// If we are running GLES1, there is no current program.
if (context->getClientVersion() >= Version(2, 0))
{
Program *program = state.getLinkedProgram(context);
ProgramPipeline *programPipeline = state.getProgramPipeline();
const ProgramExecutable *executable = state.getProgramExecutable();
bool programIsYUVOutput = false;
if (program)
{
const char *errorMsg = ValidateProgramDrawStates(context, extensions, program);
if (errorMsg)
{
return errorMsg;
}
programIsYUVOutput = program->isYUVOutput();
}
else if (programPipeline)
{
const char *errorMsg = ValidateProgramPipelineAttachedPrograms(programPipeline);
if (errorMsg)
{
return errorMsg;
}
errorMsg = ValidateProgramPipelineDrawStates(context, extensions, programPipeline);
if (errorMsg)
{
return errorMsg;
}
bool goodResult = programPipeline->link(context) == angle::Result::Continue;
ASSERT(executable);
if (!goodResult)
{
return kProgramPipelineLinkFailed;
}
programIsYUVOutput = executable->isYUVOutput();
}
if (executable)
{
if (!executable->validateSamplers(nullptr, context->getCaps()))
{
return kTextureTypeConflict;
}
if (executable->hasLinkedTessellationShader())
{
if (!executable->hasLinkedShaderStage(ShaderType::Vertex))
{
return kTessellationShaderRequiresVertexShader;
}
if (!executable->hasLinkedShaderStage(ShaderType::TessControl) ||
!executable->hasLinkedShaderStage(ShaderType::TessEvaluation))
{
return kTessellationShaderRequiresBothControlAndEvaluation;
}
}
}
if (programIsYUVOutput != framebufferIsYUV)
{
// Both the program and framebuffer must match in YUV output state.
return kYUVOutputMissmatch;
}
if (!state.validateSamplerFormats())
{
return kSamplerFormatMismatch;
}
// Do some additional WebGL-specific validation
if (extensions.webglCompatibility)
{
const TransformFeedback *transformFeedbackObject = state.getCurrentTransformFeedback();
if (state.isTransformFeedbackActive() &&
transformFeedbackObject->buffersBoundForOtherUse())
{
return kTransformFeedbackBufferDoubleBound;
}
// Detect rendering feedback loops for WebGL.
if (framebuffer->formsRenderingFeedbackLoopWith(context))
{
return kFeedbackLoop;
}
// Detect that the vertex shader input types match the attribute types
if (!ValidateVertexShaderAttributeTypeMatch(context))
{
return kVertexShaderTypeMismatch;
}
if (!context->getState().getRasterizerState().rasterizerDiscard &&
!context->getState().allActiveDrawBufferChannelsMasked())
{
// Detect that if there's active color buffer without fragment shader output
if (!ValidateFragmentShaderColorBufferMaskMatch(context))
{
return kDrawBufferMaskMismatch;
}
// Detect that the color buffer types match the fragment shader output types
if (!ValidateFragmentShaderColorBufferTypeMatch(context))
{
return kDrawBufferTypeMismatch;
}
}
const VertexArray *vao = context->getState().getVertexArray();
if (vao->hasTransformFeedbackBindingConflict(context))
{
return kVertexBufferBoundForTransformFeedback;
}
// Validate that we are rendering with a linked program.
if (!program->isLinked())
{
return kProgramNotLinked;
}
}
}
return nullptr;
}
void RecordDrawModeError(const Context *context, PrimitiveMode mode)
{
const State &state = context->getState();
TransformFeedback *curTransformFeedback = state.getCurrentTransformFeedback();
if (state.isTransformFeedbackActiveUnpaused())
{
if (!ValidateTransformFeedbackPrimitiveMode(context,
curTransformFeedback->getPrimitiveMode(), mode))
{
context->validationError(GL_INVALID_OPERATION, kInvalidDrawModeTransformFeedback);
return;
}
}
const Extensions &extensions = context->getExtensions();
switch (mode)
{
case PrimitiveMode::Points:
case PrimitiveMode::Lines:
case PrimitiveMode::LineLoop:
case PrimitiveMode::LineStrip:
case PrimitiveMode::Triangles:
case PrimitiveMode::TriangleStrip:
case PrimitiveMode::TriangleFan:
break;
case PrimitiveMode::LinesAdjacency:
case PrimitiveMode::LineStripAdjacency:
case PrimitiveMode::TrianglesAdjacency:
case PrimitiveMode::TriangleStripAdjacency:
if (!extensions.geometryShaderAny() && context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
return;
}
break;
case PrimitiveMode::Patches:
if (!extensions.tessellationShaderEXT && context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kTessellationShaderExtensionNotEnabled);
return;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidDrawMode);
return;
}
// If we are running GLES1, there is no current program.
if (context->getClientVersion() >= Version(2, 0))
{
const ProgramExecutable *executable = state.getProgramExecutable();
ASSERT(executable);
// Do geometry shader specific validations
if (executable->hasLinkedShaderStage(ShaderType::Geometry))
{
if (!IsCompatibleDrawModeWithGeometryShader(
mode, executable->getGeometryShaderInputPrimitiveType()))
{
context->validationError(GL_INVALID_OPERATION,
kIncompatibleDrawModeAgainstGeometryShader);
return;
}
}
if (executable->hasLinkedTessellationShader() && mode != PrimitiveMode::Patches)
{
context->validationError(GL_INVALID_OPERATION,
kIncompatibleDrawModeWithTessellationShader);
return;
}
if (!executable->hasLinkedTessellationShader() && mode == PrimitiveMode::Patches)
{
context->validationError(GL_INVALID_OPERATION,
kIncompatibleDrawModeWithoutTessellationShader);
return;
}
}
// An error should be recorded.
UNREACHABLE();
}
bool ValidateDrawArraysInstancedANGLE(const Context *context,
PrimitiveMode mode,
GLint first,
GLsizei count,
GLsizei primcount)
{
if (!context->getExtensions().instancedArraysANGLE)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateDrawArraysInstancedBase(context, mode, first, count, primcount))
{
return false;
}
return ValidateDrawInstancedANGLE(context);
}
bool ValidateDrawArraysInstancedEXT(const Context *context,
PrimitiveMode mode,
GLint first,
GLsizei count,
GLsizei primcount)
{
if (!context->getExtensions().instancedArraysEXT)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateDrawArraysInstancedBase(context, mode, first, count, primcount))
{
return false;
}
return true;
}
const char *ValidateDrawElementsStates(const Context *context)
{
const State &state = context->getState();
if (context->getStateCache().isTransformFeedbackActiveUnpaused())
{
// EXT_geometry_shader allows transform feedback to work with all draw commands.
// [EXT_geometry_shader] Section 12.1, "Transform Feedback"
if (!context->getExtensions().geometryShaderAny() && context->getClientVersion() < ES_3_2)
{
// It is an invalid operation to call DrawElements, DrawRangeElements or
// DrawElementsInstanced while transform feedback is active, (3.0.2, section 2.14, pg
// 86)
return kUnsupportedDrawModeForTransformFeedback;
}
}
const VertexArray *vao = state.getVertexArray();
Buffer *elementArrayBuffer = vao->getElementArrayBuffer();
if (elementArrayBuffer)
{
if (context->getExtensions().webglCompatibility)
{
if (elementArrayBuffer->isBoundForTransformFeedbackAndOtherUse())
{
return kElementArrayBufferBoundForTransformFeedback;
}
}
else if (elementArrayBuffer->isMapped())
{
// WebGL buffers cannot be mapped/unmapped because the MapBufferRange,
// FlushMappedBufferRange, and UnmapBuffer entry points are removed from the
// WebGL 2.0 API. https://www.khronos.org/registry/webgl/specs/latest/2.0/#5.14
return kBufferMapped;
}
}
else
{
// [WebGL 1.0] Section 6.2 No Client Side Arrays
// If an indexed draw command (drawElements) is called and no WebGLBuffer is bound to
// the ELEMENT_ARRAY_BUFFER binding point, an INVALID_OPERATION error is generated.
if (!context->getState().areClientArraysEnabled() ||
context->getExtensions().webglCompatibility)
{
return kMustHaveElementArrayBinding;
}
}
return nullptr;
}
bool ValidateDrawElementsInstancedANGLE(const Context *context,
PrimitiveMode mode,
GLsizei count,
DrawElementsType type,
const void *indices,
GLsizei primcount)
{
if (!context->getExtensions().instancedArraysANGLE)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateDrawElementsInstancedBase(context, mode, count, type, indices, primcount))
{
return false;
}
return ValidateDrawInstancedANGLE(context);
}
bool ValidateDrawElementsInstancedEXT(const Context *context,
PrimitiveMode mode,
GLsizei count,
DrawElementsType type,
const void *indices,
GLsizei primcount)
{
if (!context->getExtensions().instancedArraysEXT)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidateDrawElementsInstancedBase(context, mode, count, type, indices, primcount))
{
return false;
}
return true;
}
bool ValidateGetUniformBase(const Context *context,
ShaderProgramID program,
UniformLocation location)
{
if (program.value == 0)
{
context->validationError(GL_INVALID_VALUE, kProgramDoesNotExist);
return false;
}
Program *programObject = GetValidProgram(context, program);
if (!programObject)
{
return false;
}
if (!programObject || !programObject->isLinked())
{
context->validationError(GL_INVALID_OPERATION, kProgramNotLinked);
return false;
}
if (!programObject->isValidUniformLocation(location))
{
context->validationError(GL_INVALID_OPERATION, kInvalidUniformLocation);
return false;
}
return true;
}
static bool ValidateSizedGetUniform(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
GLsizei *length)
{
if (length)
{
*length = 0;
}
if (!ValidateGetUniformBase(context, program, location))
{
return false;
}
if (bufSize < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeBufferSize);
return false;
}
Program *programObject = context->getProgramResolveLink(program);
ASSERT(programObject);
// sized queries -- ensure the provided buffer is large enough
const LinkedUniform &uniform = programObject->getUniformByLocation(location);
size_t requiredBytes = VariableExternalSize(uniform.type);
if (static_cast<size_t>(bufSize) < requiredBytes)
{
context->validationError(GL_INVALID_OPERATION, kInsufficientBufferSize);
return false;
}
if (length)
{
*length = VariableComponentCount(uniform.type);
}
return true;
}
bool ValidateGetnUniformfvEXT(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLfloat *params)
{
return ValidateSizedGetUniform(context, program, location, bufSize, nullptr);
}
bool ValidateGetnUniformfvRobustANGLE(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLsizei *length,
const GLfloat *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateGetnUniformivEXT(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLint *params)
{
return ValidateSizedGetUniform(context, program, location, bufSize, nullptr);
}
bool ValidateGetnUniformivRobustANGLE(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateGetnUniformuivRobustANGLE(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLsizei *length,
const GLuint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateGetUniformfvRobustANGLE(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLsizei *length,
const GLfloat *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
// bufSize is validated in ValidateSizedGetUniform
if (!ValidateSizedGetUniform(context, program, location, bufSize, &writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetUniformivRobustANGLE(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
// bufSize is validated in ValidateSizedGetUniform
if (!ValidateSizedGetUniform(context, program, location, bufSize, &writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetUniformuivRobustANGLE(const Context *context,
ShaderProgramID program,
UniformLocation location,
GLsizei bufSize,
const GLsizei *length,
const GLuint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_OPERATION, kES3Required);
return false;
}
GLsizei writeLength = 0;
// bufSize is validated in ValidateSizedGetUniform
if (!ValidateSizedGetUniform(context, program, location, bufSize, &writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateDiscardFramebufferBase(const Context *context,
GLenum target,
GLsizei numAttachments,
const GLenum *attachments,
bool defaultFramebuffer)
{
if (numAttachments < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeAttachments);
return false;
}
for (GLsizei i = 0; i < numAttachments; ++i)
{
if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[i] <= GL_COLOR_ATTACHMENT31)
{
if (defaultFramebuffer)
{
context->validationError(GL_INVALID_ENUM, kDefaultFramebufferInvalidAttachment);
return false;
}
if (attachments[i] >=
GL_COLOR_ATTACHMENT0 + static_cast<GLuint>(context->getCaps().maxColorAttachments))
{
context->validationError(GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
return false;
}
}
else
{
switch (attachments[i])
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
case GL_DEPTH_STENCIL_ATTACHMENT:
if (defaultFramebuffer)
{
context->validationError(GL_INVALID_ENUM,
kDefaultFramebufferInvalidAttachment);
return false;
}
break;
case GL_COLOR:
case GL_DEPTH:
case GL_STENCIL:
if (!defaultFramebuffer)
{
context->validationError(GL_INVALID_ENUM,
kDefaultFramebufferAttachmentOnUserFBO);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidAttachment);
return false;
}
}
}
return true;
}
bool ValidateInsertEventMarkerEXT(const Context *context, GLsizei length, const char *marker)
{
if (!context->getExtensions().debugMarker)
{
// The debug marker calls should not set error state
// However, it seems reasonable to set an error state if the extension is not enabled
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
// Note that debug marker calls must not set error state
if (length < 0)
{
return false;
}
if (marker == nullptr)
{
return false;
}
return true;
}
bool ValidatePushGroupMarkerEXT(const Context *context, GLsizei length, const char *marker)
{
if (!context->getExtensions().debugMarker)
{
// The debug marker calls should not set error state
// However, it seems reasonable to set an error state if the extension is not enabled
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
// Note that debug marker calls must not set error state
if (length < 0)
{
return false;
}
if (length > 0 && marker == nullptr)
{
return false;
}
return true;
}
bool ValidateEGLImageTargetTexture2DOES(const Context *context,
TextureType type,
GLeglImageOES image)
{
if (!context->getExtensions().eglImageOES && !context->getExtensions().eglImageExternalOES)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
switch (type)
{
case TextureType::_2D:
if (!context->getExtensions().eglImageOES)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
}
break;
case TextureType::_2DArray:
if (!context->getExtensions().eglImageArray)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
}
break;
case TextureType::External:
if (!context->getExtensions().eglImageExternalOES)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
egl::Image *imageObject = static_cast<egl::Image *>(image);
ASSERT(context->getDisplay());
if (!context->getDisplay()->isValidImage(imageObject))
{
context->validationError(GL_INVALID_VALUE, kInvalidEGLImage);
return false;
}
if (imageObject->getSamples() > 0)
{
context->validationError(GL_INVALID_OPERATION, kEGLImageCannotCreate2DMultisampled);
return false;
}
if (!imageObject->isTexturable(context))
{
context->validationError(GL_INVALID_OPERATION, kEGLImageTextureFormatNotSupported);
return false;
}
if (imageObject->isLayered() && type != TextureType::_2DArray)
{
context->validationError(GL_INVALID_OPERATION,
"Image has more than 1 layer, target must be TEXTURE_2D_ARRAY");
return false;
}
if (imageObject->isYUV() && type != TextureType::External)
{
context->validationError(GL_INVALID_OPERATION,
"Image is YUV, target must be TEXTURE_EXTERNAL_OES");
return false;
}
if (imageObject->hasProtectedContent() != context->getState().hasProtectedContent())
{
context->validationError(GL_INVALID_OPERATION,
"Mismatch between Image and Context Protected Content state");
return false;
}
return true;
}
bool ValidateEGLImageTargetRenderbufferStorageOES(const Context *context,
GLenum target,
GLeglImageOES image)
{
if (!context->getExtensions().eglImageOES)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
switch (target)
{
case GL_RENDERBUFFER:
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
return false;
}
egl::Image *imageObject = static_cast<egl::Image *>(image);
ASSERT(context->getDisplay());
if (!context->getDisplay()->isValidImage(imageObject))
{
context->validationError(GL_INVALID_VALUE, kInvalidEGLImage);
return false;
}
if (!imageObject->isRenderable(context))
{
context->validationError(GL_INVALID_OPERATION, kEGLImageRenderbufferFormatNotSupported);
return false;
}
if (imageObject->hasProtectedContent() != context->getState().hasProtectedContent())
{
context->validationError(GL_INVALID_OPERATION,
"Mismatch between Image and Context Protected Content state");
return false;
}
return true;
}
bool ValidateBindVertexArrayBase(const Context *context, VertexArrayID array)
{
if (!context->isVertexArrayGenerated(array))
{
// The default VAO should always exist
ASSERT(array.value != 0);
context->validationError(GL_INVALID_OPERATION, kInvalidVertexArray);
return false;
}
return true;
}
bool ValidateProgramBinaryBase(const Context *context,
ShaderProgramID program,
GLenum binaryFormat,
const void *binary,
GLint length)
{
Program *programObject = GetValidProgram(context, program);
if (programObject == nullptr)
{
return false;
}
const std::vector<GLenum> &programBinaryFormats = context->getCaps().programBinaryFormats;
if (std::find(programBinaryFormats.begin(), programBinaryFormats.end(), binaryFormat) ==
programBinaryFormats.end())
{
context->validationError(GL_INVALID_ENUM, kInvalidProgramBinaryFormat);
return false;
}
if (context->hasActiveTransformFeedback(program))
{
// ES 3.0.4 section 2.15 page 91
context->validationError(GL_INVALID_OPERATION, kTransformFeedbackProgramBinary);
return false;
}
return true;
}
bool ValidateGetProgramBinaryBase(const Context *context,
ShaderProgramID program,
GLsizei bufSize,
const GLsizei *length,
const GLenum *binaryFormat,
const void *binary)
{
Program *programObject = GetValidProgram(context, program);
if (programObject == nullptr)
{
return false;
}
if (!programObject->isLinked())
{
context->validationError(GL_INVALID_OPERATION, kProgramNotLinked);
return false;
}
if (context->getCaps().programBinaryFormats.empty())
{
context->validationError(GL_INVALID_OPERATION, kNoProgramBinaryFormats);
return false;
}
return true;
}
bool ValidateDrawBuffersBase(const Context *context, GLsizei n, const GLenum *bufs)
{
// INVALID_VALUE is generated if n is negative or greater than value of MAX_DRAW_BUFFERS
if (n < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeCount);
return false;
}
if (n > context->getCaps().maxDrawBuffers)
{
context->validationError(GL_INVALID_VALUE, kIndexExceedsMaxDrawBuffer);
return false;
}
ASSERT(context->getState().getDrawFramebuffer());
FramebufferID frameBufferId = context->getState().getDrawFramebuffer()->id();
GLuint maxColorAttachment = GL_COLOR_ATTACHMENT0_EXT + context->getCaps().maxColorAttachments;
// This should come first before the check for the default frame buffer
// because when we switch to ES3.1+, invalid enums will return INVALID_ENUM
// rather than INVALID_OPERATION
for (int colorAttachment = 0; colorAttachment < n; colorAttachment++)
{
const GLenum attachment = GL_COLOR_ATTACHMENT0_EXT + colorAttachment;
if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] != GL_BACK &&
(bufs[colorAttachment] < GL_COLOR_ATTACHMENT0 ||
bufs[colorAttachment] > GL_COLOR_ATTACHMENT31))
{
// Value in bufs is not NONE, BACK, or GL_COLOR_ATTACHMENTi
// The 3.0.4 spec says to generate GL_INVALID_OPERATION here, but this
// was changed to GL_INVALID_ENUM in 3.1, which dEQP also expects.
// 3.1 is still a bit ambiguous about the error, but future specs are
// expected to clarify that GL_INVALID_ENUM is the correct error.
context->validationError(GL_INVALID_ENUM, kInvalidDrawBuffer);
return false;
}
else if (bufs[colorAttachment] >= maxColorAttachment)
{
context->validationError(GL_INVALID_OPERATION, kExceedsMaxColorAttachments);
return false;
}
else if (bufs[colorAttachment] != GL_NONE && bufs[colorAttachment] != attachment &&
frameBufferId.value != 0)
{
// INVALID_OPERATION-GL is bound to buffer and ith argument
// is not COLOR_ATTACHMENTi or NONE
context->validationError(GL_INVALID_OPERATION, kInvalidDrawBufferValue);
return false;
}
}
// INVALID_OPERATION is generated if GL is bound to the default framebuffer
// and n is not 1 or bufs is bound to value other than BACK and NONE
if (frameBufferId.value == 0)
{
if (n != 1)
{
context->validationError(GL_INVALID_OPERATION, kInvalidDrawBufferCountForDefault);
return false;
}
if (bufs[0] != GL_NONE && bufs[0] != GL_BACK)
{
context->validationError(GL_INVALID_OPERATION, kDefaultFramebufferInvalidDrawBuffer);
return false;
}
}
return true;
}
bool ValidateGetBufferPointervBase(const Context *context,
BufferBinding target,
GLenum pname,
GLsizei *length,
void *const *params)
{
if (length)
{
*length = 0;
}
if (!context->isValidBufferBinding(target))
{
context->validationError(GL_INVALID_ENUM, kInvalidBufferTypes);
return false;
}
switch (pname)
{
case GL_BUFFER_MAP_POINTER:
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
// GLES 3.0 section 2.10.1: "Attempts to attempts to modify or query buffer object state for a
// target bound to zero generate an INVALID_OPERATION error."
// GLES 3.1 section 6.6 explicitly specifies this error.
if (context->getState().getTargetBuffer(target) == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kBufferPointerNotAvailable);
return false;
}
if (length)
{
*length = 1;
}
return true;
}
bool ValidateUnmapBufferBase(const Context *context, BufferBinding target)
{
if (!context->isValidBufferBinding(target))
{
context->validationError(GL_INVALID_ENUM, kInvalidBufferTypes);
return false;
}
Buffer *buffer = context->getState().getTargetBuffer(target);
if (buffer == nullptr || !buffer->isMapped())
{
context->validationError(GL_INVALID_OPERATION, kBufferNotMapped);
return false;
}
return true;
}
bool ValidateMapBufferRangeBase(const Context *context,
BufferBinding target,
GLintptr offset,
GLsizeiptr length,
GLbitfield access)
{
if (!context->isValidBufferBinding(target))
{
context->validationError(GL_INVALID_ENUM, kInvalidBufferTypes);
return false;
}
if (offset < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeOffset);
return false;
}
if (length < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeLength);
return false;
}
Buffer *buffer = context->getState().getTargetBuffer(target);
if (!buffer)
{
context->validationError(GL_INVALID_OPERATION, kBufferNotMappable);
return false;
}
// Check for buffer overflow
CheckedNumeric<size_t> checkedOffset(offset);
auto checkedSize = checkedOffset + length;
if (!checkedSize.IsValid() || checkedSize.ValueOrDie() > static_cast<size_t>(buffer->getSize()))
{
context->validationError(GL_INVALID_VALUE, kMapOutOfRange);
return false;
}
// Check for invalid bits in the mask
constexpr GLbitfield kAllAccessBits =
GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT |
GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
if (buffer->isImmutable())
{
// GL_EXT_buffer_storage's additions to glMapBufferRange
constexpr GLbitfield kBufferStorageAccessBits =
kAllAccessBits | GL_MAP_PERSISTENT_BIT_EXT | GL_MAP_COHERENT_BIT_EXT;
if ((access & ~kBufferStorageAccessBits) != 0)
{
context->validationError(GL_INVALID_VALUE, kInvalidAccessBits);
return false;
}
// It is invalid if any of bufferStorageMatchedAccessBits bits are included in access,
// but the same bits are not included in the buffer's storage flags
constexpr GLbitfield kBufferStorageMatchedAccessBits = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT |
GL_MAP_PERSISTENT_BIT_EXT |
GL_MAP_COHERENT_BIT_EXT;
GLbitfield accessFlags = access & kBufferStorageMatchedAccessBits;
if ((accessFlags & buffer->getStorageExtUsageFlags()) != accessFlags)
{
context->validationError(GL_INVALID_OPERATION, kInvalidAccessBits);
return false;
}
}
else if ((access & ~kAllAccessBits) != 0)
{
context->validationError(GL_INVALID_VALUE, kInvalidAccessBits);
return false;
}
if (length == 0)
{
context->validationError(GL_INVALID_OPERATION, kLengthZero);
return false;
}
if (buffer->isMapped())
{
context->validationError(GL_INVALID_OPERATION, kBufferAlreadyMapped);
return false;
}
// Check for invalid bit combinations
if ((access & (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)) == 0)
{
context->validationError(GL_INVALID_OPERATION, kInvalidAccessBitsReadWrite);
return false;
}
GLbitfield writeOnlyBits =
GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
if ((access & GL_MAP_READ_BIT) != 0 && (access & writeOnlyBits) != 0)
{
context->validationError(GL_INVALID_OPERATION, kInvalidAccessBitsRead);
return false;
}
if ((access & GL_MAP_WRITE_BIT) == 0 && (access & GL_MAP_FLUSH_EXPLICIT_BIT) != 0)
{
context->validationError(GL_INVALID_OPERATION, kInvalidAccessBitsFlush);
return false;
}
return ValidateMapBufferBase(context, target);
}
bool ValidateFlushMappedBufferRangeBase(const Context *context,
BufferBinding target,
GLintptr offset,
GLsizeiptr length)
{
if (offset < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeOffset);
return false;
}
if (length < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeLength);
return false;
}
if (!context->isValidBufferBinding(target))
{
context->validationError(GL_INVALID_ENUM, kInvalidBufferTypes);
return false;
}
Buffer *buffer = context->getState().getTargetBuffer(target);
if (buffer == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kInvalidFlushZero);
return false;
}
if (!buffer->isMapped() || (buffer->getAccessFlags() & GL_MAP_FLUSH_EXPLICIT_BIT) == 0)
{
context->validationError(GL_INVALID_OPERATION, kInvalidFlushTarget);
return false;
}
// Check for buffer overflow
CheckedNumeric<size_t> checkedOffset(offset);
auto checkedSize = checkedOffset + length;
if (!checkedSize.IsValid() ||
checkedSize.ValueOrDie() > static_cast<size_t>(buffer->getMapLength()))
{
context->validationError(GL_INVALID_VALUE, kInvalidFlushOutOfRange);
return false;
}
return true;
}
bool ValidateGenOrDelete(const Context *context, GLint n)
{
if (n < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeCount);
return false;
}
return true;
}
bool ValidateRobustEntryPoint(const Context *context, GLsizei bufSize)
{
if (!context->getExtensions().robustClientMemory)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (bufSize < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeBufferSize);
return false;
}
return true;
}
bool ValidateRobustBufferSize(const Context *context, GLsizei bufSize, GLsizei numParams)
{
if (bufSize < numParams)
{
context->validationError(GL_INVALID_OPERATION, kInsufficientParams);
return false;
}
return true;
}
bool ValidateGetFramebufferAttachmentParameterivBase(const Context *context,
GLenum target,
GLenum attachment,
GLenum pname,
GLsizei *numParams)
{
if (!ValidFramebufferTarget(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidFramebufferTarget);
return false;
}
int clientVersion = context->getClientMajorVersion();
switch (pname)
{
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
break;
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR:
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR:
if (clientVersion < 3 ||
!(context->getExtensions().multiview || context->getExtensions().multiview2))
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT:
if (!context->getExtensions().multisampledRenderToTexture)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
if (clientVersion < 3 && !context->getExtensions().sRGB)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
if (clientVersion < 3)
{
context->validationError(GL_INVALID_ENUM, kES3Required);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT:
if (!context->getExtensions().geometryShaderAny() &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidPname);
return false;
}
// Determine if the attachment is a valid enum
switch (attachment)
{
case GL_BACK:
case GL_DEPTH:
case GL_STENCIL:
if (clientVersion < 3)
{
context->validationError(GL_INVALID_ENUM, kInvalidAttachment);
return false;
}
break;
case GL_DEPTH_STENCIL_ATTACHMENT:
if (clientVersion < 3 && !context->isWebGL1())
{
context->validationError(GL_INVALID_ENUM, kInvalidAttachment);
return false;
}
break;
case GL_COLOR_ATTACHMENT0:
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
break;
default:
if ((clientVersion < 3 && !context->getExtensions().drawBuffers) ||
attachment < GL_COLOR_ATTACHMENT0_EXT ||
(attachment - GL_COLOR_ATTACHMENT0_EXT) >=
static_cast<GLuint>(context->getCaps().maxColorAttachments))
{
context->validationError(GL_INVALID_ENUM, kInvalidAttachment);
return false;
}
break;
}
const Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target);
ASSERT(framebuffer);
if (framebuffer->isDefault())
{
if (clientVersion < 3)
{
context->validationError(GL_INVALID_OPERATION, kDefaultFramebufferTarget);
return false;
}
switch (attachment)
{
case GL_BACK:
case GL_DEPTH:
case GL_STENCIL:
break;
default:
context->validationError(GL_INVALID_OPERATION, kInvalidAttachment);
return false;
}
}
else
{
if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
{
// Valid attachment query
}
else
{
switch (attachment)
{
case GL_DEPTH_ATTACHMENT:
case GL_STENCIL_ATTACHMENT:
break;
case GL_DEPTH_STENCIL_ATTACHMENT:
if (!framebuffer->hasValidDepthStencil() && !context->isWebGL1())
{
context->validationError(GL_INVALID_OPERATION, kInvalidAttachment);
return false;
}
break;
default:
context->validationError(GL_INVALID_OPERATION, kInvalidAttachment);
return false;
}
}
}
const FramebufferAttachment *attachmentObject = framebuffer->getAttachment(context, attachment);
if (attachmentObject)
{
ASSERT(attachmentObject->type() == GL_RENDERBUFFER ||
attachmentObject->type() == GL_TEXTURE ||
attachmentObject->type() == GL_FRAMEBUFFER_DEFAULT);
switch (pname)
{
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
if (attachmentObject->type() != GL_RENDERBUFFER &&
attachmentObject->type() != GL_TEXTURE)
{
context->validationError(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
if (attachmentObject->type() != GL_TEXTURE)
{
context->validationError(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
if (attachmentObject->type() != GL_TEXTURE)
{
context->validationError(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
{
context->validationError(GL_INVALID_OPERATION, kInvalidAttachment);
return false;
}
break;
case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
if (attachmentObject->type() != GL_TEXTURE)
{
context->validationError(GL_INVALID_ENUM, kFramebufferIncompleteAttachment);
return false;
}
break;
default:
break;
}
}
else
{
// ES 2.0.25 spec pg 127 states that if the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE
// is NONE, then querying any other pname will generate INVALID_ENUM.
// ES 3.0.2 spec pg 235 states that if the attachment type is none,
// GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME will return zero and be an
// INVALID_OPERATION for all other pnames
switch (pname)
{
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
break;
case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
if (clientVersion < 3)
{
context->validationError(GL_INVALID_ENUM,
kInvalidFramebufferAttachmentParameter);
return false;
}
break;
default:
if (clientVersion < 3)
{
context->validationError(GL_INVALID_ENUM,
kInvalidFramebufferAttachmentParameter);
return false;
}
else
{
context->validationError(GL_INVALID_OPERATION,
kInvalidFramebufferAttachmentParameter);
return false;
}
}
}
if (numParams)
{
*numParams = 1;
}
return true;
}
bool ValidateGetFramebufferAttachmentParameterivRobustANGLE(const Context *context,
GLenum target,
GLenum attachment,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetFramebufferAttachmentParameterivBase(context, target, attachment, pname,
&numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetBufferParameterivRobustANGLE(const Context *context,
BufferBinding target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetBufferParameterBase(context, target, pname, false, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetBufferParameteri64vRobustANGLE(const Context *context,
BufferBinding target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint64 *params)
{
GLsizei numParams = 0;
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
if (!ValidateGetBufferParameterBase(context, target, pname, false, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetProgramivBase(const Context *context,
ShaderProgramID program,
GLenum pname,
GLsizei *numParams)
{
// Currently, all GetProgramiv queries return 1 parameter
if (numParams)
{
*numParams = 1;
}
if (context->isContextLost())
{
context->validationError(GL_CONTEXT_LOST, kContextLost);
if (context->getExtensions().parallelShaderCompile && pname == GL_COMPLETION_STATUS_KHR)
{
// Generate an error but still return true, the context still needs to return a
// value in this case.
return true;
}
else
{
return false;
}
}
// Special case for GL_COMPLETION_STATUS_KHR: don't resolve the link. Otherwise resolve it now.
Program *programObject = (pname == GL_COMPLETION_STATUS_KHR)
? GetValidProgramNoResolve(context, program)
: GetValidProgram(context, program);
if (!programObject)
{
return false;
}
switch (pname)
{
case GL_DELETE_STATUS:
case GL_LINK_STATUS:
case GL_VALIDATE_STATUS:
case GL_INFO_LOG_LENGTH:
case GL_ATTACHED_SHADERS:
case GL_ACTIVE_ATTRIBUTES:
case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
case GL_ACTIVE_UNIFORMS:
case GL_ACTIVE_UNIFORM_MAX_LENGTH:
break;
case GL_PROGRAM_BINARY_LENGTH:
if (context->getClientMajorVersion() < 3 &&
!context->getExtensions().getProgramBinaryOES)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_ACTIVE_UNIFORM_BLOCKS:
case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH:
case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
case GL_TRANSFORM_FEEDBACK_VARYINGS:
case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
case GL_PROGRAM_BINARY_RETRIEVABLE_HINT:
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_ENUM, kEnumRequiresGLES30);
return false;
}
break;
case GL_PROGRAM_SEPARABLE:
case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
if (context->getClientVersion() < Version(3, 1))
{
context->validationError(GL_INVALID_ENUM, kEnumRequiresGLES31);
return false;
}
break;
case GL_COMPUTE_WORK_GROUP_SIZE:
if (context->getClientVersion() < Version(3, 1))
{
context->validationError(GL_INVALID_ENUM, kEnumRequiresGLES31);
return false;
}
// [OpenGL ES 3.1] Chapter 7.12 Page 122
// An INVALID_OPERATION error is generated if COMPUTE_WORK_GROUP_SIZE is queried for a
// program which has not been linked successfully, or which does not contain objects to
// form a compute shader.
if (!programObject->isLinked())
{
context->validationError(GL_INVALID_OPERATION, kProgramNotLinked);
return false;
}
if (!programObject->getExecutable().hasLinkedShaderStage(ShaderType::Compute))
{
context->validationError(GL_INVALID_OPERATION, kNoActiveComputeShaderStage);
return false;
}
break;
case GL_GEOMETRY_LINKED_INPUT_TYPE_EXT:
case GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT:
case GL_GEOMETRY_LINKED_VERTICES_OUT_EXT:
case GL_GEOMETRY_SHADER_INVOCATIONS_EXT:
if (!context->getExtensions().geometryShaderAny() &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kGeometryShaderExtensionNotEnabled);
return false;
}
// [EXT_geometry_shader] Chapter 7.12
// An INVALID_OPERATION error is generated if GEOMETRY_LINKED_VERTICES_OUT_EXT,
// GEOMETRY_LINKED_INPUT_TYPE_EXT, GEOMETRY_LINKED_OUTPUT_TYPE_EXT, or
// GEOMETRY_SHADER_INVOCATIONS_EXT are queried for a program which has not been linked
// successfully, or which does not contain objects to form a geometry shader.
if (!programObject->isLinked())
{
context->validationError(GL_INVALID_OPERATION, kProgramNotLinked);
return false;
}
if (!programObject->getExecutable().hasLinkedShaderStage(ShaderType::Geometry))
{
context->validationError(GL_INVALID_OPERATION, kNoActiveGeometryShaderStage);
return false;
}
break;
case GL_COMPLETION_STATUS_KHR:
if (!context->getExtensions().parallelShaderCompile)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
break;
case GL_TESS_CONTROL_OUTPUT_VERTICES_EXT:
case GL_TESS_GEN_MODE_EXT:
case GL_TESS_GEN_SPACING_EXT:
case GL_TESS_GEN_VERTEX_ORDER_EXT:
case GL_TESS_GEN_POINT_MODE_EXT:
if (!context->getExtensions().tessellationShaderEXT &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kTessellationShaderExtensionNotEnabled);
return false;
}
if (!programObject->isLinked())
{
context->validationError(GL_INVALID_OPERATION, kProgramNotLinked);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
return true;
}
bool ValidateGetProgramivRobustANGLE(const Context *context,
ShaderProgramID program,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetProgramivBase(context, program, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetRenderbufferParameterivRobustANGLE(const Context *context,
GLenum target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetRenderbufferParameterivBase(context, target, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetShaderivRobustANGLE(const Context *context,
ShaderProgramID shader,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetShaderivBase(context, shader, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetTexParameterfvRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLfloat *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetTexParameterBase(context, target, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetTexParameterivRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetTexParameterBase(context, target, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetTexParameterIivRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateGetTexParameterIuivRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLuint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateTexParameterfvRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLfloat *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
return ValidateTexParameterBase(context, target, pname, bufSize, true, params);
}
bool ValidateTexParameterivRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
return ValidateTexParameterBase(context, target, pname, bufSize, true, params);
}
bool ValidateTexParameterIivRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateTexParameterIuivRobustANGLE(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
const GLuint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateGetSamplerParameterfvRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLfloat *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetSamplerParameterBase(context, sampler, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetSamplerParameterivRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetSamplerParameterBase(context, sampler, pname, &numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
bool ValidateGetSamplerParameterIivRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateGetSamplerParameterIuivRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLuint *params)
{
UNIMPLEMENTED();
return false;
}
bool ValidateSamplerParameterfvRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLfloat *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
return ValidateSamplerParameterBase(context, sampler, pname, bufSize, true, params);
}
bool ValidateSamplerParameterivRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
return ValidateSamplerParameterBase(context, sampler, pname, bufSize, true, params);
}
bool ValidateSamplerParameterIivRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLint *param)
{
UNIMPLEMENTED();
return false;
}
bool ValidateSamplerParameterIuivRobustANGLE(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
const GLuint *param)
{
UNIMPLEMENTED();
return false;
}
bool ValidateGetVertexAttribfvRobustANGLE(const Context *context,
GLuint index,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLfloat *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
if (!ValidateGetVertexAttribBase(context, index, pname, &writeLength, false, false))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetVertexAttribivRobustANGLE(const Context *context,
GLuint index,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
if (!ValidateGetVertexAttribBase(context, index, pname, &writeLength, false, false))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetVertexAttribPointervRobustANGLE(const Context *context,
GLuint index,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
void *const *pointer)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
if (!ValidateGetVertexAttribBase(context, index, pname, &writeLength, true, false))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetVertexAttribIivRobustANGLE(const Context *context,
GLuint index,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
if (!ValidateGetVertexAttribBase(context, index, pname, &writeLength, false, true))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetVertexAttribIuivRobustANGLE(const Context *context,
GLuint index,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLuint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
if (!ValidateGetVertexAttribBase(context, index, pname, &writeLength, false, true))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetActiveUniformBlockivRobustANGLE(const Context *context,
ShaderProgramID program,
UniformBlockIndex uniformBlockIndex,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei writeLength = 0;
if (!ValidateGetActiveUniformBlockivBase(context, program, uniformBlockIndex, pname,
&writeLength))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, writeLength))
{
return false;
}
SetRobustLengthParam(length, writeLength);
return true;
}
bool ValidateGetInternalformativRobustANGLE(const Context *context,
GLenum target,
GLenum internalformat,
GLenum pname,
GLsizei bufSize,
const GLsizei *length,
const GLint *params)
{
if (!ValidateRobustEntryPoint(context, bufSize))
{
return false;
}
GLsizei numParams = 0;
if (!ValidateGetInternalFormativBase(context, target, internalformat, pname, bufSize,
&numParams))
{
return false;
}
if (!ValidateRobustBufferSize(context, bufSize, numParams))
{
return false;
}
SetRobustLengthParam(length, numParams);
return true;
}
// Perform validation from WebGL 2 section 5.10 "Invalid Clears":
// In the WebGL 2 API, trying to perform a clear when there is a mismatch between the type of the
// specified clear value and the type of a buffer that is being cleared generates an
// INVALID_OPERATION error instead of producing undefined results
bool ValidateWebGLFramebufferAttachmentClearType(const Context *context,
GLint drawbuffer,
const GLenum *validComponentTypes,
size_t validComponentTypeCount)
{
const FramebufferAttachment *attachment =
context->getState().getDrawFramebuffer()->getDrawBuffer(drawbuffer);
if (attachment)
{
GLenum componentType = attachment->getFormat().info->componentType;
const GLenum *end = validComponentTypes + validComponentTypeCount;
if (std::find(validComponentTypes, end, componentType) == end)
{
context->validationError(GL_INVALID_OPERATION, kNoDefinedClearConversion);
return false;
}
}
return true;
}
bool ValidateRobustCompressedTexImageBase(const Context *context,
GLsizei imageSize,
GLsizei dataSize)
{
if (!ValidateRobustEntryPoint(context, dataSize))
{
return false;
}
Buffer *pixelUnpackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelUnpack);
if (pixelUnpackBuffer == nullptr)
{
if (dataSize < imageSize)
{
context->validationError(GL_INVALID_OPERATION, kCompressedDataSizeTooSmall);
}
}
return true;
}
bool ValidateGetBufferParameterBase(const Context *context,
BufferBinding target,
GLenum pname,
bool pointerVersion,
GLsizei *numParams)
{
if (numParams)
{
*numParams = 0;
}
if (!context->isValidBufferBinding(target))
{
context->validationError(GL_INVALID_ENUM, kInvalidBufferTypes);
return false;
}
const Buffer *buffer = context->getState().getTargetBuffer(target);
if (!buffer)
{
// A null buffer means that "0" is bound to the requested buffer target
context->validationError(GL_INVALID_OPERATION, kBufferNotBound);
return false;
}
const Extensions &extensions = context->getExtensions();
switch (pname)
{
case GL_BUFFER_USAGE:
case GL_BUFFER_SIZE:
break;
case GL_BUFFER_ACCESS_OES:
if (!extensions.mapBufferOES)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_BUFFER_MAPPED:
static_assert(GL_BUFFER_MAPPED == GL_BUFFER_MAPPED_OES, "GL enums should be equal.");
if (context->getClientMajorVersion() < 3 && !extensions.mapBufferOES &&
!extensions.mapBufferRange)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_BUFFER_MAP_POINTER:
if (!pointerVersion)
{
context->validationError(GL_INVALID_ENUM, kInvalidMapPointerQuery);
return false;
}
break;
case GL_BUFFER_ACCESS_FLAGS:
case GL_BUFFER_MAP_OFFSET:
case GL_BUFFER_MAP_LENGTH:
if (context->getClientMajorVersion() < 3 && !extensions.mapBufferRange)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_MEMORY_SIZE_ANGLE:
if (!context->getExtensions().memorySize)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
case GL_RESOURCE_INITIALIZED_ANGLE:
if (!context->getExtensions().robustResourceInitialization)
{
context->validationError(GL_INVALID_ENUM,
kRobustResourceInitializationExtensionRequired);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
// All buffer parameter queries return one value.
if (numParams)
{
*numParams = 1;
}
return true;
}
bool ValidateGetRenderbufferParameterivBase(const Context *context,
GLenum target,
GLenum pname,
GLsizei *length)
{
if (length)
{
*length = 0;
}
if (target != GL_RENDERBUFFER)
{
context->validationError(GL_INVALID_ENUM, kInvalidRenderbufferTarget);
return false;
}
Renderbuffer *renderbuffer = context->getState().getCurrentRenderbuffer();
if (renderbuffer == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kRenderbufferNotBound);
return false;
}
switch (pname)
{
case GL_RENDERBUFFER_WIDTH:
case GL_RENDERBUFFER_HEIGHT:
case GL_RENDERBUFFER_INTERNAL_FORMAT:
case GL_RENDERBUFFER_RED_SIZE:
case GL_RENDERBUFFER_GREEN_SIZE:
case GL_RENDERBUFFER_BLUE_SIZE:
case GL_RENDERBUFFER_ALPHA_SIZE:
case GL_RENDERBUFFER_DEPTH_SIZE:
case GL_RENDERBUFFER_STENCIL_SIZE:
break;
case GL_RENDERBUFFER_SAMPLES_ANGLE:
if (!context->getExtensions().framebufferMultisample)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
case GL_MEMORY_SIZE_ANGLE:
if (!context->getExtensions().memorySize)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
case GL_IMPLEMENTATION_COLOR_READ_TYPE:
if (!context->getExtensions().getImageANGLE)
{
context->validationError(GL_INVALID_ENUM, kGetImageExtensionNotEnabled);
return false;
}
break;
case GL_RESOURCE_INITIALIZED_ANGLE:
if (!context->getExtensions().robustResourceInitialization)
{
context->validationError(GL_INVALID_ENUM,
kRobustResourceInitializationExtensionRequired);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
if (length)
{
*length = 1;
}
return true;
}
bool ValidateGetShaderivBase(const Context *context,
ShaderProgramID shader,
GLenum pname,
GLsizei *length)
{
if (length)
{
*length = 0;
}
if (context->isContextLost())
{
context->validationError(GL_CONTEXT_LOST, kContextLost);
if (context->getExtensions().parallelShaderCompile && pname == GL_COMPLETION_STATUS_KHR)
{
// Generate an error but still return true, the context still needs to return a
// value in this case.
return true;
}
else
{
return false;
}
}
if (GetValidShader(context, shader) == nullptr)
{
return false;
}
switch (pname)
{
case GL_SHADER_TYPE:
case GL_DELETE_STATUS:
case GL_COMPILE_STATUS:
case GL_INFO_LOG_LENGTH:
case GL_SHADER_SOURCE_LENGTH:
break;
case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
if (!context->getExtensions().translatedShaderSource)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
case GL_COMPLETION_STATUS_KHR:
if (!context->getExtensions().parallelShaderCompile)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
if (length)
{
*length = 1;
}
return true;
}
bool ValidateGetTexParameterBase(const Context *context,
TextureType target,
GLenum pname,
GLsizei *length)
{
if (length)
{
*length = 0;
}
if ((!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target)) ||
target == TextureType::Buffer)
{
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
if (context->getTextureByType(target) == nullptr)
{
// Should only be possible for external textures
context->validationError(GL_INVALID_ENUM, kTextureNotBound);
return false;
}
if (context->getClientMajorVersion() == 1 && !IsValidGLES1TextureParameter(pname))
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
switch (pname)
{
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
break;
case GL_TEXTURE_USAGE_ANGLE:
if (!context->getExtensions().textureUsage)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (!ValidateTextureMaxAnisotropyExtensionEnabled(context))
{
return false;
}
break;
case GL_TEXTURE_IMMUTABLE_FORMAT:
if (context->getClientMajorVersion() < 3 && !context->getExtensions().textureStorage)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_WRAP_R:
case GL_TEXTURE_IMMUTABLE_LEVELS:
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_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_ENUM, kEnumRequiresGLES30);
return false;
}
break;
case GL_TEXTURE_COMPARE_MODE:
case GL_TEXTURE_COMPARE_FUNC:
if (context->getClientMajorVersion() < 3 && !context->getExtensions().shadowSamplersEXT)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (!context->getExtensions().textureSRGBDecode)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_DEPTH_STENCIL_TEXTURE_MODE:
case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE:
if (context->getClientVersion() < ES_3_1)
{
context->validationError(GL_INVALID_ENUM, kEnumRequiresGLES31);
return false;
}
break;
case GL_GENERATE_MIPMAP:
case GL_TEXTURE_CROP_RECT_OES:
// TODO(lfy@google.com): Restrict to GL_OES_draw_texture
// after GL_OES_draw_texture functionality implemented
if (context->getClientMajorVersion() > 1)
{
context->validationError(GL_INVALID_ENUM, kGLES1Only);
return false;
}
break;
case GL_MEMORY_SIZE_ANGLE:
if (!context->getExtensions().memorySize)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_BORDER_COLOR:
if (!context->getExtensions().textureBorderClampOES &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
case GL_TEXTURE_NATIVE_ID_ANGLE:
if (!context->getExtensions().textureExternalUpdateANGLE)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
case GL_IMPLEMENTATION_COLOR_READ_TYPE:
if (!context->getExtensions().getImageANGLE)
{
context->validationError(GL_INVALID_ENUM, kGetImageExtensionNotEnabled);
return false;
}
break;
case GL_RESOURCE_INITIALIZED_ANGLE:
if (!context->getExtensions().robustResourceInitialization)
{
context->validationError(GL_INVALID_ENUM,
kRobustResourceInitializationExtensionRequired);
return false;
}
break;
case GL_TEXTURE_PROTECTED_EXT:
if (!context->getExtensions().protectedTexturesEXT)
{
context->validationError(GL_INVALID_ENUM, kProtectedTexturesExtensionRequired);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
if (length)
{
*length = GetTexParameterCount(pname);
}
return true;
}
bool ValidateGetVertexAttribBase(const Context *context,
GLuint index,
GLenum pname,
GLsizei *length,
bool pointer,
bool pureIntegerEntryPoint)
{
if (length)
{
*length = 0;
}
if (pureIntegerEntryPoint && context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_OPERATION, kES3Required);
return false;
}
if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes))
{
context->validationError(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
return false;
}
if (pointer)
{
if (pname != GL_VERTEX_ATTRIB_ARRAY_POINTER)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
}
else
{
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:
break;
case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
static_assert(
GL_VERTEX_ATTRIB_ARRAY_DIVISOR == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE,
"ANGLE extension enums not equal to GL enums.");
if (context->getClientMajorVersion() < 3 &&
!context->getExtensions().instancedArraysAny())
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_VERTEX_ATTRIB_BINDING:
case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
if (context->getClientVersion() < ES_3_1)
{
context->validationError(GL_INVALID_ENUM, kEnumRequiresGLES31);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
}
if (length)
{
if (pname == GL_CURRENT_VERTEX_ATTRIB)
{
*length = 4;
}
else
{
*length = 1;
}
}
return true;
}
bool ValidatePixelPack(const Context *context,
GLenum format,
GLenum type,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLsizei bufSize,
GLsizei *length,
const void *pixels)
{
// Check for pixel pack buffer related API errors
Buffer *pixelPackBuffer = context->getState().getTargetBuffer(BufferBinding::PixelPack);
if (pixelPackBuffer != nullptr && pixelPackBuffer->isMapped())
{
// ...the buffer object's data store is currently mapped.
context->validationError(GL_INVALID_OPERATION, kBufferMapped);
return false;
}
if (context->getExtensions().webglCompatibility && pixelPackBuffer != nullptr &&
pixelPackBuffer->isBoundForTransformFeedbackAndOtherUse())
{
context->validationError(GL_INVALID_OPERATION, kPixelPackBufferBoundForTransformFeedback);
return false;
}
// .. the data would be packed to the buffer object such that the memory writes required
// would exceed the data store size.
const InternalFormat &formatInfo = GetInternalFormatInfo(format, type);
const Extents size(width, height, 1);
const auto &pack = context->getState().getPackState();
GLuint endByte = 0;
if (!formatInfo.computePackUnpackEndByte(type, size, pack, false, &endByte))
{
context->validationError(GL_INVALID_OPERATION, kIntegerOverflow);
return false;
}
if (bufSize >= 0)
{
if (pixelPackBuffer == nullptr && static_cast<size_t>(bufSize) < endByte)
{
context->validationError(GL_INVALID_OPERATION, kInsufficientBufferSize);
return false;
}
}
if (pixelPackBuffer != nullptr)
{
CheckedNumeric<size_t> checkedEndByte(endByte);
CheckedNumeric<size_t> checkedOffset(reinterpret_cast<size_t>(pixels));
checkedEndByte += checkedOffset;
if (checkedEndByte.ValueOrDie() > static_cast<size_t>(pixelPackBuffer->getSize()))
{
// Overflow past the end of the buffer
context->validationError(GL_INVALID_OPERATION, kParamOverflow);
return false;
}
}
if (pixelPackBuffer == nullptr && length != nullptr)
{
if (endByte > static_cast<size_t>(std::numeric_limits<GLsizei>::max()))
{
context->validationError(GL_INVALID_OPERATION, kIntegerOverflow);
return false;
}
*length = static_cast<GLsizei>(endByte);
}
if (context->getExtensions().webglCompatibility)
{
// WebGL 2.0 disallows the scenario:
// GL_PACK_SKIP_PIXELS + width > DataStoreWidth
// where:
// DataStoreWidth = (GL_PACK_ROW_LENGTH ? GL_PACK_ROW_LENGTH : width)
// Since these two pack parameters can only be set to non-zero values
// on WebGL 2.0 contexts, verify them for all WebGL contexts.
GLint dataStoreWidth = pack.rowLength ? pack.rowLength : width;
if (pack.skipPixels + width > dataStoreWidth)
{
context->validationError(GL_INVALID_OPERATION, kInvalidPackParametersForWebGL);
return false;
}
}
return true;
}
bool ValidateReadPixelsBase(const Context *context,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
GLsizei bufSize,
GLsizei *length,
GLsizei *columns,
GLsizei *rows,
const void *pixels)
{
if (length != nullptr)
{
*length = 0;
}
if (rows != nullptr)
{
*rows = 0;
}
if (columns != nullptr)
{
*columns = 0;
}
if (width < 0 || height < 0)
{
context->validationError(GL_INVALID_VALUE, kNegativeSize);
return false;
}
Framebuffer *readFramebuffer = context->getState().getReadFramebuffer();
ASSERT(readFramebuffer);
if (!ValidateFramebufferComplete(context, readFramebuffer))
{
return false;
}
// needIntrinsic = true. Treat renderToTexture textures as single sample since they will be
// resolved before reading.
if (!readFramebuffer->isDefault() &&
!ValidateFramebufferNotMultisampled(context, readFramebuffer, true))
{
return false;
}
if (readFramebuffer->getReadBufferState() == GL_NONE)
{
context->validationError(GL_INVALID_OPERATION, kReadBufferNone);
return false;
}
const FramebufferAttachment *readBuffer = nullptr;
switch (format)
{
case GL_DEPTH_COMPONENT:
readBuffer = readFramebuffer->getDepthAttachment();
break;
case GL_STENCIL_INDEX_OES:
readBuffer = readFramebuffer->getStencilOrDepthStencilAttachment();
break;
default:
readBuffer = readFramebuffer->getReadColorAttachment();
break;
}
// WebGL 1.0 [Section 6.26] Reading From a Missing Attachment
// In OpenGL ES it is undefined what happens when an operation tries to read from a missing
// attachment and WebGL defines it to be an error. We do the check unconditionnaly as the
// situation is an application error that would lead to a crash in ANGLE.
if (readBuffer == nullptr)
{
context->validationError(GL_INVALID_OPERATION, kMissingReadAttachment);
return false;
}
// OVR_multiview2, Revision 1:
// ReadPixels generates an INVALID_FRAMEBUFFER_OPERATION error if
// the number of views in the current read framebuffer is more than one.
if (readFramebuffer->readDisallowedByMultiview())
{
context->validationError(GL_INVALID_FRAMEBUFFER_OPERATION, kMultiviewReadFramebuffer);
return false;
}
if (context->getExtensions().webglCompatibility)
{
// The ES 2.0 spec states that the format must be "among those defined in table 3.4,
// excluding formats LUMINANCE and LUMINANCE_ALPHA.". This requires validating the format
// and type before validating the combination of format and type. However, the
// dEQP-GLES3.functional.negative_api.buffer.read_pixels passes GL_LUMINANCE as a format and
// verifies that GL_INVALID_OPERATION is generated.
// TODO(geofflang): Update this check to be done in all/no cases once this is resolved in
// dEQP/WebGL.
if (!ValidReadPixelsFormatEnum(context, format))
{
context->validationError(GL_INVALID_ENUM, kInvalidFormat);
return false;
}
if (!ValidReadPixelsTypeEnum(context, type))
{
context->validationError(GL_INVALID_ENUM, kInvalidType);
return false;
}
}
GLenum currentFormat = GL_NONE;
GLenum currentType = GL_NONE;
switch (format)
{
case GL_DEPTH_COMPONENT:
case GL_STENCIL_INDEX_OES:
// Only rely on ValidReadPixelsFormatType for depth/stencil formats
break;
default:
currentFormat = readFramebuffer->getImplementationColorReadFormat(context);
currentType = readFramebuffer->getImplementationColorReadType(context);
break;
}
bool validFormatTypeCombination =
ValidReadPixelsFormatType(context, readBuffer->getFormat().info, format, type);
if (!(currentFormat == format && currentType == type) && !validFormatTypeCombination)
{
context->validationError(GL_INVALID_OPERATION, kMismatchedTypeAndFormat);
return false;
}
if (!ValidatePixelPack(context, format, type, x, y, width, height, bufSize, length, pixels))
{
return false;
}
auto getClippedExtent = [](GLint start, GLsizei length, int bufferSize, GLsizei *outExtent) {
angle::CheckedNumeric<int> clippedExtent(length);
if (start < 0)
{
// "subtract" the area that is less than 0
clippedExtent += start;
}
angle::CheckedNumeric<int> readExtent = start;
readExtent += length;
if (!readExtent.IsValid())
{
return false;
}
if (readExtent.ValueOrDie() > bufferSize)
{
// Subtract the region to the right of the read buffer
clippedExtent -= (readExtent - bufferSize);
}
if (!clippedExtent.IsValid())
{
return false;
}
*outExtent = std::max(clippedExtent.ValueOrDie(), 0);
return true;
};
GLsizei writtenColumns = 0;
if (!getClippedExtent(x, width, readBuffer->getSize().width, &writtenColumns))
{
context->validationError(GL_INVALID_OPERATION, kIntegerOverflow);
return false;
}
GLsizei writtenRows = 0;
if (!getClippedExtent(y, height, readBuffer->getSize().height, &writtenRows))
{
context->validationError(GL_INVALID_OPERATION, kIntegerOverflow);
return false;
}
if (columns != nullptr)
{
*columns = writtenColumns;
}
if (rows != nullptr)
{
*rows = writtenRows;
}
return true;
}
template <typename ParamType>
bool ValidateTexParameterBase(const Context *context,
TextureType target,
GLenum pname,
GLsizei bufSize,
bool vectorParams,
const ParamType *params)
{
if ((!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target)) ||
target == TextureType::Buffer)
{
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
if (context->getTextureByType(target) == nullptr)
{
// Should only be possible for external textures
context->validationError(GL_INVALID_ENUM, kTextureNotBound);
return false;
}
const GLsizei minBufSize = GetTexParameterCount(pname);
if (bufSize >= 0 && bufSize < minBufSize)
{
context->validationError(GL_INVALID_OPERATION, kInsufficientBufferSize);
return false;
}
if (context->getClientMajorVersion() == 1 && !IsValidGLES1TextureParameter(pname))
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
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->getClientMajorVersion() < 3 &&
!(pname == GL_TEXTURE_WRAP_R && context->getExtensions().texture3DOES))
{
context->validationError(GL_INVALID_ENUM, kES3Required);
return false;
}
if (target == TextureType::External &&
!context->getExtensions().eglImageExternalEssl3OES)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
if (target == TextureType::VideoImage && !context->getExtensions().webglVideoTexture)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
}
break;
case GL_GENERATE_MIPMAP:
case GL_TEXTURE_CROP_RECT_OES:
if (context->getClientMajorVersion() > 1)
{
context->validationError(GL_INVALID_ENUM, kGLES1Only);
return false;
}
break;
default:
break;
}
if (target == TextureType::_2DMultisample || target == TextureType::_2DMultisampleArray)
{
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:
case GL_TEXTURE_BORDER_COLOR:
context->validationError(GL_INVALID_ENUM, kInvalidPname);
return false;
}
}
switch (pname)
{
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
{
bool restrictedWrapModes = ((target == TextureType::External &&
!context->getExtensions().eglImageExternalWrapModesEXT) ||
target == TextureType::Rectangle);
if (!ValidateTextureWrapModeValue(context, params, restrictedWrapModes))
{
return false;
}
}
break;
case GL_TEXTURE_MIN_FILTER:
{
bool restrictedMinFilter =
target == TextureType::External || target == TextureType::Rectangle;
if (!ValidateTextureMinFilterValue(context, params, restrictedMinFilter))
{
return false;
}
}
break;
case GL_TEXTURE_MAG_FILTER:
if (!ValidateTextureMagFilterValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_USAGE_ANGLE:
if (!context->getExtensions().textureUsage)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
switch (ConvertToGLenum(params[0]))
{
case GL_NONE:
case GL_FRAMEBUFFER_ATTACHMENT_ANGLE:
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
{
GLfloat paramValue = static_cast<GLfloat>(params[0]);
if (!ValidateTextureMaxAnisotropyValue(context, paramValue))
{
return false;
}
ASSERT(static_cast<ParamType>(paramValue) == params[0]);
}
break;
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
// any value is permissible
break;
case GL_TEXTURE_COMPARE_MODE:
if (!ValidateTextureCompareModeValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_COMPARE_FUNC:
if (!ValidateTextureCompareFuncValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_SWIZZLE_R:
case GL_TEXTURE_SWIZZLE_G:
case GL_TEXTURE_SWIZZLE_B:
case GL_TEXTURE_SWIZZLE_A:
switch (ConvertToGLenum(params[0]))
{
case GL_RED:
case GL_GREEN:
case GL_BLUE:
case GL_ALPHA:
case GL_ZERO:
case GL_ONE:
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_BASE_LEVEL:
if (ConvertToGLint(params[0]) < 0)
{
context->validationError(GL_INVALID_VALUE, kBaseLevelNegative);
return false;
}
if (target == TextureType::External && static_cast<GLuint>(params[0]) != 0)
{
context->validationError(GL_INVALID_OPERATION, kBaseLevelNonZero);
return false;
}
if ((target == TextureType::_2DMultisample ||
target == TextureType::_2DMultisampleArray) &&
static_cast<GLuint>(params[0]) != 0)
{
context->validationError(GL_INVALID_OPERATION, kBaseLevelNonZero);
return false;
}
if (target == TextureType::Rectangle && static_cast<GLuint>(params[0]) != 0)
{
context->validationError(GL_INVALID_OPERATION, kBaseLevelNonZero);
return false;
}
break;
case GL_TEXTURE_MAX_LEVEL:
if (ConvertToGLint(params[0]) < 0)
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
break;
case GL_DEPTH_STENCIL_TEXTURE_MODE:
if (context->getClientVersion() < Version(3, 1))
{
context->validationError(GL_INVALID_ENUM, kEnumRequiresGLES31);
return false;
}
switch (ConvertToGLenum(params[0]))
{
case GL_DEPTH_COMPONENT:
case GL_STENCIL_INDEX:
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (!ValidateTextureSRGBDecodeValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT:
if (!ValidateTextureSRGBOverrideValue(context, params))
{
return false;
}
break;
case GL_GENERATE_MIPMAP:
if (context->getClientMajorVersion() > 1)
{
context->validationError(GL_INVALID_ENUM, kGLES1Only);
return false;
}
break;
case GL_TEXTURE_CROP_RECT_OES:
if (context->getClientMajorVersion() > 1)
{
context->validationError(GL_INVALID_ENUM, kGLES1Only);
return false;
}
if (!vectorParams)
{
context->validationError(GL_INVALID_OPERATION, kInsufficientBufferSize);
return false;
}
break;
case GL_TEXTURE_BORDER_COLOR:
if (!context->getExtensions().textureBorderClampOES &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
if (!vectorParams)
{
context->validationError(GL_INVALID_ENUM, kInsufficientBufferSize);
return false;
}
break;
case GL_RESOURCE_INITIALIZED_ANGLE:
if (!context->getExtensions().robustResourceInitialization)
{
context->validationError(GL_INVALID_ENUM,
kRobustResourceInitializationExtensionRequired);
return false;
}
break;
case GL_TEXTURE_PROTECTED_EXT:
if (!context->getExtensions().protectedTexturesEXT)
{
context->validationError(GL_INVALID_ENUM, kProtectedTexturesExtensionRequired);
return false;
}
if (ConvertToBool(params[0]) != context->getState().hasProtectedContent())
{
context->validationError(GL_INVALID_OPERATION,
"Protected Texture must match Protected Context");
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
return true;
}
template bool ValidateTexParameterBase(const Context *,
TextureType,
GLenum,
GLsizei,
bool,
const GLfloat *);
template bool ValidateTexParameterBase(const Context *,
TextureType,
GLenum,
GLsizei,
bool,
const GLint *);
template bool ValidateTexParameterBase(const Context *,
TextureType,
GLenum,
GLsizei,
bool,
const GLuint *);
bool ValidateVertexAttribIndex(const Context *context, GLuint index)
{
if (index >= MAX_VERTEX_ATTRIBS)
{
context->validationError(GL_INVALID_VALUE, kIndexExceedsMaxVertexAttribute);
return false;
}
return true;
}
bool ValidateGetActiveUniformBlockivBase(const Context *context,
ShaderProgramID program,
UniformBlockIndex uniformBlockIndex,
GLenum pname,
GLsizei *length)
{
if (length)
{
*length = 0;
}
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_OPERATION, kES3Required);
return false;
}
Program *programObject = GetValidProgram(context, program);
if (!programObject)
{
return false;
}
if (uniformBlockIndex.value >= programObject->getActiveUniformBlockCount())
{
context->validationError(GL_INVALID_VALUE, kIndexExceedsActiveUniformBlockCount);
return false;
}
switch (pname)
{
case GL_UNIFORM_BLOCK_BINDING:
case GL_UNIFORM_BLOCK_DATA_SIZE:
case GL_UNIFORM_BLOCK_NAME_LENGTH:
case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES:
case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
if (length)
{
if (pname == GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES)
{
const InterfaceBlock &uniformBlock =
programObject->getUniformBlockByIndex(uniformBlockIndex.value);
*length = static_cast<GLsizei>(uniformBlock.memberIndexes.size());
}
else
{
*length = 1;
}
}
return true;
}
template <typename ParamType>
bool ValidateSamplerParameterBase(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei bufSize,
bool vectorParams,
const ParamType *params)
{
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_OPERATION, kES3Required);
return false;
}
if (!context->isSampler(sampler))
{
context->validationError(GL_INVALID_OPERATION, kInvalidSampler);
return false;
}
const GLsizei minBufSize = GetSamplerParameterCount(pname);
if (bufSize >= 0 && bufSize < minBufSize)
{
context->validationError(GL_INVALID_OPERATION, kInsufficientBufferSize);
return false;
}
switch (pname)
{
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
if (!ValidateTextureWrapModeValue(context, params, false))
{
return false;
}
break;
case GL_TEXTURE_MIN_FILTER:
if (!ValidateTextureMinFilterValue(context, params, false))
{
return false;
}
break;
case GL_TEXTURE_MAG_FILTER:
if (!ValidateTextureMagFilterValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
// any value is permissible
break;
case GL_TEXTURE_COMPARE_MODE:
if (!ValidateTextureCompareModeValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_COMPARE_FUNC:
if (!ValidateTextureCompareFuncValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (!ValidateTextureSRGBDecodeValue(context, params))
{
return false;
}
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
{
GLfloat paramValue = static_cast<GLfloat>(params[0]);
if (!ValidateTextureMaxAnisotropyValue(context, paramValue))
{
return false;
}
}
break;
case GL_TEXTURE_BORDER_COLOR:
if (!context->getExtensions().textureBorderClampOES &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
if (!vectorParams)
{
context->validationError(GL_INVALID_ENUM, kInsufficientBufferSize);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
return true;
}
template bool ValidateSamplerParameterBase(const Context *,
SamplerID,
GLenum,
GLsizei,
bool,
const GLfloat *);
template bool ValidateSamplerParameterBase(const Context *,
SamplerID,
GLenum,
GLsizei,
bool,
const GLint *);
template bool ValidateSamplerParameterBase(const Context *,
SamplerID,
GLenum,
GLsizei,
bool,
const GLuint *);
bool ValidateGetSamplerParameterBase(const Context *context,
SamplerID sampler,
GLenum pname,
GLsizei *length)
{
if (length)
{
*length = 0;
}
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_OPERATION, kES3Required);
return false;
}
if (!context->isSampler(sampler))
{
context->validationError(GL_INVALID_OPERATION, kInvalidSampler);
return false;
}
switch (pname)
{
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MIN_LOD:
case GL_TEXTURE_MAX_LOD:
case GL_TEXTURE_COMPARE_MODE:
case GL_TEXTURE_COMPARE_FUNC:
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (!ValidateTextureMaxAnisotropyExtensionEnabled(context))
{
return false;
}
break;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (!context->getExtensions().textureSRGBDecode)
{
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
break;
case GL_TEXTURE_BORDER_COLOR:
if (!context->getExtensions().textureBorderClampOES &&
context->getClientVersion() < ES_3_2)
{
context->validationError(GL_INVALID_ENUM, kExtensionNotEnabled);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
if (length)
{
*length = GetSamplerParameterCount(pname);
}
return true;
}
bool ValidateGetInternalFormativBase(const Context *context,
GLenum target,
GLenum internalformat,
GLenum pname,
GLsizei bufSize,
GLsizei *numParams)
{
if (numParams)
{
*numParams = 0;
}
if (context->getClientMajorVersion() < 3)
{
context->validationError(GL_INVALID_OPERATION, kES3Required);
return false;
}
const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
if (!formatCaps.renderbuffer)
{
context->validationError(GL_INVALID_ENUM, kFormatNotRenderable);
return false;
}
switch (target)
{
case GL_RENDERBUFFER:
break;
case GL_TEXTURE_2D_MULTISAMPLE:
if (context->getClientVersion() < ES_3_1 &&
!context->getExtensions().textureMultisample)
{
context->validationError(GL_INVALID_ENUM,
kMultisampleTextureExtensionOrES31Required);
return false;
}
break;
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
if (!context->getExtensions().textureStorageMultisample2DArrayOES)
{
context->validationError(GL_INVALID_ENUM, kMultisampleArrayExtensionRequired);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidTarget);
return false;
}
if (bufSize < 0)
{
context->validationError(GL_INVALID_VALUE, kInsufficientBufferSize);
return false;
}
GLsizei maxWriteParams = 0;
switch (pname)
{
case GL_NUM_SAMPLE_COUNTS:
maxWriteParams = 1;
break;
case GL_SAMPLES:
maxWriteParams = static_cast<GLsizei>(formatCaps.sampleCounts.size());
break;
default:
context->validationError(GL_INVALID_ENUM, kEnumNotSupported);
return false;
}
if (numParams)
{
// glGetInternalFormativ will not overflow bufSize
*numParams = std::min(bufSize, maxWriteParams);
}
return true;
}
bool ValidateFramebufferNotMultisampled(const Context *context,
const Framebuffer *framebuffer,
bool checkReadBufferResourceSamples)
{
int samples = checkReadBufferResourceSamples
? framebuffer->getReadBufferResourceSamples(context)
: framebuffer->getSamples(context);
if (samples != 0)
{
context->validationError(GL_INVALID_OPERATION, kInvalidMultisampledFramebufferOperation);
return false;
}
return true;
}
bool ValidateMultitextureUnit(const Context *context, GLenum texture)
{
if (texture < GL_TEXTURE0 || texture >= GL_TEXTURE0 + context->getCaps().maxMultitextureUnits)
{
context->validationError(GL_INVALID_ENUM, kInvalidMultitextureUnit);
return false;
}
return true;
}
bool ValidateTexStorageMultisample(const Context *context,
TextureType target,
GLsizei samples,
GLint internalFormat,
GLsizei width,
GLsizei height)
{
const Caps &caps = context->getCaps();
if (width > caps.max2DTextureSize || height > caps.max2DTextureSize)
{
context->validationError(GL_INVALID_VALUE, kTextureWidthOrHeightOutOfRange);
return false;
}
if (samples == 0)
{
context->validationError(GL_INVALID_VALUE, kSamplesZero);
return false;
}
const TextureCaps &formatCaps = context->getTextureCaps().get(internalFormat);
if (!formatCaps.textureAttachment)
{
context->validationError(GL_INVALID_ENUM, kRenderableInternalFormat);
return false;
}
// The ES3.1 spec(section 8.8) states that an INVALID_ENUM error is generated if internalformat
// is one of the unsized base internalformats listed in table 8.11.
const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalFormat);
if (formatInfo.internalFormat == GL_NONE)
{
context->validationError(GL_INVALID_ENUM, kUnsizedInternalFormatUnsupported);
return false;
}
if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
{
context->validationError(GL_INVALID_OPERATION, kSamplesOutOfRange);
return false;
}
Texture *texture = context->getTextureByType(target);
if (!texture || texture->id().value == 0)
{
context->validationError(GL_INVALID_OPERATION, kZeroBoundToTarget);
return false;
}
if (texture->getImmutableFormat())
{
context->validationError(GL_INVALID_OPERATION, kImmutableTextureBound);
return false;
}
return true;
}
bool ValidateTexStorage2DMultisampleBase(const Context *context,
TextureType target,
GLsizei samples,
GLint internalFormat,
GLsizei width,
GLsizei height)
{
if (target != TextureType::_2DMultisample)
{
context->validationError(GL_INVALID_ENUM, kInvalidTarget);
return false;
}
if (width < 1 || height < 1)
{
context->validationError(GL_INVALID_VALUE, kTextureSizeTooSmall);
return false;
}
return ValidateTexStorageMultisample(context, target, samples, internalFormat, width, height);
}
bool ValidateGetTexLevelParameterBase(const Context *context,
TextureTarget target,
GLint level,
GLenum pname,
GLsizei *length)
{
if (length)
{
*length = 0;
}
TextureType type = TextureTargetToType(target);
if (!ValidTexLevelDestinationTarget(context, type))
{
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
if (context->getTextureByType(type) == nullptr)
{
context->validationError(GL_INVALID_ENUM, kTextureNotBound);
return false;
}
if (!ValidMipLevel(context, type, level))
{
context->validationError(GL_INVALID_VALUE, kInvalidMipLevel);
return false;
}
switch (pname)
{
case GL_TEXTURE_RED_TYPE:
case GL_TEXTURE_GREEN_TYPE:
case GL_TEXTURE_BLUE_TYPE:
case GL_TEXTURE_ALPHA_TYPE:
case GL_TEXTURE_DEPTH_TYPE:
case GL_TEXTURE_RED_SIZE:
case GL_TEXTURE_GREEN_SIZE:
case GL_TEXTURE_BLUE_SIZE:
case GL_TEXTURE_ALPHA_SIZE:
case GL_TEXTURE_DEPTH_SIZE:
case GL_TEXTURE_STENCIL_SIZE:
case GL_TEXTURE_SHARED_SIZE:
case GL_TEXTURE_INTERNAL_FORMAT:
case GL_TEXTURE_WIDTH:
case GL_TEXTURE_HEIGHT:
case GL_TEXTURE_DEPTH:
case GL_TEXTURE_SAMPLES:
case GL_TEXTURE_FIXED_SAMPLE_LOCATIONS:
case GL_TEXTURE_COMPRESSED:
break;
case GL_RESOURCE_INITIALIZED_ANGLE:
if (!context->getExtensions().robustResourceInitialization)
{
context->validationError(GL_INVALID_ENUM,
kRobustResourceInitializationExtensionRequired);
return false;
}
break;
case GL_TEXTURE_BUFFER_DATA_STORE_BINDING:
case GL_TEXTURE_BUFFER_OFFSET:
case GL_TEXTURE_BUFFER_SIZE:
if (context->getClientVersion() < Version(3, 2) &&
!context->getExtensions().textureBufferAny())
{
context->validationError(GL_INVALID_ENUM, kTextureBufferExtensionNotAvailable);
return false;
}
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidPname);
return false;
}
if (length)
{
*length = 1;
}
return true;
}
bool ValidateGetMultisamplefvBase(const Context *context,
GLenum pname,
GLuint index,
const GLfloat *val)
{
if (pname != GL_SAMPLE_POSITION)
{
context->validationError(GL_INVALID_ENUM, kInvalidPname);
return false;
}
Framebuffer *framebuffer = context->getState().getDrawFramebuffer();
GLint samples = framebuffer->getSamples(context);
if (index >= static_cast<GLuint>(samples))
{
context->validationError(GL_INVALID_VALUE, kIndexExceedsSamples);
return false;
}
return true;
}
bool ValidateSampleMaskiBase(const Context *context, GLuint maskNumber, GLbitfield mask)
{
if (maskNumber >= static_cast<GLuint>(context->getCaps().maxSampleMaskWords))
{
context->validationError(GL_INVALID_VALUE, kInvalidSampleMaskNumber);
return false;
}
return true;
}
void RecordDrawAttribsError(const Context *context)
{
// An overflow can happen when adding the offset. Check against a special constant.
if (context->getStateCache().getNonInstancedVertexElementLimit() ==
VertexAttribute::kIntegerOverflow ||
context->getStateCache().getInstancedVertexElementLimit() ==
VertexAttribute::kIntegerOverflow)
{
context->validationError(GL_INVALID_OPERATION, kIntegerOverflow);
}
else
{
// [OpenGL ES 3.0.2] section 2.9.4 page 40:
// We can return INVALID_OPERATION if our buffer does not have enough backing data.
context->validationError(GL_INVALID_OPERATION, kInsufficientVertexBufferSize);
}
}
bool ValidateLoseContextCHROMIUM(const Context *context,
GraphicsResetStatus current,
GraphicsResetStatus other)
{
if (!context->getExtensions().loseContextCHROMIUM)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
switch (current)
{
case GraphicsResetStatus::GuiltyContextReset:
case GraphicsResetStatus::InnocentContextReset:
case GraphicsResetStatus::UnknownContextReset:
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidResetStatus);
}
switch (other)
{
case GraphicsResetStatus::GuiltyContextReset:
case GraphicsResetStatus::InnocentContextReset:
case GraphicsResetStatus::UnknownContextReset:
break;
default:
context->validationError(GL_INVALID_ENUM, kInvalidResetStatus);
}
return true;
}
// GL_ANGLE_texture_storage_external
bool ValidateTexImage2DExternalANGLE(const Context *context,
TextureTarget target,
GLint level,
GLint internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type)
{
if (!context->getExtensions().textureExternalUpdateANGLE)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidTexture2DDestinationTarget(context, target) &&
!ValidTextureExternalTarget(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
if (context->getClientMajorVersion() <= 2)
{
if (!ValidateES2TexImageParametersBase(context, target, level, internalformat, false, false,
0, 0, width, height, border, format, type, -1,
nullptr))
{
return false;
}
}
else
{
if (!ValidateES3TexImageParametersBase(context, target, level, internalformat, false, false,
0, 0, 0, width, height, 1, border, format, type, -1,
nullptr))
{
return false;
}
}
return true;
}
bool ValidateInvalidateTextureANGLE(const Context *context, TextureType target)
{
if (!context->getExtensions().textureExternalUpdateANGLE)
{
context->validationError(GL_INVALID_OPERATION, kExtensionNotEnabled);
return false;
}
if (!ValidTextureTarget(context, target) && !ValidTextureExternalTarget(context, target))
{
context->validationError(GL_INVALID_ENUM, kInvalidTextureTarget);
return false;
}
return true;
}
} // namespace gl