| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Firefox/gfx/angle/checkout/src/libANGLE/ (Browser von der Mozilla Stiftung Version 136.0.1©) Datei vom 10.2.2025 mit Größe 221 kB |
|
Quellcode-Bibliothek validationES2.cppSprache: C |
|||||||||||||||
|
// // 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. // // validationES2.cpp: Validation functions for OpenGL ES 2.0 entry point parameters #include "libANGLE/validationES2_autogen.h" #include <cstdint> #include "common/mathutil.h" #include "common/string_utils.h" #include "common/utilities.h" #include "libANGLE/Context.h" #include "libANGLE/ErrorStrings.h" #include "libANGLE/Fence.h" #include "libANGLE/Framebuffer.h" #include "libANGLE/FramebufferAttachment.h" #include "libANGLE/MemoryObject.h" #include "libANGLE/Renderbuffer.h" #include "libANGLE/Shader.h" #include "libANGLE/Texture.h" #include "libANGLE/Uniform.h" #include "libANGLE/VertexArray.h" #include "libANGLE/formatutils.h" #include "libANGLE/validationES.h" #include "libANGLE/validationES2.h" #include "libANGLE/validationES3_autogen.h" namespace gl { using namespace err; namespace { bool IsPartialBlit(const Context *context, const FramebufferAttachment *readBuffer, const FramebufferAttachment *writeBuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1) { const Extents &writeSize = writeBuffer->getSize(); const Extents &readSize = readBuffer->getSize(); if (srcX0 != 0 || srcY0 != 0 || dstX0 != 0 || dstY0 != 0 || dstX1 != writeSize.width || dstY1 != writeSize.height || srcX1 != readSize.width || srcY1 != readSize.height) { return true; } if (context->getState().isScissorTestEnabled()) { const Rectangle &scissor = context->getState().getScissor(); return scissor.x > 0 || scissor.y > 0 || scissor.width < writeSize.width || scissor.height < writeSize.height; } return false; } bool IsValidCopyTextureSourceInternalFormatEnum(GLenum internalFormat) { // Table 1.1 from the CHROMIUM_copy_texture spec switch (GetUnsizedFormat(internalFormat)) { case GL_RED: case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: case GL_RGB: case GL_RGBA: case GL_RGB8: case GL_RGBA8: case GL_BGRA_EXT: case GL_BGRA8_EXT: return true; default: return false; } } bool IsValidCopySubTextureSourceInternalFormat(GLenum internalFormat) { return IsValidCopyTextureSourceInternalFormatEnum(internalFormat); } bool IsValidCopyTextureDestinationInternalFormatEnum(GLint internalFormat) { // Table 1.0 from the CHROMIUM_copy_texture spec switch (internalFormat) { case GL_ALPHA: case GL_BGRA8_EXT: case GL_BGRA_EXT: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: case GL_R11F_G11F_B10F: case GL_R16F: case GL_R32F: case GL_R8: case GL_R8UI: case GL_RG16F: case GL_RG32F: case GL_RG8: case GL_RG8UI: case GL_RGB: case GL_RGB10_A2: case GL_RGB16F: case GL_RGB32F: case GL_RGB565: case GL_RGB5_A1: case GL_RGB8: case GL_RGB8UI: case GL_RGB9_E5: case GL_RGBA: case GL_RGBA16F: case GL_RGBA32F: case GL_RGBA4: case GL_RGBA8: case GL_RGBA8UI: case GL_RGBX8_ANGLE: case GL_SRGB8: case GL_SRGB8_ALPHA8: case GL_SRGB_ALPHA_EXT: case GL_SRGB_EXT: return true; default: return false; } } bool IsValidCopySubTextureDestionationInternalFormat(GLenum internalFormat) { return IsValidCopyTextureDestinationInternalFormatEnum(internalFormat); } bool IsValidCopyTextureDestinationFormatType(const Context *context, angle::EntryPoint entryPoint, GLint internalFormat, GLenum type) { if (!IsValidCopyTextureDestinationInternalFormatEnum(internalFormat)) { context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat); return false; } if (!ValidES3FormatCombination(GetUnsizedFormat(internalFormat), type, internalForm { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat return false; } const InternalFormat &internalFormatInfo = GetInternalFormatInfo(internalFormat, type); if (!internalFormatInfo.textureSupport(context->getClientVersion(), context->getExte { context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat); return false; } return true; } bool IsValidCopyTextureDestinationTargetEnum(const Context *context, TextureTarget ta { 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().textureRectangleANGLE; default: return false; } } bool IsValidCopyTextureDestinationTarget(const Context *context, TextureType textureType, TextureTarget target) { return TextureTargetToType(target) == textureType; } bool IsValidCopyTextureSourceTarget(const Context *context, TextureType type) { switch (type) { case TextureType::_2D: return true; case TextureType::Rectangle: return context->getExtensions().textureRectangleANGLE; case TextureType::External: return context->getExtensions().EGLImageExternalOES; case TextureType::VideoImage: return context->getExtensions().videoTextureWEBGL; default: return false; } } bool IsValidCopyTextureSourceLevel(const Context *context, TextureType type, GLint leve { if (!ValidMipLevel(context, type, level)) { return false; } if (level > 0 && context->getClientVersion() < ES_3_0) { return false; } return true; } bool IsValidCopyTextureDestinationLevel(const Context *context, angle::EntryPoint entryPoint, TextureType type, GLint level, GLsizei width, GLsizei height, bool isSubImage) { if (!ValidMipLevel(context, type, level)) { return false; } if (!ValidImageSizeParameters(context, entryPoint, type, level, width, height, 1, isSubI { return false; } const Caps &caps = context->getCaps(); switch (type) { case TextureType::_2D: return width <= (caps.max2DTextureSize >> level) && height <= (caps.max2DTextureSize >> level); case TextureType::Rectangle: ASSERT(level == 0); return width <= (caps.max2DTextureSize >> level) && height <= (caps.max2DTextureSize >> level); case TextureType::CubeMap: return width <= (caps.maxCubeMapTextureSize >> level) && height <= (caps.maxCubeMapTextureSize >> level); default: return true; } } bool IsValidStencilFunc(GLenum func) { switch (func) { case GL_NEVER: case GL_ALWAYS: case GL_LESS: case GL_LEQUAL: case GL_EQUAL: case GL_GEQUAL: case GL_GREATER: case GL_NOTEQUAL: return true; default: return false; } } bool IsValidStencilFace(GLenum face) { switch (face) { case GL_FRONT: case GL_BACK: case GL_FRONT_AND_BACK: return true; default: return false; } } bool IsValidStencilOp(GLenum op) { switch (op) { case GL_ZERO: case GL_KEEP: case GL_REPLACE: case GL_INCR: case GL_DECR: case GL_INVERT: case GL_INCR_WRAP: case GL_DECR_WRAP: return true; default: return false; } } static inline bool Valid1to4ComponentFloatColorBufferFormat(const Context *context, GL { return (context->getExtensions().textureFloatOES && (format == GL_RGBA32F || format == GL_RGB32F || format == GL_RG32F || format == GL_R32F)) || (context->getExtensions().textureHalfFloatOES && (format == GL_RGBA16F || format == GL_RGB16F || format == GL_RG16F || format == GL_R16F)); } static inline bool Valid2to4ComponentFloatColorBufferFormat(const Context *context, GL { return (context->getExtensions().textureFloatOES && (format == GL_RGBA32F || format == GL_RGB32F || format == GL_RG32F)) || (context->getExtensions().textureHalfFloatOES && (format == GL_RGBA16F || format == GL_RGB16F || format == GL_RG16F)); } static inline bool Valid3to4ComponentFloatColorBufferFormat(const Context *context, GL { return (context->getExtensions().textureFloatOES && (format == GL_RGBA32F || format == GL_RGB32F)) || (context->getExtensions().textureHalfFloatOES && (format == GL_RGBA16F || format == GL_RGB16F)); } static inline bool Valid4ComponentFloatColorBufferFormat(const Context *context, GLenu { return (context->getExtensions().textureFloatOES && format == GL_RGBA32F) || (context->getExtensions().textureHalfFloatOES && format == GL_RGBA16F); } bool ValidateES2CopyTexImageParameters(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, bool isSubImage, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { if (!ValidTexture2DDestinationTarget(context, target)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } TextureType texType = TextureTargetToType(target); if (!ValidImageSizeParameters(context, entryPoint, texType, level, width, height, 1, isSubImage)) { // Error is already handled. return false; } Format textureFormat = Format::Invalid(); if (!ValidateCopyTexImageParametersBase(context, entryPoint, target, level, internalf isSubImage, xoffset, yoffset, 0, x, y, width, height, border, &textureFormat)) { return false; } ASSERT(textureFormat.valid() || !isSubImage); const Framebuffer *framebuffer = context->getState().getReadFramebuffer(); GLenum colorbufferFormat = framebuffer->getReadColorAttachment()->getFormat().info->sizedInternalFormat; const auto &formatInfo = *textureFormat.info; // ValidateCopyTexImageParametersBase rejects compressed formats with GL_INVALID_OPERA ASSERT(!formatInfo.compressed); ASSERT(!GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE).compressed); // ValidateCopyTexImageParametersBase rejects depth formats with GL_INVALID_OPERATION. ASSERT(!formatInfo.depthBits); ASSERT(!GetInternalFormatInfo(internalformat, GL_UNSIGNED_BYTE).depthBits); // [OpenGL ES 2.0.24] table 3.9 if (isSubImage) { switch (formatInfo.format) { case GL_ALPHA: if (colorbufferFormat != GL_ALPHA8_EXT && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX && !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_LUMINANCE: if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE && !Valid1to4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_RED_EXT: if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_R32F && colorbufferFormat != GL_RG32F && colorbufferFormat != GL_RGB32F && colorbufferFormat != GL_RGBA32F && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE && !Valid1to4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_RG_EXT: if (colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_RG32F && colorbufferFormat != GL_RGB32F && colorbufferFormat != GL_RGBA32F && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE && !Valid2to4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_RGB: if (colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_RGB32F && colorbufferFormat != GL_RGBA32F && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE && !Valid3to4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_LUMINANCE_ALPHA: case GL_RGBA: if (colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_RGBA32F && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_BGR5_A1_ANGLEX && !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } if (formatInfo.type == GL_FLOAT && !context->getExtensions().textureFloatOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } } else { switch (internalformat) { case GL_ALPHA: if (colorbufferFormat != GL_ALPHA8_EXT && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX && !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_LUMINANCE: case GL_RED_EXT: if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE && !Valid1to4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_RG_EXT: if (colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE && !Valid2to4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_RGB: if (colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_BGRX8_ANGLEX && colorbufferFormat != GL_RGBX8_ANGLE && !Valid3to4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; case GL_LUMINANCE_ALPHA: case GL_RGBA: if (colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX && colorbufferFormat != GL_RGBA16F && !Valid4ComponentFloatColorBufferFormat(context, colorbufferFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, internalformat); return false; } } // If width or height is zero, it is a no-op. Return false without setting an error. return (width > 0 && height > 0); } bool ValidCap(const Context *context, GLenum cap, bool queryOnly) { switch (cap) { // EXT_multisample_compatibility case GL_MULTISAMPLE_EXT: case GL_SAMPLE_ALPHA_TO_ONE_EXT: return context->getExtensions().multisampleCompatibilityEXT; case GL_CULL_FACE: case GL_POLYGON_OFFSET_FILL: case GL_SAMPLE_ALPHA_TO_COVERAGE: case GL_SAMPLE_COVERAGE: case GL_SCISSOR_TEST: case GL_STENCIL_TEST: case GL_DEPTH_TEST: case GL_BLEND: case GL_DITHER: return true; case GL_PRIMITIVE_RESTART_FIXED_INDEX: case GL_RASTERIZER_DISCARD: return (context->getClientMajorVersion() >= 3); case GL_DEBUG_OUTPUT_SYNCHRONOUS: case GL_DEBUG_OUTPUT: return context->getExtensions().debugKHR; case GL_BIND_GENERATES_RESOURCE_CHROMIUM: return queryOnly && context->getExtensions().bindGeneratesResourceCHROMIUM; case GL_CLIENT_ARRAYS_ANGLE: return queryOnly && context->getExtensions().clientArraysANGLE; case GL_FRAMEBUFFER_SRGB_EXT: return context->getExtensions().sRGBWriteControlEXT; case GL_SAMPLE_MASK: return context->getClientVersion() >= Version(3, 1); case GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE: return queryOnly && context->getExtensions().robustResourceInitializationANGLE; case GL_TEXTURE_RECTANGLE_ANGLE: return context->isWebGL(); // GL_APPLE_clip_distance/GL_EXT_clip_cull_distance case GL_CLIP_DISTANCE0_EXT: case GL_CLIP_DISTANCE1_EXT: case GL_CLIP_DISTANCE2_EXT: case GL_CLIP_DISTANCE3_EXT: case GL_CLIP_DISTANCE4_EXT: case GL_CLIP_DISTANCE5_EXT: case GL_CLIP_DISTANCE6_EXT: case GL_CLIP_DISTANCE7_EXT: if (context->getExtensions().clipDistanceAPPLE || context->getExtensions().clipCullDistanceEXT) { return true; } break; case GL_SAMPLE_SHADING: return context->getExtensions().sampleShadingOES; case GL_SHADING_RATE_PRESERVE_ASPECT_RATIO_QCOM: return context->getExtensions().shadingRateQCOM; // COLOR_LOGIC_OP is in GLES1, but exposed through an ANGLE extension. case GL_COLOR_LOGIC_OP: return context->getClientVersion() < Version(2, 0) || context->getExtensions().logicOpANGLE; default: break; } // GLES1 emulation: GLES1-specific caps after this point if (context->getClientVersion().major != 1) { return false; } switch (cap) { case GL_ALPHA_TEST: case GL_VERTEX_ARRAY: case GL_NORMAL_ARRAY: case GL_COLOR_ARRAY: case GL_TEXTURE_COORD_ARRAY: case GL_TEXTURE_2D: case GL_LIGHTING: case GL_LIGHT0: case GL_LIGHT1: case GL_LIGHT2: case GL_LIGHT3: case GL_LIGHT4: case GL_LIGHT5: case GL_LIGHT6: case GL_LIGHT7: case GL_NORMALIZE: case GL_RESCALE_NORMAL: case GL_COLOR_MATERIAL: case GL_CLIP_PLANE0: case GL_CLIP_PLANE1: case GL_CLIP_PLANE2: case GL_CLIP_PLANE3: case GL_CLIP_PLANE4: case GL_CLIP_PLANE5: case GL_FOG: case GL_POINT_SMOOTH: case GL_LINE_SMOOTH: return context->getClientVersion() < Version(2, 0); case GL_POINT_SIZE_ARRAY_OES: return context->getClientVersion() < Version(2, 0) && context->getExtensions().pointSizeArrayOES; case GL_TEXTURE_CUBE_MAP: return context->getClientVersion() < Version(2, 0) && context->getExtensions().textureCubeMapOES; case GL_POINT_SPRITE_OES: return context->getClientVersion() < Version(2, 0) && context->getExtensions().pointSpriteOES; default: return false; } } // Return true if a character belongs to the ASCII subset as defined in GLSL ES 1.0 spec section // 3.1. bool IsValidESSLCharacter(unsigned char c) { // Printing characters are valid except " $ ` @ \ ' DEL. if (c >= 32 && c <= 126 && c != '"' && c != '$' && c != '`' && c != '@' && c != '\\' && c != '\'') { return true; } // Horizontal tab, line feed, vertical tab, form feed, carriage return are also valid. if (c >= 9 && c <= 13) { return true; } return false; } bool IsValidESSLString(const char *str, size_t len) { for (size_t i = 0; i < len; i++) { if (!IsValidESSLCharacter(str[i])) { return false; } } return true; } bool ValidateWebGLNamePrefix(const Context *context, angle::EntryPoint entryPoint, const GLchar *name) { ASSERT(context->isWebGL()); // WebGL 1.0 [Section 6.16] GLSL Constructs // Identifiers starting with "webgl_" and "_webgl_" are reserved for use by WebGL. if (strncmp(name, "webgl_", 6) == 0 || strncmp(name, "_webgl_", 7) == 0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kWebglBindAttribLocationReservedPrefix); return false; } return true; } bool ValidateWebGLNameLength(const Context *context, angle::EntryPoint entryPoint, siz { ASSERT(context->isWebGL()); if (context->isWebGL1() && length > 256) { // WebGL 1.0 [Section 6.21] Maxmimum Uniform and Attribute Location Lengths // WebGL imposes a limit of 256 characters on the lengths of uniform and attribute // locations. context->validationError(entryPoint, GL_INVALID_VALUE, kWebglNameLengthLimitExceede return false; } else if (length > 1024) { // WebGL 2.0 [Section 4.3.2] WebGL 2.0 imposes a limit of 1024 characters on the lengths of // uniform and attribute locations. context->validationError(entryPoint, GL_INVALID_VALUE, kWebgl2NameLengthLimitExceed return false; } return true; } bool ValidBlendFunc(const Context *context, GLenum val) { const Extensions &ext = context->getExtensions(); // these are always valid for src and dst. switch (val) { case GL_ZERO: case GL_ONE: case GL_SRC_COLOR: case GL_ONE_MINUS_SRC_COLOR: case GL_DST_COLOR: case GL_ONE_MINUS_DST_COLOR: case GL_SRC_ALPHA: case GL_ONE_MINUS_SRC_ALPHA: case GL_DST_ALPHA: case GL_ONE_MINUS_DST_ALPHA: case GL_CONSTANT_COLOR: case GL_ONE_MINUS_CONSTANT_COLOR: case GL_CONSTANT_ALPHA: case GL_ONE_MINUS_CONSTANT_ALPHA: return true; // EXT_blend_func_extended. case GL_SRC1_COLOR_EXT: case GL_SRC1_ALPHA_EXT: case GL_ONE_MINUS_SRC1_COLOR_EXT: case GL_ONE_MINUS_SRC1_ALPHA_EXT: case GL_SRC_ALPHA_SATURATE_EXT: return ext.blendFuncExtendedEXT; default: return false; } } bool ValidSrcBlendFunc(const Context *context, GLenum val) { if (ValidBlendFunc(context, val)) return true; if (val == GL_SRC_ALPHA_SATURATE) return true; return false; } bool ValidDstBlendFunc(const Context *context, GLenum val) { if (ValidBlendFunc(context, val)) return true; if (val == GL_SRC_ALPHA_SATURATE) { if (context->getClientMajorVersion() >= 3) return true; } return false; } bool ValidateES2TexImageParameters(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLsizei imageSize, const void *pixels) { if (!ValidTexture2DDestinationTarget(context, target)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } return ValidateES2TexImageParametersBase(context, entryPoint, target, level, internal isCompressed, isSubImage, xoffset, yoffset, width, height, border, format, type, imageSize, pixels); } } // anonymous namespace bool ValidateES2TexImageParametersBase(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLsizei imageSize, const void *pixels) { TextureType texType = TextureTargetToType(target); if (!ValidImageSizeParameters(context, entryPoint, texType, level, width, height, 1, isSubImage)) { // Error already handled. return false; } if (!ValidMipLevel(context, texType, level)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if ((xoffset < 0 || std::numeric_limits<GLsizei>::max() - xoffset < width) || (yoffset < 0 || std::numeric_limits<GLsizei>::max() - yoffset < height)) { context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize); return false; } const Caps &caps = context->getCaps(); switch (texType) { case TextureType::_2D: case TextureType::External: case TextureType::VideoImage: if (width > (caps.max2DTextureSize >> level) || height > (caps.max2DTextureSize >> level)) { context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize); return false; } break; case TextureType::Rectangle: ASSERT(level == 0); if (width > caps.maxRectangleTextureSize || height > caps.maxRectangleTextureSize) { context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize); return false; } if (isCompressed) { context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed); return false; } break; case TextureType::CubeMap: if (!isSubImage && width != height) { context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapFacesEqualDimensions); return false; } if (width > (caps.maxCubeMapTextureSize >> level) || height > (caps.maxCubeMapTextureSize >> level)) { context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize); return false; } break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } Texture *texture = context->getTextureByType(texType); if (!texture) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound); return false; } // Verify zero border if (border != 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBorder); return false; } bool nonEqualFormatsAllowed = false; if (isCompressed) { GLenum actualInternalFormat = isSubImage ? texture->getFormat(target, level).info->sizedInternalFormat : internalformat; const InternalFormat &internalFormatInfo = GetSizedInternalFormatInfo(actualInternalFormat); if (!internalFormatInfo.compressed && !internalFormatInfo.paletted) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kInvalidInternalFormat, internalformat); return false; } if (!internalFormatInfo.textureSupport(context->getClientVersion(), context->getExtensions())) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kInvalidInternalFormat, internalformat); return false; } if (isSubImage) { // From OpenGL ES Version 1.1.12, section 3.7.4 Compressed Paletted // Textures: // // Subimages may not be specified for compressed paletted textures. // Calling CompressedTexSubImage2D with any of the PALETTE* // arguments in table 3.11 will generate an INVALID OPERATION error. if (internalFormatInfo.paletted) { context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat, internalformat); return false; } // From the OES_compressed_ETC1_RGB8_texture spec: // // INVALID_OPERATION is generated by CompressedTexSubImage2D, TexSubImage2D, or // CopyTexSubImage2D if the texture image <level> bound to <target> has internal format // ETC1_RGB8_OES. // // This is relaxed if GL_EXT_compressed_ETC1_RGB8_sub_texture is supported. if (IsETC1Format(actualInternalFormat) && !context->getExtensions().compressedETC1RGB8SubTextureEXT) { context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat, internalformat); return false; } if (!ValidCompressedSubImageSize(context, actualInternalFormat, xoffset, yoffset, 0, width, height, 1, texture->getWidth(target, level), texture->getHeight(target, level), texture->getDepth(target, level))) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCompressedImageSize); return false; } if (format != actualInternalFormat) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } } else { if (!ValidCompressedImageSize(context, actualInternalFormat, level, width, height, 1)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCompressedImageSize); return false; } } } else { // validate <type> by itself (used as secondary key below) switch (type) { case GL_UNSIGNED_BYTE: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT: case GL_UNSIGNED_INT: case GL_UNSIGNED_INT_24_8_OES: case GL_HALF_FLOAT_OES: case GL_FLOAT: break; case GL_UNSIGNED_INT_2_10_10_10_REV_EXT: if (!context->getExtensions().textureType2101010REVEXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type); return false; } break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidType); return false; } // validate <format> + <type> combinations // - invalid <format> -> sets INVALID_ENUM // - invalid <format>+<type> combination -> sets INVALID_OPERATION switch (format) { case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: switch (type) { case GL_UNSIGNED_BYTE: case GL_FLOAT: case GL_HALF_FLOAT_OES: break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_RED: case GL_RG: if (!context->getExtensions().textureRgEXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, format); return false; } switch (type) { case GL_UNSIGNED_BYTE: break; case GL_FLOAT: if (!context->getExtensions().textureFloatOES) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type); return false; } break; case GL_HALF_FLOAT_OES: if (!context->getExtensions().textureFloatOES && !context->getExtensions().textureHalfFloatOES) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type); return false; } break; case GL_SHORT: case GL_UNSIGNED_SHORT: if (!context->getExtensions().textureNorm16EXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_RGB: switch (type) { case GL_UNSIGNED_BYTE: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_INT_2_10_10_10_REV_EXT: case GL_FLOAT: case GL_HALF_FLOAT_OES: break; case GL_SHORT: case GL_UNSIGNED_SHORT: if (!context->getExtensions().textureNorm16EXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_RGBA: switch (type) { case GL_UNSIGNED_BYTE: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_FLOAT: case GL_HALF_FLOAT_OES: case GL_UNSIGNED_INT_2_10_10_10_REV_EXT: break; case GL_SHORT: case GL_UNSIGNED_SHORT: if (!context->getExtensions().textureNorm16EXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_BGRA_EXT: if (!context->getExtensions().textureFormatBGRA8888EXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, format); return false; } switch (type) { case GL_UNSIGNED_BYTE: break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_SRGB_EXT: case GL_SRGB_ALPHA_EXT: if (!context->getExtensions().sRGBEXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, format); return false; } switch (type) { case GL_UNSIGNED_BYTE: break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_DEPTH_COMPONENT: switch (type) { case GL_UNSIGNED_SHORT: case GL_UNSIGNED_INT: break; case GL_FLOAT: if (!context->getExtensions().depthBufferFloat2NV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_DEPTH_STENCIL_OES: switch (type) { case GL_UNSIGNED_INT_24_8_OES: break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_STENCIL_INDEX: switch (type) { case GL_UNSIGNED_BYTE: break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, format); return false; } switch (format) { case GL_DEPTH_COMPONENT: case GL_DEPTH_STENCIL_OES: if (!context->getExtensions().depthTextureANGLE && !((context->getExtensions().packedDepthStencilOES || context->getExtensions().depthTextureCubeMapOES) && context->getExtensions().depthTextureOES)) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, format); return false; } switch (target) { case TextureTarget::_2D: break; case TextureTarget::CubeMapNegativeX: case TextureTarget::CubeMapNegativeY: case TextureTarget::CubeMapNegativeZ: case TextureTarget::CubeMapPositiveX: case TextureTarget::CubeMapPositiveY: case TextureTarget::CubeMapPositiveZ: if (!context->getExtensions().depthTextureCubeMapOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTargetAndFormat); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTargetAndFormat); return false; } // OES_depth_texture supports loading depth data and multiple levels, // but ANGLE_depth_texture does not if (!context->getExtensions().depthTextureOES) { if (pixels != nullptr) { context->validationError(entryPoint, GL_INVALID_OPERATION, kPixelDataNotNull); return false; } if (level != 0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kLevelNotZero); return false; } } break; case GL_STENCIL_INDEX: if (!context->getExtensions().textureStencil8OES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormat); return false; } switch (target) { case TextureTarget::_2D: case TextureTarget::_2DArray: case TextureTarget::CubeMapNegativeX: case TextureTarget::CubeMapNegativeY: case TextureTarget::CubeMapNegativeZ: case TextureTarget::CubeMapPositiveX: case TextureTarget::CubeMapPositiveY: case TextureTarget::CubeMapPositiveZ: break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTargetAndFormat); return false; } if (internalformat != GL_STENCIL_INDEX8) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTargetAndFormat); return false; } break; default: break; } if (!isSubImage) { switch (internalformat) { // Core ES 2.0 formats case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: case GL_RGB: case GL_RGBA: break; case GL_RGBA32F: if (!context->getExtensions().colorBufferFloatRgbaCHROMIUM) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } nonEqualFormatsAllowed = true; if (type != GL_FLOAT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } if (format != GL_RGBA) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_RGB32F: if (!context->getExtensions().colorBufferFloatRgbCHROMIUM) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } nonEqualFormatsAllowed = true; if (type != GL_FLOAT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } if (format != GL_RGB) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } break; case GL_BGRA_EXT: if (!context->getExtensions().textureFormatBGRA8888EXT) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } break; case GL_DEPTH_COMPONENT: if (!(context->getExtensions().depthTextureAny())) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } break; case GL_DEPTH_STENCIL: if (!(context->getExtensions().depthTextureANGLE || context->getExtensions().packedDepthStencilOES || context->getExtensions().depthTextureCubeMapOES)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } break; case GL_STENCIL_INDEX8: if (!context->getExtensions().textureStencil8OES) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } break; case GL_RED: case GL_RG: if (!context->getExtensions().textureRgEXT) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } break; case GL_SRGB_EXT: case GL_SRGB_ALPHA_EXT: if (!context->getExtensions().sRGBEXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, internalformat); return false; } break; case GL_RGB10_A2_EXT: if (!context->getExtensions().textureType2101010REVEXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, internalformat); return false; } if (type != GL_UNSIGNED_INT_2_10_10_10_REV_EXT || format != GL_RGBA) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMismatchedTypeAndFormat); return false; } nonEqualFormatsAllowed = true; break; case GL_RGB5_A1: if (context->getExtensions().textureType2101010REVEXT && type == GL_UNSIGNED_INT_2_10_10_10_REV_EXT && format == GL_RGBA) { nonEqualFormatsAllowed = true; } break; case GL_RGBX8_ANGLE: if (context->getExtensions().rgbxInternalFormatANGLE && type == GL_UNSIGNED_BYTE && format == GL_RGB) { nonEqualFormatsAllowed = true; } break; case GL_R16_EXT: case GL_RG16_EXT: case GL_RGB16_EXT: case GL_RGBA16_EXT: case GL_R16_SNORM_EXT: case GL_RG16_SNORM_EXT: case GL_RGB16_SNORM_EXT: case GL_RGBA16_SNORM_EXT: if (!context->getExtensions().textureNorm16EXT) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, internalformat); return false; } break; default: // Compressed formats are not valid internal formats for glTexImage*D context->validationErrorF(entryPoint, GL_INVALID_VALUE, kInvalidInternalFormat, internalformat); return false; } } if (type == GL_FLOAT) { if (!context->getExtensions().textureFloatOES) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type); return false; } } else if (type == GL_HALF_FLOAT_OES) { if (!context->getExtensions().textureHalfFloatOES) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, type); return false; } } } if (isSubImage) { const InternalFormat &textureInternalFormat = *texture->getFormat(target, level).info; if (textureInternalFormat.internalFormat == GL_NONE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureLevel); return false; } if (format != textureInternalFormat.format) { context->validationError(entryPoint, GL_INVALID_OPERATION, err::kTextureFormatMisma return false; } if (context->isWebGL()) { if (GetInternalFormatInfo(format, type).sizedInternalFormat != textureInternalFormat.sizedInternalFormat) { context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureTypeMismatch); return false; } } if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) || static_cast<size_t>(yoffset + height) > texture->getHeight(target, level)) { context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow); return false; } if (width > 0 && height > 0 && pixels == nullptr && context->getState().getTargetBuffer(BufferBinding::PixelUnpack) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kPixelDataNull); return false; } } else { if (texture->getImmutableFormat()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable); return false; } } // From GL_CHROMIUM_color_buffer_float_rgb[a]: // GL_RGB[A] / GL_RGB[A]32F becomes an allowable format / internalformat parameter pair for // TexImage2D. The restriction in section 3.7.1 of the OpenGL ES 2.0 spec that the // internalformat parameter and format parameter of TexImage2D must match is lifted for this // case. if (!isSubImage && !isCompressed && internalformat != format && !nonEqualFormatsAllowed) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormatCombinatio return false; } GLenum sizeCheckFormat = isSubImage ? format : internalformat; return ValidImageDataSize(context, entryPoint, texType, width, height, 1, sizeCheckForm pixels, imageSize); } bool ValidateES2TexStorageParametersBase(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { if (target != TextureType::_2D && target != TextureType::CubeMap && target != TextureType::Rectangle) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } if (width < 1 || height < 1 || levels < 1) { context->validationError(entryPoint, GL_INVALID_VALUE, kTextureSizeTooSmall); return false; } if (target == TextureType::CubeMap && width != height) { context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapFacesEqualDimensions return false; } if (levels != 1 && levels != log2(std::max(width, height)) + 1) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevels); return false; } const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalformat); if (formatInfo.format == GL_NONE || formatInfo.type == GL_NONE) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } const Caps &caps = context->getCaps(); switch (target) { case TextureType::_2D: if (width > caps.max2DTextureSize || height > caps.max2DTextureSize) { context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize); return false; } break; case TextureType::Rectangle: if (levels != 1) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (width > caps.maxRectangleTextureSize || height > caps.maxRectangleTextureSize) { context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize); return false; } if (formatInfo.compressed) { context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed); return false; } break; case TextureType::CubeMap: if (width > caps.maxCubeMapTextureSize || height > caps.maxCubeMapTextureSize) { context->validationError(entryPoint, GL_INVALID_VALUE, kResourceMaxTextureSize); return false; } break; case TextureType::InvalidEnum: context->validationError(entryPoint, GL_INVALID_ENUM, kEnumInvalid); return false; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, ToGLenum(target)); return false; } if (levels != 1 && !context->getExtensions().textureNpotOES) { if (!isPow2(width) || !isPow2(height)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kDimensionsMustBePow2); return false; } } if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions() { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFormat); return false; } // Even with OES_texture_npot, some compressed formats may impose extra restrictions. if (formatInfo.compressed) { if (!ValidCompressedImageSize(context, formatInfo.internalFormat, 0, width, height, 1) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidCompressedImageS return false; } } switch (internalformat) { case GL_DEPTH_COMPONENT16: case GL_DEPTH_COMPONENT32_OES: switch (target) { case TextureType::_2D: break; case TextureType::CubeMap: if (!context->getExtensions().depthTextureCubeMapOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget); return false; } // ANGLE_depth_texture only supports 1-level textures if (!context->getExtensions().depthTextureOES) { if (levels != 1) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevels); return false; } } break; case GL_DEPTH24_STENCIL8_OES: switch (target) { case TextureType::_2D: break; case TextureType::CubeMap: if (!context->getExtensions().depthTextureCubeMapOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget); return false; } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget); return false; } if (!context->getExtensions().packedDepthStencilOES && !context->getExtensions().depthTextureCubeMapOES) { // ANGLE_depth_texture only supports 1-level textures if (levels != 1) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidMipLevels); return false; } } break; default: break; } Texture *texture = context->getTextureByType(target); if (!texture || texture->id().value == 0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMissingTexture); return false; } if (texture->getImmutableFormat()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureIsImmutable); return false; } return true; } bool ValidateDiscardFramebufferEXT(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLsizei numAttachments, const GLenum *attachments) { if (!context->getExtensions().discardFramebufferEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } bool defaultFramebuffer = false; switch (target) { case GL_FRAMEBUFFER: defaultFramebuffer = (context->getState().getTargetFramebuffer(GL_FRAMEBUFFER)->isDefault()); break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget); return false; } return ValidateDiscardFramebufferBase(context, entryPoint, target, numAttachments, at defaultFramebuffer); } bool ValidateBindVertexArrayOES(const Context *context, angle::EntryPoint entryPoint, VertexArrayID array) { if (!context->getExtensions().vertexArrayObjectOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateBindVertexArrayBase(context, entryPoint, array); } bool ValidateDeleteVertexArraysOES(const Context *context, angle::EntryPoint entryPoint, GLsizei n, const VertexArrayID *arrays) { if (!context->getExtensions().vertexArrayObjectOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateGenVertexArraysOES(const Context *context, angle::EntryPoint entryPoint, GLsizei n, const VertexArrayID *arrays) { if (!context->getExtensions().vertexArrayObjectOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateIsVertexArrayOES(const Context *context, angle::EntryPoint entryPoint, VertexArrayID array) { if (!context->getExtensions().vertexArrayObjectOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return true; } bool ValidateProgramBinaryOES(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLenum binaryFormat, const void *binary, GLint length) { if (!context->getExtensions().getProgramBinaryOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateProgramBinaryBase(context, entryPoint, program, binaryFormat, binary, l } bool ValidateGetProgramBinaryOES(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLsizei bufSize, const GLsizei *length, const GLenum *binaryFormat, const void *binary) { if (!context->getExtensions().getProgramBinaryOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateGetProgramBinaryBase(context, entryPoint, program, bufSize, length, bin binary); } static bool ValidDebugSource(GLenum source, bool mustBeThirdPartyOrApplication) { switch (source) { case GL_DEBUG_SOURCE_API: case GL_DEBUG_SOURCE_SHADER_COMPILER: case GL_DEBUG_SOURCE_WINDOW_SYSTEM: case GL_DEBUG_SOURCE_OTHER: // Only THIRD_PARTY and APPLICATION sources are allowed to be manually inserted return !mustBeThirdPartyOrApplication; case GL_DEBUG_SOURCE_THIRD_PARTY: case GL_DEBUG_SOURCE_APPLICATION: return true; default: return false; } } static bool ValidDebugType(GLenum type) { switch (type) { case GL_DEBUG_TYPE_ERROR: case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: case GL_DEBUG_TYPE_PERFORMANCE: case GL_DEBUG_TYPE_PORTABILITY: case GL_DEBUG_TYPE_OTHER: case GL_DEBUG_TYPE_MARKER: case GL_DEBUG_TYPE_PUSH_GROUP: case GL_DEBUG_TYPE_POP_GROUP: return true; default: return false; } } static bool ValidDebugSeverity(GLenum severity) { switch (severity) { case GL_DEBUG_SEVERITY_HIGH: case GL_DEBUG_SEVERITY_MEDIUM: case GL_DEBUG_SEVERITY_LOW: case GL_DEBUG_SEVERITY_NOTIFICATION: return true; default: return false; } } bool ValidateDebugMessageControlKHR(const Context *context, angle::EntryPoint entryPoint, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!ValidDebugSource(source, false) && source != GL_DONT_CARE) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource); return false; } if (!ValidDebugType(type) && type != GL_DONT_CARE) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugType); return false; } if (!ValidDebugSeverity(severity) && severity != GL_DONT_CARE) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSeverity); return false; } if (count > 0) { if (source == GL_DONT_CARE || type == GL_DONT_CARE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDebugSourceType) return false; } if (severity != GL_DONT_CARE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDebugSeverity); return false; } } return true; } bool ValidateDebugMessageInsertKHR(const Context *context, angle::EntryPoint entryPoint, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!context->getState().getDebug().isOutputEnabled()) { // If the DEBUG_OUTPUT state is disabled calls to DebugMessageInsert are discarded and do // not generate an error. return false; } if (!ValidDebugSeverity(severity)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource); return false; } if (!ValidDebugType(type)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugType); return false; } if (!ValidDebugSource(source, true)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource); return false; } size_t messageLength = (length < 0) ? strlen(buf) : length; if (messageLength > context->getCaps().maxDebugMessageLength) { context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDebugMessageLengt return false; } return true; } bool ValidateDebugMessageCallbackKHR(const Context *context, angle::EntryPoint entryPoint, GLDEBUGPROCKHR callback, const void *userParam) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return true; } bool ValidateGetDebugMessageLogKHR(const Context *context, angle::EntryPoint entryPoint, GLuint count, GLsizei bufSize, const GLenum *sources, const GLenum *types, const GLuint *ids, const GLenum *severities, const GLsizei *lengths, const GLchar *messageLog) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (bufSize < 0 && messageLog != nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } return true; } bool ValidatePushDebugGroupKHR(const Context *context, angle::EntryPoint entryPoint, GLenum source, GLuint id, GLsizei length, const GLchar *message) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!ValidDebugSource(source, true)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidDebugSource); return false; } size_t messageLength = (length < 0) ? strlen(message) : length; if (messageLength > context->getCaps().maxDebugMessageLength) { context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxDebugMessageLengt return false; } size_t currentStackSize = context->getState().getDebug().getGroupStackDepth(); if (currentStackSize >= context->getCaps().maxDebugGroupStackDepth) { context->validationError(entryPoint, GL_STACK_OVERFLOW, kExceedsMaxDebugGroupStackD return false; } return true; } bool ValidatePopDebugGroupKHR(const Context *context, angle::EntryPoint entryPoint) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } size_t currentStackSize = context->getState().getDebug().getGroupStackDepth(); if (currentStackSize <= 1) { context->validationError(entryPoint, GL_STACK_UNDERFLOW, kCannotPopDefaultDebugGrou return false; } return true; } static bool ValidateObjectIdentifierAndName(const Context *context, angle::EntryPoint entryPoint, GLenum identifier, GLuint name) { switch (identifier) { case GL_BUFFER: if (context->getBuffer({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBufferName); return false; } return true; case GL_SHADER: if (context->getShader({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidShaderName); return false; } return true; case GL_PROGRAM: if (context->getProgramNoResolveLink({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramName); return false; } return true; case GL_VERTEX_ARRAY: if (context->getVertexArray({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidVertexArrayName); return false; } return true; case GL_QUERY: if (context->getQuery({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidQueryName); return false; } return true; case GL_TRANSFORM_FEEDBACK: if (context->getTransformFeedback({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTransformFeedbackName); return false; } return true; case GL_SAMPLER: if (context->getSampler({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSamplerName); return false; } return true; case GL_TEXTURE: if (context->getTexture({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidTextureName); return false; } return true; case GL_RENDERBUFFER: if (!context->isRenderbuffer({name})) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidRenderbufferName); return false; } return true; case GL_FRAMEBUFFER: if (context->getFramebuffer({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferName); return false; } return true; case GL_PROGRAM_PIPELINE: if (context->getProgramPipeline({name}) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramPipelineName) return false; } return true; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidIndentifier); return false; } } static bool ValidateLabelLength(const Context *context, angle::EntryPoint entryPoint, GLsizei length, const GLchar *label) { size_t labelLength = 0; if (length < 0) { if (label != nullptr) { labelLength = strlen(label); } } else { labelLength = static_cast<size_t>(length); } if (labelLength > context->getCaps().maxLabelLength) { context->validationError(entryPoint, GL_INVALID_VALUE, kExceedsMaxLabelLength); return false; } return true; } bool ValidateObjectLabelKHR(const Context *context, angle::EntryPoint entryPoint, GLenum identifier, GLuint name, GLsizei length, const GLchar *label) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!ValidateObjectIdentifierAndName(context, entryPoint, identifier, name)) { return false; } if (!ValidateLabelLength(context, entryPoint, length, label)) { return false; } return true; } bool ValidateGetObjectLabelKHR(const Context *context, angle::EntryPoint entryPoint, GLenum identifier, GLuint name, GLsizei bufSize, const GLsizei *length, const GLchar *label) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (bufSize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } if (!ValidateObjectIdentifierAndName(context, entryPoint, identifier, name)) { return false; } return true; } static bool ValidateObjectPtrName(const Context *context, angle::EntryPoint entryPoint, const void *ptr) { if (context->getSync(reinterpret_cast<GLsync>(const_cast<void *>(ptr))) == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSyncPointer); return false; } return true; } bool ValidateObjectPtrLabelKHR(const Context *context, angle::EntryPoint entryPoint, const void *ptr, GLsizei length, const GLchar *label) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!ValidateObjectPtrName(context, entryPoint, ptr)) { return false; } if (!ValidateLabelLength(context, entryPoint, length, label)) { return false; } return true; } bool ValidateGetObjectPtrLabelKHR(const Context *context, angle::EntryPoint entryPoint, const void *ptr, GLsizei bufSize, const GLsizei *length, const GLchar *label) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (bufSize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } if (!ValidateObjectPtrName(context, entryPoint, ptr)) { return false; } return true; } bool ValidateGetPointervKHR(const Context *context, angle::EntryPoint entryPoint, GLenum pname, void *const *params) { if (!context->getExtensions().debugKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } // TODO: represent this in Context::getQueryParameterInfo. switch (pname) { case GL_DEBUG_CALLBACK_FUNCTION: case GL_DEBUG_CALLBACK_USER_PARAM: break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname); return false; } return true; } bool ValidateGetPointervRobustANGLERobustANGLE(const Context *context, angle::EntryPoint entryPoint, GLenum pname, GLsizei bufSize, const GLsizei *length, void *const *params) { UNIMPLEMENTED(); return false; } bool ValidateBlitFramebufferANGLE(const Context *context, angle::EntryPoint entryPoint, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { if (!context->getExtensions().framebufferBlitANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionNotAvailab return false; } if (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0) { // TODO(jmadill): Determine if this should be available on other implementations. context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionScaleOrFli return false; } if (filter == GL_LINEAR) { context->validationError(entryPoint, GL_INVALID_ENUM, kBlitExtensionLinear); return false; } Framebuffer *readFramebuffer = context->getState().getReadFramebuffer(); Framebuffer *drawFramebuffer = context->getState().getDrawFramebuffer(); if (mask & GL_COLOR_BUFFER_BIT) { const FramebufferAttachment *readColorAttachment = readFramebuffer->getReadColorAttachment(); const FramebufferAttachment *drawColorAttachment = drawFramebuffer->getFirstColorAttachment(); if (readColorAttachment && drawColorAttachment) { if (!(readColorAttachment->type() == GL_TEXTURE && (readColorAttachment->getTextureImageIndex().getType() == TextureType::_2D || readColorAttachment->getTextureImageIndex().getType() == TextureType::Rectangle)) && readColorAttachment->type() != GL_RENDERBUFFER && readColorAttachment->type() != GL_FRAMEBUFFER_DEFAULT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionFromInvalidAttachmentType); return false; } for (size_t drawbufferIdx = 0; drawbufferIdx < drawFramebuffer->getDrawbufferStateCount(); ++drawbufferIdx) { const FramebufferAttachment *attachment = drawFramebuffer->getDrawBuffer(drawbufferIdx); if (attachment) { if (!(attachment->type() == GL_TEXTURE && (attachment->getTextureImageIndex().getType() == TextureType::_2D || attachment->getTextureImageIndex().getType() == TextureType::Rectangle)) && attachment->type() != GL_RENDERBUFFER && attachment->type() != GL_FRAMEBUFFER_DEFAULT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionToInvalidAttachmentType); return false; } // Return an error if the destination formats do not match if (!Format::EquivalentForBlit(attachment->getFormat(), readColorAttachment->getFormat())) { context->validationErrorF( entryPoint, GL_INVALID_OPERATION, kBlitExtensionFormatMismatch, readColorAttachment->getFormat().info->sizedInternalFormat, attachment->getFormat().info->sizedInternalFormat); return false; } } } GLint samples = readFramebuffer->getSamples(context); if (samples != 0 && IsPartialBlit(context, readColorAttachment, drawColorAttachment, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionMultisampledWholeBufferBlit); 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 (IsPartialBlit(context, readBuffer, drawBuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1)) { // only whole-buffer copies are permitted context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionDepthStencilWholeBufferBlit); return false; } if (readBuffer->getResourceSamples() != 0 || drawBuffer->getResourceSamples() != 0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionMultisampledDepthOrStencil); return false; } } } } return ValidateBlitFramebufferParameters(context, entryPoint, srcX0, srcY0, srcX1, src dstY0, dstX1, dstY1, mask, filter); } bool ValidateBlitFramebufferNV(const Context *context, angle::EntryPoint entryPoint, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { if (!context->getExtensions().framebufferBlitANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBlitExtensionNotAvailab return false; } return ValidateBlitFramebufferParameters(context, entryPoint, srcX0, srcY0, srcX1, src dstY0, dstX1, dstY1, mask, filter); } bool ValidateClear(const Context *context, angle::EntryPoint entryPoint, GLbitfield mas { Framebuffer *fbo = context->getState().getDrawFramebuffer(); const Extensions &extensions = context->getExtensions(); if (!ValidateFramebufferComplete(context, entryPoint, fbo)) { return false; } if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidClearMask); return false; } if (extensions.webglCompatibilityANGLE && (mask & GL_COLOR_BUFFER_BIT) != 0) { constexpr GLenum validComponentTypes[] = {GL_FLOAT, GL_UNSIGNED_NORMALIZED, GL_SIGNED_NORMALIZED}; for (GLuint drawBufferIdx = 0; drawBufferIdx < fbo->getDrawbufferStateCount(); drawBufferIdx++) { if (!ValidateWebGLFramebufferAttachmentClearType(context, entryPoint, drawBufferIdx validComponentTypes, ArraySize(validComponentTypes))) { return false; } } } if ((extensions.multiviewOVR || extensions.multiview2OVR) && extensions.disjointTimerQu { const State &state = context->getState(); Framebuffer *framebuffer = state.getDrawFramebuffer(); if (framebuffer->getNumViews() > 1 && state.isQueryActive(QueryType::TimeElapsed)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMultiviewTimerQuery); return false; } } return true; } bool ValidateDrawBuffersEXT(const Context *context, angle::EntryPoint entryPoint, GLsizei n, const GLenum *bufs) { if (!context->getExtensions().drawBuffersEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateDrawBuffersBase(context, entryPoint, n, bufs); } bool ValidateTexImage2D(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) { if (context->getClientMajorVersion() < 3) { return ValidateES2TexImageParameters(context, entryPoint, target, level, internalform false, false, 0, 0, width, height, border, format, type, -1, pixels); } ASSERT(context->getClientMajorVersion() >= 3); return ValidateES3TexImage2DParameters(context, entryPoint, target, level, internalfo false, false, 0, 0, 0, width, height, 1, border, format, type, -1, pixels); } bool ValidateTexImage2DRobustANGLE(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLsizei bufSize, const void *pixels) { if (!ValidateRobustEntryPoint(context, entryPoint, bufSize)) { return false; } if (context->getClientMajorVersion() < 3) { return ValidateES2TexImageParameters(context, entryPoint, target, level, internalform false, false, 0, 0, width, height, border, format, type, bufSize, pixels); } ASSERT(context->getClientMajorVersion() >= 3); return ValidateES3TexImage2DParameters(context, entryPoint, target, level, internalfo false, false, 0, 0, 0, width, height, 1, border, format, type, bufSize, pixels); } bool ValidateTexSubImage2D(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { if (context->getClientMajorVersion() < 3) { return ValidateES2TexImageParameters(context, entryPoint, target, level, GL_NONE, fals true, xoffset, yoffset, width, height, 0, format, type, -1, pixels); } ASSERT(context->getClientMajorVersion() >= 3); return ValidateES3TexImage2DParameters(context, entryPoint, target, level, GL_NONE, fa xoffset, yoffset, 0, width, height, 1, 0, format, type, -1, pixels); } bool ValidateTexSubImage2DRobustANGLE(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, const void *pixels) { if (!ValidateRobustEntryPoint(context, entryPoint, bufSize)) { return false; } if (context->getClientMajorVersion() < 3) { return ValidateES2TexImageParameters(context, entryPoint, target, level, GL_NONE, fals true, xoffset, yoffset, width, height, 0, format, type, bufSize, pixels); } ASSERT(context->getClientMajorVersion() >= 3); return ValidateES3TexImage2DParameters(context, entryPoint, target, level, GL_NONE, fa xoffset, yoffset, 0, width, height, 1, 0, format, type, bufSize, pixels); } bool ValidateTexSubImage3DOES(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) { return ValidateTexSubImage3D(context, entryPoint, target, level, xoffset, yoffset, zoff width, height, depth, format, type, pixels); } bool ValidateCompressedTexImage2D(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) { if (context->getClientMajorVersion() < 3) { if (!ValidateES2TexImageParameters(context, entryPoint, target, level, internalformat false, 0, 0, width, height, border, GL_NONE, GL_NONE, -1, data)) { return false; } } else { ASSERT(context->getClientMajorVersion() >= 3); if (!ValidateES3TexImage2DParameters(context, entryPoint, target, level, internalform true, false, 0, 0, 0, width, height, 1, border, GL_NONE, GL_NONE, -1, data)) { return false; } } const InternalFormat &formatInfo = GetSizedInternalFormatInfo(internalformat); GLuint expectedImageSize = 0; if (!formatInfo.computeCompressedImageSize(Extents(width, height, 1), &expectedImageSize)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow); return false; } if (imageSize < 0 || static_cast<GLuint>(imageSize) != expectedImageSize) { context->validationError(entryPoint, GL_INVALID_VALUE, kCompressedTextureDimensionsMustMatchData); return false; } if (target == TextureTarget::Rectangle) { context->validationError(entryPoint, GL_INVALID_ENUM, kRectangleTextureCompressed); return false; } return true; } bool ValidateCompressedTexImage2DRobustANGLE(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLsizei dataSize, const void *data) { if (!ValidateRobustCompressedTexImageBase(context, entryPoint, imageSize, dataSize)) { return false; } return ValidateCompressedTexImage2D(context, entryPoint, target, level, internalforma height, border, imageSize, data); } bool ValidateCompressedTexImage3DOES(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) { return ValidateCompressedTexImage3D(context, entryPoint, target, level, internalforma height, depth, border, imageSize, data); } bool ValidateCompressedTexSubImage2DRobustANGLE(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLsizei dataSize, const void *data) { if (!ValidateRobustCompressedTexImageBase(context, entryPoint, imageSize, dataSize)) { return false; } return ValidateCompressedTexSubImage2D(context, entryPoint, target, level, xoffset, yo width, height, format, imageSize, data); } bool ValidateCompressedTexSubImage2D(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) { if (context->getClientMajorVersion() < 3) { if (!ValidateES2TexImageParameters(context, entryPoint, target, level, GL_NONE, true, t xoffset, yoffset, width, height, 0, format, GL_NONE, -1, data)) { return false; } } else { ASSERT(context->getClientMajorVersion() >= 3); if (!ValidateES3TexImage2DParameters(context, entryPoint, target, level, GL_NONE, true true, xoffset, yoffset, 0, width, height, 1, 0, format, GL_NONE, -1, data)) { return false; } } const InternalFormat &formatInfo = GetSizedInternalFormatInfo(format); GLuint blockSize = 0; if (!formatInfo.computeCompressedImageSize(Extents(width, height, 1), &blockSize)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kIntegerOverflow); return false; } if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSize) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidCompressedImageSize) return false; } return true; } bool ValidateCompressedTexSubImage3DOES(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) { return ValidateCompressedTexSubImage3D(context, entryPoint, target, level, xoffset, yo zoffset, width, height, depth, format, imageSize, data); } bool ValidateGetBufferPointervOES(const Context *context, angle::EntryPoint entryPoint, BufferBinding target, GLenum pname, void *const *params) { if (!context->getExtensions().mapbufferOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateGetBufferPointervBase(context, entryPoint, target, pname, nullptr, para } bool ValidateMapBufferOES(const Context *context, angle::EntryPoint entryPoint, BufferBinding target, GLenum access) { if (!context->getExtensions().mapbufferOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!context->isValidBufferBinding(target)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes); return false; } Buffer *buffer = context->getState().getTargetBuffer(target); if (buffer == nullptr) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotMappable); return false; } if (access != GL_WRITE_ONLY_OES) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAccessBits); return false; } // Though there is no explicit mention of an interaction between GL_EXT_buffer_storage // and GL_OES_mapbuffer extension, allow it as long as the access type of glmapbufferOES // is compatible with the buffer's usage flags specified during glBufferStorageEXT if (buffer->isImmutable() && (buffer->getStorageExtUsageFlags() & GL_MAP_WRITE_BIT) == { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotMappable); return false; } if (buffer->isMapped()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferAlreadyMapped); return false; } return ValidateMapBufferBase(context, entryPoint, target); } bool ValidateUnmapBufferOES(const Context *context, angle::EntryPoint entryPoint, BufferBinding target) { if (!context->getExtensions().mapbufferOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateUnmapBufferBase(context, entryPoint, target); } bool ValidateMapBufferRangeEXT(const Context *context, angle::EntryPoint entryPoint, BufferBinding target, GLintptr offset, GLsizeiptr length, GLbitfield access) { if (!context->getExtensions().mapBufferRangeEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateMapBufferRangeBase(context, entryPoint, target, offset, length, access) } bool ValidateMapBufferBase(const Context *context, angle::EntryPoint entryPoint, BufferBinding target) { Buffer *buffer = context->getState().getTargetBuffer(target); ASSERT(buffer != nullptr); // Check if this buffer is currently being used as a transform feedback output buffer if (context->getState().isTransformFeedbackActive()) { TransformFeedback *transformFeedback = context->getState().getCurrentTransformFeedba for (size_t i = 0; i < transformFeedback->getIndexedBufferCount(); i++) { const auto &transformFeedbackBuffer = transformFeedback->getIndexedBuffer(i); if (transformFeedbackBuffer.get() == buffer) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferBoundForTransformFeedback); return false; } } } if (buffer->hasWebGLXFBBindingConflict(context->isWebGL())) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferBoundForTransformFeedback); return false; } return true; } bool ValidateFlushMappedBufferRangeEXT(const Context *context, angle::EntryPoint entryPoint, BufferBinding target, GLintptr offset, GLsizeiptr length) { if (!context->getExtensions().mapBufferRangeEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateFlushMappedBufferRangeBase(context, entryPoint, target, offset, length } bool ValidateBindUniformLocationCHROMIUM(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, UniformLocation location, const GLchar *name) { if (!context->getExtensions().bindUniformLocationCHROMIUM) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } if (location.value < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeLocation); return false; } const Caps &caps = context->getCaps(); if (static_cast<long>(location.value) >= (caps.maxVertexUniformVectors + caps.maxFragmentUniformVectors) * 4) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidBindUniformLocation) return false; } // The WebGL spec (section 6.20) disallows strings containing invalid ESSL characters for // shader-related entry points if (context->isWebGL() && !IsValidESSLString(name, strlen(name))) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters); return false; } if (strncmp(name, "gl_", 3) == 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNameBeginsWithGL); return false; } return true; } bool ValidateCoverageModulationCHROMIUM(const Context *context, angle::EntryPoint entryPoint, GLenum components) { if (!context->getExtensions().framebufferMixedSamplesCHROMIUM) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } switch (components) { case GL_RGB: case GL_RGBA: case GL_ALPHA: case GL_NONE: break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCoverageComponents); return false; } return true; } bool ValidateCopyTextureCHROMIUM(const Context *context, angle::EntryPoint entryPoint, TextureID sourceId, GLint sourceLevel, TextureTarget destTarget, TextureID destId, GLint destLevel, GLint internalFormat, GLenum destType, GLboolean unpackFlipY, GLboolean unpackPremultiplyAlpha, GLboolean unpackUnmultiplyAlpha) { if (!context->getExtensions().copyTextureCHROMIUM) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } const Texture *source = context->getTexture(sourceId); if (source == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture); return false; } if (!IsValidCopyTextureSourceTarget(context, source->getType())) { context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat); return false; } TextureType sourceType = source->getType(); ASSERT(sourceType != TextureType::CubeMap); TextureTarget sourceTarget = NonCubeTextureTypeToTarget(sourceType); if (!IsValidCopyTextureSourceLevel(context, sourceType, sourceLevel)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureLevel); return false; } GLsizei sourceWidth = static_cast<GLsizei>(source->getWidth(sourceTarget, sourceLevel)) GLsizei sourceHeight = static_cast<GLsizei>(source->getHeight(sourceTarget, sourceLevel if (sourceWidth == 0 || sourceHeight == 0) { context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat, internalFormat); return false; } const InternalFormat &sourceFormat = *source->getFormat(sourceTarget, sourceLevel).info; if (!IsValidCopyTextureSourceInternalFormatEnum(sourceFormat.internalFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidSourceTextureInternalFormat); return false; } if (!IsValidCopyTextureDestinationTargetEnum(context, destTarget)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } const Texture *dest = context->getTexture(destId); if (dest == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture); return false; } const InternalFormat &destInternalFormatInfo = GetInternalFormatInfo(internalFormat, destType); if (sourceType == TextureType::External && destInternalFormatInfo.isInt() && !context->getExtensions().EGLImageExternalEssl3OES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kANGLECopyTextureMissingRequiredExtension); return false; } if (!IsValidCopyTextureDestinationTarget(context, dest->getType(), destTarget)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureTy return false; } if (!IsValidCopyTextureDestinationLevel(context, entryPoint, dest->getType(), destLev sourceWidth, sourceHeight, false)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (!IsValidCopyTextureDestinationFormatType(context, entryPoint, internalFormat, de { return false; } if (dest->getType() == TextureType::CubeMap && sourceWidth != sourceHeight) { context->validationError(entryPoint, GL_INVALID_VALUE, kCubemapFacesEqualDimensions return false; } if (dest->getImmutableFormat()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationImmutable); return false; } return true; } bool ValidateCopySubTextureCHROMIUM(const Context *context, angle::EntryPoint entryPoint, TextureID sourceId, GLint sourceLevel, TextureTarget destTarget, TextureID destId, GLint destLevel, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLboolean unpackFlipY, GLboolean unpackPremultiplyAlpha, GLboolean unpackUnmultiplyAlpha) { if (!context->getExtensions().copyTextureCHROMIUM) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } const Texture *source = context->getTexture(sourceId); if (source == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture); return false; } if (!IsValidCopyTextureSourceTarget(context, source->getType())) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureType); return false; } TextureType sourceType = source->getType(); ASSERT(sourceType != TextureType::CubeMap); TextureTarget sourceTarget = NonCubeTextureTypeToTarget(sourceType); if (!IsValidCopyTextureSourceLevel(context, sourceType, sourceLevel)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (source->getWidth(sourceTarget, sourceLevel) == 0 || source->getHeight(sourceTarget, sourceLevel) == 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureLevel); return false; } if (x < 0 || y < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset); return false; } if (width < 0 || height < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize); return false; } if (static_cast<size_t>(x + width) > source->getWidth(sourceTarget, sourceLevel) || static_cast<size_t>(y + height) > source->getHeight(sourceTarget, sourceLevel)) { context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureTooSmall); return false; } const Format &sourceFormat = source->getFormat(sourceTarget, sourceLevel); if (!IsValidCopySubTextureSourceInternalFormat(sourceFormat.info->internalFormat)) { context->validationErrorF(entryPoint, GL_INVALID_OPERATION, kInvalidInternalFormat, sourceFormat.info->internalFormat); return false; } if (!IsValidCopyTextureDestinationTargetEnum(context, destTarget)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } const Texture *dest = context->getTexture(destId); if (dest == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture); return false; } if (!IsValidCopyTextureDestinationTarget(context, dest->getType(), destTarget)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureTy return false; } if (!IsValidCopyTextureDestinationLevel(context, entryPoint, dest->getType(), destLev height, true)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (dest->getWidth(destTarget, destLevel) == 0 || dest->getHeight(destTarget, destLevel) = { context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationLevelNotDefi return false; } const InternalFormat &destFormat = *dest->getFormat(destTarget, destLevel).info; if (!IsValidCopySubTextureDestionationInternalFormat(destFormat.internalFormat)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFormatCombinatio return false; } if (sourceType == TextureType::External && destFormat.isInt() && !context->getExtensions().EGLImageExternalEssl3OES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kANGLECopyTextureMissingRequiredExtension); return false; } if (xoffset < 0 || yoffset < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset); return false; } if (static_cast<size_t>(xoffset + width) > dest->getWidth(destTarget, destLevel) || static_cast<size_t>(yoffset + height) > dest->getHeight(destTarget, destLevel)) { context->validationError(entryPoint, GL_INVALID_VALUE, kOffsetOverflow); return false; } return true; } bool ValidateCompressedCopyTextureCHROMIUM(const Context *context, angle::EntryPoint entryPoint, TextureID sourceId, TextureID destId) { if (!context->getExtensions().copyCompressedTextureCHROMIUM) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } const Texture *source = context->getTexture(sourceId); if (source == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTexture); return false; } if (source->getType() != TextureType::_2D) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidSourceTextureType); return false; } if (source->getWidth(TextureTarget::_2D, 0) == 0 || source->getHeight(TextureTarget::_2D, 0) == 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kSourceTextureLevelZeroDefin return false; } const Format &sourceFormat = source->getFormat(TextureTarget::_2D, 0); if (!sourceFormat.info->compressed) { context->validationError(entryPoint, GL_INVALID_OPERATION, kSourceTextureMustBeComp return false; } const Texture *dest = context->getTexture(destId); if (dest == nullptr) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTexture); return false; } if (dest->getType() != TextureType::_2D) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidDestinationTextureTy return false; } if (dest->getImmutableFormat()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kDestinationImmutable); return false; } return true; } bool ValidateCreateShader(const Context *context, angle::EntryPoint entryPoint, Shader { switch (type) { case ShaderType::Vertex: case ShaderType::Fragment: break; case ShaderType::Compute: if (context->getClientVersion() < ES_3_1) { context->validationError(entryPoint, GL_INVALID_ENUM, kES31Required); return false; } break; case ShaderType::Geometry: if (!context->getExtensions().geometryShaderAny() && context->getClientVersion() < ES_3_2) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType); return false; } break; case ShaderType::TessControl: if (!context->getExtensions().tessellationShaderEXT && context->getClientVersion() < ES_3_2) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType); return false; } break; case ShaderType::TessEvaluation: if (!context->getExtensions().tessellationShaderEXT && context->getClientVersion() < ES_3_2) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType); return false; } break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType); return false; } return true; } bool ValidateBufferData(const Context *context, angle::EntryPoint entryPoint, BufferBinding target, GLsizeiptr size, const void *data, BufferUsage usage) { if (size < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize); return false; } switch (usage) { case BufferUsage::StreamDraw: case BufferUsage::StaticDraw: case BufferUsage::DynamicDraw: break; case BufferUsage::StreamRead: case BufferUsage::StaticRead: case BufferUsage::DynamicRead: case BufferUsage::StreamCopy: case BufferUsage::StaticCopy: case BufferUsage::DynamicCopy: if (context->getClientMajorVersion() < 3) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferUsage); return false; } break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferUsage); return false; } if (!context->isValidBufferBinding(target)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes); return false; } Buffer *buffer = context->getState().getTargetBuffer(target); if (!buffer) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound); return false; } if (buffer->hasWebGLXFBBindingConflict(context->isWebGL())) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferBoundForTransformFeedback); return false; } if (buffer->isImmutable()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferImmutable); return false; } return true; } bool ValidateBufferSubData(const Context *context, angle::EntryPoint entryPoint, BufferBinding target, GLintptr offset, GLsizeiptr size, const void *data) { if (size < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize); return false; } if (offset < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeOffset); return false; } if (!context->isValidBufferBinding(target)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBufferTypes); return false; } Buffer *buffer = context->getState().getTargetBuffer(target); if (!buffer) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotBound); return false; } // EXT_buffer_storage allows persistently mapped buffers to be updated via glBufferSubData bool isPersistent = (buffer->getAccessFlags() & GL_MAP_PERSISTENT_BIT_EXT) != 0; // Verify that buffer is not currently mapped unless persistent if (buffer->isMapped() && !isPersistent) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferMapped); return false; } if (buffer->hasWebGLXFBBindingConflict(context->isWebGL())) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferBoundForTransformFeedback); return false; } if (buffer->isImmutable() && (buffer->getStorageExtUsageFlags() & GL_DYNAMIC_STORAGE_BIT_EXT) == 0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kBufferNotUpdatable); return false; } // Check for possible overflow of size + offset angle::CheckedNumeric<decltype(size + offset)> checkedSize(size); checkedSize += offset; if (!checkedSize.IsValid()) { context->validationError(entryPoint, GL_INVALID_VALUE, kParamOverflow); return false; } if (size + offset > buffer->getSize()) { context->validationError(entryPoint, GL_INVALID_VALUE, kInsufficientBufferSize); return false; } return true; } bool ValidateRequestExtensionANGLE(const Context *context, angle::EntryPoint entryPoint, const GLchar *name) { if (!context->getExtensions().requestExtensionANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!context->isExtensionRequestable(name)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotRequestable return false; } return true; } bool ValidateDisableExtensionANGLE(const Context *context, angle::EntryPoint entryPoint, const GLchar *name) { if (!context->getExtensions().requestExtensionANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!context->isExtensionDisablable(name)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotDisablable) return false; } return true; } bool ValidateActiveTexture(const Context *context, angle::EntryPoint entryPoint, GLenu { if (context->getClientMajorVersion() < 2) { return ValidateMultitextureUnit(context, entryPoint, texture); } if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0 + static_cast<GLuint>(context->getCaps().maxCombinedTextureImageUnits) - 1) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCombinedImageUnit); return false; } return true; } bool ValidateAttachShader(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, ShaderProgramID shader) { Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } Shader *shaderObject = GetValidShader(context, entryPoint, shader); if (!shaderObject) { return false; } if (programObject->getAttachedShader(shaderObject->getType())) { context->validationError(entryPoint, GL_INVALID_OPERATION, kShaderAttachmentHasShad return false; } return true; } bool ValidateBindAttribLocation(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLuint index, const GLchar *name) { if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes)) { context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttrib return false; } if (strncmp(name, "gl_", 3) == 0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNameBeginsWithGL); return false; } if (context->isWebGL()) { const size_t length = strlen(name); if (!IsValidESSLString(name, length)) { // The WebGL spec (section 6.20) disallows strings containing invalid ESSL characters // for shader-related entry points context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters); return false; } if (!ValidateWebGLNameLength(context, entryPoint, length) || !ValidateWebGLNamePrefix(context, entryPoint, name)) { return false; } } return GetValidProgram(context, entryPoint, program) != nullptr; } bool ValidateBindFramebuffer(const Context *context, angle::EntryPoint entryPoint, GLenum target, FramebufferID framebuffer) { return ValidateBindFramebufferBase(context, entryPoint, target, framebuffer); } bool ValidateBindRenderbuffer(const Context *context, angle::EntryPoint entryPoint, GLenum target, RenderbufferID renderbuffer) { return ValidateBindRenderbufferBase(context, entryPoint, target, renderbuffer); } static bool ValidBlendEquationMode(const Context *context, GLenum mode) { switch (mode) { case GL_FUNC_ADD: case GL_FUNC_SUBTRACT: case GL_FUNC_REVERSE_SUBTRACT: return true; case GL_MIN: case GL_MAX: return context->getClientVersion() >= ES_3_0 || context->getExtensions().blendMinmaxEXT; default: return false; } } static bool ValidAdvancedBlendEquationMode(const Context *context, GLenum mode) { switch (mode) { case GL_MULTIPLY_KHR: case GL_SCREEN_KHR: case GL_OVERLAY_KHR: case GL_DARKEN_KHR: case GL_LIGHTEN_KHR: case GL_COLORDODGE_KHR: case GL_COLORBURN_KHR: case GL_HARDLIGHT_KHR: case GL_SOFTLIGHT_KHR: case GL_DIFFERENCE_KHR: case GL_EXCLUSION_KHR: case GL_HSL_HUE_KHR: case GL_HSL_SATURATION_KHR: case GL_HSL_COLOR_KHR: case GL_HSL_LUMINOSITY_KHR: return context->getClientVersion() >= ES_3_2 || context->getExtensions().blendEquationAdvancedKHR; default: return false; } } bool ValidateBlendColor(const Context *context, angle::EntryPoint entryPoint, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { return true; } bool ValidateBlendEquation(const Context *context, angle::EntryPoint entryPoint, GLenu { if (!ValidBlendEquationMode(context, mode) && !ValidAdvancedBlendEquationMode(context, { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation); return false; } return true; } bool ValidateBlendEquationSeparate(const Context *context, angle::EntryPoint entryPoint, GLenum modeRGB, GLenum modeAlpha) { if (!ValidBlendEquationMode(context, modeRGB)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation); return false; } if (!ValidBlendEquationMode(context, modeAlpha)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendEquation); return false; } return true; } bool ValidateBlendFunc(const Context *context, angle::EntryPoint entryPoint, GLenum sfactor, GLenum dfactor) { return ValidateBlendFuncSeparate(context, entryPoint, sfactor, dfactor, sfactor, dfact } bool ValidateBlendFuncSeparate(const Context *context, angle::EntryPoint entryPoint, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { if (!ValidSrcBlendFunc(context, srcRGB)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction); return false; } if (!ValidDstBlendFunc(context, dstRGB)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction); return false; } if (!ValidSrcBlendFunc(context, srcAlpha)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction); return false; } if (!ValidDstBlendFunc(context, dstAlpha)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidBlendFunction); return false; } if (context->getLimitations().noSimultaneousConstantColorAndAlphaBlendFunc || context->isWebGL()) { bool constantColorUsed = (srcRGB == GL_CONSTANT_COLOR || srcRGB == GL_ONE_MINUS_CONSTANT_COLOR || dstRGB == GL_CONSTANT_COLOR || dstRGB == GL_ONE_MINUS_CONSTANT_COLOR); bool constantAlphaUsed = (srcRGB == GL_CONSTANT_ALPHA || srcRGB == GL_ONE_MINUS_CONSTANT_ALPHA || dstRGB == GL_CONSTANT_ALPHA || dstRGB == GL_ONE_MINUS_CONSTANT_ALPHA); if (constantColorUsed && constantAlphaUsed) { if (context->isWebGL()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidConstantColor); return false; } WARN() << kConstantColorAlphaLimitation; context->validationError(entryPoint, GL_INVALID_OPERATION, kConstantColorAlphaLimitation); return false; } } return true; } bool ValidateGetString(const Context *context, angle::EntryPoint entryPoint, GLenum nam { switch (name) { case GL_VENDOR: case GL_RENDERER: case GL_VERSION: case GL_SHADING_LANGUAGE_VERSION: case GL_EXTENSIONS: break; case GL_REQUESTABLE_EXTENSIONS_ANGLE: if (!context->getExtensions().requestExtensionANGLE) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName); return false; } break; case GL_SERIALIZED_CONTEXT_STRING_ANGLE: if (!context->getExtensions().getSerializedContextStringANGLE) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName); return false; } break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidName); return false; } return true; } bool ValidateLineWidth(const Context *context, angle::EntryPoint entryPoint, GLfloat wi { if (width <= 0.0f || isNaN(width)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidWidth); return false; } return true; } bool ValidateDepthRangef(const Context *context, angle::EntryPoint entryPoint, GLfloat zNear, GLfloat zFar) { if (context->isWebGL() && zNear > zFar) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidDepthRange); return false; } return true; } bool ValidateRenderbufferStorage(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum internalformat, GLsizei width, GLsizei height) { return ValidateRenderbufferStorageParametersBase(context, entryPoint, target, 0, inte width, height); } bool ValidateRenderbufferStorageMultisampleANGLE(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { if (!context->getExtensions().framebufferMultisampleANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } // ANGLE_framebuffer_multisample states that the value of samples must be less than or equal // to MAX_SAMPLES_ANGLE (Context::getCaps().maxSamples) otherwise GL_INVALID_VALUE is // generated. if (samples > context->getCaps().maxSamples) { context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesOutOfRange); return false; } // ANGLE_framebuffer_multisample states GL_OUT_OF_MEMORY is generated on a failure to crea // the specified storage. This is different than ES 3.0 in which a sample number higher // than the maximum sample number supported by this format generates a GL_INVALID_VALUE. // The TextureCaps::getMaxSamples method is only guarenteed to be valid when the context is ES if (context->getClientMajorVersion() >= 3) { const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat); if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples()) { context->validationError(entryPoint, GL_OUT_OF_MEMORY, kSamplesOutOfRange); return false; } } return ValidateRenderbufferStorageParametersBase(context, entryPoint, target, sample internalformat, width, height); } bool ValidateCheckFramebufferStatus(const Context *context, angle::EntryPoint entryPoint, GLenum target) { if (!ValidFramebufferTarget(context, target)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFramebufferTarget); return false; } return true; } bool ValidateClearColor(const Context *context, angle::EntryPoint entryPoint, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { return true; } bool ValidateClearDepthf(const Context *context, angle::EntryPoint entryPoint, GLfloat { return true; } bool ValidateClearStencil(const Context *context, angle::EntryPoint entryPoint, GLint s { return true; } bool ValidateColorMask(const Context *context, angle::EntryPoint entryPoint, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) { return true; } bool ValidateCompileShader(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shader) { return true; } bool ValidateCreateProgram(const Context *context, angle::EntryPoint entryPoint) { return true; } bool ValidateCullFace(const Context *context, angle::EntryPoint entryPoint, CullFaceMo { switch (mode) { case CullFaceMode::Front: case CullFaceMode::Back: case CullFaceMode::FrontAndBack: break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidCullMode); return false; } return true; } bool ValidateDeleteProgram(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program) { if (program.value == 0) { return false; } if (!context->getProgramResolveLink(program)) { if (context->getShader(program)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName); return false; } else { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramName); return false; } } return true; } bool ValidateDeleteShader(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shader) { if (shader.value == 0) { return false; } if (!context->getShader(shader)) { if (context->getProgramResolveLink(shader)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidShaderName); return false; } else { context->validationError(entryPoint, GL_INVALID_VALUE, kExpectedShaderName); return false; } } return true; } bool ValidateDepthFunc(const Context *context, angle::EntryPoint entryPoint, GLenum fun { switch (func) { case GL_NEVER: case GL_ALWAYS: case GL_LESS: case GL_LEQUAL: case GL_EQUAL: case GL_GREATER: case GL_GEQUAL: case GL_NOTEQUAL: break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, func); return false; } return true; } bool ValidateDepthMask(const Context *context, angle::EntryPoint entryPoint, GLboolean { return true; } bool ValidateDetachShader(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, ShaderProgramID shader) { Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } Shader *shaderObject = GetValidShader(context, entryPoint, shader); if (!shaderObject) { return false; } const Shader *attachedShader = programObject->getAttachedShader(shaderObject->getType( if (attachedShader != shaderObject) { context->validationError(entryPoint, GL_INVALID_OPERATION, kShaderToDetachMustBeAtt return false; } return true; } bool ValidateDisableVertexAttribArray(const Context *context, angle::EntryPoint entryPoint, GLuint index) { if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes)) { context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttrib return false; } return true; } bool ValidateEnableVertexAttribArray(const Context *context, angle::EntryPoint entryPoint, GLuint index) { if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes)) { context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttrib return false; } return true; } bool ValidateFinish(const Context *context, angle::EntryPoint entryPoint) { return true; } bool ValidateFlush(const Context *context, angle::EntryPoint entryPoint) { return true; } bool ValidateFrontFace(const Context *context, angle::EntryPoint entryPoint, GLenum mod { switch (mode) { case GL_CW: case GL_CCW: break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, mode); return false; } return true; } bool ValidateGetActiveAttrib(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLuint index, GLsizei bufsize, const GLsizei *length, const GLint *size, const GLenum *type, const GLchar *name) { if (bufsize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } if (index >= static_cast<GLuint>(programObject->getActiveAttributeCount())) { context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUnifor return false; } return true; } bool ValidateGetActiveUniform(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLuint index, GLsizei bufsize, const GLsizei *length, const GLint *size, const GLenum *type, const GLchar *name) { if (bufsize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } if (index >= static_cast<GLuint>(programObject->getActiveUniformCount())) { context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxActiveUnifor return false; } return true; } bool ValidateGetAttachedShaders(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLsizei maxcount, const GLsizei *count, const ShaderProgramID *shaders) { if (maxcount < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeMaxCount); return false; } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } return true; } bool ValidateGetAttribLocation(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, const GLchar *name) { if (strncmp(name, "gl_", 3) == 0) { return false; } if (context->isWebGL()) { const size_t length = strlen(name); if (!IsValidESSLString(name, length)) { // The WebGL spec (section 6.20) disallows strings containing invalid ESSL characters // for shader-related entry points context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters); return false; } if (!ValidateWebGLNameLength(context, entryPoint, length) || strncmp(name, "webgl_", 6) == 0 || strncmp(name, "_webgl_", 7) == 0) { return false; } } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotBound); return false; } if (!programObject->isLinked()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked); return false; } return true; } bool ValidateGetBooleanv(const Context *context, angle::EntryPoint entryPoint, GLenum pname, const GLboolean *params) { GLenum nativeType; unsigned int numParams = 0; return ValidateStateQuery(context, entryPoint, pname, &nativeType, &numParams); } bool ValidateGetError(const Context *context, angle::EntryPoint entryPoint) { return true; } bool ValidateGetFloatv(const Context *context, angle::EntryPoint entryPoint, GLenum pname, const GLfloat *params) { GLenum nativeType; unsigned int numParams = 0; return ValidateStateQuery(context, entryPoint, pname, &nativeType, &numParams); } bool ValidateGetIntegerv(const Context *context, angle::EntryPoint entryPoint, GLenum pname, const GLint *params) { GLenum nativeType; unsigned int numParams = 0; return ValidateStateQuery(context, entryPoint, pname, &nativeType, &numParams); } bool ValidateGetProgramInfoLog(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLsizei bufsize, const GLsizei *length, const GLchar *infolog) { if (bufsize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } return true; } bool ValidateGetShaderInfoLog(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shader, GLsizei bufsize, const GLsizei *length, const GLchar *infolog) { if (bufsize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } Shader *shaderObject = GetValidShader(context, entryPoint, shader); if (!shaderObject) { return false; } return true; } bool ValidateGetShaderPrecisionFormat(const Context *context, angle::EntryPoint entryPoint, GLenum shadertype, GLenum precisiontype, const GLint *range, const GLint *precision) { switch (shadertype) { case GL_VERTEX_SHADER: case GL_FRAGMENT_SHADER: break; case GL_COMPUTE_SHADER: context->validationError(entryPoint, GL_INVALID_OPERATION, kUnimplementedComputeShaderPrecision); return false; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderType); return false; } switch (precisiontype) { case GL_LOW_FLOAT: case GL_MEDIUM_FLOAT: case GL_HIGH_FLOAT: case GL_LOW_INT: case GL_MEDIUM_INT: case GL_HIGH_INT: break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPrecision); return false; } return true; } bool ValidateGetShaderSource(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shader, GLsizei bufsize, const GLsizei *length, const GLchar *source) { if (bufsize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } Shader *shaderObject = GetValidShader(context, entryPoint, shader); if (!shaderObject) { return false; } return true; } bool ValidateGetUniformLocation(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, const GLchar *name) { if (strstr(name, "gl_") == name) { return false; } // The WebGL spec (section 6.20) disallows strings containing invalid ESSL characters for // shader-related entry points if (context->isWebGL() && !IsValidESSLString(name, strlen(name))) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidNameCharacters); return false; } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } if (!programObject->isLinked()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked); return false; } return true; } bool ValidateHint(const Context *context, angle::EntryPoint entryPoint, GLenum target, G { switch (mode) { case GL_FASTEST: case GL_NICEST: case GL_DONT_CARE: break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, mode); return false; } switch (target) { case GL_GENERATE_MIPMAP_HINT: break; case GL_TEXTURE_FILTERING_HINT_CHROMIUM: if (!context->getExtensions().textureFilteringHintCHROMIUM) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target); return false; } break; case GL_FRAGMENT_SHADER_DERIVATIVE_HINT: if (context->getClientVersion() < ES_3_0 && !context->getExtensions().standardDerivativesOES) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target); return false; } break; case GL_PERSPECTIVE_CORRECTION_HINT: case GL_POINT_SMOOTH_HINT: case GL_LINE_SMOOTH_HINT: case GL_FOG_HINT: if (context->getClientMajorVersion() >= 2) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target); return false; } break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, target); return false; } return true; } bool ValidateIsBuffer(const Context *context, angle::EntryPoint entryPoint, BufferID bu { return true; } bool ValidateIsFramebuffer(const Context *context, angle::EntryPoint entryPoint, FramebufferID framebuffer) { return true; } bool ValidateIsProgram(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program) { return true; } bool ValidateIsRenderbuffer(const Context *context, angle::EntryPoint entryPoint, RenderbufferID renderbuffer) { return true; } bool ValidateIsShader(const Context *context, angle::EntryPoint entryPoint, ShaderProg { return true; } bool ValidateIsTexture(const Context *context, angle::EntryPoint entryPoint, TextureID { return true; } bool ValidatePixelStorei(const Context *context, angle::EntryPoint entryPoint, GLenum pname, GLint param) { if (context->getClientMajorVersion() < 3) { switch (pname) { case GL_UNPACK_IMAGE_HEIGHT: case GL_UNPACK_SKIP_IMAGES: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname); return false; case GL_UNPACK_ROW_LENGTH: case GL_UNPACK_SKIP_ROWS: case GL_UNPACK_SKIP_PIXELS: if (!context->getExtensions().unpackSubimageEXT) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname); return false; } break; case GL_PACK_ROW_LENGTH: case GL_PACK_SKIP_ROWS: case GL_PACK_SKIP_PIXELS: if (!context->getExtensions().packSubimageNV) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname); return false; } break; } } if (param < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeParam); return false; } switch (pname) { case GL_UNPACK_ALIGNMENT: if (param != 1 && param != 2 && param != 4 && param != 8) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidUnpackAlignment); return false; } break; case GL_PACK_ALIGNMENT: if (param != 1 && param != 2 && param != 4 && param != 8) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidUnpackAlignment); return false; } break; case GL_PACK_REVERSE_ROW_ORDER_ANGLE: if (!context->getExtensions().packReverseRowOrderANGLE) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname); } break; case GL_UNPACK_ROW_LENGTH: case GL_UNPACK_IMAGE_HEIGHT: case GL_UNPACK_SKIP_IMAGES: case GL_UNPACK_SKIP_ROWS: case GL_UNPACK_SKIP_PIXELS: case GL_PACK_ROW_LENGTH: case GL_PACK_SKIP_ROWS: case GL_PACK_SKIP_PIXELS: break; default: context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, pname); return false; } return true; } bool ValidatePolygonOffset(const Context *context, angle::EntryPoint entryPoint, GLfloat factor, GLfloat units) { return true; } bool ValidateReleaseShaderCompiler(const Context *context, angle::EntryPoint entryPoi { return true; } bool ValidateSampleCoverage(const Context *context, angle::EntryPoint entryPoint, GLfloat value, GLboolean invert) { return true; } bool ValidateScissor(const Context *context, angle::EntryPoint entryPoint, GLint x, GLint y, GLsizei width, GLsizei height) { if (width < 0 || height < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeSize); return false; } return true; } bool ValidateShaderBinary(const Context *context, angle::EntryPoint entryPoint, GLsizei n, const ShaderProgramID *shaders, GLenum binaryformat, const void *binary, GLsizei length) { const std::vector<GLenum> &shaderBinaryFormats = context->getCaps().shaderBinaryFormats; if (std::find(shaderBinaryFormats.begin(), shaderBinaryFormats.end(), binaryformat) shaderBinaryFormats.end()) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidShaderBinaryFormat); return false; } return true; } bool ValidateShaderSource(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shader, GLsizei count, const GLchar *const *string, const GLint *length) { if (count < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount); return false; } Shader *shaderObject = GetValidShader(context, entryPoint, shader); if (!shaderObject) { return false; } return true; } bool ValidateStencilFunc(const Context *context, angle::EntryPoint entryPoint, GLenum func, GLint ref, GLuint mask) { if (!IsValidStencilFunc(func)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } return true; } bool ValidateStencilFuncSeparate(const Context *context, angle::EntryPoint entryPoint, GLenum face, GLenum func, GLint ref, GLuint mask) { if (!IsValidStencilFace(face)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } if (!IsValidStencilFunc(func)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } return true; } bool ValidateStencilMask(const Context *context, angle::EntryPoint entryPoint, GLuint m { return true; } bool ValidateStencilMaskSeparate(const Context *context, angle::EntryPoint entryPoint, GLenum face, GLuint mask) { if (!IsValidStencilFace(face)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } return true; } bool ValidateStencilOp(const Context *context, angle::EntryPoint entryPoint, GLenum fail, GLenum zfail, GLenum zpass) { if (!IsValidStencilOp(fail)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } if (!IsValidStencilOp(zfail)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } if (!IsValidStencilOp(zpass)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } return true; } bool ValidateStencilOpSeparate(const Context *context, angle::EntryPoint entryPoint, GLenum face, GLenum fail, GLenum zfail, GLenum zpass) { if (!IsValidStencilFace(face)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidStencil); return false; } return ValidateStencilOp(context, entryPoint, fail, zfail, zpass); } bool ValidateUniform1f(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLfloat x) { return ValidateUniform(context, entryPoint, GL_FLOAT, location, 1); } bool ValidateUniform1fv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, const GLfloat *v) { return ValidateUniform(context, entryPoint, GL_FLOAT, location, count); } bool ValidateUniform1i(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLint x) { return ValidateUniform1iv(context, entryPoint, location, 1, &x); } bool ValidateUniform2fv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, const GLfloat *v) { return ValidateUniform(context, entryPoint, GL_FLOAT_VEC2, location, count); } bool ValidateUniform2i(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLint x, GLint y) { return ValidateUniform(context, entryPoint, GL_INT_VEC2, location, 1); } bool ValidateUniform2iv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, const GLint *v) { return ValidateUniform(context, entryPoint, GL_INT_VEC2, location, count); } bool ValidateUniform3f(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLfloat x, GLfloat y, GLfloat z) { return ValidateUniform(context, entryPoint, GL_FLOAT_VEC3, location, 1); } bool ValidateUniform3fv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, const GLfloat *v) { return ValidateUniform(context, entryPoint, GL_FLOAT_VEC3, location, count); } bool ValidateUniform3i(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLint x, GLint y, GLint z) { return ValidateUniform(context, entryPoint, GL_INT_VEC3, location, 1); } bool ValidateUniform3iv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, const GLint *v) { return ValidateUniform(context, entryPoint, GL_INT_VEC3, location, count); } bool ValidateUniform4f(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { return ValidateUniform(context, entryPoint, GL_FLOAT_VEC4, location, 1); } bool ValidateUniform4fv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, const GLfloat *v) { return ValidateUniform(context, entryPoint, GL_FLOAT_VEC4, location, count); } bool ValidateUniform4i(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLint x, GLint y, GLint z, GLint w) { return ValidateUniform(context, entryPoint, GL_INT_VEC4, location, 1); } bool ValidateUniform4iv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, const GLint *v) { return ValidateUniform(context, entryPoint, GL_INT_VEC4, location, count); } bool ValidateUniformMatrix2fv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, GLboolean transpose, const GLfloat *value) { return ValidateUniformMatrix(context, entryPoint, GL_FLOAT_MAT2, location, count, tran } bool ValidateUniformMatrix3fv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, GLboolean transpose, const GLfloat *value) { return ValidateUniformMatrix(context, entryPoint, GL_FLOAT_MAT3, location, count, tran } bool ValidateUniformMatrix4fv(const Context *context, angle::EntryPoint entryPoint, UniformLocation location, GLsizei count, GLboolean transpose, const GLfloat *value) { return ValidateUniformMatrix(context, entryPoint, GL_FLOAT_MAT4, location, count, tran } bool ValidateValidateProgram(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program) { Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } return true; } bool ValidateVertexAttrib1f(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLfloat x) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateVertexAttrib1fv(const Context *context, angle::EntryPoint entryPoint, GLuint index, const GLfloat *values) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateVertexAttrib2f(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLfloat x, GLfloat y) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateVertexAttrib2fv(const Context *context, angle::EntryPoint entryPoint, GLuint index, const GLfloat *values) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateVertexAttrib3f(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLfloat x, GLfloat y, GLfloat z) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateVertexAttrib3fv(const Context *context, angle::EntryPoint entryPoint, GLuint index, const GLfloat *values) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateVertexAttrib4f(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateVertexAttrib4fv(const Context *context, angle::EntryPoint entryPoint, GLuint index, const GLfloat *values) { return ValidateVertexAttribIndex(context, entryPoint, index); } bool ValidateViewport(const Context *context, angle::EntryPoint entryPoint, GLint x, GLint y, GLsizei width, GLsizei height) { if (width < 0 || height < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kViewportNegativeSize); return false; } return true; } bool ValidateGetFramebufferAttachmentParameteriv(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum attachment, GLenum pname, const GLint *params) { return ValidateGetFramebufferAttachmentParameterivBase(context, entryPoint, target, pname, nullptr); } bool ValidateGetProgramiv(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, GLenum pname, const GLint *params) { return ValidateGetProgramivBase(context, entryPoint, program, pname, nullptr); } bool ValidateCopyTexImage2D(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { if (context->getClientMajorVersion() < 3) { return ValidateES2CopyTexImageParameters(context, entryPoint, target, level, internal false, 0, 0, x, y, width, height, border); } ASSERT(context->getClientMajorVersion() == 3); return ValidateES3CopyTexImage2DParameters(context, entryPoint, target, level, intern false, 0, 0, 0, x, y, width, height, border); } bool ValidateCopyTexSubImage2D(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { if (context->getClientMajorVersion() < 3) { return ValidateES2CopyTexImageParameters(context, entryPoint, target, level, GL_NONE, xoffset, yoffset, x, y, width, height, 0); } return ValidateES3CopyTexImage2DParameters(context, entryPoint, target, level, GL_NON xoffset, yoffset, 0, x, y, width, height, 0); } bool ValidateCopyTexSubImage3DOES(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { return ValidateCopyTexSubImage3D(context, entryPoint, target, level, xoffset, yoffset, x, y, width, height); } bool ValidateDeleteBuffers(const Context *context, angle::EntryPoint entryPoint, GLint n, const BufferID *buffers) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateDeleteFramebuffers(const Context *context, angle::EntryPoint entryPoint, GLint n, const FramebufferID *framebuffers) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateDeleteRenderbuffers(const Context *context, angle::EntryPoint entryPoint, GLint n, const RenderbufferID *renderbuffers) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateDeleteTextures(const Context *context, angle::EntryPoint entryPoint, GLint n, const TextureID *textures) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateDisable(const Context *context, angle::EntryPoint entryPoint, GLenum cap) { if (!ValidCap(context, cap, false)) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap); return false; } return true; } bool ValidateEnable(const Context *context, angle::EntryPoint entryPoint, GLenum cap) { if (!ValidCap(context, cap, false)) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap); return false; } if (context->getLimitations().noSampleAlphaToCoverageSupport && cap == GL_SAMPLE_ALPHA_TO_COVERAGE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNoSampleAlphaToCoveragesLimitation); // We also output an error message to the debugger window if tracing is active, so that // developers can see the error message. ERR() << kNoSampleAlphaToCoveragesLimitation; return false; } return true; } bool ValidateFramebufferRenderbuffer(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum attachment, GLenum renderbuffertarget, RenderbufferID renderbuffer) { return ValidateFramebufferRenderbufferBase(context, entryPoint, target, attachment, renderbuffertarget, renderbuffer); } bool ValidateFramebufferTexture2D(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum attachment, TextureTarget textarget, TextureID texture, GLint level) { // Attachments are required to be bound to level 0 without ES3 or the GL_OES_fbo_render_mipmap // extension if (context->getClientMajorVersion() < 3 && !context->getExtensions().fboRenderMipmapOES && level != 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferTextureLe return false; } if (!ValidateFramebufferTextureBase(context, entryPoint, target, attachment, texture, { return false; } if (texture.value != 0) { Texture *tex = context->getTexture(texture); ASSERT(tex); const Caps &caps = context->getCaps(); switch (textarget) { case TextureTarget::_2D: { if (level > log2(caps.max2DTextureSize)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (tex->getType() != TextureType::_2D) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget); return false; } } break; case TextureTarget::Rectangle: { if (level != 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (tex->getType() != TextureType::Rectangle) { context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureTargetMismatch); return false; } } break; case TextureTarget::CubeMapNegativeX: case TextureTarget::CubeMapNegativeY: case TextureTarget::CubeMapNegativeZ: case TextureTarget::CubeMapPositiveX: case TextureTarget::CubeMapPositiveY: case TextureTarget::CubeMapPositiveZ: { if (level > log2(caps.maxCubeMapTextureSize)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (tex->getType() != TextureType::CubeMap) { context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureTargetMismatch); return false; } } break; case TextureTarget::_2DMultisample: { if (context->getClientVersion() < ES_3_1 && !context->getExtensions().textureMultisampleANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kMultisampleTextureExtensionOrES31Required); return false; } if (level != 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kLevelNotZero); return false; } if (tex->getType() != TextureType::_2DMultisample) { context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureTargetMismatch); return false; } } break; case TextureTarget::External: { if (!context->getExtensions().YUVTargetEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kYUVTargetExtensionRequired); return false; } if (attachment != GL_COLOR_ATTACHMENT0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidAttachment); return false; } if (tex->getType() != TextureType::External) { context->validationError(entryPoint, GL_INVALID_OPERATION, kTextureTargetMismatch); return false; } } break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } } return true; } bool ValidateFramebufferTexture3DOES(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum attachment, TextureTarget textargetPacked, TextureID texture, GLint level, GLint zoffset) { // We don't call into a base ValidateFramebufferTexture3D here because // it doesn't exist for OpenGL ES. This function is replaced by // FramebufferTextureLayer in ES 3.x, which has broader support. if (!context->getExtensions().texture3DOES) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } // Attachments are required to be bound to level 0 without ES3 or the // GL_OES_fbo_render_mipmap extension if (context->getClientMajorVersion() < 3 && !context->getExtensions().fboRenderMipmapOES && level != 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidFramebufferTextureLe return false; } if (!ValidateFramebufferTextureBase(context, entryPoint, target, attachment, texture, { return false; } if (texture.value != 0) { Texture *tex = context->getTexture(texture); ASSERT(tex); const Caps &caps = context->getCaps(); switch (textargetPacked) { case TextureTarget::_3D: { if (level > log2(caps.max3DTextureSize)) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidMipLevel); return false; } if (zoffset >= caps.max3DTextureSize) { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidZOffset); return false; } if (tex->getType() != TextureType::_3D) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureType); return false; } } break; default: context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidTextureTarget); return false; } } return true; } bool ValidateGenBuffers(const Context *context, angle::EntryPoint entryPoint, GLint n, const BufferID *buffers) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateGenFramebuffers(const Context *context, angle::EntryPoint entryPoint, GLint n, const FramebufferID *framebuffers) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateGenRenderbuffers(const Context *context, angle::EntryPoint entryPoint, GLint n, const RenderbufferID *renderbuffers) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateGenTextures(const Context *context, angle::EntryPoint entryPoint, GLint n, const TextureID *textures) { return ValidateGenOrDelete(context, entryPoint, n); } bool ValidateGenerateMipmap(const Context *context, angle::EntryPoint entryPoint, TextureType target) { return ValidateGenerateMipmapBase(context, entryPoint, target); } bool ValidateGetBufferParameteriv(const Context *context, angle::EntryPoint entryPoint, BufferBinding target, GLenum pname, const GLint *params) { return ValidateGetBufferParameterBase(context, entryPoint, target, pname, false, nullp } bool ValidateGetRenderbufferParameteriv(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum pname, const GLint *params) { return ValidateGetRenderbufferParameterivBase(context, entryPoint, target, pname, nul } bool ValidateGetShaderiv(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shader, GLenum pname, const GLint *params) { return ValidateGetShaderivBase(context, entryPoint, shader, pname, nullptr); } bool ValidateGetTexParameterfv(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLfloat *params) { return ValidateGetTexParameterBase(context, entryPoint, target, pname, nullptr); } bool ValidateGetTexParameteriv(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLint *params) { return ValidateGetTexParameterBase(context, entryPoint, target, pname, nullptr); } bool ValidateGetTexParameterIivOES(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLint *params) { if (context->getClientMajorVersion() < 3) { context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required); return false; } return ValidateGetTexParameterBase(context, entryPoint, target, pname, nullptr); } bool ValidateGetTexParameterIuivOES(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLuint *params) { if (context->getClientMajorVersion() < 3) { context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required); return false; } return ValidateGetTexParameterBase(context, entryPoint, target, pname, nullptr); } bool ValidateGetUniformfv(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, UniformLocation location, const GLfloat *params) { return ValidateGetUniformBase(context, entryPoint, program, location); } bool ValidateGetUniformiv(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program, UniformLocation location, const GLint *params) { return ValidateGetUniformBase(context, entryPoint, program, location); } bool ValidateGetVertexAttribfv(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLenum pname, const GLfloat *params) { return ValidateGetVertexAttribBase(context, entryPoint, index, pname, nullptr, false, f } bool ValidateGetVertexAttribiv(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLenum pname, const GLint *params) { return ValidateGetVertexAttribBase(context, entryPoint, index, pname, nullptr, false, f } bool ValidateGetVertexAttribPointerv(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLenum pname, void *const *pointer) { return ValidateGetVertexAttribBase(context, entryPoint, index, pname, nullptr, true, fa } bool ValidateIsEnabled(const Context *context, angle::EntryPoint entryPoint, GLenum cap { if (!ValidCap(context, cap, true)) { context->validationErrorF(entryPoint, GL_INVALID_ENUM, kEnumNotSupported, cap); return false; } return true; } bool ValidateLinkProgram(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program) { if (context->hasActiveTransformFeedback(program)) { // ES 3.0.4 section 2.15 page 91 context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackActiveDuringLink); return false; } Program *programObject = GetValidProgram(context, entryPoint, program); if (!programObject) { return false; } return true; } bool ValidateReadPixels(const Context *context, angle::EntryPoint entryPoint, GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) { return ValidateReadPixelsBase(context, entryPoint, x, y, width, height, format, type, -1, nullptr, nullptr, nullptr, pixels); } bool ValidateTexParameterf(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, GLfloat param) { return ValidateTexParameterBase(context, entryPoint, target, pname, -1, false, ¶m); } bool ValidateTexParameterfv(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLfloat *params) { return ValidateTexParameterBase(context, entryPoint, target, pname, -1, true, params); } bool ValidateTexParameteri(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, GLint param) { return ValidateTexParameterBase(context, entryPoint, target, pname, -1, false, ¶m); } bool ValidateTexParameteriv(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLint *params) { return ValidateTexParameterBase(context, entryPoint, target, pname, -1, true, params); } bool ValidateTexParameterIivOES(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLint *params) { if (context->getClientMajorVersion() < 3) { context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required); return false; } return ValidateTexParameterBase(context, entryPoint, target, pname, -1, true, params); } bool ValidateTexParameterIuivOES(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLenum pname, const GLuint *params) { if (context->getClientMajorVersion() < 3) { context->validationError(entryPoint, GL_INVALID_OPERATION, kES3Required); return false; } return ValidateTexParameterBase(context, entryPoint, target, pname, -1, true, params); } bool ValidateUseProgram(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID program) { if (program.value != 0) { Program *programObject = context->getProgramResolveLink(program); if (!programObject) { // ES 3.1.0 section 7.3 page 72 if (context->getShader(program)) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExpectedProgramName); return false; } else { context->validationError(entryPoint, GL_INVALID_VALUE, kInvalidProgramName); return false; } } if (!programObject->isLinked()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kProgramNotLinked); return false; } } if (context->getState().isTransformFeedbackActiveUnpaused()) { // ES 3.0.4 section 2.15 page 91 context->validationError(entryPoint, GL_INVALID_OPERATION, kTransformFeedbackUsePro return false; } return true; } bool ValidateDeleteFencesNV(const Context *context, angle::EntryPoint entryPoint, GLsizei n, const FenceNVID *fences) { if (!context->getExtensions().fenceNV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported); return false; } if (n < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount); return false; } return true; } bool ValidateFinishFenceNV(const Context *context, angle::EntryPoint entryPoint, Fence { if (!context->getExtensions().fenceNV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported); return false; } FenceNV *fenceObject = context->getFenceNV(fence); if (fenceObject == nullptr) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence); return false; } if (!fenceObject->isSet()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFenceState); return false; } return true; } bool ValidateGenFencesNV(const Context *context, angle::EntryPoint entryPoint, GLsizei n, const FenceNVID *fences) { if (!context->getExtensions().fenceNV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported); return false; } if (n < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeCount); return false; } return true; } bool ValidateGetFenceivNV(const Context *context, angle::EntryPoint entryPoint, FenceNVID fence, GLenum pname, const GLint *params) { if (!context->getExtensions().fenceNV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported); return false; } FenceNV *fenceObject = context->getFenceNV(fence); if (fenceObject == nullptr) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence); return false; } if (!fenceObject->isSet()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFenceState); return false; } switch (pname) { case GL_FENCE_STATUS_NV: case GL_FENCE_CONDITION_NV: break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidPname); return false; } return true; } bool ValidateGetGraphicsResetStatusEXT(const Context *context, angle::EntryPoint entr { if (!context->getExtensions().robustnessEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return true; } bool ValidateGetTranslatedShaderSourceANGLE(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shader, GLsizei bufsize, const GLsizei *length, const GLchar *source) { if (!context->getExtensions().translatedShaderSourceANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (bufsize < 0) { context->validationError(entryPoint, GL_INVALID_VALUE, kNegativeBufferSize); return false; } Shader *shaderObject = context->getShader(shader); if (!shaderObject) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidShaderName); return false; } return true; } bool ValidateIsFenceNV(const Context *context, angle::EntryPoint entryPoint, FenceNVID { if (!context->getExtensions().fenceNV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported); return false; } return true; } bool ValidateSetFenceNV(const Context *context, angle::EntryPoint entryPoint, FenceNVID fence, GLenum condition) { if (!context->getExtensions().fenceNV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported); return false; } if (condition != GL_ALL_COMPLETED_NV) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidFenceCondition); return false; } FenceNV *fenceObject = context->getFenceNV(fence); if (fenceObject == nullptr) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence); return false; } return true; } bool ValidateTestFenceNV(const Context *context, angle::EntryPoint entryPoint, FenceNV { if (!context->getExtensions().fenceNV) { context->validationError(entryPoint, GL_INVALID_OPERATION, kNVFenceNotSupported); return false; } FenceNV *fenceObject = context->getFenceNV(fence); if (fenceObject == nullptr) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFence); return false; } if (fenceObject->isSet() != GL_TRUE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kInvalidFenceState); return false; } return true; } bool ValidateTexStorage2DEXT(const Context *context, angle::EntryPoint entryPoint, TextureType type, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { if (!context->getExtensions().textureStorageEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (context->getClientMajorVersion() < 3) { return ValidateES2TexStorageParametersBase(context, entryPoint, type, levels, internalformat, width, height); } ASSERT(context->getClientMajorVersion() >= 3); return ValidateES3TexStorage2DParameters(context, entryPoint, type, levels, internalf width, height, 1); } bool ValidateVertexAttribDivisorANGLE(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLuint divisor) { if (!context->getExtensions().instancedArraysANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes)) { context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttrib return false; } if (context->getLimitations().attributeZeroRequiresZeroDivisorInEXT) { if (index == 0 && divisor != 0) { context->validationError(entryPoint, GL_INVALID_OPERATION, kAttributeZeroRequiresDivisorLimitation); // We also output an error message to the debugger window if tracing is active, so // that developers can see the error message. ERR() << kAttributeZeroRequiresDivisorLimitation; return false; } } return true; } bool ValidateVertexAttribDivisorEXT(const Context *context, angle::EntryPoint entryPoint, GLuint index, GLuint divisor) { if (!context->getExtensions().instancedArraysEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (index >= static_cast<GLuint>(context->getCaps().maxVertexAttributes)) { context->validationError(entryPoint, GL_INVALID_VALUE, kIndexExceedsMaxVertexAttrib return false; } return true; } bool ValidateTexImage3DOES(const Context *context, angle::EntryPoint entryPoint, TextureTarget target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) { return ValidateTexImage3D(context, entryPoint, target, level, internalformat, width, he depth, border, format, type, pixels); } bool ValidatePopGroupMarkerEXT(const Context *context, angle::EntryPoint entryPoint) { if (!context->getExtensions().debugMarkerEXT) { // 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(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return true; } bool ValidateTexStorage1DEXT(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) { UNIMPLEMENTED(); context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } bool ValidateTexStorage3DEXT(const Context *context, angle::EntryPoint entryPoint, TextureType target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { if (!context->getExtensions().textureStorageEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (context->getClientMajorVersion() < 3) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return ValidateES3TexStorage3DParameters(context, entryPoint, target, levels, interna width, height, depth); } bool ValidateMaxShaderCompilerThreadsKHR(const Context *context, angle::EntryPoint entryPoint, GLuint count) { if (!context->getExtensions().parallelShaderCompileKHR) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } return true; } bool ValidateMultiDrawArraysANGLE(const Context *context, angle::EntryPoint entryPoint, PrimitiveMode mode, const GLint *firsts, const GLsizei *counts, GLsizei drawcount) { if (!context->getExtensions().multiDrawANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } for (GLsizei drawID = 0; drawID < drawcount; ++drawID) { if (!ValidateDrawArrays(context, entryPoint, mode, firsts[drawID], counts[drawID])) { return false; } } return true; } bool ValidateMultiDrawElementsANGLE(const Context *context, angle::EntryPoint entryPoint, PrimitiveMode mode, const GLsizei *counts, DrawElementsType type, const GLvoid *const *indices, GLsizei drawcount) { if (!context->getExtensions().multiDrawANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } for (GLsizei drawID = 0; drawID < drawcount; ++drawID) { if (!ValidateDrawElements(context, entryPoint, mode, counts[drawID], type, indices[dra { return false; } } return true; } bool ValidateProvokingVertexANGLE(const Context *context, angle::EntryPoint entryPoint, ProvokingVertexConvention modePacked) { if (!context->getExtensions().provokingVertexANGLE) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } switch (modePacked) { case ProvokingVertexConvention::FirstVertexConvention: case ProvokingVertexConvention::LastVertexConvention: break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidProvokingVertex); return false; } return true; } bool ValidateFramebufferTexture2DMultisampleEXT(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLenum attachment, TextureTarget textarget, TextureID texture, GLint level, GLsizei samples) { if (!context->getExtensions().multisampledRenderToTextureEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (samples < 0) { return false; } // EXT_multisampled_render_to_texture states that the value of samples // must be less than or equal to MAX_SAMPLES_EXT (Context::getCaps().maxSamples) // otherwise GL_INVALID_VALUE is generated. if (samples > context->getCaps().maxSamples) { context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesOutOfRange); return false; } if (!ValidateFramebufferTextureBase(context, entryPoint, target, attachment, texture, { return false; } // EXT_multisampled_render_to_texture returns INVALID_OPERATION when a sample number hig // the maximum sample number supported by this format is passed. // The TextureCaps::getMaxSamples method is only guarenteed to be valid when the context is ES if (texture.value != 0 && context->getClientMajorVersion() >= 3) { Texture *tex = context->getTexture(texture); GLenum sizedInternalFormat = tex->getFormat(textarget, level).info->sizedInternalForma const TextureCaps &formatCaps = context->getTextureCaps().get(sizedInternalFormat); if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples()) { context->validationError(entryPoint, GL_INVALID_OPERATION, kSamplesOutOfRange); return false; } } // Unless EXT_multisampled_render_to_texture2 is enabled, only color attachment 0 can be us if (!context->getExtensions().multisampledRenderToTexture2EXT && attachment != GL_COLOR_ATTACHMENT0) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidAttachment); return false; } if (!ValidTexture2DDestinationTarget(context, textarget)) { context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); return false; } return true; } bool ValidateRenderbufferStorageMultisampleEXT(const Context *context, angle::EntryPoint entryPoint, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { if (!context->getExtensions().multisampledRenderToTextureEXT) { context->validationError(entryPoint, GL_INVALID_OPERATION, kExtensionNotEnabled); return false; } if (!ValidateRenderbufferStorageParametersBase(context, entryPoint, target, samples, internalformat, width, height)) { return false; } // EXT_multisampled_render_to_texture states that the value of samples // must be less than or equal to MAX_SAMPLES_EXT (Context::getCaps().maxSamples) // otherwise GL_INVALID_VALUE is generated. if (samples > context->getCaps().maxSamples) { context->validationError(entryPoint, GL_INVALID_VALUE, kSamplesOutOfRange); return false; } // EXT_multisampled_render_to_texture returns GL_OUT_OF_MEMORY on failure to create // the specified storage. This is different than ES 3.0 in which a sample number higher // than the maximum sample number supported by this format generates a GL_INVALID_VALUE. // The TextureCaps::getMaxSamples method is only guarenteed to be valid when the context is ES if (context->getClientMajorVersion() >= 3) { const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat); if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples()) { context->validationError(entryPoint, GL_OUT_OF_MEMORY, kSamplesOutOfRange); return false; } } return true; } void RecordBindTextureTypeError(const Context *context, angle::EntryPoint entryPoint, TextureType target) { ASSERT(!context->getStateCache().isValidBindTextureType(target)); switch (target) { case TextureType::Rectangle: ASSERT(!context->getExtensions().textureRectangleANGLE); context->validationError(entryPoint, GL_INVALID_ENUM, kTextureRectangleNotSupported break; case TextureType::_3D: case TextureType::_2DArray: ASSERT(context->getClientMajorVersion() < 3); context->validationError(entryPoint, GL_INVALID_ENUM, kES3Required); break; case TextureType::_2DMultisample: ASSERT(context->getClientVersion() < Version(3, 1) && !context->getExtensions().textureMultisampleANGLE); context->validationError(entryPoint, GL_INVALID_ENUM, kMultisampleTextureExtensionOrES31Required); break; case TextureType::_2DMultisampleArray: ASSERT(!context->getExtensions().textureStorageMultisample2dArrayOES); context->validationError(entryPoint, GL_INVALID_ENUM, kMultisampleArrayExtensionRequired); break; case TextureType::External: ASSERT(!context->getExtensions().EGLImageExternalOES && !context->getExtensions().EGLStreamConsumerExternalNV); context->validationError(entryPoint, GL_INVALID_ENUM, kExternalTextureNotSupported) break; case TextureType::VideoImage: ASSERT(!context->getExtensions().videoTextureWEBGL); context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled); break; case TextureType::Buffer: ASSERT(!context->getExtensions().textureBufferOES && !context->getExtensions().textureBufferEXT); context->validationError(entryPoint, GL_INVALID_ENUM, kExtensionNotEnabled); break; default: context->validationError(entryPoint, GL_INVALID_ENUM, kInvalidTextureTarget); } } } // namespace gl
¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.210Bemerkung: (vorverarbeitet am 2026-04-28) ¤*Bot Zugriff |
|
||||||||||||||
2026-05-26