| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include "gles/gles_validate.h" |
| |
| #include <GLES/gl.h> |
| #include <GLES/glext.h> |
| #include <GLES2/gl2.h> |
| |
| #include "gles/state.h" |
| |
| bool IsValidAlphaFunc(GLenum func) { |
| switch (func) { |
| case GL_NEVER: |
| case GL_LESS: |
| case GL_EQUAL: |
| case GL_LEQUAL: |
| case GL_GREATER: |
| case GL_NOTEQUAL: |
| case GL_GEQUAL: |
| case GL_ALWAYS: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidBlendFunc(GLenum factor) { |
| switch (factor) { |
| 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: |
| case GL_SRC_ALPHA_SATURATE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidBufferTarget(GLenum target) { |
| return target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER; |
| } |
| |
| bool IsValidBufferUsage(GLenum usage) { |
| return usage == GL_STATIC_DRAW || usage == GL_DYNAMIC_DRAW || |
| usage == GL_STREAM_DRAW; |
| } |
| |
| bool IsValidClientState(GLenum state) { |
| switch (state) { |
| case GL_COLOR_ARRAY: |
| case GL_NORMAL_ARRAY: |
| case GL_TEXTURE_COORD_ARRAY: |
| case GL_VERTEX_ARRAY: |
| case GL_POINT_SIZE_ARRAY_OES: |
| case GL_WEIGHT_ARRAY_OES: |
| case GL_MATRIX_INDEX_ARRAY_OES: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidColorPointerSize(GLint size) { |
| return ((size >= 3) && (size <= 4)); |
| } |
| |
| bool IsValidColorPointerType(GLenum type) { |
| switch (type) { |
| case GL_UNSIGNED_BYTE: |
| case GL_FIXED: |
| case GL_FLOAT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidCullFaceMode(GLenum mode) { |
| switch (mode) { |
| case GL_FRONT: |
| case GL_BACK: |
| case GL_FRONT_AND_BACK: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidDepthFunc(GLenum func) { |
| switch (func) { |
| case GL_NEVER: |
| case GL_LESS: |
| case GL_EQUAL: |
| case GL_LEQUAL: |
| case GL_GREATER: |
| case GL_NOTEQUAL: |
| case GL_GEQUAL: |
| case GL_ALWAYS: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidDrawMode(GLenum mode) { |
| switch (mode) { |
| case GL_POINTS: |
| case GL_LINE_STRIP: |
| case GL_LINE_LOOP: |
| case GL_LINES: |
| case GL_TRIANGLE_STRIP: |
| case GL_TRIANGLE_FAN: |
| case GL_TRIANGLES: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidDrawType(GLenum mode) { |
| switch (mode) { |
| case GL_UNSIGNED_BYTE: |
| case GL_UNSIGNED_SHORT: |
| case GL_UNSIGNED_INT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidEmulatedCompressedTextureFormats(GLenum type) { |
| // Note: This should be kept in sync with kEmulatedCompressedTextureFormats |
| // in gles_context.cpp. |
| switch (type) { |
| case GL_PALETTE4_R5_G6_B5_OES: |
| case GL_PALETTE4_RGB5_A1_OES: |
| case GL_PALETTE4_RGB8_OES: |
| case GL_PALETTE4_RGBA4_OES: |
| case GL_PALETTE4_RGBA8_OES: |
| case GL_PALETTE8_R5_G6_B5_OES: |
| case GL_PALETTE8_RGB5_A1_OES: |
| case GL_PALETTE8_RGB8_OES: |
| case GL_PALETTE8_RGBA4_OES: |
| case GL_PALETTE8_RGBA8_OES: |
| case GL_ETC1_RGB8_OES: |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidFramebufferAttachment(GLenum attachment) { |
| switch (attachment) { |
| case GL_COLOR_ATTACHMENT0: |
| case GL_DEPTH_ATTACHMENT: |
| case GL_STENCIL_ATTACHMENT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidFramebufferAttachmentParams(GLenum pname) { |
| switch (pname) { |
| case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE: |
| case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: |
| case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL: |
| case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidFramebufferTarget(GLenum target) { |
| return target == GL_FRAMEBUFFER; |
| } |
| |
| bool IsValidFrontFaceMode(GLenum mode) { |
| switch (mode) { |
| case GL_CW: |
| case GL_CCW: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidMatrixIndexPointerSize(GLint size) { |
| return ((size >= 1) && (size <= UniformContext::kMaxVertexUnitsOES)); |
| } |
| |
| bool IsValidMatrixIndexPointerType(GLenum type) { |
| return type == GL_UNSIGNED_BYTE; |
| } |
| |
| bool IsValidMipmapHintMode(GLenum mode) { |
| switch (mode) { |
| case GL_FASTEST: |
| case GL_NICEST: |
| case GL_DONT_CARE: |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidNormalPointerType(GLenum type) { |
| switch (type) { |
| case GL_BYTE: |
| case GL_SHORT: |
| case GL_FLOAT: |
| case GL_FIXED: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidPixelFormat(GLenum format) { |
| switch (format) { |
| case GL_ALPHA: |
| case GL_DEPTH_COMPONENT: |
| case GL_RGB: |
| case GL_RGBA: |
| case GL_LUMINANCE: |
| case GL_LUMINANCE_ALPHA: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidPixelFormatAndType(GLenum format, GLenum type) { |
| switch (format) { |
| 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: |
| return true; |
| } |
| break; |
| case GL_RGB: |
| switch (type) { |
| case GL_UNSIGNED_BYTE: |
| case GL_UNSIGNED_SHORT_5_6_5: |
| return true; |
| } |
| break; |
| case GL_LUMINANCE: |
| case GL_LUMINANCE_ALPHA: |
| case GL_ALPHA: |
| switch (type) { |
| case GL_UNSIGNED_BYTE: |
| return true; |
| } |
| break; |
| } |
| return false; |
| } |
| |
| bool IsValidPixelStoreAlignment(GLint value) { |
| switch (value) { |
| case 1: |
| case 2: |
| case 4: |
| case 8: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidPixelStoreName(GLenum name) { |
| switch (name) { |
| case GL_PACK_ALIGNMENT: |
| case GL_UNPACK_ALIGNMENT: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidPixelType(GLenum type) { |
| switch (type) { |
| case GL_UNSIGNED_BYTE: |
| case GL_UNSIGNED_INT: |
| case GL_UNSIGNED_SHORT: |
| 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_FLOAT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidPointPointerType(GLenum type) { |
| return type == GL_FIXED || type == GL_FLOAT; |
| } |
| |
| bool IsValidPrecisionType(GLenum type) { |
| switch (type) { |
| case GL_LOW_FLOAT: |
| case GL_MEDIUM_FLOAT: |
| case GL_HIGH_FLOAT: |
| case GL_LOW_INT: |
| case GL_MEDIUM_INT: |
| case GL_HIGH_INT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidRenderbufferFormat(GLenum internalformat) { |
| switch (internalformat) { |
| case GL_DEPTH24_STENCIL8_OES: |
| case GL_DEPTH_COMPONENT16_OES: |
| case GL_DEPTH_COMPONENT24_OES: |
| case GL_DEPTH_COMPONENT32_OES: |
| case GL_RGB565_OES: |
| case GL_RGB5_A1_OES: |
| case GL_RGB8_OES: |
| case GL_RGBA4_OES: |
| case GL_RGBA8_OES: |
| case GL_STENCIL_INDEX1_OES: |
| case GL_STENCIL_INDEX4_OES: |
| case GL_STENCIL_INDEX8_OES: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidRenderbufferParams(GLenum pname) { |
| switch (pname) { |
| case GL_RENDERBUFFER_WIDTH: |
| case GL_RENDERBUFFER_HEIGHT: |
| case GL_RENDERBUFFER_INTERNAL_FORMAT: |
| case GL_RENDERBUFFER_RED_SIZE: |
| case GL_RENDERBUFFER_GREEN_SIZE: |
| case GL_RENDERBUFFER_BLUE_SIZE: |
| case GL_RENDERBUFFER_ALPHA_SIZE: |
| case GL_RENDERBUFFER_DEPTH_SIZE: |
| case GL_RENDERBUFFER_STENCIL_SIZE: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidRenderbufferTarget(GLenum target) { |
| return target == GL_RENDERBUFFER; |
| } |
| |
| bool IsValidShaderType(GLenum type) { |
| return type == GL_VERTEX_SHADER || type == GL_FRAGMENT_SHADER; |
| } |
| |
| bool IsValidStencilFunc(GLenum func) { |
| switch (func) { |
| case GL_NEVER: |
| case GL_LESS: |
| case GL_LEQUAL: |
| case GL_GREATER: |
| case GL_GEQUAL: |
| case GL_EQUAL: |
| case GL_NOTEQUAL: |
| case GL_ALWAYS: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTexCoordPointerSize(GLint size) { |
| return ((size >= 2) && (size <= 4)); |
| } |
| |
| bool IsValidTexCoordPointerType(GLenum type) { |
| switch (type) { |
| case GL_BYTE: |
| case GL_SHORT: |
| case GL_FLOAT: |
| case GL_FIXED: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidTexEnv(GLenum target, GLenum pname) { |
| switch (pname) { |
| case GL_TEXTURE_ENV_MODE: |
| case GL_TEXTURE_ENV_COLOR: |
| case GL_COMBINE_RGB: |
| case GL_COMBINE_ALPHA: |
| case GL_SRC0_RGB: |
| case GL_SRC1_RGB: |
| case GL_SRC2_RGB: |
| case GL_SRC0_ALPHA: |
| case GL_SRC1_ALPHA: |
| case GL_SRC2_ALPHA: |
| case GL_OPERAND0_RGB: |
| case GL_OPERAND1_RGB: |
| case GL_OPERAND2_RGB: |
| case GL_OPERAND0_ALPHA: |
| case GL_OPERAND1_ALPHA: |
| case GL_OPERAND2_ALPHA: |
| case GL_RGB_SCALE: |
| case GL_ALPHA_SCALE: |
| case GL_COORD_REPLACE_OES: |
| break; |
| default: |
| return false; |
| } |
| return (target == GL_TEXTURE_ENV || target == GL_POINT_SPRITE_OES); |
| } |
| |
| bool IsValidTexEnvCombineAlpha(GLenum param) { |
| switch (param) { |
| case GL_REPLACE: |
| case GL_MODULATE: |
| case GL_ADD: |
| case GL_ADD_SIGNED: |
| case GL_INTERPOLATE: |
| case GL_SUBTRACT: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTexEnvCombineRgb(GLenum param) { |
| switch (param) { |
| case GL_REPLACE: |
| case GL_MODULATE: |
| case GL_ADD: |
| case GL_ADD_SIGNED: |
| case GL_INTERPOLATE: |
| case GL_SUBTRACT: |
| case GL_DOT3_RGB: |
| case GL_DOT3_RGBA: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTexEnvMode(GLenum param) { |
| switch (param) { |
| case GL_REPLACE: |
| case GL_MODULATE: |
| case GL_DECAL: |
| case GL_BLEND: |
| case GL_ADD: |
| case GL_COMBINE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTexEnvOperandAlpha(GLenum param) { |
| switch (param) { |
| case GL_SRC_ALPHA: |
| case GL_ONE_MINUS_SRC_ALPHA: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTexEnvOperandRgb(GLenum param) { |
| switch (param) { |
| case GL_SRC_COLOR: |
| case GL_ONE_MINUS_SRC_COLOR: |
| case GL_SRC_ALPHA: |
| case GL_ONE_MINUS_SRC_ALPHA: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTexEnvScale(GLfloat scale) { |
| return (scale == 1.f || scale == 2.f || scale == 4.f); |
| } |
| |
| bool IsValidTexEnvSource(GLenum param) { |
| switch (param) { |
| case GL_PREVIOUS: |
| case GL_PRIMARY_COLOR: |
| case GL_TEXTURE: |
| case GL_CONSTANT: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTexGenCoord(GLenum coord) { |
| // GL_S, GL_T and GL_R are not defined in GLES1 and GLES1 headers. |
| // Only GL_TEXTURE_GEN_STR_OES is supported. |
| return coord == GL_TEXTURE_GEN_STR_OES; |
| } |
| |
| bool IsValidTexGenMode(GLenum mode) { |
| // opengles_spec_1_1_extension_pack.pdf 4.1 |
| // Only GL_NORMAL_MAP_OES & GL_REFLECTION_MAP_OES are supported. |
| switch (mode) { |
| case GL_NORMAL_MAP_OES: |
| case GL_REFLECTION_MAP_OES: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTextureDimensions(GLsizei width, GLsizei height, |
| GLint max_texture_size) { |
| if (width < 0 || width > max_texture_size) |
| return false; |
| if (height < 0 || height > max_texture_size) |
| return false; |
| return IsPowerOf2(width) && IsPowerOf2(height); |
| } |
| |
| bool IsValidTextureEnum(GLenum unit, GLuint max_num_textures) { |
| return unit >= GL_TEXTURE0 && unit <= (GL_TEXTURE0 + max_num_textures); |
| } |
| |
| bool IsValidTextureParam(GLenum param) { |
| switch (param) { |
| case GL_GENERATE_MIPMAP: |
| case GL_TEXTURE_CROP_RECT_OES: |
| case GL_TEXTURE_MIN_FILTER: |
| case GL_TEXTURE_MAG_FILTER: |
| case GL_TEXTURE_WRAP_S: |
| case GL_TEXTURE_WRAP_T: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool IsValidTextureTarget(GLenum target) { |
| return target == GL_TEXTURE_2D || target == GL_TEXTURE_CUBE_MAP || |
| target == GL_TEXTURE_EXTERNAL_OES; |
| } |
| |
| bool IsValidTextureTargetAndParam(GLenum target, GLenum pname) { |
| switch (pname) { |
| case GL_TEXTURE_MIN_FILTER: |
| case GL_TEXTURE_MAG_FILTER: |
| case GL_TEXTURE_WRAP_S: |
| case GL_TEXTURE_WRAP_T: |
| case GL_GENERATE_MIPMAP: |
| break; |
| default: |
| return false; |
| } |
| return (target == GL_TEXTURE_2D) || (target == GL_TEXTURE_CUBE_MAP_OES); |
| } |
| |
| bool IsValidTextureTargetEx(GLenum target) { |
| switch (target) { |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES: |
| case GL_TEXTURE_EXTERNAL_OES: |
| case GL_TEXTURE_2D: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidTextureTargetLimited(GLenum target) { |
| return target == GL_TEXTURE_2D || target == GL_TEXTURE_EXTERNAL_OES; |
| } |
| |
| bool IsValidVertexAttribSize(GLint size) { |
| return ((size >= 1) && (size <= 4)); |
| } |
| |
| bool IsValidVertexAttribType(GLenum type) { |
| switch (type) { |
| case GL_BYTE: |
| case GL_UNSIGNED_BYTE: |
| case GL_SHORT: |
| case GL_UNSIGNED_SHORT: |
| case GL_FIXED: |
| case GL_FLOAT: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidVertexPointerSize(GLint size) { |
| return ((size >= 2) && (size <= 4)); |
| } |
| |
| bool IsValidVertexPointerType(GLenum type) { |
| switch (type) { |
| case GL_BYTE: |
| case GL_SHORT: |
| case GL_FLOAT: |
| case GL_FIXED: |
| return true; |
| } |
| return false; |
| } |
| |
| bool IsValidWeightPointerSize(GLint size) { |
| return ((size >= 1) && (size <= UniformContext::kMaxVertexUnitsOES)); |
| } |
| |
| bool IsValidWeightPointerType(GLenum type) { |
| switch (type) { |
| case GL_FIXED: |
| case GL_FLOAT: |
| return true; |
| } |
| return false; |
| } |
