| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2017 The Khronos Group Inc. |
| * |
| * 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. |
| * |
| */ /*! |
| * \file glcPackedPixelsTests.cpp |
| * \brief |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "glcPackedPixelsTests.hpp" |
| #include "deMath.h" |
| #include "glcMisc.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluShaderProgram.hpp" |
| #include "gluStrUtil.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuTestLog.hpp" |
| #include <algorithm> |
| #include <cstring> |
| #include <limits> |
| #include <map> |
| #include <stdio.h> |
| |
| using namespace glw; |
| using namespace glu; |
| |
| namespace glcts |
| { |
| |
| enum |
| { |
| GRADIENT_WIDTH = 7, |
| GRADIENT_HEIGHT = 3 |
| }; |
| |
| enum InputOutputOperation |
| { |
| OUTPUT_GETTEXIMAGE, |
| OUTPUT_READPIXELS, |
| INPUT_TEXIMAGE, |
| }; |
| |
| enum ComponentFormat |
| { |
| FORMAT_STENCIL, // stencil, unsigned int |
| FORMAT_DEPTH, // depth, unsigned [fp|float] |
| FORMAT_DEPTH_STENCIL, // depth+stencil, unsigned [fp|float] |
| FORMAT_COLOR, // color, [signed|unsigned] fp |
| FORMAT_COLOR_INTEGER, // color, [signed|unsigned] int |
| }; |
| |
| enum TypeStorage |
| { |
| STORAGE_UNSIGNED, // unsigned fp/int |
| STORAGE_SIGNED, // signed fp/int |
| STORAGE_FLOAT, // signed/unsigned float |
| }; |
| |
| union InternalFormatBits { |
| struct Bits |
| { |
| int red; // red bits |
| int green; // green bits |
| int blue; // blue bits |
| int alpha; // alpha bits |
| int intensity; // intensity bits |
| int luminance; // luminance bits |
| int depth; // depth bits |
| int stencil; // stencil bits |
| int exponent; // shared exponent bits |
| } bits; |
| int array[9]; // all the bits |
| }; |
| |
| struct PixelType |
| { |
| GLenum type; |
| int size; |
| int storage; |
| bool special; |
| bool reversed; |
| InternalFormatBits bits; |
| bool clamp; |
| }; |
| |
| struct PixelFormat |
| { |
| GLenum format; // format name |
| int components; // number of components |
| int componentFormat; // element meaning |
| GLenum attachment; // target buffer |
| InternalFormatBits componentOrder; // zero based element order, -1 for N/A |
| }; |
| |
| enum InternalFormatSamplerType |
| { |
| SAMPLER_UNORM = 0, // unsigned normalized |
| SAMPLER_NORM, // normalized |
| SAMPLER_UINT, // unsigned integer |
| SAMPLER_INT, // integer |
| SAMPLER_FLOAT // floating-point |
| }; |
| |
| enum InternalFormatFlag |
| { |
| FLAG_PACKED = 1, // packed pixel format |
| FLAG_COMPRESSED = 2, // compressed format |
| FLAG_REQ_RBO_GL42 = 4, // required RBO & tex format in OpenGL 4.2 |
| FLAG_REQ_RBO_ES30 = 8, // required RBO & tex format in OpenGL ES 3.0 |
| FLAG_REQ_RBO = FLAG_REQ_RBO_GL42 | FLAG_REQ_RBO_ES30, // Required RBO & tex format in both |
| }; |
| |
| struct InternalFormat |
| { |
| GLenum sizedFormat; |
| GLenum baseFormat; |
| GLenum format; |
| GLenum type; |
| InternalFormatSamplerType sampler; |
| InternalFormatBits bits; |
| int flags; // InternalFormatFlag |
| }; |
| |
| struct EnumFormats |
| { |
| GLenum internalformat; |
| GLenum format; |
| GLenum type; |
| int size; |
| bool bRenderable; |
| }; |
| |
| #define PACK_DEFAULTI (0) |
| #define PACK_DEFAULTUI (0) |
| #define PACK_DEFAULTF (-2.0f) |
| |
| static const InternalFormat coreInternalformats[] = |
| { |
| { GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,16, 0, 0 } }, 0 }, |
| { GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_UNSIGNED_INT, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,24, 8, 0 } }, 0 }, |
| { GL_RED, GL_RED, GL_RED, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RG, GL_RG, GL_RG, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_R8, GL_RED, GL_RED, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R8_SNORM, GL_RED, GL_RED, GL_BYTE, SAMPLER_NORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_R16, GL_RED, GL_RED, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_R16_SNORM, GL_RED, GL_RED, GL_SHORT, SAMPLER_NORM, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RG8, GL_RG, GL_RG, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG8_SNORM, GL_RG, GL_RG, GL_BYTE, SAMPLER_NORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RG16, GL_RG, GL_RG, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RG16_SNORM, GL_RG, GL_RG, GL_SHORT, SAMPLER_NORM, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_R3_G3_B2, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE_3_3_2, SAMPLER_UNORM, { { 3, 3, 2, 0, 0, 0, 0, 0, 0 } }, FLAG_PACKED }, |
| { GL_RGB4, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 4, 4, 4, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB5, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 5, 5, 5, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB8, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_ES30 }, |
| { GL_RGB8_SNORM, GL_RGB, GL_RGB, GL_BYTE, SAMPLER_NORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB10, GL_RGB, GL_RGB, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { {10,10,10, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB12, GL_RGB, GL_RGB, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { {12,12,12, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB16, GL_RGB, GL_RGB, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB16_SNORM, GL_RGB, GL_RGB, GL_SHORT, SAMPLER_NORM, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA2, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 2, 2, 2, 2, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA4, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, SAMPLER_UNORM, { { 4, 4, 4, 4, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO }, |
| { GL_RGB5_A1, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, SAMPLER_UNORM, { { 5, 5, 5, 1, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO }, |
| { GL_RGBA8, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA8_SNORM, GL_RGBA, GL_RGBA, GL_BYTE, SAMPLER_NORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB10_A2, GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_10_10_10_2, SAMPLER_UNORM, { {10,10,10, 2, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO_GL42 }, |
| { GL_RGB10_A2UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_INT_10_10_10_2, SAMPLER_UINT, { {10,10,10, 2, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO_GL42 }, |
| { GL_RGBA12, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { {12,12,12,12, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA16, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { {16,16,16,16, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RGBA16_SNORM, GL_RGBA, GL_RGBA, GL_SHORT, SAMPLER_NORM, { {16,16,16,16, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_SRGB8, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_SRGB8_ALPHA8, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R16F, GL_RED, GL_RED, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RG16F, GL_RG, GL_RG, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RGB16F, GL_RGB, GL_RGB, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA16F, GL_RGBA, GL_RGBA, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16,16,16,16, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_R32F, GL_RED, GL_RED, GL_FLOAT, SAMPLER_FLOAT, { {32, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RG32F, GL_RG, GL_RG, GL_FLOAT, SAMPLER_FLOAT, { {32,32, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RGB32F, GL_RGB, GL_RGB, GL_FLOAT, SAMPLER_FLOAT, { {32,32,32, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA32F, GL_RGBA, GL_RGBA, GL_FLOAT, SAMPLER_FLOAT, { {32,32,32,32, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_R11F_G11F_B10F, GL_RGB, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, SAMPLER_FLOAT, { {11,11,10, 0, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO_GL42 }, |
| { GL_RGB9_E5, GL_RGB, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV, SAMPLER_FLOAT, { { 9, 9, 9, 0, 0, 0, 0, 0, 5 } }, FLAG_PACKED }, |
| { GL_R8I, GL_RED, GL_RED_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R8UI, GL_RED, GL_RED_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R16I, GL_RED, GL_RED_INTEGER, GL_SHORT, SAMPLER_INT, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R16UI, GL_RED, GL_RED_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R32I, GL_RED, GL_RED_INTEGER, GL_INT, SAMPLER_INT, { {32, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R32UI, GL_RED, GL_RED_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG8I, GL_RG, GL_RG_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG8UI, GL_RG, GL_RG_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG16I, GL_RG, GL_RG_INTEGER, GL_SHORT, SAMPLER_INT, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG16UI, GL_RG, GL_RG_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG32I, GL_RG, GL_RG_INTEGER, GL_INT, SAMPLER_INT, { {32,32, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG32UI, GL_RG, GL_RG_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32,32, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGB8I, GL_RGB, GL_RGB_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB8UI, GL_RGB, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB16I, GL_RGB, GL_RGB_INTEGER, GL_SHORT, SAMPLER_INT, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB16UI, GL_RGB, GL_RGB_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB32I, GL_RGB, GL_RGB_INTEGER, GL_INT, SAMPLER_INT, { {32,32,32, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB32UI, GL_RGB, GL_RGB_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32,32,32, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA8I, GL_RGBA, GL_RGBA_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA8UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA16I, GL_RGBA, GL_RGBA_INTEGER, GL_SHORT, SAMPLER_INT, { {16,16,16,16, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA16UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16,16,16,16, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA32I, GL_RGBA, GL_RGBA_INTEGER, GL_INT, SAMPLER_INT, { {32,32,32,32, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA32UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32,32,32,32, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,16, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,24, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH_COMPONENT32, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,32, 0, 0 } }, 0 }, |
| { GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_FLOAT, SAMPLER_FLOAT, { { 0, 0, 0, 0, 0, 0,32, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,24, 8, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, SAMPLER_FLOAT, { { 0, 0, 0, 0, 0, 0,32, 8, 0 } }, FLAG_PACKED|FLAG_REQ_RBO }, |
| { GL_COMPRESSED_RED, GL_RED, GL_RED, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_RG, GL_RG, GL_RG, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_RGB, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_RGBA, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_SRGB, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_SRGB_ALPHA, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_RED_RGTC1, GL_RED, GL_RED, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_SIGNED_RED_RGTC1, GL_RED, GL_RED, GL_BYTE, SAMPLER_NORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_RG_RGTC2, GL_RG, GL_RG, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| { GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_RG, GL_BYTE, SAMPLER_NORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_COMPRESSED }, |
| }; |
| |
| static InternalFormat esInternalformats[] = |
| { |
| { GL_LUMINANCE, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 8, 0, 0, 0 } }, 0 }, |
| { GL_ALPHA, GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 0, 0, 0, 8, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 0, 0, 0, 8, 0, 8, 0, 0, 0 } }, 0 }, |
| { GL_RGB, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_R8, GL_RED, GL_RED, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R8_SNORM, GL_RED, GL_RED, GL_BYTE, SAMPLER_NORM, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RG8, GL_RG, GL_RG, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG8_SNORM, GL_RG, GL_RG, GL_BYTE, SAMPLER_NORM, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB8, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_ES30 }, |
| { GL_RGB8_SNORM, GL_RGB, GL_RGB, GL_BYTE, SAMPLER_NORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB565, GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, SAMPLER_UNORM, { { 5, 6, 5, 0, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO }, |
| { GL_RGBA4, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, SAMPLER_UNORM, { { 4, 4, 4, 4, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO }, |
| { GL_RGB5_A1, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, SAMPLER_UNORM, { { 5, 5, 5, 1, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO }, |
| { GL_RGBA8, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA8_SNORM, GL_RGBA, GL_RGBA, GL_BYTE, SAMPLER_NORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB10_A2, GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, SAMPLER_UNORM, { {10,10,10, 2, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO_ES30 }, |
| { GL_RGB10_A2UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV, SAMPLER_UINT, { {10,10,10, 2, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO_ES30 }, |
| { GL_SRGB8, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_SRGB8_ALPHA8, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, SAMPLER_UNORM, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R16F, GL_RED, GL_RED, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RG16F, GL_RG, GL_RG, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RGB16F, GL_RGB, GL_RGB, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA16F, GL_RGBA, GL_RGBA, GL_HALF_FLOAT, SAMPLER_FLOAT, { {16,16,16,16, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_R32F, GL_RED, GL_RED, GL_FLOAT, SAMPLER_FLOAT, { {32, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RG32F, GL_RG, GL_RG, GL_FLOAT, SAMPLER_FLOAT, { {32,32, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_RGB32F, GL_RGB, GL_RGB, GL_FLOAT, SAMPLER_FLOAT, { {32,32,32, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA32F, GL_RGBA, GL_RGBA, GL_FLOAT, SAMPLER_FLOAT, { {32,32,32,32, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO_GL42 }, |
| { GL_R11F_G11F_B10F, GL_RGB, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, SAMPLER_FLOAT, { {11,11,10, 0, 0, 0, 0, 0, 0 } }, FLAG_PACKED|FLAG_REQ_RBO_GL42 }, |
| { GL_RGB9_E5, GL_RGB, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV, SAMPLER_FLOAT, { { 9, 9, 9, 0, 0, 0, 0, 0, 5 } }, FLAG_PACKED }, |
| { GL_R8I, GL_RED, GL_RED_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R8UI, GL_RED, GL_RED_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R16I, GL_RED, GL_RED_INTEGER, GL_SHORT, SAMPLER_INT, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R16UI, GL_RED, GL_RED_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R32I, GL_RED, GL_RED_INTEGER, GL_INT, SAMPLER_INT, { {32, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_R32UI, GL_RED, GL_RED_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32, 0, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG8I, GL_RG, GL_RG_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG8UI, GL_RG, GL_RG_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 8, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG16I, GL_RG, GL_RG_INTEGER, GL_SHORT, SAMPLER_INT, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG16UI, GL_RG, GL_RG_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16,16, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG32I, GL_RG, GL_RG_INTEGER, GL_INT, SAMPLER_INT, { {32,32, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RG32UI, GL_RG, GL_RG_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32,32, 0, 0, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGB8I, GL_RGB, GL_RGB_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB8UI, GL_RGB, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 8, 8, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB16I, GL_RGB, GL_RGB_INTEGER, GL_SHORT, SAMPLER_INT, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB16UI, GL_RGB, GL_RGB_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16,16,16, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB32I, GL_RGB, GL_RGB_INTEGER, GL_INT, SAMPLER_INT, { {32,32,32, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGB32UI, GL_RGB, GL_RGB_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32,32,32, 0, 0, 0, 0, 0, 0 } }, 0 }, |
| { GL_RGBA8I, GL_RGBA, GL_RGBA_INTEGER, GL_BYTE, SAMPLER_INT, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA8UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, SAMPLER_UINT, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA16I, GL_RGBA, GL_RGBA_INTEGER, GL_SHORT, SAMPLER_INT, { {16,16,16,16, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA16UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, SAMPLER_UINT, { {16,16,16,16, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA32I, GL_RGBA, GL_RGBA_INTEGER, GL_INT, SAMPLER_INT, { {32,32,32,32, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_RGBA32UI, GL_RGBA, GL_RGBA_INTEGER, GL_UNSIGNED_INT, SAMPLER_UINT, { {32,32,32,32, 0, 0, 0, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,16, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,24, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_FLOAT, SAMPLER_FLOAT, { { 0, 0, 0, 0, 0, 0,32, 0, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, SAMPLER_UNORM, { { 0, 0, 0, 0, 0, 0,24, 8, 0 } }, FLAG_REQ_RBO }, |
| { GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, SAMPLER_FLOAT, { { 0, 0, 0, 0, 0, 0,32, 8, 0 } }, FLAG_PACKED|FLAG_REQ_RBO }, |
| }; |
| |
| static const PixelFormat coreFormats[] = { |
| { GL_STENCIL_INDEX, 1, FORMAT_STENCIL, GL_STENCIL_ATTACHMENT, { {-1,-1,-1,-1,-1,-1,-1, 0,-1} } }, |
| { GL_DEPTH_COMPONENT, 1, FORMAT_DEPTH, GL_DEPTH_ATTACHMENT, { {-1,-1,-1,-1,-1,-1, 0,-1,-1} } }, |
| { GL_DEPTH_STENCIL, 2, FORMAT_DEPTH_STENCIL, GL_DEPTH_STENCIL_ATTACHMENT, { {-1,-1,-1,-1,-1,-1, 0, 1,-1} } }, |
| { GL_RED, 1, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0,-1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_GREEN, 1, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { {-1, 0,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_BLUE, 1, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { {-1,-1, 0,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RG, 2, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0, 1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGB, 3, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0, 1, 2,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGBA, 4, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0, 1, 2, 3,-1,-1,-1,-1,-1} } }, |
| { GL_BGR, 3, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 2, 1, 0,-1,-1,-1,-1,-1,-1} } }, |
| { GL_BGRA, 4, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 2, 1, 0, 3,-1,-1,-1,-1,-1} } }, |
| { GL_RED_INTEGER, 1, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0,-1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_GREEN_INTEGER, 1, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { {-1, 0,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_BLUE_INTEGER, 1, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { {-1,-1, 0,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RG_INTEGER, 2, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0, 1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGB_INTEGER, 3, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0, 1, 2,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGBA_INTEGER, 4, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0, 1, 2, 3,-1,-1,-1,-1,-1} } }, |
| { GL_BGR_INTEGER, 3, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 2, 1, 0,-1,-1,-1,-1,-1,-1} } }, |
| { GL_BGRA_INTEGER, 4, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 2, 1, 0, 3,-1,-1,-1,-1,-1} } }, |
| }; |
| |
| static const PixelFormat esFormats[] = { |
| { GL_DEPTH_COMPONENT, 1, FORMAT_DEPTH, GL_DEPTH_ATTACHMENT, { {-1,-1,-1,-1,-1,-1, 0,-1,-1} } }, |
| { GL_DEPTH_STENCIL, 2, FORMAT_DEPTH_STENCIL, GL_DEPTH_STENCIL_ATTACHMENT, { {-1,-1,-1,-1,-1,-1, 0, 1,-1} } }, |
| { GL_RED, 1, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0,-1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RG, 2, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0, 1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGB, 3, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0, 1, 2,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGBA, 4, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { { 0, 1, 2, 3,-1,-1,-1,-1,-1} } }, |
| { GL_LUMINANCE, 1, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { {-1,-1,-1,-1,-1, 0,-1,-1,-1} } }, |
| { GL_ALPHA, 1, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { {-1,-1,-1, 0,-1,-1,-1,-1,-1} } }, |
| { GL_LUMINANCE_ALPHA, 2, FORMAT_COLOR, GL_COLOR_ATTACHMENT0, { {-1,-1,-1, 1,-1, 0,-1,-1,-1} } }, |
| { GL_RED_INTEGER, 1, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0,-1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RG_INTEGER, 2, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0, 1,-1,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGB_INTEGER, 3, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0, 1, 2,-1,-1,-1,-1,-1,-1} } }, |
| { GL_RGBA_INTEGER, 4, FORMAT_COLOR_INTEGER, GL_COLOR_ATTACHMENT0, { { 0, 1, 2, 3,-1,-1,-1,-1,-1} } }, |
| }; |
| |
| static const PixelType coreTypes[] = { |
| { GL_UNSIGNED_BYTE, sizeof(GLubyte), STORAGE_UNSIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_BYTE, sizeof(GLbyte), STORAGE_SIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_UNSIGNED_SHORT, sizeof(GLushort), STORAGE_UNSIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_SHORT, sizeof(GLshort), STORAGE_SIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_UNSIGNED_INT, sizeof(GLuint), STORAGE_UNSIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_INT, sizeof(GLint), STORAGE_SIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_HALF_FLOAT, sizeof(GLhalf), STORAGE_FLOAT, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_FLOAT, sizeof(GLfloat), STORAGE_FLOAT, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_5_6_5, sizeof(GLushort), STORAGE_UNSIGNED, true, false, { { 5, 6, 5, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_4_4_4_4, sizeof(GLushort), STORAGE_UNSIGNED, true, false, { { 4, 4, 4, 4, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_5_5_5_1, sizeof(GLushort), STORAGE_UNSIGNED, true, false, { { 5, 5, 5, 1, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_2_10_10_10_REV, sizeof(GLuint), STORAGE_UNSIGNED, true, true, { {10,10,10, 2, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_24_8, sizeof(GLuint), STORAGE_UNSIGNED, true, false, { { 0, 0, 0, 0, 0, 0,24, 8, 0 } }, false }, |
| { GL_UNSIGNED_INT_10F_11F_11F_REV, sizeof(GLuint), STORAGE_FLOAT, true, true, { { 6, 7, 7, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_5_9_9_9_REV, sizeof(GLuint), STORAGE_FLOAT, true, true, { { 9, 9, 9, 5, 0, 0, 0, 0, 0 } }, false }, |
| { GL_FLOAT_32_UNSIGNED_INT_24_8_REV, sizeof(GLfloat)+sizeof(GLuint), STORAGE_FLOAT, true, true, { { 0, 0, 0, 0, 0, 0,32, 8,24 } }, false }, |
| { GL_UNSIGNED_BYTE_3_3_2, sizeof(GLubyte), STORAGE_UNSIGNED, true, false, { { 3, 3, 2, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_BYTE_2_3_3_REV, sizeof(GLubyte), STORAGE_UNSIGNED, true, true, { { 3, 3, 2, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_5_6_5_REV, sizeof(GLushort), STORAGE_UNSIGNED, true, true, { { 5, 6, 5, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_4_4_4_4_REV, sizeof(GLushort), STORAGE_UNSIGNED, true, true, { { 4, 4, 4, 4, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_1_5_5_5_REV, sizeof(GLushort), STORAGE_UNSIGNED, true, true, { { 5, 5, 5, 1, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_8_8_8_8, sizeof(GLuint), STORAGE_UNSIGNED, true, false, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_8_8_8_8_REV, sizeof(GLuint), STORAGE_UNSIGNED, true, true, { { 8, 8, 8, 8, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_10_10_10_2, sizeof(GLuint), STORAGE_UNSIGNED, true, true, { {10,10,10, 2, 0, 0, 0, 0, 0 } }, false }, |
| }; |
| |
| static const PixelType esTypes[] = { |
| { GL_UNSIGNED_BYTE, sizeof(GLubyte), STORAGE_UNSIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_BYTE, sizeof(GLbyte), STORAGE_SIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_UNSIGNED_SHORT, sizeof(GLushort), STORAGE_UNSIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_SHORT, sizeof(GLshort), STORAGE_SIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, true }, |
| { GL_UNSIGNED_INT, sizeof(GLuint), STORAGE_UNSIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_INT, sizeof(GLint), STORAGE_SIGNED, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_HALF_FLOAT, sizeof(GLhalf), STORAGE_FLOAT, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_FLOAT, sizeof(GLfloat), STORAGE_FLOAT, false, false, { { 0, 0, 0, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_5_6_5, sizeof(GLushort), STORAGE_UNSIGNED, true, false, { { 5, 6, 5, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_4_4_4_4, sizeof(GLushort), STORAGE_UNSIGNED, true, false, { { 4, 4, 4, 4, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_SHORT_5_5_5_1, sizeof(GLushort), STORAGE_UNSIGNED, true, false, { { 5, 5, 5, 1, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_2_10_10_10_REV, sizeof(GLuint), STORAGE_UNSIGNED, true, true, { {10,10,10, 2, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_24_8, sizeof(GLuint), STORAGE_UNSIGNED, true, false, { { 0, 0, 0, 0, 0, 0,24, 8, 0 } }, false }, |
| { GL_UNSIGNED_INT_10F_11F_11F_REV, sizeof(GLuint), STORAGE_FLOAT, true, true, { { 6, 7, 7, 0, 0, 0, 0, 0, 0 } }, false }, |
| { GL_UNSIGNED_INT_5_9_9_9_REV, sizeof(GLuint), STORAGE_FLOAT, true, true, { { 9, 9, 9, 5, 0, 0, 0, 0, 0 } }, false }, |
| { GL_FLOAT_32_UNSIGNED_INT_24_8_REV, sizeof(GLfloat)+sizeof(GLuint), STORAGE_FLOAT, true, true, { { 0, 0, 0, 0, 0, 0,32, 8,24 } }, false }, |
| }; |
| |
| static const EnumFormats esValidFormats[] = { |
| { GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, 4, true }, |
| { GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_BYTE, 4, true }, |
| { GL_RGBA4, GL_RGBA, GL_UNSIGNED_BYTE, 4, true }, |
| { GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, 4, true }, |
| { GL_RGBA8_SNORM, GL_RGBA, GL_BYTE, 4, false }, |
| { GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 2, true }, |
| { GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 2, true }, |
| { GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 4, true }, |
| { GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 4, true }, |
| { GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, 8, false }, |
| { GL_RGBA32F, GL_RGBA, GL_FLOAT, 16, false }, |
| { GL_RGBA16F, GL_RGBA, GL_FLOAT, 16, false }, |
| { GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, 4, true }, |
| { GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE, 4, true }, |
| { GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, 8, true }, |
| { GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT, 8, true }, |
| { GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, 16, true }, |
| { GL_RGBA32I, GL_RGBA_INTEGER, GL_INT, 16, true }, |
| { GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV, 4, true }, |
| { GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE, 3, true }, |
| { GL_RGB565, GL_RGB, GL_UNSIGNED_BYTE, 3, true }, |
| { GL_SRGB8, GL_RGB, GL_UNSIGNED_BYTE, 3, false }, |
| { GL_RGB8_SNORM, GL_RGB, GL_BYTE, 3, false }, |
| { GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 2, true }, |
| { GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, 4, false }, |
| { GL_R11F_G11F_B10F, GL_RGB, GL_HALF_FLOAT, 6, false }, |
| { GL_R11F_G11F_B10F, GL_RGB, GL_FLOAT, 12, false }, |
| { GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV, 4, false }, |
| { GL_RGB9_E5, GL_RGB, GL_HALF_FLOAT, 6, false }, |
| { GL_RGB9_E5, GL_RGB, GL_FLOAT, 12, false }, |
| { GL_RGB16F, GL_RGB, GL_HALF_FLOAT, 6, false }, |
| { GL_RGB32F, GL_RGB, GL_FLOAT, 12, false }, |
| { GL_RGB16F, GL_RGB, GL_FLOAT, 12, false }, |
| { GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE, 3, false }, |
| { GL_RGB8I, GL_RGB_INTEGER, GL_BYTE, 3, false }, |
| { GL_RGB16UI, GL_RGB_INTEGER, GL_UNSIGNED_SHORT, 6, false }, |
| { GL_RGB16I, GL_RGB_INTEGER, GL_SHORT, 6, false }, |
| { GL_RGB32UI, GL_RGB_INTEGER, GL_UNSIGNED_INT, 12, false }, |
| { GL_RGB32I, GL_RGB_INTEGER, GL_INT, 12, false }, |
| { GL_RG8, GL_RG, GL_UNSIGNED_BYTE, 2, true }, |
| { GL_RG8_SNORM, GL_RG, GL_BYTE, 2, false }, |
| { GL_RG16F, GL_RG, GL_HALF_FLOAT, 4, false }, |
| { GL_RG32F, GL_RG, GL_FLOAT, 8, false }, |
| { GL_RG16F, GL_RG, GL_FLOAT, 8, false }, |
| { GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE, 2, true }, |
| { GL_RG8I, GL_RG_INTEGER, GL_BYTE, 2, true }, |
| { GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, 4, true }, |
| { GL_RG16I, GL_RG_INTEGER, GL_SHORT, 4, true }, |
| { GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, 8, true }, |
| { GL_RG32I, GL_RG_INTEGER, GL_INT, 8, true }, |
| { GL_R8, GL_RED, GL_UNSIGNED_BYTE, 1, true }, |
| { GL_R8_SNORM, GL_RED, GL_BYTE, 1, false }, |
| { GL_R16F, GL_RED, GL_HALF_FLOAT, 2, false }, |
| { GL_R32F, GL_RED, GL_FLOAT, 4, false }, |
| { GL_R16F, GL_RED, GL_FLOAT, 4, false }, |
| { GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, 1, true }, |
| { GL_R8I, GL_RED_INTEGER, GL_BYTE, 1, true }, |
| { GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT, 2, true }, |
| { GL_R16I, GL_RED_INTEGER, GL_SHORT, 2, true }, |
| { GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, 4, true }, |
| { GL_R32I, GL_RED_INTEGER, GL_INT, 4, true }, |
| { GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 4, true }, |
| { GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, 4, true }, |
| { GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, 2, true }, |
| { GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, 4, true }, |
| { GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 4, true }, |
| { GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, 8, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 2, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 2, true }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_BYTE, 3, true }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 2, true }, |
| { GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, 2, false }, |
| { GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE, 1, false }, |
| { GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE, 1, false }, |
| }; |
| |
| static const EnumFormats coreValidFormats[] = { |
| { GL_RGB, GL_RGB, GL_UNSIGNED_BYTE_3_3_2, 3, true }, |
| { GL_RGB_INTEGER, GL_RGB_INTEGER, GL_UNSIGNED_BYTE_3_3_2, 3, true }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_BYTE_2_3_3_REV, 3, true }, |
| { GL_RGB_INTEGER, GL_RGB_INTEGER, GL_UNSIGNED_BYTE_2_3_3_REV, 3, true }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, 3, true }, |
| { GL_RGB_INTEGER, GL_RGB_INTEGER, GL_UNSIGNED_SHORT_5_6_5, 3, true }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, 3, true }, |
| { GL_RGB_INTEGER, GL_RGB_INTEGER, GL_UNSIGNED_SHORT_5_6_5_REV, 3, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT_4_4_4_4, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT_4_4_4_4_REV, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_SHORT_4_4_4_4_REV, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_SHORT_4_4_4_4, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_SHORT_5_5_5_1, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT_5_5_5_1, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_SHORT_5_5_5_1, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT_1_5_5_5_REV, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_SHORT_1_5_5_5_REV, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_INT_8_8_8_8, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_INT_8_8_8_8, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_INT_8_8_8_8_REV, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_INT_8_8_8_8_REV, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_10_10_10_2, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_INT_10_10_10_2, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_INT_10_10_10_2, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_INT_10_10_10_2, 4, true }, |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, 4, true }, |
| { GL_BGRA, GL_BGRA, GL_UNSIGNED_INT_2_10_10_10_REV, 4, true }, |
| { GL_RGBA_INTEGER, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV, 4, true }, |
| { GL_BGRA_INTEGER, GL_BGRA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV, 4, true }, |
| { GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, 2, true }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, 3, true }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV, 4, true }, |
| { GL_DEPTH_STENCIL, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, 2, true }, |
| }; |
| |
| static const EnumFormats validformats_EXT_texture_type_2_10_10_10_REV[] = { |
| { GL_RGBA, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV_EXT, 4, false }, |
| { GL_RGB, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV_EXT, 3, false } |
| }; |
| |
| // Valid combinations given by GL_EXT_texture_type_2_10_10_10_REV and |
| // GL_OES_required_internalformat extensions |
| static const EnumFormats validformats_OES_required_internalformat[] = { |
| { GL_RGB8_OES, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV_EXT, 3, true }, |
| { GL_RGB565, GL_RGB, GL_UNSIGNED_INT_2_10_10_10_REV_EXT, 4, true } |
| }; |
| |
| // Companion type for GL_FLOAT_32_UNSIGNED_INT_24_8_REV. Stencil part was |
| // not split into 24/8 to avoid any packing related issues from compiler. |
| struct F_32_UINT_24_8_REV |
| { |
| GLfloat d; |
| GLuint s; |
| }; |
| |
| // custom pixel data type. holds both float and integer pixel data. memory consuming, but |
| // it is not that relavant in this case. makes comparing more reliable and flexible |
| struct FloatPixel |
| { |
| int i_r; |
| int i_g; |
| int i_b; |
| int i_a; |
| int i_d; |
| int i_s; |
| |
| unsigned int ui_r; |
| unsigned int ui_g; |
| unsigned int ui_b; |
| unsigned int ui_a; |
| unsigned int ui_d; |
| unsigned int ui_s; |
| |
| float r; |
| float g; |
| float b; |
| float a; |
| float d; |
| float s; |
| }; |
| |
| static const int NUM_FLOAT_PIXEL_COUNT = sizeof(FloatPixel) / sizeof(float); |
| |
| typedef int rawIntPixel[4]; |
| typedef unsigned int rawUintPixel[4]; |
| typedef float rawFloatPixel[4]; |
| |
| struct PackedPixelsBufferProperties |
| { |
| int elementsInGroup; // number of elements in a group |
| int rowLength; // number of groups in the row |
| int alignment; // alignment (in bytes) |
| int elementSize; // size of an element (in bytes) |
| int elementsInRow; // row size (in elements) |
| int elementsInRowNoAlign; // row size (in elements) without alignment |
| int rowCount; // number of rows in 2D image |
| int imagesCount; // number of 2D images in 3D image |
| int skipPixels; // (UN)PACK_SKIP_PIXELS |
| int skipRows; // (UN)PACK_SKIP_ROWS |
| int skipImages; // (UN)PACK_SKIP_IMAGES |
| int swapBytes; |
| int lsbFirst; |
| }; |
| |
| std::string getTypeStr(GLenum type) |
| { |
| // this function extends glu::getTypeStr by types used in this tests |
| |
| typedef std::map<GLenum, std::string> TypeMap; |
| static TypeMap typeMap; |
| if (typeMap.empty()) |
| { |
| typeMap[GL_UNSIGNED_BYTE_3_3_2] = "GL_UNSIGNED_BYTE_3_3_2"; |
| typeMap[GL_UNSIGNED_BYTE_2_3_3_REV] = "GL_UNSIGNED_BYTE_2_3_3_REV"; |
| typeMap[GL_UNSIGNED_SHORT_5_6_5_REV] = "GL_UNSIGNED_SHORT_5_6_5_REV"; |
| typeMap[GL_UNSIGNED_SHORT_4_4_4_4_REV] = "GL_UNSIGNED_SHORT_4_4_4_4_REV"; |
| typeMap[GL_UNSIGNED_SHORT_1_5_5_5_REV] = "GL_UNSIGNED_SHORT_1_5_5_5_REV"; |
| typeMap[GL_UNSIGNED_INT_8_8_8_8] = "GL_UNSIGNED_INT_8_8_8_8"; |
| typeMap[GL_UNSIGNED_INT_8_8_8_8_REV] = "GL_UNSIGNED_INT_8_8_8_8_REV"; |
| typeMap[GL_UNSIGNED_INT_10_10_10_2] = "GL_UNSIGNED_INT_10_10_10_2"; |
| } |
| |
| TypeMap::iterator it = typeMap.find(type); |
| if (it == typeMap.end()) |
| { |
| // if type is not in map use glu function |
| return glu::getTypeStr(type).toString(); |
| } |
| return it->second; |
| } |
| |
| std::string getFormatStr(GLenum format) |
| { |
| // this function extends glu::getTextureFormatStr by types used in this tests |
| |
| typedef std::map<GLenum, std::string> FormatMap; |
| static FormatMap formatMap; |
| if (formatMap.empty()) |
| { |
| formatMap[GL_GREEN] = "GL_GREEN"; |
| formatMap[GL_BLUE] = "GL_BLUE"; |
| formatMap[GL_GREEN_INTEGER] = "GL_GREEN_INTEGER"; |
| formatMap[GL_BLUE_INTEGER] = "GL_BLUE_INTEGER"; |
| formatMap[GL_BGR] = "GL_BGR"; |
| formatMap[GL_BGR_INTEGER] = "GL_BGR_INTEGER"; |
| formatMap[GL_BGRA_INTEGER] = "GL_BGRA_INTEGER"; |
| formatMap[GL_R3_G3_B2] = "GL_R3_G3_B2"; |
| formatMap[GL_RGB4] = "GL_RGB4"; |
| formatMap[GL_RGB5] = "GL_RGB5"; |
| formatMap[GL_RGB12] = "GL_RGB12"; |
| formatMap[GL_RGBA2] = "GL_RGBA2"; |
| formatMap[GL_RGBA12] = "GL_RGBA12"; |
| formatMap[GL_COMPRESSED_RED] = "GL_COMPRESSED_RED"; |
| formatMap[GL_COMPRESSED_RG] = "GL_COMPRESSED_RG"; |
| formatMap[GL_COMPRESSED_RGB] = "GL_COMPRESSED_RGB"; |
| formatMap[GL_COMPRESSED_RGBA] = "GL_COMPRESSED_RGBA"; |
| formatMap[GL_COMPRESSED_SRGB] = "GL_COMPRESSED_SRGB"; |
| formatMap[GL_COMPRESSED_SRGB_ALPHA] = "GL_COMPRESSED_SRGB_ALPHA"; |
| formatMap[GL_COMPRESSED_RED_RGTC1] = "GL_COMPRESSED_RED_RGTC1"; |
| formatMap[GL_COMPRESSED_SIGNED_RED_RGTC1] = "GL_COMPRESSED_SIGNED_RED_RGTC1"; |
| formatMap[GL_COMPRESSED_RG_RGTC2] = "GL_COMPRESSED_RG_RGTC2"; |
| formatMap[GL_COMPRESSED_SIGNED_RG_RGTC2] = "GL_COMPRESSED_SIGNED_RG_RGTC2"; |
| formatMap[GL_STENCIL_INDEX] = "GL_STENCIL_INDEX"; |
| } |
| |
| FormatMap::iterator it = formatMap.find(format); |
| if (it == formatMap.end()) |
| { |
| // if format is not in map use glu function |
| return glu::getTextureFormatStr(format).toString(); |
| } |
| return it->second; |
| } |
| |
| std::string getModeStr(GLenum type) |
| { |
| typedef std::map<GLenum, std::string> ModeMap; |
| static ModeMap modeMap; |
| if (modeMap.empty()) |
| { |
| modeMap[GL_UNPACK_ROW_LENGTH] = "GL_UNPACK_ROW_LENGTH"; |
| modeMap[GL_UNPACK_SKIP_ROWS] = "GL_UNPACK_SKIP_ROWS"; |
| modeMap[GL_UNPACK_SKIP_PIXELS] = "GL_UNPACK_SKIP_PIXELS"; |
| modeMap[GL_UNPACK_ALIGNMENT] = "GL_UNPACK_ALIGNMENT"; |
| modeMap[GL_UNPACK_IMAGE_HEIGHT] = "GL_UNPACK_IMAGE_HEIGHT"; |
| modeMap[GL_UNPACK_SKIP_IMAGES] = "GL_UNPACK_SKIP_IMAGES"; |
| modeMap[GL_PACK_ROW_LENGTH] = "GL_PACK_ROW_LENGTH"; |
| modeMap[GL_PACK_SKIP_ROWS] = "GL_PACK_SKIP_ROWS"; |
| modeMap[GL_PACK_SKIP_PIXELS] = "GL_PACK_SKIP_PIXELS"; |
| modeMap[GL_PACK_ALIGNMENT] = "GL_PACK_ALIGNMENT"; |
| modeMap[GL_UNPACK_SWAP_BYTES] = "GL_UNPACK_SWAP_BYTES"; |
| modeMap[GL_UNPACK_LSB_FIRST] = "GL_UNPACK_LSB_FIRST"; |
| modeMap[GL_PACK_SWAP_BYTES] = "GL_PACK_SWAP_BYTES"; |
| modeMap[GL_PACK_LSB_FIRST] = "GL_PACK_LSB_FIRST"; |
| modeMap[GL_PACK_IMAGE_HEIGHT] = "GL_PACK_IMAGE_HEIGHT"; |
| modeMap[GL_PACK_SKIP_IMAGES] = "GL_PACK_SKIP_IMAGES"; |
| } |
| |
| ModeMap::iterator it = modeMap.find(type); |
| if (it == modeMap.end()) |
| TCU_FAIL("Unknown mode name"); |
| return it->second; |
| } |
| |
| class RectangleTest : public deqp::TestCase |
| { |
| public: |
| RectangleTest(deqp::Context& context, std::string& name, InternalFormat internalFormat); |
| virtual ~RectangleTest(); |
| |
| void resetInitialStorageModes(); |
| void applyInitialStorageModes(); |
| void testAllFormatsAndTypes(); |
| |
| virtual tcu::TestNode::IterateResult iterate(void); |
| |
| protected: |
| void createGradient(); |
| void swapBytes(int typeSize, std::vector<GLbyte>& dataBuffer); |
| |
| template <typename Type> |
| void makeGradient(Type (*unpack)(float)); |
| |
| template <typename Type> |
| static Type unpackSizedComponents(float value, int s1, int s2, int s3, int s4); |
| |
| template <typename Type> |
| static Type unpackSizedComponentsRev(float value, int s1, int s2, int s3, int s4); |
| |
| static GLubyte unpack_UNSIGNED_BYTE(float value); |
| static GLbyte unpack_BYTE(float value); |
| static GLushort unpack_UNSIGNED_SHORT(float value); |
| static GLshort unpack_SHORT(float value); |
| static GLuint unpack_UNSIGNED_INT(float value); |
| static GLint unpack_INT(float value); |
| static GLhalf unpack_HALF_FLOAT(float value); |
| static GLfloat unpack_FLOAT(float value); |
| static GLubyte unpack_UNSIGNED_BYTE_3_3_2(float value); |
| static GLubyte unpack_UNSIGNED_BYTE_2_3_3_REV(float value); |
| static GLushort unpack_UNSIGNED_SHORT_5_6_5_REV(float value); |
| static GLushort unpack_UNSIGNED_SHORT_4_4_4_4_REV(float value); |
| static GLushort unpack_UNSIGNED_SHORT_1_5_5_5_REV(float value); |
| static GLuint unpack_UNSIGNED_INT_8_8_8_8(float value); |
| static GLuint unpack_UNSIGNED_INT_8_8_8_8_REV(float value); |
| static GLuint unpack_UNSIGNED_INT_10_10_10_2(float value); |
| static GLushort unpack_UNSIGNED_SHORT_5_6_5(float value); |
| static GLushort unpack_UNSIGNED_SHORT_4_4_4_4(float value); |
| static GLushort unpack_UNSIGNED_SHORT_5_5_5_1(float value); |
| static GLuint unpack_UNSIGNED_INT_2_10_10_10_REV(float value); |
| static GLuint unpack_UNSIGNED_INT_24_8(float value); |
| static GLuint unpack_UNSIGNED_INT_5_9_9_9_REV(float value); |
| static GLuint unpack_UNSIGNED_INT_10F_11F_11F_REV(float value); |
| static F_32_UINT_24_8_REV unpack_FLOAT_32_UNSIGNED_INT_24_8_REV(float value); |
| |
| bool isFormatValid(const PixelFormat& format, const PixelType& type, const struct InternalFormat& internalformat, |
| bool checkInput, bool checkOutput, int operation) const; |
| bool isUnsizedFormat(GLenum format) const; |
| bool isSRGBFormat(const InternalFormat& internalFormat) const; |
| bool isSNORMFormat(const InternalFormat& internalFormat) const; |
| bool isCopyValid(const InternalFormat& copyInternalFormat, const InternalFormat& internalFormat) const; |
| bool isFBOImageAttachValid(const InternalFormat& internalformat, GLenum format, GLenum type) const; |
| |
| const PixelFormat& getPixelFormat(GLenum format) const; |
| const PixelType& getPixelType(GLenum type) const; |
| const EnumFormats* getCanonicalFormat(const InternalFormat& internalformat, GLenum format, GLenum type) const; |
| InternalFormatSamplerType getSampler(const PixelType& type, const PixelFormat& format) const; |
| |
| GLenum readOutputData(const PixelFormat& outputFormat, const PixelType& outputType, int operation); |
| |
| bool doCopy(); |
| |
| bool doCopyInner(); |
| |
| bool compare(GLvoid* gradient, GLvoid* data, const PixelFormat& outputFormat, const PixelType& outputType, |
| bool isCopy) const; |
| |
| void getFloatBuffer(GLvoid* gradient, int samplerIsIntUintFloat, const PixelFormat& format, const PixelType& type, |
| int elementCount, std::vector<FloatPixel>& result) const; |
| |
| void getBits(const PixelType& type, const PixelFormat& format, std::vector<int>& resultTable) const; |
| |
| template <typename Type> |
| void makeBuffer(const GLvoid* gradient, const PixelFormat& format, int samplerIsIntUintFloat, int elementCount, |
| int componentCount, float (*pack)(Type), std::vector<FloatPixel>& result) const; |
| |
| template <typename Type> |
| void makeBufferPackedInt(const GLvoid* gradient, const PixelFormat& format, int elementCount, |
| void (*pack)(rawIntPixel*, Type), std::vector<FloatPixel>& result) const; |
| |
| template <typename Type> |
| void makeBufferPackedUint(const GLvoid* gradient, const PixelFormat& format, int elementCount, |
| void (*pack)(rawUintPixel*, Type), std::vector<FloatPixel>& result) const; |
| |
| template <typename Type> |
| void makeBufferPackedFloat(const GLvoid* gradient, const PixelFormat& format, int elementCount, |
| void (*pack)(rawFloatPixel*, Type), std::vector<FloatPixel>& result) const; |
| |
| FloatPixel orderComponentsInt(rawIntPixel values, const PixelFormat& format) const; |
| FloatPixel orderComponentsUint(rawUintPixel values, const PixelFormat& format) const; |
| FloatPixel orderComponentsFloat(rawFloatPixel values, const PixelFormat& format) const; |
| |
| unsigned int getRealBitPrecision(int bits, bool isFloat) const; |
| |
| bool stripBuffer(const PackedPixelsBufferProperties& props, const GLubyte* orginalBuffer, |
| std::vector<GLubyte>& newBuffer, bool validate) const; |
| |
| int clampSignedValue(int bits, int value) const; |
| unsigned int clampUnsignedValue(int bits, unsigned int value) const; |
| |
| static float pack_UNSIGNED_BYTE(GLubyte value); |
| static float pack_BYTE(GLbyte value); |
| static float pack_UNSIGNED_SHORT(GLushort value); |
| static float pack_SHORT(GLshort value); |
| static float pack_UNSIGNED_INT(GLuint value); |
| static float pack_INT(GLint value); |
| static float pack_HALF_FLOAT(GLhalf value); |
| static float pack_FLOAT(GLfloat value); |
| static void pack_UNSIGNED_BYTE_3_3_2(rawFloatPixel* values, GLubyte value); |
| static void pack_UNSIGNED_BYTE_3_3_2_UINT(rawUintPixel* values, GLubyte value); |
| static void pack_UNSIGNED_BYTE_3_3_2_INT(rawIntPixel* values, GLubyte value); |
| static void pack_UNSIGNED_BYTE_2_3_3_REV(rawFloatPixel* values, GLubyte value); |
| static void pack_UNSIGNED_BYTE_2_3_3_REV_UINT(rawUintPixel* values, GLubyte value); |
| static void pack_UNSIGNED_BYTE_2_3_3_REV_INT(rawIntPixel* values, GLubyte value); |
| static void pack_UNSIGNED_SHORT_5_6_5(rawFloatPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_6_5_UINT(rawUintPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_6_5_INT(rawIntPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_6_5_REV(rawFloatPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_6_5_REV_UINT(rawUintPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_6_5_REV_INT(rawIntPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_4_4_4_4(rawFloatPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_4_4_4_4_UINT(rawUintPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_4_4_4_4_INT(rawIntPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_4_4_4_4_REV(rawFloatPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_4_4_4_4_REV_UINT(rawUintPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_4_4_4_4_REV_INT(rawIntPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_5_5_1(rawFloatPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_5_5_1_UINT(rawUintPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_5_5_5_1_INT(rawIntPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_1_5_5_5_REV(rawFloatPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_1_5_5_5_REV_UINT(rawUintPixel* values, GLushort value); |
| static void pack_UNSIGNED_SHORT_1_5_5_5_REV_INT(rawIntPixel* values, GLushort value); |
| static void pack_UNSIGNED_INT_8_8_8_8(rawFloatPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_8_8_8_8_UINT(rawUintPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_8_8_8_8_INT(rawIntPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_8_8_8_8_REV(rawFloatPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_8_8_8_8_REV_UINT(rawUintPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_8_8_8_8_REV_INT(rawIntPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_10_10_10_2(rawFloatPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_10_10_10_2_UINT(rawUintPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_10_10_10_2_INT(rawIntPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_2_10_10_10_REV(rawFloatPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_2_10_10_10_REV_UINT(rawUintPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_2_10_10_10_REV_INT(rawIntPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_24_8(rawFloatPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_10F_11F_11F_REV(rawFloatPixel* values, GLuint value); |
| static void pack_UNSIGNED_INT_5_9_9_9_REV(rawFloatPixel* values, GLuint value); |
| static void pack_FLOAT_32_UNSIGNED_INT_24_8_REV(rawFloatPixel* values, F_32_UINT_24_8_REV value); |
| |
| bool getTexImage(); |
| bool getTexImageInner(const PixelFormat& outputFormat, const PixelType& outputType); |
| |
| bool doRead(GLuint texture); |
| bool readPixels(bool isCopy); |
| bool readPixelsInner(const PixelFormat& outputFormat, const PixelType& outputType, bool isCopy); |
| |
| protected: |
| const InternalFormat m_internalFormat; |
| |
| bool m_usePBO; |
| GLenum m_textureTarget; |
| PackedPixelsBufferProperties m_initialPackProperties; |
| PackedPixelsBufferProperties m_initialUnpackProperties; |
| |
| std::vector<GLbyte> m_gradient; |
| const GLubyte m_defaultFillValue; |
| |
| public: |
| // debuf counters |
| static int m_countReadPixels; |
| static int m_countReadPixelsOK; |
| static int m_countGetTexImage; |
| static int m_countGetTexImageOK; |
| static int m_countCompare; |
| static int m_countCompareOK; |
| |
| private: |
| // those attribute change multiple times during test execution |
| PixelFormat m_inputFormat; |
| PixelType m_inputType; |
| InternalFormat m_copyInternalFormat; |
| PackedPixelsBufferProperties m_packProperties; |
| PackedPixelsBufferProperties m_unpackProperties; |
| std::vector<GLbyte> m_outputBuffer; |
| }; |
| |
| int RectangleTest::m_countReadPixels = 0; |
| int RectangleTest::m_countReadPixelsOK = 0; |
| int RectangleTest::m_countGetTexImage = 0; |
| int RectangleTest::m_countGetTexImageOK = 0; |
| int RectangleTest::m_countCompare = 0; |
| int RectangleTest::m_countCompareOK = 0; |
| |
| RectangleTest::RectangleTest(deqp::Context& context, std::string& name, InternalFormat internalFormat) |
| : deqp::TestCase(context, name.c_str(), "") |
| , m_internalFormat(internalFormat) |
| , m_usePBO(false) |
| , m_textureTarget(GL_TEXTURE_2D) |
| , m_defaultFillValue(0xaa) |
| { |
| } |
| |
| RectangleTest::~RectangleTest() |
| { |
| } |
| |
| void RectangleTest::resetInitialStorageModes() |
| { |
| m_initialPackProperties.skipPixels = 0; |
| m_initialPackProperties.skipRows = 0; |
| m_initialPackProperties.rowLength = 0; |
| m_initialPackProperties.alignment = 4; |
| m_initialPackProperties.rowCount = 0; |
| m_initialPackProperties.skipImages = 0; |
| m_initialPackProperties.lsbFirst = 0; |
| m_initialPackProperties.swapBytes = 0; |
| |
| m_initialUnpackProperties.skipPixels = 0; |
| m_initialUnpackProperties.skipRows = 0; |
| m_initialUnpackProperties.rowLength = 0; |
| m_initialUnpackProperties.alignment = 4; |
| m_initialUnpackProperties.rowCount = 0; |
| m_initialUnpackProperties.skipImages = 0; |
| m_initialUnpackProperties.lsbFirst = 0; |
| m_initialUnpackProperties.swapBytes = 0; |
| } |
| |
| void RectangleTest::applyInitialStorageModes() |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| PackedPixelsBufferProperties& up = m_initialUnpackProperties; |
| PackedPixelsBufferProperties& pp = m_initialPackProperties; |
| |
| m_unpackProperties = up; |
| m_packProperties = pp; |
| |
| gl.pixelStorei(GL_PACK_ROW_LENGTH, pp.rowLength); |
| gl.pixelStorei(GL_PACK_SKIP_ROWS, pp.skipRows); |
| gl.pixelStorei(GL_PACK_SKIP_PIXELS, pp.skipPixels); |
| gl.pixelStorei(GL_PACK_ALIGNMENT, pp.alignment); |
| |
| gl.pixelStorei(GL_UNPACK_ROW_LENGTH, up.rowLength); |
| gl.pixelStorei(GL_UNPACK_SKIP_ROWS, up.skipRows); |
| gl.pixelStorei(GL_UNPACK_SKIP_PIXELS, up.skipPixels); |
| gl.pixelStorei(GL_UNPACK_ALIGNMENT, up.alignment); |
| gl.pixelStorei(GL_UNPACK_IMAGE_HEIGHT, up.rowCount); |
| gl.pixelStorei(GL_UNPACK_SKIP_IMAGES, up.skipImages); |
| |
| if (!isContextTypeES(renderContext.getType())) |
| { |
| gl.pixelStorei(GL_PACK_IMAGE_HEIGHT, pp.rowCount); |
| gl.pixelStorei(GL_PACK_SKIP_IMAGES, pp.skipImages); |
| |
| gl.pixelStorei(GL_PACK_SWAP_BYTES, pp.swapBytes); |
| gl.pixelStorei(GL_PACK_LSB_FIRST, pp.lsbFirst); |
| |
| gl.pixelStorei(GL_UNPACK_SWAP_BYTES, up.swapBytes); |
| gl.pixelStorei(GL_UNPACK_LSB_FIRST, up.lsbFirst); |
| } |
| } |
| |
| void RectangleTest::swapBytes(int typeSize, std::vector<GLbyte>& dataBuffer) |
| { |
| int bufferSize = dataBuffer.size(); |
| switch (typeSize) |
| { |
| case 1: |
| break; // no swapping |
| case 2: |
| { |
| GLushort* data = reinterpret_cast<GLushort*>(&dataBuffer[0]); |
| for (int i = 0; i < bufferSize / 2; i++) |
| { |
| GLushort v = data[i]; |
| data[i] = ((v & 0xff) << 8) + ((v & 0xff00) >> 8); |
| } |
| break; |
| } |
| case 4: |
| case 8: // typeSize is 2 x 32bit, behaves the same this time |
| { |
| GLuint* data = reinterpret_cast<GLuint*>(&dataBuffer[0]); |
| for (int i = 0; i < bufferSize / 4; i++) |
| { |
| GLuint v = data[i]; |
| data[i] = ((v & 0xff) << 24) + ((v & 0xff00) << 8) + ((v & 0xff0000) >> 8) + ((v & 0xff000000) >> 24); |
| } |
| break; |
| } |
| default: |
| TCU_FAIL("Invalid size for swapBytes"); |
| } |
| } |
| |
| const PixelFormat& RectangleTest::getPixelFormat(GLenum format) const |
| { |
| const PixelFormat* formats; |
| int formatsCount; |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| formats = esFormats; |
| formatsCount = DE_LENGTH_OF_ARRAY(esFormats); |
| } |
| else |
| { |
| formats = coreFormats; |
| formatsCount = DE_LENGTH_OF_ARRAY(coreFormats); |
| } |
| |
| // Look up pixel format from a GL enum |
| for (int i = 0; i < formatsCount; i++) |
| { |
| if (formats[i].format == format) |
| return formats[i]; |
| } |
| |
| TCU_FAIL("Unsuported format."); |
| return formats[0]; |
| } |
| |
| const PixelType& RectangleTest::getPixelType(GLenum type) const |
| { |
| const PixelType* types; |
| int typesCount; |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| types = esTypes; |
| typesCount = DE_LENGTH_OF_ARRAY(esTypes); |
| } |
| else |
| { |
| types = coreTypes; |
| typesCount = DE_LENGTH_OF_ARRAY(coreTypes); |
| } |
| |
| for (int i = 0; i < typesCount; i++) |
| { |
| if (types[i].type == type) |
| return types[i]; |
| } |
| |
| TCU_FAIL("Unsuported type."); |
| return types[0]; |
| } |
| |
| const EnumFormats* RectangleTest::getCanonicalFormat(const InternalFormat& internalformat, GLenum format, |
| GLenum type) const |
| { |
| // function returns a canonical format from internal format. for example |
| // GL_RGBA16F => { GL_RGBA, GL_FLOAT }; used mostly for GLES tests |
| |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(esValidFormats); ++i) |
| { |
| if ((esValidFormats[i].internalformat == internalformat.sizedFormat) && |
| (esValidFormats[i].format == format) && (esValidFormats[i].type == type)) |
| { |
| return &(esValidFormats[i]); |
| } |
| } |
| |
| const glu::ContextInfo& contextInfo = m_context.getContextInfo(); |
| if (contextInfo.isExtensionSupported("GL_EXT_texture_type_2_10_10_10_REV")) |
| { |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(validformats_EXT_texture_type_2_10_10_10_REV); ++i) |
| { |
| if (validformats_EXT_texture_type_2_10_10_10_REV[i].internalformat == internalformat.sizedFormat && |
| validformats_EXT_texture_type_2_10_10_10_REV[i].format == format && |
| validformats_EXT_texture_type_2_10_10_10_REV[i].type == type) |
| { |
| return &(validformats_EXT_texture_type_2_10_10_10_REV[i]); |
| } |
| } |
| |
| if (contextInfo.isExtensionSupported("GL_OES_required_internalformat")) |
| { |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(validformats_OES_required_internalformat); ++i) |
| { |
| if (validformats_OES_required_internalformat[i].internalformat == internalformat.sizedFormat && |
| validformats_OES_required_internalformat[i].format == format && |
| validformats_OES_required_internalformat[i].type == type) |
| { |
| return &(validformats_OES_required_internalformat[i]); |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(coreValidFormats); ++i) |
| { |
| if ((coreValidFormats[i].internalformat == internalformat.sizedFormat) && |
| (coreValidFormats[i].format == format) && (coreValidFormats[i].type == type)) |
| { |
| return &(coreValidFormats[i]); |
| } |
| } |
| } |
| |
| return 0; |
| } |
| |
| InternalFormatSamplerType RectangleTest::getSampler(const PixelType& type, const PixelFormat& format) const |
| { |
| switch (type.storage) |
| { |
| case STORAGE_FLOAT: |
| return SAMPLER_FLOAT; |
| |
| case STORAGE_UNSIGNED: |
| if ((format.componentFormat == FORMAT_COLOR_INTEGER) || (format.componentFormat == FORMAT_STENCIL)) |
| return SAMPLER_UINT; |
| return SAMPLER_UNORM; |
| |
| case STORAGE_SIGNED: |
| if (format.componentFormat == FORMAT_COLOR_INTEGER) |
| return SAMPLER_INT; |
| return SAMPLER_NORM; |
| |
| default: |
| TCU_FAIL("Invalid storage specifier"); |
| } |
| } |
| |
| void RectangleTest::createGradient() |
| { |
| switch (m_inputType.type) |
| { |
| case GL_UNSIGNED_BYTE: |
| makeGradient(unpack_UNSIGNED_BYTE); |
| break; |
| case GL_BYTE: |
| makeGradient<GLbyte>(unpack_BYTE); |
| break; |
| case GL_UNSIGNED_SHORT: |
| makeGradient<GLushort>(unpack_UNSIGNED_SHORT); |
| break; |
| case GL_SHORT: |
| makeGradient<GLshort>(unpack_SHORT); |
| break; |
| case GL_UNSIGNED_INT: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT); |
| break; |
| case GL_INT: |
| makeGradient<GLint>(unpack_INT); |
| break; |
| case GL_HALF_FLOAT: |
| makeGradient<GLhalf>(unpack_HALF_FLOAT); |
| break; |
| case GL_FLOAT: |
| makeGradient<GLfloat>(unpack_FLOAT); |
| break; |
| case GL_UNSIGNED_SHORT_5_6_5: |
| makeGradient<GLushort>(unpack_UNSIGNED_SHORT_5_6_5); |
| break; |
| case GL_UNSIGNED_SHORT_4_4_4_4: |
| makeGradient<GLushort>(unpack_UNSIGNED_SHORT_4_4_4_4); |
| break; |
| case GL_UNSIGNED_SHORT_5_5_5_1: |
| makeGradient<GLushort>(unpack_UNSIGNED_SHORT_5_5_5_1); |
| break; |
| case GL_UNSIGNED_INT_2_10_10_10_REV: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT_2_10_10_10_REV); |
| break; |
| case GL_UNSIGNED_INT_24_8: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT_24_8); |
| break; |
| case GL_UNSIGNED_INT_10F_11F_11F_REV: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT_10F_11F_11F_REV); |
| break; |
| case GL_UNSIGNED_INT_5_9_9_9_REV: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT_5_9_9_9_REV); |
| break; |
| case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: |
| makeGradient<F_32_UINT_24_8_REV>(unpack_FLOAT_32_UNSIGNED_INT_24_8_REV); |
| break; |
| case GL_UNSIGNED_BYTE_3_3_2: |
| makeGradient<GLubyte>(unpack_UNSIGNED_BYTE_3_3_2); |
| break; |
| case GL_UNSIGNED_BYTE_2_3_3_REV: |
| makeGradient<GLubyte>(unpack_UNSIGNED_BYTE_2_3_3_REV); |
| break; |
| case GL_UNSIGNED_SHORT_5_6_5_REV: |
| makeGradient<GLushort>(unpack_UNSIGNED_SHORT_5_6_5_REV); |
| break; |
| case GL_UNSIGNED_SHORT_4_4_4_4_REV: |
| makeGradient<GLushort>(unpack_UNSIGNED_SHORT_4_4_4_4_REV); |
| break; |
| case GL_UNSIGNED_SHORT_1_5_5_5_REV: |
| makeGradient<GLushort>(unpack_UNSIGNED_SHORT_1_5_5_5_REV); |
| break; |
| case GL_UNSIGNED_INT_8_8_8_8: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT_8_8_8_8); |
| break; |
| case GL_UNSIGNED_INT_8_8_8_8_REV: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT_8_8_8_8_REV); |
| break; |
| case GL_UNSIGNED_INT_10_10_10_2: |
| makeGradient<GLuint>(unpack_UNSIGNED_INT_10_10_10_2); |
| break; |
| default: |
| TCU_FAIL("Unsupported type"); |
| }; |
| } |
| |
| template <typename Type> |
| void RectangleTest::makeGradient(Type (*unpack)(float)) |
| { |
| // number of elements in a group |
| int elementsInGroup = m_inputFormat.components; |
| if (m_inputType.special) |
| elementsInGroup = 1; |
| |
| int rowCount = m_unpackProperties.rowCount; |
| if (rowCount == 0) |
| rowCount = GRADIENT_HEIGHT + m_unpackProperties.skipRows; |
| |
| // number of groups in the row |
| int rowLength = m_unpackProperties.rowLength; |
| if (rowLength == 0) |
| rowLength = GRADIENT_WIDTH + m_unpackProperties.skipPixels; |
| |
| int elementSize = m_inputType.size; |
| |
| // row size (in elements) |
| int elementsInRowNoAlign = elementsInGroup * rowLength; |
| int elementsInRow = elementsInRowNoAlign; |
| if (elementSize < m_unpackProperties.alignment) |
| { |
| int alignment = m_unpackProperties.alignment; |
| elementsInRow = (int)(alignment * deFloatCeil(elementSize * elementsInGroup * rowLength / ((float)alignment))) / |
| elementSize; |
| } |
| |
| if (m_textureTarget == GL_TEXTURE_2D) |
| m_unpackProperties.skipImages = 0; |
| |
| // "depth" will be 1 + skipped image layers. |
| // We still want to work on a 2D-ish image later. |
| int depth = 1 + m_unpackProperties.skipImages; |
| |
| m_unpackProperties.elementsInGroup = elementsInGroup; |
| m_unpackProperties.rowCount = rowCount; |
| m_unpackProperties.rowLength = rowLength; |
| m_unpackProperties.elementSize = elementSize; |
| m_unpackProperties.elementsInRowNoAlign = elementsInRowNoAlign; |
| m_unpackProperties.elementsInRow = elementsInRow; |
| m_unpackProperties.imagesCount = depth; |
| |
| // element size * elements in row * number of rows * number of 2d images |
| std::size_t bufferSize = elementSize * elementsInRow * rowCount * depth; |
| |
| m_gradient.resize(bufferSize); |
| Type* data = reinterpret_cast<Type*>(&m_gradient[0]); |
| |
| std::size_t dataToSkip = m_unpackProperties.skipImages * rowCount * elementsInRow; |
| std::size_t index = dataToSkip; |
| const Type defaultValue = unpack(0.5f); |
| std::fill(data, data + dataToSkip, defaultValue); |
| |
| for (int k = 0; k < depth; k++) |
| { |
| for (int j = 0; j < rowCount; j++) |
| { |
| for (int i = 0; i < elementsInRow; i++) |
| { |
| int x = i / elementsInGroup; |
| if ((k == depth - 1) && (m_unpackProperties.skipRows <= j) && |
| (j < m_unpackProperties.skipRows + GRADIENT_HEIGHT) && (m_unpackProperties.skipPixels <= x) && |
| (x < m_unpackProperties.skipPixels + GRADIENT_WIDTH)) |
| { |
| float value = static_cast<float>(x - m_unpackProperties.skipPixels) / GRADIENT_WIDTH; |
| int channel = i - elementsInGroup * x; |
| value *= 1.0f - 0.25f * channel; |
| data[index] = unpack(value); |
| } |
| else |
| { |
| data[index] = defaultValue; |
| } |
| index++; |
| } |
| } |
| } |
| } |
| |
| template <typename Type> |
| Type RectangleTest::unpackSizedComponents(float value, int s1, int s2, int s3, int s4) |
| { |
| int typeBits = sizeof(Type) * 8; |
| double v = static_cast<double>(value); |
| Type c1 = static_cast<Type>(v * 1.00 * ((1 << s1) - 1)); |
| Type c2 = static_cast<Type>(v * 0.75 * ((1 << s2) - 1)); |
| Type c3 = static_cast<Type>(v * 0.50 * ((1 << s3) - 1)); |
| Type c4 = static_cast<Type>(v * 0.25 * ((1 << s4) - 1)); |
| return ((c1) << (typeBits - s1)) | ((c2) << (typeBits - s1 - s2)) | ((c3) << (typeBits - s1 - s2 - s3)) | |
| ((c4) << (typeBits - s1 - s2 - s3 - s4)); |
| } |
| |
| template <typename Type> |
| Type RectangleTest::unpackSizedComponentsRev(float value, int s1, int s2, int s3, int s4) |
| { |
| int typeBits = sizeof(Type) * 8; |
| double v = static_cast<double>(value); |
| Type c1 = static_cast<Type>(v * 1.00 * ((1 << s4) - 1)); |
| Type c2 = static_cast<Type>(v * 0.75 * ((1 << s3) - 1)); |
| Type c3 = static_cast<Type>(v * 0.50 * ((1 << s2) - 1)); |
| Type c4 = static_cast<Type>(v * 0.25 * ((1 << s1) - 1)); |
| return ((c4) << (typeBits - s1)) | ((c3) << (typeBits - s1 - s2)) | ((c2) << (typeBits - s1 - s2 - s3)) | |
| ((c1) << (typeBits - s1 - s2 - s3 - s4)); |
| } |
| |
| GLubyte RectangleTest::unpack_UNSIGNED_BYTE(float value) |
| { |
| return static_cast<GLubyte>(value * std::numeric_limits<GLubyte>::max()); |
| } |
| |
| GLbyte RectangleTest::unpack_BYTE(float value) |
| { |
| return static_cast<GLbyte>(value * std::numeric_limits<GLbyte>::max()); |
| } |
| |
| GLushort RectangleTest::unpack_UNSIGNED_SHORT(float value) |
| { |
| return static_cast<GLushort>(value * std::numeric_limits<GLushort>::max()); |
| } |
| |
| GLshort RectangleTest::unpack_SHORT(float value) |
| { |
| return static_cast<GLshort>(value * std::numeric_limits<GLshort>::max()); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT(float value) |
| { |
| return static_cast<GLuint>(value * std::numeric_limits<GLuint>::max()); |
| } |
| |
| GLint RectangleTest::unpack_INT(float value) |
| { |
| return static_cast<GLint>(value * std::numeric_limits<GLint>::max()); |
| } |
| |
| GLhalf RectangleTest::unpack_HALF_FLOAT(float value) |
| { |
| return floatToHalfFloat(value); |
| } |
| |
| GLfloat RectangleTest::unpack_FLOAT(float value) |
| { |
| return value; |
| } |
| |
| GLubyte RectangleTest::unpack_UNSIGNED_BYTE_3_3_2(float value) |
| { |
| return unpackSizedComponents<GLubyte>(value, 3, 3, 2, 0); |
| } |
| |
| GLubyte RectangleTest::unpack_UNSIGNED_BYTE_2_3_3_REV(float value) |
| { |
| return unpackSizedComponentsRev<GLubyte>(value, 2, 3, 3, 0); |
| } |
| |
| GLushort RectangleTest::unpack_UNSIGNED_SHORT_5_6_5_REV(float value) |
| { |
| return unpackSizedComponentsRev<GLushort>(value, 5, 6, 5, 0); |
| } |
| |
| GLushort RectangleTest::unpack_UNSIGNED_SHORT_4_4_4_4_REV(float value) |
| { |
| return unpackSizedComponentsRev<GLushort>(value, 4, 4, 4, 4); |
| } |
| |
| GLushort RectangleTest::unpack_UNSIGNED_SHORT_1_5_5_5_REV(float value) |
| { |
| return unpackSizedComponentsRev<GLushort>(value, 1, 5, 5, 5); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT_8_8_8_8(float value) |
| { |
| return unpackSizedComponents<GLuint>(value, 8, 8, 8, 8); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT_8_8_8_8_REV(float value) |
| { |
| return unpackSizedComponentsRev<GLuint>(value, 8, 8, 8, 8); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT_10_10_10_2(float value) |
| { |
| return unpackSizedComponents<GLuint>(value, 10, 10, 10, 2); |
| } |
| |
| GLushort RectangleTest::unpack_UNSIGNED_SHORT_5_6_5(float value) |
| { |
| return unpackSizedComponents<GLushort>(value, 5, 6, 5, 0); |
| } |
| |
| GLushort RectangleTest::unpack_UNSIGNED_SHORT_4_4_4_4(float value) |
| { |
| return unpackSizedComponents<GLushort>(value, 4, 4, 4, 4); |
| } |
| |
| GLushort RectangleTest::unpack_UNSIGNED_SHORT_5_5_5_1(float value) |
| { |
| return unpackSizedComponents<GLushort>(value, 5, 5, 5, 1); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT_2_10_10_10_REV(float value) |
| { |
| return unpackSizedComponentsRev<GLuint>(value, 2, 10, 10, 10); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT_24_8(float value) |
| { |
| return unpackSizedComponents<GLuint>(value, 24, 8, 0, 0); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT_5_9_9_9_REV(float value) |
| { |
| const int N = 9; |
| const int B = 15; |
| const int E_max = 31; |
| |
| GLfloat red = value * 1.00f; |
| GLfloat green = value * 0.75f; |
| GLfloat blue = value * 0.50f; |
| |
| GLfloat sharedExpMax = (deFloatPow(2.0f, (float)N) - 1.0f) / deFloatPow(2.0f, (float)N) * deFloatPow(2.0f, (float)(E_max - B)); |
| |
| GLfloat red_c = deFloatMax(0, deFloatMin(sharedExpMax, red)); |
| GLfloat green_c = deFloatMax(0, deFloatMin(sharedExpMax, green)); |
| GLfloat blue_c = deFloatMax(0, deFloatMin(sharedExpMax, blue)); |
| |
| GLfloat max_c = deFloatMax(deFloatMax(red_c, green_c), blue_c); |
| |
| GLfloat exp_p = deFloatMax(-B - 1, deFloatFloor(deFloatLog2(max_c))) + 1 + B; |
| |
| GLfloat max_s = deFloatFloor(max_c / deFloatPow(2.0f, exp_p - (float)B - (float)N) + 0.5f); |
| |
| GLfloat exp_s; |
| |
| if (0 <= max_s && max_s < deFloatPow(2.0f, (float)N)) |
| exp_s = exp_p; |
| else |
| exp_s = exp_p + 1; |
| |
| GLfloat red_s = deFloatFloor(red_c / deFloatPow(2.0f, exp_s - (float)B - (float)N) + 0.5f); |
| GLfloat green_s = deFloatFloor(green_c / deFloatPow(2.0f, exp_s - (float)B - (float)N) + 0.5f); |
| GLfloat blue_s = deFloatFloor(blue_c / deFloatPow(2.0f, exp_s - (float)B - (float)N) + 0.5f); |
| |
| GLuint c1 = (static_cast<GLuint>(red_s)) & 511; |
| GLuint c2 = (static_cast<GLuint>(green_s)) & 511; |
| GLuint c3 = (static_cast<GLuint>(blue_s)) & 511; |
| GLuint c4 = (static_cast<GLuint>(exp_s)) & 31; |
| |
| return (c1) | (c2 << 9) | (c3 << 18) | (c4 << 27); |
| } |
| |
| GLuint RectangleTest::unpack_UNSIGNED_INT_10F_11F_11F_REV(float value) |
| { |
| GLuint c1 = floatToUnisgnedF11(value * 1.00f); |
| GLuint c2 = floatToUnisgnedF11(value * 0.75f); |
| GLuint c3 = floatToUnisgnedF10(value * 0.50f); |
| return (c3 << 22) | (c2 << 11) | (c1); |
| } |
| |
| F_32_UINT_24_8_REV RectangleTest::unpack_FLOAT_32_UNSIGNED_INT_24_8_REV(float value) |
| { |
| F_32_UINT_24_8_REV ret; |
| ret.d = value; |
| ret.s = (GLuint)(value * 255.0 * 0.75); |
| ret.s &= 0xff; |
| return ret; |
| } |
| |
| bool RectangleTest::isFormatValid(const PixelFormat& format, const PixelType& type, |
| const struct InternalFormat& internalformat, bool checkInput, bool checkOutput, |
| int operation) const |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| glu::ContextType contextType = renderContext.getType(); |
| const glu::ContextInfo& contextInfo = m_context.getContextInfo(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| int i; |
| |
| // Test the combination of input format, input type and internalFormat |
| if (glu::isContextTypeES(contextType)) |
| { |
| if (checkInput) |
| { |
| // GLES30 has more restricted requirement on combination than GL for input |
| for (i = 0; i < DE_LENGTH_OF_ARRAY(esValidFormats); ++i) |
| { |
| if (internalformat.sizedFormat == esValidFormats[i].internalformat && |
| format.format == esValidFormats[i].format && type.type == esValidFormats[i].type) |
| { |
| break; |
| } |
| } |
| |
| if (i == DE_LENGTH_OF_ARRAY(esValidFormats)) |
| { |
| // Check for support of OES_texture_float extension |
| if (((GL_LUMINANCE_ALPHA == format.format) && (GL_LUMINANCE_ALPHA == internalformat.sizedFormat)) || |
| ((GL_LUMINANCE == format.format) && (GL_LUMINANCE == internalformat.sizedFormat)) || |
| ((GL_ALPHA == format.format) && (GL_ALPHA == internalformat.sizedFormat)) || |
| ((GL_RGBA == format.format) && (GL_RGBA == internalformat.sizedFormat)) || |
| ((GL_RGB == format.format) && (GL_RGB == internalformat.sizedFormat))) |
| { |
| if ((contextInfo.isExtensionSupported("GL_OES_texture_float") && (GL_FLOAT == type.type)) || |
| (contextInfo.isExtensionSupported("GL_OES_texture_half_float") && |
| (GL_HALF_FLOAT_OES == type.type))) |
| { |
| return true; |
| } |
| } |
| |
| // Check for support of EXT_texture_type_2_10_10_10_REV extension |
| if (((GL_RGBA == format.format) && (GL_RGBA == internalformat.sizedFormat)) || |
| ((GL_RGB == format.format) && (GL_RGB == internalformat.sizedFormat))) |
| { |
| if (contextInfo.isExtensionSupported("GL_EXT_texture_type_2_10_10_10_REV") && |
| ((GL_UNSIGNED_INT_2_10_10_10_REV_EXT == type.type))) |
| return true; |
| } |
| |
| // Check for support of NV_packed_float extension |
| if ((GL_RGB == format.format) && (GL_RGB == internalformat.sizedFormat)) |
| { |
| if (contextInfo.isExtensionSupported("GL_NV_packed_float") && |
| ((GL_UNSIGNED_INT_10F_11F_11F_REV == type.type))) |
| return true; |
| } |
| |
| // Check for support of EXT_texture_type_2_10_10_10_REV and GL_OES_required_internalformat extensions |
| if (contextInfo.isExtensionSupported("GL_EXT_texture_type_2_10_10_10_REV") && |
| contextInfo.isExtensionSupported("GL_OES_required_internalformat")) |
| { |
| for (i = 0; i < DE_LENGTH_OF_ARRAY(validformats_OES_required_internalformat); ++i) |
| { |
| if (internalformat.sizedFormat == validformats_OES_required_internalformat[i].internalformat && |
| format.format == validformats_OES_required_internalformat[i].format && |
| type.type == validformats_OES_required_internalformat[i].type) |
| { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| if ((m_textureTarget == GL_TEXTURE_3D) && |
| ((format.format == GL_DEPTH_COMPONENT) || (format.format == GL_DEPTH_STENCIL))) |
| return false; |
| } |
| else if (checkOutput) |
| { |
| // GLES30 has more restricted requirement on combination than GL for output |
| // As stated in Section Reading Pixels |
| InternalFormatSamplerType sampler = internalformat.sampler; |
| |
| const PixelFormat& inputFormat = getPixelFormat(internalformat.format); |
| |
| if (inputFormat.attachment == GL_DEPTH_ATTACHMENT && contextInfo.isExtensionSupported("GL_NV_read_depth") && |
| format.format == GL_DEPTH_COMPONENT && |
| ((sampler == SAMPLER_FLOAT && type.type == GL_FLOAT) || |
| (sampler != SAMPLER_FLOAT && (type.type == GL_UNSIGNED_SHORT || type.type == GL_UNSIGNED_INT || |
| type.type == GL_UNSIGNED_INT_24_8)))) |
| { |
| return true; |
| } |
| |
| if (inputFormat.attachment == GL_DEPTH_STENCIL_ATTACHMENT && |
| contextInfo.isExtensionSupported("GL_NV_read_depth_stencil") && |
| ((format.format == GL_DEPTH_STENCIL && |
| ((sampler == SAMPLER_FLOAT && type.type == GL_FLOAT_32_UNSIGNED_INT_24_8_REV) || |
| (sampler != SAMPLER_FLOAT && type.type == GL_UNSIGNED_INT_24_8))) || |
| (format.format == GL_DEPTH_COMPONENT && |
| ((sampler == SAMPLER_FLOAT && type.type == GL_FLOAT) || |
| (sampler != SAMPLER_FLOAT && (type.type == GL_UNSIGNED_SHORT || type.type == GL_UNSIGNED_INT || |
| type.type == GL_UNSIGNED_INT_24_8)))))) |
| { |
| return true; |
| } |
| |
| if (inputFormat.attachment != GL_COLOR_ATTACHMENT0) |
| { |
| return false; |
| } |
| |
| if ((sampler == SAMPLER_UNORM) && (((type.type == GL_UNSIGNED_BYTE) && (format.format == GL_RGB) && |
| (internalformat.sizedFormat == GL_SRGB8)) || |
| ((type.type == GL_UNSIGNED_BYTE) && (format.format == GL_RGBA) && |
| (internalformat.sizedFormat == GL_SRGB8_ALPHA8))) && |
| contextInfo.isExtensionSupported("GL_NV_sRGB_formats")) |
| { |
| return true; |
| } |
| |
| if ((sampler == SAMPLER_NORM) && (type.type == GL_UNSIGNED_BYTE) && (format.format == GL_RGBA) && |
| ((internalformat.sizedFormat == GL_R8_SNORM) || (internalformat.sizedFormat == GL_RG8_SNORM) || |
| (internalformat.sizedFormat == GL_RGBA8_SNORM) || (internalformat.sizedFormat == GL_R16_SNORM) || |
| (internalformat.sizedFormat == GL_RG16_SNORM) || (internalformat.sizedFormat == GL_RGBA16_SNORM)) && |
| contextInfo.isExtensionSupported("GL_EXT_render_snorm")) |
| { |
| return true; |
| } |
| |
| if ((sampler == SAMPLER_NORM) && (type.type == GL_BYTE) && (format.format == GL_RGBA) && |
| ((internalformat.sizedFormat == GL_R8_SNORM) || (internalformat.sizedFormat == GL_RG8_SNORM) || |
| (internalformat.sizedFormat == GL_RGBA8_SNORM)) && |
| contextInfo.isExtensionSupported("GL_EXT_render_snorm")) |
| { |
| return true; |
| } |
| |
| GLint implementType; |
| GLint implementFormat; |
| gl.getIntegerv(GL_IMPLEMENTATION_COLOR_READ_TYPE, &implementType); |
| gl.getIntegerv(GL_IMPLEMENTATION_COLOR_READ_FORMAT, &implementFormat); |
| GLenum err = gl.getError(); |
| GLenum implementTypeEnum = static_cast<GLenum>(implementType); |
| GLenum implementFormatEnum = static_cast<GLenum>(implementFormat); |
| |
| if (((sampler == SAMPLER_UNORM) && (type.type == GL_UNSIGNED_BYTE) && (format.format == GL_RGBA)) || |
| ((sampler == SAMPLER_UINT) && (type.type == GL_UNSIGNED_INT) && (format.format == GL_RGBA_INTEGER)) || |
| ((sampler == SAMPLER_INT) && (type.type == GL_INT) && (format.format == GL_RGBA_INTEGER)) || |
| ((sampler == SAMPLER_FLOAT) && (type.type == GL_FLOAT) && (format.format == GL_RGBA)) || |
| ((err == GL_NO_ERROR) && (type.type == implementTypeEnum) && (format.format == implementFormatEnum)) || |
| ((internalformat.sizedFormat == GL_RGB10_A2) && (type.type == GL_UNSIGNED_INT_2_10_10_10_REV) && |
| (format.format == GL_RGBA))) |
| { |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| } |
| else |
| { |
| if (format.format == GL_DEPTH_STENCIL) |
| { |
| if (type.type != GL_UNSIGNED_INT_24_8 && type.type != GL_FLOAT_32_UNSIGNED_INT_24_8_REV) |
| { |
| return false; |
| } |
| } |
| |
| if ((format.componentFormat == FORMAT_COLOR_INTEGER) && (type.type == GL_FLOAT || type.type == GL_HALF_FLOAT)) |
| { |
| return false; |
| } |
| |
| if ((internalformat.baseFormat == GL_DEPTH_STENCIL || internalformat.baseFormat == GL_STENCIL_INDEX || |
| internalformat.baseFormat == GL_DEPTH_COMPONENT) != |
| (format.format == GL_DEPTH_STENCIL || format.format == GL_STENCIL_INDEX || |
| format.format == GL_DEPTH_COMPONENT)) |
| { |
| return false; |
| } |
| |
| if (operation == INPUT_TEXIMAGE) |
| { |
| if (format.format == GL_STENCIL_INDEX || internalformat.baseFormat == GL_STENCIL_INDEX) |
| { |
| return false; |
| } |
| |
| if ((format.format == GL_DEPTH_COMPONENT || format.format == GL_DEPTH_STENCIL) && |
| !(internalformat.baseFormat == GL_DEPTH_STENCIL || internalformat.baseFormat == GL_DEPTH_COMPONENT)) |
| { |
| return false; |
| } |
| } |
| else if (operation == OUTPUT_GETTEXIMAGE) |
| { |
| if ((format.format == GL_STENCIL_INDEX && |
| ((internalformat.baseFormat != GL_STENCIL_INDEX && internalformat.baseFormat != GL_DEPTH_STENCIL) || |
| !contextInfo.isExtensionSupported("GL_ARB_texture_stencil8")))) |
| { |
| return false; |
| } |
| |
| if (format.format == GL_DEPTH_STENCIL && internalformat.baseFormat != GL_DEPTH_STENCIL) |
| { |
| return false; |
| } |
| } |
| else if (operation == OUTPUT_READPIXELS) |
| { |
| if (format.format == GL_DEPTH_STENCIL && internalformat.baseFormat != GL_DEPTH_STENCIL) |
| { |
| return false; |
| } |
| |
| if (format.format == GL_DEPTH_COMPONENT && internalformat.baseFormat != GL_DEPTH_STENCIL && |
| internalformat.baseFormat != GL_DEPTH_COMPONENT) |
| { |
| return false; |
| } |
| |
| if (format.format == GL_STENCIL_INDEX && internalformat.baseFormat != GL_DEPTH_STENCIL && |
| internalformat.baseFormat != GL_STENCIL_INDEX) |
| { |
| return false; |
| } |
| } |
| |
| if (type.special == true) |
| { |
| bool valid = false; |
| |
| for (i = 0; i < DE_LENGTH_OF_ARRAY(coreValidFormats); ++i) |
| { |
| if (coreValidFormats[i].format == format.format && coreValidFormats[i].type == type.type) |
| { |
| valid = true; |
| break; |
| } |
| } |
| |
| if (!valid) |
| return false; |
| } |
| |
| if ((format.componentFormat == FORMAT_COLOR_INTEGER) && |
| !(internalformat.sampler == SAMPLER_INT || internalformat.sampler == SAMPLER_UINT)) |
| { |
| return false; |
| } |
| |
| if (!(format.componentFormat == FORMAT_COLOR_INTEGER) && |
| (internalformat.sampler == SAMPLER_INT || internalformat.sampler == SAMPLER_UINT)) |
| { |
| return false; |
| } |
| |
| if ((m_textureTarget == GL_TEXTURE_3D) && |
| ((internalformat.baseFormat == GL_DEPTH_COMPONENT) || (internalformat.baseFormat == GL_DEPTH_STENCIL) || |
| (internalformat.sizedFormat == GL_COMPRESSED_RED_RGTC1) || |
| (internalformat.sizedFormat == GL_COMPRESSED_SIGNED_RED_RGTC1) || |
| (internalformat.sizedFormat == GL_COMPRESSED_RG_RGTC2) || |
| (internalformat.sizedFormat == GL_COMPRESSED_SIGNED_RG_RGTC2))) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool RectangleTest::isUnsizedFormat(GLenum format) const |
| { |
| GLenum formats[] = { GL_RGBA, GL_RGB, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_ALPHA }; |
| GLenum* formatsEnd = formats + DE_LENGTH_OF_ARRAY(formats); |
| return (std::find(formats, formatsEnd, format) < formatsEnd); |
| } |
| |
| bool RectangleTest::isSRGBFormat(const InternalFormat& internalFormat) const |
| { |
| return (internalFormat.sizedFormat == GL_SRGB8) || (internalFormat.sizedFormat == GL_SRGB8_ALPHA8); |
| } |
| |
| bool RectangleTest::isSNORMFormat(const InternalFormat& internalFormat) const |
| { |
| GLenum formats[] = { GL_R8_SNORM, GL_RG8_SNORM, GL_RGB8_SNORM, GL_RGBA8_SNORM, |
| GL_R16_SNORM, GL_RG16_SNORM, GL_RGB16_SNORM, GL_RGBA16_SNORM }; |
| GLenum* formatsEnd = formats + DE_LENGTH_OF_ARRAY(formats); |
| return (std::find(formats, formatsEnd, internalFormat.sizedFormat) < formatsEnd); |
| } |
| |
| bool RectangleTest::isCopyValid(const InternalFormat& copyInternalFormat, const InternalFormat& internalFormat) const |
| { |
| // check if copy between two internal formats is allowed |
| |
| int b1 = getPixelFormat(internalFormat.format).components; |
| int b2 = getPixelFormat(copyInternalFormat.format).components; |
| |
| if (b2 > b1) |
| return false; |
| |
| //Check that the types can be converted in CopyTexImage. |
| if (((copyInternalFormat.sampler == SAMPLER_UINT) && (internalFormat.sampler != SAMPLER_UINT)) || |
| ((copyInternalFormat.sampler == SAMPLER_INT) && (internalFormat.sampler != SAMPLER_INT)) || |
| (((copyInternalFormat.sampler == SAMPLER_FLOAT) || (internalFormat.sampler == SAMPLER_UNORM) || |
| (copyInternalFormat.sampler == SAMPLER_NORM)) && |
| (!((copyInternalFormat.sampler == SAMPLER_FLOAT) || (internalFormat.sampler == SAMPLER_UNORM) || |
| (internalFormat.sampler == SAMPLER_NORM))))) |
| { |
| return false; |
| } |
| |
| // Core GL is less restricted then ES - check it first |
| if (!glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| if ((copyInternalFormat.format == GL_DEPTH_COMPONENT && internalFormat.format != GL_DEPTH_COMPONENT) || |
| (copyInternalFormat.format == GL_DEPTH_STENCIL && internalFormat.format != GL_DEPTH_STENCIL) || |
| (copyInternalFormat.format == GL_ALPHA && internalFormat.format != GL_ALPHA) || |
| (copyInternalFormat.format == GL_LUMINANCE && internalFormat.format != GL_LUMINANCE) || |
| (copyInternalFormat.format == GL_LUMINANCE_ALPHA && internalFormat.format != GL_LUMINANCE_ALPHA)) |
| { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| const glu::ContextInfo& contextInfo = m_context.getContextInfo(); |
| |
| // GLES30 has more restricted requirement on glCopyTexImage2D |
| // As stated in Table 3.15 and comment to glCopyTexImage2D |
| if ((internalFormat.baseFormat == GL_DEPTH_COMPONENT) || (internalFormat.baseFormat == GL_DEPTH_STENCIL) || |
| (copyInternalFormat.baseFormat == GL_DEPTH_COMPONENT) || (copyInternalFormat.baseFormat == GL_DEPTH_STENCIL) || |
| ((internalFormat.baseFormat != GL_RGBA && internalFormat.baseFormat != GL_ALPHA) && |
| ((copyInternalFormat.baseFormat == GL_ALPHA) || (copyInternalFormat.baseFormat == GL_LUMINANCE_ALPHA))) || |
| ((internalFormat.baseFormat == GL_ALPHA) && |
| ((copyInternalFormat.baseFormat != GL_RGBA) && (copyInternalFormat.baseFormat != GL_ALPHA) && |
| (copyInternalFormat.baseFormat != GL_LUMINANCE_ALPHA))) || |
| (isSRGBFormat(internalFormat) != isSRGBFormat(copyInternalFormat)) || |
| // GLES30 does not define ReadPixels types for signed normalized fixed point formats in Table 3.14, |
| // and conversions to SNORM internalformats are not allowed by Table 3.2 |
| (copyInternalFormat.sampler == SAMPLER_NORM) || |
| ((copyInternalFormat.sizedFormat == GL_RGB9_E5) && |
| !contextInfo.isExtensionSupported("GL_APPLE_color_buffer_packed_float"))) |
| { |
| /* Some formats are activated by extensions, check. */ |
| if (((internalFormat.baseFormat == GL_LUMINANCE && copyInternalFormat.baseFormat == GL_LUMINANCE) || |
| (internalFormat.baseFormat == GL_ALPHA && copyInternalFormat.baseFormat == GL_ALPHA) || |
| (internalFormat.baseFormat == GL_LUMINANCE_ALPHA && |
| (copyInternalFormat.baseFormat == GL_LUMINANCE_ALPHA || copyInternalFormat.baseFormat == GL_LUMINANCE || |
| copyInternalFormat.baseFormat == GL_ALPHA))) && |
| contextInfo.isExtensionSupported("GL_NV_render_luminance_alpha")) |
| { |
| return true; |
| } |
| else if (contextInfo.isExtensionSupported("GL_EXT_render_snorm") && isSNORMFormat(copyInternalFormat) && |
| (internalFormat.sampler == copyInternalFormat.sampler) && |
| (((copyInternalFormat.baseFormat == GL_RED) && |
| (internalFormat.baseFormat == GL_RED || internalFormat.baseFormat == GL_RG || |
| internalFormat.baseFormat == GL_RGB || internalFormat.baseFormat == GL_RGBA || |
| copyInternalFormat.baseFormat == GL_LUMINANCE)) || |
| ((copyInternalFormat.baseFormat == GL_RG) && |
| (internalFormat.baseFormat == GL_RG || internalFormat.baseFormat == GL_RGB || |
| internalFormat.baseFormat == GL_RGBA)) || |
| ((copyInternalFormat.baseFormat == GL_RGB) && |
| (internalFormat.baseFormat == GL_RGB || internalFormat.baseFormat == GL_RGBA)) || |
| ((copyInternalFormat.baseFormat == GL_RGBA) && (internalFormat.baseFormat == GL_RGBA)))) |
| { |
| return true; |
| } |
| |
| return false; |
| } |
| else |
| { |
| if (internalFormat.sampler != copyInternalFormat.sampler) |
| { |
| // You can't convert between different base types, for example NORM<->FLOAT. |
| return false; |
| } |
| if (!isUnsizedFormat(copyInternalFormat.sizedFormat)) |
| { |
| if ((internalFormat.bits.bits.red && copyInternalFormat.bits.bits.red && |
| internalFormat.bits.bits.red != copyInternalFormat.bits.bits.red) || |
| (internalFormat.bits.bits.green && copyInternalFormat.bits.bits.green && |
| internalFormat.bits.bits.green != copyInternalFormat.bits.bits.green) || |
| (internalFormat.bits.bits.blue && copyInternalFormat.bits.bits.blue && |
| internalFormat.bits.bits.blue != copyInternalFormat.bits.bits.blue) || |
| (internalFormat.bits.bits.alpha && copyInternalFormat.bits.bits.alpha && |
| internalFormat.bits.bits.alpha != copyInternalFormat.bits.bits.alpha)) |
| { |
| // If the destination internalFormat is sized we don't allow component size changes. |
| return false; |
| } |
| } |
| else |
| { |
| if (internalFormat.sizedFormat == GL_RGB10_A2) |
| { |
| // Not allowed to convert from a GL_RGB10_A2 surface. |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool RectangleTest::isFBOImageAttachValid(const InternalFormat& internalformat, GLenum format, GLenum type) const |
| { |
| const glu::ContextInfo& contextInfo = m_context.getContextInfo(); |
| |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| const EnumFormats* validFormat = getCanonicalFormat(internalformat, format, type); |
| if (validFormat != 0) |
| { |
| if (!validFormat->bRenderable) |
| { |
| /* Some formats are activated by extensions, check. */ |
| if ((GL_RGBA32F == validFormat->internalformat || GL_RGBA16F == validFormat->internalformat || |
| GL_RG32F == validFormat->internalformat || GL_RG16F == validFormat->internalformat || |
| GL_R32F == validFormat->internalformat || GL_R16F == validFormat->internalformat || |
| GL_R11F_G11F_B10F == validFormat->internalformat) && |
| contextInfo.isExtensionSupported("GL_EXT_color_buffer_float")) |
| { |
| return true; |
| } |
| |
| if ((GL_RGBA16F == validFormat->internalformat || GL_RGB16F == validFormat->internalformat || |
| GL_RG16F == validFormat->internalformat || GL_R16F == validFormat->internalformat) && |
| contextInfo.isExtensionSupported("GL_EXT_color_buffer_half_float")) |
| { |
| return true; |
| } |
| |
| if ((GL_R11F_G11F_B10F == validFormat->internalformat || GL_RGB9_E5 == validFormat->internalformat) && |
| contextInfo.isExtensionSupported("GL_APPLE_color_buffer_packed_float")) |
| { |
| return true; |
| } |
| |
| if ((GL_LUMINANCE == validFormat->internalformat || GL_ALPHA == validFormat->internalformat || |
| GL_LUMINANCE_ALPHA == validFormat->internalformat) && |
| contextInfo.isExtensionSupported("GL_NV_render_luminance_alpha")) |
| { |
| return true; |
| } |
| |
| if ((GL_SRGB8 == validFormat->internalformat) && contextInfo.isExtensionSupported("GL_NV_sRGB_formats")) |
| { |
| return true; |
| } |
| |
| if (((GL_R8_SNORM == validFormat->internalformat) || (GL_RG8_SNORM == validFormat->internalformat) || |
| (GL_RGBA8_SNORM == validFormat->internalformat) || (GL_R16_SNORM == validFormat->internalformat) || |
| (GL_RG16_SNORM == validFormat->internalformat) || |
| (GL_RGBA16_SNORM == validFormat->internalformat)) && |
| contextInfo.isExtensionSupported("GL_EXT_render_snorm")) |
| { |
| return true; |
| } |
| } |
| return validFormat->bRenderable; |
| } |
| else |
| { |
| // Check for NV_packed_float |
| if (GL_RGB == internalformat.sizedFormat && GL_RGB == format && GL_UNSIGNED_INT_10F_11F_11F_REV == type && |
| contextInfo.isExtensionSupported("GL_NV_packed_float")) |
| { |
| return true; |
| } |
| return false; |
| } |
| } |
| else |
| { |
| if (format == GL_DEPTH_STENCIL && internalformat.sizedFormat != GL_DEPTH24_STENCIL8 && |
| internalformat.sizedFormat != GL_DEPTH32F_STENCIL8) |
| { |
| // We can't make a complete DEPTH_STENCIL attachment with a |
| // texture that does not have both DEPTH and STENCIL components. |
| return false; |
| } |
| |
| GLenum colorRenderableFrmats[] = { GL_RGBA32F, GL_RGBA32I, GL_RGBA32UI, GL_RGBA16, |
| GL_RGBA16F, GL_RGBA16I, GL_RGBA16UI, GL_RGBA8, |
| GL_RGBA8I, GL_RGBA8UI, GL_SRGB8_ALPHA8, GL_RGB10_A2, |
| GL_RGB10_A2UI, GL_RGB5_A1, GL_RGBA4, GL_R11F_G11F_B10F, |
| GL_RGB565, GL_RG32F, GL_RG32I, GL_RG32UI, |
| GL_RG16, GL_RG16F, GL_RG16I, GL_RG16UI, |
| GL_RG8, GL_RG8I, GL_RG8UI, GL_R32F, |
| GL_R32I, GL_R32UI, GL_R16F, GL_R16I, |
| GL_R16UI, GL_R16, GL_R8, GL_R8I, |
| GL_R8UI }; |
| GLenum* formatsEnd = colorRenderableFrmats + DE_LENGTH_OF_ARRAY(colorRenderableFrmats); |
| if (std::find(colorRenderableFrmats, formatsEnd, internalformat.sizedFormat) < formatsEnd) |
| return true; |
| |
| GLenum dsRenderableFormats[] = { |
| GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT16, |
| GL_DEPTH32F_STENCIL8, GL_DEPTH24_STENCIL8, |
| }; |
| |
| formatsEnd = dsRenderableFormats + DE_LENGTH_OF_ARRAY(dsRenderableFormats); |
| if (std::find(dsRenderableFormats, formatsEnd, internalformat.sizedFormat) < formatsEnd) |
| return true; |
| |
| return false; |
| } |
| } |
| |
| bool RectangleTest::doRead(GLuint texture) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| GLuint fboId; |
| gl.genFramebuffers(1, &fboId); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, fboId); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer"); |
| |
| bool validImageAttach = isFBOImageAttachValid(m_internalFormat, m_inputFormat.format, m_inputType.type); |
| if (m_textureTarget == GL_TEXTURE_2D) |
| gl.framebufferTexture2D(GL_FRAMEBUFFER, m_inputFormat.attachment, GL_TEXTURE_2D, texture, 0); |
| else if (glu::isContextTypeES(renderContext.getType())) |
| gl.framebufferTextureLayer(GL_FRAMEBUFFER, m_inputFormat.attachment, texture, 0, 0); |
| else |
| gl.framebufferTexture3D(GL_FRAMEBUFFER, m_inputFormat.attachment, GL_TEXTURE_3D, texture, 0, 0); |
| GLenum status = gl.checkFramebufferStatus(GL_FRAMEBUFFER); |
| |
| bool result = true; |
| if (status == GL_FRAMEBUFFER_COMPLETE) |
| { |
| if (!validImageAttach && glu::isContextTypeES(renderContext.getType())) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "FBO is complete but expected incomplete with sizedFormat: " |
| << getFormatStr(m_internalFormat.sizedFormat) << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| else |
| { |
| result &= readPixels(false); |
| result &= doCopy(); |
| } |
| } |
| else if (validImageAttach) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "FBO is not complete but expected complete with sizedFormat: " |
| << getFormatStr(m_internalFormat.sizedFormat) << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| |
| gl.deleteFramebuffers(1, &fboId); |
| |
| return result; |
| } |
| |
| bool RectangleTest::readPixels(bool isCopy) |
| { |
| bool result = true; |
| |
| const PixelType* types; |
| int typesCount; |
| const PixelFormat* formats; |
| int formatsCount; |
| |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| types = esTypes; |
| typesCount = DE_LENGTH_OF_ARRAY(esTypes); |
| formats = esFormats; |
| formatsCount = DE_LENGTH_OF_ARRAY(esFormats); |
| } |
| else |
| { |
| types = coreTypes; |
| typesCount = DE_LENGTH_OF_ARRAY(coreTypes); |
| formats = coreFormats; |
| formatsCount = DE_LENGTH_OF_ARRAY(coreFormats); |
| } |
| |
| // for each output format |
| for (int m = 0; m < formatsCount; ++m) |
| { |
| const PixelFormat& outputFormat = formats[m]; |
| |
| // for each output type |
| for (int n = 0; n < typesCount; ++n) |
| { |
| const PixelType& outputType = types[n]; |
| |
| if (isCopy) |
| { |
| // continue when input format,type != canonical format,type and |
| // output format,type != canonical format,type |
| if ((outputFormat.format != m_copyInternalFormat.format || |
| outputType.type != m_copyInternalFormat.type)) |
| { |
| // invalid output format and type - skipping case |
| continue; |
| } |
| } |
| else if ((m_inputFormat.format != m_internalFormat.format || m_inputType.type != m_internalFormat.type) && |
| (outputFormat.format != m_internalFormat.format || outputType.type != m_internalFormat.type)) |
| { |
| // invalid output format and type - skipping case |
| continue; |
| } |
| |
| result &= readPixelsInner(outputFormat, outputType, isCopy); |
| } |
| } |
| |
| return result; |
| } |
| |
| bool RectangleTest::readPixelsInner(const PixelFormat& outputFormat, const PixelType& outputType, bool isCopy) |
| { |
| const char* copyStage = "Copy stage: "; |
| |
| GLenum readerror = readOutputData(outputFormat, outputType, OUTPUT_READPIXELS); |
| if (m_outputBuffer.empty()) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "No buffer allocated" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| m_countReadPixels++; |
| |
| // Check if output format is valid |
| bool outputFormatValid = isFormatValid(outputFormat, outputType, isCopy ? m_copyInternalFormat : m_internalFormat, |
| false, true, OUTPUT_READPIXELS); |
| |
| // Even if this is a valid glReadPixels format, we can't read non-existant components |
| if (outputFormatValid && outputFormat.format == GL_DEPTH_STENCIL && m_inputFormat.format != GL_DEPTH_STENCIL) |
| outputFormatValid = false; |
| |
| if (outputFormatValid) |
| { |
| if (readerror != GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << (isCopy ? copyStage : "") |
| << "Valid format used but glReadPixels failed for input = [" |
| << getFormatStr(m_inputFormat.format) << ", " << getTypeStr(m_inputType.type) |
| << "] output = [" << getFormatStr(outputFormat.format) << ", " |
| << getTypeStr(outputType.type) << "]" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| { |
| m_countReadPixelsOK++; |
| m_countCompare++; |
| |
| // compare output gradient to input gradient |
| if (!compare(&m_gradient[0], &m_outputBuffer[0], outputFormat, outputType, isCopy)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << (isCopy ? copyStage : "") |
| << "Gradient comparison failed during ReadPixels for input = [" |
| << getFormatStr(m_inputFormat.format) << ", " << getTypeStr(m_inputType.type) |
| << "] output = [" << getFormatStr(outputFormat.format) << ", " |
| << getTypeStr(outputType.type) << "]" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| m_countCompareOK++; |
| } |
| } |
| else if (readerror == GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << (isCopy ? copyStage : "") |
| << "Invalid format used but glReadPixels succeeded for input = [" |
| << getFormatStr(m_inputFormat.format) << ", " << getTypeStr(m_inputType.type) |
| << "] output = [" << getFormatStr(outputFormat.format) << ", " << getTypeStr(outputType.type) |
| << "]" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| GLenum RectangleTest::readOutputData(const PixelFormat& outputFormat, const PixelType& outputType, int operation) |
| { |
| // If using PBOs buffer object for GL_PIXEL_PACK_BUFFER must |
| // be bound and not allocated before calling when using PBOs |
| |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| PackedPixelsBufferProperties& props = m_packProperties; |
| props.elementSize = outputType.size; |
| props.elementsInGroup = outputType.special ? 1 : outputFormat.components; |
| props.rowLength = (props.rowLength == 0) ? (GRADIENT_WIDTH + props.skipPixels) : props.rowLength; |
| props.elementsInRowNoAlign = props.elementsInGroup * props.rowLength; |
| props.elementsInRow = props.elementsInRowNoAlign; |
| |
| if (glu::isContextTypeES(renderContext.getType())) |
| { |
| props.rowCount = 0; |
| props.skipImages = 0; |
| } |
| else if ((operation == OUTPUT_READPIXELS) || (m_textureTarget == GL_TEXTURE_2D)) |
| props.skipImages = 0; |
| |
| if (props.rowCount == 0) |
| props.rowCount = GRADIENT_HEIGHT + props.skipRows; |
| props.imagesCount = props.skipImages + 1; |
| if (props.elementSize < props.alignment) |
| { |
| props.elementsInRow = (int)(props.alignment * deFloatCeil(props.elementSize * props.elementsInGroup * |
| props.rowLength / ((float)props.alignment))) / |
| props.elementSize; |
| } |
| |
| int bufferSize = |
| props.elementSize * props.elementsInRow * props.rowCount * props.imagesCount * (props.skipImages + 1); |
| |
| // The output buffer allocated should be initialized to a known value. After |
| // a pack operation, any extra memory allocated for skipping should be |
| // verified to be the original known value, untouched by the GL. |
| const GLubyte defaultFillValue = 0xaa; |
| m_outputBuffer.resize(static_cast<std::size_t>(bufferSize)); |
| std::fill(m_outputBuffer.begin(), m_outputBuffer.end(), defaultFillValue); |
| |
| GLuint packPBO; |
| if (m_usePBO) |
| { |
| gl.genBuffers(1, &packPBO); |
| gl.bindBuffer(GL_PIXEL_PACK_BUFFER, packPBO); |
| gl.bufferData(GL_PIXEL_PACK_BUFFER, bufferSize, &m_outputBuffer[0], GL_STATIC_READ); |
| } |
| |
| GLenum readError = GL_NO_ERROR; |
| switch (operation) |
| { |
| case OUTPUT_GETTEXIMAGE: |
| gl.getTexImage(m_textureTarget, 0, outputFormat.format, outputType.type, m_usePBO ? 0 : &m_outputBuffer[0]); |
| break; |
| |
| case OUTPUT_READPIXELS: |
| if (m_inputFormat.attachment != GL_DEPTH_ATTACHMENT && |
| m_inputFormat.attachment != GL_DEPTH_STENCIL_ATTACHMENT && |
| m_inputFormat.attachment != GL_STENCIL_ATTACHMENT) |
| gl.readBuffer(m_inputFormat.attachment); |
| |
| readError = gl.getError(); |
| if (readError == GL_NO_ERROR) |
| gl.readPixels(0, 0, GRADIENT_WIDTH, GRADIENT_HEIGHT, outputFormat.format, outputType.type, |
| m_usePBO ? 0 : &m_outputBuffer[0]); |
| break; |
| } |
| |
| if (readError == GL_NO_ERROR) |
| readError = gl.getError(); |
| |
| if (m_usePBO) |
| { |
| if (readError == GL_NO_ERROR) |
| { |
| GLvoid* mappedData = gl.mapBufferRange(GL_PIXEL_PACK_BUFFER, 0, bufferSize, GL_MAP_READ_BIT); |
| if (!mappedData) |
| return GL_INVALID_INDEX; |
| |
| std::memcpy(&m_outputBuffer[0], mappedData, bufferSize); |
| gl.unmapBuffer(GL_PIXEL_PACK_BUFFER); |
| } |
| |
| gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0); |
| gl.deleteBuffers(1, &packPBO); |
| } |
| |
| if (m_packProperties.swapBytes && (readError == GL_NO_ERROR)) |
| swapBytes(outputType.size, m_outputBuffer); |
| |
| return readError; |
| } |
| |
| bool RectangleTest::doCopy() |
| { |
| bool result = true; |
| |
| const InternalFormat* copyInternalFormats; |
| int internalFormatsCount; |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| copyInternalFormats = esInternalformats; |
| internalFormatsCount = DE_LENGTH_OF_ARRAY(esInternalformats); |
| } |
| else |
| { |
| copyInternalFormats = coreInternalformats; |
| internalFormatsCount = DE_LENGTH_OF_ARRAY(coreInternalformats); |
| } |
| |
| if ((m_inputFormat.format == m_internalFormat.format) && (m_inputType.type == m_internalFormat.type)) |
| { |
| for (int i = 0; i < internalFormatsCount; ++i) |
| { |
| m_copyInternalFormat = copyInternalFormats[i]; |
| result &= doCopyInner(); |
| } |
| } |
| |
| return result; |
| } |
| |
| bool RectangleTest::doCopyInner() |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| bool result = true; |
| |
| const EnumFormats* copyFormatEnum = |
| getCanonicalFormat(m_copyInternalFormat, m_copyInternalFormat.format, m_copyInternalFormat.type); |
| |
| if (copyFormatEnum != 0) |
| { |
| GLuint texture2; |
| GLenum status; |
| |
| bool validcopy = isCopyValid(m_copyInternalFormat, m_internalFormat); |
| |
| gl.genTextures(1, &texture2); |
| // Target is always GL_TEXTURE_2D |
| gl.bindTexture(GL_TEXTURE_2D, texture2); |
| GLenum error = gl.getError(); |
| |
| // CopyTexImage to copy_internalformat (GL converts, but PixelStore is ignored) |
| // Target is always GL_TEXTURE_2D |
| gl.copyTexImage2D(GL_TEXTURE_2D, 0, m_copyInternalFormat.sizedFormat, 0, 0, GRADIENT_WIDTH, GRADIENT_HEIGHT, 0); |
| error = gl.getError(); |
| |
| // if this combination of copy_internalformat,internalformat is invalid |
| if (validcopy == false) |
| { |
| // expect error and continue |
| if (error != GL_NO_ERROR) |
| { |
| // Invalid format used and glCopyTexImage2D failed |
| result = true; |
| } |
| else |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid format used but glCopyTexImage2D succeeded" |
| << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| } |
| else // validcopy == true |
| { |
| // expect no error and continue |
| if (error != GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Valid format used but glCopyTexImage2D failed" |
| << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| else |
| { |
| if (!glu::isContextTypeES(renderContext.getType())) |
| { |
| // if GetTexImage is supported we call the |
| // inner function only as no loop needed |
| const PixelFormat& outputFormat = getPixelFormat(copyFormatEnum->format); |
| const PixelType& outputType = getPixelType(copyFormatEnum->type); |
| result &= getTexImageInner(outputFormat, outputType); |
| } |
| |
| GLint orginalFboId; |
| gl.getIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &orginalFboId); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv"); |
| |
| GLuint fboId; |
| gl.genFramebuffers(1, &fboId); |
| gl.bindFramebuffer(GL_FRAMEBUFFER, fboId); |
| |
| bool validImageAttach = |
| isFBOImageAttachValid(m_copyInternalFormat, copyFormatEnum->format, copyFormatEnum->type); |
| |
| // attach copy_internalformat texture to FBO |
| // Target is always GL_TEXTURE_2D |
| const PixelFormat& copyFormat = getPixelFormat(copyFormatEnum->format); |
| gl.framebufferTexture2D(GL_FRAMEBUFFER, copyFormat.attachment, GL_TEXTURE_2D, texture2, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D"); |
| |
| status = gl.checkFramebufferStatus(GL_FRAMEBUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCheckFramebufferStatus"); |
| |
| // if an unsized sizedFormat was given, then implementation chosen copy format |
| // destination might be different than what's expected; |
| // we cannot continue checking since ReadPixels might not choose a compatible |
| // format, also the format may not be renderable as expected |
| if (isUnsizedFormat(m_copyInternalFormat.sizedFormat)) |
| { |
| result &= true; |
| } |
| else if (status == GL_FRAMEBUFFER_COMPLETE) |
| { |
| if (validImageAttach) |
| result &= readPixels(true); |
| else |
| { |
| m_testCtx.getLog() |
| << tcu::TestLog::Message << "Copy FBO is complete but expected incomplete with sizedFormat " |
| << getFormatStr(m_copyInternalFormat.sizedFormat) << ", attachement " |
| << copyFormat.attachment << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| } |
| else if (validImageAttach) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Copy FBO is not complete but expected complete with sizedFormat " |
| << getFormatStr(m_copyInternalFormat.sizedFormat) << ", attachement " |
| << copyFormat.attachment << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| |
| // bind original FBO |
| gl.bindFramebuffer(GL_FRAMEBUFFER, orginalFboId); |
| gl.deleteFramebuffers(1, &fboId); |
| } |
| } |
| |
| gl.deleteTextures(1, &texture2); |
| } |
| |
| return result; |
| } |
| |
| bool RectangleTest::compare(GLvoid* gradient, GLvoid* data, const PixelFormat& outputFormat, |
| const PixelType& outputType, bool isCopy) const |
| { |
| // Compares the reference gradient data to the output data |
| |
| int iformatSampler = m_internalFormat.sampler; |
| int outputSampler = getSampler(outputType, outputFormat); |
| int inputSampler = getSampler(m_inputType, m_inputFormat); |
| |
| if (isCopy) |
| iformatSampler = m_copyInternalFormat.sampler; |
| |
| int samplerIsIntUintFloat = 3; // 1: INT | 2: UINT | 3: FLOAT/UNORM/NORM |
| if (m_internalFormat.sampler == SAMPLER_INT) |
| samplerIsIntUintFloat = 1; |
| else if (m_internalFormat.sampler == SAMPLER_UINT) |
| samplerIsIntUintFloat = 2; |
| |
| std::vector<GLubyte> gradientStrip; |
| if (!stripBuffer(m_unpackProperties, static_cast<const GLubyte*>(gradient), gradientStrip, false)) |
| return false; |
| std::vector<GLubyte> dataStrip; |
| if (!stripBuffer(m_packProperties, static_cast<const GLubyte*>(data), dataStrip, true)) |
| return false; |
| |
| if (gradientStrip.empty() || dataStrip.empty()) |
| return false; |
| |
| std::vector<FloatPixel> inputBuffer; |
| getFloatBuffer(&gradientStrip[0], samplerIsIntUintFloat, m_inputFormat, m_inputType, |
| GRADIENT_WIDTH * GRADIENT_HEIGHT, inputBuffer); |
| |
| std::vector<FloatPixel> outputBuffer; |
| getFloatBuffer(&dataStrip[0], samplerIsIntUintFloat, outputFormat, outputType, GRADIENT_WIDTH * GRADIENT_HEIGHT, |
| outputBuffer); |
| |
| std::vector<int> inputBitTable; |
| getBits(m_inputType, m_inputFormat, inputBitTable); |
| std::vector<int> outputBitTable; |
| getBits(outputType, outputFormat, outputBitTable); |
| const int* internalformatBitTable = reinterpret_cast<const int*>(&m_internalFormat.bits); |
| const int* copyFormatBitTable = m_copyInternalFormat.bits.array; |
| |
| // make struct field iterable |
| float* inputBufferFloat = reinterpret_cast<float*>(&inputBuffer[0]); |
| float* outputBufferFloat = reinterpret_cast<float*>(&outputBuffer[0]); |
| |
| int* inputBufferInt = reinterpret_cast<int*>(&inputBuffer[0]); |
| int* outputBufferInt = reinterpret_cast<int*>(&outputBuffer[0]); |
| |
| unsigned int* inputBufferUint = reinterpret_cast<unsigned int*>(&inputBuffer[0]); |
| unsigned int* outputBufferUint = reinterpret_cast<unsigned int*>(&outputBuffer[0]); |
| |
| for (int i = 0; i < GRADIENT_WIDTH * GRADIENT_HEIGHT; ++i) |
| { |
| for (int j = 0; j < NUM_FLOAT_PIXEL_COUNT / 3; ++j) |
| { |
| int bit1 = getRealBitPrecision(inputBitTable[j], inputSampler == SAMPLER_FLOAT); |
| int bit2 = getRealBitPrecision(outputBitTable[j], outputSampler == SAMPLER_FLOAT); |
| int bit3 = getRealBitPrecision(internalformatBitTable[j], iformatSampler == SAMPLER_FLOAT); |
| int bitdiff; |
| |
| if (bit1 >= bit3) |
| { |
| if ((inputSampler == SAMPLER_UNORM && m_internalFormat.sampler == SAMPLER_NORM)) |
| bit3 -= 1; |
| } |
| |
| if (bit2 <= bit3) |
| { |
| if (outputSampler == SAMPLER_NORM && m_internalFormat.sampler == SAMPLER_UNORM) |
| bit2 -= 1; |
| } |
| |
| if (!(m_internalFormat.flags & FLAG_REQ_RBO) && bit3 > 8 && m_internalFormat.sampler != SAMPLER_UINT && |
| m_internalFormat.sampler != SAMPLER_INT) |
| { |
| // If this internalFormat is not a required format there is no requirement |
| // that the implementation uses exactly the bit width requested. For example, |
| // it may substitute RGB10 for RGB12. The implementation can't make subtitutions |
| // for integer formats. |
| bit3 = 8; |
| } |
| |
| bitdiff = std::min(std::min(bit1, bit2), bit3); |
| if (isCopy) |
| { |
| bitdiff = std::min(bitdiff, copyFormatBitTable[j]); |
| } |
| |
| if (bitdiff > 0) |
| { |
| if (samplerIsIntUintFloat == 1) // 1: INT |
| { |
| int inputValue = inputBufferInt[NUM_FLOAT_PIXEL_COUNT * i + j]; |
| int outputValue = outputBufferInt[NUM_FLOAT_PIXEL_COUNT * i + j]; |
| |
| if (inputSampler == SAMPLER_UINT) |
| // If input data was unsigned, it should be clamped to fit into |
| // internal format positive range (otherwise it may wrap and |
| // yield negative internalformat values) |
| inputValue = clampUnsignedValue(bit3 - 1, inputValue); |
| ; |
| |
| inputValue = clampSignedValue(bit3, inputValue); |
| if (isCopy) |
| { |
| inputValue = clampSignedValue(copyFormatBitTable[j], inputValue); |
| } |
| if (outputSampler == SAMPLER_UINT) |
| inputValue = clampUnsignedValue(bit2, inputValue); |
| else |
| inputValue = clampSignedValue(bit2, inputValue); |
| |
| if (inputValue != outputValue) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Integer comparison: " << i << ", " << j << ", " |
| << NUM_FLOAT_PIXEL_COUNT * i + j << ": " << inputValue |
| << " == " << outputValue << ": not equal." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| else if (samplerIsIntUintFloat == 2) // 2: UINT |
| { |
| unsigned int inputValue = inputBufferUint[NUM_FLOAT_PIXEL_COUNT * i + j + 6]; |
| unsigned int outputValue = outputBufferUint[NUM_FLOAT_PIXEL_COUNT * i + j + 6]; |
| |
| inputValue = clampUnsignedValue(bit3, inputValue); |
| if (isCopy) |
| inputValue = clampUnsignedValue(copyFormatBitTable[j], inputValue); |
| |
| if (outputSampler == SAMPLER_UINT) |
| inputValue = clampUnsignedValue(bit2, inputValue); |
| else if (outputSampler == SAMPLER_INT) |
| inputValue = clampUnsignedValue(bit2 - 1, inputValue); |
| if (inputValue != outputValue) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Integer comparison: " << i << ", " << j << ", " |
| << NUM_FLOAT_PIXEL_COUNT * i + j << ": " << inputValue |
| << " == " << outputValue << ": not equal." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| else if (samplerIsIntUintFloat == 3) // 3: FLOAT / UNORM / NORM |
| { |
| float inputValue = inputBufferFloat[NUM_FLOAT_PIXEL_COUNT * i + j + 12]; |
| float outputValue = outputBufferFloat[NUM_FLOAT_PIXEL_COUNT * i + j + 12]; |
| float epsilon; |
| |
| if ((outputSampler == SAMPLER_UNORM) || (outputSampler == SAMPLER_NORM)) |
| { |
| // Check if format is UNORM/NORM which needs different |
| // precision since it implies a int->float conversion. |
| epsilon = 1.0f / ((float)((1 << (bitdiff - 1))) - 1); |
| } |
| else if ((inputSampler == SAMPLER_FLOAT) != (outputSampler == SAMPLER_FLOAT)) |
| { |
| // Allow for rounding in either direction for float->int conversions. |
| epsilon = 1.0f / ((float)((1 << (bitdiff - 1))) - 1); |
| } |
| else |
| epsilon = 1.0f / ((float)((1 << bitdiff) - 1)); |
| |
| if (inputSampler == SAMPLER_FLOAT || outputSampler == SAMPLER_FLOAT) |
| { |
| // According to GL spec the precision requirement |
| // of floating-point values is 1 part in 10^5. |
| epsilon = deFloatMax(epsilon, 0.00001f); |
| } |
| |
| if (m_internalFormat.flags & FLAG_COMPRESSED) |
| epsilon = deFloatMax(epsilon, 0.1f); |
| |
| // Clamp input value to range of output |
| if (iformatSampler == SAMPLER_UNORM || outputSampler == SAMPLER_UNORM) |
| inputValue = deFloatMax(deFloatMin(inputValue, 1.0f), 0.0f); |
| else if (iformatSampler == SAMPLER_NORM || outputSampler == SAMPLER_NORM) |
| inputValue = deFloatMax(deFloatMin(inputValue, 1.0f), -1.0f); |
| |
| // Compare the input and output |
| if (deFloatAbs(inputValue - outputValue) > epsilon) |
| { |
| m_testCtx.getLog() |
| << tcu::TestLog::Message << "Non-integer comparison: " << i << ", " << j << ", " |
| << NUM_FLOAT_PIXEL_COUNT * i + j << ", " << epsilon << ": " << inputValue |
| << " == " << outputValue << ": not equal." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| else |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Sampler type cannot be recognised, so no comparison" |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| void RectangleTest::getFloatBuffer(GLvoid* gradient, int samplerIsIntUintFloat, const PixelFormat& format, |
| const PixelType& type, int elementCount, std::vector<FloatPixel>& result) const |
| { |
| int componentCount = format.components; |
| switch (type.type) |
| { |
| case GL_UNSIGNED_BYTE: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_UNSIGNED_BYTE, result); |
| break; |
| case GL_BYTE: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_BYTE, result); |
| break; |
| case GL_UNSIGNED_SHORT: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_UNSIGNED_SHORT, result); |
| break; |
| case GL_SHORT: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_SHORT, result); |
| break; |
| case GL_UNSIGNED_INT: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_UNSIGNED_INT, result); |
| break; |
| case GL_INT: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_INT, result); |
| break; |
| case GL_HALF_FLOAT: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_HALF_FLOAT, result); |
| break; |
| case GL_FLOAT: |
| makeBuffer(gradient, format, samplerIsIntUintFloat, elementCount, componentCount, pack_FLOAT, result); |
| break; |
| case GL_UNSIGNED_SHORT_5_6_5: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_6_5_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_6_5_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_6_5, result); |
| break; |
| case GL_UNSIGNED_SHORT_4_4_4_4: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_SHORT_4_4_4_4_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_SHORT_4_4_4_4_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_SHORT_4_4_4_4, result); |
| break; |
| case GL_UNSIGNED_SHORT_5_5_5_1: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_5_5_1_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_5_5_1_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_5_5_1, result); |
| break; |
| case GL_UNSIGNED_INT_2_10_10_10_REV: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_INT_2_10_10_10_REV_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_INT_2_10_10_10_REV_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_INT_2_10_10_10_REV, result); |
| break; |
| case GL_UNSIGNED_INT_24_8: |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_INT_24_8, result); |
| break; |
| case GL_UNSIGNED_INT_10F_11F_11F_REV: |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_INT_10F_11F_11F_REV, result); |
| break; |
| case GL_UNSIGNED_INT_5_9_9_9_REV: |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_INT_5_9_9_9_REV, result); |
| break; |
| case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: |
| makeBufferPackedFloat(gradient, format, elementCount, pack_FLOAT_32_UNSIGNED_INT_24_8_REV, result); |
| break; |
| case GL_UNSIGNED_BYTE_3_3_2: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_BYTE_3_3_2_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_BYTE_3_3_2_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_BYTE_3_3_2, result); |
| break; |
| case GL_UNSIGNED_BYTE_2_3_3_REV: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_BYTE_2_3_3_REV_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_BYTE_2_3_3_REV_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_BYTE_2_3_3_REV, result); |
| break; |
| case GL_UNSIGNED_SHORT_5_6_5_REV: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_6_5_REV_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_6_5_REV_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_SHORT_5_6_5_REV, result); |
| break; |
| case GL_UNSIGNED_SHORT_4_4_4_4_REV: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_SHORT_4_4_4_4_REV_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_SHORT_4_4_4_4_REV_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_SHORT_4_4_4_4_REV, result); |
| break; |
| case GL_UNSIGNED_SHORT_1_5_5_5_REV: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_SHORT_1_5_5_5_REV_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_SHORT_1_5_5_5_REV_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_SHORT_1_5_5_5_REV, result); |
| break; |
| case GL_UNSIGNED_INT_8_8_8_8: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_INT_8_8_8_8_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_INT_8_8_8_8_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_INT_8_8_8_8, result); |
| break; |
| case GL_UNSIGNED_INT_8_8_8_8_REV: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_INT_8_8_8_8_REV_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_INT_8_8_8_8_REV_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_INT_8_8_8_8_REV, result); |
| break; |
| case GL_UNSIGNED_INT_10_10_10_2: |
| if (samplerIsIntUintFloat == 1) |
| makeBufferPackedInt(gradient, format, elementCount, pack_UNSIGNED_INT_10_10_10_2_INT, result); |
| else if (samplerIsIntUintFloat == 2) |
| makeBufferPackedUint(gradient, format, elementCount, pack_UNSIGNED_INT_10_10_10_2_UINT, result); |
| else if (samplerIsIntUintFloat == 3) |
| makeBufferPackedFloat(gradient, format, elementCount, pack_UNSIGNED_INT_10_10_10_2, result); |
| break; |
| default: |
| TCU_FAIL("Unsuported type"); |
| } |
| } |
| |
| template <typename Type> |
| void RectangleTest::makeBuffer(const GLvoid* gradient, const PixelFormat& format, int samplerIsIntUintFloat, |
| int elementCount, int componentCount, float (*pack)(Type), |
| std::vector<FloatPixel>& result) const |
| { |
| const Type* sourceData = static_cast<const Type*>(gradient); |
| result.resize(sizeof(FloatPixel) * elementCount); |
| for (int i = 0; i < elementCount; ++i) |
| { |
| rawFloatPixel values; |
| rawIntPixel valuesInt; |
| rawUintPixel valuesUint; |
| for (int j = 0; j < componentCount; j++) |
| { |
| if (samplerIsIntUintFloat == 1) |
| valuesInt[j] = (int)static_cast<Type>(sourceData[componentCount * i + j]); |
| else if (samplerIsIntUintFloat == 2) |
| valuesUint[j] = (unsigned int)static_cast<Type>(sourceData[componentCount * i + j]); |
| else if (samplerIsIntUintFloat == 3) |
| values[j] = pack(sourceData[componentCount * i + j]); |
| } |
| if (samplerIsIntUintFloat == 1) |
| result[i] = orderComponentsInt(valuesInt, format); |
| else if (samplerIsIntUintFloat == 2) |
| result[i] = orderComponentsUint(valuesUint, format); |
| else if (samplerIsIntUintFloat == 3) |
| result[i] = orderComponentsFloat(values, format); |
| } |
| } |
| |
| void RectangleTest::getBits(const PixelType& type, const PixelFormat& format, std::vector<int>& resultTable) const |
| { |
| // return bit depth table based on type and format pair; |
| // table is always NUM_FLOAT_PIXEL_COUNT digit long |
| |
| resultTable.resize(NUM_FLOAT_PIXEL_COUNT); |
| std::fill(resultTable.begin(), resultTable.end(), 0); |
| |
| if (type.special == true) |
| { |
| std::memcpy(&resultTable[0], &type.bits, sizeof(int) * NUM_FLOAT_PIXEL_COUNT); |
| if (type.type == GL_UNSIGNED_INT_5_9_9_9_REV) |
| { |
| //this type is another special case: it is always converted to 3-channel color (no A). |
| //as results of this function are used for comparison of converted values we set A bits to 0. |
| resultTable[3] = 0; |
| } |
| } |
| else |
| { |
| int bits; |
| |
| if (type.type == GL_FLOAT) |
| bits = 32; |
| else if (type.type == GL_HALF_FLOAT) |
| bits = 16; |
| else |
| bits = type.size << 3; |
| |
| if (format.format == GL_DEPTH_STENCIL || format.format == GL_DEPTH_COMPONENT) |
| resultTable[4] = bits; |
| |
| if (format.format == GL_DEPTH_STENCIL || format.format == GL_STENCIL_INDEX || |
| format.format == GL_STENCIL_INDEX8) |
| { |
| resultTable[5] = bits; |
| } |
| |
| if (format.format == GL_RED || format.format == GL_RG || format.format == GL_RGB || format.format == GL_RGBA || |
| format.format == GL_BGR || format.format == GL_BGRA || format.format == GL_RED_INTEGER || |
| format.format == GL_RG_INTEGER || format.format == GL_RGB_INTEGER || format.format == GL_RGBA_INTEGER || |
| format.format == GL_BGR_INTEGER || format.format == GL_BGRA_INTEGER) |
| { |
| resultTable[0] = bits; |
| } |
| |
| if (format.format == GL_RG || format.format == GL_RGB || format.format == GL_RGBA || format.format == GL_BGR || |
| format.format == GL_BGRA || format.format == GL_RG_INTEGER || format.format == GL_RGB_INTEGER || |
| format.format == GL_RGBA_INTEGER || format.format == GL_BGR_INTEGER || format.format == GL_BGRA_INTEGER) |
| { |
| resultTable[1] = bits; |
| } |
| |
| if (format.format == GL_RGB || format.format == GL_RGBA || format.format == GL_BGR || |
| format.format == GL_BGRA || format.format == GL_RGB_INTEGER || format.format == GL_RGBA_INTEGER || |
| format.format == GL_BGR_INTEGER || format.format == GL_BGRA_INTEGER) |
| { |
| resultTable[2] = bits; |
| } |
| |
| if (format.format == GL_RGBA || format.format == GL_BGRA || format.format == GL_RGBA_INTEGER || |
| format.format == GL_BGRA_INTEGER) |
| { |
| resultTable[3] = bits; |
| } |
| } |
| } |
| |
| template <typename Type> |
| void RectangleTest::makeBufferPackedInt(const GLvoid* gradient, const PixelFormat& format, int elementCount, |
| void (*pack)(rawIntPixel*, Type), std::vector<FloatPixel>& result) const |
| { |
| const Type* sourceData = static_cast<const Type*>(gradient); |
| result.resize(sizeof(FloatPixel) * elementCount); |
| for (int i = 0; i < elementCount; ++i) |
| { |
| rawIntPixel values; |
| pack(&values, sourceData[i]); |
| result[i] = orderComponentsInt(values, format); |
| } |
| } |
| |
| template <typename Type> |
| void RectangleTest::makeBufferPackedUint(const GLvoid* gradient, const PixelFormat& format, int elementCount, |
| void (*pack)(rawUintPixel*, Type), std::vector<FloatPixel>& result) const |
| { |
| const Type* sourceData = static_cast<const Type*>(gradient); |
| result.resize(sizeof(FloatPixel) * elementCount); |
| for (int i = 0; i < elementCount; ++i) |
| { |
| rawUintPixel values; |
| pack(&values, sourceData[i]); |
| result[i] = orderComponentsUint(values, format); |
| } |
| } |
| |
| template <typename Type> |
| void RectangleTest::makeBufferPackedFloat(const GLvoid* gradient, const PixelFormat& format, int elementCount, |
| void (*pack)(rawFloatPixel*, Type), std::vector<FloatPixel>& result) const |
| { |
| const Type* sourceData = static_cast<const Type*>(gradient); |
| result.resize(sizeof(FloatPixel) * elementCount); |
| for (int i = 0; i < elementCount; ++i) |
| { |
| rawFloatPixel values; |
| pack(&values, sourceData[i]); |
| result[i] = orderComponentsFloat(values, format); |
| } |
| } |
| |
| FloatPixel RectangleTest::orderComponentsInt(rawIntPixel values, const PixelFormat& format) const |
| { |
| FloatPixel fp = { PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, |
| PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, |
| PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF }; |
| |
| if (format.componentOrder.bits.red >= 0) |
| fp.i_r = values[format.componentOrder.bits.red]; |
| if (format.componentOrder.bits.green >= 0) |
| fp.i_g = values[format.componentOrder.bits.green]; |
| if (format.componentOrder.bits.blue >= 0) |
| fp.i_b = values[format.componentOrder.bits.blue]; |
| if (format.componentOrder.bits.alpha >= 0) |
| fp.i_a = values[format.componentOrder.bits.alpha]; |
| if (format.componentOrder.bits.depth >= 0) |
| fp.i_d = values[format.componentOrder.bits.depth]; |
| if (format.componentOrder.bits.stencil >= 0) |
| fp.i_s = values[format.componentOrder.bits.stencil]; |
| |
| return fp; |
| } |
| |
| FloatPixel RectangleTest::orderComponentsUint(rawUintPixel values, const PixelFormat& format) const |
| { |
| FloatPixel fp = { PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, |
| PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, |
| PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF }; |
| |
| if (format.componentOrder.bits.red >= 0) |
| fp.ui_r = values[format.componentOrder.bits.red]; |
| if (format.componentOrder.bits.green >= 0) |
| fp.ui_g = values[format.componentOrder.bits.green]; |
| if (format.componentOrder.bits.blue >= 0) |
| fp.ui_b = values[format.componentOrder.bits.blue]; |
| if (format.componentOrder.bits.alpha >= 0) |
| fp.ui_a = values[format.componentOrder.bits.alpha]; |
| if (format.componentOrder.bits.depth >= 0) |
| fp.ui_d = values[format.componentOrder.bits.depth]; |
| if (format.componentOrder.bits.stencil >= 0) |
| fp.ui_s = values[format.componentOrder.bits.stencil]; |
| |
| return fp; |
| } |
| |
| FloatPixel RectangleTest::orderComponentsFloat(rawFloatPixel values, const PixelFormat& format) const |
| { |
| FloatPixel fp = { PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, PACK_DEFAULTI, |
| PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, PACK_DEFAULTUI, |
| PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF, PACK_DEFAULTF }; |
| |
| if (format.componentOrder.bits.red >= 0) |
| fp.r = values[format.componentOrder.bits.red]; |
| if (format.componentOrder.bits.green >= 0) |
| fp.g = values[format.componentOrder.bits.green]; |
| if (format.componentOrder.bits.blue >= 0) |
| fp.b = values[format.componentOrder.bits.blue]; |
| if (format.componentOrder.bits.alpha >= 0) |
| fp.a = values[format.componentOrder.bits.alpha]; |
| if (format.componentOrder.bits.depth >= 0) |
| fp.d = values[format.componentOrder.bits.depth]; |
| if (format.componentOrder.bits.stencil >= 0) |
| fp.s = values[format.componentOrder.bits.stencil]; |
| |
| return fp; |
| } |
| |
| unsigned int RectangleTest::getRealBitPrecision(int bits, bool isFloat) const |
| { |
| if (!isFloat) |
| return bits; |
| switch (bits) |
| { |
| case 32: |
| return 23; |
| case 16: |
| return 10; |
| case 11: |
| return 6; |
| case 10: |
| return 5; |
| } |
| return bits; |
| } |
| |
| bool RectangleTest::stripBuffer(const PackedPixelsBufferProperties& props, const GLubyte* orginalBuffer, |
| std::vector<GLubyte>& newBuffer, bool validate) const |
| { |
| // Extracts pixel data from a buffer with specific |
| // pixel store configuration into a flat buffer |
| |
| int newBufferSize = props.elementSize * props.elementsInRowNoAlign * GRADIENT_HEIGHT; |
| if (!newBufferSize) |
| return false; |
| newBuffer.resize(newBufferSize); |
| |
| int skipBottom = ((props.skipImages * props.rowCount + props.skipRows) * props.elementsInRow) * props.elementSize; |
| int skipTop = (props.rowCount - GRADIENT_HEIGHT - props.skipRows) * props.elementsInRow * props.elementSize; |
| int skipLeft = props.skipPixels * props.elementsInGroup * props.elementSize; |
| int skipRight = (props.elementsInRow - GRADIENT_WIDTH * props.elementsInGroup) * props.elementSize - skipLeft; |
| int copy = GRADIENT_WIDTH * props.elementsInGroup * props.elementSize; |
| int skipAlign = (props.elementsInRow - props.elementsInRowNoAlign) * props.elementSize; |
| |
| if (validate) |
| { |
| for (int i = 0; i < skipBottom; i++) |
| { |
| if (orginalBuffer[i] != m_defaultFillValue) |
| return false; |
| } |
| } |
| |
| int index_src = skipBottom; |
| int index_dst = 0; |
| |
| for (int j = 0; j < GRADIENT_HEIGHT; j++) |
| { |
| if (validate) |
| { |
| for (int i = 0; i < skipLeft; i++) |
| { |
| if (orginalBuffer[index_src + i] != m_defaultFillValue) |
| return false; |
| } |
| } |
| index_src += skipLeft; |
| |
| std::memcpy(&newBuffer[0] + index_dst, &orginalBuffer[0] + index_src, copy); |
| index_src += copy; |
| index_dst += copy; |
| |
| if (validate) |
| { |
| for (int i = skipAlign; i < skipRight; i++) |
| { |
| if (orginalBuffer[index_src + i] != m_defaultFillValue) |
| return false; |
| } |
| } |
| index_src += skipRight; |
| } |
| |
| if (validate) |
| { |
| for (int i = 0; i < skipTop; i++) |
| { |
| if (orginalBuffer[index_src + i] != m_defaultFillValue) |
| return false; |
| } |
| } |
| index_src += skipTop; |
| |
| return true; |
| } |
| |
| int RectangleTest::clampSignedValue(int bits, int value) const |
| { |
| int max = 2147483647; |
| int min = 0x80000000; |
| |
| if (bits < 32) |
| { |
| max = (1 << (bits - 1)) - 1; |
| min = (1 << (bits - 1)) - (1 << bits); |
| } |
| |
| if (value >= max) |
| return max; |
| else if (value <= min) |
| return min; |
| |
| return value; |
| } |
| |
| unsigned int RectangleTest::clampUnsignedValue(int bits, unsigned int value) const |
| { |
| unsigned int max = 4294967295u; |
| unsigned int min = 0; |
| |
| if (bits < 32) |
| { |
| max = (1 << bits) - 1; |
| } |
| |
| if (value >= max) |
| return max; |
| else if (value <= min) |
| return min; |
| |
| return value; |
| } |
| |
| float RectangleTest::pack_UNSIGNED_BYTE(GLubyte value) |
| { |
| return static_cast<GLfloat>(value) / std::numeric_limits<GLubyte>::max(); |
| } |
| |
| float RectangleTest::pack_BYTE(GLbyte value) |
| { |
| return deFloatMax(static_cast<GLfloat>(value) / std::numeric_limits<GLbyte>::max(), -1.0f); |
| } |
| |
| float RectangleTest::pack_UNSIGNED_SHORT(GLushort value) |
| { |
| return static_cast<GLfloat>(value) / std::numeric_limits<GLushort>::max(); |
| } |
| |
| float RectangleTest::pack_SHORT(GLshort value) |
| { |
| return deFloatMax(static_cast<GLfloat>(value) / std::numeric_limits<GLshort>::max(), -1.0f); |
| } |
| |
| float RectangleTest::pack_UNSIGNED_INT(GLuint value) |
| { |
| return static_cast<GLfloat>(value) / std::numeric_limits<GLuint>::max(); |
| } |
| |
| float RectangleTest::pack_INT(GLint value) |
| { |
| return deFloatMax(static_cast<GLfloat>(value) / std::numeric_limits<GLint>::max(), -1.0f); |
| } |
| |
| float RectangleTest::pack_HALF_FLOAT(GLhalf value) |
| { |
| return halfFloatToFloat(value); |
| } |
| |
| float RectangleTest::pack_FLOAT(GLfloat value) |
| { |
| return value; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_BYTE_3_3_2(rawFloatPixel* values, GLubyte value) |
| { |
| (*values)[0] = ((value >> 5) & 7) / 7.0f; |
| (*values)[1] = ((value >> 2) & 7) / 7.0f; |
| (*values)[2] = ((value >> 0) & 3) / 3.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_BYTE_3_3_2_UINT(rawUintPixel* values, GLubyte value) |
| { |
| (*values)[0] = (value >> 5) & 7; |
| (*values)[1] = (value >> 2) & 7; |
| (*values)[2] = (value >> 0) & 3; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_BYTE_3_3_2_INT(rawIntPixel* values, GLubyte value) |
| { |
| (*values)[0] = (static_cast<GLbyte>(value) >> 5) & 7; |
| (*values)[1] = (static_cast<GLbyte>(value) >> 2) & 7; |
| (*values)[2] = (static_cast<GLbyte>(value) >> 0) & 3; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_BYTE_2_3_3_REV(rawFloatPixel* values, GLubyte value) |
| { |
| (*values)[2] = ((value >> 6) & 3) / 3.0f; |
| (*values)[1] = ((value >> 3) & 7) / 7.0f; |
| (*values)[0] = ((value >> 0) & 7) / 7.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_BYTE_2_3_3_REV_UINT(rawUintPixel* values, GLubyte value) |
| { |
| (*values)[2] = (value >> 6) & 3; |
| (*values)[1] = (value >> 3) & 7; |
| (*values)[0] = (value >> 0) & 7; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_BYTE_2_3_3_REV_INT(rawIntPixel* values, GLubyte value) |
| { |
| (*values)[2] = (static_cast<GLbyte>(value) >> 6) & 3; |
| (*values)[1] = (static_cast<GLbyte>(value) >> 3) & 7; |
| (*values)[0] = (static_cast<GLbyte>(value) >> 0) & 7; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_6_5(rawFloatPixel* values, GLushort value) |
| { |
| (*values)[0] = ((value >> 11) & 31) / 31.0f; |
| (*values)[1] = ((value >> 5) & 63) / 63.0f; |
| (*values)[2] = ((value >> 0) & 31) / 31.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_6_5_UINT(rawUintPixel* values, GLushort value) |
| { |
| (*values)[0] = (value >> 11) & 31; |
| (*values)[1] = (value >> 5) & 63; |
| (*values)[2] = (value >> 0) & 31; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_6_5_INT(rawIntPixel* values, GLushort value) |
| { |
| (*values)[0] = (static_cast<GLshort>(value) >> 11) & 31; |
| (*values)[1] = (static_cast<GLshort>(value) >> 5) & 63; |
| (*values)[2] = (static_cast<GLshort>(value) >> 0) & 31; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_6_5_REV(rawFloatPixel* values, GLushort value) |
| { |
| (*values)[2] = ((value >> 11) & 31) / 31.0f; |
| (*values)[1] = ((value >> 5) & 63) / 63.0f; |
| (*values)[0] = ((value >> 0) & 31) / 31.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_6_5_REV_UINT(rawUintPixel* values, GLushort value) |
| { |
| (*values)[2] = (value >> 11) & 31; |
| (*values)[1] = (value >> 5) & 63; |
| (*values)[0] = (value >> 0) & 31; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_6_5_REV_INT(rawIntPixel* values, GLushort value) |
| { |
| (*values)[2] = (static_cast<GLshort>(value) >> 11) & 31; |
| (*values)[1] = (static_cast<GLshort>(value) >> 5) & 63; |
| (*values)[0] = (static_cast<GLshort>(value) >> 0) & 31; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_4_4_4_4(rawFloatPixel* values, GLushort value) |
| { |
| (*values)[0] = ((value >> 12) & 15) / 15.0f; |
| (*values)[1] = ((value >> 8) & 15) / 15.0f; |
| (*values)[2] = ((value >> 4) & 15) / 15.0f; |
| (*values)[3] = ((value >> 0) & 15) / 15.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_4_4_4_4_UINT(rawUintPixel* values, GLushort value) |
| { |
| (*values)[0] = (value >> 12) & 15; |
| (*values)[1] = (value >> 8) & 15; |
| (*values)[2] = (value >> 4) & 15; |
| (*values)[3] = (value >> 0) & 15; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_4_4_4_4_INT(rawIntPixel* values, GLushort value) |
| { |
| (*values)[0] = (static_cast<GLshort>(value) >> 12) & 15; |
| (*values)[1] = (static_cast<GLshort>(value) >> 8) & 15; |
| (*values)[2] = (static_cast<GLshort>(value) >> 4) & 15; |
| (*values)[3] = (static_cast<GLshort>(value) >> 0) & 15; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_4_4_4_4_REV(rawFloatPixel* values, GLushort value) |
| { |
| (*values)[3] = ((value >> 12) & 15) / 15.0f; |
| (*values)[2] = ((value >> 8) & 15) / 15.0f; |
| (*values)[1] = ((value >> 4) & 15) / 15.0f; |
| (*values)[0] = ((value >> 0) & 15) / 15.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_4_4_4_4_REV_UINT(rawUintPixel* values, GLushort value) |
| { |
| (*values)[3] = (value >> 12) & 15; |
| (*values)[2] = (value >> 8) & 15; |
| (*values)[1] = (value >> 4) & 15; |
| (*values)[0] = (value >> 0) & 15; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_4_4_4_4_REV_INT(rawIntPixel* values, GLushort value) |
| { |
| (*values)[3] = (static_cast<GLshort>(value) >> 12) & 15; |
| (*values)[2] = (static_cast<GLshort>(value) >> 8) & 15; |
| (*values)[1] = (static_cast<GLshort>(value) >> 4) & 15; |
| (*values)[0] = (static_cast<GLshort>(value) >> 0) & 15; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_5_5_1(rawFloatPixel* values, GLushort value) |
| { |
| (*values)[0] = ((value >> 11) & 31) / 31.0f; |
| (*values)[1] = ((value >> 6) & 31) / 31.0f; |
| (*values)[2] = ((value >> 1) & 31) / 31.0f; |
| (*values)[3] = ((value >> 0) & 1) / 1.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_5_5_1_UINT(rawUintPixel* values, GLushort value) |
| { |
| (*values)[0] = (value >> 11) & 31; |
| (*values)[1] = (value >> 6) & 31; |
| (*values)[2] = (value >> 1) & 31; |
| (*values)[3] = (value >> 0) & 1; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_5_5_5_1_INT(rawIntPixel* values, GLushort value) |
| { |
| (*values)[0] = (static_cast<GLshort>(value) >> 11) & 31; |
| (*values)[1] = (static_cast<GLshort>(value) >> 6) & 31; |
| (*values)[2] = (static_cast<GLshort>(value) >> 1) & 31; |
| (*values)[3] = (static_cast<GLshort>(value) >> 0) & 1; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_1_5_5_5_REV(rawFloatPixel* values, GLushort value) |
| { |
| (*values)[3] = ((value >> 15) & 1) / 1.0f; |
| (*values)[2] = ((value >> 10) & 31) / 31.0f; |
| (*values)[1] = ((value >> 5) & 31) / 31.0f; |
| (*values)[0] = ((value >> 0) & 31) / 31.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_1_5_5_5_REV_UINT(rawUintPixel* values, GLushort value) |
| { |
| (*values)[3] = (value >> 15) & 1; |
| (*values)[2] = (value >> 10) & 31; |
| (*values)[1] = (value >> 5) & 31; |
| (*values)[0] = (value >> 0) & 31; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_SHORT_1_5_5_5_REV_INT(rawIntPixel* values, GLushort value) |
| { |
| (*values)[3] = (static_cast<GLshort>(value) >> 15) & 1; |
| (*values)[2] = (static_cast<GLshort>(value) >> 10) & 31; |
| (*values)[1] = (static_cast<GLshort>(value) >> 5) & 31; |
| (*values)[0] = (static_cast<GLshort>(value) >> 0) & 31; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_8_8_8_8(rawFloatPixel* values, GLuint value) |
| { |
| (*values)[0] = ((value >> 24) & 255) / 255.0f; |
| (*values)[1] = ((value >> 16) & 255) / 255.0f; |
| (*values)[2] = ((value >> 8) & 255) / 255.0f; |
| (*values)[3] = ((value >> 0) & 255) / 255.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_8_8_8_8_UINT(rawUintPixel* values, GLuint value) |
| { |
| (*values)[0] = (value >> 24) & 255; |
| (*values)[1] = (value >> 16) & 255; |
| (*values)[2] = (value >> 8) & 255; |
| (*values)[3] = (value >> 0) & 255; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_8_8_8_8_INT(rawIntPixel* values, GLuint value) |
| { |
| (*values)[0] = (static_cast<GLint>(value) >> 24) & 255; |
| (*values)[1] = (static_cast<GLint>(value) >> 16) & 255; |
| (*values)[2] = (static_cast<GLint>(value) >> 8) & 255; |
| (*values)[3] = (static_cast<GLint>(value) >> 0) & 255; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_8_8_8_8_REV(rawFloatPixel* values, GLuint value) |
| { |
| (*values)[3] = ((value >> 24) & 255) / 255.0f; |
| (*values)[2] = ((value >> 16) & 255) / 255.0f; |
| (*values)[1] = ((value >> 8) & 255) / 255.0f; |
| (*values)[0] = ((value >> 0) & 255) / 255.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_8_8_8_8_REV_UINT(rawUintPixel* values, GLuint value) |
| { |
| (*values)[3] = (value >> 24) & 255; |
| (*values)[2] = (value >> 16) & 255; |
| (*values)[1] = (value >> 8) & 255; |
| (*values)[0] = (value >> 0) & 255; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_8_8_8_8_REV_INT(rawIntPixel* values, GLuint value) |
| { |
| (*values)[3] = (static_cast<GLint>(value) >> 24) & 255; |
| (*values)[2] = (static_cast<GLint>(value) >> 16) & 255; |
| (*values)[1] = (static_cast<GLint>(value) >> 8) & 255; |
| (*values)[0] = (static_cast<GLint>(value) >> 0) & 255; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_10_10_10_2(rawFloatPixel* values, GLuint value) |
| { |
| (*values)[0] = ((value >> 22) & 1023) / 1023.0f; |
| (*values)[1] = ((value >> 12) & 1023) / 1023.0f; |
| (*values)[2] = ((value >> 2) & 1023) / 1023.0f; |
| (*values)[3] = ((value >> 0) & 3) / 3.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_10_10_10_2_UINT(rawUintPixel* values, GLuint value) |
| { |
| (*values)[0] = ((value >> 22) & 1023); |
| (*values)[1] = ((value >> 12) & 1023); |
| (*values)[2] = ((value >> 2) & 1023); |
| (*values)[3] = ((value >> 0) & 3); |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_10_10_10_2_INT(rawIntPixel* values, GLuint value) |
| { |
| (*values)[0] = ((static_cast<GLint>(value) >> 22) & 1023); |
| (*values)[1] = ((static_cast<GLint>(value) >> 12) & 1023); |
| (*values)[2] = ((static_cast<GLint>(value) >> 2) & 1023); |
| (*values)[3] = ((static_cast<GLint>(value) >> 0) & 3); |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_2_10_10_10_REV(rawFloatPixel* values, GLuint value) |
| { |
| (*values)[3] = ((value >> 30) & 3) / 3.0f; |
| (*values)[2] = ((value >> 20) & 1023) / 1023.0f; |
| (*values)[1] = ((value >> 10) & 1023) / 1023.0f; |
| (*values)[0] = ((value >> 0) & 1023) / 1023.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_2_10_10_10_REV_UINT(rawUintPixel* values, GLuint value) |
| { |
| (*values)[3] = (value >> 30) & 3; |
| (*values)[2] = (value >> 20) & 1023; |
| (*values)[1] = (value >> 10) & 1023; |
| (*values)[0] = (value >> 0) & 1023; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_2_10_10_10_REV_INT(rawIntPixel* values, GLuint value) |
| { |
| (*values)[3] = (static_cast<GLint>(value) >> 30) & 3; |
| (*values)[2] = (static_cast<GLint>(value) >> 20) & 1023; |
| (*values)[1] = (static_cast<GLint>(value) >> 10) & 1023; |
| (*values)[0] = (static_cast<GLint>(value) >> 0) & 1023; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_24_8(rawFloatPixel* values, GLuint value) |
| { |
| (*values)[0] = ((value >> 8) & 16777215) / 16777215.0f; |
| (*values)[1] = ((value >> 0) & 255) / 255.0f; |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_10F_11F_11F_REV(rawFloatPixel* values, GLuint value) |
| { |
| (*values)[2] = unsignedF10ToFloat((value >> 22) & 1023); |
| (*values)[1] = unsignedF11ToFloat((value >> 11) & 2047); |
| (*values)[0] = unsignedF11ToFloat((value >> 0) & 2047); |
| } |
| |
| void RectangleTest::pack_UNSIGNED_INT_5_9_9_9_REV(rawFloatPixel* values, GLuint value) |
| { |
| const int B = 15; |
| const int N = 9; |
| GLint pExp = ((value >> 27) & 31); |
| GLuint pBlue = ((value >> 18) & 511); |
| GLuint pGreen = ((value >> 9) & 511); |
| GLuint pRed = ((value >> 0) & 511); |
| |
| (*values)[2] = (float)(pBlue * pow(2.0, pExp - B - N)); |
| (*values)[1] = (float)(pGreen * pow(2.0, pExp - B - N)); |
| (*values)[0] = (float)(pRed * pow(2.0, pExp - B - N)); |
| (*values)[3] = 1.0f; |
| } |
| |
| void RectangleTest::pack_FLOAT_32_UNSIGNED_INT_24_8_REV(rawFloatPixel* values, F_32_UINT_24_8_REV value) |
| { |
| (*values)[0] = value.d; |
| (*values)[1] = (value.s & 255) / 255.0f; |
| } |
| |
| bool RectangleTest::getTexImage() |
| { |
| // for each output format |
| for (int m = 0; m < DE_LENGTH_OF_ARRAY(coreFormats); ++m) |
| { |
| const PixelFormat& outputFormat = coreFormats[m]; |
| |
| // for each output type |
| for (int n = 0; n < DE_LENGTH_OF_ARRAY(coreTypes); ++n) |
| { |
| const PixelType& outputType = coreTypes[n]; |
| |
| if ((m_inputFormat.format != m_internalFormat.format || m_inputType.type != m_internalFormat.type) && |
| (outputFormat.format != m_internalFormat.format || outputType.type != m_internalFormat.type)) |
| { |
| continue; |
| } |
| |
| if (!getTexImageInner(outputFormat, outputType)) |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| bool RectangleTest::getTexImageInner(const PixelFormat& outputFormat, const PixelType& outputType) |
| { |
| bool outputFormatValid = isFormatValid(outputFormat, outputType, m_internalFormat, false, true, OUTPUT_GETTEXIMAGE); |
| |
| GLenum error = readOutputData(outputFormat, outputType, OUTPUT_GETTEXIMAGE); |
| m_countGetTexImage++; |
| |
| if (!outputFormatValid) |
| { |
| if (error) |
| { |
| m_countGetTexImageOK++; |
| return true; |
| } |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Expected error but got no GL error" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (error) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Error during glGetTexImage" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| m_countGetTexImageOK++; |
| m_countCompare++; |
| |
| // compare output gradient to input gradient |
| if (compare(&m_gradient[0], &m_outputBuffer[0], outputFormat, outputType, false)) |
| { |
| m_countCompareOK++; |
| return true; |
| } |
| |
| m_testCtx.getLog() << tcu::TestLog::Message << "Gradient comparison failed during GetTexImage for input = [" |
| << getFormatStr(m_inputFormat.format) << ", " << getTypeStr(m_inputType.type) << "] output = [" |
| << getFormatStr(outputFormat.format) << ", " << getTypeStr(outputType.type) << "]" |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| void RectangleTest::testAllFormatsAndTypes() |
| { |
| DE_ASSERT((m_textureTarget == GL_TEXTURE_2D) || (m_textureTarget == GL_TEXTURE_3D)); |
| |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| bool result = true; |
| |
| gl.clear(GL_COLOR_BUFFER_BIT); |
| |
| const PixelType* types; |
| int typesCount; |
| const PixelFormat* formats; |
| int formatsCount; |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| types = esTypes; |
| typesCount = DE_LENGTH_OF_ARRAY(esTypes); |
| formats = esFormats; |
| formatsCount = DE_LENGTH_OF_ARRAY(esFormats); |
| } |
| else |
| { |
| types = coreTypes; |
| typesCount = DE_LENGTH_OF_ARRAY(coreTypes); |
| formats = coreFormats; |
| formatsCount = DE_LENGTH_OF_ARRAY(coreFormats); |
| } |
| |
| for (int inputFormatIndex = 0; inputFormatIndex < formatsCount; inputFormatIndex++) |
| { |
| m_inputFormat = formats[inputFormatIndex]; |
| |
| for (int inputTypeIndex = 0; inputTypeIndex < typesCount; inputTypeIndex++) |
| { |
| GLenum error = 0; |
| m_inputType = types[inputTypeIndex]; |
| |
| applyInitialStorageModes(); |
| |
| // Create input gradient in format,type, with appropriate range |
| createGradient(); |
| if (m_gradient.empty()) |
| TCU_FAIL("Could not create gradient."); |
| |
| if (m_unpackProperties.swapBytes) |
| swapBytes(m_inputType.size, m_gradient); |
| |
| GLuint texture; |
| gl.genTextures(1, &texture); |
| gl.bindTexture(m_textureTarget, texture); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture"); |
| if (m_textureTarget == GL_TEXTURE_3D) |
| { |
| gl.texImage3D(GL_TEXTURE_3D, 0, m_internalFormat.sizedFormat, GRADIENT_WIDTH, GRADIENT_HEIGHT, 1, 0, |
| m_inputFormat.format, m_inputType.type, &m_gradient[0]); |
| } |
| else |
| { |
| gl.texImage2D(GL_TEXTURE_2D, 0, m_internalFormat.sizedFormat, GRADIENT_WIDTH, GRADIENT_HEIGHT, 0, |
| m_inputFormat.format, m_inputType.type, &m_gradient[0]); |
| } |
| |
| if (m_unpackProperties.swapBytes) |
| swapBytes(m_inputType.size, m_gradient); |
| |
| error = gl.getError(); |
| if (isFormatValid(m_inputFormat, m_inputType, m_internalFormat, true, false, INPUT_TEXIMAGE)) |
| { |
| if (error == GL_NO_ERROR) |
| { |
| if (!glu::isContextTypeES(renderContext.getType())) |
| result &= getTexImage(); |
| result &= doRead(texture); |
| } |
| else |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Valid format used but glTexImage2D/3D failed" |
| << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| } |
| else if (error == GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Invalid format used but glTexImage2D/3D succeeded" |
| << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| |
| gl.deleteTextures(1, &texture); |
| } |
| } |
| |
| if (result) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| } |
| |
| tcu::TestNode::IterateResult RectangleTest::iterate(void) |
| { |
| resetInitialStorageModes(); |
| testAllFormatsAndTypes(); |
| return STOP; |
| } |
| |
| class InitialValuesTest : public deqp::TestCase |
| { |
| public: |
| InitialValuesTest(deqp::Context& context); |
| virtual ~InitialValuesTest(); |
| |
| tcu::TestNode::IterateResult iterate(void); |
| }; |
| |
| InitialValuesTest::InitialValuesTest(deqp::Context& context) |
| : deqp::TestCase(context, "initial_values", "Verify if all UNPACK and PACK initial " |
| "state matches the values in table 6.28 (6.23, in ES.)") |
| { |
| } |
| |
| InitialValuesTest::~InitialValuesTest() |
| { |
| } |
| |
| tcu::TestNode::IterateResult InitialValuesTest::iterate(void) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| bool result = true; |
| |
| GLenum commonIntModes[] = { GL_UNPACK_ROW_LENGTH, GL_UNPACK_SKIP_ROWS, GL_UNPACK_SKIP_PIXELS, |
| GL_UNPACK_IMAGE_HEIGHT, GL_UNPACK_SKIP_IMAGES, GL_PACK_ROW_LENGTH, |
| GL_PACK_SKIP_ROWS, GL_PACK_SKIP_PIXELS }; |
| |
| // check if following eight storage modes are 0 |
| GLint i = 1; |
| for (int mode = 0; mode < DE_LENGTH_OF_ARRAY(commonIntModes); mode++) |
| { |
| gl.getIntegerv(commonIntModes[mode], &i); |
| result &= (i == 0); |
| } |
| |
| // check if following two storage modes are 4 |
| gl.getIntegerv(GL_UNPACK_ALIGNMENT, &i); |
| result &= (i == 4); |
| gl.getIntegerv(GL_PACK_ALIGNMENT, &i); |
| result &= (i == 4); |
| |
| // check storage modes available only in core GL |
| if (!glu::isContextTypeES(renderContext.getType())) |
| { |
| // check if following four boolean modes are false |
| GLboolean b = true; |
| gl.getBooleanv(GL_UNPACK_SWAP_BYTES, &b); |
| result &= (b == false); |
| gl.getBooleanv(GL_UNPACK_LSB_FIRST, &b); |
| result &= (b == false); |
| gl.getBooleanv(GL_PACK_SWAP_BYTES, &b); |
| result &= (b == false); |
| gl.getBooleanv(GL_PACK_LSB_FIRST, &b); |
| result &= (b == false); |
| |
| // check if following two modes are 0 |
| gl.getIntegerv(GL_PACK_IMAGE_HEIGHT, &i); |
| result &= (i == 0); |
| gl.getIntegerv(GL_PACK_SKIP_IMAGES, &i); |
| result &= (i == 0); |
| } |
| |
| // make sure that no pack/unpack buffers are bound |
| gl.getIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &i); |
| result &= (i == 0); |
| gl.getIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &i); |
| result &= (i == 0); |
| |
| if (result) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| |
| class PBORectangleTest : public RectangleTest |
| { |
| public: |
| PBORectangleTest(deqp::Context& context, std::string& name, InternalFormat internalFormat); |
| virtual ~PBORectangleTest(); |
| }; |
| |
| PBORectangleTest::PBORectangleTest(deqp::Context& context, std::string& name, InternalFormat internalFormat) |
| : RectangleTest(context, name, internalFormat) |
| { |
| m_usePBO = true; |
| } |
| |
| PBORectangleTest::~PBORectangleTest() |
| { |
| } |
| |
| class VariedRectangleTest : public RectangleTest |
| { |
| public: |
| VariedRectangleTest(deqp::Context& context, std::string& name, InternalFormat internalFormat); |
| virtual ~VariedRectangleTest(); |
| |
| tcu::TestNode::IterateResult iterate(void); |
| |
| protected: |
| struct StoreMode |
| { |
| GLenum parameter; |
| GLint* property; |
| GLint value; |
| }; |
| }; |
| |
| VariedRectangleTest::VariedRectangleTest(deqp::Context& context, std::string& name, InternalFormat internalFormat) |
| : RectangleTest(context, name, internalFormat) |
| { |
| } |
| |
| VariedRectangleTest::~VariedRectangleTest() |
| { |
| } |
| |
| tcu::TestNode::IterateResult VariedRectangleTest::iterate(void) |
| { |
| const int IMAGE_WIDTH_1 = 10; |
| const int IMAGE_WIDTH_2 = 15; |
| const int IMAGE_HEIGHT_1 = 10; |
| const int IMAGE_HEIGHT_2 = 15; |
| |
| PackedPixelsBufferProperties& up = m_initialUnpackProperties; |
| PackedPixelsBufferProperties& pp = m_initialPackProperties; |
| |
| StoreMode commonCases[] = { |
| { GL_UNPACK_ROW_LENGTH, &up.rowLength, 0 }, |
| { GL_UNPACK_ROW_LENGTH, &up.rowLength, IMAGE_WIDTH_1 }, |
| { GL_UNPACK_ROW_LENGTH, &up.rowLength, IMAGE_WIDTH_2 }, |
| { GL_UNPACK_SKIP_ROWS, &up.skipRows, 0 }, |
| { GL_UNPACK_SKIP_ROWS, &up.skipRows, 1 }, |
| { GL_UNPACK_SKIP_ROWS, &up.skipRows, 2 }, |
| { GL_UNPACK_SKIP_PIXELS, &up.skipPixels, 0 }, |
| { GL_UNPACK_SKIP_PIXELS, &up.skipPixels, 1 }, |
| { GL_UNPACK_SKIP_PIXELS, &up.skipPixels, 2 }, |
| { GL_UNPACK_ALIGNMENT, &up.alignment, 1 }, |
| { GL_UNPACK_ALIGNMENT, &up.alignment, 2 }, |
| { GL_UNPACK_ALIGNMENT, &up.alignment, 4 }, |
| { GL_UNPACK_ALIGNMENT, &up.alignment, 8 }, |
| { GL_UNPACK_IMAGE_HEIGHT, &up.rowCount, 0 }, |
| { GL_UNPACK_IMAGE_HEIGHT, &up.rowCount, IMAGE_HEIGHT_1 }, |
| { GL_UNPACK_IMAGE_HEIGHT, &up.rowCount, IMAGE_HEIGHT_2 }, |
| { GL_UNPACK_SKIP_IMAGES, &up.skipImages, 0 }, |
| { GL_UNPACK_SKIP_IMAGES, &up.skipImages, 1 }, |
| { GL_UNPACK_SKIP_IMAGES, &up.skipImages, 2 }, |
| { GL_PACK_ROW_LENGTH, &pp.rowLength, 0 }, |
| { GL_PACK_ROW_LENGTH, &pp.rowLength, IMAGE_WIDTH_1 }, |
| { GL_PACK_ROW_LENGTH, &pp.rowLength, IMAGE_WIDTH_2 }, |
| { GL_PACK_SKIP_ROWS, &pp.skipRows, 0 }, |
| { GL_PACK_SKIP_ROWS, &pp.skipRows, 1 }, |
| { GL_PACK_SKIP_ROWS, &pp.skipRows, 2 }, |
| { GL_PACK_SKIP_PIXELS, &pp.skipPixels, 0 }, |
| { GL_PACK_SKIP_PIXELS, &pp.skipPixels, 1 }, |
| { GL_PACK_SKIP_PIXELS, &pp.skipPixels, 2 }, |
| { GL_PACK_ALIGNMENT, &pp.alignment, 1 }, |
| { GL_PACK_ALIGNMENT, &pp.alignment, 2 }, |
| { GL_PACK_ALIGNMENT, &pp.alignment, 4 }, |
| { GL_PACK_ALIGNMENT, &pp.alignment, 8 }, |
| }; |
| |
| StoreMode coreCases[] = { |
| { GL_UNPACK_SWAP_BYTES, &up.swapBytes, GL_FALSE }, |
| { GL_UNPACK_SWAP_BYTES, &up.swapBytes, GL_TRUE }, |
| { GL_UNPACK_LSB_FIRST, &up.lsbFirst, GL_FALSE }, |
| { GL_UNPACK_LSB_FIRST, &up.lsbFirst, GL_TRUE }, |
| { GL_PACK_SWAP_BYTES, &pp.swapBytes, GL_FALSE }, |
| { GL_PACK_SWAP_BYTES, &pp.swapBytes, GL_TRUE }, |
| { GL_PACK_LSB_FIRST, &pp.lsbFirst, GL_FALSE }, |
| { GL_PACK_LSB_FIRST, &pp.lsbFirst, GL_TRUE }, |
| { GL_PACK_IMAGE_HEIGHT, &pp.rowCount, 0 }, |
| { GL_PACK_IMAGE_HEIGHT, &pp.rowCount, IMAGE_HEIGHT_1 }, |
| { GL_PACK_IMAGE_HEIGHT, &pp.rowCount, IMAGE_HEIGHT_2 }, |
| { GL_PACK_SKIP_IMAGES, &pp.skipImages, 0 }, |
| { GL_PACK_SKIP_IMAGES, &pp.skipImages, 1 }, |
| { GL_PACK_SKIP_IMAGES, &pp.skipImages, 2 }, |
| }; |
| |
| std::vector<StoreMode> testModes(commonCases, commonCases + DE_LENGTH_OF_ARRAY(commonCases)); |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| bool contextTypeIsCoreGL = !glu::isContextTypeES(renderContext.getType()); |
| if (contextTypeIsCoreGL) |
| testModes.insert(testModes.end(), coreCases, coreCases + DE_LENGTH_OF_ARRAY(coreCases)); |
| |
| std::vector<StoreMode>::iterator currentCase = testModes.begin(); |
| while (currentCase != testModes.end()) |
| { |
| resetInitialStorageModes(); |
| |
| GLenum parameter = currentCase->parameter; |
| GLint value = currentCase->value; |
| |
| *(currentCase->property) = value; |
| |
| // for some parameters an additional parameter needs to be set |
| if (parameter == GL_PACK_SKIP_ROWS) |
| { |
| if (contextTypeIsCoreGL) |
| m_initialPackProperties.rowCount = GRADIENT_HEIGHT + value; |
| } |
| else if (parameter == GL_PACK_SKIP_PIXELS) |
| m_initialPackProperties.rowLength = GRADIENT_WIDTH + value; |
| else if (parameter == GL_UNPACK_SKIP_ROWS) |
| m_initialUnpackProperties.rowCount = GRADIENT_HEIGHT + value; |
| else if (parameter == GL_UNPACK_SKIP_PIXELS) |
| m_initialUnpackProperties.rowLength = GRADIENT_WIDTH + value; |
| |
| m_textureTarget = GL_TEXTURE_2D; |
| if ((parameter == GL_PACK_IMAGE_HEIGHT) || (parameter == GL_PACK_SKIP_IMAGES) || |
| (parameter == GL_UNPACK_IMAGE_HEIGHT) || (parameter == GL_UNPACK_SKIP_IMAGES)) |
| m_textureTarget = GL_TEXTURE_3D; |
| |
| testAllFormatsAndTypes(); |
| |
| if (m_testCtx.getTestResult() != QP_TEST_RESULT_PASS) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Case for: " << glu::getGettableStateStr(parameter).toString() << " = " << value |
| << " failed." << tcu::TestLog::EndMessage; |
| return STOP; |
| } |
| |
| ++currentCase; |
| } |
| |
| return STOP; |
| } |
| |
| PackedPixelsTests::PackedPixelsTests(deqp::Context& context) : TestCaseGroup(context, "packed_pixels", "") |
| { |
| } |
| |
| PackedPixelsTests::~PackedPixelsTests(void) |
| { |
| #ifdef LOG_PACKED_PIXELS_STATISTICS |
| m_testCtx.getLog() << tcu::TestLog::Message << "PackedPixelsTests statistics:" |
| << "\n countReadPixels: " << RectangleTest::m_countReadPixels |
| << "\n countReadPixelsOK: " << RectangleTest::m_countReadPixelsOK |
| << "\n countGetTexImage: " << RectangleTest::m_countGetTexImage |
| << "\n countGetTexImageOK: " << RectangleTest::m_countGetTexImageOK |
| << "\n countCompare: " << RectangleTest::m_countCompare |
| << "\n countCompareOK: " << RectangleTest::m_countCompareOK << tcu::TestLog::EndMessage; |
| #endif |
| } |
| |
| void PackedPixelsTests::init(void) |
| { |
| const InternalFormat* internalFormats; |
| unsigned int internalFormatsCount; |
| |
| if (glu::isContextTypeES(m_context.getRenderContext().getType())) |
| { |
| internalFormats = esInternalformats; |
| internalFormatsCount = DE_LENGTH_OF_ARRAY(esInternalformats); |
| } |
| else |
| { |
| internalFormats = coreInternalformats; |
| internalFormatsCount = DE_LENGTH_OF_ARRAY(coreInternalformats); |
| } |
| |
| TestCaseGroup* rectangleGroup = new deqp::TestCaseGroup(m_context, "rectangle", ""); |
| rectangleGroup->addChild(new InitialValuesTest(m_context)); |
| TestCaseGroup* pboRectangleGroup = new deqp::TestCaseGroup(m_context, "pbo_rectangle", ""); |
| TestCaseGroup* variedRectangleGroup = new deqp::TestCaseGroup(m_context, "varied_rectangle", ""); |
| |
| for (unsigned int internalFormatIndex = 0; internalFormatIndex < internalFormatsCount; internalFormatIndex++) |
| { |
| const InternalFormat& internalFormat = internalFormats[internalFormatIndex]; |
| std::string internalFormatString = getFormatStr(internalFormat.sizedFormat); |
| |
| std::string name = internalFormatString.substr(3); |
| std::transform(name.begin(), name.end(), name.begin(), tolower); |
| |
| rectangleGroup->addChild(new RectangleTest(m_context, name, internalFormat)); |
| pboRectangleGroup->addChild(new PBORectangleTest(m_context, name, internalFormat)); |
| variedRectangleGroup->addChild(new VariedRectangleTest(m_context, name, internalFormat)); |
| } |
| |
| addChild(rectangleGroup); |
| addChild(pboRectangleGroup); |
| addChild(variedRectangleGroup); |
| } |
| |
| } /* glcts namespace */ |