| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2018 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 es3cCopyTexImageConversionsTests.cpp |
| * \brief Tests verifying glCopyTexImage2D.. |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "es3cCopyTexImageConversionsTests.hpp" |
| #include "deMath.h" |
| #include "deSharedPtr.hpp" |
| #include "gluContextInfo.hpp" |
| #include "gluDefs.hpp" |
| #include "gluStrUtil.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "tcuStringTemplate.hpp" |
| #include "tcuTestLog.hpp" |
| #include <cstring> |
| #include <limits> |
| #include <map> |
| |
| using namespace glw; |
| |
| namespace es3cts |
| { |
| |
| // Amount of entries database should allocate for its entries upon creation. |
| #define N_START_CONVERSION_DATABASE_ENTRIES (32) |
| |
| // Should 3D textures be used as source attachments, this field defines |
| // their depth. It MUST be at least 2, because the test implementation |
| // also uses second array (counted from one) to store the data-set information. |
| #define TEXTURE_DEPTH (2) |
| // Data set height |
| #define TEXTURE_HEIGHT (2) |
| // Data set width |
| #define TEXTURE_WIDTH (2) |
| |
| // Defines for non color-renderable textures support |
| #define NUMBER_OF_ELEMENTS_IN_VEC4 (4) |
| #define NUMBER_OF_POINTS_TO_DRAW (TEXTURE_WIDTH * TEXTURE_HEIGHT) |
| #define TEXTURE_COORDINATES_ARRAY_SIZE (TEXTURE_WIDTH * TEXTURE_HEIGHT * NUMBER_OF_ELEMENTS_IN_VEC4 * sizeof(float)) |
| #define TEXTURE_2D_SAMPLER_TYPE (0) |
| #define TEXTURE_3D_SAMPLER_TYPE (1) |
| #define TEXTURE_2D_ARRAY_SAMPLER_TYPE (2) |
| #define TEXTURE_CUBE_SAMPLER_TYPE (3) |
| #define SRC_TEXTURE_COORDS_ATTRIB_INDEX (1) |
| #define DST_TEXTURE_COORDS_ATTRIB_INDEX (0) |
| |
| // Buffer object indices used for non color-renderable textures support. |
| #define COMPARISON_RESULT_BUFFER_OBJECT_INDEX (0) |
| #define SOURCE_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX (1) |
| #define DESTINATION_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX (2) |
| |
| // Stores detailed information about: |
| // 1) what FBO effective internalformats can be used for glCopyTexImage2D(), assuming |
| // specific result texture's internalformat as passed by one of the arguments. |
| // 2) what internalformat the result texture object should use. |
| const GLenum conversionArray[] = { |
| /* GL_RGBA GL_RGB GL_LUMINANCE_ALPHA GL_LUMINANCE GL_ALPHA GL_R8 GL_R8_SNORM GL_RG8 GL_RG8_SNORM GL_RGB8 GL_RGB8_SNORM GL_RGB565 GL_RGBA4 GL_RGB5_A1 GL_RGBA8 GL_RGBA8_SNORM GL_RGB10_A2 GL_RGB10_A2UI GL_SRGB8 GL_SRGB8_ALPHA8 GL_R16F GL_RG16F GL_RGB16F GL_RGBA16F GL_R32F GL_RG32F GL_RGB32F GL_RGBA32F GL_R11F_G11F_B10F GL_RGB9_E5 GL_R8I GL_R8UI GL_R16I GL_R16UI GL_R32I GL_R32UI GL_RG8I GL_RG8UI GL_RG16I GL_RG16UI GL_RG32I GL_RG32UI GL_RGB8I GL_RGB8UI GL_RGB16I GL_RGB16UI GL_RGB32I GL_RGB32UI GL_RGBA8I GL_RGBA8UI GL_RGBA16I GL_RGBA16UI GL_RGBA32I GL_RGBA32UI */ |
| /* GL_R8, */ GL_NONE, GL_NONE, GL_NONE, GL_LUMINANCE8_OES, GL_NONE, GL_R8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG8, */ GL_NONE, GL_NONE, GL_NONE, GL_LUMINANCE8_OES, GL_NONE, GL_R8, GL_NONE, GL_RG8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGB8, */ GL_NONE, GL_RGB8, GL_NONE, GL_LUMINANCE8_OES, GL_NONE, GL_R8, GL_NONE, GL_RG8, GL_NONE, GL_RGB8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGB565, */ GL_NONE, GL_RGB565, GL_NONE, GL_LUMINANCE8_OES, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB565, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA4, */ GL_RGBA4, GL_RGB565, GL_LUMINANCE8_ALPHA8_OES, GL_LUMINANCE8_OES, GL_ALPHA8_OES, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA4, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGB5_A1, */ GL_RGB5_A1, GL_RGB565, GL_LUMINANCE8_ALPHA8_OES, GL_LUMINANCE8_OES, GL_ALPHA8_OES, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB5_A1, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA8, */ GL_RGBA8, GL_RGB8, GL_LUMINANCE8_ALPHA8_OES, GL_LUMINANCE8_OES, GL_ALPHA8_OES, GL_R8, GL_NONE, GL_RG8, GL_NONE, GL_RGB8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGB10_A2, */ GL_NONE, GL_RGB8, GL_NONE, GL_LUMINANCE8_OES, GL_ALPHA8_OES, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB10_A2, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGB10_A2UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB10_A2UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_SRGB8_ALPHA8, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_SRGB8, GL_SRGB8_ALPHA8, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_R8I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R8I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_R8UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R8UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_R16I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_R16UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_R32I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_R32UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG8I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R8I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG8I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG8UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R8UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG8UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG16I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG16I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG16UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG16UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG32I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG32I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG32UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG32UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA8I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R8I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG8I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB8I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA8I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA8UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R8UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG8UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB8UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA8UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA16I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG16I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB16I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA16I, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA16UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG16UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB16UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA16UI, GL_NONE, GL_NONE, |
| /* GL_RGBA32I, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG32I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB32I, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA32I, GL_NONE, |
| /* GL_RGBA32UI, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RG32UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGB32UI, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_RGBA32UI, |
| /* GL_R16F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG16F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16F, GL_RG16F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_R32F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RG32F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32F, GL_RG32F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGB16F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16F, GL_RG16F, GL_RGB16F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA16F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R16F, GL_RG16F, GL_RGB16F, GL_RGBA16F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGB32F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32F, GL_RG32F, GL_RGB32F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| /* GL_RGBA32F, */ GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_R32F, GL_RG32F, GL_RGB32F, GL_RGBA32F, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, GL_NONE, |
| }; |
| |
| // Tells: |
| // 1) how many rows conversion_array uses. |
| // 2) what destination internalformat (NOT effective internalformat!) |
| // corresponds to each entry. |
| // NOTE: If you need to modify this array, make sure conversion-array |
| // is updated accordingly! |
| const GLenum copyTexImage2DInternalFormatOrdering[] = { GL_RGBA, |
| GL_RGB, |
| GL_LUMINANCE_ALPHA, |
| GL_LUMINANCE, |
| GL_ALPHA, |
| GL_R8, |
| GL_R8_SNORM, |
| GL_RG8, |
| GL_RG8_SNORM, |
| GL_RGB8, |
| GL_RGB8_SNORM, |
| GL_RGB565, |
| GL_RGBA4, |
| GL_RGB5_A1, |
| GL_RGBA8, |
| GL_RGBA8_SNORM, |
| GL_RGB10_A2, |
| GL_RGB10_A2UI, |
| GL_SRGB8, |
| GL_SRGB8_ALPHA8, |
| GL_R16F, |
| GL_RG16F, |
| GL_RGB16F, |
| GL_RGBA16F, |
| GL_R32F, |
| GL_RG32F, |
| GL_RGB32F, |
| GL_RGBA32F, |
| GL_R11F_G11F_B10F, |
| GL_RGB9_E5, |
| GL_R8I, |
| GL_R8UI, |
| GL_R16I, |
| GL_R16UI, |
| GL_R32I, |
| GL_R32UI, |
| GL_RG8I, |
| GL_RG8UI, |
| GL_RG16I, |
| GL_RG16UI, |
| GL_RG32I, |
| GL_RG32UI, |
| GL_RGB8I, |
| GL_RGB8UI, |
| GL_RGB16I, |
| GL_RGB16UI, |
| GL_RGB32I, |
| GL_RGB32UI, |
| GL_RGBA8I, |
| GL_RGBA8UI, |
| GL_RGBA16I, |
| GL_RGBA16UI, |
| GL_RGBA32I, |
| GL_RGBA32UI }; |
| |
| // Ordering as per Bug 9807 table for FBO effective internalformats |
| const GLenum fboEffectiveInternalFormatOrdering[] = { |
| GL_R8, GL_RG8, GL_RGB8, GL_RGB565, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGB10_A2UI, |
| GL_SRGB8_ALPHA8, GL_R8I, GL_R8UI, GL_R16I, GL_R16UI, GL_R32I, GL_R32UI, GL_RG8I, GL_RG8UI, |
| GL_RG16I, GL_RG16UI, GL_RG32I, GL_RG32UI, GL_RGBA8I, GL_RGBA8UI, GL_RGBA16I, GL_RGBA16UI, GL_RGBA32I, |
| GL_RGBA32UI, GL_R16F, GL_RG16F, GL_R32F, GL_RG32F, GL_RGB16F, GL_RGBA16F, GL_RGB32F, GL_RGBA32F, |
| }; |
| |
| // Tells how channels are ordered for a particular pixel. |
| enum ChannelOrder |
| { |
| CHANNEL_ORDER_ABGR, |
| CHANNEL_ORDER_BGR, |
| CHANNEL_ORDER_BGRA, |
| CHANNEL_ORDER_R, |
| CHANNEL_ORDER_RG, |
| CHANNEL_ORDER_RGB, |
| CHANNEL_ORDER_RGBA, |
| |
| CHANNEL_ORDER_UNKNOWN |
| }; |
| |
| // Tells how many bits and what type is used for data representation |
| // for a single pixel channel. |
| enum ChannelDataType |
| { |
| CHANNEL_DATA_TYPE_NONE = 0, |
| CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS, |
| CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS, |
| CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_BYTE_1BIT, |
| CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_BYTE_4BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_BYTE_5BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_BYTE_6BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS, |
| CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS, |
| CHANNEL_DATA_TYPE_FLOAT |
| }; |
| |
| // Structure holding uniform locations and object IDs. |
| // Those values are used to support non-color-renderable texture internalformat checks. |
| struct NonRenderableInternalformatSupportObjects |
| { |
| GLuint comparison_result_buffer_object_id; |
| GLuint dst_texture_pixels_buffer_object_id; |
| GLint dst_2D_texture_uniform_location; |
| GLint dst_Cube_texture_uniform_location; |
| GLuint fragment_shader_object_id; |
| GLuint program_object_id; |
| GLuint src_texture_pixels_buffer_object_id; |
| GLint src_2D_texture_uniform_location; |
| GLint src_2DArray_texture_uniform_location; |
| GLint src_3D_texture_uniform_location; |
| GLint src_Cube_texture_uniform_location; |
| GLuint transform_feedback_object_id; |
| GLuint vertex_shader_object_id; |
| GLint channels_to_compare_uniform_location; |
| GLint samplers_to_use_uniform_location; |
| GLuint src_texture_coordinates_buffer_object_id; |
| GLuint dst_texture_coordinates_buffer_object_id; |
| }; |
| |
| // Structure describing contents of a channel of a single pixel. |
| struct ChannelData |
| { |
| // Union that allows to access the data representation |
| // in a data_type-friendly manner |
| union { |
| signed char signed_byte_data; |
| signed int signed_integer_data; |
| signed short signed_short_data; |
| unsigned char unsigned_byte_data; |
| unsigned int unsigned_integer_data; |
| unsigned short unsigned_short_data; |
| float float_data; |
| }; |
| |
| // Data type used for channel representation |
| ChannelDataType data_type; |
| }; |
| |
| // Structure describing a single pixel. |
| struct PixelData |
| { |
| // Alpha channel data descriptor |
| ChannelData alpha; |
| // Blue channel data descriptor |
| ChannelData blue; |
| // Green channel data descriptor |
| ChannelData green; |
| // Red channel data descriptor |
| ChannelData red; |
| |
| // For source pixels: GL internal-format used by all channels. |
| // For destination pixels: GL format to be used for gl.readPixels() |
| // operation in order to retrieve result data |
| // in a matching representation. |
| GLenum data_internalformat; |
| // For source pixels: GL type used by all channels. |
| // For destination pixels: GL type to be used for gl.readPixels() |
| // operation in order to retrieve result data |
| // in a matching representation. |
| GLenum data_type; |
| }; |
| |
| // To confirm contents of data stored in non-renderable internalformat, a special shader |
| // is used. This type definition tells which texture() function sampler should be used |
| // for sampling the texture data. |
| enum DataSamplerType |
| { |
| DATA_SAMPLER_FLOAT, |
| DATA_SAMPLER_INTEGER, |
| DATA_SAMPLER_UNSIGNED_INTEGER, |
| }; |
| |
| // When a special shader is used to check whether the copy succeeded we need to know which |
| // channels will have to be compared |
| enum PixelCompareChannel |
| { |
| PIXEL_COMPARE_CHANNEL_R = 0x1, |
| PIXEL_COMPARE_CHANNEL_G = 0x2, |
| PIXEL_COMPARE_CHANNEL_B = 0x4, |
| PIXEL_COMPARE_CHANNEL_A = 0x8, |
| PIXEL_COMPARE_CHANNEL_RG = PIXEL_COMPARE_CHANNEL_R | PIXEL_COMPARE_CHANNEL_G, |
| PIXEL_COMPARE_CHANNEL_RA = PIXEL_COMPARE_CHANNEL_R | PIXEL_COMPARE_CHANNEL_A, |
| PIXEL_COMPARE_CHANNEL_RGB = PIXEL_COMPARE_CHANNEL_RG | PIXEL_COMPARE_CHANNEL_B, |
| PIXEL_COMPARE_CHANNEL_RGBA = PIXEL_COMPARE_CHANNEL_RGB | PIXEL_COMPARE_CHANNEL_A, |
| }; |
| |
| // Structure describing a single conversion rule. |
| // |
| // For more details on meaning of these fields, please refer |
| // to doxygen of AddEntryToConversionDatabase() and similar. |
| struct ConversionDatabaseEntry |
| { |
| // Reference destination data expected for bottom-left corner |
| PixelData dst_bottomleft_corner; |
| // Reference destination data expected for bottom-right corner |
| PixelData dst_bottomright_corner; |
| // Reference destination data expected for top-left corner |
| PixelData dst_topleft_corner; |
| // Reference destination data expected for top-right corner |
| PixelData dst_topright_corner; |
| |
| // Input bottom-left corner data to be used for conversion |
| PixelData src_bottomleft_corner; |
| // Input bottom-right corner data to be used for conversion |
| PixelData src_bottomright_corner; |
| // Input top-left corner data to be used for conversion |
| PixelData src_topleft_corner; |
| // Input top-right corner data to be used for conversion |
| PixelData src_topright_corner; |
| |
| // What are the channels that we need to compare if gl.readPixels |
| // can't be used to read back the data |
| PixelCompareChannel channels_to_compare; |
| }; |
| |
| // Structure describing contents of an opaque conversion database handle. |
| class ConversionDatabase |
| { |
| public: |
| ConversionDatabase(); |
| ~ConversionDatabase(); |
| |
| void initializeDatabase(); |
| |
| bool isTypeSupportedByGLReadPixels(GLenum type); |
| bool isInternalFormatCompatibleWithType(GLenum type, GLenum internalformat); |
| bool convertNormalizedUnsignedFixedPoint(int* src_input_rgba_bits, int* src_attachment_rgba_bits, |
| int* dst_attachment_rgba_bits, int* dst_output_rgba_bits, int* src_rgba, |
| int* dst_rgba); |
| |
| PixelData getAlpha8OESPixelData(GLenum type, unsigned char alpha); |
| PixelData getLuminance8OESPixelData(GLenum type, unsigned char luminance); |
| PixelData getLuminance8Alpha8OESPixelData(GLenum type, unsigned char luminance, unsigned char alpha); |
| PixelData getR16IPixelData(int is_source_pixel, GLenum type, int red); |
| PixelData getR16UIPixelData(int is_source_pixel, GLenum type, unsigned int red); |
| PixelData getR32IPixelData(int is_source_pixel, GLenum type, int red); |
| PixelData getR32UIPixelData(int is_source_pixel, GLenum type, unsigned int red); |
| PixelData getR8IPixelData(int is_source_pixel, GLenum type, int red); |
| PixelData getR8UIPixelData(int is_source_pixel, GLenum type, unsigned int red); |
| PixelData getR8PixelData(int is_source_pixel, GLenum type, unsigned char red); |
| PixelData getRG16IPixelData(int is_source_pixel, GLenum type, int red, int green); |
| PixelData getRG16UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green); |
| PixelData getRG32IPixelData(int is_source_pixel, GLenum type, int red, int green); |
| PixelData getRG32UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green); |
| PixelData getRG8IPixelData(int is_source_pixel, GLenum type, int red, int green); |
| PixelData getRG8UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green); |
| PixelData getRG8PixelData(int is_source_pixel, GLenum type, unsigned char red, unsigned char green); |
| PixelData getRGB10A2PixelData(GLenum type, unsigned short red, unsigned short green, unsigned short blue, |
| unsigned char alpha); |
| PixelData getRGB10A2UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue, unsigned int alpha); |
| PixelData getRGB16IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue); |
| PixelData getRGB16UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue); |
| PixelData getRGB32IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue); |
| PixelData getRGB32UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue); |
| PixelData getRGB5A1PixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue, unsigned int alpha); |
| PixelData getRGB565PixelData(int is_source_pixel, GLenum type, int red, int green, int blue); |
| PixelData getRGB8PixelData(int is_source_pixel, GLenum type, unsigned char red, unsigned char green, |
| unsigned char blue); |
| PixelData getRGB8IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue); |
| PixelData getRGB8UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue); |
| PixelData getRGBA16IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue, int alpha); |
| PixelData getRGBA16UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue, unsigned int alpha); |
| PixelData getRGBA32IPixelData(GLenum type, int red, int green, int blue, int alpha); |
| |
| PixelData getRGBA32UIPixelData(GLenum type, unsigned int red, unsigned int green, unsigned int blue, |
| unsigned int alpha); |
| PixelData getRGBA8IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue, int alpha); |
| PixelData getRGBA8UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue, unsigned int alpha); |
| PixelData getRGBA4PixelData(int is_source_pixel, GLenum type, unsigned char red, unsigned char green, |
| unsigned char blue, unsigned char alpha); |
| PixelData getRGBA8PixelData(GLenum type, unsigned char red, unsigned char green, unsigned char blue, |
| unsigned char alpha); |
| PixelData getSRGB8Alpha8PixelData(GLenum type, unsigned char red, unsigned char green, unsigned char blue, |
| unsigned char alpha); |
| PixelData getSRGB8PixelData(int is_source_pixel, GLenum type, unsigned char red, unsigned char green, |
| unsigned char blue); |
| PixelData getR16FPixelData(int is_source_pixel, GLenum type, float red); |
| PixelData getR32FPixelData(int is_source_pixel, GLenum type, float red); |
| PixelData getRG16FPixelData(int is_source_pixel, GLenum type, float red, float green); |
| PixelData getRG32FPixelData(int is_source_pixel, GLenum type, float red, float green); |
| PixelData getRGB16FPixelData(int is_source_pixel, GLenum type, float red, float green, float blue); |
| PixelData getRGB32FPixelData(int is_source_pixel, GLenum type, float red, float green, float blue); |
| PixelData getRGBA16FPixelData(GLenum type, float red, float green, float blue, float alpha); |
| PixelData getRGBA32FPixelData(GLenum type, float red, float green, float blue, float alpha); |
| |
| protected: |
| void addEntryToConversionDatabase(PixelData src_topleft, PixelData dst_topleft, PixelData src_topright, |
| PixelData dst_topright, PixelData src_bottomleft, PixelData dst_bottomleft, |
| PixelData src_bottomright, PixelData dst_bottomright, |
| PixelCompareChannel channels_to_compare); |
| void configureConversionDatabase(); |
| |
| public: |
| // An array of _conversion_database_entry instances, |
| // storing all known conversion rules. |
| std::vector<ConversionDatabaseEntry> entries; |
| |
| // Amount of entries allocated in the "entries" array so far. |
| unsigned int n_entries_allocated; |
| |
| // Amount of entries added to the "entries" array so far. |
| unsigned int n_entries_added; |
| }; |
| |
| ConversionDatabase::ConversionDatabase() : n_entries_allocated(0), n_entries_added(0) |
| { |
| } |
| |
| ConversionDatabase::~ConversionDatabase() |
| { |
| } |
| |
| /** Initializes database instance. The database will be filled by the |
| * function with all available conversion rules, so it is a mistake to call |
| * ConfigureConversionDatabase() function for a handle reported by this function. |
| * |
| * The handle should be released with ReleaseConversionDatabase() when no longer |
| * needed. |
| * |
| * @return Handle to the newly created conversion database. |
| **/ |
| void ConversionDatabase::initializeDatabase() |
| { |
| // Return when database was initialized earlier. |
| if (!entries.empty()) |
| return; |
| |
| entries.resize(N_START_CONVERSION_DATABASE_ENTRIES); |
| n_entries_allocated = N_START_CONVERSION_DATABASE_ENTRIES; |
| n_entries_added = 0; |
| |
| if (entries.empty()) |
| TCU_FAIL("Out of memory while pre-allocating space for conversion database entries"); |
| |
| deMemset(&entries[0], DE_NULL, N_START_CONVERSION_DATABASE_ENTRIES * sizeof(ConversionDatabaseEntry)); |
| |
| // Add all predefined entries that the test implementation is aware of |
| configureConversionDatabase(); |
| } |
| |
| /** Tells whether @param type can be used for a gl.readPixels() call. |
| * |
| * @param type GL type to consider. |
| * |
| * @return true if the type should be accepted by a gl.readPixels() call, |
| * false otherwise. |
| */ |
| bool ConversionDatabase::isTypeSupportedByGLReadPixels(GLenum type) |
| { |
| return (type == GL_INT) || (type == GL_UNSIGNED_BYTE) || (type == GL_UNSIGNED_INT) || (type == GL_FLOAT) || |
| (type == GL_HALF_FLOAT) || (type == GL_UNSIGNED_INT_2_10_10_10_REV); |
| } |
| |
| /** Tells whether @param type can be used with @param internalformat internal format. |
| * |
| * @param type GLES type to consider. |
| * @param internalformat GLES internal format to consider. |
| * |
| * @return true if the type is compatible with specific internal format, false otherwise. |
| **/ |
| bool ConversionDatabase::isInternalFormatCompatibleWithType(GLenum type, GLenum internalformat) |
| { |
| bool result = false; |
| |
| switch (type) |
| { |
| case GL_INT: |
| { |
| result = (internalformat == GL_R8I) || (internalformat == GL_R16I) || (internalformat == GL_R32I) || |
| (internalformat == GL_RG8I) || (internalformat == GL_RG16I) || (internalformat == GL_RG32I) || |
| (internalformat == GL_RGB8I) || (internalformat == GL_RGB16I) || (internalformat == GL_RGB32I) || |
| (internalformat == GL_RGBA8I) || (internalformat == GL_RGBA16I) || (internalformat == GL_RGBA32I); |
| |
| break; |
| } |
| |
| case GL_UNSIGNED_BYTE: |
| { |
| result = (internalformat == GL_RGB) || (internalformat == GL_RGBA) || (internalformat == GL_LUMINANCE_ALPHA) || |
| (internalformat == GL_LUMINANCE) || (internalformat == GL_LUMINANCE8_OES) || |
| (internalformat == GL_LUMINANCE8_ALPHA8_OES) || (internalformat == GL_ALPHA) || |
| (internalformat == GL_ALPHA8_OES) || (internalformat == GL_R8) || (internalformat == GL_R8_SNORM) || |
| (internalformat == GL_RG8) || (internalformat == GL_RG8_SNORM) || (internalformat == GL_RGB8) || |
| (internalformat == GL_SRGB8) || (internalformat == GL_RGB565) || (internalformat == GL_RGB8_SNORM) || |
| (internalformat == GL_RGBA8) || (internalformat == GL_SRGB8_ALPHA8) || |
| (internalformat == GL_RGBA8_SNORM) || (internalformat == GL_RGB5_A1) || (internalformat == GL_RGBA4); |
| |
| break; |
| } |
| |
| case GL_UNSIGNED_INT: |
| { |
| result = (internalformat == GL_R8UI) || (internalformat == GL_R16UI) || (internalformat == GL_R32UI) || |
| (internalformat == GL_RG8UI) || (internalformat == GL_RG16UI) || (internalformat == GL_RG32UI) || |
| (internalformat == GL_RGB8UI) || (internalformat == GL_RGB10_A2UI) || (internalformat == GL_RGB16UI) || |
| (internalformat == GL_RGB32UI) || (internalformat == GL_RGBA8UI) || (internalformat == GL_RGBA16UI) || |
| (internalformat == GL_RGBA32UI); |
| |
| break; |
| } |
| |
| case GL_UNSIGNED_INT_2_10_10_10_REV: |
| { |
| result = (internalformat == GL_RGB10_A2) || (internalformat == GL_RGB10_A2UI); |
| |
| break; |
| } |
| |
| case GL_FLOAT: |
| { |
| result = (internalformat == GL_RGB) || (internalformat == GL_RGBA) || (internalformat == GL_R32F) || |
| (internalformat == GL_RG32F) || (internalformat == GL_RGB32F) || (internalformat == GL_RGBA32F); |
| |
| break; |
| } |
| |
| case GL_HALF_FLOAT: |
| { |
| result = (internalformat == GL_RGB) || (internalformat == GL_RGBA) || (internalformat == GL_R16F) || |
| (internalformat == GL_RG16F) || (internalformat == GL_RGB16F) || (internalformat == GL_RGBA16F); |
| |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unsupported type"); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Converts normalized unsigned fixed-point RGBA pixel representations |
| * from one resolution to another, simulating the result that one would |
| * get if glCopyTexImage2D() call was used for a single pixel, read |
| * afterward with a gl.readPixels() call. |
| * |
| * @param src_input_rgba_bits Pointer to an array storing 4 integers, representing |
| * amount of bits per channel, as used by input data, |
| * that will be fed to a GL object using gl.texImage2D() |
| * call or similar. Cannot be NULL. |
| * @param src_attachment_rgba_bits Pointer to an array storing 4 integers, representing |
| * amount of bits per channel, as used by data storage |
| * of an object attached to read buffer. Cannot be NULL. |
| * @param dst_attachment_rgba_bits Pointer to an array storing 4 integers, representing |
| * amount of bits per channel, as used by data storage |
| * of a texture object that glCopyTexImage2D() call will |
| * initialize. Cannot be NULL. |
| * @param dst_output_rgba_bits Pointer to an array storing 4 integers, representing |
| * amount of bits per channel, as requested by the user |
| * using the gl.readPixels() call. Cannot be NULL. |
| * @param src_rgba Pointer to an array storing 4 values representing |
| * RGBA channel. It is assumed the values do not exceed |
| * allowed precision, described by @param src_input_rgba_bits. |
| * Cannot be NULL. |
| * @param dst_rgba Deref will be used to store result of the conversion. |
| * Cannot be NULL. |
| * |
| * @return 1 if successful, 0 otherwise. |
| * */ |
| bool ConversionDatabase::convertNormalizedUnsignedFixedPoint(int* src_input_rgba_bits, int* src_attachment_rgba_bits, |
| int* dst_attachment_rgba_bits, int* dst_output_rgba_bits, |
| int* src_rgba, int* dst_rgba) |
| { |
| float a_f32 = 0.0f; |
| float b_f32 = 0.0f; |
| float dst_rgba_f[4] = { 0.0f }; |
| float g_f32 = 0.0f; |
| float r_f32 = 0.0f; |
| int src_rgba_intermediate[4] = { src_rgba[0], src_rgba[1], src_rgba[2], src_rgba[3] }; |
| |
| // Reduce or crank up precision before casting to floats |
| int bit_diffs_src_intermediate[] = { abs(src_input_rgba_bits[0] - src_attachment_rgba_bits[0]), |
| abs(src_input_rgba_bits[1] - src_attachment_rgba_bits[1]), |
| abs(src_input_rgba_bits[2] - src_attachment_rgba_bits[2]), |
| abs(src_input_rgba_bits[3] - src_attachment_rgba_bits[3]) }; |
| |
| for (unsigned int n = 0; n < sizeof(bit_diffs_src_intermediate) / sizeof(bit_diffs_src_intermediate[0]); ++n) |
| { |
| float tmp = ((float)src_rgba_intermediate[n]) / ((1 << src_input_rgba_bits[n]) - 1); |
| if (tmp > 1.0f) |
| tmp = 1.0f; |
| tmp *= (float)((1 << src_attachment_rgba_bits[n]) - 1); |
| src_rgba_intermediate[n] = (int)(0.5 + tmp); |
| } |
| |
| // The following equations correspond to equation 2.1 from ES spec 3.0.2 |
| r_f32 = ((float)src_rgba_intermediate[0]) / (float)((1 << src_attachment_rgba_bits[0]) - 1); |
| g_f32 = ((float)src_rgba_intermediate[1]) / (float)((1 << src_attachment_rgba_bits[1]) - 1); |
| b_f32 = ((float)src_rgba_intermediate[2]) / (float)((1 << src_attachment_rgba_bits[2]) - 1); |
| a_f32 = ((float)src_rgba_intermediate[3]) / (float)((1 << src_attachment_rgba_bits[3]) - 1); |
| |
| // Clamp to <0, 1>. Since we're dealing with unsigned ints on input, there's |
| // no way we could be lower than 0. |
| if (r_f32 > 1.0f) |
| r_f32 = 1.0f; |
| if (g_f32 > 1.0f) |
| g_f32 = 1.0f; |
| if (b_f32 > 1.0f) |
| b_f32 = 1.0f; |
| if (a_f32 > 1.0f) |
| a_f32 = 1.0f; |
| |
| // The following equations are taken from table 4.5 & equation 2.3, |
| // ES spec 3.0.2 |
| dst_rgba_f[0] = (r_f32 * (float)((1 << dst_attachment_rgba_bits[0]) - 1)); |
| dst_rgba_f[1] = (g_f32 * (float)((1 << dst_attachment_rgba_bits[1]) - 1)); |
| dst_rgba_f[2] = (b_f32 * (float)((1 << dst_attachment_rgba_bits[2]) - 1)); |
| dst_rgba_f[3] = (a_f32 * (float)((1 << dst_attachment_rgba_bits[3]) - 1)); |
| |
| // As per spec: |
| // |
| // The conversion from a floating-point value f to the corresponding |
| // unsigned normalized fixed-point value c is defined by first clamping |
| // f to the range [0,1], then computing |
| // |
| // f' = convert_float_uint(f * (2^b-1), b) [2.3] |
| // |
| // where convert_float_uint(r,b) returns one of the two unsigned binary |
| // integer values with exactly b bits which are closest to the floating-point |
| // value r (where *rounding to nearest is preferred*) |
| // |
| // C casting truncates the remainder, so if dst_rgba_f[x] is larger than or |
| // equal to 0.5, we need to take a ceiling of the value. |
| for (unsigned int n = 0; n < 4 /* channels */; ++n) |
| { |
| if (deFloatMod(dst_rgba_f[n], 1.0f) >= 0.5f) |
| dst_rgba_f[n] = deFloatCeil(dst_rgba_f[n]); |
| } |
| |
| // Expand the data or reduce its precision, depending on the type requested by the caller. |
| dst_rgba[0] = ((unsigned int)dst_rgba_f[0]); |
| dst_rgba[1] = ((unsigned int)dst_rgba_f[1]); |
| dst_rgba[2] = ((unsigned int)dst_rgba_f[2]); |
| dst_rgba[3] = ((unsigned int)dst_rgba_f[3]); |
| |
| for (unsigned int n = 0; n < 4 /* channels */; ++n) |
| { |
| float tmp = ((float)dst_rgba[n]) / ((1 << dst_attachment_rgba_bits[n]) - 1); |
| if (tmp > 1.0f) |
| tmp = 1.0f; |
| tmp *= (float)((1 << dst_output_rgba_bits[n]) - 1); |
| dst_rgba[n] = (int)(0.5 + tmp); |
| } |
| |
| return true; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_ALPHA8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getAlpha8OESPixelData(GLenum type, unsigned char alpha) |
| { |
| PixelData result; |
| |
| // Sanity checks |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| // Carry on |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.unsigned_byte_data = alpha; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.red.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.data_internalformat = GL_ALPHA8_OES; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_LUMINANCE8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param luminance Luminance value. Will get cloned to blue/green/red channels. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getLuminance8OESPixelData(GLenum type, unsigned char luminance) |
| { |
| PixelData result; |
| |
| /* Sanity checks */ |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| /* Carry on */ |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.unsigned_byte_data = 255; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = luminance; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = luminance; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = luminance; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.data_internalformat = GL_LUMINANCE8_OES; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_LUMINANCE8_ALPHA8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param luminance Luminance value. Will be cloned to blue/green/red channels. |
| * @param alpha Alpha channel value. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getLuminance8Alpha8OESPixelData(GLenum type, unsigned char luminance, unsigned char alpha) |
| { |
| PixelData result; |
| |
| /* Sanity checks */ |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| /* Carry on */ |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.unsigned_byte_data = alpha; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = luminance; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = luminance; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = luminance; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.data_internalformat = GL_LUMINANCE8_ALPHA8_OES; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R16I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_SHORT for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR16IPixelData(int is_source_pixel, GLenum type, int red) |
| { |
| PixelData result; |
| |
| /* Sanity checks */ |
| if (is_source_pixel) |
| { |
| DE_ASSERT(type == GL_SHORT); |
| } /* if (is_source_pixel) */ |
| else |
| { |
| DE_ASSERT(type == GL_INT); |
| } |
| |
| /* Carry on */ |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.red.signed_short_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| } /* if (is_source_pixel) */ |
| else |
| { |
| result.alpha.signed_integer_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| } |
| |
| result.data_internalformat = GL_R16I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R16UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_SHORT for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR16UIPixelData(int is_source_pixel, GLenum type, unsigned int red) |
| { |
| PixelData result; |
| |
| /* Sanity checks */ |
| if (is_source_pixel) |
| { |
| DE_ASSERT(type == GL_UNSIGNED_SHORT); |
| } /* if (is_source_pixels) */ |
| else |
| { |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| } |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.red.unsigned_short_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| } /* if (is_source_pixel) */ |
| else |
| { |
| result.alpha.unsigned_integer_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| } |
| |
| result.data_internalformat = GL_R16UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R32I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_INT. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR32IPixelData(int is_source_pixel, GLenum type, int red) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (!is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.red.signed_integer_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.data_internalformat = GL_R32I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R32UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_INT. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR32UIPixelData(int is_source_pixel, GLenum type, unsigned int red) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (!is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = 1; |
| } /* if (!is_source_pixel) */ |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.red.unsigned_integer_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.data_internalformat = GL_R32UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R8I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_BYTE for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR8IPixelData(int is_source_pixel, GLenum type, int red) |
| { |
| PixelData result; |
| |
| // Sanity checks |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_BYTE); |
| else |
| DE_ASSERT(type == GL_INT); |
| |
| // Carry on |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.red.signed_byte_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_R8I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R8UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_BYTE for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR8UIPixelData(int is_source_pixel, GLenum type, unsigned int red) |
| { |
| PixelData result; |
| |
| /* Sanity checks */ |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.red.unsigned_byte_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = 1; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_R8UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must beGL_UNSIGNED_BYTE. |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR8PixelData(int is_source_pixel, GLenum type, unsigned char red) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = 255; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.red.unsigned_byte_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.data_internalformat = GL_R8; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG16I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_SHORT for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG16IPixelData(int is_source_pixel, GLenum type, int red, int green) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| { |
| DE_ASSERT(type == GL_SHORT); |
| } |
| else |
| { |
| DE_ASSERT(type == GL_INT); |
| } |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.signed_short_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.red.signed_short_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RG16I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG16UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_SHORT for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG16UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_SHORT); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.signed_short_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.red.signed_short_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = 1; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RG16UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG32I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_INT. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG32IPixelData(int is_source_pixel, GLenum type, int red, int green) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.signed_integer_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.data_internalformat = GL_RG32I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG32UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_INT. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG32UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = 1; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.unsigned_integer_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.data_internalformat = GL_RG32UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG8I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_BYTE for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG8IPixelData(int is_source_pixel, GLenum type, int red, int green) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_BYTE); |
| else |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.signed_byte_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.red.signed_byte_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| } /* if (is_source_pixel) */ |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RG8I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB8UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_BYTE for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG8UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.unsigned_byte_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = 1; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RG8UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG8PixelData(int is_source_pixel, GLenum type, unsigned char red, unsigned char green) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = 255; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.green.unsigned_byte_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.data_internalformat = GL_RG8; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB10_A2 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_INT_2_10_10_10_REV. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB10A2PixelData(GLenum type, unsigned short red, unsigned short green, |
| unsigned short blue, unsigned char alpha) |
| { |
| PixelData result; |
| |
| DE_ASSERT(red <= 1023); |
| DE_ASSERT(green <= 1023); |
| DE_ASSERT(blue <= 1023); |
| DE_ASSERT(alpha <= 3); |
| |
| DE_ASSERT(type == GL_UNSIGNED_INT_2_10_10_10_REV); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.unsigned_byte_data = alpha; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS; |
| result.blue.unsigned_short_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.green.unsigned_short_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.red.unsigned_short_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.data_internalformat = GL_RGB10_A2; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB10A2UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_INT_2_10_10_10_REV for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB10A2UIPixelData(int is_source_pixel, GLenum type, unsigned int red, |
| unsigned int green, unsigned int blue, unsigned int alpha) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_INT_2_10_10_10_REV); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.unsigned_byte_data = alpha; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS; |
| result.blue.unsigned_short_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.green.unsigned_short_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.red.unsigned_short_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| } |
| else |
| { |
| result.alpha.unsigned_integer_data = alpha; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.blue.unsigned_integer_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| } |
| |
| result.data_internalformat = GL_RGB10_A2UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB16I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_SHORT for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB16IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_SHORT); |
| else |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.blue.signed_short_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.green.signed_short_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.red.signed_short_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.blue.signed_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGB16I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB16UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_SHORT for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB16UIPixelData(int is_source_pixel, GLenum type, unsigned int red, |
| unsigned int green, unsigned int blue) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_SHORT); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.blue.unsigned_short_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.green.unsigned_short_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.red.unsigned_short_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.alpha.unsigned_integer_data = 1; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.blue.unsigned_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGB16UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB32I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_INT. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB32IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.blue.signed_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| result.data_internalformat = GL_RGB32I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB32UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_INT. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB32UIPixelData(int is_source_pixel, GLenum type, unsigned int red, |
| unsigned int green, unsigned int blue) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = 1; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.blue.unsigned_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| result.data_internalformat = GL_RGB32UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB5A1 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT_5_5_5_1 or |
| * GL_UNSIGNED_INT_2_10_10_10_REV for source pixels. |
| * 2) GL_UNSIGNED_BYTE for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB5A1PixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue, unsigned int alpha) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| { |
| DE_ASSERT(type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_SHORT_5_5_5_1 || |
| type == GL_UNSIGNED_INT_2_10_10_10_REV); |
| } |
| else |
| { |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| } |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| switch (type) |
| { |
| case GL_UNSIGNED_BYTE: |
| { |
| DE_ASSERT(red <= 255); |
| DE_ASSERT(green <= 255); |
| DE_ASSERT(blue <= 255); |
| DE_ASSERT(alpha <= 255); |
| |
| // Fill the channel data structures |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| |
| break; |
| } |
| |
| case GL_UNSIGNED_SHORT_5_5_5_1: |
| { |
| DE_ASSERT(red <= 31); |
| DE_ASSERT(green <= 31); |
| DE_ASSERT(blue <= 31); |
| DE_ASSERT(alpha == 0 || alpha == 1); |
| |
| // Fill the channel data structures |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_1BIT; |
| result.alpha.unsigned_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_5BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_5BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_5BITS; |
| result.red.unsigned_byte_data = red; |
| |
| break; |
| } |
| |
| case GL_UNSIGNED_INT_2_10_10_10_REV: |
| { |
| // Sanity checks |
| DE_ASSERT(red <= 1023); |
| DE_ASSERT(green <= 1023); |
| DE_ASSERT(blue <= 1023); |
| DE_ASSERT(alpha <= 3); |
| |
| // Fill the channel data structures |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS; |
| result.alpha.unsigned_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.blue.unsigned_short_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.green.unsigned_short_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| result.red.unsigned_short_data = red; |
| |
| break; |
| } |
| } |
| |
| result.data_internalformat = GL_RGB5_A1; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB565 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT_5_6_5 for source pixels. |
| * 2) GL_UNSIGNED_BYTE for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB565PixelData(int is_source_pixel, GLenum type, int red, int green, int blue) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_SHORT_5_6_5); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| switch (type) |
| { |
| case GL_UNSIGNED_BYTE: |
| { |
| // Fill the channel data structures |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| |
| break; |
| } |
| |
| case GL_UNSIGNED_SHORT_5_6_5: |
| { |
| DE_ASSERT(red >= 0 && red <= 31); |
| DE_ASSERT(green >= 0 && green <= 63); |
| DE_ASSERT(blue >= 0 && blue <= 31); |
| |
| // Fill the channel data structures |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_5BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_6BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_5BITS; |
| result.red.unsigned_byte_data = red; |
| |
| break; |
| } |
| } |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = 255; |
| } |
| |
| result.data_internalformat = GL_RGB565; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB8PixelData(int is_source_pixel, GLenum type, unsigned char red, unsigned char green, |
| unsigned char blue) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = 255; |
| } |
| |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| result.data_internalformat = GL_RGB8; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB8I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_BYTE for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB8IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_BYTE); |
| else |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.blue.signed_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.green.signed_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.red.signed_byte_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = 1; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.blue.signed_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGB8I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB8UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_BYTE for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB8UIPixelData(int is_source_pixel, GLenum type, unsigned int red, unsigned int green, |
| unsigned int blue) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = 1; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.blue.unsigned_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGB8UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA16I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_SHORT for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA16IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue, |
| int alpha) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_SHORT); |
| else |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.alpha.signed_short_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.blue.signed_short_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.green.signed_short_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS; |
| result.red.signed_short_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.blue.signed_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGBA16I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA16UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_SHORT for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA16UIPixelData(int is_source_pixel, GLenum type, unsigned int red, |
| unsigned int green, unsigned int blue, unsigned int alpha) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_SHORT); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.alpha.unsigned_short_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.blue.unsigned_short_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.green.unsigned_short_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS; |
| result.red.unsigned_short_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.blue.unsigned_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGBA16UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA32I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_INT. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA32IPixelData(GLenum type, int red, int green, int blue, int alpha) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.blue.signed_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| result.data_internalformat = GL_RGBA32I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA32UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_INT. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA32UIPixelData(GLenum type, unsigned int red, unsigned int green, unsigned int blue, |
| unsigned int alpha) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.blue.unsigned_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| result.data_internalformat = GL_RGBA32UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA8I internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_BYTE for source pixels. |
| * 2) GL_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA8IPixelData(int is_source_pixel, GLenum type, int red, int green, int blue, |
| int alpha) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_BYTE); |
| else |
| DE_ASSERT(type == GL_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.alpha.signed_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.blue.signed_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.green.signed_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS; |
| result.red.signed_byte_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.alpha.signed_integer_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.blue.signed_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.green.signed_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| result.red.signed_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGBA8I; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA8UI internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_BYTE for source pixels. |
| * 2) GL_UNSIGNED_INT for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA8UIPixelData(int is_source_pixel, GLenum type, unsigned int red, |
| unsigned int green, unsigned int blue, unsigned int alpha) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_INT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.alpha.unsigned_integer_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.blue.unsigned_integer_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.green.unsigned_integer_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| result.red.unsigned_integer_data = red; |
| } |
| |
| result.data_internalformat = GL_RGBA8UI; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA4 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be: |
| * 1) GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT_4_4_4_4 for source pixels. |
| * 2) GL_UNSIGNED_BYTE for destination pixels. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA4PixelData(int is_source_pixel, GLenum type, unsigned char red, |
| unsigned char green, unsigned char blue, unsigned char alpha) |
| { |
| PixelData result; |
| |
| if (is_source_pixel) |
| DE_ASSERT(type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_SHORT_4_4_4_4); |
| else |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| switch (type) |
| { |
| case GL_UNSIGNED_BYTE: |
| { |
| // Fill the channel data structures |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| |
| break; |
| } |
| |
| case GL_UNSIGNED_SHORT_4_4_4_4: |
| { |
| DE_ASSERT(red <= 15); |
| DE_ASSERT(green <= 15); |
| DE_ASSERT(blue <= 15); |
| DE_ASSERT(alpha <= 15); |
| |
| // Fill the channel data structures |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_4BITS; |
| result.alpha.unsigned_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_4BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_4BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_4BITS; |
| result.red.unsigned_byte_data = red; |
| |
| break; |
| } |
| } |
| |
| result.data_internalformat = GL_RGBA4; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA8PixelData(GLenum type, unsigned char red, unsigned char green, unsigned char blue, |
| unsigned char alpha) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_UNSIGNED_BYTE); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = alpha; |
| result.blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.blue.unsigned_byte_data = blue; |
| result.green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.green.unsigned_byte_data = green; |
| result.red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.red.unsigned_byte_data = red; |
| result.data_internalformat = GL_RGBA8; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_SRGB8_ALPHA8 internal format. |
| * |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getSRGB8Alpha8PixelData(GLenum type, unsigned char red, unsigned char green, |
| unsigned char blue, unsigned char alpha) |
| { |
| PixelData result = getRGBA8PixelData(type, red, green, blue, alpha); |
| |
| result.data_internalformat = GL_SRGB8_ALPHA8; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_SRGB8 internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_UNSIGNED_BYTE. |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getSRGB8PixelData(int is_source_pixel, GLenum type, unsigned char red, |
| unsigned char green, unsigned char blue) |
| { |
| PixelData result = getSRGB8Alpha8PixelData(type, red, green, blue, 0); |
| |
| if (is_source_pixel) |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_NONE; |
| result.alpha.unsigned_byte_data = 0; |
| } |
| else |
| { |
| result.alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| result.alpha.unsigned_byte_data = 255; |
| } |
| |
| result.data_internalformat = GL_SRGB8; |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R16F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_HALF_FLOAT |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR16FPixelData(int is_source_pixel, GLenum type, float red) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_HALF_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| else |
| { |
| result.alpha.float_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| |
| result.data_internalformat = GL_R16F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_R32F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_FLOAT |
| * @param red Value for red channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getR32FPixelData(int is_source_pixel, GLenum type, float red) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| else |
| { |
| result.alpha.float_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| |
| result.data_internalformat = GL_R32F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG16F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_HALF_FLOAT |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG16FPixelData(int is_source_pixel, GLenum type, float red, float green) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_HALF_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| else |
| { |
| result.alpha.float_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| |
| result.data_internalformat = GL_RG16F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RG32F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_FLOAT |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRG32FPixelData(int is_source_pixel, GLenum type, float red, float green) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| else |
| { |
| result.alpha.float_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| |
| result.data_internalformat = GL_RG32F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB16F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_HALF_FLOAT |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for green channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB16FPixelData(int is_source_pixel, GLenum type, float red, float green, float blue) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_HALF_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.blue.float_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| else |
| { |
| result.alpha.float_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.blue.float_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| |
| result.data_internalformat = GL_RGB16F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGB32F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_FLOAT |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGB32FPixelData(int is_source_pixel, GLenum type, float red, float green, float blue) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| if (is_source_pixel) |
| { |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.blue.float_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| else |
| { |
| result.alpha.float_data = 1; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.blue.float_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| } |
| |
| result.data_internalformat = GL_RGB32F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA16F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_HALF_FLOAT |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA16FPixelData(GLenum type, float red, float green, float blue, float alpha) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_HALF_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.float_data = alpha; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.blue.float_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| |
| result.data_internalformat = GL_RGBA16F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Retrieves a PixelData instance describing a single pixel stored in |
| * GL_RGBA32F internal format. |
| * |
| * @param is_source_pixel 1 if the pixel is going to be used as conversion source, |
| * 0 otherwise. |
| * @param type GLES type the pixel uses. Must be GL_FLOAT |
| * @param red Value for red channel. |
| * @param green Value for green channel. |
| * @param blue Value for blue channel. |
| * @param alpha Value for alpha channel. |
| * |
| * @return Filled PixelData instance. |
| **/ |
| PixelData ConversionDatabase::getRGBA32FPixelData(GLenum type, float red, float green, float blue, float alpha) |
| { |
| PixelData result; |
| |
| DE_ASSERT(type == GL_FLOAT); |
| |
| deMemset(&result, 0, sizeof(result)); |
| |
| result.alpha.float_data = alpha; |
| result.alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.red.float_data = red; |
| result.red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.green.float_data = green; |
| result.green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| result.blue.float_data = blue; |
| result.blue.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| |
| result.data_internalformat = GL_RGBA32F; |
| result.data_type = type; |
| |
| return result; |
| } |
| |
| /** Adds a new conversion rule to a conversion database. |
| * |
| * Destination pixel datasets can only use one of the following types: |
| * |
| * GL_UNSIGNED_BYTE (for fixed-point source types); |
| * GL_INT (for signed integer types); |
| * GL_UNSIGNED_INT (for unsigned integer types); |
| * GL_UNSIGNED_INT_2_10_10_10_REV (for GL_RGB10_A2 type ONLY) |
| * |
| * The type used for destination storage configures arguments that |
| * will be passed to a gl.readPixels() call in verification stage IF |
| * source internalformat is color-renderable. If not, destination type |
| * determines how result & reference data should be compared using |
| * a special program object. |
| * |
| * It is illegal to: |
| * |
| * 1) add more than one conversion rule that uses the same source+destination |
| * internalformat+type combination. |
| * 2) use source pixels of different internalformats or types; |
| * 3) use destination pixels of different internalformats or types; |
| * 4) use pixel data instances using invalid internalformat or types. |
| * |
| * @param src_topleft Pixel-data instance describing source top-left corner. |
| * @param dst_topleft Pixel-data instance describing destination top-left corner. |
| * @param src_topright Pixel-data instance describing source top-right corner. |
| * @param dst_topright Pixel-data instance describing destination top-right corner. |
| * @param src_bottomleft Pixel-data instance describing source bottom-left corner. |
| * @param dst_bottomleft Pixel-data instance describing destination bottom-left corner. |
| * @param src_bottomright Pixel-data instance describing source bottom-right corner. |
| * @param dst_bottomright Pixel-data instance describing destination bottom-right corner. |
| **/ |
| void ConversionDatabase::addEntryToConversionDatabase(PixelData src_topleft, PixelData dst_topleft, |
| PixelData src_topright, PixelData dst_topright, |
| PixelData src_bottomleft, PixelData dst_bottomleft, |
| PixelData src_bottomright, PixelData dst_bottomright, |
| PixelCompareChannel channels_to_compare) |
| { |
| GLenum dst_internalformat = GL_NONE; |
| GLenum dst_type = GL_NONE; |
| int is_dst_internalformat_valid = 0; |
| int is_dst_type_valid = 0; |
| GLenum src_internalformat = GL_NONE; |
| GLenum src_type = GL_NONE; |
| |
| // Sanity checks: general |
| DE_ASSERT(src_topleft.data_internalformat != GL_NONE); |
| DE_ASSERT(dst_topleft.data_internalformat != GL_NONE); |
| |
| if (src_topleft.data_internalformat == GL_NONE || dst_topleft.data_internalformat == GL_NONE) |
| return; // if (source / destination internalformats are GL_NONE) |
| |
| DE_ASSERT(src_topleft.data_internalformat == src_topright.data_internalformat); |
| DE_ASSERT(src_topleft.data_internalformat == src_bottomleft.data_internalformat); |
| DE_ASSERT(src_topleft.data_internalformat == src_bottomright.data_internalformat); |
| DE_ASSERT(src_topleft.data_type == src_topright.data_type); |
| DE_ASSERT(src_topleft.data_type == src_bottomleft.data_type); |
| DE_ASSERT(src_topleft.data_type == src_bottomright.data_type); |
| |
| if (src_topleft.data_internalformat != src_topright.data_internalformat || |
| src_topleft.data_internalformat != src_bottomleft.data_internalformat || |
| src_topleft.data_internalformat != src_bottomright.data_internalformat || |
| src_topleft.data_type != src_topright.data_type || src_topleft.data_type != src_bottomleft.data_type || |
| src_topleft.data_type != src_bottomright.data_type) |
| { |
| return; |
| } // if (source pixels' internalformats and/or types are not the same values) |
| |
| DE_ASSERT(dst_topleft.data_internalformat == dst_topright.data_internalformat); |
| DE_ASSERT(dst_topleft.data_internalformat == dst_bottomleft.data_internalformat); |
| DE_ASSERT(dst_topleft.data_internalformat == dst_bottomright.data_internalformat); |
| DE_ASSERT(dst_topleft.data_type == dst_topright.data_type); |
| DE_ASSERT(dst_topleft.data_type == dst_bottomleft.data_type); |
| DE_ASSERT(dst_topleft.data_type == dst_bottomright.data_type); |
| |
| if (dst_topleft.data_internalformat != dst_topright.data_internalformat || |
| dst_topleft.data_internalformat != dst_bottomleft.data_internalformat || |
| dst_topleft.data_internalformat != dst_bottomright.data_internalformat || |
| dst_topleft.data_type != dst_topright.data_type || dst_topleft.data_type != dst_bottomleft.data_type || |
| dst_topleft.data_type != dst_bottomright.data_type) |
| { |
| return; |
| } // if (destination pixels' internalformats and/or types are not the same values) |
| |
| src_internalformat = src_topleft.data_internalformat; |
| src_type = src_topleft.data_type; |
| dst_internalformat = dst_topleft.data_internalformat; |
| dst_type = dst_topleft.data_type; |
| |
| // Sanity checks: format used for destination storage |
| is_dst_type_valid = isTypeSupportedByGLReadPixels(dst_type); |
| is_dst_internalformat_valid = isInternalFormatCompatibleWithType(dst_type, dst_internalformat); |
| |
| DE_ASSERT(is_dst_type_valid && is_dst_internalformat_valid); |
| if (!is_dst_type_valid || !is_dst_internalformat_valid) |
| TCU_FAIL("Requested destination type or internalformat is not compatible with validation requirements."); |
| |
| // Sanity checks: make sure the conversion has not been already added |
| for (unsigned int n = 0; n < n_entries_added; ++n) |
| { |
| ConversionDatabaseEntry& entry_ptr = entries[n]; |
| |
| GLenum iterated_dst_internalformat = entry_ptr.dst_topleft_corner.data_internalformat; |
| GLenum iterated_dst_type = entry_ptr.dst_topleft_corner.data_type; |
| GLenum iterated_src_internalformat = entry_ptr.src_topleft_corner.data_internalformat; |
| GLenum iterated_src_type = entry_ptr.src_topleft_corner.data_type; |
| int is_new_rule = src_internalformat != iterated_src_internalformat || |
| ((src_internalformat == iterated_src_internalformat) && (src_type != iterated_src_type)) || |
| ((src_internalformat == iterated_src_internalformat) && (src_type == iterated_src_type) && |
| (dst_internalformat != iterated_dst_internalformat)) || |
| ((src_internalformat == iterated_src_internalformat) && (src_type == iterated_src_type) && |
| (dst_internalformat == iterated_dst_internalformat) && (dst_type != iterated_dst_type)); |
| |
| DE_ASSERT(is_new_rule); |
| if (!is_new_rule) |
| TCU_FAIL("This conversion rule already exists!"); |
| } |
| |
| // Make sure there's enough space to hold a new entry |
| if ((n_entries_added + 1) >= n_entries_allocated) |
| { |
| // Realloc is needed |
| n_entries_allocated <<= 1; |
| entries.resize(n_entries_allocated); |
| if (entries.empty()) |
| TCU_FAIL("Out of memory while reallocating conversion database"); |
| } |
| |
| // Add the new entry |
| ConversionDatabaseEntry& entry_ptr = entries[n_entries_added]; |
| entry_ptr.dst_bottomleft_corner = dst_bottomleft; |
| entry_ptr.dst_bottomright_corner = dst_bottomright; |
| entry_ptr.dst_topleft_corner = dst_topleft; |
| entry_ptr.dst_topright_corner = dst_topright; |
| entry_ptr.src_bottomleft_corner = src_bottomleft; |
| entry_ptr.src_bottomright_corner = src_bottomright; |
| entry_ptr.src_topleft_corner = src_topleft; |
| entry_ptr.src_topright_corner = src_topright; |
| entry_ptr.channels_to_compare = channels_to_compare; |
| |
| ++n_entries_added; |
| } |
| |
| /** Adds all known conversion rules to a conversion database passed by argument. |
| * |
| * A conversion database stores exactly one conversion rule for each valid combination |
| * of source+destination internal-formats (with an exception that for each internalformat |
| * data may be represented with many different types!). |
| * These rules are then used by copy_tex_image_conversions_required conformance test to |
| * validate successfully executed conversions. |
| * |
| * A quick reminder: |
| * |
| * Source dataset corresponds to 2x2 image (using up to 4 channels) that the attachment bound to |
| * read buffer will use prior to glCopyTexImage2D() call. This image is defined by 4 Get*PixelData() |
| * calls with the first argument set to 1. |
| * Destination dataset corresponds to 2x2 image (using up to 4 channels) that the result texture |
| * object should match (within acceptable epsilon). This image is defined by 4 Get*PixelData() calls |
| * with the first argument set to 0. |
| * |
| * Source datasets are allowed to use any internalformat+type combination that is considered supported |
| * by GLES implementation. |
| * Destination datasets are only allowed to use specific types - please see AddEntryToConversionDatabase() |
| * doxygen for more details. |
| * |
| * @param database Conversion database handle. |
| **/ |
| void ConversionDatabase::configureConversionDatabase() |
| { |
| int bits_1010102[4] = { 10, 10, 10, 2 }; |
| int bits_4444[4] = { 4, 4, 4, 4 }; |
| int bits_5551[4] = { 5, 5, 5, 1 }; |
| int bits_565[4] = { 5, 6, 5, 0 }; |
| int bits_888[4] = { 8, 8, 8, 0 }; |
| int bits_8888[4] = { 8, 8, 8, 8 }; |
| |
| /* GL_R8 */ |
| { |
| const unsigned char texel1[1] = { 255 }; |
| const unsigned char texel2[1] = { 127 }; |
| const unsigned char texel3[1] = { 63 }; |
| const unsigned char texel4[1] = { 0 }; |
| |
| /* GL_R8 => GL_LUMINANCE8_OES */ |
| addEntryToConversionDatabase( |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel1[0]), getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel1[0]), |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel2[0]), getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel2[0]), |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel3[0]), getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel3[0]), |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel4[0]), getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_R8 => GL_R8 */ |
| addEntryToConversionDatabase( |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel1[0]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel1[0]), |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel2[0]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel2[0]), |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel3[0]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel3[0]), |
| getR8PixelData(1, GL_UNSIGNED_BYTE, texel4[0]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_RG8 */ |
| { |
| const unsigned char texel1[2] = { 255, 127 }; |
| const unsigned char texel2[2] = { 127, 63 }; |
| const unsigned char texel3[2] = { 63, 0 }; |
| const unsigned char texel4[2] = { 0, 255 }; |
| |
| /* GL_RG8 => GL_LUMINANCE8_OES */ |
| addEntryToConversionDatabase(getRG8PixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel1[0]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel2[0]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel3[0]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG8 => GL_R8 */ |
| addEntryToConversionDatabase( |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel1[0]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel2[0]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel3[0]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), getR8PixelData(0, GL_UNSIGNED_BYTE, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG8 => GL_RG8 */ |
| addEntryToConversionDatabase(getRG8PixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), |
| getRG8PixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RGB8 */ |
| { |
| const unsigned char texel1[3] = { 255, 127, 63 }; |
| const unsigned char texel2[3] = { 127, 63, 0 }; |
| const unsigned char texel3[3] = { 63, 0, 255 }; |
| const unsigned char texel4[3] = { 0, 255, 127 }; |
| |
| /* GL_RGB8 => GL_RGB8 */ |
| addEntryToConversionDatabase(getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGB8 => GL_LUMINANCE8_OES */ |
| addEntryToConversionDatabase(getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel1[0]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel2[0]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel3[0]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGB8 => GL_R8 */ |
| addEntryToConversionDatabase(getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel1[0]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel2[0]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel3[0]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGB8 => GL_RG8 */ |
| addEntryToConversionDatabase(getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), |
| getRGB8PixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| { /* GL_RGB565 */ |
| int texel565_1[4] = { 31, 63, 21, 0 }; |
| int texel565_2[4] = { 21, 43, 11, 0 }; |
| int texel565_3[4] = { 11, 23, 1, 0 }; |
| int texel888_1[4] = { 255, 155, 55, 0 }; |
| int texel888_2[4] = { 176, 76, 36, 0 }; |
| int texel888_3[4] = { 88, 66, 44, 0 }; |
| int texel888_4[4] = { 20, 10, 0, 0 }; |
| |
| int temp_565_to_888_bl[4] = { 0 }; |
| int temp_565_to_888_tl[4] = { 0 }; |
| int temp_565_to_888_tr[4] = { 0 }; |
| int temp_888_through_565_to_888_bl[4] = { 0 }; |
| int temp_888_through_565_to_888_br[4] = { 0 }; |
| int temp_888_through_565_to_888_tl[4] = { 0 }; |
| int temp_888_through_565_to_888_tr[4] = { 0 }; |
| |
| convertNormalizedUnsignedFixedPoint(bits_565, bits_888, bits_888, bits_888, texel565_1, temp_565_to_888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_565, bits_888, bits_888, bits_888, texel565_2, temp_565_to_888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_565, bits_888, bits_888, bits_888, texel565_3, temp_565_to_888_bl); |
| |
| convertNormalizedUnsignedFixedPoint(bits_888, bits_565, bits_888, bits_888, texel888_1, |
| temp_888_through_565_to_888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_888, bits_565, bits_888, bits_888, texel888_2, |
| temp_888_through_565_to_888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_888, bits_565, bits_888, bits_888, texel888_3, |
| temp_888_through_565_to_888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_888, bits_565, bits_888, bits_888, texel888_4, |
| temp_888_through_565_to_888_br); |
| |
| /* GL_RGB565 => GL_RGB565 */ |
| addEntryToConversionDatabase( |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, texel565_1[0], texel565_1[1], texel565_1[2]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_565_to_888_tl[0], temp_565_to_888_tl[1], |
| temp_565_to_888_tl[2]), |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, texel565_2[0], texel565_2[1], texel565_2[2]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_565_to_888_tr[0], temp_565_to_888_tr[1], |
| temp_565_to_888_tr[2]), |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, texel565_3[0], texel565_3[1], texel565_3[2]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_565_to_888_bl[0], temp_565_to_888_bl[1], |
| temp_565_to_888_bl[2]), |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, 0, 0, 0), getRGB565PixelData(0, GL_UNSIGNED_BYTE, 0, 0, 0), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| addEntryToConversionDatabase( |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_1[0], texel888_1[1], texel888_1[2]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_888_through_565_to_888_tl[0], |
| temp_888_through_565_to_888_tl[1], temp_888_through_565_to_888_tl[2]), |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_2[0], texel888_2[1], texel888_2[2]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_888_through_565_to_888_tr[0], |
| temp_888_through_565_to_888_tr[1], temp_888_through_565_to_888_tr[2]), |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_3[0], texel888_3[1], texel888_3[2]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_888_through_565_to_888_bl[0], |
| temp_888_through_565_to_888_bl[1], temp_888_through_565_to_888_bl[2]), |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_4[0], texel888_4[1], texel888_4[2]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_888_through_565_to_888_br[0], |
| temp_888_through_565_to_888_br[1], temp_888_through_565_to_888_br[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGB565 => GL_LUMINANCE8_OES */ |
| addEntryToConversionDatabase( |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, texel565_1[0], texel565_1[1], texel565_1[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_565_to_888_tl[0]), |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, texel565_2[0], texel565_2[1], texel565_2[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_565_to_888_tr[0]), |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, texel565_3[0], texel565_3[1], texel565_3[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_565_to_888_bl[0]), |
| getRGB565PixelData(1, GL_UNSIGNED_SHORT_5_6_5, 0, 0, 0), getLuminance8OESPixelData(GL_UNSIGNED_BYTE, 0), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| addEntryToConversionDatabase( |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_1[0], texel888_1[1], texel888_1[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_888_through_565_to_888_tl[0]), |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_2[0], texel888_2[1], texel888_2[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_888_through_565_to_888_tr[0]), |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_3[0], texel888_3[1], texel888_3[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_888_through_565_to_888_bl[0]), |
| getRGB565PixelData(1, GL_UNSIGNED_BYTE, texel888_4[0], texel888_4[1], texel888_4[2]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_888_through_565_to_888_br[0]), PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_RGBA4 */ |
| { |
| int texel4444_1[4] = { 15, 9, 4, 0 }; |
| int texel4444_2[4] = { 9, 4, 0, 15 }; |
| int texel4444_3[4] = { 4, 0, 15, 9 }; |
| int texel4444_4[4] = { 0, 15, 9, 4 }; |
| int texel8888_1[4] = { 255, 159, 79, 0 }; |
| int texel8888_2[4] = { 159, 79, 0, 255 }; |
| int texel8888_3[4] = { 79, 0, 255, 159 }; |
| int texel8888_4[4] = { 0, 255, 159, 79 }; |
| |
| int temp_4444_to_565_8888_tl[4] = { 0 }; |
| int temp_4444_to_565_8888_tr[4] = { 0 }; |
| int temp_4444_to_565_8888_bl[4] = { 0 }; |
| int temp_4444_to_565_8888_br[4] = { 0 }; |
| int temp_4444_to_8888_tl[4] = { 0 }; |
| int temp_4444_to_8888_tr[4] = { 0 }; |
| int temp_4444_to_8888_bl[4] = { 0 }; |
| int temp_4444_to_8888_br[4] = { 0 }; |
| int temp_8888_through_4444_to_565_tl[4] = { 0 }; |
| int temp_8888_through_4444_to_565_tr[4] = { 0 }; |
| int temp_8888_through_4444_to_565_bl[4] = { 0 }; |
| int temp_8888_through_4444_to_565_br[4] = { 0 }; |
| int temp_8888_through_4444_to_8888_tl[4] = { 0 }; |
| int temp_8888_through_4444_to_8888_tr[4] = { 0 }; |
| int temp_8888_through_4444_to_8888_bl[4] = { 0 }; |
| int temp_8888_through_4444_to_8888_br[4] = { 0 }; |
| int temp_8888_through_4444_565_to_8888_tl[4] = { 0 }; |
| int temp_8888_through_4444_565_to_8888_tr[4] = { 0 }; |
| int temp_8888_through_4444_565_to_8888_bl[4] = { 0 }; |
| int temp_8888_through_4444_565_to_8888_br[4] = { 0 }; |
| |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_565, bits_8888, bits_8888, texel4444_1, |
| temp_4444_to_565_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_565, bits_8888, bits_8888, texel4444_2, |
| temp_4444_to_565_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_565, bits_8888, bits_8888, texel4444_3, |
| temp_4444_to_565_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_565, bits_8888, bits_8888, texel4444_4, |
| temp_4444_to_565_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_8888, bits_8888, bits_8888, texel4444_1, |
| temp_4444_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_8888, bits_8888, bits_8888, texel4444_2, |
| temp_4444_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_8888, bits_8888, bits_8888, texel4444_3, |
| temp_4444_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_4444, bits_8888, bits_8888, bits_8888, texel4444_4, |
| temp_4444_to_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_565, texel8888_1, |
| temp_8888_through_4444_to_565_tl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_565, texel8888_2, |
| temp_8888_through_4444_to_565_tr); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_565, texel8888_3, |
| temp_8888_through_4444_to_565_bl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_565, texel8888_4, |
| temp_8888_through_4444_to_565_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_8888, bits_8888, texel8888_1, |
| temp_8888_through_4444_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_8888, bits_8888, texel8888_2, |
| temp_8888_through_4444_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_8888, bits_8888, texel8888_3, |
| temp_8888_through_4444_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_8888, bits_8888, texel8888_4, |
| temp_8888_through_4444_to_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_8888, texel8888_1, |
| temp_8888_through_4444_565_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_8888, texel8888_2, |
| temp_8888_through_4444_565_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_8888, texel8888_3, |
| temp_8888_through_4444_565_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_4444, bits_565, bits_8888, texel8888_4, |
| temp_8888_through_4444_565_to_8888_br); |
| |
| /* GL_RGBA4 => GL_RGBA4 */ |
| addEntryToConversionDatabase( |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_1[0], texel4444_1[1], texel4444_1[2], |
| texel4444_1[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_8888_tl[0], temp_4444_to_8888_tl[1], |
| temp_4444_to_8888_tl[2], temp_4444_to_8888_tl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_2[0], texel4444_2[1], texel4444_2[2], |
| texel4444_2[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_8888_tr[0], temp_4444_to_8888_tr[1], |
| temp_4444_to_8888_tr[2], temp_4444_to_8888_tr[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_3[0], texel4444_3[1], texel4444_3[2], |
| texel4444_3[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_8888_bl[0], temp_4444_to_8888_bl[1], |
| temp_4444_to_8888_bl[2], temp_4444_to_8888_bl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_4[0], texel4444_4[1], texel4444_4[2], |
| texel4444_4[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_8888_br[0], temp_4444_to_8888_br[1], |
| temp_4444_to_8888_br[2], temp_4444_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| |
| addEntryToConversionDatabase( |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_1[0], texel8888_1[1], texel8888_1[2], texel8888_1[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tl[0], |
| temp_8888_through_4444_to_8888_tl[1], temp_8888_through_4444_to_8888_tl[2], |
| temp_8888_through_4444_to_8888_tl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_2[0], texel8888_2[1], texel8888_2[2], texel8888_2[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tr[0], |
| temp_8888_through_4444_to_8888_tr[1], temp_8888_through_4444_to_8888_tr[2], |
| temp_8888_through_4444_to_8888_tr[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_3[0], texel8888_3[1], texel8888_3[2], texel8888_3[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_bl[0], |
| temp_8888_through_4444_to_8888_bl[1], temp_8888_through_4444_to_8888_bl[2], |
| temp_8888_through_4444_to_8888_bl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_4[0], texel8888_4[1], texel8888_4[2], texel8888_4[3]), |
| getRGBA4PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_br[0], |
| temp_8888_through_4444_to_8888_br[1], temp_8888_through_4444_to_8888_br[2], |
| temp_8888_through_4444_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| |
| /* GL_RGBA4 => GL_RGB565 */ |
| addEntryToConversionDatabase(getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_1[0], texel4444_1[1], |
| texel4444_1[2], texel4444_1[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_565_8888_tl[0], |
| temp_4444_to_565_8888_tl[1], temp_4444_to_565_8888_tl[2]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_2[0], texel4444_2[1], |
| texel4444_2[2], texel4444_2[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_565_8888_tr[0], |
| temp_4444_to_565_8888_tr[1], temp_4444_to_565_8888_tr[2]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_3[0], texel4444_3[1], |
| texel4444_3[2], texel4444_3[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_565_8888_bl[0], |
| temp_4444_to_565_8888_bl[1], temp_4444_to_565_8888_bl[2]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_4[0], texel4444_4[1], |
| texel4444_4[2], texel4444_4[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_4444_to_565_8888_br[0], |
| temp_4444_to_565_8888_br[1], temp_4444_to_565_8888_br[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| addEntryToConversionDatabase( |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_1[0], texel8888_1[1], texel8888_1[2], texel8888_1[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_565_to_8888_tl[0], |
| temp_8888_through_4444_565_to_8888_tl[1], temp_8888_through_4444_565_to_8888_tl[2]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_2[0], texel8888_2[1], texel8888_2[2], texel8888_2[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_565_to_8888_tr[0], |
| temp_8888_through_4444_565_to_8888_tr[1], temp_8888_through_4444_565_to_8888_tr[2]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_3[0], texel8888_3[1], texel8888_3[2], texel8888_3[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_565_to_8888_bl[0], |
| temp_8888_through_4444_565_to_8888_bl[1], temp_8888_through_4444_565_to_8888_bl[2]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel8888_4[0], texel8888_4[1], texel8888_4[2], texel8888_4[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_4444_565_to_8888_br[0], |
| temp_8888_through_4444_565_to_8888_br[1], temp_8888_through_4444_565_to_8888_br[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA4 => GL_LUMINANCE8_ALPHA8_OES */ |
| addEntryToConversionDatabase( |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_1[0], texel4444_1[1], texel4444_1[2], |
| texel4444_1[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_tl[0], temp_4444_to_8888_tl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_2[0], texel4444_2[1], texel4444_2[2], |
| texel4444_2[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_tr[0], temp_4444_to_8888_tr[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_3[0], texel4444_3[1], texel4444_3[2], |
| texel4444_3[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_bl[0], temp_4444_to_8888_bl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_4[0], texel4444_4[1], texel4444_4[2], |
| texel4444_4[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_br[0], temp_4444_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RA); |
| |
| addEntryToConversionDatabase( |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_1[0], texel4444_1[1], texel4444_1[2], texel4444_1[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tl[0], |
| temp_8888_through_4444_to_8888_tl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_2[0], texel4444_2[1], texel4444_2[2], texel4444_2[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tr[0], |
| temp_8888_through_4444_to_8888_tr[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_3[0], texel4444_3[1], texel4444_3[2], texel4444_3[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_bl[0], |
| temp_8888_through_4444_to_8888_bl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_4[0], texel4444_4[1], texel4444_4[2], texel4444_4[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_br[0], |
| temp_8888_through_4444_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RA); |
| |
| /* GL_RGBA4 => GL_LUMINANCE8_OES */ |
| addEntryToConversionDatabase(getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_1[0], texel4444_1[1], |
| texel4444_1[2], texel4444_1[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_tl[0]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_2[0], texel4444_2[1], |
| texel4444_2[2], texel4444_2[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_tr[0]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_3[0], texel4444_3[1], |
| texel4444_3[2], texel4444_3[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_bl[0]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_4[0], texel4444_4[1], |
| texel4444_4[2], texel4444_4[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_br[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| addEntryToConversionDatabase( |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_1[0], texel4444_1[1], texel4444_1[2], texel4444_1[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tl[0]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_2[0], texel4444_2[1], texel4444_2[2], texel4444_2[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tr[0]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_3[0], texel4444_3[1], texel4444_3[2], texel4444_3[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_bl[0]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_4[0], texel4444_4[1], texel4444_4[2], texel4444_4[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_br[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA4 => GL_ALPHA8_OES */ |
| addEntryToConversionDatabase(getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_1[0], texel4444_1[1], |
| texel4444_1[2], texel4444_1[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_tl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_2[0], texel4444_2[1], |
| texel4444_2[2], texel4444_2[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_tr[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_3[0], texel4444_3[1], |
| texel4444_3[2], texel4444_3[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_bl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_SHORT_4_4_4_4, texel4444_4[0], texel4444_4[1], |
| texel4444_4[2], texel4444_4[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_4444_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_A); |
| |
| addEntryToConversionDatabase( |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_1[0], texel4444_1[1], texel4444_1[2], texel4444_1[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_2[0], texel4444_2[1], texel4444_2[2], texel4444_2[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_tr[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_3[0], texel4444_3[1], texel4444_3[2], texel4444_3[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_bl[3]), |
| getRGBA4PixelData(1, GL_UNSIGNED_BYTE, texel4444_4[0], texel4444_4[1], texel4444_4[2], texel4444_4[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_4444_to_8888_br[3]), PIXEL_COMPARE_CHANNEL_A); |
| } |
| |
| /* GL_RGB5_A1 */ |
| { |
| int texel2101010_1[4] = { 1023, 703, 383, 2 }; |
| int texel2101010_2[4] = { 703, 383, 0, 0 }; |
| int texel2101010_3[4] = { 383, 0, 1023, 2 }; |
| int texel2101010_4[4] = { 0, 1023, 703, 0 }; |
| int texel5551_1[4] = { 31, 21, 11, 1 }; |
| int texel5551_2[4] = { 21, 11, 0, 0 }; |
| int texel5551_3[4] = { 11, 0, 31, 1 }; |
| int texel5551_4[4] = { 0, 31, 21, 0 }; |
| int texel8888_1[4] = { 255, 207, 95, 255 }; |
| int texel8888_2[4] = { 207, 95, 0, 0 }; |
| int texel8888_3[4] = { 95, 0, 255, 255 }; |
| int texel8888_4[4] = { 0, 255, 207, 0 }; |
| |
| int temp_2101010rev_through_5551_to_8888_tl[4] = { 0 }; |
| int temp_2101010rev_through_5551_to_8888_tr[4] = { 0 }; |
| int temp_2101010rev_through_5551_to_8888_bl[4] = { 0 }; |
| int temp_2101010rev_through_5551_to_8888_br[4] = { 0 }; |
| int temp_2101010rev_through_5551_565_to_8888_tl[4] = { 0 }; |
| int temp_2101010rev_through_5551_565_to_8888_tr[4] = { 0 }; |
| int temp_2101010rev_through_5551_565_to_8888_bl[4] = { 0 }; |
| int temp_2101010rev_through_5551_565_to_8888_br[4] = { 0 }; |
| int temp_5551_to_8888_tl[4] = { 0 }; |
| int temp_5551_to_8888_tr[4] = { 0 }; |
| int temp_5551_to_8888_bl[4] = { 0 }; |
| int temp_5551_to_8888_br[4] = { 0 }; |
| int temp_5551_through_565_to_8888_tl[4] = { 0 }; |
| int temp_5551_through_565_to_8888_tr[4] = { 0 }; |
| int temp_5551_through_565_to_8888_bl[4] = { 0 }; |
| int temp_5551_through_565_to_8888_br[4] = { 0 }; |
| int temp_8888_through_5551_to_8888_tl[4] = { 0 }; |
| int temp_8888_through_5551_to_8888_tr[4] = { 0 }; |
| int temp_8888_through_5551_to_8888_bl[4] = { 0 }; |
| int temp_8888_through_5551_to_8888_br[4] = { 0 }; |
| int temp_8888_through_5551_565_to_8888_tl[4] = { 0 }; |
| int temp_8888_through_5551_565_to_8888_tr[4] = { 0 }; |
| int temp_8888_through_5551_565_to_8888_bl[4] = { 0 }; |
| int temp_8888_through_5551_565_to_8888_br[4] = { 0 }; |
| |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_8888, bits_8888, texel2101010_1, |
| temp_2101010rev_through_5551_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_8888, bits_8888, texel2101010_2, |
| temp_2101010rev_through_5551_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_8888, bits_8888, texel2101010_3, |
| temp_2101010rev_through_5551_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_8888, bits_8888, texel2101010_4, |
| temp_2101010rev_through_5551_to_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_565, bits_8888, texel2101010_1, |
| temp_2101010rev_through_5551_565_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_565, bits_8888, texel2101010_2, |
| temp_2101010rev_through_5551_565_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_565, bits_8888, texel2101010_3, |
| temp_2101010rev_through_5551_565_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_1010102, bits_5551, bits_565, bits_8888, texel2101010_4, |
| temp_2101010rev_through_5551_565_to_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_8888, bits_8888, bits_8888, texel5551_1, |
| temp_5551_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_8888, bits_8888, bits_8888, texel5551_2, |
| temp_5551_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_8888, bits_8888, bits_8888, texel5551_3, |
| temp_5551_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_8888, bits_8888, bits_8888, texel5551_4, |
| temp_5551_to_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_8888, bits_8888, texel8888_1, |
| temp_8888_through_5551_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_8888, bits_8888, texel8888_2, |
| temp_8888_through_5551_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_8888, bits_8888, texel8888_3, |
| temp_8888_through_5551_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_8888, bits_8888, texel8888_4, |
| temp_8888_through_5551_to_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_565, bits_8888, texel8888_1, |
| temp_8888_through_5551_565_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_565, bits_8888, texel8888_2, |
| temp_8888_through_5551_565_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_565, bits_8888, texel8888_3, |
| temp_8888_through_5551_565_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_8888, bits_5551, bits_565, bits_8888, texel8888_4, |
| temp_8888_through_5551_565_to_8888_br); |
| |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_565, bits_8888, bits_8888, texel5551_1, |
| temp_5551_through_565_to_8888_tl); |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_565, bits_8888, bits_8888, texel5551_2, |
| temp_5551_through_565_to_8888_tr); |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_565, bits_8888, bits_8888, texel5551_3, |
| temp_5551_through_565_to_8888_bl); |
| convertNormalizedUnsignedFixedPoint(bits_5551, bits_565, bits_8888, bits_8888, texel5551_4, |
| temp_5551_through_565_to_8888_br); |
| |
| /* GL_RGB5_A1 => GL_RGB5_A1 */ |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_1[0], texel8888_1[1], texel8888_1[2], texel8888_1[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tl[0], |
| temp_8888_through_5551_to_8888_tl[1], temp_8888_through_5551_to_8888_tl[2], |
| temp_8888_through_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_2[0], texel8888_2[1], texel8888_2[2], texel8888_2[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tr[0], |
| temp_8888_through_5551_to_8888_tr[1], temp_8888_through_5551_to_8888_tr[2], |
| temp_8888_through_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_3[0], texel8888_3[1], texel8888_3[2], texel8888_3[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_bl[0], |
| temp_8888_through_5551_to_8888_bl[1], temp_8888_through_5551_to_8888_bl[2], |
| temp_8888_through_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_4[0], texel8888_4[1], texel8888_4[2], texel8888_4[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_br[0], |
| temp_8888_through_5551_to_8888_br[1], temp_8888_through_5551_to_8888_br[2], |
| temp_8888_through_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_1[0], texel5551_1[1], texel5551_1[2], |
| texel5551_1[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_5551_to_8888_tl[0], temp_5551_to_8888_tl[1], |
| temp_5551_to_8888_tl[2], temp_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_2[0], texel5551_2[1], texel5551_2[2], |
| texel5551_2[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_5551_to_8888_tr[0], temp_5551_to_8888_tr[1], |
| temp_5551_to_8888_tr[2], temp_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_3[0], texel5551_3[1], texel5551_3[2], |
| texel5551_3[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_5551_to_8888_bl[0], temp_5551_to_8888_bl[1], |
| temp_5551_to_8888_bl[2], temp_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_4[0], texel5551_4[1], texel5551_4[2], |
| texel5551_4[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_5551_to_8888_br[0], temp_5551_to_8888_br[1], |
| temp_5551_to_8888_br[2], temp_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_1[0], texel2101010_1[1], |
| texel2101010_1[2], texel2101010_1[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tl[0], |
| temp_2101010rev_through_5551_to_8888_tl[1], temp_2101010rev_through_5551_to_8888_tl[2], |
| temp_2101010rev_through_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_2[0], texel2101010_2[1], |
| texel2101010_2[2], texel2101010_2[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tr[0], |
| temp_2101010rev_through_5551_to_8888_tr[1], temp_2101010rev_through_5551_to_8888_tr[2], |
| temp_2101010rev_through_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_3[0], texel2101010_3[1], |
| texel2101010_3[2], texel2101010_3[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_bl[0], |
| temp_2101010rev_through_5551_to_8888_bl[1], temp_2101010rev_through_5551_to_8888_bl[2], |
| temp_2101010rev_through_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_4[0], texel2101010_4[1], |
| texel2101010_4[2], texel2101010_4[3]), |
| getRGB5A1PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_br[0], |
| temp_2101010rev_through_5551_to_8888_br[1], temp_2101010rev_through_5551_to_8888_br[2], |
| temp_2101010rev_through_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| |
| /* GL_RGB5_A1 => GL_RGB565 */ |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_1[0], texel8888_1[1], texel8888_1[2], texel8888_1[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_565_to_8888_tl[0], |
| temp_8888_through_5551_565_to_8888_tl[1], temp_8888_through_5551_565_to_8888_tl[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_2[0], texel8888_2[1], texel8888_2[2], texel8888_2[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_565_to_8888_tr[0], |
| temp_8888_through_5551_565_to_8888_tr[1], temp_8888_through_5551_565_to_8888_tr[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_3[0], texel8888_3[1], texel8888_3[2], texel8888_3[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_565_to_8888_bl[0], |
| temp_8888_through_5551_565_to_8888_bl[1], temp_8888_through_5551_565_to_8888_bl[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_4[0], texel8888_4[1], texel8888_4[2], texel8888_4[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_8888_through_5551_565_to_8888_br[0], |
| temp_8888_through_5551_565_to_8888_br[1], temp_8888_through_5551_565_to_8888_br[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_1[0], texel5551_1[1], texel5551_1[2], |
| texel5551_1[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_5551_through_565_to_8888_tl[0], |
| temp_5551_through_565_to_8888_tl[1], temp_5551_through_565_to_8888_tl[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_2[0], texel5551_2[1], texel5551_2[2], |
| texel5551_2[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_5551_through_565_to_8888_tr[0], |
| temp_5551_through_565_to_8888_tr[1], temp_5551_through_565_to_8888_tr[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_3[0], texel5551_3[1], texel5551_3[2], |
| texel5551_3[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_5551_through_565_to_8888_bl[0], |
| temp_5551_through_565_to_8888_bl[1], temp_5551_through_565_to_8888_bl[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_4[0], texel5551_4[1], texel5551_4[2], |
| texel5551_4[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_5551_through_565_to_8888_br[0], |
| temp_5551_through_565_to_8888_br[1], temp_5551_through_565_to_8888_br[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_1[0], texel2101010_1[1], |
| texel2101010_1[2], texel2101010_1[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_565_to_8888_tl[0], |
| temp_2101010rev_through_5551_565_to_8888_tl[1], |
| temp_2101010rev_through_5551_565_to_8888_tl[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_2[0], texel2101010_2[1], |
| texel2101010_2[2], texel2101010_2[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_565_to_8888_tr[0], |
| temp_2101010rev_through_5551_565_to_8888_tr[1], |
| temp_2101010rev_through_5551_565_to_8888_tr[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_3[0], texel2101010_3[1], |
| texel2101010_3[2], texel2101010_3[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_565_to_8888_bl[0], |
| temp_2101010rev_through_5551_565_to_8888_bl[1], |
| temp_2101010rev_through_5551_565_to_8888_bl[2]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_4[0], texel2101010_4[1], |
| texel2101010_4[2], texel2101010_4[3]), |
| getRGB565PixelData(0, GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_565_to_8888_br[0], |
| temp_2101010rev_through_5551_565_to_8888_br[1], |
| temp_2101010rev_through_5551_565_to_8888_br[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGB5_A1 => GL_LUMINANCE8_ALPHA8_OES */ |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_1[0], texel8888_1[1], texel8888_1[2], texel8888_1[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tl[0], |
| temp_8888_through_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_2[0], texel8888_2[1], texel8888_2[2], texel8888_2[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tr[0], |
| temp_8888_through_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_3[0], texel8888_3[1], texel8888_3[2], texel8888_3[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_bl[0], |
| temp_8888_through_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_4[0], texel8888_4[1], texel8888_4[2], texel8888_4[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_br[0], |
| temp_8888_through_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RA); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_1[0], texel5551_1[1], texel5551_1[2], |
| texel5551_1[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_tl[0], temp_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_2[0], texel5551_2[1], texel5551_2[2], |
| texel5551_2[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_tr[0], temp_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_3[0], texel5551_3[1], texel5551_3[2], |
| texel5551_3[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_bl[0], temp_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_4[0], texel5551_4[1], texel5551_4[2], |
| texel5551_4[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_br[0], temp_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RA); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_1[0], texel2101010_1[1], |
| texel2101010_1[2], texel2101010_1[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tl[0], |
| temp_2101010rev_through_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_2[0], texel2101010_2[1], |
| texel2101010_2[2], texel2101010_2[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tr[0], |
| temp_2101010rev_through_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_3[0], texel2101010_3[1], |
| texel2101010_3[2], texel2101010_3[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_bl[0], |
| temp_2101010rev_through_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_4[0], texel2101010_4[1], |
| texel2101010_4[2], texel2101010_4[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_br[0], |
| temp_2101010rev_through_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_RA); |
| |
| /* GL_RGB5_A1 => GL_LUMINANCE8_OES */ |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_1[0], texel8888_1[1], texel8888_1[2], texel8888_1[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tl[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_2[0], texel8888_2[1], texel8888_2[2], texel8888_2[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tr[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_3[0], texel8888_3[1], texel8888_3[2], texel8888_3[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_bl[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_4[0], texel8888_4[1], texel8888_4[2], texel8888_4[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_br[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| addEntryToConversionDatabase(getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_1[0], texel5551_1[1], |
| texel5551_1[2], texel5551_1[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_tl[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_2[0], texel5551_2[1], |
| texel5551_2[2], texel5551_2[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_tr[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_3[0], texel5551_3[1], |
| texel5551_3[2], texel5551_3[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_bl[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_4[0], texel5551_4[1], |
| texel5551_4[2], texel5551_4[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_br[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_1[0], texel2101010_1[1], |
| texel2101010_1[2], texel2101010_1[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tl[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_2[0], texel2101010_2[1], |
| texel2101010_2[2], texel2101010_2[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tr[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_3[0], texel2101010_3[1], |
| texel2101010_3[2], texel2101010_3[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_bl[0]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_4[0], texel2101010_4[1], |
| texel2101010_4[2], texel2101010_4[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_br[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGB5_A1 => GL_ALPHA8_OES */ |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_1[0], texel8888_1[1], texel8888_1[2], texel8888_1[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_2[0], texel8888_2[1], texel8888_2[2], texel8888_2[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_3[0], texel8888_3[1], texel8888_3[2], texel8888_3[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_BYTE, texel8888_4[0], texel8888_4[1], texel8888_4[2], texel8888_4[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_8888_through_5551_to_8888_br[3]), PIXEL_COMPARE_CHANNEL_A); |
| |
| addEntryToConversionDatabase(getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_1[0], texel5551_1[1], |
| texel5551_1[2], texel5551_1[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_2[0], texel5551_2[1], |
| texel5551_2[2], texel5551_2[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_3[0], texel5551_3[1], |
| texel5551_3[2], texel5551_3[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_SHORT_5_5_5_1, texel5551_4[0], texel5551_4[1], |
| texel5551_4[2], texel5551_4[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_A); |
| |
| addEntryToConversionDatabase( |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_1[0], texel2101010_1[1], |
| texel2101010_1[2], texel2101010_1[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_2[0], texel2101010_2[1], |
| texel2101010_2[2], texel2101010_2[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_tr[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_3[0], texel2101010_3[1], |
| texel2101010_3[2], texel2101010_3[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_bl[3]), |
| getRGB5A1PixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2101010_4[0], texel2101010_4[1], |
| texel2101010_4[2], texel2101010_4[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, temp_2101010rev_through_5551_to_8888_br[3]), |
| PIXEL_COMPARE_CHANNEL_A); |
| } |
| |
| /* GL_RGBA8 */ |
| { |
| const unsigned char texel1[4] = { 255, 127, 63, 0 }; |
| const unsigned char texel2[4] = { 127, 63, 0, 255 }; |
| const unsigned char texel3[4] = { 63, 0, 255, 127 }; |
| const unsigned char texel4[4] = { 0, 255, 127, 63 }; |
| |
| /* GL_RGBA8 => GL_RGBA8 */ |
| addEntryToConversionDatabase(getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| |
| /* GL_RGBA8 => GL_RGB8 */ |
| addEntryToConversionDatabase(getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB8PixelData(0, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA8 => GL_LUMINANCE8_ALPHA8_OES */ |
| addEntryToConversionDatabase(getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getLuminance8Alpha8OESPixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RA); |
| |
| /* GL_RGBA8 => GL_LUMINANCE8_OES */ |
| addEntryToConversionDatabase(getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel1[0]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel2[0]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel3[0]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getLuminance8OESPixelData(GL_UNSIGNED_BYTE, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA8 => GL_ALPHA8_OES */ |
| addEntryToConversionDatabase(getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, texel1[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, texel2[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, texel3[3]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getAlpha8OESPixelData(GL_UNSIGNED_BYTE, texel4[3]), PIXEL_COMPARE_CHANNEL_A); |
| |
| /* GL_RGBA8 => GL_R8 */ |
| addEntryToConversionDatabase(getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel1[0]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel2[0]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel3[0]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR8PixelData(0, GL_UNSIGNED_BYTE, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA8 => GL_RG8 */ |
| addEntryToConversionDatabase(getRGBA8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), |
| getRGBA8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG8PixelData(0, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RGB10_A2 */ |
| { |
| const unsigned short texel1[4] = { 1023, 682, 341, 3 }; |
| const unsigned short texel2[4] = { 682, 341, 0, 2 }; |
| const unsigned short texel3[4] = { 341, 0, 1023, 1 }; |
| const unsigned short texel4[4] = { 0, 1023, 682, 0 }; |
| |
| /* GL_RGB10_A2 => GL_RGB10_A2 */ |
| addEntryToConversionDatabase(getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel1[0], texel1[1], |
| texel1[2], (unsigned char)texel1[3]), |
| getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel1[0], texel1[1], |
| texel1[2], (unsigned char)texel1[3]), |
| getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel2[0], texel2[1], |
| texel2[2], (unsigned char)texel2[3]), |
| getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel2[0], texel2[1], |
| texel2[2], (unsigned char)texel2[3]), |
| getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel3[0], texel3[1], |
| texel3[2], (unsigned char)texel3[3]), |
| getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel3[0], texel3[1], |
| texel3[2], (unsigned char)texel3[3]), |
| getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel4[0], texel4[1], |
| texel4[2], (unsigned char)texel4[3]), |
| getRGB10A2PixelData(GL_UNSIGNED_INT_2_10_10_10_REV, texel4[0], texel4[1], |
| texel4[2], (unsigned char)texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_RGB10_A2UI */ |
| { |
| const unsigned short texel1[4] = { 1023, 682, 341, 3 }; |
| const unsigned short texel2[4] = { 682, 341, 0, 2 }; |
| const unsigned short texel3[4] = { 341, 0, 1023, 1 }; |
| const unsigned short texel4[4] = { 0, 1023, 682, 0 }; |
| |
| /* GL_RGB10_A2UI => GL_RGB10_A2UI */ |
| addEntryToConversionDatabase( |
| getRGB10A2UIPixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB10A2UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB10A2UIPixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB10A2UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB10A2UIPixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB10A2UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB10A2UIPixelData(1, GL_UNSIGNED_INT_2_10_10_10_REV, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB10A2UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_SRGB8_ALPHA8 */ |
| { |
| const unsigned char texel1[4] = { 255, 127, 63, 0 }; |
| const unsigned char texel2[4] = { 127, 63, 0, 255 }; |
| const unsigned char texel3[4] = { 63, 0, 255, 127 }; |
| const unsigned char texel4[4] = { 0, 255, 127, 63 }; |
| |
| /* GL_SRGB8_ALPHA8 => GL_SRGB8 */ |
| addEntryToConversionDatabase( |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getSRGB8PixelData(0, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getSRGB8PixelData(0, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getSRGB8PixelData(0, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getSRGB8PixelData(0, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2]), PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_SRGB8_ALPHA8 => GL_SRGB8_ALPHA8 */ |
| addEntryToConversionDatabase( |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getSRGB8Alpha8PixelData(GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_R8I */ |
| { |
| const signed char texel1[1] = { 127 }; |
| const signed char texel2[1] = { 42 }; |
| const signed char texel3[1] = { -43 }; |
| const signed char texel4[1] = { -127 }; |
| |
| /* GL_R8I => GL_R8I */ |
| addEntryToConversionDatabase(getR8IPixelData(1, GL_BYTE, texel1[0]), getR8IPixelData(0, GL_INT, texel1[0]), |
| getR8IPixelData(1, GL_BYTE, texel2[0]), getR8IPixelData(0, GL_INT, texel2[0]), |
| getR8IPixelData(1, GL_BYTE, texel3[0]), getR8IPixelData(0, GL_INT, texel3[0]), |
| getR8IPixelData(1, GL_BYTE, texel4[0]), getR8IPixelData(0, GL_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_R8UI */ |
| { |
| const unsigned char texel1[1] = { 255 }; |
| const unsigned char texel2[1] = { 127 }; |
| const unsigned char texel3[1] = { 63 }; |
| const unsigned char texel4[1] = { 0 }; |
| |
| /* GL_R8UI => GL_R8UI */ |
| addEntryToConversionDatabase( |
| getR8UIPixelData(1, GL_UNSIGNED_BYTE, texel1[0]), getR8UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getR8UIPixelData(1, GL_UNSIGNED_BYTE, texel2[0]), getR8UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getR8UIPixelData(1, GL_UNSIGNED_BYTE, texel3[0]), getR8UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getR8UIPixelData(1, GL_UNSIGNED_BYTE, texel4[0]), getR8UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_R16I */ |
| { |
| const signed short texel1[1] = { 32767 }; |
| const signed short texel2[1] = { 10922 }; |
| const signed short texel3[1] = { -10923 }; |
| const signed short texel4[1] = { -32767 }; |
| |
| /* GL_R16I => GL_R16I */ |
| addEntryToConversionDatabase(getR16IPixelData(1, GL_SHORT, texel1[0]), getR16IPixelData(0, GL_INT, texel1[0]), |
| getR16IPixelData(1, GL_SHORT, texel2[0]), getR16IPixelData(0, GL_INT, texel2[0]), |
| getR16IPixelData(1, GL_SHORT, texel3[0]), getR16IPixelData(0, GL_INT, texel3[0]), |
| getR16IPixelData(1, GL_SHORT, texel4[0]), getR16IPixelData(0, GL_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_R16UI */ |
| { |
| const unsigned short texel1[1] = { 65535 }; |
| const unsigned short texel2[1] = { 43690 }; |
| const unsigned short texel3[1] = { 21845 }; |
| const unsigned short texel4[1] = { 0 }; |
| |
| /* GL_R16UI => GL_R16UI */ |
| addEntryToConversionDatabase( |
| getR16UIPixelData(1, GL_UNSIGNED_SHORT, texel1[0]), getR16UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getR16UIPixelData(1, GL_UNSIGNED_SHORT, texel2[0]), getR16UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getR16UIPixelData(1, GL_UNSIGNED_SHORT, texel3[0]), getR16UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getR16UIPixelData(1, GL_UNSIGNED_SHORT, texel4[0]), getR16UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_R32I */ |
| { |
| const int texel1[1] = { 2147483647l }; |
| const int texel2[1] = { 715827883l }; |
| const int texel3[1] = { -715827881l }; |
| const int texel4[1] = { -2147483647l }; |
| |
| /* GL_R32I => GL_R32I */ |
| addEntryToConversionDatabase(getR32IPixelData(1, GL_INT, texel1[0]), getR32IPixelData(0, GL_INT, texel1[0]), |
| getR32IPixelData(1, GL_INT, texel2[0]), getR32IPixelData(0, GL_INT, texel2[0]), |
| getR32IPixelData(1, GL_INT, texel3[0]), getR32IPixelData(0, GL_INT, texel3[0]), |
| getR32IPixelData(1, GL_INT, texel4[0]), getR32IPixelData(0, GL_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_R32UI */ |
| { |
| const unsigned int texel1[1] = { 4294967295u }; |
| const unsigned int texel2[1] = { 2863311530u }; |
| const unsigned int texel3[1] = { 1431655765u }; |
| const unsigned int texel4[1] = { 0 }; |
| |
| /* GL_R32UI => GL_R32UI */ |
| addEntryToConversionDatabase( |
| getR32UIPixelData(1, GL_UNSIGNED_INT, texel1[0]), getR32UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getR32UIPixelData(1, GL_UNSIGNED_INT, texel2[0]), getR32UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getR32UIPixelData(1, GL_UNSIGNED_INT, texel3[0]), getR32UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getR32UIPixelData(1, GL_UNSIGNED_INT, texel4[0]), getR32UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_RG8I */ |
| { |
| const signed char texel1[2] = { 127, 42 }; |
| const signed char texel2[2] = { 42, -43 }; |
| const signed char texel3[2] = { -43, -127 }; |
| const signed char texel4[2] = { -127, 127 }; |
| |
| /* GL_RG8I => GL_R8I */ |
| addEntryToConversionDatabase( |
| getRG8IPixelData(1, GL_BYTE, texel1[0], texel1[1]), getR8IPixelData(0, GL_INT, texel1[0]), |
| getRG8IPixelData(1, GL_BYTE, texel2[0], texel2[1]), getR8IPixelData(0, GL_INT, texel2[0]), |
| getRG8IPixelData(1, GL_BYTE, texel3[0], texel3[1]), getR8IPixelData(0, GL_INT, texel3[0]), |
| getRG8IPixelData(1, GL_BYTE, texel4[0], texel4[1]), getR8IPixelData(0, GL_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| /* GL_RG8I => GL_RG8I */ |
| addEntryToConversionDatabase( |
| getRG8IPixelData(1, GL_BYTE, texel1[0], texel1[1]), getRG8IPixelData(0, GL_INT, texel1[0], texel1[1]), |
| getRG8IPixelData(1, GL_BYTE, texel2[0], texel2[1]), getRG8IPixelData(0, GL_INT, texel2[0], texel2[1]), |
| getRG8IPixelData(1, GL_BYTE, texel3[0], texel3[1]), getRG8IPixelData(0, GL_INT, texel3[0], texel3[1]), |
| getRG8IPixelData(1, GL_BYTE, texel4[0], texel4[1]), getRG8IPixelData(0, GL_INT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RG8UI */ |
| { |
| const unsigned char texel1[2] = { 255, 127 }; |
| const unsigned char texel2[2] = { 127, 63 }; |
| const unsigned char texel3[2] = { 63, 0 }; |
| const unsigned char texel4[2] = { 0, 255 }; |
| |
| /* GL_RG8UI => GL_R8UI */ |
| addEntryToConversionDatabase(getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG8UI => GL_RG8UI */ |
| addEntryToConversionDatabase(getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getRG8UIPixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RG16I */ |
| { |
| const short texel1[2] = { 32767, 10922 }; |
| const short texel2[2] = { 10922, -10923 }; |
| const short texel3[2] = { -10923, -32767 }; |
| const short texel4[2] = { -32767, 32767 }; |
| |
| /* GL_RG16I => GL_R16I */ |
| addEntryToConversionDatabase( |
| getRG16IPixelData(1, GL_SHORT, texel1[0], texel1[1]), getR16IPixelData(0, GL_INT, texel1[0]), |
| getRG16IPixelData(1, GL_SHORT, texel2[0], texel2[1]), getR16IPixelData(0, GL_INT, texel2[0]), |
| getRG16IPixelData(1, GL_SHORT, texel3[0], texel3[1]), getR16IPixelData(0, GL_INT, texel3[0]), |
| getRG16IPixelData(1, GL_SHORT, texel4[0], texel4[1]), getR16IPixelData(0, GL_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG16I => GL_RG16I */ |
| addEntryToConversionDatabase( |
| getRG16IPixelData(1, GL_SHORT, texel1[0], texel1[1]), getRG16IPixelData(0, GL_INT, texel1[0], texel1[1]), |
| getRG16IPixelData(1, GL_SHORT, texel2[0], texel2[1]), getRG16IPixelData(0, GL_INT, texel2[0], texel2[1]), |
| getRG16IPixelData(1, GL_SHORT, texel3[0], texel3[1]), getRG16IPixelData(0, GL_INT, texel3[0], texel3[1]), |
| getRG16IPixelData(1, GL_SHORT, texel4[0], texel4[1]), getRG16IPixelData(0, GL_INT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RG16UI */ |
| { |
| const unsigned short texel1[2] = { 65535, 43690 }; |
| const unsigned short texel2[2] = { 43690, 21845 }; |
| const unsigned short texel3[2] = { 21845, 0 }; |
| const unsigned short texel4[2] = { 0, 65535 }; |
| |
| /* GL_RG16UI => GL_R16UI */ |
| addEntryToConversionDatabase(getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel1[0], texel1[1]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel2[0], texel2[1]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel3[0], texel3[1]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel4[0], texel4[1]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG16UI => GL_RG16UI */ |
| addEntryToConversionDatabase(getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel1[0], texel1[1]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel2[0], texel2[1]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel3[0], texel3[1]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getRG16UIPixelData(1, GL_UNSIGNED_SHORT, texel4[0], texel4[1]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RG32I */ |
| { |
| const int texel1[2] = { 2147483647, 715827883l }; |
| const int texel2[2] = { 715827883, -715827881l }; |
| const int texel3[2] = { -715827881, -2147483647l }; |
| const int texel4[2] = { -2147483647, 2147483647l }; |
| |
| /* GL_RG32I => GL_R32I */ |
| addEntryToConversionDatabase( |
| getRG32IPixelData(1, GL_INT, texel1[0], texel1[1]), getR32IPixelData(0, GL_INT, texel1[0]), |
| getRG32IPixelData(1, GL_INT, texel2[0], texel2[1]), getR32IPixelData(0, GL_INT, texel2[0]), |
| getRG32IPixelData(1, GL_INT, texel3[0], texel3[1]), getR32IPixelData(0, GL_INT, texel3[0]), |
| getRG32IPixelData(1, GL_INT, texel4[0], texel4[1]), getR32IPixelData(0, GL_INT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG32I => GL_RG32I */ |
| addEntryToConversionDatabase( |
| getRG32IPixelData(1, GL_INT, texel1[0], texel1[1]), getRG32IPixelData(0, GL_INT, texel1[0], texel1[1]), |
| getRG32IPixelData(1, GL_INT, texel2[0], texel2[1]), getRG32IPixelData(0, GL_INT, texel2[0], texel2[1]), |
| getRG32IPixelData(1, GL_INT, texel3[0], texel3[1]), getRG32IPixelData(0, GL_INT, texel3[0], texel3[1]), |
| getRG32IPixelData(1, GL_INT, texel4[0], texel4[1]), getRG32IPixelData(0, GL_INT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RG32UI */ |
| { |
| const unsigned int texel1[2] = { 4294967295u, 2863311530u }; |
| const unsigned int texel2[2] = { 2863311530u, 1431655765u }; |
| const unsigned int texel3[2] = { 1431655765u, 0 }; |
| const unsigned int texel4[2] = { 0, 4294967295u }; |
| |
| /* GL_RG32UI => GL_R32UI */ |
| addEntryToConversionDatabase(getRG32UIPixelData(1, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getRG32UIPixelData(1, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getRG32UIPixelData(1, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getRG32UIPixelData(1, GL_UNSIGNED_INT, texel4[0], texel4[1]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG32UI => GL_RG32UI */ |
| addEntryToConversionDatabase(getRG32UIPixelData(1, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getRG32UIPixelData(1, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getRG32UIPixelData(1, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getRG32UIPixelData(1, GL_UNSIGNED_INT, texel4[0], texel4[1]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RGBA8I */ |
| { |
| const signed char texel1[4] = { 127, 42, -43, -127 }; |
| const signed char texel2[4] = { 42, -43, -127, 127 }; |
| const signed char texel3[4] = { -43, -127, 127, 42 }; |
| const signed char texel4[4] = { -127, 127, 42, -43 }; |
| |
| /* GL_RGBA8I => GL_R8I */ |
| addEntryToConversionDatabase(getRGBA8IPixelData(1, GL_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR8IPixelData(0, GL_INT, texel1[0]), |
| getRGBA8IPixelData(1, GL_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR8IPixelData(0, GL_INT, texel2[0]), |
| getRGBA8IPixelData(1, GL_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR8IPixelData(0, GL_INT, texel3[0]), |
| getRGBA8IPixelData(1, GL_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR8IPixelData(0, GL_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA8I => GL_RG8I */ |
| addEntryToConversionDatabase(getRGBA8IPixelData(1, GL_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG8IPixelData(0, GL_INT, texel1[0], texel1[1]), |
| getRGBA8IPixelData(1, GL_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG8IPixelData(0, GL_INT, texel2[0], texel2[1]), |
| getRGBA8IPixelData(1, GL_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG8IPixelData(0, GL_INT, texel3[0], texel3[1]), |
| getRGBA8IPixelData(1, GL_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG8IPixelData(0, GL_INT, texel4[0], texel4[1]), PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA8I => GL_RGB8I */ |
| addEntryToConversionDatabase(getRGBA8IPixelData(1, GL_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB8IPixelData(0, GL_INT, texel1[0], texel1[1], texel1[2]), |
| getRGBA8IPixelData(1, GL_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB8IPixelData(0, GL_INT, texel2[0], texel2[1], texel2[2]), |
| getRGBA8IPixelData(1, GL_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB8IPixelData(0, GL_INT, texel3[0], texel3[1], texel3[2]), |
| getRGBA8IPixelData(1, GL_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB8IPixelData(0, GL_INT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA8I => GL_RGBA8I */ |
| addEntryToConversionDatabase(getRGBA8IPixelData(1, GL_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA8IPixelData(0, GL_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA8IPixelData(1, GL_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA8IPixelData(0, GL_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA8IPixelData(1, GL_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA8IPixelData(0, GL_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA8IPixelData(1, GL_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA8IPixelData(0, GL_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_RGBA8UI */ |
| { |
| const unsigned char texel1[4] = { 255, 127, 63, 0 }; |
| const unsigned char texel2[4] = { 127, 63, 0, 255 }; |
| const unsigned char texel3[4] = { 63, 0, 255, 127 }; |
| const unsigned char texel4[4] = { 0, 255, 127, 63 }; |
| |
| /* GL_RGBA8UI => GL_R8UI */ |
| addEntryToConversionDatabase( |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR8UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA8UI => GL_RG8UI */ |
| addEntryToConversionDatabase( |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG8UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1]), PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA8UI => GL_RGB8UI */ |
| addEntryToConversionDatabase( |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB8UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB8UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB8UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB8UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2]), PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA8UI => GL_RGBA8UI */ |
| addEntryToConversionDatabase( |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA8UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA8UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA8UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA8UIPixelData(1, GL_UNSIGNED_BYTE, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA8UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_RGBA16I */ |
| { |
| const short texel1[4] = { 32767, 10922, -10923, -32767 }; |
| const short texel2[4] = { 10922, -10923, -32767, 32767 }; |
| const short texel3[4] = { -10923, -32767, 32767, 10922 }; |
| const short texel4[4] = { -32767, 32767, 10922, -10923 }; |
| |
| /* GL_RGBA16I => GL_R16I */ |
| addEntryToConversionDatabase(getRGBA16IPixelData(1, GL_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR16IPixelData(0, GL_INT, texel1[0]), |
| getRGBA16IPixelData(1, GL_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR16IPixelData(0, GL_INT, texel2[0]), |
| getRGBA16IPixelData(1, GL_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR16IPixelData(0, GL_INT, texel3[0]), |
| getRGBA16IPixelData(1, GL_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR16IPixelData(0, GL_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA16I => GL_RG16I */ |
| addEntryToConversionDatabase(getRGBA16IPixelData(1, GL_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG16IPixelData(0, GL_INT, texel1[0], texel1[1]), |
| getRGBA16IPixelData(1, GL_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG16IPixelData(0, GL_INT, texel2[0], texel2[1]), |
| getRGBA16IPixelData(1, GL_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG16IPixelData(0, GL_INT, texel3[0], texel3[1]), |
| getRGBA16IPixelData(1, GL_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG16IPixelData(0, GL_INT, texel4[0], texel4[1]), PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA16I => GL_RGB16I */ |
| addEntryToConversionDatabase(getRGBA16IPixelData(1, GL_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB16IPixelData(0, GL_INT, texel1[0], texel1[1], texel1[2]), |
| getRGBA16IPixelData(1, GL_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB16IPixelData(0, GL_INT, texel2[0], texel2[1], texel2[2]), |
| getRGBA16IPixelData(1, GL_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB16IPixelData(0, GL_INT, texel3[0], texel3[1], texel3[2]), |
| getRGBA16IPixelData(1, GL_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB16IPixelData(0, GL_INT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA16I => GL_RGBA16I */ |
| addEntryToConversionDatabase(getRGBA16IPixelData(1, GL_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA16IPixelData(0, GL_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA16IPixelData(1, GL_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA16IPixelData(0, GL_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA16IPixelData(1, GL_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA16IPixelData(0, GL_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA16IPixelData(1, GL_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA16IPixelData(0, GL_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_RGBA16UI */ |
| { |
| const unsigned short texel1[4] = { 65535, 43690, 21845, 0 }; |
| const unsigned short texel2[4] = { 43690, 21845, 0, 65535 }; |
| const unsigned short texel3[4] = { 21845, 0, 65535, 43690 }; |
| const unsigned short texel4[4] = { 0, 65535, 43690, 21845 }; |
| |
| /* GL_RGBA16UI => GL_R16UI */ |
| addEntryToConversionDatabase( |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR16UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA16UI => GL_RG16UI */ |
| addEntryToConversionDatabase( |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG16UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1]), PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA16UI => GL_RGB16UI */ |
| addEntryToConversionDatabase( |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB16UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB16UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB16UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB16UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2]), PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA16UI => GL_RGBA16UI */ |
| addEntryToConversionDatabase( |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA16UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA16UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA16UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA16UIPixelData(1, GL_UNSIGNED_SHORT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA16UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_RGBA32I */ |
| { |
| const int texel1[4] = { 2147483647, 715827883, -715827881, -2147483647 }; |
| const int texel2[4] = { 715827883, -715827881, -2147483647, 2147483647 }; |
| const int texel3[4] = { -715827881, -2147483647, 2147483647, 715827883 }; |
| const int texel4[4] = { -2147483647, 2147483647, 715827883, -715827881 }; |
| |
| /* GL_RGBA32I => GL_R32I */ |
| addEntryToConversionDatabase(getRGBA32IPixelData(GL_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR32IPixelData(0, GL_INT, texel1[0]), |
| getRGBA32IPixelData(GL_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR32IPixelData(0, GL_INT, texel2[0]), |
| getRGBA32IPixelData(GL_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR32IPixelData(0, GL_INT, texel3[0]), |
| getRGBA32IPixelData(GL_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR32IPixelData(0, GL_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA32I => GL_RG32I */ |
| addEntryToConversionDatabase(getRGBA32IPixelData(GL_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG32IPixelData(0, GL_INT, texel1[0], texel1[1]), |
| getRGBA32IPixelData(GL_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG32IPixelData(0, GL_INT, texel2[0], texel2[1]), |
| getRGBA32IPixelData(GL_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG32IPixelData(0, GL_INT, texel3[0], texel3[1]), |
| getRGBA32IPixelData(GL_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG32IPixelData(0, GL_INT, texel4[0], texel4[1]), PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA32I => GL_RGB32I */ |
| addEntryToConversionDatabase(getRGBA32IPixelData(GL_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB32IPixelData(0, GL_INT, texel1[0], texel1[1], texel1[2]), |
| getRGBA32IPixelData(GL_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB32IPixelData(0, GL_INT, texel2[0], texel2[1], texel2[2]), |
| getRGBA32IPixelData(GL_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB32IPixelData(0, GL_INT, texel3[0], texel3[1], texel3[2]), |
| getRGBA32IPixelData(GL_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB32IPixelData(0, GL_INT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA32I => GL_RGBA32I */ |
| addEntryToConversionDatabase(getRGBA32IPixelData(GL_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA32IPixelData(GL_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA32IPixelData(GL_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA32IPixelData(GL_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA32IPixelData(GL_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA32IPixelData(GL_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA32IPixelData(GL_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA32IPixelData(GL_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_RGBA32UI */ |
| { |
| const unsigned int texel1[4] = { 4294967295u, 2863311530u, 1431655765u, 0 }; |
| const unsigned int texel2[4] = { 2863311530u, 1431655765u, 0, 4294967295u }; |
| const unsigned int texel3[4] = { 1431655765u, 0, 4294967295u, 2863311530u }; |
| const unsigned int texel4[4] = { 0, 4294967295u, 2863311530u, 1431655765u }; |
| |
| /* GL_RGBA32UI => GL_R32UI */ |
| addEntryToConversionDatabase(getRGBA32UIPixelData(GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel1[0]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel2[0]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel3[0]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR32UIPixelData(0, GL_UNSIGNED_INT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA32UI => GL_RG32UI */ |
| addEntryToConversionDatabase(getRGBA32UIPixelData(GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG32UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA32UI => GL_RGB32UI */ |
| addEntryToConversionDatabase(getRGBA32UIPixelData(GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB32UIPixelData(0, GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB32UIPixelData(0, GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB32UIPixelData(0, GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB32UIPixelData(0, GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA32UI => GL_RGBA32UI */ |
| addEntryToConversionDatabase(getRGBA32UIPixelData(GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA32UIPixelData(GL_UNSIGNED_INT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_R16F */ |
| { |
| const float texel1[1] = { 1 }; |
| const float texel2[1] = { 4096 }; |
| const float texel3[1] = { -4096 }; |
| const float texel4[1] = { 32000 }; |
| |
| /* GL_R16F => GL_R16F */ |
| addEntryToConversionDatabase( |
| getR16FPixelData(1, GL_HALF_FLOAT, texel1[0]), getR16FPixelData(0, GL_HALF_FLOAT, texel1[0]), |
| getR16FPixelData(1, GL_HALF_FLOAT, texel2[0]), getR16FPixelData(0, GL_HALF_FLOAT, texel2[0]), |
| getR16FPixelData(1, GL_HALF_FLOAT, texel3[0]), getR16FPixelData(0, GL_HALF_FLOAT, texel3[0]), |
| getR16FPixelData(1, GL_HALF_FLOAT, texel4[0]), getR16FPixelData(0, GL_HALF_FLOAT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_RG16F */ |
| { |
| const float texel1[2] = { 1, 0 }; |
| const float texel2[2] = { 4096, -4096 }; |
| const float texel3[2] = { -32000, 32000 }; |
| const float texel4[2] = { 1.5f, -4.7f }; |
| |
| /* GL_RG16F => GL_R16F */ |
| addEntryToConversionDatabase( |
| getRG16FPixelData(1, GL_HALF_FLOAT, texel1[0], texel1[1]), getR16FPixelData(0, GL_HALF_FLOAT, texel1[0]), |
| getRG16FPixelData(1, GL_HALF_FLOAT, texel2[0], texel2[1]), getR16FPixelData(0, GL_HALF_FLOAT, texel2[0]), |
| getRG16FPixelData(1, GL_HALF_FLOAT, texel3[0], texel3[1]), getR16FPixelData(0, GL_HALF_FLOAT, texel3[0]), |
| getRG16FPixelData(1, GL_HALF_FLOAT, texel4[0], texel4[1]), getR16FPixelData(0, GL_HALF_FLOAT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG16F => GL_RG16F */ |
| addEntryToConversionDatabase(getRG16FPixelData(1, GL_HALF_FLOAT, texel1[0], texel1[1]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel1[0], texel1[1]), |
| getRG16FPixelData(1, GL_HALF_FLOAT, texel2[0], texel2[1]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel2[0], texel2[1]), |
| getRG16FPixelData(1, GL_HALF_FLOAT, texel3[0], texel3[1]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel3[0], texel3[1]), |
| getRG16FPixelData(1, GL_HALF_FLOAT, texel4[0], texel4[1]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_R32F */ |
| { |
| const float texel1[1] = { 1 }; |
| const float texel2[1] = { 4096 }; |
| const float texel3[1] = { -4096 }; |
| const float texel4[1] = { 32000 }; |
| |
| /* GL_R32F => GL_R32F */ |
| addEntryToConversionDatabase(getR32FPixelData(1, GL_FLOAT, texel1[0]), getR32FPixelData(0, GL_FLOAT, texel1[0]), |
| getR32FPixelData(1, GL_FLOAT, texel2[0]), getR32FPixelData(0, GL_FLOAT, texel2[0]), |
| getR32FPixelData(1, GL_FLOAT, texel3[0]), getR32FPixelData(0, GL_FLOAT, texel3[0]), |
| getR32FPixelData(1, GL_FLOAT, texel4[0]), getR32FPixelData(0, GL_FLOAT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| } |
| |
| /* GL_RG32F */ |
| { |
| const float texel1[2] = { 1, 0 }; |
| const float texel2[2] = { 4096, -4096 }; |
| const float texel3[2] = { -32000, 32000 }; |
| const float texel4[2] = { 1.5f, -4.7f }; |
| |
| /* GL_RG32F => GL_R32F */ |
| addEntryToConversionDatabase( |
| getRG32FPixelData(1, GL_FLOAT, texel1[0], texel1[1]), getR32FPixelData(0, GL_FLOAT, texel1[0]), |
| getRG32FPixelData(1, GL_FLOAT, texel2[0], texel2[1]), getR32FPixelData(0, GL_FLOAT, texel2[0]), |
| getRG32FPixelData(1, GL_FLOAT, texel3[0], texel3[1]), getR32FPixelData(0, GL_FLOAT, texel3[0]), |
| getRG32FPixelData(1, GL_FLOAT, texel4[0], texel4[1]), getR32FPixelData(0, GL_FLOAT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RG32F => GL_RG32F */ |
| addEntryToConversionDatabase( |
| getRG32FPixelData(1, GL_FLOAT, texel1[0], texel1[1]), getRG32FPixelData(0, GL_FLOAT, texel1[0], texel1[1]), |
| getRG32FPixelData(1, GL_FLOAT, texel2[0], texel2[1]), getRG32FPixelData(0, GL_FLOAT, texel2[0], texel2[1]), |
| getRG32FPixelData(1, GL_FLOAT, texel3[0], texel3[1]), getRG32FPixelData(0, GL_FLOAT, texel3[0], texel3[1]), |
| getRG32FPixelData(1, GL_FLOAT, texel4[0], texel4[1]), getRG32FPixelData(0, GL_FLOAT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| } |
| |
| /* GL_RGB16F */ |
| { |
| const float texel1[3] = { 1, 0, -1 }; |
| const float texel2[3] = { 4096, -4096, 127.5f }; |
| const float texel3[3] = { -32000, 32000, -456.7f }; |
| const float texel4[3] = { 1.5f, -4.7f, 123.6f }; |
| |
| /* GL_RGB16F => GL_R16F */ |
| addEntryToConversionDatabase(getRGB16FPixelData(1, GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel1[0]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel2[0]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel3[0]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGB16F => GL_RG16F */ |
| addEntryToConversionDatabase(getRGB16FPixelData(1, GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel1[0], texel1[1]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel2[0], texel2[1]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel3[0], texel3[1]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGB16F => GL_RGB16F */ |
| addEntryToConversionDatabase(getRGB16FPixelData(1, GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRGB16FPixelData(1, GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| } |
| |
| /* GL_RGBA16F */ |
| { |
| const float texel1[4] = { 1, 0, -1, 0.25f }; |
| const float texel2[4] = { 4096, -4096, 127.5f, 0.5f }; |
| const float texel3[4] = { -32000, 32000, -456.7f, 0.75f }; |
| const float texel4[4] = { 1.5f, -4.7f, 123.6f, 1 }; |
| |
| /* GL_RGBA16F => GL_R16F */ |
| addEntryToConversionDatabase(getRGBA16FPixelData(GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel1[0]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel2[0]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel3[0]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR16FPixelData(0, GL_HALF_FLOAT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA16F => GL_RG16F */ |
| addEntryToConversionDatabase(getRGBA16FPixelData(GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel1[0], texel1[1]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel2[0], texel2[1]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel3[0], texel3[1]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG16FPixelData(0, GL_HALF_FLOAT, texel4[0], texel4[1]), |
| PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA16F => GL_RGB16F */ |
| addEntryToConversionDatabase(getRGBA16FPixelData(GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB16FPixelData(0, GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA16F => GL_RGBA16F */ |
| addEntryToConversionDatabase(getRGBA16FPixelData(GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA16FPixelData(GL_HALF_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| |
| /* GL_RGB32F */ |
| { |
| const float texel1[3] = { 1, 0, -1 }; |
| const float texel2[3] = { 4096, -4096, 127.5f }; |
| const float texel3[3] = { -32000, 32000, -456.7f }; |
| const float texel4[3] = { 1.5f, -4.7f, 123.6f }; |
| |
| /* GL_RGB32F => GL_R32F */ |
| addEntryToConversionDatabase( |
| getRGB32FPixelData(1, GL_FLOAT, texel1[0], texel1[1], texel1[2]), getR32FPixelData(0, GL_FLOAT, texel1[0]), |
| getRGB32FPixelData(1, GL_FLOAT, texel2[0], texel2[1], texel2[2]), getR32FPixelData(0, GL_FLOAT, texel2[0]), |
| getRGB32FPixelData(1, GL_FLOAT, texel3[0], texel3[1], texel3[2]), getR32FPixelData(0, GL_FLOAT, texel3[0]), |
| getRGB32FPixelData(1, GL_FLOAT, texel4[0], texel4[1], texel4[2]), getR32FPixelData(0, GL_FLOAT, texel4[0]), |
| PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGB32F => GL_RG32F */ |
| addEntryToConversionDatabase(getRGB32FPixelData(1, GL_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRG32FPixelData(0, GL_FLOAT, texel1[0], texel1[1]), |
| getRGB32FPixelData(1, GL_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRG32FPixelData(0, GL_FLOAT, texel2[0], texel2[1]), |
| getRGB32FPixelData(1, GL_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRG32FPixelData(0, GL_FLOAT, texel3[0], texel3[1]), |
| getRGB32FPixelData(1, GL_FLOAT, texel4[0], texel4[1], texel4[2]), |
| getRG32FPixelData(0, GL_FLOAT, texel4[0], texel4[1]), PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGB32F => GL_RGB32F */ |
| addEntryToConversionDatabase(getRGB32FPixelData(1, GL_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRGB32FPixelData(0, GL_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRGB32FPixelData(1, GL_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRGB32FPixelData(0, GL_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRGB32FPixelData(1, GL_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRGB32FPixelData(0, GL_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRGB32FPixelData(1, GL_FLOAT, texel4[0], texel4[1], texel4[2]), |
| getRGB32FPixelData(0, GL_FLOAT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| } |
| |
| /* GL_RGBA32F */ |
| { |
| const float texel1[4] = { 1, 0, -1, 0.25f }; |
| const float texel2[4] = { 4096, -4096, 127.5f, 0.5f }; |
| const float texel3[4] = { -32000, 32000, -456.7f, 0.75f }; |
| const float texel4[4] = { 1.5f, -4.7f, 123.6f, 1 }; |
| |
| /* GL_RGBA32F => GL_R32F */ |
| addEntryToConversionDatabase(getRGBA32FPixelData(GL_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getR32FPixelData(0, GL_FLOAT, texel1[0]), |
| getRGBA32FPixelData(GL_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getR32FPixelData(0, GL_FLOAT, texel2[0]), |
| getRGBA32FPixelData(GL_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getR32FPixelData(0, GL_FLOAT, texel3[0]), |
| getRGBA32FPixelData(GL_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getR32FPixelData(0, GL_FLOAT, texel4[0]), PIXEL_COMPARE_CHANNEL_R); |
| |
| /* GL_RGBA32F => GL_RG32F */ |
| addEntryToConversionDatabase(getRGBA32FPixelData(GL_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRG32FPixelData(0, GL_FLOAT, texel1[0], texel1[1]), |
| getRGBA32FPixelData(GL_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRG32FPixelData(0, GL_FLOAT, texel2[0], texel2[1]), |
| getRGBA32FPixelData(GL_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRG32FPixelData(0, GL_FLOAT, texel3[0], texel3[1]), |
| getRGBA32FPixelData(GL_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRG32FPixelData(0, GL_FLOAT, texel4[0], texel4[1]), PIXEL_COMPARE_CHANNEL_RG); |
| |
| /* GL_RGBA32F => GL_RGB32F */ |
| addEntryToConversionDatabase(getRGBA32FPixelData(GL_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGB32FPixelData(0, GL_FLOAT, texel1[0], texel1[1], texel1[2]), |
| getRGBA32FPixelData(GL_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGB32FPixelData(0, GL_FLOAT, texel2[0], texel2[1], texel2[2]), |
| getRGBA32FPixelData(GL_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGB32FPixelData(0, GL_FLOAT, texel3[0], texel3[1], texel3[2]), |
| getRGBA32FPixelData(GL_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGB32FPixelData(0, GL_FLOAT, texel4[0], texel4[1], texel4[2]), |
| PIXEL_COMPARE_CHANNEL_RGB); |
| |
| /* GL_RGBA32F => GL_RGBA32F */ |
| addEntryToConversionDatabase(getRGBA32FPixelData(GL_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA32FPixelData(GL_FLOAT, texel1[0], texel1[1], texel1[2], texel1[3]), |
| getRGBA32FPixelData(GL_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA32FPixelData(GL_FLOAT, texel2[0], texel2[1], texel2[2], texel2[3]), |
| getRGBA32FPixelData(GL_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA32FPixelData(GL_FLOAT, texel3[0], texel3[1], texel3[2], texel3[3]), |
| getRGBA32FPixelData(GL_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| getRGBA32FPixelData(GL_FLOAT, texel4[0], texel4[1], texel4[2], texel4[3]), |
| PIXEL_COMPARE_CHANNEL_RGBA); |
| } |
| } |
| |
| class TestBase : public deqp::TestCase |
| { |
| public: |
| TestBase(deqp::Context& context, GLenum source_attachment_type, GLenum destination_attachment_type); |
| virtual ~TestBase(); |
| |
| protected: |
| bool getFormatAndTypeCompatibleWithInternalformat(GLenum internalformat, int index, GLenum* out_format, |
| GLenum* out_type) const; |
| bool getFormatForInternalformat(GLenum internalformat, GLenum* out_format) const; |
| GLenum getFBOEffectiveInternalFormatAtIndex(unsigned int index) const; |
| GLenum getCopyTexImage2DInternalFormatAtIndex(unsigned int index) const; |
| const char* getTargetName(GLenum target) const; |
| GLenum getGeneralTargetForDetailedTarget(GLenum target); |
| |
| GLuint generateGLObject(GLenum object_type); |
| bool configureGLObject(int is_source_gl_object, GLenum object_target, GLint object_id, GLenum internal_format, |
| GLenum format, GLenum type, void* data); |
| void destroyGLObject(GLenum target, GLuint object_id); |
| |
| bool isValidRBOInternalFormat(GLenum internalformat) const; |
| bool isColorRenderableInternalFormat(GLenum internalformat) const; |
| bool isDepthRenderableInternalFormat(GLenum internalformat) const; |
| bool isDepthStencilRenderableInternalFormat(GLenum internalformat) const; |
| bool isFBOEffectiveInternalFormatCompatibleWithDestinationInternalFormat(GLenum src_internalformat, |
| GLenum dst_internalformat) const; |
| const char* getInternalformatString(GLenum internalformat); |
| |
| protected: |
| GLenum m_source_attachment_type; |
| GLenum m_destination_attachment_type; |
| }; |
| |
| TestBase::TestBase(deqp::Context& context, GLenum source_attachment_type, GLenum destination_attachment_type) |
| : deqp::TestCase(context, "", "") |
| , m_source_attachment_type(source_attachment_type) |
| , m_destination_attachment_type(destination_attachment_type) |
| { |
| static std::map<GLenum, std::string> attachment_name_map; |
| if (attachment_name_map.empty()) |
| { |
| attachment_name_map[GL_TEXTURE_2D] = "texture2d"; |
| attachment_name_map[GL_TEXTURE_CUBE_MAP_NEGATIVE_X] = "cubemap_negx"; |
| attachment_name_map[GL_TEXTURE_CUBE_MAP_NEGATIVE_Y] = "cubemap_negy"; |
| attachment_name_map[GL_TEXTURE_CUBE_MAP_NEGATIVE_Z] = "cubemap_negz"; |
| attachment_name_map[GL_TEXTURE_CUBE_MAP_POSITIVE_X] = "cubemap_posx"; |
| attachment_name_map[GL_TEXTURE_CUBE_MAP_POSITIVE_Y] = "cubemap_posy"; |
| attachment_name_map[GL_TEXTURE_CUBE_MAP_POSITIVE_Z] = "cubemap_posz"; |
| attachment_name_map[GL_TEXTURE_2D_ARRAY] = "texture_array"; |
| attachment_name_map[GL_TEXTURE_3D] = "texture3d"; |
| attachment_name_map[GL_RENDERBUFFER] = "renderbuffer"; |
| } |
| |
| m_name = attachment_name_map[m_source_attachment_type] + "_" + attachment_name_map[m_destination_attachment_type]; |
| } |
| |
| TestBase::~TestBase() |
| { |
| } |
| |
| /** For every valid GLES internalformat, gl.readPixels() can often work with a variety of different |
| * format+type combinations. This function allows to enumerate valid pairs for user-specified |
| * internal formats. |
| * |
| * Enumeration should start from 0 and continue until the function starts reporting failure. |
| * |
| * @param internalformat GLES internal format to consider. |
| * @param index Index of format+type pair to look up. |
| * @param out_format Deref will be used to store compatible GLES format. Cannot be NULL. |
| * @param out_type Deref will be used to store compatible GLES type. Cannot be NULL. |
| * |
| * @return true if successful and relevant format & type information has been stored under |
| * dereferences of corresponding arguments, false otherwise. |
| **/ |
| bool TestBase::getFormatAndTypeCompatibleWithInternalformat(GLenum internalformat, int index, GLenum* out_format, |
| GLenum* out_type) const |
| { |
| const glu::ContextInfo& contextInfo = m_context.getContextInfo(); |
| bool is_ext_texture_storage_supported = contextInfo.isExtensionSupported("GL_EXT_texture_storage"); |
| bool is_ext_texture_type_2_10_10_10_rev_supported = |
| contextInfo.isExtensionSupported("GL_EXT_texture_type_2_10_10_10_REV"); |
| |
| DE_ASSERT(out_format != NULL); |
| DE_ASSERT(out_type != NULL); |
| |
| if (!getFormatForInternalformat(internalformat, out_format)) |
| TCU_FAIL("No format known for requested internalformat"); |
| |
| switch (internalformat) |
| { |
| case GL_ALPHA: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_LUMINANCE: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R8: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_LUMINANCE_ALPHA: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG8: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_SRGB: |
| case GL_RGB: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else if (index == 1) |
| *out_type = GL_UNSIGNED_SHORT_5_6_5; |
| else if (index == 2) |
| *out_type = GL_UNSIGNED_INT_2_10_10_10_REV; |
| else if (index == 3) |
| *out_type = GL_HALF_FLOAT; |
| else if (index == 4) |
| *out_type = GL_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_SRGB8: |
| case GL_RGB8: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB565: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_SHORT_5_6_5; |
| else if (index == 1) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else if (index == 1) |
| *out_type = GL_UNSIGNED_SHORT_4_4_4_4; |
| else if (index == 2) |
| *out_type = GL_UNSIGNED_SHORT_5_5_5_1; |
| else if (index == 3) |
| *out_type = GL_HALF_FLOAT; |
| else if (index == 4) |
| *out_type = GL_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA4: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_SHORT_4_4_4_4; |
| else if (index == 1) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB5_A1: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_SHORT_5_5_5_1; |
| else if (index == 1) |
| *out_type = GL_UNSIGNED_BYTE; |
| else if (index == 2) |
| *out_type = GL_UNSIGNED_INT_2_10_10_10_REV; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA8: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB10_A2: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_INT_2_10_10_10_REV; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB10_A2UI: |
| { |
| if (index == 0) |
| { |
| *out_type = GL_UNSIGNED_INT_2_10_10_10_REV; |
| } /* if (index == 0) */ |
| else |
| { |
| return false; |
| } |
| |
| break; |
| } |
| |
| case GL_SRGB8_ALPHA8: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R8I: |
| { |
| if (index == 0) |
| *out_type = GL_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R8UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R16I: |
| { |
| if (index == 0) |
| *out_type = GL_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R16UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R32I: |
| { |
| if (index == 0) |
| *out_type = GL_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R32UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG8I: |
| { |
| if (index == 0) |
| *out_type = GL_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG8UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG16I: |
| { |
| if (index == 0) |
| *out_type = GL_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG16UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG32I: |
| { |
| if (index == 0) |
| *out_type = GL_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG32UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB8I: |
| { |
| if (index == 0) |
| *out_type = GL_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB8UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB16I: |
| { |
| if (index == 0) |
| *out_type = GL_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB16UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB32I: |
| { |
| if (index == 0) |
| *out_type = GL_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB32UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA8I: |
| { |
| if (index == 0) |
| *out_type = GL_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA8UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_BYTE; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA16I: |
| { |
| if (index == 0) |
| *out_type = GL_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA16UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_SHORT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA32I: |
| { |
| if (index == 0) |
| *out_type = GL_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA32UI: |
| { |
| if (index == 0) |
| *out_type = GL_UNSIGNED_INT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R16F: |
| { |
| if (index == 0) |
| *out_type = GL_HALF_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG16F: |
| { |
| if (index == 0) |
| *out_type = GL_HALF_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_R32F: |
| { |
| if (index == 0) |
| *out_type = GL_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RG32F: |
| { |
| if (index == 0) |
| *out_type = GL_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB16F: |
| { |
| if (index == 0) |
| *out_type = GL_HALF_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA16F: |
| { |
| if (index == 0) |
| *out_type = GL_HALF_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB32F: |
| { |
| if (index == 0) |
| *out_type = GL_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGBA32F: |
| { |
| if (index == 0) |
| *out_type = GL_FLOAT; |
| else |
| return false; |
| break; |
| } |
| |
| case GL_RGB10_EXT: |
| { |
| if (index == 0) |
| { |
| if (is_ext_texture_type_2_10_10_10_rev_supported && is_ext_texture_storage_supported) |
| { |
| *out_type = GL_UNSIGNED_INT_2_10_10_10_REV; |
| } /* if (is_ext_texture_type_2_10_10_10_rev_supported) */ |
| else |
| { |
| return false; |
| } |
| } /* if (index == 0) */ |
| else |
| { |
| return false; |
| } |
| break; |
| } |
| |
| case GL_ALPHA8_EXT: |
| { |
| // TODO: No extension available at the time of writing. |
| return false; |
| } |
| |
| case GL_LUMINANCE8_EXT: |
| { |
| // TODO: No extension available at the time of writing. |
| return false; |
| } |
| |
| case GL_LUMINANCE8_ALPHA8_EXT: |
| { |
| // TODO: No extension available at the time of writing. |
| return false; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unsupported internalformat"); |
| } |
| } // switch (internalformat) |
| |
| return true; |
| } |
| |
| /** Retrieves GLES format compatible for user-specified GLES internal format. |
| * |
| * @param internalformat GLES internalformat to consider. |
| * @param out_format Deref will be used to store the result. Cannot be NULL. |
| * |
| * @return true if successful, false otherwise. |
| **/ |
| bool TestBase::getFormatForInternalformat(GLenum internalformat, GLenum* out_format) const |
| { |
| DE_ASSERT(out_format != NULL); |
| |
| // Find out the format for user-provided internalformat |
| switch (internalformat) |
| { |
| case GL_ALPHA: |
| *out_format = GL_ALPHA; |
| break; |
| |
| case GL_LUMINANCE_ALPHA: |
| *out_format = GL_LUMINANCE_ALPHA; |
| break; |
| |
| case GL_LUMINANCE: |
| case GL_LUMINANCE8_OES: |
| *out_format = GL_LUMINANCE; |
| break; |
| |
| case GL_R8: |
| case GL_R8_SNORM: |
| case GL_R16F: |
| case GL_R32F: |
| *out_format = GL_RED; |
| break; |
| |
| case GL_R8UI: |
| case GL_R8I: |
| case GL_R16UI: |
| case GL_R16I: |
| case GL_R32UI: |
| case GL_R32I: |
| *out_format = GL_RED_INTEGER; |
| break; |
| |
| case GL_RG8: |
| case GL_RG8_SNORM: |
| case GL_RG16F: |
| case GL_RG32F: |
| *out_format = GL_RG; |
| break; |
| |
| case GL_RG8UI: |
| case GL_RG8I: |
| case GL_RG16UI: |
| case GL_RG16I: |
| case GL_RG32UI: |
| case GL_RG32I: |
| *out_format = GL_RG_INTEGER; |
| break; |
| |
| case GL_RGB: |
| case GL_RGB8: |
| case GL_SRGB8: |
| case GL_RGB565: |
| case GL_RGB8_SNORM: |
| case GL_R11F_G11F_B10F: |
| case GL_RGB9_E5: |
| case GL_RGB16F: |
| case GL_RGB32F: |
| *out_format = GL_RGB; |
| break; |
| |
| case GL_RGB8UI: |
| case GL_RGB8I: |
| case GL_RGB16UI: |
| case GL_RGB16I: |
| case GL_RGB32UI: |
| case GL_RGB32I: |
| *out_format = GL_RGB_INTEGER; |
| break; |
| |
| case GL_RGBA: |
| case GL_RGBA8: |
| case GL_SRGB8_ALPHA8: |
| case GL_RGBA8_SNORM: |
| case GL_RGB5_A1: |
| case GL_RGBA4: |
| case GL_RGB10_A2: |
| case GL_RGBA16F: |
| case GL_RGBA32F: |
| *out_format = GL_RGBA; |
| break; |
| |
| case GL_RGBA8UI: |
| case GL_RGBA8I: |
| case GL_RGB10_A2UI: |
| case GL_RGBA16UI: |
| case GL_RGBA16I: |
| case GL_RGBA32I: |
| case GL_RGBA32UI: |
| *out_format = GL_RGBA_INTEGER; |
| break; |
| |
| case GL_DEPTH_COMPONENT16: |
| case GL_DEPTH_COMPONENT24: |
| case GL_DEPTH_COMPONENT32F: |
| *out_format = GL_DEPTH_COMPONENT; |
| break; |
| |
| case GL_DEPTH24_STENCIL8: |
| case GL_DEPTH32F_STENCIL8: |
| *out_format = GL_DEPTH_STENCIL; |
| break; |
| |
| default: |
| TCU_FAIL("Internalformat not recognized"); |
| return false; |
| } // switch (internalformat) |
| |
| return true; |
| } |
| |
| /** Retrieves FBO effective internal format at user-specified index. |
| * |
| * Pays extra care not to reach outside of fbo_effective_internal_format_ordering array. |
| * |
| * @param index Index to look up the internal format at. |
| * |
| * @return Requested information or GL_NONE if failed or 0xFFFFFFFF if index is |
| * outside allowed range. |
| **/ |
| GLenum TestBase::getFBOEffectiveInternalFormatAtIndex(unsigned int index) const |
| { |
| const unsigned int n_effective_internalformats = DE_LENGTH_OF_ARRAY(fboEffectiveInternalFormatOrdering); |
| |
| DE_ASSERT(index < n_effective_internalformats); |
| if (index < n_effective_internalformats) |
| return fboEffectiveInternalFormatOrdering[index]; |
| |
| // Return glitch |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "GetFBOEffectiveInternalFormatAtIndex - Invalid index requested: " << index |
| << tcu::TestLog::EndMessage; |
| |
| return static_cast<GLenum>(0xFFFFFFFF); |
| } |
| |
| /** Retrieves glCopyTexImage2D() internal format at user-specified index. |
| * |
| * Pays extra care not to reach outside of copy_tex_image_2d_internal_format_orderingarray. |
| * |
| * @param index Index to look up the internal format at. |
| * |
| * @return Requested information or GL_NONE if failed or 0xFFFFFFFF if index is outside |
| * allowed range. |
| **/ |
| GLenum TestBase::getCopyTexImage2DInternalFormatAtIndex(unsigned int index) const |
| { |
| const unsigned int n_internalformats = DE_LENGTH_OF_ARRAY(copyTexImage2DInternalFormatOrdering); |
| |
| DE_ASSERT(index < n_internalformats); |
| if (index < n_internalformats) |
| return copyTexImage2DInternalFormatOrdering[index]; |
| |
| // Return glitch |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "GetCopyTexImage2DInternalFormatAtIndex - Invalid index requested: " << index |
| << tcu::TestLog::EndMessage; |
| |
| return static_cast<GLenum>(0xFFFFFFFF); |
| } |
| |
| /** Retrieves a string representing name of target passed by argument. |
| * |
| * @param target GLES target to retrieve a string for. |
| * |
| * @return A relevant string or "?" (without double quotation marks) |
| * if type is unrecognized. |
| **/ |
| const char* TestBase::getTargetName(GLenum target) const |
| { |
| const char* result = "?"; |
| |
| switch (target) |
| { |
| case GL_RENDERBUFFER: |
| result = "GL_RENDERBUFFER"; |
| break; |
| case GL_TEXTURE_2D: |
| result = "GL_TEXTURE_2D"; |
| break; |
| case GL_TEXTURE_2D_ARRAY: |
| result = "GL_TEXTURE_2D_ARRAY"; |
| break; |
| case GL_TEXTURE_3D: |
| result = "GL_TEXTURE_3D"; |
| break; |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| result = "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"; |
| break; |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| result = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"; |
| break; |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| result = "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"; |
| break; |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| result = "GL_TEXTURE_CUBE_MAP_POSITIVE_X"; |
| break; |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| result = "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"; |
| break; |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| result = "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"; |
| break; |
| } |
| |
| return result; |
| } |
| |
| /** Returns a general texture target for cube-map texture targets or |
| * user-specified target otherwise. |
| * |
| * @param target GLES target to consider. Allowed values: |
| * 1) GL_RENDERBUFFER, |
| * 2) GL_TEXTURE_2D, |
| * 3) GL_TEXTURE_2D_ARRAY, |
| * 4) GL_TEXTURE_3D, |
| * 5) GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| * 6) GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| * 7) GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| * 8) GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| * 9) GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| * 10) GL_TEXTURE_CUBE_MAP_POSITIVE_Z. |
| * |
| * @return General texture target or used-specified target |
| * if successful, GL_NONE otherwise. |
| */ |
| GLenum TestBase::getGeneralTargetForDetailedTarget(GLenum target) |
| { |
| GLenum result = GL_NONE; |
| |
| switch (target) |
| { |
| case GL_RENDERBUFFER: |
| case GL_TEXTURE_2D: |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_3D: |
| { |
| result = target; |
| |
| break; |
| } // renderbuffer & 2D/3D texture targets |
| |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| { |
| result = GL_TEXTURE_CUBE_MAP; |
| |
| break; |
| } // cube-map texture targets |
| |
| default: |
| { |
| TCU_FAIL("Unrecognized target"); |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Generates a GL object of an user-requested type. |
| * |
| * NOTE: It is expected no error is reported by OpenGL ES prior to |
| * the call. |
| * |
| * @param object_type Type of a GL object to create. Allowed values: |
| * 1) GL_RENDERBUFFER, |
| * 2) GL_TEXTURE_2D, |
| * 3) GL_TEXTURE_2D_ARRAY, |
| * 4) GL_TEXTURE_3D, |
| * 5) GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| * 6) GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| * 7) GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| * 8) GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| * 9) GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| * 10) GL_TEXTURE_CUBE_MAP_POSITIVE_Z. |
| * |
| * @return GLES ID (different than zero) of the created object if |
| * successful, zero otherwise. |
| */ |
| GLuint TestBase::generateGLObject(GLenum object_type) |
| { |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLenum error_code = GL_NO_ERROR; |
| GLuint result = 0; |
| |
| switch (object_type) |
| { |
| case GL_RENDERBUFFER: |
| { |
| gl.genRenderbuffers(1, &result); |
| break; |
| } |
| |
| case GL_TEXTURE_2D: |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_3D: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| { |
| gl.genTextures(1, &result); |
| break; |
| } |
| |
| default: |
| TCU_FAIL("Unsupported source attachment type"); |
| } |
| |
| // check if all is good with our new object |
| error_code = gl.getError(); |
| |
| if (error_code != GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Could not generate a renderbuffer OR texture object. GL reported error: [" << error_code |
| << "]" << tcu::TestLog::EndMessage; |
| return 0; |
| } |
| |
| return result; |
| } |
| |
| /** Sets up a GL object and binds it to either GL_DRAW_FRAMEBUFFER |
| * (if @param is_source_gl_object is 0) or GL_READ_FRAMEBUFFER zeroth |
| * color attachment. |
| * |
| * NOTE: The function assumes the object at @param object_id of @param |
| * object_target type has already been generated! |
| * |
| * @param is_source_gl_object 1 if the object should be bound to |
| * GL_DRAW_FRAMEBUFFER target once configured, |
| * 0 to bound the object to GL_READ_FRAMEBUFFER |
| * target instead. |
| * @param object_target Type of the object to configure. Allowed values: |
| * 1) GL_RENDERBUFFER, |
| * 2) GL_TEXTURE_2D, |
| * 3) GL_TEXTURE_2D_ARRAY, |
| * 4) GL_TEXTURE_3D, |
| * 5) GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| * 6) GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| * 7) GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| * 8) GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| * 9) GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| * 10) GL_TEXTURE_CUBE_MAP_POSITIVE_Z. |
| * @param object_id GLES ID of the object to configure. |
| * @param internal_format Internal-format of the data under @param data. |
| * @param format Format of the data under @param data. |
| * @param type Type the data @param data is represented with. |
| * @param data Buffer with the data to fill the object with. |
| * Cannot be NULL. |
| * |
| * @return true if successful, false otherwise., |
| **/ |
| bool TestBase::configureGLObject(int is_source_gl_object, GLenum object_target, GLint object_id, GLenum internal_format, |
| GLenum format, GLenum type, void* data) |
| { |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| GLenum fbo_target = (is_source_gl_object == 0) ? GL_DRAW_FRAMEBUFFER : GL_READ_FRAMEBUFFER; |
| bool result = true; |
| |
| // Special case for GL_HALF_FLOAT -> input data is in GL_FLOAT |
| if (type == GL_HALF_FLOAT) |
| type = GL_FLOAT; |
| |
| switch (object_target) |
| { |
| case GL_RENDERBUFFER: |
| { |
| GLint current_draw_fbo_id = 0; |
| GLint current_read_fbo_id = 0; |
| GLuint temporary_draw_fbo_id = 0; |
| GLuint temporary_read_fbo_id = 0; |
| GLuint temporary_to_id = 0; |
| |
| // Retrieve current draw/read fbo bindings |
| gl.getIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, ¤t_draw_fbo_id); |
| gl.getIntegerv(GL_READ_FRAMEBUFFER_BINDING, ¤t_read_fbo_id); |
| |
| // Set up the RBO */ |
| gl.bindRenderbuffer(GL_RENDERBUFFER, object_id); |
| gl.renderbufferStorage(GL_RENDERBUFFER, internal_format, TEXTURE_WIDTH, TEXTURE_HEIGHT); |
| |
| // Generate a temporary 2D texture object and copy the data into it |
| gl.genTextures(1, &temporary_to_id); |
| gl.bindTexture(GL_TEXTURE_2D, temporary_to_id); |
| gl.texImage2D(GL_TEXTURE_2D, 0 /* level */, internal_format, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0 /* border */, |
| format, type, data); |
| |
| // Set up a temporary read FBO with the texture object attached to zeroth color attachment.. |
| gl.genFramebuffers(1, &temporary_read_fbo_id); |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, temporary_read_fbo_id); |
| gl.framebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, temporary_to_id, |
| 0 /* level */); |
| |
| // and another one we'll bind to draw framebuffer target with the renderbuffer object attached |
| gl.genFramebuffers(1, &temporary_draw_fbo_id); |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, temporary_draw_fbo_id); |
| gl.framebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, object_id); |
| |
| // Blit the texture contents into the renderbuffer. |
| gl.blitFramebuffer(0 /* srcX0 */, 0 /* srcY0 */, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0 /* dstX0 */, 0 /* dstY0 */, |
| TEXTURE_WIDTH, TEXTURE_HEIGHT, GL_COLOR_BUFFER_BIT, GL_NEAREST); |
| |
| // Restore pre-call configuration |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, current_draw_fbo_id); |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, current_read_fbo_id); |
| |
| // Get rid of the temporary objects |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| gl.deleteTextures(1, &temporary_to_id); |
| gl.deleteFramebuffers(1, &temporary_draw_fbo_id); |
| gl.deleteFramebuffers(1, &temporary_read_fbo_id); |
| |
| // Update the pre-call framebuffer's attachment configuration |
| gl.framebufferRenderbuffer(fbo_target, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, object_id); |
| break; |
| } |
| |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| { |
| const GLenum cm_targets[] = { GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z }; |
| GLenum general_target = getGeneralTargetForDetailedTarget(object_target); |
| unsigned int n_cm_target = 0; |
| |
| // Set up base mipmap for our source texture. |
| gl.bindTexture(general_target, object_id); |
| |
| // Set up *all* faces of a cube-map (as per Bugzilla #9689 & #9807), |
| // so that the CM texture is cube complete. |
| for (n_cm_target = 0; n_cm_target < sizeof(cm_targets) / sizeof(cm_targets[0]); ++n_cm_target) |
| { |
| gl.texImage2D(cm_targets[n_cm_target], 0 /* level */, internal_format, TEXTURE_WIDTH, TEXTURE_HEIGHT, |
| 0 /* border */, format, type, data); |
| } |
| |
| gl.texParameterf(general_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.texParameterf(general_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.texParameterf(general_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl.texParameterf(general_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| // Set up the FBO attachment |
| if (is_source_gl_object) |
| gl.framebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0, object_target, object_id, 0); |
| |
| gl.bindTexture(general_target, 0); |
| break; |
| } |
| |
| case GL_TEXTURE_2D: |
| { |
| // Set up base mipmap for our source texture. |
| gl.bindTexture(object_target, object_id); |
| gl.texImage2D(object_target, 0 /* level */, internal_format, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0 /* border */, |
| format, type, data); |
| |
| gl.texParameterf(object_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.texParameterf(object_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.texParameterf(object_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl.texParameterf(object_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| // Set up the FBO attachment |
| if (is_source_gl_object) |
| gl.framebufferTexture2D(fbo_target, GL_COLOR_ATTACHMENT0, object_target, object_id, 0); |
| |
| gl.bindTexture(object_target, 0); |
| break; |
| } |
| |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_3D: |
| { |
| // Set up base mipmap for our source texture. |
| gl.bindTexture(object_target, object_id); |
| gl.texImage3D(object_target, 0 /* level */, internal_format, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, |
| 0 /* border */, format, type, NULL); |
| gl.texSubImage3D(object_target, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 1 /* zoffset */, TEXTURE_WIDTH, |
| TEXTURE_HEIGHT, 1 /* depth */, format, type, data); |
| |
| gl.texParameterf(object_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.texParameterf(object_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.texParameterf(object_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl.texParameterf(object_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| gl.texParameterf(object_target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); |
| |
| DE_ASSERT(is_source_gl_object); |
| |
| // Set up the FBO attachment. Make sure there is an actual difference from gl.framebufferTexture2D() |
| // and use the second layer of the texture. |
| gl.framebufferTextureLayer(fbo_target, GL_COLOR_ATTACHMENT0, object_id, 0 /* level */, 1 /* layer */); |
| |
| gl.bindTexture(object_target, 0); |
| break; |
| } |
| |
| default: |
| { |
| // ASSERTION FAILURE: unsupported source attachment type |
| DE_ASSERT(0); |
| result = false; |
| } |
| } /* switch (source_attachment_type) */ |
| |
| if (result) |
| { |
| GLenum error_code = gl.getError(); |
| |
| if (error_code != GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Could not set up a GL object [" |
| << (is_source_gl_object ? "source" : "destination") << "] of format [" |
| << getInternalformatString(internal_format) << "] to be used as " |
| << getTargetName(object_target) << " attachment for the test. GL reported error [" |
| << error_code << "]"; |
| return false; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Releases a GL object. If @param target represents a texture, |
| * the object is unbound from the target prior to a gl.deleteTextures() |
| * call. |
| * |
| * @param target Type of the object to release. Allowed values: |
| * 1) GL_RENDERBUFFER, |
| * 2) GL_TEXTURE_2D, |
| * 3) GL_TEXTURE_2D_ARRAY, |
| * 4) GL_TEXTURE_3D, |
| * 5) GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| * 6) GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| * 7) GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| * 8) GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| * 9) GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| * 10) GL_TEXTURE_CUBE_MAP_POSITIVE_Z. |
| * |
| * @param object_id GLES ID of the object to release. |
| */ |
| void TestBase::destroyGLObject(GLenum target, GLuint object_id) |
| { |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| switch (target) |
| { |
| case GL_RENDERBUFFER: |
| { |
| gl.bindRenderbuffer(GL_RENDERBUFFER, 0); |
| gl.deleteRenderbuffers(1, &object_id); |
| break; |
| } |
| |
| case GL_TEXTURE_2D: |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_3D: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| { |
| GLenum general_attachment_type = getGeneralTargetForDetailedTarget(target); |
| gl.bindTexture(general_attachment_type, 0); |
| gl.deleteTextures(1, &object_id); |
| break; |
| } |
| |
| default: |
| { |
| TCU_FAIL("Unsupported attachment type."); |
| } |
| } |
| } |
| |
| /** Tells whether @param internalformat can be used for |
| * a gl.renderbufferStorage*() call. |
| * |
| * @param internalformat Internalformat to consider. |
| * |
| * @return true if the internal format can be used for the call, |
| * false otherwise. |
| **/ |
| bool TestBase::isValidRBOInternalFormat(GLenum internalformat) const |
| { |
| // Internal format can be used for gl.renderbufferStorage() |
| // call if it's either color-, depth- or stencil-renderable. |
| return isColorRenderableInternalFormat(internalformat) || isDepthRenderableInternalFormat(internalformat) || |
| isDepthStencilRenderableInternalFormat(internalformat); |
| } |
| |
| /** Tells whether internal format @param internalformat is color-renderable. |
| * |
| * @param internalformat GLES internal format to consider. |
| * |
| * @return true if @param internalformat is color-renderable, false otherwise |
| **/ |
| bool TestBase::isColorRenderableInternalFormat(GLenum internalformat) const |
| { |
| const glu::ContextInfo& contextInfo = m_context.getContextInfo(); |
| |
| bool supports_fp_textures = contextInfo.isExtensionSupported("GL_EXT_color_buffer_float"); |
| bool supports_half_fp_textures = contextInfo.isExtensionSupported("GL_EXT_color_buffer_half_float"); |
| |
| // Floating-point textures are only supported if |
| // implementation supports GL_EXT_color_buffer_float extension |
| if (!supports_fp_textures && (internalformat == GL_R32F || internalformat == GL_RG32F || |
| internalformat == GL_RGB32F || internalformat == GL_RGBA32F)) |
| { |
| return false; |
| } |
| |
| // Half floating-point textures are only supported if |
| // implementation supports GL_EXT_color_buffer_half_float extension |
| if (!supports_half_fp_textures && (internalformat == GL_R16F || internalformat == GL_RG16F || |
| internalformat == GL_RGB16F || internalformat == GL_RGBA16F)) |
| { |
| return false; |
| } |
| |
| switch (internalformat) |
| { |
| case GL_RGB: |
| case GL_RGBA: |
| case GL_R8: |
| case GL_RG8: |
| case GL_RGB8: |
| case GL_RGB565: |
| case GL_RGBA4: |
| case GL_RGB5_A1: |
| case GL_RGBA8: |
| case GL_RGB10_A2: |
| case GL_RGB10_A2UI: |
| case GL_SRGB8_ALPHA8: |
| case GL_R8I: |
| case GL_R8UI: |
| case GL_R16I: |
| case GL_R16UI: |
| case GL_R32I: |
| case GL_R32UI: |
| case GL_RG8I: |
| case GL_RG8UI: |
| case GL_RG16I: |
| case GL_RG16UI: |
| case GL_RG32I: |
| case GL_RG32UI: |
| case GL_RGBA8I: |
| case GL_RGBA8UI: |
| case GL_RGBA16I: |
| case GL_RGBA16UI: |
| case GL_RGBA32I: |
| case GL_RGBA32UI: |
| // GLES3.0 color-renderable internalformats |
| return true; |
| |
| case GL_R16F: |
| case GL_R32F: |
| case GL_RG16F: |
| case GL_RG32F: |
| case GL_RGB16F: |
| // GL_RGB32F not supported |
| case GL_RGBA16F: |
| case GL_RGBA32F: |
| // Since we passed the above checks, we can assume |
| // the internalformats are color-renderable |
| return true; |
| |
| default: |
| return false; |
| } |
| |
| return false; |
| } |
| |
| /** Tells whether internal format @param internalformat is depth-renderable. |
| * |
| * @param internalformat GLES internal format to consider. |
| * |
| * @return true if @param internalformat is depth-renderable, false otherwise |
| **/ |
| bool TestBase::isDepthRenderableInternalFormat(GLenum internalformat) const |
| { |
| switch (internalformat) |
| { |
| case GL_DEPTH_COMPONENT16: |
| case GL_DEPTH_COMPONENT24: |
| case GL_DEPTH_COMPONENT32F: |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Tells whether internal format @param internalformat is depth+stencil-renderable. |
| * |
| * @param internalformat GLES internal format to consider. |
| * |
| * @return true if @param internalformat is depth+stencil-renderable, false otherwise |
| **/ |
| bool TestBase::isDepthStencilRenderableInternalFormat(GLenum internalformat) const |
| { |
| switch (internalformat) |
| { |
| case GL_DEPTH24_STENCIL8: |
| case GL_DEPTH32F_STENCIL8: |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Tells whether OpenGL ES 3.0 implementations should accept copying texture image data from |
| * a read buffer using @param src_internalformat internalformat-based storage to a texture object |
| * using an internal format @param dst_internalformat. |
| * |
| * @param src_internalformat Internal format to be used for source object's data storage. |
| * @param dst_internalformat Internal format to be used for destination texture object's data storage. |
| * |
| * @return true if the operation is expected to execute successfully, false otherwise. |
| */ |
| bool TestBase::isFBOEffectiveInternalFormatCompatibleWithDestinationInternalFormat(GLenum src_internalformat, |
| GLenum dst_internalformat) const |
| { |
| const unsigned int n_copyteximage_internalformats = DE_LENGTH_OF_ARRAY(copyTexImage2DInternalFormatOrdering); |
| unsigned int n_dst_internalformat = 0; |
| const unsigned int n_effective_internalformats = DE_LENGTH_OF_ARRAY(fboEffectiveInternalFormatOrdering); |
| unsigned int n_src_internalformat = 0; |
| bool result = false; |
| |
| // Find out which index does the source internalformat use |
| while (n_src_internalformat < n_effective_internalformats) |
| { |
| GLenum internalformat_at_n = getFBOEffectiveInternalFormatAtIndex(n_src_internalformat); |
| |
| if (internalformat_at_n == src_internalformat) |
| break; |
| else |
| ++n_src_internalformat; |
| } |
| |
| DE_ASSERT(n_src_internalformat != n_effective_internalformats); |
| if (n_src_internalformat == n_effective_internalformats) |
| return false; |
| |
| // Find out which index does the target internalformat use |
| while (n_dst_internalformat < n_copyteximage_internalformats) |
| { |
| GLenum internalformat_at_n = getCopyTexImage2DInternalFormatAtIndex(n_dst_internalformat); |
| |
| if (internalformat_at_n == dst_internalformat) |
| break; |
| else |
| ++n_dst_internalformat; |
| } |
| |
| DE_ASSERT(n_dst_internalformat != n_copyteximage_internalformats); |
| if (n_dst_internalformat == n_copyteximage_internalformats) |
| return false; |
| |
| // Find out if the conversion is allowed |
| unsigned int conversion_array_index = n_copyteximage_internalformats * n_src_internalformat + n_dst_internalformat; |
| |
| DE_ASSERT(conversion_array_index < (sizeof(conversionArray) / sizeof(GLenum))); |
| if (conversion_array_index < (sizeof(conversionArray) / sizeof(GLenum))) |
| result = (conversionArray[conversion_array_index] != GL_NONE); |
| |
| return result; |
| } |
| |
| /** Retrieves a string representing name of internal format passed by argument. |
| * |
| * @param internalformat GLES internal format to retrieve a string for. |
| * |
| * @return A relevant string or "?" (without double quotation marks) |
| * if type is unrecognized. |
| **/ |
| const char* TestBase::getInternalformatString(GLenum internalformat) |
| { |
| switch (internalformat) |
| { |
| case GL_ALPHA: |
| return "GL_ALPHA"; |
| case GL_ALPHA8_OES: |
| return "GL_ALPHA8"; |
| case GL_LUMINANCE: |
| return "GL_LUMINANCE"; |
| case GL_LUMINANCE8_OES: |
| return "GL_LUMINANCE8"; |
| case GL_LUMINANCE8_ALPHA8_OES: |
| return "GL_LUMINANCE8_ALPHA8"; |
| case GL_LUMINANCE_ALPHA: |
| return "GL_LUMINANCE_ALPHA"; |
| case GL_R11F_G11F_B10F: |
| return "GL_R11F_G11F_B10F"; |
| case GL_R16F: |
| return "GL_R16F"; |
| case GL_R16I: |
| return "GL_R16I"; |
| case GL_R16UI: |
| return "GL_R16UI"; |
| case GL_R32F: |
| return "GL_R32F"; |
| case GL_R32I: |
| return "GL_R32I"; |
| case GL_R32UI: |
| return "GL_R32UI"; |
| case GL_R8: |
| return "GL_R8"; |
| case GL_R8I: |
| return "GL_R8I"; |
| case GL_R8UI: |
| return "GL_R8UI"; |
| case GL_R8_SNORM: |
| return "GL_R8_SNORM"; |
| case GL_RG16F: |
| return "GL_RG16F"; |
| case GL_RG16I: |
| return "GL_RG16I"; |
| case GL_RG16UI: |
| return "GL_RG16UI"; |
| case GL_RG32F: |
| return "GL_RG32F"; |
| case GL_RG32I: |
| return "GL_RG32I"; |
| case GL_RG32UI: |
| return "GL_RG32UI"; |
| case GL_RG8: |
| return "GL_RG8"; |
| case GL_RG8I: |
| return "GL_RG8I"; |
| case GL_RG8UI: |
| return "GL_RG8UI"; |
| case GL_RG8_SNORM: |
| return "GL_RG8_SNORM"; |
| case GL_RGB: |
| return "GL_RGB"; |
| case GL_RGB10_A2: |
| return "GL_RGB10_A2"; |
| case GL_RGB10_A2UI: |
| return "GL_RGB10_A2UI"; |
| case GL_RGB16F: |
| return "GL_RGB16F"; |
| case GL_RGB16I: |
| return "GL_RGB16I"; |
| case GL_RGB16UI: |
| return "GL_RGB16UI"; |
| case GL_RGB32F: |
| return "GL_RGB32F"; |
| case GL_RGB32I: |
| return "GL_RGB32I"; |
| case GL_RGB32UI: |
| return "GL_RGB32UI"; |
| case GL_RGB5_A1: |
| return "GL_RGB5_A1"; |
| case GL_RGB8: |
| return "GL_RGB8"; |
| case GL_RGB8I: |
| return "GL_RGB8I"; |
| case GL_RGB8UI: |
| return "GL_RGB8UI"; |
| case GL_RGB8_SNORM: |
| return "GL_RGB8_SNORM"; |
| case GL_RGB9_E5: |
| return "GL_RGB9_E5"; |
| case GL_RGBA: |
| return "GL_RGBA"; |
| case GL_RGBA16I: |
| return "GL_RGBA16I"; |
| case GL_RGBA16UI: |
| return "GL_RGBA16UI"; |
| case GL_RGBA4: |
| return "GL_RGBA4"; |
| case GL_RGBA32I: |
| return "GL_RGBA32I"; |
| case GL_RGBA32UI: |
| return "GL_RGBA32UI"; |
| case GL_RGBA8I: |
| return "GL_RGBA8I"; |
| case GL_RGBA8UI: |
| return "GL_RGBA8UI"; |
| case GL_RGB565: |
| return "GL_RGB565"; |
| case GL_RGBA16F: |
| return "GL_RGBA16F"; |
| case GL_RGBA32F: |
| return "GL_RGBA32F"; |
| case GL_RGBA8: |
| return "GL_RGBA8"; |
| case GL_RGBA8_SNORM: |
| return "GL_RGBA8_SNORM"; |
| case GL_SRGB8: |
| return "GL_SRGB8"; |
| case GL_SRGB8_ALPHA8: |
| return "GL_SRGB8_ALPHA8"; |
| } |
| |
| return "GL_NONE"; |
| } |
| |
| /* SPECIFICATION: |
| * |
| * This conformance test verifies that glCopyTexImage2D() implementation accepts |
| * internalformats that are compatible with effective internalformat of current |
| * read buffer. |
| * |
| * The test starts from creating two framebuffer objects, that it accordingly binds |
| * to GL_DRAW_FRAMEBUFFER and GL_READ_FRAMEBUFFER targets. It then enters two-level loop: |
| * |
| * a) First level determines source attachment type: this could either be a 2D texture/cube-map |
| * face mip-map, a specific mip-map of a slice coming from a 2D texture array OR a 3D texture, |
| * or finally a render-buffer. All of these can be bound to an attachment point that is |
| * later pointed to by read buffer configuration. |
| * b) Second level configures attachment type of destination. Since glCopyTexImage2D() |
| * specification limits accepted targets, only 2D texture or cube-map face targets are |
| * accepted. |
| * |
| * For each viable source/destination configuration, the test then enters another two-level loop: |
| * |
| * I) First sub-level determines what internal format should be used for the source attachment. |
| * All texture formats required from a conformant GLES3.0 implementation are iterated over. |
| * II) Second sub-level determines internal format that should be passed as a parameter to |
| * a glCopyTexImage2D() call. |
| * |
| * For each internal format pair, the test creates and configures a corresponding GL object and |
| * attaches it to the read framebuffer. The test also uses a pre-generated texture object ID that |
| * will be re-configured with each glCopyTexImage2D() call. |
| * |
| * Source data is a 2x2 array consisting of up to 4 channels with different values, represented |
| * in an iteration-specific format and type. For more details, please see implementation of |
| * ConfigureConversionDatabase() entry-point. |
| * |
| * The test then loops over all supported format+type combinations for the internal-format considered |
| * and feeds them into actual glCopyTexImage2D() call. It is against the specification for the call |
| * to fail at this point. Should this be the case, the test is considered to fail but will continue |
| * iterating over all the loops to make sure all problems are reported within a single run. |
| * |
| * Once the call is determined to have finished successfully, the test attempts to read the result data. |
| * This needs to be handled in two ways: |
| * |
| * - if internalformat is color-renderable, we can attach the result texture to the read framebuffer object |
| * and do a glReadPixels() call. For some combinations of internalformat and attachment types the implementations |
| * are allowed to report unsupported framebuffer configuration, in which case the test will proceed with testing |
| * remaining source/destination/internalformat combinations and will not consider this an error. |
| * - if internalformat is not color-renderable, we need to bind the result texture to a texture unit and |
| * use a program object to determine whether the data made available are valid. THIS CASE IS NOT IMPLEMENTED |
| * YET! |
| * |
| * Once the data are downloaded, they are compared against reference texture data. Should the rendered output |
| * diverge outside the allowed epsilon, the test will report an error but will continue iterating to make sure |
| * all source/destination/internalformat combinations are covered. |
| */ |
| class RequiredCase : public TestBase |
| { |
| public: |
| RequiredCase(deqp::Context& context, de::SharedPtr<ConversionDatabase> database, GLenum sourceAttachmentTypes, |
| GLenum destinationAttachmentTypes); |
| virtual ~RequiredCase(); |
| |
| void deinit(void); |
| tcu::TestNode::IterateResult iterate(void); |
| |
| protected: |
| bool execute(GLenum src_internalformat, GLenum dst_internalformat, |
| NonRenderableInternalformatSupportObjects* objects_ptr); |
| bool bindTextureToTargetToSpecificTextureUnit(GLuint to_id, GLenum texture_target, GLenum texture_unit); |
| bool setUniformValues(GLint source_2D_texture_uniform_location, GLenum source_2D_texture_unit, |
| GLint source_2DArray_texture_uniform_location, GLenum source_2DArray_texture_unit, |
| GLint source_3D_texture_uniform_location, GLenum source_3D_texture_unit, |
| GLint source_Cube_texture_uniform_location, GLenum source_Cube_texture_unit, |
| GLint destination_2D_texture_uniform_location, GLenum destination_2D_texture_unit, |
| GLint destination_Cube_texture_uniform_location, GLenum destination_Cube_texture_unit, |
| GLint channels_to_compare_uniform_location, GLint channels_to_compare, |
| GLint samplers_to_use_uniform_location, GLint samplers_to_use); |
| bool copyDataFromBufferObject(GLuint bo_id, std::vector<GLint>& retrieved_data); |
| bool findEntryInConversionDatabase(unsigned int index, GLenum src_internalformat, GLenum src_type, |
| GLenum copyteximage2d_internalformat, GLenum* out_result_internalformat, |
| GLenum* out_dst_type, PixelData* out_src_topleft, PixelData* out_src_topright, |
| PixelData* out_src_bottomleft, PixelData* out_src_bottomright, |
| PixelData* out_dst_topleft, PixelData* out_dst_topright, |
| PixelData* out_dst_bottomleft, PixelData* out_dst_bottomright, |
| PixelCompareChannel* out_channels_to_compare); |
| int getIndexOfCopyTexImage2DInternalFormat(GLenum internalformat); |
| int getIndexOfFramebufferEffectiveInternalFormat(GLenum internalformat); |
| bool compareExpectedResultsByReadingPixels(PixelData source_tl_pixel_data, PixelData source_tr_pixel_data, |
| PixelData source_bl_pixel_data, PixelData source_br_pixel_data, |
| PixelData reference_tl_pixel_data, PixelData reference_tr_pixel_data, |
| PixelData reference_bl_pixel_data, PixelData reference_br_pixel_data, |
| GLenum read_type, GLenum result_internalformat); |
| unsigned int getSizeOfPixel(GLenum format, GLenum type); |
| bool getPixelDataFromRawData(void* raw_data, GLenum raw_data_format, GLenum raw_data_type, PixelData* out_result); |
| bool comparePixelData(PixelData downloaded_pixel, PixelData reference_pixel, PixelData source_pixel, |
| GLenum result_internalformat, bool has_test_failed_already); |
| bool getNumberOfBitsForInternalFormat(GLenum internalformat, int* out_rgba_bits); |
| |
| bool getRawDataFromPixelData(std::vector<char>& result, PixelData topleft, PixelData topright, PixelData bottomleft, |
| PixelData bottomright); |
| bool getNumberOfBitsForChannelDataType(ChannelDataType channel_data_type, int* out_n_bits); |
| |
| bool getChannelOrderForInternalformatAndType(GLenum internalformat, GLenum type, ChannelOrder* out_channel_order); |
| bool generateObjectsToSupportNonColorRenderableInternalformats(); |
| bool prepareSupportForNonRenderableTexture(NonRenderableInternalformatSupportObjects& objects, |
| DataSamplerType src_texture_sampler_type, |
| DataSamplerType dst_texture_sampler_type, GLenum source_attachment_type, |
| GLenum destination_attachment_type); |
| bool calculateBufferDataSize(DataSamplerType sampler_type, GLuint* buffer_data_size_ptr); |
| const float* getTexCoordinates(GLenum attachment_type) const; |
| bool prepareProgramAndShaderObjectsToSupportNonRenderableTexture(GLuint program_object_id, |
| GLuint fragment_shader_object_id, |
| GLuint vertex_shader_object_id, |
| DataSamplerType src_texture_sampler_type, |
| DataSamplerType dst_texture_sampler_type); |
| bool setSourceForShaderObjectsUsedForNonRenderableTextureSupport(GLuint fragment_shader_object_id, |
| GLuint vertex_shader_object_id, |
| DataSamplerType src_texture_sampler_type, |
| DataSamplerType dst_texture_sampler_type); |
| bool compileAndCheckShaderCompilationStatus(GLuint shader_object_id); |
| bool linkAndCheckProgramLinkStatus(GLuint program_object_id); |
| bool getUniformLocations(GLuint program_object_id, GLint* source_2D_texture_uniform_location_ptr, |
| GLint* source_2DArray_texture_uniform_location_ptr, |
| GLint* source_3D_texture_uniform_location_ptr, |
| GLint* source_Cube_texture_uniform_location_ptr, |
| GLint* destination_2D_texture_uniform_location_ptr, |
| GLint* destination_Cube_texture_uniform_location_ptr, |
| GLint* channels_to_compare_uniform_location_ptr, |
| GLint* samplers_to_use_uniform_location_ptr); |
| void displayPixelComparisonFailureMessage(GLint source_pixel_r, GLint source_pixel_g, GLint source_pixel_b, |
| GLint source_pixel_a, GLenum source_internalformat, GLenum source_type, |
| GLint reference_pixel_r, GLint reference_pixel_g, GLint reference_pixel_b, |
| GLint reference_pixel_a, GLenum reference_internalformat, |
| GLenum reference_type, GLint result_pixel_r, GLint result_pixel_g, |
| GLint result_pixel_b, GLint result_pixel_a, GLenum result_internalformat, |
| GLenum result_type, GLint max_epsilon_r, GLint max_epsilon_g, |
| GLint max_epsilon_b, GLint max_epsilon_a); |
| DataSamplerType getDataSamplerTypeForInternalformat(GLenum internalformat); |
| bool isInternalFormatCompatibleWithFPSampler(GLenum internalformat); |
| bool isInternalFormatCompatibleWithIntegerSampler(GLenum internalformat); |
| bool isInternalFormatCompatibleWithUnsignedIntegerSampler(GLenum internalformat); |
| void destroyObjectsSupportingNonRenderableInternalformats(NonRenderableInternalformatSupportObjects& objects); |
| void unbindAndDestroyBufferObject(GLuint bo_id); |
| void destroyTransformFeedbackObject(GLuint transform_feedback_object_id); |
| void destroyProgramAndShaderObjects(GLuint program_object_id, GLuint fragment_shader_id, GLuint vertex_shader_id); |
| void unbindColorAttachments(); |
| void restoreBindings(GLenum src_attachment_point, GLenum dst_attachment_point, GLint bound_draw_fbo_id, |
| GLint bound_read_fbo_id); |
| |
| private: |
| GLuint m_dst_object_id; |
| GLuint m_src_object_id; |
| |
| de::SharedPtr<ConversionDatabase> m_conversion_database; |
| |
| // Some of the internalformats considered during the test are not renderable, meaning |
| // we cannot use glReadPixels() to retrieve their contents. |
| // Instead, a special program object needs to be used to perform the verification in |
| // actual shader. |
| // We create a program object for possible each float/int/uint->float/int/uint combination. |
| // All objects created during the process are stored in a dedicated |
| // _non_renderable_internalformat_support_objects instance and released once the test ends. |
| NonRenderableInternalformatSupportObjects m_f_src_f_dst_internalformat; |
| NonRenderableInternalformatSupportObjects m_i_src_i_dst_internalformat; |
| NonRenderableInternalformatSupportObjects m_ui_src_ui_dst_internalformat; |
| }; |
| |
| RequiredCase::RequiredCase(deqp::Context& context, de::SharedPtr<ConversionDatabase> database, |
| GLenum sourceAttachmentTypes, GLenum destinationAttachmentTypes) |
| : TestBase(context, sourceAttachmentTypes, destinationAttachmentTypes) |
| , m_dst_object_id(0) |
| , m_src_object_id(0) |
| , m_conversion_database(database) |
| { |
| deMemset(&m_f_src_f_dst_internalformat, 0, sizeof(m_f_src_f_dst_internalformat)); |
| deMemset(&m_i_src_i_dst_internalformat, 0, sizeof(m_i_src_i_dst_internalformat)); |
| deMemset(&m_ui_src_ui_dst_internalformat, 0, sizeof(m_ui_src_ui_dst_internalformat)); |
| } |
| |
| RequiredCase::~RequiredCase() |
| { |
| } |
| |
| void RequiredCase::deinit(void) |
| { |
| // free shared pointer |
| m_conversion_database.clear(); |
| |
| // Release the source object before we continue |
| if (m_src_object_id != 0) |
| { |
| destroyGLObject(m_source_attachment_type, m_src_object_id); |
| |
| m_src_object_id = 0; |
| } |
| |
| if (m_dst_object_id != 0) |
| { |
| destroyGLObject(m_destination_attachment_type, m_dst_object_id); |
| |
| m_dst_object_id = 0; |
| } |
| |
| destroyObjectsSupportingNonRenderableInternalformats(m_f_src_f_dst_internalformat); |
| destroyObjectsSupportingNonRenderableInternalformats(m_i_src_i_dst_internalformat); |
| destroyObjectsSupportingNonRenderableInternalformats(m_ui_src_ui_dst_internalformat); |
| } |
| |
| tcu::TestNode::IterateResult RequiredCase::iterate(void) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| GLuint draw_fbo_id = 0; |
| GLuint read_fbo_id = 0; |
| gl.genFramebuffers(1, &draw_fbo_id); |
| gl.genFramebuffers(1, &read_fbo_id); |
| |
| gl.bindTexture(GL_TEXTURE_2D, 0); |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, draw_fbo_id); |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, read_fbo_id); |
| |
| // We will be reading from zeroth color attachment |
| gl.readBuffer(GL_COLOR_ATTACHMENT0); |
| |
| // Make sure the pixel storage is configured accordingly to our data sets! |
| gl.pixelStorei(GL_UNPACK_ALIGNMENT, 1); |
| gl.pixelStorei(GL_PACK_ALIGNMENT, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei"); |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| |
| // Sanity checks |
| DE_ASSERT(m_destination_attachment_type == GL_TEXTURE_2D || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_X || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_X || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_Y || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_Z); |
| |
| // Determine general attachment type |
| GLenum general_attachment_type = getGeneralTargetForDetailedTarget(m_source_attachment_type); |
| if (general_attachment_type == GL_NONE) |
| return STOP; |
| |
| // Set up source object |
| m_src_object_id = generateGLObject(m_source_attachment_type); |
| if (m_src_object_id == 0) |
| return STOP; |
| |
| // Set up destination object |
| m_dst_object_id = generateGLObject(m_destination_attachment_type); |
| if (m_dst_object_id == 0) |
| return STOP; |
| |
| // Generate all objects required to execute the non-renderable internalformat tests. |
| // Can't use the shader on GL_RENDERBUFFER as source. |
| if (m_source_attachment_type != GL_RENDERBUFFER && !generateObjectsToSupportNonColorRenderableInternalformats()) |
| { |
| return STOP; |
| } |
| |
| m_conversion_database.get()->initializeDatabase(); |
| |
| // Run through all FBO internal formats. |
| bool result = true; |
| const int n_dst_internal_formats = DE_LENGTH_OF_ARRAY(copyTexImage2DInternalFormatOrdering); |
| const int n_fbo_internal_formats = DE_LENGTH_OF_ARRAY(fboEffectiveInternalFormatOrdering); |
| for (int n_fbo_internal_format = 0; n_fbo_internal_format < n_fbo_internal_formats; ++n_fbo_internal_format) |
| { |
| GLenum fbo_internalformat = fboEffectiveInternalFormatOrdering[n_fbo_internal_format]; |
| |
| // Run through all destination internal formats. |
| for (int n_dst_internal_format = 0; n_dst_internal_format < n_dst_internal_formats; ++n_dst_internal_format) |
| { |
| GLenum dst_internalformat = copyTexImage2DInternalFormatOrdering[n_dst_internal_format]; |
| |
| switch (getDataSamplerTypeForInternalformat(fbo_internalformat)) |
| { |
| case DATA_SAMPLER_FLOAT: |
| { |
| switch (getDataSamplerTypeForInternalformat(dst_internalformat)) |
| { |
| case DATA_SAMPLER_FLOAT: |
| { |
| if (!execute(fbo_internalformat, dst_internalformat, &m_f_src_f_dst_internalformat)) |
| { |
| // At least one conversion was invalid or failed. Test should fail, |
| // but let's continue iterating over internalformats. |
| result = false; |
| } |
| |
| break; |
| } |
| |
| case DATA_SAMPLER_INTEGER: |
| case DATA_SAMPLER_UNSIGNED_INTEGER: |
| { |
| // There shouldn't be any valid conversion formats in this case. Just pass NULL for the non-renderable case's objects. |
| // The test will fail if we try to verify the copy for different data type formats |
| if (!execute(fbo_internalformat, dst_internalformat, NULL)) |
| { |
| // At least one conversion was invalid or failed. Test should |
| // fail, but let's continue iterating over internalformats. |
| result = false; |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| // Unrecognized destination internalformat |
| DE_ASSERT(0); |
| break; |
| } |
| } // switch (GetDataSamplerTypeForInternalformat(dst_internalformat) ) |
| |
| break; |
| } |
| |
| case DATA_SAMPLER_INTEGER: |
| { |
| switch (getDataSamplerTypeForInternalformat(dst_internalformat)) |
| { |
| case DATA_SAMPLER_INTEGER: |
| { |
| if (!execute(fbo_internalformat, dst_internalformat, &m_i_src_i_dst_internalformat)) |
| { |
| // At least one conversion was invalid or failed. Test should fail, |
| // but let's continue iterating over internalformats. |
| result = false; |
| } |
| |
| break; |
| } |
| |
| case DATA_SAMPLER_FLOAT: |
| case DATA_SAMPLER_UNSIGNED_INTEGER: |
| { |
| // There shouldn't be any valid conversion formats in this case. Just pass NULL for the non-renderable case's objects. |
| // The test will fail if we try to verify the copy for different data type formats |
| if (!execute(fbo_internalformat, dst_internalformat, NULL)) |
| { |
| // At least one conversion was invalid or failed. Test should fail, |
| // but let's continue iterating over internalformats. |
| result = false; |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| // Unrecognized destination internalformat |
| DE_ASSERT(0); |
| |
| break; |
| } |
| } // switch (GetDataSamplerTypeForInternalformat(dst_internalformat) ) |
| |
| break; |
| } // case DATA_SAMPLER_INTEGER: |
| |
| case DATA_SAMPLER_UNSIGNED_INTEGER: |
| { |
| switch (getDataSamplerTypeForInternalformat(dst_internalformat)) |
| { |
| case DATA_SAMPLER_UNSIGNED_INTEGER: |
| { |
| if (!execute(fbo_internalformat, dst_internalformat, &m_ui_src_ui_dst_internalformat)) |
| { |
| // At least one conversion was invalid or failed. Test should fail, |
| // but let's continue iterating over internalformats. |
| result = false; |
| } |
| |
| break; |
| } |
| |
| case DATA_SAMPLER_FLOAT: |
| case DATA_SAMPLER_INTEGER: |
| { |
| // There shouldn't be any valid conversion formats in this case. Just pass NULL for the non-renderable case's objects. |
| // The test will fail if we try to verify the copy for different data type formats |
| if (!execute(fbo_internalformat, dst_internalformat, NULL)) |
| { |
| // At least one conversion was invalid or failed. Test should fail, |
| // but let's continue iterating over internalformats. |
| result = false; |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| // Unrecognized destination internalformat? |
| DE_ASSERT(0); |
| break; |
| } |
| } // switch (GetDataSamplerTypeForInternalformat(dst_internalformat) ) |
| |
| break; |
| } // case DATA_SAMPLER_UNSIGNED_INTEGER |
| |
| default: |
| { |
| // Unrecognized source internalformat |
| DE_ASSERT(0); |
| break; |
| } |
| } // switch (GetDataSamplerTypeForInternalformat(fbo_internalformat) ) |
| } // for (all destination internalformats) |
| } // for (all FBO internalformats) |
| |
| if (result) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| return STOP; |
| } |
| |
| /** This function verifies if glCopyTexImage2D() implementation performs conversions as |
| * per GLES3.0.3 spec, and that the result data is valid. For more detailed description, |
| * please see specification of copy_tex_image_conversions_required conformance test. |
| * |
| * @param conversion_database Conversion database handle. Cannot be NULL. |
| * @param source_attachment_type Tells what GL object (or which texture target) |
| * should be used as a read buffer for |
| * a glCopyTexImage2D) call. Allowed values: |
| * 1) GL_TEXTURE_2D, |
| * 2) GL_TEXTURE_2D_ARRAY, |
| * 3) GL_TEXTURE_3D, |
| * 4) GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| * 5) GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| * 6) GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| * 7) GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| * 8) GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| * 9) GL_TEXTURE_CUBE_MAP_POSITIVE_Z. |
| * @param destination_attachment_type Tells which texture target should be used for |
| * a glCopyTexImage2D() call. Allowed values: |
| * 1) GL_TEXTURE_2D, |
| * 2) GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| * 3) GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| * 4) GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| * 5) GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| * 6) GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| * 7) GL_TEXTURE_CUBE_MAP_POSITIVE_Z. |
| * @param src_internalformat GLES internalformat that read buffer should use. |
| * @param dst_internalformat GLES internalformat that should be used for glReadPixels() call. |
| * This should NOT be the expected effective internalformat! |
| * @param objects_ptr Deref where generated object ids are stored |
| * (objects which were generated to support non-color-renderable internalformats). |
| * Cannot be NULL. |
| * |
| * @return true if successful, false otherwise. |
| */ |
| bool RequiredCase::execute(GLenum src_internalformat, GLenum dst_internalformat, |
| NonRenderableInternalformatSupportObjects* objects_ptr) |
| { |
| GLenum fbo_completeness = GL_NONE; |
| GLenum general_destination_attachment_type = GL_NONE; |
| int n_format_type_pair = 0; |
| GLenum src_format = GL_NONE; |
| GLenum src_type = GL_NONE; |
| |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // If we're using a renderbuffer as a source, make sure the internalformat |
| // we'll try to use to store data in it is actually renderable |
| if (m_destination_attachment_type == GL_RENDERBUFFER && !isValidRBOInternalFormat(src_internalformat)) |
| return true; |
| |
| // Only accept source internal formats that are color renderable |
| if (!isColorRenderableInternalFormat(src_internalformat)) |
| return true; |
| |
| // Retrieve general destination attachment type before we continue |
| if ((general_destination_attachment_type = getGeneralTargetForDetailedTarget(m_destination_attachment_type)) == |
| GL_NONE) |
| { |
| return false; |
| } |
| |
| // Good. Check if the conversion is required - if so, we can run the test! |
| if (!isFBOEffectiveInternalFormatCompatibleWithDestinationInternalFormat(src_internalformat, dst_internalformat)) |
| return true; |
| |
| bool result = true; |
| std::vector<char> fbo_data(4); |
| |
| // Try using all compatible format+type pairs |
| while (getFormatAndTypeCompatibleWithInternalformat(src_internalformat, n_format_type_pair, &src_format, &src_type)) |
| { |
| // Try to find a rule in the conversion database, so that we know what data we should fill |
| // the source attachment with. |
| // There may be many entries for a single source internal format + type pair, so |
| // iterate until the find() function fails. |
| GLenum effective_internalformat = GL_NONE; |
| int n_conversion_rule = 0; |
| PixelData result_bottomleft_pixel_data; |
| PixelData result_bottomright_pixel_data; |
| PixelData result_topleft_pixel_data; |
| PixelData result_topright_pixel_data; |
| GLenum result_type = GL_NONE; |
| PixelData src_bottomleft_pixel_data; |
| PixelData src_bottomright_pixel_data; |
| PixelData src_topleft_pixel_data; |
| PixelData src_topright_pixel_data; |
| PixelCompareChannel channels_to_compare; |
| |
| while (findEntryInConversionDatabase( |
| n_conversion_rule, src_internalformat, src_type, dst_internalformat, &effective_internalformat, |
| &result_type, &src_topleft_pixel_data, &src_topright_pixel_data, &src_bottomleft_pixel_data, |
| &src_bottomright_pixel_data, &result_topleft_pixel_data, &result_topright_pixel_data, |
| &result_bottomleft_pixel_data, &result_bottomright_pixel_data, &channels_to_compare)) |
| { |
| #if 0 |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Testing [src " |
| << getInternalformatString(src_internalformat) |
| << " " << glu::getTypeStr(src_type).toString() |
| << "]=>[" << getInternalformatString(dst_internalformat) << "effective: " |
| << getInternalformatString(effective_internalformat) << "] read with type: [" |
| << glu::getTypeStr(result_type).toString() << ", src target: [" << GetTargetName(m_source_attachment_type) |
| << "], dst target: " << GetTargetName(m_destination_attachment_type) |
| << tcu::TestLog::EndMessage; |
| #endif |
| |
| // Retrieve source data we can have uploaded to the source attachment |
| if (!getRawDataFromPixelData(fbo_data, src_topleft_pixel_data, src_topright_pixel_data, |
| src_bottomleft_pixel_data, src_bottomright_pixel_data)) |
| { |
| unbindColorAttachments(); |
| return false; |
| } |
| |
| // Set up source attachment |
| if (!configureGLObject(1, m_source_attachment_type, m_src_object_id, src_internalformat, src_format, |
| src_type, &fbo_data[0])) |
| { |
| unbindColorAttachments(); |
| return false; |
| } |
| |
| // Make sure the source FBO configuration is supported. |
| fbo_completeness = gl.checkFramebufferStatus(GL_READ_FRAMEBUFFER); |
| |
| if (fbo_completeness != GL_FRAMEBUFFER_COMPLETE) |
| { |
| if (fbo_completeness == GL_FRAMEBUFFER_UNSUPPORTED) |
| { |
| // The implementation does not allow us to use source data built using this internal-format, |
| // using this particular attachment type. Break out of the loop, there's no need to carry on |
| // trying. |
| break; |
| } |
| else |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "FBO error - incompleteness reason [" |
| << fbo_completeness << "]" << tcu::TestLog::EndMessage; |
| |
| // This should never happen. Consider test failed |
| unbindColorAttachments(); |
| return false; |
| } |
| } |
| |
| // Ask the implementation to perform the conversion! |
| switch (m_destination_attachment_type) |
| { |
| case GL_TEXTURE_2D: |
| { |
| gl.bindTexture(m_destination_attachment_type, m_dst_object_id); |
| |
| gl.copyTexImage2D(m_destination_attachment_type, 0, dst_internalformat, 0 /* x */, 0 /* y */, |
| TEXTURE_WIDTH, TEXTURE_HEIGHT, 0 /* border */); |
| |
| gl.texParameterf(m_destination_attachment_type, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.texParameterf(m_destination_attachment_type, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.texParameterf(m_destination_attachment_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl.texParameterf(m_destination_attachment_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| gl.bindTexture(m_destination_attachment_type, 0); |
| |
| break; |
| } |
| |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| { |
| unsigned int j = 0; |
| GLuint dst_format, dst_type; |
| |
| getFormatAndTypeCompatibleWithInternalformat(dst_internalformat, 0, &dst_format, &dst_type); |
| |
| gl.bindTexture(general_destination_attachment_type, m_dst_object_id); |
| |
| // Initialize all faces so that the texture is CM complete |
| // It's needed in case we need to use a shader to verify the copy operation |
| for (j = GL_TEXTURE_CUBE_MAP_POSITIVE_X; j <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z; j++) |
| { |
| if (j == m_destination_attachment_type) |
| { |
| // Do the copy to the destination face |
| gl.copyTexImage2D(j, 0, dst_internalformat, 0 /* x */, 0 /* y */, TEXTURE_WIDTH, TEXTURE_HEIGHT, |
| 0 /* border */); |
| } |
| else |
| { |
| // Clear the remaining faces to catch "copy to the wrong face" errors |
| static std::vector<char> zero_data(TEXTURE_WIDTH * TEXTURE_HEIGHT * 4 * sizeof(float), 0); |
| gl.texImage2D(j, 0, dst_internalformat, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0, dst_format, dst_type, |
| &zero_data[0]); |
| } |
| } |
| |
| gl.texParameterf(general_destination_attachment_type, GL_TEXTURE_MIN_FILTER, GL_NEAREST); |
| gl.texParameterf(general_destination_attachment_type, GL_TEXTURE_MAG_FILTER, GL_NEAREST); |
| gl.texParameterf(general_destination_attachment_type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); |
| gl.texParameterf(general_destination_attachment_type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); |
| |
| gl.bindTexture(general_destination_attachment_type, 0); |
| |
| break; |
| } // cube-map texture target cases |
| |
| default: |
| { |
| // Unsupported destination attachment type |
| DE_ASSERT(0); |
| } |
| } // switch (destination_attachment_type) |
| |
| // Has the conversion succeeded as expected? |
| GLenum error_code = gl.getError(); |
| |
| if (error_code != GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glCopyTexImage2D() reported an error for [" |
| << getInternalformatString(src_internalformat) << "]=>[" |
| << getInternalformatString(dst_internalformat) |
| << "] internalformat conversion [target=" << getTargetName(m_source_attachment_type) |
| << "], as opposed to ES specification requirements!" << tcu::TestLog::EndMessage; |
| |
| // This test is now considered failed |
| result = false; |
| } |
| else |
| { |
| // Conversion succeeded. We now need to compare the data stored by OpenGL ES with reference data. |
| if (isColorRenderableInternalFormat(effective_internalformat)) |
| { |
| gl.framebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_destination_attachment_type, |
| m_dst_object_id, 0); |
| |
| fbo_completeness = gl.checkFramebufferStatus(GL_READ_FRAMEBUFFER); |
| if (fbo_completeness != GL_FRAMEBUFFER_COMPLETE) |
| { |
| // Per spec: |
| // Although the GL defines a wide variety of internal formats for framebuffer- |
| // attachable image, such as texture images and renderbuffer images, some imple- |
| // mentations may not support rendering to particular combinations of internal for- |
| // mats. If the combination of formats of the images attached to a framebuffer object |
| // are not supported by the implementation, then the framebuffer is not complete un- |
| // der the clause labeled FRAMEBUFFER_UNSUPPORTED. |
| if (fbo_completeness != GL_FRAMEBUFFER_UNSUPPORTED) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Framebuffer is considered incomplete [reason: " << fbo_completeness |
| << "] - cannot proceed with the test case" << tcu::TestLog::EndMessage; |
| result = false; |
| } |
| } |
| else |
| { |
| if (!compareExpectedResultsByReadingPixels( |
| src_topleft_pixel_data, src_topright_pixel_data, src_bottomleft_pixel_data, |
| src_bottomright_pixel_data, result_topleft_pixel_data, result_topright_pixel_data, |
| result_bottomleft_pixel_data, result_bottomright_pixel_data, result_type, |
| effective_internalformat)) |
| { |
| // This test is now considered failed |
| result = false; |
| } |
| } |
| gl.framebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_destination_attachment_type, 0, |
| 0); |
| } // if (IsColorRenderableInternalFormat(effective_internalformat) ) |
| else if (m_source_attachment_type != GL_RENDERBUFFER) |
| { |
| // We cannot use glReadPixels()-approach to test this internalformat. |
| // The approach to be taken for non-color-renderable internalformats will |
| // be to use a special vertex shader to verify texture data. Outcome of the |
| // comparison will be captured using transform feedback. |
| GLint bound_draw_fbo_id = 0; |
| GLint bound_read_fbo_id = 0; |
| int compare_result_index = 0; |
| std::vector<GLint> copied_compare_result_data; |
| std::vector<GLint> copied_dst_texture_data; |
| std::vector<GLint> copied_src_texture_data; |
| GLenum dst_attachment_point = GL_TEXTURE2; |
| GLenum src_attachment_point = GL_TEXTURE1; |
| GLint samplers_to_use = 0; |
| // unique sampler values |
| GLint src_2D_texture_attachment = GL_TEXTURE3; |
| GLint src_2DArray_texture_attachment = GL_TEXTURE4; |
| GLint src_3D_texture_attachment = GL_TEXTURE5; |
| GLint src_Cube_texture_attachment = GL_TEXTURE6; |
| GLint dst_2D_texture_attachment = GL_TEXTURE7; |
| GLint dst_Cube_texture_attachment = GL_TEXTURE8; |
| |
| if (m_source_attachment_type == GL_TEXTURE_2D_ARRAY) |
| { |
| samplers_to_use = TEXTURE_2D_ARRAY_SAMPLER_TYPE; |
| src_2DArray_texture_attachment = src_attachment_point; |
| } |
| else if (m_source_attachment_type == GL_TEXTURE_3D) |
| { |
| samplers_to_use = TEXTURE_3D_SAMPLER_TYPE; |
| src_3D_texture_attachment = src_attachment_point; |
| } |
| else if (m_source_attachment_type != GL_TEXTURE_2D) |
| { |
| samplers_to_use = TEXTURE_CUBE_SAMPLER_TYPE; |
| src_Cube_texture_attachment = src_attachment_point; |
| } |
| else |
| src_2D_texture_attachment = src_attachment_point; |
| |
| if (m_destination_attachment_type != GL_TEXTURE_2D) |
| { |
| samplers_to_use = (samplers_to_use | (TEXTURE_CUBE_SAMPLER_TYPE << 8)); |
| dst_Cube_texture_attachment = dst_attachment_point; |
| } |
| else |
| dst_2D_texture_attachment = dst_attachment_point; |
| |
| // We will get a NULL pointer here if src and dst data type are different |
| // (NORM -> INT, UNSIGNED INT -> INT etc.). It's not allowed by the spec. |
| if (objects_ptr == NULL) |
| { |
| m_testCtx.getLog() |
| << tcu::TestLog::Message << "Source and destination should be of the same data type - " |
| "cannot proceed with the test case" |
| << tcu::TestLog::EndMessage; |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| // Retrieve currently bound framebuffer (draw and read) object IDs. |
| // If there is any FBO bound, glDraw*() function uses it, which is not wanted in this situation. |
| // What we do here is: unbinding FBOs, issue draw calls, bind FBOs again. |
| gl.getIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &bound_draw_fbo_id); |
| gl.getIntegerv(GL_READ_FRAMEBUFFER_BINDING, &bound_read_fbo_id); |
| |
| // Use default framebuffer object for this case purposes. |
| gl.bindFramebuffer(GL_FRAMEBUFFER, 0); |
| |
| // Bind source texture object to specific texture unit. |
| if (!bindTextureToTargetToSpecificTextureUnit(m_src_object_id, m_source_attachment_type, |
| src_attachment_point)) |
| { |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| // Bind destination texture object to specific texture unit. |
| if (!bindTextureToTargetToSpecificTextureUnit(m_dst_object_id, m_destination_attachment_type, |
| dst_attachment_point)) |
| { |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| // Set active program object. |
| gl.useProgram(objects_ptr->program_object_id); |
| |
| if (!setUniformValues(objects_ptr->src_2D_texture_uniform_location, src_2D_texture_attachment, |
| objects_ptr->src_2DArray_texture_uniform_location, |
| src_2DArray_texture_attachment, objects_ptr->src_3D_texture_uniform_location, |
| src_3D_texture_attachment, objects_ptr->src_Cube_texture_uniform_location, |
| src_Cube_texture_attachment, objects_ptr->dst_2D_texture_uniform_location, |
| dst_2D_texture_attachment, objects_ptr->dst_Cube_texture_uniform_location, |
| dst_Cube_texture_attachment, |
| objects_ptr->channels_to_compare_uniform_location, channels_to_compare, |
| objects_ptr->samplers_to_use_uniform_location, samplers_to_use)) |
| { |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, COMPARISON_RESULT_BUFFER_OBJECT_INDEX, |
| objects_ptr->comparison_result_buffer_object_id); |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, SOURCE_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX, |
| objects_ptr->src_texture_pixels_buffer_object_id); |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, DESTINATION_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX, |
| objects_ptr->dst_texture_pixels_buffer_object_id); |
| |
| // Enable texture corrdinates (vertex attribs 0 & 1) |
| gl.enableVertexAttribArray(SRC_TEXTURE_COORDS_ATTRIB_INDEX); |
| gl.enableVertexAttribArray(DST_TEXTURE_COORDS_ATTRIB_INDEX); |
| |
| // Begin transform feedback operations. |
| gl.enable(GL_RASTERIZER_DISCARD); |
| |
| // Issue transform feedback operations. |
| gl.beginTransformFeedback(GL_POINTS); |
| error_code = gl.getError(); |
| if (GL_NO_ERROR != error_code) |
| { |
| m_testCtx.getLog() |
| << tcu::TestLog::Message << "An error [" << error_code |
| << "] occurred after glBeginTransformFeedback() call." << tcu::TestLog::EndMessage; |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| gl.drawArrays(GL_POINTS, 0, NUMBER_OF_POINTS_TO_DRAW); |
| |
| error_code = gl.getError(); |
| if (GL_NO_ERROR != error_code) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "An error [" << error_code |
| << "] occurred after glDrawArrays() call." << tcu::TestLog::EndMessage; |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| gl.endTransformFeedback(); |
| |
| error_code = gl.getError(); |
| if (GL_NO_ERROR != error_code) |
| { |
| m_testCtx.getLog() |
| << tcu::TestLog::Message << "An error [" << error_code |
| << "] occurred after glEndTransformFeedback() call." << tcu::TestLog::EndMessage; |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| // Restore default active program object. |
| gl.useProgram(0); |
| |
| // Make sure no error was generated at this point. |
| error_code = gl.getError(); |
| if (GL_NO_ERROR != error_code) |
| { |
| m_testCtx.getLog() |
| << tcu::TestLog::Message << "An error [" << error_code |
| << "] occurred while working with transform feedback object." << tcu::TestLog::EndMessage; |
| result = false; |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, |
| bound_read_fbo_id); |
| continue; |
| } |
| |
| gl.disable(GL_RASTERIZER_DISCARD); |
| |
| // Let's read the buffer data now. |
| copyDataFromBufferObject(objects_ptr->comparison_result_buffer_object_id, |
| copied_compare_result_data); |
| copyDataFromBufferObject(objects_ptr->src_texture_pixels_buffer_object_id, copied_src_texture_data); |
| copyDataFromBufferObject(objects_ptr->dst_texture_pixels_buffer_object_id, copied_dst_texture_data); |
| |
| // Check the results. |
| for (compare_result_index = 0; compare_result_index < NUMBER_OF_POINTS_TO_DRAW; |
| compare_result_index++) |
| { |
| if (copied_compare_result_data[compare_result_index] != 1) |
| { |
| int index_in_vec4_array = compare_result_index * NUMBER_OF_ELEMENTS_IN_VEC4; |
| |
| // Returned result indicates that textures are different. |
| // Print texture object contents as well. |
| displayPixelComparisonFailureMessage(copied_src_texture_data[index_in_vec4_array], |
| copied_src_texture_data[index_in_vec4_array + 1], |
| copied_src_texture_data[index_in_vec4_array + 2], |
| copied_src_texture_data[index_in_vec4_array + 3], |
| src_internalformat, src_type, 0, 0, 0, 0, GL_NONE, |
| GL_NONE, copied_dst_texture_data[index_in_vec4_array], |
| copied_dst_texture_data[index_in_vec4_array + 1], |
| copied_dst_texture_data[index_in_vec4_array + 2], |
| copied_dst_texture_data[index_in_vec4_array + 3], |
| dst_internalformat, result_type, 0, 0, 0, 0); |
| |
| // Report failure. |
| result = false; |
| } |
| } |
| |
| fbo_completeness = GL_FRAMEBUFFER_COMPLETE; |
| |
| restoreBindings(src_attachment_point, dst_attachment_point, bound_draw_fbo_id, bound_read_fbo_id); |
| } // if (source_attachment_type != GL_RENDERBUFFER && destination_attachment_type != GL_RENDERBUFFER) |
| } // if (no error was reported by GLES) |
| |
| n_conversion_rule++; |
| } |
| |
| // There should be at least ONE conversion rule defined |
| // for each valid FBO effective internalformat =>copyteximage2d internalformat defined! |
| // NOTE: This assertion can fail IF GLES implementation does not support particular FBO attachment combination. |
| // Make sure the check is not performed, should GL_FRAMEBUFFER_UNSUPPORTED fbo status be reported. |
| if (fbo_completeness != GL_FRAMEBUFFER_UNSUPPORTED) |
| { |
| if (n_conversion_rule == 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "No conversion rule for [src " |
| << getInternalformatString(src_internalformat) << " " |
| << glu::getTypeStr(src_type).toString() << "]=>[" |
| << getInternalformatString(dst_internalformat) |
| << "effective: " << getInternalformatString(effective_internalformat) |
| << "] read with type: [" << glu::getTypeStr(result_type).toString() |
| << ", src target: [" << getTargetName(m_source_attachment_type) |
| << "], dst target: " << getTargetName(m_destination_attachment_type) |
| << tcu::TestLog::EndMessage; |
| } |
| } |
| |
| // Check next format+type combination |
| n_format_type_pair++; |
| |
| // If we're copying from a renderbuffer, we don't really care about compatible format+type pairs, as |
| // the effective internalformat is explicitly configured by glRenderbufferStorage() call. |
| if (m_source_attachment_type == GL_RENDERBUFFER) |
| { |
| break; |
| } // if (general_attachment_type == GL_RENDERBUFFER) |
| } // while (internalformat has n-th legal format+type pair) |
| |
| unbindColorAttachments(); |
| return result; |
| } |
| |
| /** Binds texture object to a given texture target of a specified texture unit. |
| * |
| * @param to_id Valid texture object ID to be bound. |
| * @param texture_target Valid texture target to which @param to_id will be bound. |
| * @param texture_unit Texture unit to which @param to_id will be bound. |
| * |
| * @return GTFtrue if successful, GTFfalse otherwise. |
| */ |
| bool RequiredCase::bindTextureToTargetToSpecificTextureUnit(GLuint to_id, GLenum texture_target, GLenum texture_unit) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Set active texture unit. |
| gl.activeTexture(texture_unit); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture"); |
| |
| if (texture_target == GL_TEXTURE_CUBE_MAP_POSITIVE_X || texture_target == GL_TEXTURE_CUBE_MAP_NEGATIVE_X || |
| texture_target == GL_TEXTURE_CUBE_MAP_POSITIVE_Y || texture_target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y || |
| texture_target == GL_TEXTURE_CUBE_MAP_POSITIVE_Z || texture_target == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) |
| { |
| texture_target = GL_TEXTURE_CUBE_MAP; |
| } |
| |
| // Bind texture object to specific texture target of specified texture unit. |
| gl.bindTexture(texture_target, to_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture"); |
| |
| // Restore default active texture unit. |
| gl.activeTexture(GL_TEXTURE0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture"); |
| |
| return true; |
| } |
| |
| /** Sets values of uniforms, that will later be used to perform data check-up for non-renderable internalformats. |
| * |
| * @param source_2D_texture_uniform_location Location for source 2D texture sample uniform. |
| * @param source_2D_texture_unit Texture unit which the source 2D texture object is bound to. |
| * Will be used to set value for @param source_2D_texture_uniform_location. |
| * @param source_2DArray_texture_uniform_location Location for source 2DArray texture sample uniform. |
| * @param source_2DArray_texture_unit Texture unit which the source 2DArray texture object is bound to. |
| * Will be used to set value for @param source_2DArray_texture_uniform_location. |
| * @param source_3D_texture_uniform_location Location for source 3D texture sample uniform. |
| * @param source_3D_texture_unit Texture unit which the source 3D texture object is bound to. |
| * Will be used to set value for @param source_Cube_texture_uniform_location. |
| * @param source_Cube_texture_uniform_location Location for source Cube texture sample uniform. |
| * @param source_Cube_texture_unit Texture unit which the source 2D texture object is bound to. |
| * Will be used to set value for @param source_2D_texture_uniform_location. |
| * @param destination_2D_texture_uniform_location Location for destination texture sample uniform. |
| * @param destination_2D_texture_unit Texture unit which the destination texture object is bound to. |
| * Will be used to set value for @param destination_2D_texture_uniform_location. |
| * @param destination_Cube_texture_uniform_location Location for destination texture sample uniform. |
| * @param destination_Cube_texture_unit Texture unit which the destination texture object is bound to. |
| * Will be used to set value for @param destination_Cube_texture_uniform_location. |
| * @param channels_to_compare_uniform_location Location for components to compare value uniform. |
| * @param channels_to_compare Components to compare value. |
| * @param samplers_to_use_uniform_location Location for samplers to use value uniform. |
| * @param samplers_to_use samplers to use value. |
| * |
| * @return GTFtrue if the operation succeeded (no error was generated), |
| * GTFfalse otherwise. |
| */ |
| bool RequiredCase::setUniformValues(GLint source_2D_texture_uniform_location, GLenum source_2D_texture_unit, |
| GLint source_2DArray_texture_uniform_location, GLenum source_2DArray_texture_unit, |
| GLint source_3D_texture_uniform_location, GLenum source_3D_texture_unit, |
| GLint source_Cube_texture_uniform_location, GLenum source_Cube_texture_unit, |
| GLint destination_2D_texture_uniform_location, GLenum destination_2D_texture_unit, |
| GLint destination_Cube_texture_uniform_location, |
| GLenum destination_Cube_texture_unit, GLint channels_to_compare_uniform_location, |
| GLint channels_to_compare, GLint samplers_to_use_uniform_location, |
| GLint samplers_to_use) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| if (source_2D_texture_uniform_location == -1 || source_2DArray_texture_uniform_location == -1 || |
| source_3D_texture_uniform_location == -1 || source_Cube_texture_uniform_location == -1 || |
| destination_2D_texture_uniform_location == -1 || destination_Cube_texture_uniform_location == -1 || |
| channels_to_compare_uniform_location == -1 || samplers_to_use_uniform_location == -1) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Cannot set uniform values for invalid uniform locations." |
| << tcu::TestLog::EndMessage; |
| |
| return false; |
| } // if (input uniform locations are invalid) |
| |
| // We are now ready to set uniform values. |
| gl.uniform1i(destination_2D_texture_uniform_location, destination_2D_texture_unit - GL_TEXTURE0); |
| gl.uniform1i(destination_Cube_texture_uniform_location, destination_Cube_texture_unit - GL_TEXTURE0); |
| gl.uniform1i(source_2D_texture_uniform_location, source_2D_texture_unit - GL_TEXTURE0); |
| gl.uniform1i(source_2DArray_texture_uniform_location, source_2DArray_texture_unit - GL_TEXTURE0); |
| gl.uniform1i(source_3D_texture_uniform_location, source_3D_texture_unit - GL_TEXTURE0); |
| gl.uniform1i(source_Cube_texture_uniform_location, source_Cube_texture_unit - GL_TEXTURE0); |
| gl.uniform1i(channels_to_compare_uniform_location, channels_to_compare); |
| gl.uniform1i(samplers_to_use_uniform_location, samplers_to_use); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i"); |
| |
| return true; |
| } |
| |
| /** Retrieves and copies data stored in buffer object into allocated memory buffer. |
| * It is user's responsibility to free allocated memory. |
| * |
| * @param bo_id Valid buffer object ID from which data is retrieved. |
| * @param retrieved_data_ptr_ptr Deref will be used to store retrieved buffer object data. |
| * |
| * @return GTFtrue if successful, GTFfalse otherwise. |
| */ |
| bool RequiredCase::copyDataFromBufferObject(GLuint bo_id, std::vector<GLint>& retrieved_data) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| GLint buffer_size = 0; |
| gl.bindBuffer(GL_ARRAY_BUFFER, bo_id); |
| gl.getBufferParameteriv(GL_ARRAY_BUFFER, GL_BUFFER_SIZE, &buffer_size); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBufferParameteriv"); |
| |
| GLint* buffer_data_ptr = NULL; |
| buffer_data_ptr = (GLint*)gl.mapBufferRange(GL_ARRAY_BUFFER, 0, buffer_size, GL_MAP_READ_BIT); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange"); |
| |
| if (buffer_data_ptr == NULL) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Could not map buffer object." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| // Copy retrieved buffer data. |
| retrieved_data.resize(buffer_size / sizeof(GLint)); |
| std::memcpy(&retrieved_data[0], buffer_data_ptr, buffer_size); |
| |
| gl.unmapBuffer(GL_ARRAY_BUFFER); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer"); |
| |
| return true; |
| } |
| |
| /** Allocates a buffer of sufficient size to hold 2x2 texture data represented |
| * with @param read_type GL type, issues a glReadPixels() call and then compares |
| * retrieved data with reference data (provided by the caller using reference_* |
| * arguments). |
| * Should it happen that the call resulted in an indirect conversion, the function |
| * calculates an epsilon, taking differences in amount of bits that were used to |
| * represent the data during any stage of the conversion into consideration. |
| * |
| * @param source_tl_pixel_data Describes pixel data that was used to build source |
| * object's contents (top-left corner). |
| * @param source_tr_pixel_data Describes pixel data that was used to build source |
| * object's contents (top-right corner). |
| * @param source_bl_pixel_data Describes pixel data that was used to build source |
| * object's contents (bottom-left corner). |
| * @param source_br_pixel_data Describes pixel data that was used to build source |
| * object's contents (bottom-right corner). |
| * @param reference_tl_pixel_data Describes ideal result pixel data. (top-left corner). |
| * @param reference_tr_pixel_data Describes ideal result pixel data. (top-right corner). |
| * @param reference_bl_pixel_data Describes ideal result pixel data. (bottom-left corner). |
| * @param reference_br_pixel_data Describes ideal result pixel data. (bottom-right corner). |
| * @param read_type GL type that will be used for glReadPixels() call. This |
| * type should be directly related with data type used in |
| * all reference_* pixel data arguments. |
| * @param result_internalformat Effective internal-format, expected to be used by the |
| * implementation to hold destination object's data. |
| * @param src_format GL format used for source object's data storage. |
| * @param src_type GL type used for source object's data storage. |
| * @param src_attachment_type Object type or texture target of the source object. |
| * @param dst_attachment_type Object type or texture target of the destination object. |
| * |
| * @return GTFtrue if all read pixels were correct, GTFfalse otherwise |
| **/ |
| bool RequiredCase::compareExpectedResultsByReadingPixels(PixelData source_tl_pixel_data, PixelData source_tr_pixel_data, |
| PixelData source_bl_pixel_data, PixelData source_br_pixel_data, |
| PixelData reference_tl_pixel_data, |
| PixelData reference_tr_pixel_data, |
| PixelData reference_bl_pixel_data, |
| PixelData reference_br_pixel_data, GLenum read_type, |
| GLenum result_internalformat) |
| { |
| char* data_traveller_ptr = NULL; |
| int n = 0; |
| unsigned int n_bytes_per_result_pixel = 0; |
| GLenum read_format = GL_NONE; |
| bool result = true; |
| |
| PixelData* reference_pixels[] = { |
| &reference_bl_pixel_data, &reference_br_pixel_data, &reference_tl_pixel_data, &reference_tr_pixel_data, |
| }; |
| PixelData* source_pixels[] = { &source_bl_pixel_data, &source_br_pixel_data, &source_tl_pixel_data, |
| &source_tr_pixel_data }; |
| PixelData result_pixels[4]; |
| |
| // Determine which read format should be used for reading. |
| // Note that GLES3 accepts GL_RGBA_INTEGER format for GL_RGB10_A2UI internalformat |
| // and GL_RGBA for GL_RGB10_A2 - handle this in a special case. |
| if (((read_type == GL_UNSIGNED_INT_2_10_10_10_REV) && (result_internalformat == GL_RGB10_A2UI)) || |
| (read_type == GL_UNSIGNED_INT) || (read_type == GL_INT)) |
| { |
| read_format = GL_RGBA_INTEGER; |
| } |
| else |
| { |
| read_format = GL_RGBA; |
| } |
| |
| // Update read_type for GL_HALF_FLOAT |
| if (read_type == GL_HALF_FLOAT) |
| { |
| read_type = GL_FLOAT; |
| } |
| |
| // Allocate data buffer |
| n_bytes_per_result_pixel = getSizeOfPixel(read_format, read_type); |
| std::vector<char> data(TEXTURE_WIDTH * TEXTURE_HEIGHT * n_bytes_per_result_pixel); |
| |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Retrieve the data. |
| gl.readPixels(0, 0, TEXTURE_WIDTH, TEXTURE_HEIGHT, read_format, read_type, &data[0]); |
| |
| // Was the operation successful? |
| GLenum error_code = gl.getError(); |
| if (error_code != GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "glReadPixels() failed with error: [" << error_code << "]" |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| // Convert the data we read back to pixel data structures |
| data_traveller_ptr = &data[0]; |
| |
| for (n = 0; n < DE_LENGTH_OF_ARRAY(reference_pixels); ++n) |
| { |
| PixelData* result_pixel_ptr = result_pixels + n; |
| |
| if (!getPixelDataFromRawData(data_traveller_ptr, read_format, read_type, result_pixel_ptr)) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "GetPixelDataFromRawData failed!" |
| << tcu::TestLog::EndMessage; |
| |
| // Could not convert raw data to pixel data instance! |
| DE_ASSERT(0); |
| return false; |
| } // if (raw data->pixel data conversion failed) |
| |
| // Move the data traveller |
| data_traveller_ptr += n_bytes_per_result_pixel; |
| } // for (all pixels) |
| |
| // Compare each pixel with reference data. For debugging purposes, compare every single pixel, |
| // even if at least one comparison has already failed. |
| DE_ASSERT(DE_LENGTH_OF_ARRAY(reference_pixels) == DE_LENGTH_OF_ARRAY(result_pixels)); |
| |
| for (n = 0; n < DE_LENGTH_OF_ARRAY(reference_pixels); ++n) |
| { |
| result &= comparePixelData(result_pixels[n], *(reference_pixels[n]), *(source_pixels[n]), result_internalformat, |
| (result == 0)); |
| } // For each pixel |
| |
| if (result == false) |
| { |
| // Log a separator line for clarity |
| m_testCtx.getLog() << tcu::TestLog::Message << "<-- Erroneous test case finishes." << tcu::TestLog::EndMessage; |
| } |
| |
| return result; |
| } |
| |
| /** Retrieves size (expressed in bytes) of a single pixel represented by |
| * a @param format format + @param type type pair. |
| * |
| * @param format GLES format to consider. |
| * @param type GLES type to consider. |
| * |
| * @return Size of the pixel or 0 if either of the arguments was not recognized. |
| **/ |
| unsigned int RequiredCase::getSizeOfPixel(GLenum format, GLenum type) |
| { |
| int result = 0; |
| |
| switch (format) |
| { |
| case GL_RED: |
| result = 1; |
| break; |
| case GL_RED_INTEGER: |
| result = 1; |
| break; |
| case GL_RG: |
| result = 2; |
| break; |
| case GL_RG_INTEGER: |
| result = 2; |
| break; |
| case GL_RGB: |
| result = 3; |
| break; |
| case GL_RGB_INTEGER: |
| result = 3; |
| break; |
| case GL_RGBA: |
| result = 4; |
| break; |
| case GL_RGBA_INTEGER: |
| result = 4; |
| break; |
| case GL_DEPTH_COMPONENT: |
| result = 1; |
| break; |
| case GL_DEPTH_STENCIL: |
| result = 2; |
| break; |
| case GL_LUMINANCE_ALPHA: |
| result = 2; |
| break; |
| case GL_LUMINANCE: |
| result = 1; |
| break; |
| case GL_ALPHA: |
| result = 1; |
| break; |
| |
| default: |
| { |
| DE_ASSERT(0); |
| result = 0; |
| } |
| } |
| |
| switch (type) |
| { |
| case GL_UNSIGNED_BYTE: |
| result *= 1; |
| break; |
| case GL_BYTE: |
| result *= 1; |
| break; |
| case GL_UNSIGNED_SHORT: |
| result *= 2; |
| break; |
| case GL_SHORT: |
| result *= 2; |
| break; |
| case GL_UNSIGNED_INT: |
| result *= 4; |
| break; |
| case GL_INT: |
| result *= 4; |
| break; |
| case GL_HALF_FLOAT: |
| result *= 2; |
| break; |
| case GL_FLOAT: |
| result *= 4; |
| break; |
| case GL_UNSIGNED_SHORT_5_6_5: |
| result = 2; |
| break; |
| case GL_UNSIGNED_SHORT_4_4_4_4: |
| result = 2; |
| break; |
| case GL_UNSIGNED_SHORT_5_5_5_1: |
| result = 2; |
| break; |
| case GL_UNSIGNED_INT_2_10_10_10_REV: |
| result = 4; |
| break; |
| case GL_UNSIGNED_INT_10F_11F_11F_REV: |
| result = 4; |
| break; |
| case GL_UNSIGNED_INT_5_9_9_9_REV: |
| result = 4; |
| break; |
| case GL_UNSIGNED_INT_24_8: |
| result = 4; |
| break; |
| case GL_FLOAT_32_UNSIGNED_INT_24_8_REV: |
| result = 8; |
| break; |
| |
| default: |
| { |
| DE_ASSERT(0); |
| |
| result = 0; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** Takes a pointer with raw data representation and converts it to |
| * four instances of _pixel_data corresponding to four corners of a |
| * quad used for verification purposes. Assumes 2x2 resolution. |
| * |
| * @param raw_data Pointer to a buffer storing the data. |
| * @param raw_data_format Format of the data stored under @param raw_data. |
| * @param raw_data_type Type of the data stored under @param raw_data. |
| * @param out_result Deref will be used to store four _pixel_data instances. |
| * Cannot be NULL, must be capacious enough to hold four |
| * instances of the structure. |
| * |
| * @return GTFtrue if successful, GTFfalse otherwise. |
| **/ |
| bool RequiredCase::getPixelDataFromRawData(void* raw_data, GLenum raw_data_format, GLenum raw_data_type, |
| PixelData* out_result) |
| { |
| // Sanity checks: format should be equal to one of the values supported |
| // by glReadPixels() |
| DE_ASSERT(raw_data_format == GL_RGBA || raw_data_format == GL_RGBA_INTEGER); |
| |
| if (raw_data_format != GL_RGBA && raw_data_format != GL_RGBA_INTEGER) |
| { |
| return false; |
| } |
| |
| // Sanity checks: type should be equal to one of the values supported |
| // by glReadPixels() |
| DE_ASSERT(raw_data_type == GL_UNSIGNED_BYTE || raw_data_type == GL_UNSIGNED_INT || raw_data_type == GL_INT || |
| raw_data_type == GL_FLOAT || raw_data_type == GL_UNSIGNED_INT_2_10_10_10_REV_EXT); |
| |
| if (raw_data_type != GL_UNSIGNED_BYTE && raw_data_type != GL_UNSIGNED_INT && raw_data_type != GL_INT && |
| raw_data_type != GL_FLOAT && raw_data_type != GL_UNSIGNED_INT_2_10_10_10_REV_EXT) |
| { |
| return false; |
| } |
| |
| // Reset the result structure |
| deMemset(out_result, 0, sizeof(PixelData)); |
| |
| out_result->data_internalformat = raw_data_format; |
| out_result->data_type = raw_data_type; |
| |
| // Fill the fields, depending on user-provided format+type pair |
| if (raw_data_format == GL_RGBA && raw_data_type == GL_UNSIGNED_BYTE) |
| { |
| char* raw_data_ptr = reinterpret_cast<char*>(raw_data); |
| |
| out_result->alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| out_result->blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| out_result->green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| out_result->red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS; |
| |
| out_result->red.unsigned_byte_data = raw_data_ptr[0]; |
| out_result->green.unsigned_byte_data = raw_data_ptr[1]; |
| out_result->blue.unsigned_byte_data = raw_data_ptr[2]; |
| out_result->alpha.unsigned_byte_data = raw_data_ptr[3]; |
| } |
| else if (raw_data_format == GL_RGBA_INTEGER && raw_data_type == GL_UNSIGNED_INT) |
| { |
| unsigned int* raw_data_ptr = reinterpret_cast<unsigned int*>(raw_data); |
| |
| out_result->alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| out_result->blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| out_result->green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| out_result->red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS; |
| |
| out_result->red.unsigned_integer_data = raw_data_ptr[0]; |
| out_result->green.unsigned_integer_data = raw_data_ptr[1]; |
| out_result->blue.unsigned_integer_data = raw_data_ptr[2]; |
| out_result->alpha.unsigned_integer_data = raw_data_ptr[3]; |
| } |
| else if (raw_data_format == GL_RGBA_INTEGER && raw_data_type == GL_INT) |
| { |
| signed int* raw_data_ptr = reinterpret_cast<signed int*>(raw_data); |
| |
| out_result->alpha.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| out_result->blue.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| out_result->green.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| out_result->red.data_type = CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS; |
| |
| out_result->red.signed_integer_data = raw_data_ptr[0]; |
| out_result->green.signed_integer_data = raw_data_ptr[1]; |
| out_result->blue.signed_integer_data = raw_data_ptr[2]; |
| out_result->alpha.signed_integer_data = raw_data_ptr[3]; |
| } |
| else if (raw_data_format == GL_RGBA && raw_data_type == GL_FLOAT) |
| { |
| float* raw_data_ptr = reinterpret_cast<float*>(raw_data); |
| |
| out_result->alpha.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| out_result->blue.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| out_result->green.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| out_result->red.data_type = CHANNEL_DATA_TYPE_FLOAT; |
| |
| out_result->red.float_data = raw_data_ptr[0]; |
| out_result->green.float_data = raw_data_ptr[1]; |
| out_result->blue.float_data = raw_data_ptr[2]; |
| out_result->alpha.float_data = raw_data_ptr[3]; |
| } /* if (raw_data_format == GL_RGBA && raw_data_type == GL_FLOAT) */ |
| else |
| { |
| signed int* raw_data_ptr = (signed int*)raw_data; |
| |
| DE_ASSERT(raw_data_format == GL_RGBA && raw_data_type == GL_UNSIGNED_INT_2_10_10_10_REV); |
| |
| out_result->alpha.data_type = CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS; |
| out_result->blue.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| out_result->green.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| out_result->red.data_type = CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS; |
| |
| out_result->alpha.unsigned_byte_data = ((*raw_data_ptr) >> 30) & ((1 << 2) - 1); |
| out_result->blue.unsigned_short_data = ((*raw_data_ptr) >> 20) & ((1 << 10) - 1); |
| out_result->green.unsigned_short_data = ((*raw_data_ptr) >> 10) & ((1 << 10) - 1); |
| out_result->red.unsigned_short_data = ((*raw_data_ptr)) & ((1 << 10) - 1); |
| } |
| |
| return true; |
| } |
| |
| /** Checks if downloaded pixel data is valid. Should the rendered values differ |
| * outside allowed range, the function logs detailed information about the problem. |
| * |
| * @param downloaded_pixel Instance of _pixel_data describing a pixel |
| * that was rendered by the implementation. |
| * @param reference_pixel Instance of _pixel_data describing ideal |
| * pixel data. |
| * @param source_pixel Instance of _pixel_data describing the pixel |
| * prior to conversion. |
| * @param result_internalformat Internal format the implementation is expected |
| * to be using for the converted data. |
| * @param src_attachment_type Type of the source object used for the conversion. |
| * @param dst_attachment_type Type of the destination object used for the conversion. |
| * @param has_test_failed_already 1 if any of the other pixels making up the test 2x2 |
| * data-set has already been determined to be corrupt. |
| * 0 otherwise. |
| * @param src_internalformat Internal-format used for source object's data storage. |
| * @param src_datatype Type used for source object's data storage. |
| * |
| * @return 1 if the pixels match, 0 otherwise. |
| **/ |
| bool RequiredCase::comparePixelData(PixelData downloaded_pixel, PixelData reference_pixel, PixelData source_pixel, |
| GLenum result_internalformat, bool has_test_failed_already) |
| { |
| ChannelData* channel_data[12] = { 0 }; |
| int max_epsilon[4] = { 0 }; |
| int has_pixel_failed = 0; |
| int n_channel = 0; |
| bool result = true; |
| int result_rgba_bits[4] = { 0 }; |
| int source_rgba_bits[4] = { 0 }; |
| |
| // Form channel data so we can later analyse channels one after another in a loop |
| channel_data[0] = &downloaded_pixel.red; |
| channel_data[1] = &reference_pixel.red; |
| channel_data[2] = &source_pixel.red; |
| channel_data[3] = &downloaded_pixel.green; |
| channel_data[4] = &reference_pixel.green; |
| channel_data[5] = &source_pixel.green; |
| channel_data[6] = &downloaded_pixel.blue; |
| channel_data[7] = &reference_pixel.blue; |
| channel_data[8] = &source_pixel.blue; |
| channel_data[9] = &downloaded_pixel.alpha; |
| channel_data[10] = &reference_pixel.alpha; |
| channel_data[11] = &source_pixel.alpha; |
| |
| // Retrieve number of bits used for source and result data. |
| getNumberOfBitsForInternalFormat(source_pixel.data_internalformat, source_rgba_bits); |
| getNumberOfBitsForInternalFormat(result_internalformat, result_rgba_bits); |
| |
| // Time for actual comparison! |
| for (unsigned int n = 0; n < sizeof(channel_data) / sizeof(channel_data[0]); |
| n += 3 /* downloaded + reference + source pixel combinations */, ++n_channel) |
| { |
| ChannelData* downloaded_channel_ptr = channel_data[n]; |
| ChannelData* reference_channel_ptr = channel_data[n + 1]; |
| |
| // Calculate maximum epsilon |
| int max_n_bits = 0; |
| int min_n_bits = std::numeric_limits<int>::max(); |
| int n_dst_bits = result_rgba_bits[n_channel]; |
| int n_reading_bits = 0; |
| int n_source_bits = source_rgba_bits[n_channel]; |
| |
| getNumberOfBitsForChannelDataType(downloaded_channel_ptr->data_type, &n_reading_bits); |
| |
| if (max_n_bits < n_dst_bits && n_dst_bits != 0) |
| { |
| max_n_bits = n_dst_bits; |
| } /* if (max_n_bits < n_dst_bits && n_dst_bits != 0) */ |
| if (max_n_bits < n_reading_bits && n_reading_bits != 0) |
| { |
| max_n_bits = n_reading_bits; |
| } |
| if (max_n_bits < n_source_bits && n_source_bits != 0) |
| { |
| max_n_bits = n_source_bits; |
| } |
| |
| if (n_dst_bits != 0) |
| { |
| min_n_bits = n_dst_bits; |
| } |
| |
| if (min_n_bits > n_reading_bits && n_reading_bits != 0) |
| { |
| min_n_bits = n_reading_bits; |
| } |
| if (min_n_bits > n_source_bits && n_source_bits != 0) |
| { |
| min_n_bits = n_source_bits; |
| } |
| |
| if (max_n_bits != min_n_bits && max_n_bits != 0) |
| { |
| DE_ASSERT(min_n_bits != std::numeric_limits<int>::max()); |
| |
| // Allow rounding in either direction |
| max_epsilon[n_channel] = deCeilFloatToInt32(((1 << max_n_bits) - 1.0f) / ((1 << min_n_bits) - 1)); |
| } |
| else |
| { |
| max_epsilon[n_channel] = 0; |
| } |
| |
| // At the moment, we only care about data types that correspond to GL types usable for glReadPixels() calls. |
| // Please feel free to expand this switch() with support for data types you need. |
| switch (downloaded_channel_ptr->data_type) |
| { |
| case CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS: |
| { |
| int delta = (downloaded_channel_ptr->signed_integer_data - reference_channel_ptr->signed_integer_data); |
| |
| if (abs(delta) > max_epsilon[n_channel]) |
| { |
| if (result) |
| { |
| has_pixel_failed = 1; |
| result = false; |
| } |
| } |
| |
| break; |
| } |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS: |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS: |
| { |
| int delta = (downloaded_channel_ptr->unsigned_byte_data - reference_channel_ptr->unsigned_byte_data); |
| |
| if (abs(delta) > max_epsilon[n_channel]) |
| { |
| if (result) |
| { |
| has_pixel_failed = 1; |
| result = false; |
| } |
| } |
| |
| break; |
| } |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS: |
| { |
| int delta = static_cast<int>(downloaded_channel_ptr->unsigned_integer_data - |
| reference_channel_ptr->unsigned_integer_data); |
| |
| if (abs(delta) > max_epsilon[n_channel]) |
| { |
| if (result) |
| { |
| has_pixel_failed = 1; |
| result = false; |
| } |
| } |
| |
| break; |
| } |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS: |
| { |
| int delta = (downloaded_channel_ptr->unsigned_short_data - reference_channel_ptr->unsigned_short_data); |
| |
| if (abs(delta) > max_epsilon[n_channel]) |
| { |
| if (result) |
| { |
| has_pixel_failed = 1; |
| result = false; |
| } |
| } |
| |
| break; |
| } /* case CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS: */ |
| |
| case CHANNEL_DATA_TYPE_FLOAT: |
| { |
| int delta = deChopFloatToInt32(downloaded_channel_ptr->float_data - reference_channel_ptr->float_data); |
| |
| if (abs(delta) > max_epsilon[n_channel]) |
| { |
| if (result) |
| { |
| has_pixel_failed = 1; |
| result = false; |
| } |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| // Unrecognized data type |
| DE_ASSERT(0); |
| } |
| } |
| |
| if (has_pixel_failed && !has_test_failed_already) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Erroneous test case starts-->" << tcu::TestLog::EndMessage; |
| has_test_failed_already = true; |
| } |
| } // for (all channels) |
| |
| if (!result) |
| { |
| displayPixelComparisonFailureMessage( |
| channel_data[2] != NULL ? channel_data[2]->unsigned_integer_data : 0, |
| channel_data[5] != NULL ? channel_data[5]->unsigned_integer_data : 0, |
| channel_data[8] != NULL ? channel_data[8]->unsigned_integer_data : 0, |
| channel_data[11] != NULL ? channel_data[11]->unsigned_integer_data : 0, source_pixel.data_internalformat, |
| source_pixel.data_type, channel_data[1] != NULL ? channel_data[1]->unsigned_integer_data : 0, |
| channel_data[4] != NULL ? channel_data[4]->unsigned_integer_data : 0, |
| channel_data[7] != NULL ? channel_data[7]->unsigned_integer_data : 0, |
| channel_data[10] != NULL ? channel_data[10]->unsigned_integer_data : 0, reference_pixel.data_internalformat, |
| reference_pixel.data_type, channel_data[0] != NULL ? channel_data[0]->unsigned_integer_data : 0, |
| channel_data[3] != NULL ? channel_data[3]->unsigned_integer_data : 0, |
| channel_data[6] != NULL ? channel_data[6]->unsigned_integer_data : 0, |
| channel_data[9] != NULL ? channel_data[9]->unsigned_integer_data : 0, result_internalformat, |
| downloaded_pixel.data_type, max_epsilon[0], max_epsilon[1], max_epsilon[2], max_epsilon[3]); |
| } |
| |
| return result; |
| } |
| |
| /** Retrieves number of bits used for a single pixel, were it |
| * stored in @param internalformat internal format. |
| * |
| * @param internalformat GLES internal format to consider. |
| * @param out_rgba_bits Deref will be used to store 4 integers |
| * describing amount of bits that the internal |
| * format uses for subsequently R, G, B and A |
| * channels. Cannot be NULL. |
| * |
| * @return GTFtrue if successful, GTFfalse otherwise. |
| **/ |
| bool RequiredCase::getNumberOfBitsForInternalFormat(GLenum internalformat, int* out_rgba_bits) |
| { |
| deMemset(out_rgba_bits, 0, sizeof(int) * 4); |
| |
| switch (internalformat) |
| { |
| case GL_LUMINANCE8_OES: |
| out_rgba_bits[0] = 8; |
| break; |
| case GL_R16I: |
| out_rgba_bits[0] = 16; |
| break; |
| case GL_R16UI: |
| out_rgba_bits[0] = 16; |
| break; |
| case GL_R32I: |
| out_rgba_bits[0] = 32; |
| break; |
| case GL_R32UI: |
| out_rgba_bits[0] = 32; |
| break; |
| case GL_R8: |
| out_rgba_bits[0] = 8; |
| break; |
| case GL_R8_SNORM: |
| out_rgba_bits[0] = 8; |
| break; |
| case GL_R8I: |
| out_rgba_bits[0] = 8; |
| break; |
| case GL_R8UI: |
| out_rgba_bits[0] = 8; |
| break; |
| case GL_RG16UI: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| break; |
| case GL_RG16I: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| break; |
| case GL_RG32I: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| break; |
| case GL_RG32UI: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| break; |
| case GL_RG8: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| break; |
| case GL_RG8_SNORM: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| break; |
| case GL_RG8I: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| break; |
| case GL_RG8UI: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| break; |
| case GL_RGB10_A2: |
| out_rgba_bits[0] = 10; |
| out_rgba_bits[1] = 10; |
| out_rgba_bits[2] = 10; |
| out_rgba_bits[3] = 2; |
| break; |
| case GL_RGB10_A2UI: |
| out_rgba_bits[0] = 10; |
| out_rgba_bits[1] = 10; |
| out_rgba_bits[2] = 10; |
| out_rgba_bits[3] = 2; |
| break; |
| case GL_RGB16I: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| out_rgba_bits[2] = 16; |
| break; |
| case GL_RGB16UI: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| out_rgba_bits[2] = 16; |
| break; |
| case GL_RGB32I: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| out_rgba_bits[2] = 32; |
| break; |
| case GL_RGB32UI: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| out_rgba_bits[2] = 32; |
| break; |
| case GL_RGB5_A1: |
| out_rgba_bits[0] = 5; |
| out_rgba_bits[1] = 5; |
| out_rgba_bits[2] = 5; |
| out_rgba_bits[3] = 1; |
| break; |
| case GL_RGB565: |
| out_rgba_bits[0] = 5; |
| out_rgba_bits[1] = 6; |
| out_rgba_bits[2] = 5; |
| break; |
| case GL_RGB8: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| break; |
| case GL_RGB8_SNORM: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| break; |
| case GL_RGB8I: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| break; |
| case GL_RGB8UI: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| break; |
| case GL_RGBA16I: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| out_rgba_bits[2] = 16; |
| out_rgba_bits[3] = 16; |
| break; |
| case GL_RGBA16UI: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| out_rgba_bits[2] = 16; |
| out_rgba_bits[3] = 16; |
| break; |
| case GL_RGBA32I: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| out_rgba_bits[2] = 32; |
| out_rgba_bits[3] = 32; |
| break; |
| case GL_RGBA32UI: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| out_rgba_bits[2] = 32; |
| out_rgba_bits[3] = 32; |
| break; |
| case GL_RGBA4: |
| out_rgba_bits[0] = 4; |
| out_rgba_bits[1] = 4; |
| out_rgba_bits[2] = 4; |
| out_rgba_bits[3] = 4; |
| break; |
| case GL_RGBA8: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| out_rgba_bits[3] = 8; |
| break; |
| case GL_RGBA8_SNORM: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| out_rgba_bits[3] = 8; |
| break; |
| case GL_RGBA8I: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| out_rgba_bits[3] = 8; |
| break; |
| case GL_RGBA8UI: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| out_rgba_bits[3] = 8; |
| break; |
| case GL_SRGB8: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| break; |
| case GL_SRGB8_ALPHA8: |
| out_rgba_bits[0] = 8; |
| out_rgba_bits[1] = 8; |
| out_rgba_bits[2] = 8; |
| out_rgba_bits[3] = 8; |
| break; |
| case GL_R16F: |
| out_rgba_bits[0] = 16; |
| break; |
| case GL_RG16F: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| break; |
| case GL_RGB16F: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| out_rgba_bits[2] = 16; |
| break; |
| case GL_RGBA16F: |
| out_rgba_bits[0] = 16; |
| out_rgba_bits[1] = 16; |
| out_rgba_bits[2] = 16; |
| out_rgba_bits[3] = 16; |
| break; |
| case GL_R32F: |
| out_rgba_bits[0] = 32; |
| break; |
| case GL_RG32F: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| break; |
| case GL_RGB32F: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| out_rgba_bits[2] = 32; |
| break; |
| case GL_RGBA32F: |
| out_rgba_bits[0] = 32; |
| out_rgba_bits[1] = 32; |
| out_rgba_bits[2] = 32; |
| out_rgba_bits[3] = 32; |
| break; |
| |
| default: |
| { |
| DE_ASSERT(0); |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** Browses the conversion database provided by user and looks for conversion rules |
| * that match the following requirements: |
| * |
| * 1) Source object's data internal format equal to @param src_internalformat. |
| * 2) Source object's data type equal to @param src_type. |
| * 3) Internal format used for glCopyTexImage2D() call equal to @param copyteximage2d_internalformat. |
| * |
| * The function allows to find as many conversion rules matching these requirements as |
| * available. For any triple, caller should use incrementing values of @param index, |
| * starting from 0. |
| * |
| * Source dataset corresponds to 2x2 image (using up to 4 channels) that the attachment bound to |
| * read buffer will use prior to glCopyTexImage2D() call. |
| * Destination dataset corresponds to 2x2 image (using up to 4 channels) that the result texture object |
| * should match (within acceptable epsilon). |
| * |
| * @param index Index of conversion rule the caller is interested in reading. |
| * @param src_internalformat Source object's data internal format to assume. |
| * @param src_type Source object's data type to assume. |
| * @param copyteximage2d_internalformat Internal format to be used for glCopyTexImage2D() call. |
| * @param out_result_internalformat Deref will be used to store internal format that GLES implementation |
| * should use for storage of the converted data. Cannot be NULL. |
| * @param out_dst_type Deref will be used to store type that GLES implementation should use |
| * for storage of the converted data. Cannot be NULL. |
| * @param out_src_topleft Deref will be used to store _pixel_data instance describing top-left |
| * corner of the source dataset. Cannot be NULL. |
| * @param out_src_topright Deref will be used to store _pixel_data instance describing top-right |
| * corner of the source dataset. Cannot be NULL. |
| * @param out_src_bottomleft Deref will be used to store _pixel_data instance describing bottom-left |
| * corner of the source dataset. Cannot be NULL. |
| * @param out_src_bottomright Deref will be used to store _pixel_data instance describing bottom-right |
| * corner of the source dataset. Cannot be NULL. |
| * @param out_dst_topleft Deref will be used to store _pixel_data instance describing top-left |
| * corner of the destination dataset. |
| * @param out_dst_topright Deref will be used to store _pixel_data instance describing top-right |
| * corner of the destination dataset. |
| * @param out_dst_bottomleft Deref will be used to store _pixel_data instance describing bottom-left |
| * corner of the destination dataset. |
| * @param out_dst_bottomright Deref will be used to store _pixel_data instance describing bottom-right |
| * corner of the destination dataset. |
| * |
| * @return GTFtrue if @param index -th conversion rule was found, GTFfalse otherwise. |
| **/ |
| bool RequiredCase::findEntryInConversionDatabase(unsigned int index, GLenum src_internalformat, GLenum src_type, |
| GLenum copyteximage2d_internalformat, |
| GLenum* out_result_internalformat, GLenum* out_dst_type, |
| PixelData* out_src_topleft, PixelData* out_src_topright, |
| PixelData* out_src_bottomleft, PixelData* out_src_bottomright, |
| PixelData* out_dst_topleft, PixelData* out_dst_topright, |
| PixelData* out_dst_bottomleft, PixelData* out_dst_bottomright, |
| PixelCompareChannel* out_channels_to_compare) |
| { |
| const int conversion_array_width = |
| sizeof(copyTexImage2DInternalFormatOrdering) / sizeof(copyTexImage2DInternalFormatOrdering[0]); |
| int copyteximage2d_index = -1; |
| int fbo_effective_internalformat_index = -1; |
| unsigned int n_entry = 0; |
| unsigned int n_matching_entries = 0; |
| GLenum result_internalformat = GL_NONE; |
| int result_internalformat_index = -1; |
| |
| /* Sanity checks */ |
| DE_ASSERT(out_src_topleft != NULL); |
| DE_ASSERT(out_src_topright != NULL); |
| DE_ASSERT(out_src_bottomleft != NULL); |
| DE_ASSERT(out_src_bottomright != NULL); |
| DE_ASSERT(out_dst_topleft != NULL); |
| DE_ASSERT(out_dst_topright != NULL); |
| DE_ASSERT(out_dst_bottomleft != NULL); |
| DE_ASSERT(out_dst_bottomright != NULL); |
| |
| // Retrieve internalformat that converted data will be stored in |
| copyteximage2d_index = getIndexOfCopyTexImage2DInternalFormat(copyteximage2d_internalformat); |
| fbo_effective_internalformat_index = getIndexOfFramebufferEffectiveInternalFormat(src_internalformat); |
| |
| DE_ASSERT(copyteximage2d_index != -1 && fbo_effective_internalformat_index != -1); |
| if (copyteximage2d_index == -1 || fbo_effective_internalformat_index == -1) |
| return false; |
| |
| result_internalformat_index = fbo_effective_internalformat_index * conversion_array_width + copyteximage2d_index; |
| |
| DE_ASSERT(result_internalformat_index < DE_LENGTH_OF_ARRAY(conversionArray)); |
| if (result_internalformat_index >= DE_LENGTH_OF_ARRAY(conversionArray)) |
| return false; |
| |
| result_internalformat = conversionArray[result_internalformat_index]; |
| |
| DE_ASSERT(result_internalformat != GL_NONE); |
| if (result_internalformat == GL_NONE) |
| return false; |
| |
| // We use the simplest approach possible to keep the code as readable as possible. |
| for (n_entry = 0; n_entry < m_conversion_database->n_entries_added; ++n_entry) |
| { |
| ConversionDatabaseEntry& entry_ptr = m_conversion_database->entries[n_entry]; |
| |
| if (entry_ptr.src_bottomleft_corner.data_internalformat == src_internalformat && |
| entry_ptr.src_bottomleft_corner.data_type == src_type && |
| entry_ptr.dst_bottomleft_corner.data_internalformat == result_internalformat) |
| { |
| /* Is it the n-th match we're being asked for? */ |
| if (index == n_matching_entries) |
| { |
| /* Indeed! */ |
| *out_src_topleft = entry_ptr.src_topleft_corner; |
| *out_src_topright = entry_ptr.src_topright_corner; |
| *out_src_bottomleft = entry_ptr.src_bottomleft_corner; |
| *out_src_bottomright = entry_ptr.src_bottomright_corner; |
| *out_dst_topleft = entry_ptr.dst_topleft_corner; |
| *out_dst_topright = entry_ptr.dst_topright_corner; |
| *out_dst_bottomleft = entry_ptr.dst_bottomleft_corner; |
| *out_dst_bottomright = entry_ptr.dst_bottomright_corner; |
| |
| *out_result_internalformat = entry_ptr.dst_topleft_corner.data_internalformat; |
| *out_dst_type = entry_ptr.dst_topleft_corner.data_type; |
| |
| *out_channels_to_compare = entry_ptr.channels_to_compare; |
| |
| return true; |
| } |
| else |
| { |
| ++n_matching_entries; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /** Retrieves index under which user-specified internalformat can be found in |
| * copy_tex_image_2d_internal_format_ordering array. |
| * |
| * @param internalformat GLES internal format to look for. |
| * |
| * @return Index >= 0 if successful, -1 otherwise. |
| **/ |
| int RequiredCase::getIndexOfCopyTexImage2DInternalFormat(GLenum internalformat) |
| { |
| int max_index = DE_LENGTH_OF_ARRAY(copyTexImage2DInternalFormatOrdering); |
| for (int index = 0; index < max_index; ++index) |
| { |
| if (copyTexImage2DInternalFormatOrdering[index] == internalformat) |
| return index; |
| } |
| |
| return -1; |
| } |
| |
| /** Retrieves index under which user-specified internalformat can be found in |
| * fbo_effective_internal_format_ordering array. |
| * |
| * @param internalformat GLES internal format to look for. |
| * |
| * @return Index >= 0 if successful, -1 otherwise. |
| **/ |
| int RequiredCase::getIndexOfFramebufferEffectiveInternalFormat(GLenum internalformat) |
| { |
| int max_index = DE_LENGTH_OF_ARRAY(fboEffectiveInternalFormatOrdering); |
| for (int index = 0; index < max_index; ++index) |
| { |
| if (fboEffectiveInternalFormatOrdering[index] == internalformat) |
| return index; |
| } |
| |
| return -1; |
| } |
| |
| /** Takes four pixels (described by _pixel_data structures) making up |
| * the 2x2 texture used for source objects, and converts the representation |
| * to raw data that can later be fed to glTexImage2D(), glTexImage3D() etc. |
| * calls. |
| * |
| * NOTE: It is caller's responsibility to free the returned buffer when no |
| * longer used. Use free() function to deallocate the resource. |
| * |
| * @param topleft Instance of _pixel_data describing top-left corner. |
| * @param topright Instance of _pixel_data describing top-right corner. |
| * @param bottomleft Instance of _pixel_data describing bottom-left corner. |
| * @param bottomright Instance of _pixel_data describing bottom-right corner. |
| * |
| * @return Pointer to the buffer or NULL if failed. |
| **/ |
| bool RequiredCase::getRawDataFromPixelData(std::vector<char>& result, PixelData topleft, PixelData topright, |
| PixelData bottomleft, PixelData bottomright) |
| { |
| ChannelOrder channel_order = CHANNEL_ORDER_UNKNOWN; |
| GLenum format = GL_NONE; |
| GLenum internalformat = topleft.data_internalformat; |
| unsigned int n_bytes_needed = 0; |
| unsigned int n_bytes_per_pixel = 0; |
| unsigned int n_pixel = 0; |
| const PixelData* pixels[] = { &bottomleft, &bottomright, &topleft, &topright }; |
| char* result_traveller = DE_NULL; |
| GLenum type = topleft.data_type; |
| |
| // Sanity checks |
| DE_ASSERT(topleft.data_internalformat == topright.data_internalformat); |
| DE_ASSERT(topleft.data_internalformat == bottomleft.data_internalformat); |
| DE_ASSERT(topleft.data_internalformat == bottomright.data_internalformat); |
| DE_ASSERT(topleft.data_type == topright.data_type); |
| DE_ASSERT(topleft.data_type == bottomleft.data_type); |
| DE_ASSERT(topleft.data_type == bottomright.data_type); |
| |
| // Allocate the buffer |
| if (!getFormatForInternalformat(internalformat, &format)) |
| { |
| DE_ASSERT(0); |
| return false; |
| } // if (no format known for requested internalformat) |
| |
| if (!getChannelOrderForInternalformatAndType(internalformat, type, &channel_order)) |
| { |
| DE_ASSERT(0); |
| return false; |
| } // if (no channel order known for internalformat+type combination) |
| |
| // special case for GL_HALF_FLOAT, treat it as a FLOAT |
| if (type == GL_HALF_FLOAT) |
| n_bytes_per_pixel = getSizeOfPixel(format, GL_FLOAT); |
| else |
| n_bytes_per_pixel = getSizeOfPixel(format, type); |
| n_bytes_needed = TEXTURE_WIDTH * TEXTURE_HEIGHT * n_bytes_per_pixel; |
| |
| if (n_bytes_needed == 0) |
| { |
| DE_ASSERT(0); |
| return false; |
| } |
| |
| result.resize(n_bytes_needed); |
| |
| // Fill the raw data buffer with data. |
| result_traveller = &result[0]; |
| |
| for (n_pixel = 0; n_pixel < sizeof(pixels) / sizeof(pixels[0]); ++n_pixel) |
| { |
| const ChannelData* channels[] = { NULL, NULL, NULL, NULL }; /* We need up to four channels */ |
| int n_bits_for_channel_0 = 0; |
| int n_bits_for_channel_1 = 0; |
| int n_bits_for_channel_2 = 0; |
| int n_bits_for_channel_3 = 0; |
| const PixelData* pixel_ptr = pixels[n_pixel]; |
| |
| switch (channel_order) |
| { |
| case CHANNEL_ORDER_ABGR: |
| { |
| channels[0] = &pixel_ptr->alpha; |
| channels[1] = &pixel_ptr->blue; |
| channels[2] = &pixel_ptr->green; |
| channels[3] = &pixel_ptr->red; |
| break; |
| } |
| |
| case CHANNEL_ORDER_BGR: |
| { |
| channels[0] = &pixel_ptr->blue; |
| channels[1] = &pixel_ptr->green; |
| channels[2] = &pixel_ptr->red; |
| break; |
| } |
| |
| case CHANNEL_ORDER_BGRA: |
| { |
| channels[0] = &pixel_ptr->blue; |
| channels[1] = &pixel_ptr->green; |
| channels[2] = &pixel_ptr->red; |
| channels[3] = &pixel_ptr->alpha; |
| break; |
| } |
| |
| case CHANNEL_ORDER_R: |
| { |
| channels[0] = &pixel_ptr->red; |
| break; |
| } |
| |
| case CHANNEL_ORDER_RG: |
| { |
| channels[0] = &pixel_ptr->red; |
| channels[1] = &pixel_ptr->green; |
| break; |
| } |
| |
| case CHANNEL_ORDER_RGB: |
| { |
| channels[0] = &pixel_ptr->red; |
| channels[1] = &pixel_ptr->green; |
| channels[2] = &pixel_ptr->blue; |
| break; |
| } |
| |
| case CHANNEL_ORDER_RGBA: |
| { |
| channels[0] = &pixel_ptr->red; |
| channels[1] = &pixel_ptr->green; |
| channels[2] = &pixel_ptr->blue; |
| channels[3] = &pixel_ptr->alpha; |
| break; |
| } |
| |
| default: |
| { |
| // Unrecognized channel order |
| DE_ASSERT(0); |
| } |
| } |
| |
| // Pack the channel data, depending on channel sizes |
| if (((channels[0] != NULL) && |
| !getNumberOfBitsForChannelDataType(channels[0]->data_type, &n_bits_for_channel_0)) || |
| ((channels[1] != NULL) && |
| !getNumberOfBitsForChannelDataType(channels[1]->data_type, &n_bits_for_channel_1)) || |
| ((channels[2] != NULL) && |
| !getNumberOfBitsForChannelDataType(channels[2]->data_type, &n_bits_for_channel_2)) || |
| ((channels[3] != NULL) && |
| !getNumberOfBitsForChannelDataType(channels[3]->data_type, &n_bits_for_channel_3))) |
| { |
| // Unrecognized data type |
| DE_ASSERT(0); |
| return false; |
| } // if (could not determine number of bits making up any of the channels) |
| |
| // NOTE: We will read HALF_FLOAT data as FLOAT data (32 bit) to avoid conversion before passing the data to GL |
| if (channels[0] != NULL && channels[1] != NULL && channels[2] != NULL && channels[3] != NULL) |
| { |
| // RGBA32 |
| if (type == GL_HALF_FLOAT || ((n_bits_for_channel_0 == 32) && (n_bits_for_channel_1 == 32) && |
| (n_bits_for_channel_2 == 32) && (n_bits_for_channel_3 == 32))) |
| { |
| unsigned int* result_traveller32 = (unsigned int*)result_traveller; |
| |
| *result_traveller32 = channels[0]->unsigned_integer_data; |
| result_traveller32++; |
| *result_traveller32 = channels[1]->unsigned_integer_data; |
| result_traveller32++; |
| *result_traveller32 = channels[2]->unsigned_integer_data; |
| result_traveller32++; |
| *result_traveller32 = channels[3]->unsigned_integer_data; |
| |
| result_traveller += 4 * 4; |
| } |
| else |
| // RGBA16 |
| if (n_bits_for_channel_0 == 16 && n_bits_for_channel_1 == 16 && n_bits_for_channel_2 == 16 && |
| n_bits_for_channel_3 == 16) |
| { |
| unsigned short* result_traveller16 = (unsigned short*)result_traveller; |
| |
| *result_traveller16 = channels[0]->unsigned_short_data; |
| result_traveller16++; |
| *result_traveller16 = channels[1]->unsigned_short_data; |
| result_traveller16++; |
| *result_traveller16 = channels[2]->unsigned_short_data; |
| result_traveller16++; |
| *result_traveller16 = channels[3]->unsigned_short_data; |
| |
| result_traveller += 8; |
| } |
| else |
| // RGBA4 |
| if (n_bits_for_channel_0 == 4 && n_bits_for_channel_1 == 4 && n_bits_for_channel_2 == 4 && |
| n_bits_for_channel_3 == 4) |
| { |
| unsigned short* result_traveller16 = (unsigned short*)result_traveller; |
| |
| *result_traveller16 = (channels[0]->unsigned_byte_data << 12) + (channels[1]->unsigned_byte_data << 8) + |
| (channels[2]->unsigned_byte_data << 4) + channels[3]->unsigned_byte_data; |
| |
| result_traveller += 2; |
| } |
| else |
| // RGBA8 |
| if (n_bits_for_channel_0 == 8 && n_bits_for_channel_1 == 8 && n_bits_for_channel_2 == 8 && |
| n_bits_for_channel_3 == 8) |
| { |
| *result_traveller = channels[0]->unsigned_byte_data; |
| result_traveller++; |
| *result_traveller = channels[1]->unsigned_byte_data; |
| result_traveller++; |
| *result_traveller = channels[2]->unsigned_byte_data; |
| result_traveller++; |
| *result_traveller = channels[3]->unsigned_byte_data; |
| result_traveller++; |
| } |
| else |
| // RGB5A1 |
| if (n_bits_for_channel_0 == 5 && n_bits_for_channel_1 == 5 && n_bits_for_channel_2 == 5 && |
| n_bits_for_channel_3 == 1) |
| { |
| unsigned short* result_traveller16 = (unsigned short*)result_traveller; |
| |
| *result_traveller16 = (channels[0]->unsigned_byte_data << 11) + (channels[1]->unsigned_byte_data << 6) + |
| (channels[2]->unsigned_byte_data << 1) + channels[3]->unsigned_byte_data; |
| |
| result_traveller += 2; |
| } |
| else |
| // RGB10A2_REV |
| if (n_bits_for_channel_0 == 2 && n_bits_for_channel_1 == 10 && n_bits_for_channel_2 == 10 && |
| n_bits_for_channel_3 == 10) |
| { |
| unsigned int* result_traveller32 = (unsigned int*)result_traveller; |
| |
| DE_ASSERT(channels[0]->data_type == CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS); |
| DE_ASSERT(channels[1]->data_type == CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS); |
| DE_ASSERT(channels[2]->data_type == CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS); |
| DE_ASSERT(channels[3]->data_type == CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS); |
| |
| *result_traveller32 = (channels[0]->unsigned_byte_data << 30) + |
| (channels[1]->unsigned_short_data << 20) + |
| (channels[2]->unsigned_short_data << 10) + channels[3]->unsigned_short_data; |
| |
| result_traveller += 4; |
| } |
| else |
| { |
| // Unsupported bit layout |
| DE_ASSERT(0); |
| return false; |
| } |
| } |
| else if (channels[0] != NULL && channels[1] != NULL && channels[2] != NULL) |
| { |
| // RGB32 |
| if ((type == GL_HALF_FLOAT) || |
| ((n_bits_for_channel_0 == 32) && (n_bits_for_channel_1 == 32) && (n_bits_for_channel_2 == 32))) |
| { |
| unsigned int* result_traveller32 = (unsigned int*)result_traveller; |
| |
| *result_traveller32 = channels[0]->unsigned_integer_data; |
| result_traveller32++; |
| *result_traveller32 = channels[1]->unsigned_integer_data; |
| result_traveller32++; |
| *result_traveller32 = channels[2]->unsigned_integer_data; |
| |
| result_traveller += 3 * 4; |
| } |
| else |
| // RGB8 |
| if (n_bits_for_channel_0 == 8 && n_bits_for_channel_1 == 8 && n_bits_for_channel_2 == 8) |
| { |
| *result_traveller = channels[0]->unsigned_byte_data; |
| result_traveller++; |
| *result_traveller = channels[1]->unsigned_byte_data; |
| result_traveller++; |
| *result_traveller = channels[2]->unsigned_byte_data; |
| result_traveller++; |
| } |
| else |
| // RGB565 |
| if (n_bits_for_channel_0 == 5 && n_bits_for_channel_1 == 6 && n_bits_for_channel_2 == 5) |
| { |
| unsigned short* result_traveller16 = (unsigned short*)result_traveller; |
| |
| *result_traveller16 = (channels[0]->unsigned_byte_data << 11) + (channels[1]->unsigned_byte_data << 5) + |
| (channels[2]->unsigned_byte_data); |
| |
| result_traveller += 2; |
| } |
| else |
| { |
| // Unsupported bit layout |
| DE_ASSERT(0); |
| return false; |
| } |
| } |
| else if (channels[0] != NULL && channels[1] != NULL) |
| { |
| // RG32 |
| if ((type == GL_HALF_FLOAT) || ((n_bits_for_channel_0 == 32) && (n_bits_for_channel_1 == 32))) |
| { |
| unsigned int* result_traveller32 = (unsigned int*)result_traveller; |
| |
| *result_traveller32 = channels[0]->unsigned_integer_data; |
| result_traveller32++; |
| *result_traveller32 = channels[1]->unsigned_integer_data; |
| |
| result_traveller += 8; |
| } |
| else |
| // RG16 |
| if (n_bits_for_channel_0 == 16 && n_bits_for_channel_1 == 16) |
| { |
| unsigned short* result_traveller16 = (unsigned short*)result_traveller; |
| |
| *result_traveller16 = channels[0]->unsigned_short_data; |
| result_traveller16++; |
| *result_traveller16 = channels[1]->unsigned_short_data; |
| |
| result_traveller += 4; |
| } |
| else |
| // RG8 |
| if (n_bits_for_channel_0 == 8 && n_bits_for_channel_1 == 8) |
| { |
| *result_traveller = channels[0]->unsigned_byte_data; |
| result_traveller++; |
| *result_traveller = channels[1]->unsigned_byte_data; |
| result_traveller++; |
| } |
| else |
| { |
| // Unsupported bit layout |
| DE_ASSERT(0); |
| return false; |
| } |
| } |
| else if (channels[0] != NULL) |
| { |
| // R32 |
| if (type == GL_HALF_FLOAT || n_bits_for_channel_0 == 32) |
| { |
| unsigned int* result_traveller32 = (unsigned int*)result_traveller; |
| |
| *result_traveller32 = channels[0]->unsigned_integer_data; |
| result_traveller += 4; |
| } |
| else |
| // R16 |
| if (n_bits_for_channel_0 == 16) |
| { |
| unsigned short* result_traveller16 = (unsigned short*)result_traveller; |
| |
| *result_traveller16 = channels[0]->unsigned_short_data; |
| result_traveller += 2; |
| } |
| else |
| // R8 |
| if (n_bits_for_channel_0 == 8) |
| { |
| *result_traveller = channels[0]->unsigned_byte_data; |
| result_traveller++; |
| } |
| else |
| { |
| // Unsupported bit layout |
| DE_ASSERT(0); |
| return false; |
| } |
| } |
| else |
| { |
| // Unrecognized channel data layout. |
| DE_ASSERT(0); |
| return false; |
| } |
| } // for (all pixels) |
| |
| return true; |
| } |
| |
| /** Retrieves number of bits used for a single channel, were it stored in |
| * @param channel_data_type internal channel data type. |
| * |
| * @param channel_data_type Channel data type to consider. |
| * @param out_n_bits Deref will be used to store the amount of bits. |
| * Cannot be NULL. |
| * |
| * @return GTFtrue if successful, GTFfalse otherwise. |
| **/ |
| bool RequiredCase::getNumberOfBitsForChannelDataType(ChannelDataType channel_data_type, int* out_n_bits) |
| { |
| DE_ASSERT(out_n_bits != NULL); |
| switch (channel_data_type) |
| { |
| case CHANNEL_DATA_TYPE_SIGNED_BYTE_8BITS: |
| *out_n_bits = 8; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_SIGNED_INTEGER_32BITS: |
| *out_n_bits = 32; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_SIGNED_SHORT_16BITS: |
| *out_n_bits = 16; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_1BIT: |
| *out_n_bits = 1; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_2BITS: |
| *out_n_bits = 2; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_4BITS: |
| *out_n_bits = 4; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_5BITS: |
| *out_n_bits = 5; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_6BITS: |
| *out_n_bits = 6; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_BYTE_8BITS: |
| *out_n_bits = 8; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_INTEGER_32BITS: |
| *out_n_bits = 32; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_SHORT_10BITS: |
| *out_n_bits = 10; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_UNSIGNED_SHORT_16BITS: |
| *out_n_bits = 16; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_FLOAT: |
| *out_n_bits = 32; |
| return true; |
| |
| case CHANNEL_DATA_TYPE_NONE: |
| return true; |
| } |
| |
| // Unrecognized channel data type |
| DE_ASSERT(0); |
| return false; |
| } |
| |
| /** Retrieves information on channel order for user-specified internal format+type |
| * combination. |
| * |
| * @param internalformat GLES internal format to consider. |
| * @param type GLES type to consider. |
| * @param out_channel_order Deref will be used to store requested information. |
| * Cannot be NULL. |
| * |
| * @return GTFtrue if successful, GTFfalse otherwise. |
| **/ |
| bool RequiredCase::getChannelOrderForInternalformatAndType(GLenum internalformat, GLenum type, |
| ChannelOrder* out_channel_order) |
| { |
| GLenum format = GL_NONE; |
| DE_ASSERT(out_channel_order != NULL); |
| |
| // Determine the order |
| if (!getFormatForInternalformat(internalformat, &format)) |
| { |
| DE_ASSERT(0); |
| return false; |
| } |
| |
| switch (format) |
| { |
| case GL_RED: |
| case GL_RED_INTEGER: |
| // Only one order is sane |
| *out_channel_order = CHANNEL_ORDER_R; |
| return true; |
| |
| case GL_RG: |
| case GL_RG_INTEGER: |
| // Only one order is sane |
| *out_channel_order = CHANNEL_ORDER_RG; |
| return true; |
| |
| case GL_RGB: |
| case GL_RGB_INTEGER: |
| // Two options here |
| if (type == GL_UNSIGNED_INT_10F_11F_11F_REV || type == GL_UNSIGNED_INT_5_9_9_9_REV) |
| *out_channel_order = CHANNEL_ORDER_BGR; |
| else |
| *out_channel_order = CHANNEL_ORDER_RGB; |
| return true; |
| |
| case GL_RGBA: |
| case GL_RGBA_INTEGER: |
| // Two options here |
| if (type == GL_UNSIGNED_INT_2_10_10_10_REV) |
| *out_channel_order = CHANNEL_ORDER_ABGR; |
| else |
| *out_channel_order = CHANNEL_ORDER_RGBA; |
| return true; |
| |
| default: |
| // Unrecognized format? |
| DE_ASSERT(0); |
| return false; |
| } |
| |
| return false; |
| } |
| |
| /** Creates objects required to support non color-renderable internalformats of texture objects. |
| * There are different objects created for each combination of float/integer/unsigned integer internalformats |
| * of source and destination texture objects created. |
| * |
| * @param f_src_f_dst_internalformat_ptr Deref will be used to store created object IDs for |
| * float source and float destination texture object. |
| * Cannot be NULL. |
| * @param i_src_i_dst_internalformat_ptr Deref will be used to store created object IDs for |
| * integer source and integer destination texture object. |
| * Cannot be NULL. |
| * @param ui_src_ui_dst_internalformat_ptr Deref will be used to store created object IDs for |
| * unsigned integer source and unsigned integer destination texture object. |
| * Cannot be NULL. |
| * @param source_attachment_type Tells what GL object (or which texture target) |
| * should be used as a read buffer for a glCopyTexImage2D call. |
| * @param destination_attachment_type Tells which texture target should be used for |
| * a glCopyTexImage2D() call. |
| * |
| * @return true if successful, false otherwise. |
| */ |
| bool RequiredCase::generateObjectsToSupportNonColorRenderableInternalformats() |
| { |
| // if (failed to prepare objects for float->float shader-based checks) |
| if (!prepareSupportForNonRenderableTexture(m_f_src_f_dst_internalformat, DATA_SAMPLER_FLOAT, DATA_SAMPLER_FLOAT, |
| m_source_attachment_type, m_destination_attachment_type)) |
| { |
| return false; |
| } |
| |
| // if (failed to prepare objects for int->int shader-based checks) |
| if (!prepareSupportForNonRenderableTexture(m_i_src_i_dst_internalformat, DATA_SAMPLER_INTEGER, DATA_SAMPLER_INTEGER, |
| m_source_attachment_type, m_destination_attachment_type)) |
| { |
| return false; |
| } |
| |
| // if (failed to prepare objects for uint->uint shader-based checks) |
| if (!prepareSupportForNonRenderableTexture(m_ui_src_ui_dst_internalformat, DATA_SAMPLER_UNSIGNED_INTEGER, |
| DATA_SAMPLER_UNSIGNED_INTEGER, m_source_attachment_type, |
| m_destination_attachment_type)) |
| { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Creates and prepares buffer and program objects to be used for non-renderable texture support. |
| * In case the destination texture's internalformat is not renderable, |
| * glReadPixels() cannot be issued to retrieve texture object data. |
| * Instead, a program object is used to retrieve and compare source and destination texture data. |
| * This function creates and prepares all objects needed to support this approach. |
| * |
| * @param objects_ptr Deref will be used for storing generated object ids. Cannot be NULL. |
| * @param src_texture_sampler_type Type of the sampler to be used for sampling source texture (float/int/uint). |
| * @param dst_texture_sampler_type Type of the sampler to be used for sampling destination texture (float/int/uint). |
| * @param source_attachment_type |
| * @param destination_attachment_type |
| * |
| * @return true if the operation succeeded (no error was generated), |
| * false otherwise. |
| */ |
| bool RequiredCase::prepareSupportForNonRenderableTexture(NonRenderableInternalformatSupportObjects& objects, |
| DataSamplerType src_texture_sampler_type, |
| DataSamplerType dst_texture_sampler_type, |
| GLenum source_attachment_type, |
| GLenum destination_attachment_type) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| const GLuint compare_result_size = NUMBER_OF_POINTS_TO_DRAW * sizeof(GLint); |
| GLuint destination_buffer_data_size = 0; |
| GLuint source_buffer_data_size = 0; |
| const GLchar* varying_names[] = { "compare_result", "src_texture_pixel_values", "dst_texture_pixel_values" }; |
| const GLsizei varying_names_count = DE_LENGTH_OF_ARRAY(varying_names); |
| |
| // Create program and shader objects. |
| objects.program_object_id = gl.createProgram(); |
| objects.fragment_shader_object_id = gl.createShader(GL_FRAGMENT_SHADER); |
| objects.vertex_shader_object_id = gl.createShader(GL_VERTEX_SHADER); |
| |
| // Generate buffer and transform feedback objects. |
| gl.genTransformFeedbacks(1, &objects.transform_feedback_object_id); |
| gl.genBuffers(1, &objects.comparison_result_buffer_object_id); |
| gl.genBuffers(1, &objects.src_texture_pixels_buffer_object_id); |
| gl.genBuffers(1, &objects.dst_texture_pixels_buffer_object_id); |
| gl.genBuffers(1, &objects.src_texture_coordinates_buffer_object_id); |
| gl.genBuffers(1, &objects.dst_texture_coordinates_buffer_object_id); |
| |
| // Calculate texture data size depending on source and destination sampler types. |
| if (!calculateBufferDataSize(src_texture_sampler_type, &source_buffer_data_size)) |
| return false; |
| if (!calculateBufferDataSize(dst_texture_sampler_type, &destination_buffer_data_size)) |
| return false; |
| |
| // Initialize buffer objects storage. |
| gl.bindBuffer(GL_ARRAY_BUFFER, objects.comparison_result_buffer_object_id); |
| gl.bufferData(GL_ARRAY_BUFFER, compare_result_size, NULL, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData"); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, objects.src_texture_pixels_buffer_object_id); |
| gl.bufferData(GL_ARRAY_BUFFER, source_buffer_data_size, NULL, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData"); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, objects.dst_texture_pixels_buffer_object_id); |
| gl.bufferData(GL_ARRAY_BUFFER, destination_buffer_data_size, NULL, GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData"); |
| |
| // Initialize texture coordinates |
| gl.bindBuffer(GL_ARRAY_BUFFER, objects.src_texture_coordinates_buffer_object_id); |
| gl.bufferData(GL_ARRAY_BUFFER, TEXTURE_COORDINATES_ARRAY_SIZE, getTexCoordinates(source_attachment_type), |
| GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData"); |
| |
| gl.vertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer"); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, objects.dst_texture_coordinates_buffer_object_id); |
| gl.bufferData(GL_ARRAY_BUFFER, TEXTURE_COORDINATES_ARRAY_SIZE, getTexCoordinates(destination_attachment_type), |
| GL_STATIC_DRAW); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData"); |
| |
| gl.vertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer"); |
| |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| |
| // Bind buffer objects to GL_TRANSFORM_FEEDBACK target at specific indices. |
| gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, COMPARISON_RESULT_BUFFER_OBJECT_INDEX, |
| objects.comparison_result_buffer_object_id, 0, compare_result_size); |
| gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, SOURCE_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX, |
| objects.src_texture_pixels_buffer_object_id, 0, source_buffer_data_size); |
| gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, DESTINATION_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX, |
| objects.dst_texture_pixels_buffer_object_id, 0, destination_buffer_data_size); |
| |
| // Specify values for transform feedback. |
| gl.transformFeedbackVaryings(objects.program_object_id, varying_names_count, varying_names, GL_SEPARATE_ATTRIBS); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings"); |
| |
| // Prepare program and shader objects. |
| if (!prepareProgramAndShaderObjectsToSupportNonRenderableTexture( |
| objects.program_object_id, objects.fragment_shader_object_id, objects.vertex_shader_object_id, |
| src_texture_sampler_type, dst_texture_sampler_type)) |
| { |
| return false; |
| } |
| |
| // Retrieve uniform locations. |
| if (!getUniformLocations(objects.program_object_id, &objects.src_2D_texture_uniform_location, |
| &objects.src_2DArray_texture_uniform_location, &objects.src_3D_texture_uniform_location, |
| &objects.src_Cube_texture_uniform_location, &objects.dst_2D_texture_uniform_location, |
| &objects.dst_Cube_texture_uniform_location, &objects.channels_to_compare_uniform_location, |
| &objects.samplers_to_use_uniform_location)) |
| { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Calculate size needed for texture object data storage to successfully |
| * capture all the data needed. |
| * For simplicity, we assume all internalformats of our concern use four |
| * components. It's not a dreadful waste of memory, given amount of data |
| * we will be checking for later on anyway. |
| * |
| * @param _data_sampler_type Type of the sampler used to read the data. |
| * @param texture_data_size_ptr Deref will be used to stored calculated result. |
| * Cannot be NULL. |
| * |
| * @return true if successful, false otherwise. |
| */ |
| bool RequiredCase::calculateBufferDataSize(DataSamplerType sampler_type, GLuint* buffer_data_size_ptr) |
| { |
| if (buffer_data_size_ptr == NULL) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "NULL pointer passed as a deref to store calculated result." |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| switch (sampler_type) |
| { |
| case DATA_SAMPLER_FLOAT: |
| *buffer_data_size_ptr = NUMBER_OF_POINTS_TO_DRAW * NUMBER_OF_ELEMENTS_IN_VEC4 * sizeof(GLfloat); |
| return true; |
| |
| case DATA_SAMPLER_INTEGER: |
| *buffer_data_size_ptr = NUMBER_OF_POINTS_TO_DRAW * NUMBER_OF_ELEMENTS_IN_VEC4 * sizeof(GLint); |
| return true; |
| |
| case DATA_SAMPLER_UNSIGNED_INTEGER: |
| *buffer_data_size_ptr = NUMBER_OF_POINTS_TO_DRAW * NUMBER_OF_ELEMENTS_IN_VEC4 * sizeof(GLuint); |
| return true; |
| |
| default: |
| m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized data sampler type." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Texture coordinates to use when glReadPixels can't be used to read back the data. |
| * Different coordinates for different attachment types. |
| * |
| * @param attachment_type Texture attachment type |
| * |
| * @return Array of 4 3-tuples of texture coordinates to use |
| */ |
| const float* RequiredCase::getTexCoordinates(GLenum attachment_type) const |
| { |
| static const float texture_coordinates[7][NUMBER_OF_POINTS_TO_DRAW * 4] = { |
| // 2D texture, 3D texture and 2D array |
| { 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0 }, |
| // Cube Map NEGATIVE_X |
| { -1, .99f, -.99f, 0, -1, .99f, .99f, 0, -1, -.99f, .99f, 0, -1, -.99f, -.99f, 0 }, |
| // Cube Map NEGATIVE_Y |
| { -.99f, -1, .99f, 0, .99f, -1, .99f, 0, .99f, -1, -.99f, 0, -.99f, -1, -.99f, 0 }, |
| // Cube Map NEGATIVE_Z |
| { .99f, .99f, -1, 0, -.99f, .99f, -1, 0, -.99f, -.99f, -1, 0, .99f, -.99f, -1, 0 }, |
| // Cube Map POSITIVE_X |
| { 1, .99f, .99f, 0, 1, .99f, -.99f, 0, 1, -.99f, -.99f, 0, 1, -.99f, .99f, 0 }, |
| // Cube Map POSITIVE_Y |
| { -.99f, 1, -.99f, 0, .99f, 1, -.99f, 0, .99f, 1, .99f, 0, -.99f, 1, .99f, 0 }, |
| // Cube Map POSITIVE_Z |
| { -.99f, .99f, 1, 0, .99f, .99f, 1, 0, .99f, -.99f, 1, 0, -.99f, -.99f, 1, 0 }, |
| }; |
| |
| switch (attachment_type) |
| { |
| case GL_TEXTURE_2D: |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_3D: |
| return texture_coordinates[0]; |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
| return texture_coordinates[1]; |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
| return texture_coordinates[2]; |
| case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
| return texture_coordinates[3]; |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
| return texture_coordinates[4]; |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
| return texture_coordinates[5]; |
| case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
| return texture_coordinates[6]; |
| default: |
| DE_ASSERT(!"Invalid attachment type!"); |
| return NULL; |
| } |
| } |
| |
| /** Sets source for shader objects, compiles them and attaches to program object. |
| * Program object can be used to verify whether copying texture image works correctly if |
| * non-renderable internalformats are considered. |
| * If all the operations succeeded, the program object is activated. |
| * |
| * @param program_object_id ID of a program object to be initialized. |
| * The value must be a valid program object ID. |
| * @param fragment_shader_object_id ID of a fragment shader object to be initialized. |
| * The value must be a valid fragment shader object ID. |
| * @param vertex_shader_object_id ID of a vertex shader object to be initialized. |
| * The value must be a valid vertex shader object ID. |
| * @param src_texture_sampler_type Sampler to be used for sampling source texture object. |
| * @param dst_texture_sampler_type Sampler to be used for sampling destination texture object. |
| * |
| * @return true if the operation succeeded, false otherwise. |
| */ |
| bool RequiredCase::prepareProgramAndShaderObjectsToSupportNonRenderableTexture(GLuint program_object_id, |
| GLuint fragment_shader_object_id, |
| GLuint vertex_shader_object_id, |
| DataSamplerType src_texture_sampler_type, |
| DataSamplerType dst_texture_sampler_type) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Attach shader objects to program object. |
| gl.attachShader(program_object_id, fragment_shader_object_id); |
| gl.attachShader(program_object_id, vertex_shader_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader"); |
| |
| if (!setSourceForShaderObjectsUsedForNonRenderableTextureSupport( |
| fragment_shader_object_id, vertex_shader_object_id, src_texture_sampler_type, dst_texture_sampler_type)) |
| { |
| return false; |
| } |
| |
| if (!compileAndCheckShaderCompilationStatus(fragment_shader_object_id)) |
| return false; |
| |
| if (!compileAndCheckShaderCompilationStatus(vertex_shader_object_id)) |
| return false; |
| |
| if (!linkAndCheckProgramLinkStatus(program_object_id)) |
| return false; |
| |
| return true; |
| } |
| |
| /** Assigns source code to fragment/vertex shaders which will then be used to verify texture data.. |
| * |
| * @param fragment_shader_object_id ID of an already created fragment shader. |
| * @param vertex_shader_object_id ID of an already created vertex shader. |
| * @param src_texture_sampler_type Type of sampler to be used for sampling source texture object (float/int/uint). |
| * @param dst_texture_sampler_type Type of sampler to be used for sampling destination texture object (float/int/uint). |
| * |
| * @return true if successful, false otherwise. |
| */ |
| bool RequiredCase::setSourceForShaderObjectsUsedForNonRenderableTextureSupport(GLuint fragment_shader_object_id, |
| GLuint vertex_shader_object_id, |
| DataSamplerType src_texture_sampler_type, |
| DataSamplerType dst_texture_sampler_type) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| std::map<std::string, std::string> specializationMap; |
| |
| const GLchar* fragment_shader_source = { "#version 300 es\n" |
| "void main()\n" |
| "{}\n" }; |
| static std::string shader_source[3]; |
| const GLchar* vertex_shader_source = NULL; |
| const GLchar* source = "#version 300 es\n" |
| "\n" |
| " uniform highp ${SAMPLER_PREFIX}sampler2D dst_texture2D;\n" |
| " uniform highp ${SAMPLER_PREFIX}samplerCube dst_textureCube;\n" |
| " uniform highp ${SAMPLER_PREFIX}sampler2D src_texture2D;\n" |
| " uniform highp ${SAMPLER_PREFIX}sampler3D src_texture3D;\n" |
| " uniform highp ${SAMPLER_PREFIX}sampler2DArray src_texture2DArray;\n" |
| " uniform highp ${SAMPLER_PREFIX}samplerCube src_textureCube;\n" |
| " uniform int channels_to_compare;\n" |
| " uniform int samplers_to_use;\n" |
| "layout(location = 0) in vec4 dst_texture_coord;\n" |
| "layout(location = 1) in vec4 src_texture_coord;\n" |
| "${OUT_QUALIFIER} out ${OUT_TYPE} dst_texture_pixel_values;\n" |
| "${OUT_QUALIFIER} out ${OUT_TYPE} src_texture_pixel_values;\n" |
| "flat out int compare_result;\n" |
| "\n" |
| "void main()\n" |
| "{\n" |
| " ${OUT_TYPE} src_texture_data;\n" |
| " ${OUT_TYPE} dst_texture_data;\n" |
| " const ${EPSILON_TYPE} epsilon = ${EPSILON_VALUE};\n" |
| " int result = 1;\n" |
| " bool compare_red = (channels_to_compare & 0x1) != 0;\n" |
| " bool compare_green = (channels_to_compare & 0x2) != 0;\n" |
| " bool compare_blue = (channels_to_compare & 0x4) != 0;\n" |
| " bool compare_alpha = (channels_to_compare & 0x8) != 0;\n" |
| " int src_sampler = samplers_to_use & 0xff;\n" |
| " int dst_sampler = samplers_to_use >> 8;\n" |
| "\n" |
| " if (src_sampler == 0)\n" |
| " {\n" |
| " src_texture_data = texture(src_texture2D, src_texture_coord.xy);\n" |
| " }\n" |
| " else if (src_sampler == 1)\n" |
| " {\n" |
| " src_texture_data = texture(src_texture3D, src_texture_coord.xyz);\n" |
| " }\n" |
| " else if (src_sampler == 2)\n" |
| " {\n" |
| " src_texture_data = texture(src_texture2DArray, src_texture_coord.xyz);\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " src_texture_data = texture(src_textureCube, src_texture_coord.xyz);\n" |
| " }\n" |
| "\n" |
| " if (dst_sampler == 0)\n" |
| " {\n" |
| " dst_texture_data = texture(dst_texture2D, dst_texture_coord.xy);\n" |
| " }\n" |
| " else\n" |
| " {\n" |
| " dst_texture_data = texture(dst_textureCube, dst_texture_coord.xyz);\n" |
| " }\n" |
| "\n" |
| " if (compare_red && ${FN}(src_texture_data.x - dst_texture_data.x) > epsilon)\n" |
| " {\n" |
| " result = 0;\n" |
| " }\n" |
| " if (compare_green && ${FN}(src_texture_data.y - dst_texture_data.y) > epsilon)\n" |
| " {\n" |
| " result = 0;\n" |
| " }\n" |
| " if (compare_blue && ${FN}(src_texture_data.z - dst_texture_data.z) > epsilon)\n" |
| " {\n" |
| " result = 0;\n" |
| " }\n" |
| " if (compare_alpha && ${FN}(src_texture_data.w - dst_texture_data.w) > epsilon)\n" |
| " {\n" |
| " result = 0;\n" |
| " }\n" |
| "\n" |
| " compare_result = result;\n" |
| " dst_texture_pixel_values = dst_texture_data;\n" |
| " src_texture_pixel_values = src_texture_data;\n" |
| "}\n"; |
| |
| switch (src_texture_sampler_type) |
| { |
| case DATA_SAMPLER_FLOAT: |
| { |
| switch (dst_texture_sampler_type) |
| { |
| case DATA_SAMPLER_FLOAT: |
| { |
| specializationMap["SAMPLER_PREFIX"] = " "; |
| specializationMap["OUT_QUALIFIER"] = " "; |
| specializationMap["OUT_TYPE"] = " vec4"; |
| specializationMap["EPSILON_TYPE"] = "float"; |
| specializationMap["EPSILON_VALUE"] = "(1.0/255.0)"; |
| specializationMap["FN"] = "abs"; |
| shader_source[0] = tcu::StringTemplate(source).specialize(specializationMap); |
| |
| vertex_shader_source = shader_source[0].c_str(); |
| break; |
| } |
| |
| default: |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized sampler type for destination texture object." |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| |
| break; |
| } |
| |
| case DATA_SAMPLER_INTEGER: |
| { |
| switch (dst_texture_sampler_type) |
| { |
| case DATA_SAMPLER_INTEGER: |
| { |
| specializationMap["SAMPLER_PREFIX"] = "i"; |
| specializationMap["OUT_QUALIFIER"] = "flat"; |
| specializationMap["OUT_TYPE"] = "ivec4"; |
| specializationMap["EPSILON_TYPE"] = "int"; |
| specializationMap["EPSILON_VALUE"] = "0"; |
| specializationMap["FN"] = "abs"; |
| |
| shader_source[1] = tcu::StringTemplate(source).specialize(specializationMap); |
| vertex_shader_source = shader_source[1].c_str(); |
| break; |
| } |
| |
| default: |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Unrecognized type of internalformat of destination texture object." |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| |
| break; |
| } |
| |
| case DATA_SAMPLER_UNSIGNED_INTEGER: |
| { |
| switch (dst_texture_sampler_type) |
| { |
| case DATA_SAMPLER_UNSIGNED_INTEGER: |
| { |
| specializationMap["SAMPLER_PREFIX"] = "u"; |
| specializationMap["OUT_QUALIFIER"] = "flat"; |
| specializationMap["OUT_TYPE"] = "uvec4"; |
| specializationMap["EPSILON_TYPE"] = "uint"; |
| specializationMap["EPSILON_VALUE"] = "0u"; |
| specializationMap["FN"] = ""; |
| |
| shader_source[2] = tcu::StringTemplate(source).specialize(specializationMap); |
| vertex_shader_source = shader_source[2].c_str(); |
| break; |
| } |
| |
| default: |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Unrecognized type of internalformat of destination texture object." |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| |
| break; |
| } |
| |
| default: |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized type of internalformat of source texture object." |
| << tcu::TestLog::EndMessage; |
| return false; |
| } |
| } |
| |
| // Set shader source for fragment shader object. |
| gl.shaderSource(fragment_shader_object_id, 1 /* part */, &fragment_shader_source, NULL); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource"); |
| |
| // Set shader source for vertex shader object. |
| gl.shaderSource(vertex_shader_object_id, 1 /* part */, &vertex_shader_source, NULL); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource"); |
| |
| return true; |
| } |
| |
| /** Compiles a shader object and returns compilation status. |
| * |
| * @param shader_object_id ID of a shader object to be compiled. |
| * |
| * @return true in case operation succeeded (no error was generated and compilation was successful), |
| * false otherwise. |
| */ |
| bool RequiredCase::compileAndCheckShaderCompilationStatus(GLuint shader_object_id) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Compile shader object. |
| gl.compileShader(shader_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader"); |
| |
| // Check if compilation was successful. |
| GLint shader_compile_status = GL_FALSE; |
| gl.getShaderiv(shader_object_id, GL_COMPILE_STATUS, &shader_compile_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv"); |
| |
| if (GL_FALSE == shader_compile_status) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Shader object compilation failed." << tcu::TestLog::EndMessage; |
| |
| // Retrieve shader info log in case of failed compilation. |
| GLint info_log_length = 0; |
| gl.getShaderiv(shader_object_id, GL_INFO_LOG_LENGTH, &info_log_length); |
| if (info_log_length != 0) |
| { |
| std::vector<char> log(info_log_length + 1, 0); |
| gl.getShaderInfoLog(shader_object_id, info_log_length, NULL, &log[0]); |
| m_testCtx.getLog() << tcu::TestLog::Message << "Shader info log = [" << &log[0] << "]" |
| << tcu::TestLog::EndMessage; |
| } |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Links a program object and returns link status. |
| * |
| * @param program_object_id ID of a program object to be linked. |
| * |
| * @return true in case of the operation succeeded (no error was generated and linking end up with success), |
| * false otherwise. |
| */ |
| bool RequiredCase::linkAndCheckProgramLinkStatus(GLuint program_object_id) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| gl.linkProgram(program_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram"); |
| |
| // Check if link opearation was successful. |
| GLint program_link_status = GL_FALSE; |
| gl.getProgramiv(program_object_id, GL_LINK_STATUS, &program_link_status); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv"); |
| if (GL_FALSE == program_link_status) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Program object linking failed." << tcu::TestLog::EndMessage; |
| |
| // Retrieve program info log in case of failed linking. |
| GLint info_log_length = 0; |
| gl.getProgramiv(program_object_id, GL_INFO_LOG_LENGTH, &info_log_length); |
| if (info_log_length != 0) |
| { |
| std::vector<char> log(info_log_length + 1, 0); |
| gl.getProgramInfoLog(program_object_id, info_log_length, NULL, &log[0]); |
| m_testCtx.getLog() << tcu::TestLog::Message << "Program info log = [" << &log[0] << "]" |
| << tcu::TestLog::EndMessage; |
| } |
| |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** Retrieve locations of uniforms (source and destination texture samples) |
| * and store them in derefs. |
| * |
| * @param program_object_id ID of a program object for which uniform locations are to be retrieved. |
| * @param source_2D_texture_uniform_location_ptr Deref used to store uniform location for a 2D source texture. |
| * Cannot be NULL. |
| * @param source_2DArray_texture_uniform_location_ptr Deref used to store uniform location for a 2DArray source texture. |
| * Cannot be NULL. |
| * @param source_3D_texture_uniform_location_ptr Deref used to store uniform location for a 3D source texture. |
| * Cannot be NULL. |
| * @param source_Cube_texture_uniform_location_ptr Deref used to store uniform location for a Cube source texture. |
| * Cannot be NULL. |
| * @param destination_2D_texture_uniform_location_ptr Deref used to store uniform location for a 2D destination texture. |
| * Cannot be NULL. |
| * @param destination_Cube_texture_uniform_location_ptr Deref used to store uniform location for a Cube destination texture. |
| * Cannot be NULL. |
| * @param channels_to_compare_uniform_location_ptr Deref used to store uniform location for a channels_to_compare. |
| * Cannot be NULL. |
| * @param samplers_to_use_uniform_location_ptr Deref used to store uniform location for a samplers_to_use. |
| * Cannot be NULL. |
| * |
| * @return true if the operation succeeded (no error was generated and valid uniform locations were returned), |
| * false otherwise. |
| */ |
| bool RequiredCase::getUniformLocations(GLuint program_object_id, GLint* source_2D_texture_uniform_location_ptr, |
| GLint* source_2DArray_texture_uniform_location_ptr, |
| GLint* source_3D_texture_uniform_location_ptr, |
| GLint* source_Cube_texture_uniform_location_ptr, |
| GLint* destination_2D_texture_uniform_location_ptr, |
| GLint* destination_Cube_texture_uniform_location_ptr, |
| GLint* channels_to_compare_uniform_location_ptr, |
| GLint* samplers_to_use_uniform_location_ptr) |
| { |
| if (source_2D_texture_uniform_location_ptr == NULL || source_2DArray_texture_uniform_location_ptr == NULL || |
| source_3D_texture_uniform_location_ptr == NULL || source_Cube_texture_uniform_location_ptr == NULL || |
| destination_2D_texture_uniform_location_ptr == NULL || destination_Cube_texture_uniform_location_ptr == NULL || |
| channels_to_compare_uniform_location_ptr == NULL || samplers_to_use_uniform_location_ptr == NULL) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "NULL pointers passed." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Set active program object. |
| gl.useProgram(program_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram"); |
| |
| GLint destination_2D_texture_uniform_location = -1; |
| destination_2D_texture_uniform_location = gl.getUniformLocation(program_object_id, "dst_texture2D"); |
| if (destination_2D_texture_uniform_location == -1) |
| return false; |
| |
| GLint destination_Cube_texture_uniform_location = -1; |
| destination_Cube_texture_uniform_location = gl.getUniformLocation(program_object_id, "dst_textureCube"); |
| if (destination_Cube_texture_uniform_location == -1) |
| return false; |
| |
| GLint source_2D_texture_uniform_location = -1; |
| source_2D_texture_uniform_location = gl.getUniformLocation(program_object_id, "src_texture2D"); |
| if (source_2D_texture_uniform_location == -1) |
| return false; |
| |
| GLint source_2DArray_texture_uniform_location = -1; |
| source_2DArray_texture_uniform_location = gl.getUniformLocation(program_object_id, "src_texture2DArray"); |
| if (source_2DArray_texture_uniform_location == -1) |
| return false; |
| |
| GLint source_3D_texture_uniform_location = -1; |
| source_3D_texture_uniform_location = gl.getUniformLocation(program_object_id, "src_texture3D"); |
| if (source_3D_texture_uniform_location == -1) |
| return false; |
| |
| GLint source_Cube_texture_uniform_location = -1; |
| source_Cube_texture_uniform_location = gl.getUniformLocation(program_object_id, "src_textureCube"); |
| if (source_Cube_texture_uniform_location == -1) |
| return false; |
| |
| GLint channels_to_compare_uniform_location = -1; |
| channels_to_compare_uniform_location = gl.getUniformLocation(program_object_id, "channels_to_compare"); |
| if (channels_to_compare_uniform_location == -1) |
| return false; |
| |
| GLint samplers_to_use_uniform_location = -1; |
| samplers_to_use_uniform_location = gl.getUniformLocation(program_object_id, "samplers_to_use"); |
| if (samplers_to_use_uniform_location == -1) |
| return false; |
| |
| // We are now ready to store retrieved locations. |
| *source_2D_texture_uniform_location_ptr = source_2D_texture_uniform_location; |
| *source_2DArray_texture_uniform_location_ptr = source_2DArray_texture_uniform_location; |
| *source_3D_texture_uniform_location_ptr = source_3D_texture_uniform_location; |
| *source_Cube_texture_uniform_location_ptr = source_Cube_texture_uniform_location; |
| *destination_2D_texture_uniform_location_ptr = destination_2D_texture_uniform_location; |
| *destination_Cube_texture_uniform_location_ptr = destination_Cube_texture_uniform_location; |
| *channels_to_compare_uniform_location_ptr = channels_to_compare_uniform_location; |
| *samplers_to_use_uniform_location_ptr = samplers_to_use_uniform_location; |
| |
| // Restore default settings. |
| gl.useProgram(0); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram"); |
| |
| return true; |
| } |
| |
| /** Display error message with detailed information. |
| * The function should be issued only when pixel comparison failed. |
| * |
| * @param src_attachment_type Source attachment type. |
| * @param dst_attachment_type Destination attachment type. |
| * @param source_pixel_r R channel source pixel value. |
| * @param source_pixel_g G channel source pixel value. |
| * @param source_pixel_b B channel source pixel value. |
| * @param source_pixel_a A channel source pixel value. |
| * @param source_internalformat Source internalformat. |
| * @param source_type Source type. |
| * @param reference_pixel_r R channel reference pixel value. |
| * @param reference_pixel_g G channel reference pixel value. |
| * @param reference_pixel_b B channel reference pixel value. |
| * @param reference_pixel_a A channel reference pixel value. |
| * @param reference_internalformat Reference internalformat. |
| * @param reference_type Reference type. |
| * @param result_pixel_r R channel result pixel value. |
| * @param result_pixel_g G channel result pixel value. |
| * @param result_pixel_b B channel result pixel value. |
| * @param result_pixel_a A channel result pixel value. |
| * @param result_internalformat Result internalformat. |
| * @param result_type Type internalformat. |
| * @param max_epsilon_r Maximum value for an epsilon used for comparison R channel pixel values. |
| * @param max_epsilon_g Maximum value for an epsilon used for comparison G channel pixel values. |
| * @param max_epsilon_b Maximum value for an epsilon used for comparison B channel pixel values. |
| * @param max_epsilon_a Maximum value for an epsilon used for comparison A channel pixel values. |
| */ |
| void RequiredCase::displayPixelComparisonFailureMessage( |
| GLint source_pixel_r, GLint source_pixel_g, GLint source_pixel_b, GLint source_pixel_a, |
| GLenum source_internalformat, GLenum source_type, GLint reference_pixel_r, GLint reference_pixel_g, |
| GLint reference_pixel_b, GLint reference_pixel_a, GLenum reference_internalformat, GLenum reference_type, |
| GLint result_pixel_r, GLint result_pixel_g, GLint result_pixel_b, GLint result_pixel_a, |
| GLenum result_internalformat, GLenum result_type, GLint max_epsilon_r, GLint max_epsilon_g, GLint max_epsilon_b, |
| GLint max_epsilon_a) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Conversion failed for source [" |
| << getTargetName(m_source_attachment_type) << "] and destination [" |
| << getTargetName(m_destination_attachment_type) << "FBO attachment types." |
| << "\nSource pixel: [" << source_pixel_r << ", " << source_pixel_g << ", " |
| << source_pixel_b << ", " << source_pixel_a << "]\nSource internalformat: [" |
| << getInternalformatString(source_internalformat) << "]\nSource type: [" |
| << glu::getTypeStr(source_type).toString() << "]\nReference pixel: [" |
| << reference_pixel_r << ", " << reference_pixel_g << ", " << reference_pixel_b << ", " |
| << reference_pixel_a << "]\nReference internalformat: [" |
| << getInternalformatString(reference_internalformat) << "]\nReference type: [" |
| << glu::getTypeStr(reference_type).toString() << "]\nResult pixel: [" |
| << result_pixel_r << ", " << result_pixel_g << ", " << result_pixel_b << ", " << result_pixel_a |
| << "]\nResult internalformat: [" << getInternalformatString(result_internalformat) |
| << "]\nType used for glReadPixels(): [" << glu::getTypeStr(result_type).toString() |
| << "]\nMaximum epsilon: [" << max_epsilon_r << ", " << max_epsilon_g << ", " |
| << max_epsilon_b << ", " << max_epsilon_a << "]" << tcu::TestLog::EndMessage; |
| } |
| |
| /** Returns sampler type (float/integer/unsigned integer) that should be used for |
| * sampling a texture using data stored in specific internalformat. |
| * |
| * @param internalformat Internalformat to use for the query. |
| * |
| * @return Sampler type to9 be used.. |
| */ |
| DataSamplerType RequiredCase::getDataSamplerTypeForInternalformat(GLenum internalformat) |
| { |
| if (isInternalFormatCompatibleWithFPSampler(internalformat)) |
| return DATA_SAMPLER_FLOAT; |
| else if (isInternalFormatCompatibleWithIntegerSampler(internalformat)) |
| return DATA_SAMPLER_INTEGER; |
| else if (isInternalFormatCompatibleWithUnsignedIntegerSampler(internalformat)) |
| return DATA_SAMPLER_UNSIGNED_INTEGER; |
| else |
| { |
| // Unrecognized internal format |
| DE_ASSERT(0); |
| } |
| |
| return DATA_SAMPLER_FLOAT; |
| } |
| |
| /** Tells whether internal format @param internalformat is compatible with a floating-point |
| * texture sampling function. |
| * |
| * @param internalformat GLES internal format to consider. |
| * |
| * @return true if yes, false otherwise. |
| **/ |
| bool RequiredCase::isInternalFormatCompatibleWithFPSampler(GLenum internalformat) |
| { |
| switch (internalformat) |
| { |
| // FP texture() GLSL function should be used for sampling textures using |
| // the following internalformats |
| case GL_ALPHA: |
| case GL_ALPHA8_OES: |
| case GL_DEPTH_COMPONENT16: |
| case GL_DEPTH_COMPONENT24: |
| case GL_DEPTH24_STENCIL8: |
| case GL_LUMINANCE: |
| case GL_LUMINANCE8_OES: |
| case GL_LUMINANCE_ALPHA: |
| case GL_LUMINANCE8_ALPHA8_OES: |
| case GL_R8: |
| case GL_R8_SNORM: |
| case GL_RG8: |
| case GL_RG8_SNORM: |
| case GL_RGB: |
| case GL_RGB5_A1: |
| case GL_RGB10_A2: |
| case GL_RGB565: |
| case GL_RGB8: |
| case GL_RGB8_SNORM: |
| case GL_RGBA: |
| case GL_RGBA4: |
| case GL_RGBA8: |
| case GL_RGBA8_SNORM: |
| case GL_SRGB8: |
| case GL_SRGB8_ALPHA8: |
| |
| // These are strictly floating-point internal formats |
| case GL_DEPTH_COMPONENT32F: |
| case GL_DEPTH32F_STENCIL8: |
| case GL_R11F_G11F_B10F: |
| case GL_R16F: |
| case GL_R32F: |
| case GL_RG16F: |
| case GL_RG32F: |
| case GL_RGB16F: |
| case GL_RGB32F: |
| case GL_RGB9_E5: |
| case GL_RGBA16F: |
| case GL_RGBA32F: |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Tells whether internal format @param internalformat is compatible with integer |
| * texture sampling function. |
| * |
| * @param internalformat GLES internal format to consider. |
| * |
| * @return true if yes, false otherwise. |
| **/ |
| bool RequiredCase::isInternalFormatCompatibleWithIntegerSampler(GLenum internalformat) |
| { |
| switch (internalformat) |
| { |
| case GL_R16I: |
| case GL_R32I: |
| case GL_R8I: |
| case GL_RG16I: |
| case GL_RG32I: |
| case GL_RG8I: |
| case GL_RGB16I: |
| case GL_RGB32I: |
| case GL_RGB8I: |
| case GL_RGBA16I: |
| case GL_RGBA32I: |
| case GL_RGBA8I: |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Tells whether internal format @param internalformat is compatible with unsigned integer |
| * texture sampling function. |
| * |
| * @param internalformat GLES internal format to consider. |
| * |
| * @return true if yes, false otherwise. |
| **/ |
| bool RequiredCase::isInternalFormatCompatibleWithUnsignedIntegerSampler(GLenum internalformat) |
| { |
| switch (internalformat) |
| { |
| case GL_R16UI: |
| case GL_R32UI: |
| case GL_R8UI: |
| case GL_RG16UI: |
| case GL_RG32UI: |
| case GL_RG8UI: |
| case GL_RGB10_A2UI: |
| case GL_RGB16UI: |
| case GL_RGB32UI: |
| case GL_RGB8UI: |
| case GL_RGBA16UI: |
| case GL_RGBA32UI: |
| case GL_RGBA8UI: |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Deletes all objects which were created to support non-renderable texture internalformats. |
| * |
| * @param objects Reference to generated object. |
| */ |
| void RequiredCase::destroyObjectsSupportingNonRenderableInternalformats( |
| NonRenderableInternalformatSupportObjects& objects) |
| { |
| unbindAndDestroyBufferObject(objects.comparison_result_buffer_object_id); |
| unbindAndDestroyBufferObject(objects.src_texture_pixels_buffer_object_id); |
| unbindAndDestroyBufferObject(objects.dst_texture_pixels_buffer_object_id); |
| unbindAndDestroyBufferObject(objects.src_texture_coordinates_buffer_object_id); |
| unbindAndDestroyBufferObject(objects.dst_texture_coordinates_buffer_object_id); |
| destroyTransformFeedbackObject(objects.transform_feedback_object_id); |
| destroyProgramAndShaderObjects(objects.program_object_id, objects.fragment_shader_object_id, |
| objects.vertex_shader_object_id); |
| |
| objects.comparison_result_buffer_object_id = 0; |
| objects.dst_texture_pixels_buffer_object_id = 0; |
| objects.dst_2D_texture_uniform_location = -1; |
| objects.dst_Cube_texture_uniform_location = -1; |
| objects.fragment_shader_object_id = 0; |
| objects.transform_feedback_object_id = 0; |
| objects.program_object_id = 0; |
| objects.src_2D_texture_uniform_location = -1; |
| objects.src_2DArray_texture_uniform_location = -1; |
| objects.src_3D_texture_uniform_location = -1; |
| objects.src_Cube_texture_uniform_location = -1; |
| objects.src_texture_pixels_buffer_object_id = 0; |
| objects.vertex_shader_object_id = 0; |
| objects.channels_to_compare_uniform_location = -1; |
| objects.samplers_to_use_uniform_location = -1; |
| objects.src_texture_coordinates_buffer_object_id = 0; |
| objects.dst_texture_coordinates_buffer_object_id = 0; |
| } |
| |
| /** Unbind and destroy buffer object which was created for transform feedback purposes. |
| * |
| * @param bo_id ID of a buffer object (which was created for transform feedback purposes) to be deleted. |
| * If not zero, it is assumed that the value corresponds to valid buffer object ID. |
| */ |
| void RequiredCase::unbindAndDestroyBufferObject(GLuint bo_id) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Set zero buffer object to be used for GL_TRANSFORM_FEEDBACK_BUFFER. |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, COMPARISON_RESULT_BUFFER_OBJECT_INDEX, 0); |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, SOURCE_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX, 0); |
| gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, DESTINATION_TEXTURE_PIXELS_BUFFER_OBJECT_INDEX, 0); |
| gl.bindBuffer(GL_ARRAY_BUFFER, 0); |
| |
| if (bo_id != 0) |
| { |
| gl.deleteBuffers(1, &bo_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers"); |
| } |
| } |
| |
| /** Unbind and destroy transform feedback object. |
| * |
| * @param transform_feedback_object_id ID of a transform feedback object to be deleted. |
| * If not zero, it is assumed that the value corresponds |
| * to valid transform feedback object ID. |
| */ |
| void RequiredCase::destroyTransformFeedbackObject(GLuint transform_feedback_object_id) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Set zero transform feedback object to be used. |
| gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); |
| |
| if (transform_feedback_object_id != 0) |
| { |
| gl.deleteTransformFeedbacks(1, &transform_feedback_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDestroyTransformFeedbackObject"); |
| } |
| } |
| |
| /** Destroy program and shader objects. |
| * |
| * @param program_object_id ID of a program object to be deleted. |
| * If not zero, it is assumed that the value corresponds to valid program object ID. |
| * @param fragment_shader_id ID of a fragment shader object to be deleted. |
| * If not zero, it is assumed that the value corresponds to valid shader object ID. |
| * @param vertex_shader_id ID of a vertex shader object to be deleted. |
| * If not zero, it is assumed that the value corresponds to valid shader object ID. |
| */ |
| void RequiredCase::destroyProgramAndShaderObjects(GLuint program_object_id, GLuint fragment_shader_id, |
| GLuint vertex_shader_id) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Use zero program object. |
| gl.useProgram(0); |
| |
| // Try to destroy fragment shader object. |
| if (fragment_shader_id != 0) |
| { |
| gl.deleteShader(fragment_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader"); |
| } |
| |
| // Try to destroy vertex shader object. |
| if (vertex_shader_id != 0) |
| { |
| gl.deleteShader(vertex_shader_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader"); |
| } |
| |
| // Try to destroy program object. |
| if (program_object_id != 0) |
| { |
| gl.deleteProgram(program_object_id); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteProgram"); |
| } |
| } |
| |
| void RequiredCase::unbindColorAttachments() |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| switch (m_source_attachment_type) |
| { |
| case GL_RENDERBUFFER: |
| gl.framebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, 0); |
| break; |
| case GL_TEXTURE_2D_ARRAY: |
| case GL_TEXTURE_3D: |
| gl.framebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, 0, 0, 0); |
| break; |
| default: |
| gl.framebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_source_attachment_type, 0, 0); |
| break; |
| } |
| |
| if (gl.getError() != GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Could not unbind texture objects from read/draw framebuffers" |
| << tcu::TestLog::EndMessage; |
| } |
| } |
| |
| void RequiredCase::restoreBindings(GLenum src_attachment_point, GLenum dst_attachment_point, GLint bound_draw_fbo_id, |
| GLint bound_read_fbo_id) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| gl.disableVertexAttribArray(SRC_TEXTURE_COORDS_ATTRIB_INDEX); |
| gl.disableVertexAttribArray(DST_TEXTURE_COORDS_ATTRIB_INDEX); |
| |
| gl.activeTexture(src_attachment_point); |
| gl.bindTexture(getGeneralTargetForDetailedTarget(m_source_attachment_type), 0); |
| gl.activeTexture(dst_attachment_point); |
| gl.bindTexture(getGeneralTargetForDetailedTarget(m_destination_attachment_type), 0); |
| gl.activeTexture(GL_TEXTURE0); |
| |
| // Restore previous framebuffer bindings. |
| gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, bound_draw_fbo_id); |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, bound_read_fbo_id); |
| } |
| |
| /* SPECIFICATION: |
| * |
| * This conformance test verifies that glCopyTexImage2D() implementation does NOT |
| * accept internalformats that are incompatible with effective internalformat of |
| * current read buffer. |
| * |
| * The test starts from creating a framebuffer object, which is then bound to |
| * GL_READ_FRAMEBUFFER target. It then enters two-level loop: |
| * |
| * a) First level determines source attachment type: this could either be a 2D texture/cube-map |
| * face mip-map, a specific mip-map of a slice coming from a 2D texture array OR a 3D texture, |
| * or finally a render-buffer. All of these can be bound to an attachment point that is |
| * later pointed to by read buffer configuration. |
| * b) Second level configures attachment type of destination. Since glCopyTexImage2D() |
| * specification limits accepted targets, only 2D texture or cube-map face targets are |
| * accepted. |
| * |
| * For each viable source/destination configuration, the test then enters another two-level loop: |
| * |
| * I) First sub-level determines what internal format should be used for the source attachment. |
| * All texture formats required from a conformant GLES3.0 implementation are iterated over. |
| * II) Second sub-level determines internal format that should be passed as a parameter to |
| * a glCopyTexImage2D() call. |
| * |
| * For each internal format pair, the test creates and configures a corresponding GL object and |
| * attaches it to the read framebuffer. The test also uses a pre-generated texture object that |
| * should be re-configured with each glCopyTexImage2D) call. |
| * |
| * The test then loops over all supported format+type combinations for the internal-format considered |
| * and feeds them into actual glCopyTexImage2D() call. Since we're dealing with a negative test, these |
| * calls are only made if a source/destination internalformat combination is spec-wise invalid and |
| * should result in an error. If the implementation accepts a pair that would require indirect |
| * conversions outside scope of the specification, the test should fail. |
| */ |
| class ForbiddenCase : public TestBase |
| { |
| public: |
| ForbiddenCase(deqp::Context& context, GLenum source_attachment_types, GLenum destination_attachment_types); |
| virtual ~ForbiddenCase(); |
| |
| virtual tcu::TestNode::IterateResult iterate(void); |
| |
| protected: |
| bool execute(GLenum src_internal_format, GLenum dst_internal_format, GLuint src_object_id, GLuint dst_object_id); |
| }; |
| |
| ForbiddenCase::ForbiddenCase(deqp::Context& context, GLenum source_attachment_types, |
| GLenum destination_attachment_types) |
| : TestBase(context, source_attachment_types, destination_attachment_types) |
| { |
| } |
| |
| ForbiddenCase::~ForbiddenCase() |
| { |
| } |
| |
| tcu::TestNode::IterateResult ForbiddenCase::iterate(void) |
| { |
| glu::RenderContext& renderContext = m_context.getRenderContext(); |
| const Functions& gl = renderContext.getFunctions(); |
| |
| // Create a FBO we will be using throughout the test |
| GLuint fbo_id = 0; |
| gl.genFramebuffers(1, &fbo_id); |
| |
| gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo_id); |
| |
| // We will be reading from zeroth color attachment |
| gl.readBuffer(GL_COLOR_ATTACHMENT0); |
| |
| // Make sure the pixel storage is configured accordingly to our data sets |
| gl.pixelStorei(GL_UNPACK_ALIGNMENT, 1); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei"); |
| |
| // Sanity checks |
| DE_ASSERT(m_destination_attachment_type == GL_TEXTURE_2D || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_X || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_X || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_Y || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_Z); |
| |
| // Determine general attachment type |
| GLenum general_attachment_type = getGeneralTargetForDetailedTarget(m_source_attachment_type); |
| if (general_attachment_type == GL_NONE) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| |
| // Set up source object |
| GLuint src_object_id = generateGLObject(m_source_attachment_type); |
| if (src_object_id == 0) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| |
| // Set up destination object |
| GLuint dst_object_id = generateGLObject(m_destination_attachment_type); |
| if (dst_object_id == 0) |
| { |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| return STOP; |
| } |
| |
| // Run through all FBO internal formats |
| bool result = true; |
| int dstInternalFormatsCount = DE_LENGTH_OF_ARRAY(copyTexImage2DInternalFormatOrdering); |
| const int fboInternalFormatsCount = DE_LENGTH_OF_ARRAY(fboEffectiveInternalFormatOrdering); |
| for (int fboInternalFormatIndex = 0; fboInternalFormatIndex < fboInternalFormatsCount; ++fboInternalFormatIndex) |
| { |
| GLenum fboInternalIormat = fboEffectiveInternalFormatOrdering[fboInternalFormatIndex]; |
| |
| // Run through all destination internal formats |
| for (int dstInternalFormatUndex = 0; dstInternalFormatUndex < dstInternalFormatsCount; ++dstInternalFormatUndex) |
| { |
| GLenum dstInternalFormat = copyTexImage2DInternalFormatOrdering[dstInternalFormatUndex]; |
| |
| if (!execute(fboInternalIormat, dstInternalFormat, src_object_id, dst_object_id)) |
| { |
| // At least one conversion was invalid or failed. Test should |
| // fail, but let's continue iterating over internalformats. |
| result = false; |
| } |
| } |
| } |
| |
| // Release GL objects before we continue |
| if (dst_object_id != 0) |
| destroyGLObject(m_destination_attachment_type, dst_object_id); |
| |
| if (src_object_id != 0) |
| destroyGLObject(m_source_attachment_type, src_object_id); |
| |
| if (result) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
| |
| return STOP; |
| } |
| |
| /** This function verifies if glCopyTexImage2D() implementation forbids conversions that |
| * are considered forbidden by GLES3.0.3 spec. For more detailed description, please |
| * consult specification of copy_tex_image_conversions_forbidden conformance test. |
| * |
| * @param src_internalformat GLES internalformat that read buffer should use. |
| * @param src_object_id ID of the source GL object of @param source_attachment_type |
| * type. |
| * @param dst_internalformat GLES internalformat that should be used for gl.readPixels() call. |
| * This should NOT be the expected effective internalformat! |
| * @param dst_object_id ID of the destination GL object of |
| * @param destination_attachment_type type. |
| * |
| * @return true if successful, false otherwise. |
| */ |
| bool ForbiddenCase::execute(GLenum src_internal_format, GLenum dst_internal_format, GLuint src_object_id, |
| GLuint dst_object_id) |
| { |
| // Allocate the max possible size for the texture data (4 compoenents of 4 bytes each) |
| static char fbo_data[TEXTURE_WIDTH * TEXTURE_HEIGHT * 4 * 4]; |
| GLenum fbo_format = GL_NONE; |
| GLenum fbo_type = GL_NONE; |
| GLenum general_destination_attachment_type = getGeneralTargetForDetailedTarget(m_destination_attachment_type); |
| int n_src_pair = 0; |
| bool result = true; |
| |
| // Sanity checks |
| DE_ASSERT(m_destination_attachment_type == GL_TEXTURE_2D || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_X || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_Y || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_NEGATIVE_Z || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_X || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_Y || |
| m_destination_attachment_type == GL_TEXTURE_CUBE_MAP_POSITIVE_Z); |
| |
| // Skip the internalformat if it's non-renderable and we're trying to set up a renderbuffer source. |
| if (m_source_attachment_type == GL_RENDERBUFFER && !isValidRBOInternalFormat(src_internal_format)) |
| return true; |
| |
| // Try using all compatible format+type pairs for |
| const Functions& gl = m_context.getRenderContext().getFunctions(); |
| while (getFormatAndTypeCompatibleWithInternalformat(src_internal_format, n_src_pair, &fbo_format, &fbo_type)) |
| { |
| // Do not test internal formats that are not deemed renderable by GLES implementation we're testing |
| if (!isColorRenderableInternalFormat(src_internal_format)) |
| break; |
| |
| // Set up data to be used for source. Note we don't really care much about the data anyway because we want to run |
| // negative tests, but in case the conversion is incorrectly allowed, we do not want this fact to be covered by |
| // missing source attachment data |
| if (!configureGLObject(1, m_source_attachment_type, src_object_id, src_internal_format, fbo_format, fbo_type, |
| fbo_data)) |
| return false; |
| |
| // Good. Check if the conversion is forbidden - if so, we can run a negative test! */ |
| if (!isFBOEffectiveInternalFormatCompatibleWithDestinationInternalFormat(src_internal_format, |
| dst_internal_format)) |
| { |
| #if 0 |
| m_testCtx.getLog() << tcu::TestLog::Message |
| << "Testing conversion [" << getInternalformatString(src_internal_format) |
| << "]=>[" << getInternalformatString(dst_internal_format) |
| << "] for source target [" << GetTargetName(m_source_attachment_type) |
| << "] and destination target [" << GetTargetName(m_destination_attachment_type) << "]", |
| << tcu::TestLog::EndMessage; |
| #endif |
| |
| // Ask the implementation to perform the conversion! |
| gl.bindTexture(general_destination_attachment_type, dst_object_id); |
| gl.copyTexImage2D(m_destination_attachment_type, 0, dst_internal_format, 0 /* x */, 0 /* y */, |
| TEXTURE_WIDTH, TEXTURE_HEIGHT, 0 /* border */); |
| gl.bindTexture(general_destination_attachment_type, 0); |
| |
| // Has the conversion failed as expected? |
| GLenum error_code = gl.getError(); |
| if (error_code == GL_NO_ERROR) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "[" << getInternalformatString(src_internal_format) |
| << "]=>[" << getInternalformatString(dst_internal_format) |
| << "] conversion [src target=" << getTargetName(m_source_attachment_type) |
| << ", dst target=" << getTargetName(m_destination_attachment_type) |
| << "] supported contrary to GLES3.0 spec." << tcu::TestLog::EndMessage; |
| // This test is now considered failed |
| result = false; |
| } |
| else if (error_code != GL_INVALID_OPERATION) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "[" << getInternalformatString(src_internal_format) |
| << "]=>[" << getInternalformatString(dst_internal_format) |
| << "] conversion [src target=" << getTargetName(m_source_attachment_type) |
| << ", dst target=" << getTargetName(m_destination_attachment_type) << "] caused [" |
| << error_code << "] error instead of GL_INVALID_OPERATION." |
| << tcu::TestLog::EndMessage; |
| // This test is now considered failed |
| result = false; |
| } |
| } |
| |
| n_src_pair++; |
| |
| // If we're copying from a renderbuffer, we don't really care about compatible format+type pairs, as |
| // the effective internalformat is explicitly configured by gl.renderbufferStorage() call. |
| if (m_source_attachment_type == GL_RENDERBUFFER) |
| break; |
| } // for (all compatible format+type pairs) |
| |
| return result; |
| } |
| |
| CopyTexImageConversionsTests::CopyTexImageConversionsTests(deqp::Context& context) |
| : TestCaseGroup(context, "copy_tex_image_conversions", "") |
| { |
| } |
| |
| void CopyTexImageConversionsTests::init() |
| { |
| // Types of objects that can be used as source attachments for conversion process |
| const GLenum sourceAttachmentTypes[] = { GL_TEXTURE_2D, |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_Z, |
| GL_TEXTURE_2D_ARRAY, |
| GL_TEXTURE_3D, |
| GL_RENDERBUFFER }; |
| |
| // Types of objects that can be used as destination attachments for conversion process |
| const GLenum destinationAttachmentTypes[] = { |
| GL_TEXTURE_2D, |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_X, |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_X, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_Y, |
| GL_TEXTURE_CUBE_MAP_POSITIVE_Z, |
| }; |
| |
| // Set up conversion database |
| de::SharedPtr<ConversionDatabase> conversionDatabase(new ConversionDatabase()); |
| |
| TestCaseGroup* requiredGroup = new deqp::TestCaseGroup(m_context, "required", ""); |
| TestCaseGroup* forbiddenGroup = new deqp::TestCaseGroup(m_context, "forbidden", ""); |
| for (int srcAttachmentIndex = 0; srcAttachmentIndex < DE_LENGTH_OF_ARRAY(sourceAttachmentTypes); |
| ++srcAttachmentIndex) |
| { |
| GLenum srcAttachmentType = sourceAttachmentTypes[srcAttachmentIndex]; |
| for (int dstAttachmentIndex = 0; dstAttachmentIndex < DE_LENGTH_OF_ARRAY(destinationAttachmentTypes); |
| ++dstAttachmentIndex) |
| { |
| GLenum dstAttachmentType = destinationAttachmentTypes[dstAttachmentIndex]; |
| requiredGroup->addChild( |
| new RequiredCase(m_context, conversionDatabase, srcAttachmentType, dstAttachmentType)); |
| forbiddenGroup->addChild(new ForbiddenCase(m_context, srcAttachmentType, dstAttachmentType)); |
| } |
| } |
| |
| addChild(forbiddenGroup); |
| addChild(requiredGroup); |
| } |
| |
| } // es3cts namespace |
