// // Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. // // validationES2.cpp: Validation functions for OpenGL ES 2.0 entry point parameters #include "libANGLE/validationES2.h" #include <cstdint> #include "libANGLE/validationES.h" #include "libANGLE/validationES3.h" #include "libANGLE/Context.h" #include "libANGLE/Texture.h" #include "libANGLE/Framebuffer.h" #include "libANGLE/Renderbuffer.h" #include "libANGLE/formatutils.h" #include "libANGLE/FramebufferAttachment.h" #include "libANGLE/Uniform.h" #include "common/mathutil.h" #include "common/string_utils.h" #include "common/utilities.h" namespace gl { namespace { bool IsPartialBlit(gl::Context *context, const FramebufferAttachment *readBuffer, const FramebufferAttachment *writeBuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1) { const Extents &writeSize = writeBuffer->getSize(); const Extents &readSize = readBuffer->getSize(); if (srcX0 != 0 || srcY0 != 0 || dstX0 != 0 || dstY0 != 0 || dstX1 != writeSize.width || dstY1 != writeSize.height || srcX1 != readSize.width || srcY1 != readSize.height) { return true; } if (context->getGLState().isScissorTestEnabled()) { const Rectangle &scissor = context->getGLState().getScissor(); return scissor.x > 0 || scissor.y > 0 || scissor.width < writeSize.width || scissor.height < writeSize.height; } return false; } template <typename T> bool ValidatePathInstances(gl::Context *context, GLsizei numPaths, const void *paths, GLuint pathBase) { const auto *array = static_cast<const T *>(paths); for (GLsizei i = 0; i < numPaths; ++i) { const GLuint pathName = array[i] + pathBase; if (context->hasPath(pathName) && !context->hasPathData(pathName)) { context->handleError(gl::Error(GL_INVALID_OPERATION, "No such path object.")); return false; } } return true; } bool ValidateInstancedPathParameters(gl::Context *context, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum transformType, const GLfloat *transformValues) { if (!context->getExtensions().pathRendering) { context->handleError( gl::Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (paths == nullptr) { context->handleError(gl::Error(GL_INVALID_VALUE, "No path name array.")); return false; } if (numPaths < 0) { context->handleError(gl::Error(GL_INVALID_VALUE, "Invalid (negative) numPaths.")); return false; } if (!angle::IsValueInRangeForNumericType<std::uint32_t>(numPaths)) { context->handleError(gl::Error(GL_INVALID_OPERATION, "Overflow in numPaths.")); return false; } std::uint32_t pathNameTypeSize = 0; std::uint32_t componentCount = 0; switch (pathNameType) { case GL_UNSIGNED_BYTE: pathNameTypeSize = sizeof(GLubyte); if (!ValidatePathInstances<GLubyte>(context, numPaths, paths, pathBase)) return false; break; case GL_BYTE: pathNameTypeSize = sizeof(GLbyte); if (!ValidatePathInstances<GLbyte>(context, numPaths, paths, pathBase)) return false; break; case GL_UNSIGNED_SHORT: pathNameTypeSize = sizeof(GLushort); if (!ValidatePathInstances<GLushort>(context, numPaths, paths, pathBase)) return false; break; case GL_SHORT: pathNameTypeSize = sizeof(GLshort); if (!ValidatePathInstances<GLshort>(context, numPaths, paths, pathBase)) return false; break; case GL_UNSIGNED_INT: pathNameTypeSize = sizeof(GLuint); if (!ValidatePathInstances<GLuint>(context, numPaths, paths, pathBase)) return false; break; case GL_INT: pathNameTypeSize = sizeof(GLint); if (!ValidatePathInstances<GLint>(context, numPaths, paths, pathBase)) return false; break; default: context->handleError(gl::Error(GL_INVALID_ENUM, "Invalid path name type.")); return false; } switch (transformType) { case GL_NONE: componentCount = 0; break; case GL_TRANSLATE_X_CHROMIUM: case GL_TRANSLATE_Y_CHROMIUM: componentCount = 1; break; case GL_TRANSLATE_2D_CHROMIUM: componentCount = 2; break; case GL_TRANSLATE_3D_CHROMIUM: componentCount = 3; break; case GL_AFFINE_2D_CHROMIUM: case GL_TRANSPOSE_AFFINE_2D_CHROMIUM: componentCount = 6; break; case GL_AFFINE_3D_CHROMIUM: case GL_TRANSPOSE_AFFINE_3D_CHROMIUM: componentCount = 12; break; default: context->handleError(gl::Error(GL_INVALID_ENUM, "Invalid transformation.")); return false; } if (componentCount != 0 && transformValues == nullptr) { context->handleError(gl::Error(GL_INVALID_VALUE, "No transform array given.")); return false; } angle::CheckedNumeric<std::uint32_t> checkedSize(0); checkedSize += (numPaths * pathNameTypeSize); checkedSize += (numPaths * sizeof(GLfloat) * componentCount); if (!checkedSize.IsValid()) { context->handleError(gl::Error(GL_INVALID_OPERATION, "Overflow in num paths.")); return false; } return true; } bool IsValidCopyTextureFormat(Context *context, GLenum internalFormat) { const InternalFormat &internalFormatInfo = GetInternalFormatInfo(internalFormat); switch (internalFormatInfo.format) { case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: case GL_RGB: case GL_RGBA: return true; case GL_RED: return context->getClientMajorVersion() >= 3 || context->getExtensions().textureRG; case GL_BGRA_EXT: return context->getExtensions().textureFormatBGRA8888; default: return false; } } bool IsValidCopyTextureDestinationFormatType(Context *context, GLint internalFormat, GLenum type) { switch (internalFormat) { case GL_RGB: case GL_RGBA: break; case GL_BGRA_EXT: return context->getExtensions().textureFormatBGRA8888; default: return false; } switch (type) { case GL_UNSIGNED_BYTE: break; default: return false; } return true; } bool IsValidCopyTextureDestinationTarget(Context *context, GLenum target) { switch (target) { case GL_TEXTURE_2D: return true; // TODO(geofflang): accept GL_TEXTURE_RECTANGLE_ARB if the texture_rectangle extension is // supported default: return false; } } bool IsValidCopyTextureSourceTarget(Context *context, GLenum target) { if (IsValidCopyTextureDestinationTarget(context, target)) { return true; } // TODO(geofflang): accept GL_TEXTURE_EXTERNAL_OES if the texture_external extension is // supported return false; } } // anonymous namespace bool ValidateES2TexImageParameters(Context *context, GLenum target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { if (!ValidTexture2DDestinationTarget(context, target)) { context->handleError(Error(GL_INVALID_ENUM)); return false; } if (!ValidImageSizeParameters(context, target, level, width, height, 1, isSubImage)) { context->handleError(Error(GL_INVALID_VALUE)); return false; } if (level < 0 || xoffset < 0 || std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height) { context->handleError(Error(GL_INVALID_VALUE)); return false; } if (!isSubImage && !isCompressed && internalformat != format) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } const gl::Caps &caps = context->getCaps(); if (target == GL_TEXTURE_2D) { if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) || static_cast<GLuint>(height) > (caps.max2DTextureSize >> level)) { context->handleError(Error(GL_INVALID_VALUE)); return false; } } else if (IsCubeMapTextureTarget(target)) { if (!isSubImage && width != height) { context->handleError(Error(GL_INVALID_VALUE)); return false; } if (static_cast<GLuint>(width) > (caps.maxCubeMapTextureSize >> level) || static_cast<GLuint>(height) > (caps.maxCubeMapTextureSize >> level)) { context->handleError(Error(GL_INVALID_VALUE)); return false; } } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } gl::Texture *texture = context->getTargetTexture(IsCubeMapTextureTarget(target) ? GL_TEXTURE_CUBE_MAP : target); if (!texture) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } if (isSubImage) { if (format != GL_NONE) { if (gl::GetSizedInternalFormat(format, type) != texture->getFormat(target, level).asSized()) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } if (static_cast<size_t>(xoffset + width) > texture->getWidth(target, level) || static_cast<size_t>(yoffset + height) > texture->getHeight(target, level)) { context->handleError(Error(GL_INVALID_VALUE)); return false; } } else { if (texture->getImmutableFormat()) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } // Verify zero border if (border != 0) { context->handleError(Error(GL_INVALID_VALUE)); return false; } if (isCompressed) { GLenum actualInternalFormat = isSubImage ? texture->getFormat(target, level).asSized() : internalformat; switch (actualInternalFormat) { case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: if (!context->getExtensions().textureCompressionDXT1) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: if (!context->getExtensions().textureCompressionDXT1) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: if (!context->getExtensions().textureCompressionDXT5) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_OES: if (!context->getExtensions().compressedETC1RGB8Texture) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: if (!context->getExtensions().lossyETCDecode) { context->handleError( Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported")); return false; } break; default: context->handleError(Error( GL_INVALID_ENUM, "internalformat is not a supported compressed internal format")); return false; } if (!ValidCompressedImageSize(context, actualInternalFormat, width, height)) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } else { // validate <type> by itself (used as secondary key below) switch (type) { case GL_UNSIGNED_BYTE: case GL_UNSIGNED_SHORT_5_6_5: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_UNSIGNED_SHORT: case GL_UNSIGNED_INT: case GL_UNSIGNED_INT_24_8_OES: case GL_HALF_FLOAT_OES: case GL_FLOAT: break; default: context->handleError(Error(GL_INVALID_ENUM)); return false; } // validate <format> + <type> combinations // - invalid <format> -> sets INVALID_ENUM // - invalid <format>+<type> combination -> sets INVALID_OPERATION switch (format) { case GL_ALPHA: case GL_LUMINANCE: case GL_LUMINANCE_ALPHA: switch (type) { case GL_UNSIGNED_BYTE: case GL_FLOAT: case GL_HALF_FLOAT_OES: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RED: case GL_RG: if (!context->getExtensions().textureRG) { context->handleError(Error(GL_INVALID_ENUM)); return false; } switch (type) { case GL_UNSIGNED_BYTE: case GL_FLOAT: case GL_HALF_FLOAT_OES: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RGB: switch (type) { case GL_UNSIGNED_BYTE: case GL_UNSIGNED_SHORT_5_6_5: case GL_FLOAT: case GL_HALF_FLOAT_OES: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RGBA: switch (type) { case GL_UNSIGNED_BYTE: case GL_UNSIGNED_SHORT_4_4_4_4: case GL_UNSIGNED_SHORT_5_5_5_1: case GL_FLOAT: case GL_HALF_FLOAT_OES: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_BGRA_EXT: switch (type) { case GL_UNSIGNED_BYTE: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_SRGB_EXT: case GL_SRGB_ALPHA_EXT: if (!context->getExtensions().sRGB) { context->handleError(Error(GL_INVALID_ENUM)); return false; } switch (type) { case GL_UNSIGNED_BYTE: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: // error cases for compressed textures are handled below case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: break; case GL_DEPTH_COMPONENT: switch (type) { case GL_UNSIGNED_SHORT: case GL_UNSIGNED_INT: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_DEPTH_STENCIL_OES: switch (type) { case GL_UNSIGNED_INT_24_8_OES: break; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; default: context->handleError(Error(GL_INVALID_ENUM)); return false; } switch (format) { case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: if (context->getExtensions().textureCompressionDXT1) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: if (context->getExtensions().textureCompressionDXT3) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: if (context->getExtensions().textureCompressionDXT5) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_OES: if (context->getExtensions().compressedETC1RGB8Texture) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: if (context->getExtensions().lossyETCDecode) { context->handleError( Error(GL_INVALID_OPERATION, "ETC1_RGB8_LOSSY_DECODE_ANGLE can't work with this type.")); return false; } else { context->handleError( Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported.")); return false; } break; case GL_DEPTH_COMPONENT: case GL_DEPTH_STENCIL_OES: if (!context->getExtensions().depthTextures) { context->handleError(Error(GL_INVALID_VALUE)); return false; } if (target != GL_TEXTURE_2D) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } // OES_depth_texture supports loading depth data and multiple levels, // but ANGLE_depth_texture does not if (pixels != NULL || level != 0) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; default: break; } if (type == GL_FLOAT) { if (!context->getExtensions().textureFloat) { context->handleError(Error(GL_INVALID_ENUM)); return false; } } else if (type == GL_HALF_FLOAT_OES) { if (!context->getExtensions().textureHalfFloat) { context->handleError(Error(GL_INVALID_ENUM)); return false; } } } return true; } bool ValidateES2CopyTexImageParameters(ValidationContext *context, GLenum target, GLint level, GLenum internalformat, bool isSubImage, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { if (!ValidTexture2DDestinationTarget(context, target)) { context->handleError(Error(GL_INVALID_ENUM, "Invalid texture target")); return false; } Format textureFormat = Format::Invalid(); if (!ValidateCopyTexImageParametersBase(context, target, level, internalformat, isSubImage, xoffset, yoffset, 0, x, y, width, height, border, &textureFormat)) { return false; } const gl::Framebuffer *framebuffer = context->getGLState().getReadFramebuffer(); GLenum colorbufferFormat = framebuffer->getReadColorbuffer()->getFormat().asSized(); const auto &formatInfo = *textureFormat.info; // [OpenGL ES 2.0.24] table 3.9 if (isSubImage) { switch (formatInfo.format) { case GL_ALPHA: if (colorbufferFormat != GL_ALPHA8_EXT && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_LUMINANCE: if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RED_EXT: if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_R32F && colorbufferFormat != GL_RG32F && colorbufferFormat != GL_RGB32F && colorbufferFormat != GL_RGBA32F) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RG_EXT: if (colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RG32F && colorbufferFormat != GL_RGB32F && colorbufferFormat != GL_RGBA32F) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RGB: if (colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGB32F && colorbufferFormat != GL_RGBA32F) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_LUMINANCE_ALPHA: case GL_RGBA: if (colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA32F) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: case GL_ETC1_RGB8_OES: case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: context->handleError(Error(GL_INVALID_OPERATION)); return false; case GL_DEPTH_COMPONENT: case GL_DEPTH_STENCIL_OES: context->handleError(Error(GL_INVALID_OPERATION)); return false; default: context->handleError(Error(GL_INVALID_OPERATION)); return false; } if (formatInfo.type == GL_FLOAT && !context->getExtensions().textureFloat) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } else { switch (internalformat) { case GL_ALPHA: if (colorbufferFormat != GL_ALPHA8_EXT && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_LUMINANCE: if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RED_EXT: if (colorbufferFormat != GL_R8_EXT && colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RG_EXT: if (colorbufferFormat != GL_RG8_EXT && colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_RGB: if (colorbufferFormat != GL_RGB565 && colorbufferFormat != GL_RGB8_OES && colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_LUMINANCE_ALPHA: case GL_RGBA: if (colorbufferFormat != GL_RGBA4 && colorbufferFormat != GL_RGB5_A1 && colorbufferFormat != GL_BGRA8_EXT && colorbufferFormat != GL_RGBA8_OES && colorbufferFormat != GL_BGR5_A1_ANGLEX) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: if (context->getExtensions().textureCompressionDXT1) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: if (context->getExtensions().textureCompressionDXT3) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: if (context->getExtensions().textureCompressionDXT5) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_OES: if (context->getExtensions().compressedETC1RGB8Texture) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: if (context->getExtensions().lossyETCDecode) { context->handleError(Error(GL_INVALID_OPERATION, "ETC1_RGB8_LOSSY_DECODE_ANGLE can't be copied to.")); return false; } else { context->handleError( Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported.")); return false; } break; case GL_DEPTH_COMPONENT: case GL_DEPTH_COMPONENT16: case GL_DEPTH_COMPONENT32_OES: case GL_DEPTH_STENCIL_OES: case GL_DEPTH24_STENCIL8_OES: if (context->getExtensions().depthTextures) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } else { context->handleError(Error(GL_INVALID_ENUM)); return false; } default: context->handleError(Error(GL_INVALID_ENUM)); return false; } } // If width or height is zero, it is a no-op. Return false without setting an error. return (width > 0 && height > 0); } bool ValidateES2TexStorageParameters(Context *context, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { if (target != GL_TEXTURE_2D && target != GL_TEXTURE_CUBE_MAP) { context->handleError(Error(GL_INVALID_ENUM)); return false; } if (width < 1 || height < 1 || levels < 1) { context->handleError(Error(GL_INVALID_VALUE)); return false; } if (target == GL_TEXTURE_CUBE_MAP && width != height) { context->handleError(Error(GL_INVALID_VALUE)); return false; } if (levels != 1 && levels != gl::log2(std::max(width, height)) + 1) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat); if (formatInfo.format == GL_NONE || formatInfo.type == GL_NONE) { context->handleError(Error(GL_INVALID_ENUM)); return false; } const gl::Caps &caps = context->getCaps(); switch (target) { case GL_TEXTURE_2D: if (static_cast<GLuint>(width) > caps.max2DTextureSize || static_cast<GLuint>(height) > caps.max2DTextureSize) { context->handleError(Error(GL_INVALID_VALUE)); return false; } break; case GL_TEXTURE_CUBE_MAP: if (static_cast<GLuint>(width) > caps.maxCubeMapTextureSize || static_cast<GLuint>(height) > caps.maxCubeMapTextureSize) { context->handleError(Error(GL_INVALID_VALUE)); return false; } break; default: context->handleError(Error(GL_INVALID_ENUM)); return false; } if (levels != 1 && !context->getExtensions().textureNPOT) { if (!gl::isPow2(width) || !gl::isPow2(height)) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } switch (internalformat) { case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: if (!context->getExtensions().textureCompressionDXT1) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: if (!context->getExtensions().textureCompressionDXT3) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: if (!context->getExtensions().textureCompressionDXT5) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_OES: if (!context->getExtensions().compressedETC1RGB8Texture) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: if (!context->getExtensions().lossyETCDecode) { context->handleError( Error(GL_INVALID_ENUM, "ANGLE_lossy_etc_decode extension is not supported.")); return false; } break; case GL_RGBA32F_EXT: case GL_RGB32F_EXT: case GL_ALPHA32F_EXT: case GL_LUMINANCE32F_EXT: case GL_LUMINANCE_ALPHA32F_EXT: if (!context->getExtensions().textureFloat) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_RGBA16F_EXT: case GL_RGB16F_EXT: case GL_ALPHA16F_EXT: case GL_LUMINANCE16F_EXT: case GL_LUMINANCE_ALPHA16F_EXT: if (!context->getExtensions().textureHalfFloat) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_R8_EXT: case GL_RG8_EXT: case GL_R16F_EXT: case GL_RG16F_EXT: case GL_R32F_EXT: case GL_RG32F_EXT: if (!context->getExtensions().textureRG) { context->handleError(Error(GL_INVALID_ENUM)); return false; } break; case GL_DEPTH_COMPONENT16: case GL_DEPTH_COMPONENT32_OES: case GL_DEPTH24_STENCIL8_OES: if (!context->getExtensions().depthTextures) { context->handleError(Error(GL_INVALID_ENUM)); return false; } if (target != GL_TEXTURE_2D) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } // ANGLE_depth_texture only supports 1-level textures if (levels != 1) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } break; default: break; } gl::Texture *texture = context->getTargetTexture(target); if (!texture || texture->id() == 0) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } if (texture->getImmutableFormat()) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } return true; } // check for combinations of format and type that are valid for ReadPixels bool ValidES2ReadFormatType(ValidationContext *context, GLenum format, GLenum type) { switch (format) { case GL_RGBA: switch (type) { case GL_UNSIGNED_BYTE: break; default: return false; } break; case GL_BGRA_EXT: switch (type) { case GL_UNSIGNED_BYTE: case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT: case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT: break; default: return false; } break; case GL_RG_EXT: case GL_RED_EXT: if (!context->getExtensions().textureRG) { return false; } switch (type) { case GL_UNSIGNED_BYTE: break; default: return false; } break; default: return false; } return true; } bool ValidateDiscardFramebufferEXT(Context *context, GLenum target, GLsizei numAttachments, const GLenum *attachments) { if (!context->getExtensions().discardFramebuffer) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } bool defaultFramebuffer = false; switch (target) { case GL_FRAMEBUFFER: defaultFramebuffer = (context->getGLState().getTargetFramebuffer(GL_FRAMEBUFFER)->id() == 0); break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid framebuffer target")); return false; } return ValidateDiscardFramebufferBase(context, target, numAttachments, attachments, defaultFramebuffer); } bool ValidateBindVertexArrayOES(Context *context, GLuint array) { if (!context->getExtensions().vertexArrayObject) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } return ValidateBindVertexArrayBase(context, array); } bool ValidateDeleteVertexArraysOES(Context *context, GLsizei n) { if (!context->getExtensions().vertexArrayObject) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } return ValidateGenOrDelete(context, n); } bool ValidateGenVertexArraysOES(Context *context, GLsizei n) { if (!context->getExtensions().vertexArrayObject) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } return ValidateGenOrDelete(context, n); } bool ValidateIsVertexArrayOES(Context *context) { if (!context->getExtensions().vertexArrayObject) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } return true; } bool ValidateProgramBinaryOES(Context *context, GLuint program, GLenum binaryFormat, const void *binary, GLint length) { if (!context->getExtensions().getProgramBinary) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } return ValidateProgramBinaryBase(context, program, binaryFormat, binary, length); } bool ValidateGetProgramBinaryOES(Context *context, GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary) { if (!context->getExtensions().getProgramBinary) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } return ValidateGetProgramBinaryBase(context, program, bufSize, length, binaryFormat, binary); } static bool ValidDebugSource(GLenum source, bool mustBeThirdPartyOrApplication) { switch (source) { case GL_DEBUG_SOURCE_API: case GL_DEBUG_SOURCE_SHADER_COMPILER: case GL_DEBUG_SOURCE_WINDOW_SYSTEM: case GL_DEBUG_SOURCE_OTHER: // Only THIRD_PARTY and APPLICATION sources are allowed to be manually inserted return !mustBeThirdPartyOrApplication; case GL_DEBUG_SOURCE_THIRD_PARTY: case GL_DEBUG_SOURCE_APPLICATION: return true; default: return false; } } static bool ValidDebugType(GLenum type) { switch (type) { case GL_DEBUG_TYPE_ERROR: case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: case GL_DEBUG_TYPE_PERFORMANCE: case GL_DEBUG_TYPE_PORTABILITY: case GL_DEBUG_TYPE_OTHER: case GL_DEBUG_TYPE_MARKER: case GL_DEBUG_TYPE_PUSH_GROUP: case GL_DEBUG_TYPE_POP_GROUP: return true; default: return false; } } static bool ValidDebugSeverity(GLenum severity) { switch (severity) { case GL_DEBUG_SEVERITY_HIGH: case GL_DEBUG_SEVERITY_MEDIUM: case GL_DEBUG_SEVERITY_LOW: case GL_DEBUG_SEVERITY_NOTIFICATION: return true; default: return false; } } bool ValidateDebugMessageControlKHR(Context *context, GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (!ValidDebugSource(source, false) && source != GL_DONT_CARE) { context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source.")); return false; } if (!ValidDebugType(type) && type != GL_DONT_CARE) { context->handleError(Error(GL_INVALID_ENUM, "Invalid debug type.")); return false; } if (!ValidDebugSeverity(severity) && severity != GL_DONT_CARE) { context->handleError(Error(GL_INVALID_ENUM, "Invalid debug severity.")); return false; } if (count > 0) { if (source == GL_DONT_CARE || type == GL_DONT_CARE) { context->handleError(Error( GL_INVALID_OPERATION, "If count is greater than zero, source and severity cannot be GL_DONT_CARE.")); return false; } if (severity != GL_DONT_CARE) { context->handleError( Error(GL_INVALID_OPERATION, "If count is greater than zero, severity must be GL_DONT_CARE.")); return false; } } return true; } bool ValidateDebugMessageInsertKHR(Context *context, GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (!context->getGLState().getDebug().isOutputEnabled()) { // If the DEBUG_OUTPUT state is disabled calls to DebugMessageInsert are discarded and do // not generate an error. return false; } if (!ValidDebugSeverity(severity)) { context->handleError(Error(GL_INVALID_ENUM, "Invalid debug severity.")); return false; } if (!ValidDebugType(type)) { context->handleError(Error(GL_INVALID_ENUM, "Invalid debug type.")); return false; } if (!ValidDebugSource(source, true)) { context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source.")); return false; } size_t messageLength = (length < 0) ? strlen(buf) : length; if (messageLength > context->getExtensions().maxDebugMessageLength) { context->handleError( Error(GL_INVALID_VALUE, "Message length is larger than GL_MAX_DEBUG_MESSAGE_LENGTH.")); return false; } return true; } bool ValidateDebugMessageCallbackKHR(Context *context, GLDEBUGPROCKHR callback, const void *userParam) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } return true; } bool ValidateGetDebugMessageLogKHR(Context *context, GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (bufSize < 0 && messageLog != nullptr) { context->handleError( Error(GL_INVALID_VALUE, "bufSize must be positive if messageLog is not null.")); return false; } return true; } bool ValidatePushDebugGroupKHR(Context *context, GLenum source, GLuint id, GLsizei length, const GLchar *message) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (!ValidDebugSource(source, true)) { context->handleError(Error(GL_INVALID_ENUM, "Invalid debug source.")); return false; } size_t messageLength = (length < 0) ? strlen(message) : length; if (messageLength > context->getExtensions().maxDebugMessageLength) { context->handleError( Error(GL_INVALID_VALUE, "Message length is larger than GL_MAX_DEBUG_MESSAGE_LENGTH.")); return false; } size_t currentStackSize = context->getGLState().getDebug().getGroupStackDepth(); if (currentStackSize >= context->getExtensions().maxDebugGroupStackDepth) { context->handleError( Error(GL_STACK_OVERFLOW, "Cannot push more than GL_MAX_DEBUG_GROUP_STACK_DEPTH debug groups.")); return false; } return true; } bool ValidatePopDebugGroupKHR(Context *context) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } size_t currentStackSize = context->getGLState().getDebug().getGroupStackDepth(); if (currentStackSize <= 1) { context->handleError(Error(GL_STACK_UNDERFLOW, "Cannot pop the default debug group.")); return false; } return true; } static bool ValidateObjectIdentifierAndName(Context *context, GLenum identifier, GLuint name) { switch (identifier) { case GL_BUFFER: if (context->getBuffer(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid buffer.")); return false; } return true; case GL_SHADER: if (context->getShader(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid shader.")); return false; } return true; case GL_PROGRAM: if (context->getProgram(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid program.")); return false; } return true; case GL_VERTEX_ARRAY: if (context->getVertexArray(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid vertex array.")); return false; } return true; case GL_QUERY: if (context->getQuery(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid query.")); return false; } return true; case GL_TRANSFORM_FEEDBACK: if (context->getTransformFeedback(name) == nullptr) { context->handleError( Error(GL_INVALID_VALUE, "name is not a valid transform feedback.")); return false; } return true; case GL_SAMPLER: if (context->getSampler(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid sampler.")); return false; } return true; case GL_TEXTURE: if (context->getTexture(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid texture.")); return false; } return true; case GL_RENDERBUFFER: if (context->getRenderbuffer(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid renderbuffer.")); return false; } return true; case GL_FRAMEBUFFER: if (context->getFramebuffer(name) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid framebuffer.")); return false; } return true; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid identifier.")); return false; } } static bool ValidateLabelLength(Context *context, GLsizei length, const GLchar *label) { size_t labelLength = 0; if (length < 0) { if (label != nullptr) { labelLength = strlen(label); } } else { labelLength = static_cast<size_t>(length); } if (labelLength > context->getExtensions().maxLabelLength) { context->handleError( Error(GL_INVALID_VALUE, "Label length is larger than GL_MAX_LABEL_LENGTH.")); return false; } return true; } bool ValidateObjectLabelKHR(Context *context, GLenum identifier, GLuint name, GLsizei length, const GLchar *label) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (!ValidateObjectIdentifierAndName(context, identifier, name)) { return false; } if (!ValidateLabelLength(context, length, label)) { return false; } return true; } bool ValidateGetObjectLabelKHR(Context *context, GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (bufSize < 0) { context->handleError(Error(GL_INVALID_VALUE, "bufSize cannot be negative.")); return false; } if (!ValidateObjectIdentifierAndName(context, identifier, name)) { return false; } return true; } static bool ValidateObjectPtrName(Context *context, const void *ptr) { if (context->getFenceSync(reinterpret_cast<GLsync>(const_cast<void *>(ptr))) == nullptr) { context->handleError(Error(GL_INVALID_VALUE, "name is not a valid sync.")); return false; } return true; } bool ValidateObjectPtrLabelKHR(Context *context, const void *ptr, GLsizei length, const GLchar *label) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (!ValidateObjectPtrName(context, ptr)) { return false; } if (!ValidateLabelLength(context, length, label)) { return false; } return true; } bool ValidateGetObjectPtrLabelKHR(Context *context, const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } if (bufSize < 0) { context->handleError(Error(GL_INVALID_VALUE, "bufSize cannot be negative.")); return false; } if (!ValidateObjectPtrName(context, ptr)) { return false; } return true; } bool ValidateGetPointervKHR(Context *context, GLenum pname, void **params) { if (!context->getExtensions().debug) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not enabled")); return false; } // TODO: represent this in Context::getQueryParameterInfo. switch (pname) { case GL_DEBUG_CALLBACK_FUNCTION: case GL_DEBUG_CALLBACK_USER_PARAM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid pname.")); return false; } return true; } bool ValidateBlitFramebufferANGLE(Context *context, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { if (!context->getExtensions().framebufferBlit) { context->handleError(Error(GL_INVALID_OPERATION, "Blit extension not available.")); return false; } if (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0) { // TODO(jmadill): Determine if this should be available on other implementations. context->handleError(Error( GL_INVALID_OPERATION, "Scaling and flipping in BlitFramebufferANGLE not supported by this implementation.")); return false; } if (filter == GL_LINEAR) { context->handleError(Error(GL_INVALID_ENUM, "Linear blit not supported in this extension")); return false; } Framebuffer *readFramebuffer = context->getGLState().getReadFramebuffer(); Framebuffer *drawFramebuffer = context->getGLState().getDrawFramebuffer(); if (mask & GL_COLOR_BUFFER_BIT) { const FramebufferAttachment *readColorAttachment = readFramebuffer->getReadColorbuffer(); const FramebufferAttachment *drawColorAttachment = drawFramebuffer->getFirstColorbuffer(); if (readColorAttachment && drawColorAttachment) { if (!(readColorAttachment->type() == GL_TEXTURE && readColorAttachment->getTextureImageIndex().type == GL_TEXTURE_2D) && readColorAttachment->type() != GL_RENDERBUFFER && readColorAttachment->type() != GL_FRAMEBUFFER_DEFAULT) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } for (size_t drawbufferIdx = 0; drawbufferIdx < drawFramebuffer->getDrawbufferStateCount(); ++drawbufferIdx) { const FramebufferAttachment *attachment = drawFramebuffer->getDrawBuffer(drawbufferIdx); if (attachment) { if (!(attachment->type() == GL_TEXTURE && attachment->getTextureImageIndex().type == GL_TEXTURE_2D) && attachment->type() != GL_RENDERBUFFER && attachment->type() != GL_FRAMEBUFFER_DEFAULT) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } // Return an error if the destination formats do not match if (!Format::SameSized(attachment->getFormat(), readColorAttachment->getFormat())) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } } if (readFramebuffer->getSamples(context->getContextState()) != 0 && IsPartialBlit(context, readColorAttachment, drawColorAttachment, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1)) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } } GLenum masks[] = {GL_DEPTH_BUFFER_BIT, GL_STENCIL_BUFFER_BIT}; GLenum attachments[] = {GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT}; for (size_t i = 0; i < 2; i++) { if (mask & masks[i]) { const FramebufferAttachment *readBuffer = readFramebuffer->getAttachment(attachments[i]); const FramebufferAttachment *drawBuffer = drawFramebuffer->getAttachment(attachments[i]); if (readBuffer && drawBuffer) { if (IsPartialBlit(context, readBuffer, drawBuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1)) { // only whole-buffer copies are permitted ERR( "Only whole-buffer depth and stencil blits are supported by this " "implementation."); context->handleError(Error(GL_INVALID_OPERATION)); return false; } if (readBuffer->getSamples() != 0 || drawBuffer->getSamples() != 0) { context->handleError(Error(GL_INVALID_OPERATION)); return false; } } } } return ValidateBlitFramebufferParameters(context, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); } bool ValidateClear(ValidationContext *context, GLbitfield mask) { auto fbo = context->getGLState().getDrawFramebuffer(); if (fbo->checkStatus(context->getContextState()) != GL_FRAMEBUFFER_COMPLETE) { context->handleError(Error(GL_INVALID_FRAMEBUFFER_OPERATION)); return false; } if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) != 0) { context->handleError(Error(GL_INVALID_VALUE)); return false; } return true; } bool ValidateDrawBuffersEXT(ValidationContext *context, GLsizei n, const GLenum *bufs) { if (!context->getExtensions().drawBuffers) { context->handleError(Error(GL_INVALID_OPERATION, "Extension not supported.")); return false; } return ValidateDrawBuffersBase(context, n, bufs); } bool ValidateTexImage2D(Context *context, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) { if (context->getClientMajorVersion() < 3) { return ValidateES2TexImageParameters(context, target, level, internalformat, false, false, 0, 0, width, height, border, format, type, pixels); } ASSERT(context->getClientMajorVersion() >= 3); return ValidateES3TexImage2DParameters(context, target, level, internalformat, false, false, 0, 0, 0, width, height, 1, border, format, type, pixels); } bool ValidateTexSubImage2D(Context *context, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) { if (context->getClientMajorVersion() < 3) { return ValidateES2TexImageParameters(context, target, level, GL_NONE, false, true, xoffset, yoffset, width, height, 0, format, type, pixels); } ASSERT(context->getClientMajorVersion() >= 3); return ValidateES3TexImage2DParameters(context, target, level, GL_NONE, false, true, xoffset, yoffset, 0, width, height, 1, 0, format, type, pixels); } bool ValidateCompressedTexImage2D(Context *context, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) { if (context->getClientMajorVersion() < 3) { if (!ValidateES2TexImageParameters(context, target, level, internalformat, true, false, 0, 0, width, height, border, GL_NONE, GL_NONE, data)) { return false; } } else { ASSERT(context->getClientMajorVersion() >= 3); if (!ValidateES3TexImage2DParameters(context, target, level, internalformat, true, false, 0, 0, 0, width, height, 1, border, GL_NONE, GL_NONE, data)) { return false; } } const InternalFormat &formatInfo = GetInternalFormatInfo(internalformat); auto blockSizeOrErr = formatInfo.computeCompressedImageSize(GL_UNSIGNED_BYTE, gl::Extents(width, height, 1)); if (blockSizeOrErr.isError()) { context->handleError(blockSizeOrErr.getError()); return false; } if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSizeOrErr.getResult()) { context->handleError(Error(GL_INVALID_VALUE)); return false; } return true; } bool ValidateCompressedTexSubImage2D(Context *context, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) { if (context->getClientMajorVersion() < 3) { if (!ValidateES2TexImageParameters(context, target, level, GL_NONE, true, true, xoffset, yoffset, width, height, 0, GL_NONE, GL_NONE, data)) { return false; } } else { ASSERT(context->getClientMajorVersion() >= 3); if (!ValidateES3TexImage2DParameters(context, target, level, GL_NONE, true, true, xoffset, yoffset, 0, width, height, 1, 0, GL_NONE, GL_NONE, data)) { return false; } } const InternalFormat &formatInfo = GetInternalFormatInfo(format); auto blockSizeOrErr = formatInfo.computeCompressedImageSize(GL_UNSIGNED_BYTE, gl::Extents(width, height, 1)); if (blockSizeOrErr.isError()) { context->handleError(blockSizeOrErr.getError()); return false; } if (imageSize < 0 || static_cast<GLuint>(imageSize) != blockSizeOrErr.getResult()) { context->handleError(Error(GL_INVALID_VALUE)); return false; } return true; } bool ValidateGetBufferPointervOES(Context *context, GLenum target, GLenum pname, void **params) { if (!context->getExtensions().mapBuffer) { context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available.")); return false; } return ValidateGetBufferPointervBase(context, target, pname, params); } bool ValidateMapBufferOES(Context *context, GLenum target, GLenum access) { if (!context->getExtensions().mapBuffer) { context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available.")); return false; } if (!ValidBufferTarget(context, target)) { context->handleError(Error(GL_INVALID_ENUM, "Invalid buffer target.")); return false; } Buffer *buffer = context->getGLState().getTargetBuffer(target); if (buffer == nullptr) { context->handleError(Error(GL_INVALID_OPERATION, "Attempted to map buffer object zero.")); return false; } if (access != GL_WRITE_ONLY_OES) { context->handleError(Error(GL_INVALID_ENUM, "Non-write buffer mapping not supported.")); return false; } if (buffer->isMapped()) { context->handleError(Error(GL_INVALID_OPERATION, "Buffer is already mapped.")); return false; } return true; } bool ValidateUnmapBufferOES(Context *context, GLenum target) { if (!context->getExtensions().mapBuffer) { context->handleError(Error(GL_INVALID_OPERATION, "Map buffer extension not available.")); return false; } return ValidateUnmapBufferBase(context, target); } bool ValidateMapBufferRangeEXT(Context *context, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { if (!context->getExtensions().mapBufferRange) { context->handleError( Error(GL_INVALID_OPERATION, "Map buffer range extension not available.")); return false; } return ValidateMapBufferRangeBase(context, target, offset, length, access); } bool ValidateFlushMappedBufferRangeEXT(Context *context, GLenum target, GLintptr offset, GLsizeiptr length) { if (!context->getExtensions().mapBufferRange) { context->handleError( Error(GL_INVALID_OPERATION, "Map buffer range extension not available.")); return false; } return ValidateFlushMappedBufferRangeBase(context, target, offset, length); } bool ValidateBindTexture(Context *context, GLenum target, GLuint texture) { Texture *textureObject = context->getTexture(texture); if (textureObject && textureObject->getTarget() != target && texture != 0) { context->handleError(Error(GL_INVALID_OPERATION, "Invalid texture")); return false; } switch (target) { case GL_TEXTURE_2D: case GL_TEXTURE_CUBE_MAP: break; case GL_TEXTURE_3D: case GL_TEXTURE_2D_ARRAY: if (context->getClientMajorVersion() < 3) { context->handleError(Error(GL_INVALID_ENUM, "GLES 3.0 disabled")); return false; } break; case GL_TEXTURE_EXTERNAL_OES: if (!context->getExtensions().eglImageExternal && !context->getExtensions().eglStreamConsumerExternal) { context->handleError( Error(GL_INVALID_ENUM, "External texture extension not enabled")); return false; } break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid target")); return false; } return true; } bool ValidateBindUniformLocationCHROMIUM(Context *context, GLuint program, GLint location, const GLchar *name) { if (!context->getExtensions().bindUniformLocation) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_bind_uniform_location is not available.")); return false; } Program *programObject = GetValidProgram(context, program); if (!programObject) { return false; } if (location < 0) { context->handleError(Error(GL_INVALID_VALUE, "Location cannot be less than 0.")); return false; } const Caps &caps = context->getCaps(); if (static_cast<size_t>(location) >= (caps.maxVertexUniformVectors + caps.maxFragmentUniformVectors) * 4) { context->handleError(Error(GL_INVALID_VALUE, "Location must be less than (MAX_VERTEX_UNIFORM_VECTORS + " "MAX_FRAGMENT_UNIFORM_VECTORS) * 4")); return false; } if (strncmp(name, "gl_", 3) == 0) { context->handleError( Error(GL_INVALID_OPERATION, "Name cannot start with the reserved \"gl_\" prefix.")); return false; } return true; } bool ValidateCoverageModulationCHROMIUM(Context *context, GLenum components) { if (!context->getExtensions().framebufferMixedSamples) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_framebuffer_mixed_samples is not available.")); return false; } switch (components) { case GL_RGB: case GL_RGBA: case GL_ALPHA: case GL_NONE: break; default: context->handleError( Error(GL_INVALID_ENUM, "GLenum components is not one of GL_RGB, GL_RGBA, GL_ALPHA or GL_NONE.")); return false; } return true; } // CHROMIUM_path_rendering bool ValidateMatrix(Context *context, GLenum matrixMode, const GLfloat *matrix) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (matrixMode != GL_PATH_MODELVIEW_CHROMIUM && matrixMode != GL_PATH_PROJECTION_CHROMIUM) { context->handleError(Error(GL_INVALID_ENUM, "Invalid matrix mode.")); return false; } if (matrix == nullptr) { context->handleError(Error(GL_INVALID_OPERATION, "Invalid matrix.")); return false; } return true; } bool ValidateMatrixMode(Context *context, GLenum matrixMode) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (matrixMode != GL_PATH_MODELVIEW_CHROMIUM && matrixMode != GL_PATH_PROJECTION_CHROMIUM) { context->handleError(Error(GL_INVALID_ENUM, "Invalid matrix mode.")); return false; } return true; } bool ValidateGenPaths(Context *context, GLsizei range) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } // range = 0 is undefined in NV_path_rendering. // we add stricter semantic check here and require a non zero positive range. if (range <= 0) { context->handleError(Error(GL_INVALID_VALUE, "Invalid range.")); return false; } if (!angle::IsValueInRangeForNumericType<std::uint32_t>(range)) { context->handleError(Error(GL_INVALID_OPERATION, "Range overflow.")); return false; } return true; } bool ValidateDeletePaths(Context *context, GLuint path, GLsizei range) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } // range = 0 is undefined in NV_path_rendering. // we add stricter semantic check here and require a non zero positive range. if (range <= 0) { context->handleError(Error(GL_INVALID_VALUE, "Invalid range.")); return false; } angle::CheckedNumeric<std::uint32_t> checkedRange(path); checkedRange += range; if (!angle::IsValueInRangeForNumericType<std::uint32_t>(range) || !checkedRange.IsValid()) { context->handleError(Error(GL_INVALID_OPERATION, "Range overflow.")); return false; } return true; } bool ValidatePathCommands(Context *context, GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (!context->hasPath(path)) { context->handleError(Error(GL_INVALID_OPERATION, "No such path object.")); return false; } if (numCommands < 0) { context->handleError(Error(GL_INVALID_VALUE, "Invalid number of commands.")); return false; } else if (numCommands > 0) { if (!commands) { context->handleError(Error(GL_INVALID_VALUE, "No commands array given.")); return false; } } if (numCoords < 0) { context->handleError(Error(GL_INVALID_VALUE, "Invalid number of coordinates.")); return false; } else if (numCoords > 0) { if (!coords) { context->handleError(Error(GL_INVALID_VALUE, "No coordinate array given.")); return false; } } std::uint32_t coordTypeSize = 0; switch (coordType) { case GL_BYTE: coordTypeSize = sizeof(GLbyte); break; case GL_UNSIGNED_BYTE: coordTypeSize = sizeof(GLubyte); break; case GL_SHORT: coordTypeSize = sizeof(GLshort); break; case GL_UNSIGNED_SHORT: coordTypeSize = sizeof(GLushort); break; case GL_FLOAT: coordTypeSize = sizeof(GLfloat); break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid coordinate type.")); return false; } angle::CheckedNumeric<std::uint32_t> checkedSize(numCommands); checkedSize += (coordTypeSize * numCoords); if (!checkedSize.IsValid()) { context->handleError(Error(GL_INVALID_OPERATION, "Coord size overflow.")); return false; } // early return skips command data validation when it doesn't exist. if (!commands) return true; GLsizei expectedNumCoords = 0; for (GLsizei i = 0; i < numCommands; ++i) { switch (commands[i]) { case GL_CLOSE_PATH_CHROMIUM: // no coordinates. break; case GL_MOVE_TO_CHROMIUM: case GL_LINE_TO_CHROMIUM: expectedNumCoords += 2; break; case GL_QUADRATIC_CURVE_TO_CHROMIUM: expectedNumCoords += 4; break; case GL_CUBIC_CURVE_TO_CHROMIUM: expectedNumCoords += 6; break; case GL_CONIC_CURVE_TO_CHROMIUM: expectedNumCoords += 5; break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid command.")); return false; } } if (expectedNumCoords != numCoords) { context->handleError(Error(GL_INVALID_VALUE, "Invalid number of coordinates.")); return false; } return true; } bool ValidateSetPathParameter(Context *context, GLuint path, GLenum pname, GLfloat value) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (!context->hasPath(path)) { context->handleError(Error(GL_INVALID_OPERATION, "No such path object.")); return false; } switch (pname) { case GL_PATH_STROKE_WIDTH_CHROMIUM: if (value < 0.0f) { context->handleError(Error(GL_INVALID_VALUE, "Invalid stroke width.")); return false; } break; case GL_PATH_END_CAPS_CHROMIUM: switch (static_cast<GLenum>(value)) { case GL_FLAT_CHROMIUM: case GL_SQUARE_CHROMIUM: case GL_ROUND_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid end caps.")); return false; } break; case GL_PATH_JOIN_STYLE_CHROMIUM: switch (static_cast<GLenum>(value)) { case GL_MITER_REVERT_CHROMIUM: case GL_BEVEL_CHROMIUM: case GL_ROUND_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid join style.")); return false; } case GL_PATH_MITER_LIMIT_CHROMIUM: if (value < 0.0f) { context->handleError(Error(GL_INVALID_VALUE, "Invalid miter limit.")); return false; } break; case GL_PATH_STROKE_BOUND_CHROMIUM: // no errors, only clamping. break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid path parameter.")); return false; } return true; } bool ValidateGetPathParameter(Context *context, GLuint path, GLenum pname, GLfloat *value) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (!context->hasPath(path)) { context->handleError(Error(GL_INVALID_OPERATION, "No such path object.")); return false; } if (!value) { context->handleError(Error(GL_INVALID_VALUE, "No value array.")); return false; } switch (pname) { case GL_PATH_STROKE_WIDTH_CHROMIUM: case GL_PATH_END_CAPS_CHROMIUM: case GL_PATH_JOIN_STYLE_CHROMIUM: case GL_PATH_MITER_LIMIT_CHROMIUM: case GL_PATH_STROKE_BOUND_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid path parameter.")); return false; } return true; } bool ValidatePathStencilFunc(Context *context, GLenum func, GLint ref, GLuint mask) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } 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: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid stencil function.")); return false; } return true; } // Note that the spec specifies that for the path drawing commands // if the path object is not an existing path object the command // does nothing and no error is generated. // However if the path object exists but has not been specified any // commands then an error is generated. bool ValidateStencilFillPath(Context *context, GLuint path, GLenum fillMode, GLuint mask) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (context->hasPath(path) && !context->hasPathData(path)) { context->handleError(Error(GL_INVALID_OPERATION, "No such path object.")); return false; } switch (fillMode) { case GL_COUNT_UP_CHROMIUM: case GL_COUNT_DOWN_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid fill mode.")); return false; } if (!isPow2(mask + 1)) { context->handleError(Error(GL_INVALID_VALUE, "Invalid stencil bit mask.")); return false; } return true; } bool ValidateStencilStrokePath(Context *context, GLuint path, GLint reference, GLuint mask) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (context->hasPath(path) && !context->hasPathData(path)) { context->handleError(Error(GL_INVALID_OPERATION, "No such path or path has no data.")); return false; } return true; } bool ValidateCoverPath(Context *context, GLuint path, GLenum coverMode) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } if (context->hasPath(path) && !context->hasPathData(path)) { context->handleError(Error(GL_INVALID_OPERATION, "No such path object.")); return false; } switch (coverMode) { case GL_CONVEX_HULL_CHROMIUM: case GL_BOUNDING_BOX_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid cover mode.")); return false; } return true; } bool ValidateStencilThenCoverFillPath(Context *context, GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode) { return ValidateStencilFillPath(context, path, fillMode, mask) && ValidateCoverPath(context, path, coverMode); } bool ValidateStencilThenCoverStrokePath(Context *context, GLuint path, GLint reference, GLuint mask, GLenum coverMode) { return ValidateStencilStrokePath(context, path, reference, mask) && ValidateCoverPath(context, path, coverMode); } bool ValidateIsPath(Context *context) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } return true; } bool ValidateCoverFillPathInstanced(Context *context, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues) { if (!ValidateInstancedPathParameters(context, numPaths, pathNameType, paths, pathBase, transformType, transformValues)) return false; switch (coverMode) { case GL_CONVEX_HULL_CHROMIUM: case GL_BOUNDING_BOX_CHROMIUM: case GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid cover mode.")); return false; } return true; } bool ValidateCoverStrokePathInstanced(Context *context, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues) { if (!ValidateInstancedPathParameters(context, numPaths, pathNameType, paths, pathBase, transformType, transformValues)) return false; switch (coverMode) { case GL_CONVEX_HULL_CHROMIUM: case GL_BOUNDING_BOX_CHROMIUM: case GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid cover mode.")); return false; } return true; } bool ValidateStencilFillPathInstanced(Context *context, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues) { if (!ValidateInstancedPathParameters(context, numPaths, pathNameType, paths, pathBase, transformType, transformValues)) return false; switch (fillMode) { case GL_COUNT_UP_CHROMIUM: case GL_COUNT_DOWN_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid fill mode.")); return false; } if (!isPow2(mask + 1)) { context->handleError(Error(GL_INVALID_VALUE, "Invalid stencil bit mask.")); return false; } return true; } bool ValidateStencilStrokePathInstanced(Context *context, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues) { if (!ValidateInstancedPathParameters(context, numPaths, pathNameType, paths, pathBase, transformType, transformValues)) return false; // no more validation here. return true; } bool ValidateStencilThenCoverFillPathInstanced(Context *context, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues) { if (!ValidateInstancedPathParameters(context, numPaths, pathNameType, paths, pathBase, transformType, transformValues)) return false; switch (coverMode) { case GL_CONVEX_HULL_CHROMIUM: case GL_BOUNDING_BOX_CHROMIUM: case GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid cover mode.")); return false; } switch (fillMode) { case GL_COUNT_UP_CHROMIUM: case GL_COUNT_DOWN_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid fill mode.")); return false; } if (!isPow2(mask + 1)) { context->handleError(Error(GL_INVALID_VALUE, "Invalid stencil bit mask.")); return false; } return true; } bool ValidateStencilThenCoverStrokePathInstanced(Context *context, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues) { if (!ValidateInstancedPathParameters(context, numPaths, pathNameType, paths, pathBase, transformType, transformValues)) return false; switch (coverMode) { case GL_CONVEX_HULL_CHROMIUM: case GL_BOUNDING_BOX_CHROMIUM: case GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM: break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid cover mode.")); return false; } return true; } bool ValidateBindFragmentInputLocation(Context *context, GLuint program, GLint location, const GLchar *name) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } const GLint MaxLocation = context->getCaps().maxVaryingVectors * 4; if (location >= MaxLocation) { context->handleError(Error(GL_INVALID_VALUE, "Location exceeds max varying.")); return false; } const auto *programObject = context->getProgram(program); if (!programObject) { context->handleError(Error(GL_INVALID_OPERATION, "No such program.")); return false; } if (!name) { context->handleError(Error(GL_INVALID_VALUE, "No name given.")); return false; } if (angle::BeginsWith(name, "gl_")) { context->handleError(Error(GL_INVALID_OPERATION, "Cannot bind a built-in variable.")); return false; } return true; } bool ValidateProgramPathFragmentInputGen(Context *context, GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat *coeffs) { if (!context->getExtensions().pathRendering) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_path_rendering is not available.")); return false; } const auto *programObject = context->getProgram(program); if (!programObject || programObject->isFlaggedForDeletion()) { context->handleError(Error(GL_INVALID_OPERATION, "No such program.")); return false; } if (!programObject->isLinked()) { context->handleError(Error(GL_INVALID_OPERATION, "Program is not linked.")); return false; } switch (genMode) { case GL_NONE: if (components != 0) { context->handleError(Error(GL_INVALID_VALUE, "Invalid components.")); return false; } break; case GL_OBJECT_LINEAR_CHROMIUM: case GL_EYE_LINEAR_CHROMIUM: case GL_CONSTANT_CHROMIUM: if (components < 1 || components > 4) { context->handleError(Error(GL_INVALID_VALUE, "Invalid components.")); return false; } if (!coeffs) { context->handleError(Error(GL_INVALID_VALUE, "No coefficients array given.")); return false; } break; default: context->handleError(Error(GL_INVALID_ENUM, "Invalid gen mode.")); return false; } // If the location is -1 then the command is silently ignored // and no further validation is needed. if (location == -1) return true; const auto &binding = programObject->getFragmentInputBindingInfo(location); if (!binding.valid) { context->handleError(Error(GL_INVALID_OPERATION, "No such binding.")); return false; } if (binding.type != GL_NONE) { GLint expectedComponents = 0; switch (binding.type) { case GL_FLOAT: expectedComponents = 1; break; case GL_FLOAT_VEC2: expectedComponents = 2; break; case GL_FLOAT_VEC3: expectedComponents = 3; break; case GL_FLOAT_VEC4: expectedComponents = 4; break; default: context->handleError(Error(GL_INVALID_OPERATION, "Fragment input type is not a floating point scalar or vector.")); return false; } if (expectedComponents != components && genMode != GL_NONE) { context->handleError(Error(GL_INVALID_OPERATION, "Unexpected number of components")); return false; } } return true; } bool ValidateCopyTextureCHROMIUM(Context *context, GLuint sourceId, GLuint destId, GLint internalFormat, GLenum destType, GLboolean unpackFlipY, GLboolean unpackPremultiplyAlpha, GLboolean unpackUnmultiplyAlpha) { if (!context->getExtensions().copyTexture) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_copy_texture extension not available.")); return false; } const gl::Texture *source = context->getTexture(sourceId); if (source == nullptr) { context->handleError( Error(GL_INVALID_VALUE, "Source texture is not a valid texture object.")); return false; } if (!IsValidCopyTextureSourceTarget(context, source->getTarget())) { context->handleError(Error(GL_INVALID_VALUE, "Source texture a valid texture type.")); return false; } GLenum sourceTarget = source->getTarget(); ASSERT(sourceTarget != GL_TEXTURE_CUBE_MAP); if (source->getWidth(sourceTarget, 0) == 0 || source->getHeight(sourceTarget, 0) == 0) { context->handleError( Error(GL_INVALID_VALUE, "Level 0 of the source texture must be defined.")); return false; } const gl::Format &sourceFormat = source->getFormat(sourceTarget, 0); if (!IsValidCopyTextureFormat(context, sourceFormat.format)) { context->handleError( Error(GL_INVALID_OPERATION, "Source texture internal format is invalid.")); return false; } const gl::Texture *dest = context->getTexture(destId); if (dest == nullptr) { context->handleError( Error(GL_INVALID_VALUE, "Destination texture is not a valid texture object.")); return false; } if (!IsValidCopyTextureDestinationTarget(context, dest->getTarget())) { context->handleError(Error(GL_INVALID_VALUE, "Destination texture a valid texture type.")); return false; } if (!IsValidCopyTextureDestinationFormatType(context, internalFormat, destType)) { context->handleError( Error(GL_INVALID_OPERATION, "Destination internal format and type combination is not valid.")); return false; } if (dest->getImmutableFormat()) { context->handleError(Error(GL_INVALID_OPERATION, "Destination texture is immutable.")); return false; } return true; } bool ValidateCopySubTextureCHROMIUM(Context *context, GLuint sourceId, GLuint destId, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, GLboolean unpackFlipY, GLboolean unpackPremultiplyAlpha, GLboolean unpackUnmultiplyAlpha) { if (!context->getExtensions().copyTexture) { context->handleError( Error(GL_INVALID_OPERATION, "GL_CHROMIUM_copy_texture extension not available.")); return false; } const gl::Texture *source = context->getTexture(sourceId); if (source == nullptr) { context->handleError( Error(GL_INVALID_VALUE, "Source texture is not a valid texture object.")); return false; } if (!IsValidCopyTextureSourceTarget(context, source->getTarget())) { context->handleError(Error(GL_INVALID_VALUE, "Source texture a valid texture type.")); return false; } GLenum sourceTarget = source->getTarget(); ASSERT(sourceTarget != GL_TEXTURE_CUBE_MAP); if (source->getWidth(sourceTarget, 0) == 0 || source->getHeight(sourceTarget, 0) == 0) { context->handleError( Error(GL_INVALID_VALUE, "Level 0 of the source texture must be defined.")); return false; } if (x < 0 || y < 0) { context->handleError(Error(GL_INVALID_VALUE, "x and y cannot be negative.")); return false; } if (width < 0 || height < 0) { context->handleError(Error(GL_INVALID_VALUE, "width and height cannot be negative.")); return false; } if (static_cast<size_t>(x + width) > source->getWidth(sourceTarget, 0) || static_cast<size_t>(y + height) > source->getHeight(sourceTarget, 0)) { context->handleError( Error(GL_INVALID_VALUE, "Source texture not large enough to copy from.")); return false; } const gl::Format &sourceFormat = source->getFormat(sourceTarget, 0); if (!IsValidCopyTextureFormat(context, sourceFormat.format)) { context->handleError( Error(GL_INVALID_OPERATION, "Source texture internal format is invalid.")); return false; } const gl::Texture *dest = context->getTexture(destId); if (dest == nullptr) { context->handleError( Error(GL_INVALID_VALUE, "Destination texture is not a valid texture object.")); return false; } if (!IsValidCopyTextureDestinationTarget(context, dest->getTarget())) { context->handleError(Error(GL_INVALID_VALUE, "Destination texture a valid texture type.")); return false; } GLenum destTarget = dest->getTarget(); ASSERT(destTarget != GL_TEXTURE_CUBE_MAP); if (dest->getWidth(sourceTarget, 0) == 0 || dest->getHeight(sourceTarget, 0) == 0) { context->handleError( Error(GL_INVALID_VALUE, "Level 0 of the destination texture must be defined.")); return false; } const gl::Format &destFormat = dest->getFormat(destTarget, 0); if (!IsValidCopyTextureDestinationFormatType(context, destFormat.format, destFormat.type)) { context->handleError( Error(GL_INVALID_OPERATION, "Destination internal format and type combination is not valid.")); return false; } if (xoffset < 0 || yoffset < 0) { context->handleError(Error(GL_INVALID_VALUE, "xoffset and yoffset cannot be negative.")); return false; } if (static_cast<size_t>(xoffset + width) > dest->getWidth(destTarget, 0) || static_cast<size_t>(yoffset + height) > dest->getHeight(destTarget, 0)) { context->handleError( Error(GL_INVALID_VALUE, "Destination texture not large enough to copy to.")); return false; } return true; } bool ValidateCreateShader(Context *context, GLenum type) { switch (type) { case GL_VERTEX_SHADER: case GL_FRAGMENT_SHADER: break; case GL_COMPUTE_SHADER: if (context->getGLVersion().isES31()) { break; } default: context->handleError(Error(GL_INVALID_ENUM)); return false; } return true; } } // namespace gl