| #ifndef _ESEXTCTEXTURECUBEMAPARRAYSAMPLING_HPP |
| #define _ESEXTCTEXTURECUBEMAPARRAYSAMPLING_HPP |
| /*------------------------------------------------------------------------- |
| * OpenGL Conformance Test Suite |
| * ----------------------------- |
| * |
| * Copyright (c) 2014-2016 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 |
| * \brief |
| */ /*-------------------------------------------------------------------*/ |
| |
| /*! |
| * \file esextcTextureCubeMapArraySampling.hpp |
| * \brief Texture Cube Map Array Sampling (Test 1) |
| */ /*-------------------------------------------------------------------*/ |
| |
| #include "../esextcTestCaseBase.hpp" |
| |
| #include <string> |
| |
| namespace glcts |
| { |
| |
| /** Implementation of (Test 1) for texture_cube_map_array extension. Test description follows: |
| * |
| * Make sure sampling cube-map array textures works correctly. |
| * |
| * Category: Functionality tests, |
| * Optional dependency on EXT_geometry_shader; |
| * Optional dependency on EXT_tessellation_shader; |
| * Optional dependency on OES_texture_stencil8; |
| * |
| * Priority: Must-have. |
| * |
| * Verify that both mutable and immutable cube-map array textures initialized |
| * with: |
| * |
| * * a color-renderable internalformat (GL_RGBA8); |
| * * a depth-renderable internalformat (GL_DEPTH_COMPONENT32F); |
| * * GL_RGBA32I internalformat; |
| * * GL_RGBA32UI internalformat; |
| * * GL_STENCIL_INDEX8 internalformat; |
| * * GL_COMPRESSED_RGBA8_ETC2_EAC internalformat; |
| * |
| * can be correctly sampled from: |
| * |
| * * a compute shader. |
| * * a fragment shader; |
| * * a geometry shader; (if supported) |
| * * a tessellation control shader; (if supported) |
| * * a tessellation evaluation shader; (if supported) |
| * * a vertex shader. |
| * |
| * For depth textures, the test should verify results reported by |
| * samplerCubeArray and samplerCubeArrayShadow samplers are valid. |
| * |
| * Use the following texture sampling GLSL functions: |
| * |
| * * texture(); |
| * * textureLod() (lod argument set to 0 and n_total_texture_mipmaps-1; |
| * in the former case we expect base mip-map data to be |
| * used, in the latter it should be the last mip-map that |
| * is used as texel data source) |
| * * textureGrad() (dPdx, dPdy should be calculated as distance to "right" |
| * and "top" "neighbours". Set of neighbours should |
| * ensure sampling of base and last mipmap level); |
| * * textureGather(); |
| * |
| * The following samplers should be used: (whichever applies for texture |
| * considered) |
| * |
| * * isamplerCubeArray; |
| * * samplerCubeArray; |
| * * samplerCubeArrayShadow; |
| * * usamplerCubeArray; |
| * |
| * The following cube-map array texture resolutions should be used for the |
| * purpose of the test: |
| * |
| * * not compressed formats |
| * [width x height x depth] |
| * 1) 64 x 64 x 18; |
| * 2) 117 x 117 x 6; |
| * 3) 256 x 256 x 6; |
| * 4) 173 x 173 x 12; |
| * * compressed formats |
| * [width x height x depth] |
| * 1) 8 x 8 x 12 |
| * 2) 13 x 13 x 12; |
| * |
| * In case of color data, for m-th mip-map level of n-th face at i-th layer, |
| * the mip-map should be filled with the following color: |
| * |
| * ((m+1)/n_mipmaps, (n+1)/6, (i+1)/n_layers, 1.0 / 4.0) |
| * |
| * For signed/unsigned integer data, remove the denominator from all channels. |
| * |
| * For compressed formats, each component should be equal: |
| * |
| * (m * n_layers * 6) + (i * 6) + n |
| * |
| * In case of depth data, for m-th mip-map level of n-th face at i-th layer, |
| * the mip-map should be filled with the following depth: |
| * |
| * (m+1 + n+1 + i+1) / (n_mipmaps + 6 + n_layers) |
| * |
| * In case of stencil data, for m-th mip-map level of n-th face at i-th layer, |
| * the mip-map should be filled with the following stencil index value: |
| * |
| * (m+1 + n+1 + i+1) / (n_mipmaps + 6 + n_layers) * 255 |
| * |
| * The test should use the maximum allowed amount of mip-maps, equal to: |
| * |
| * (floor(log2(max(width, height))) + 1; |
| * |
| * In each iteration, make sure that type of the uniform (as reported by |
| * glGetActiveUniform() and glGetProgramResourceiv() ) used for the test |
| * iteration is valid. |
| **/ |
| class TextureCubeMapArraySamplingTest : public TestCaseBase |
| { |
| public: |
| /* Public methods */ |
| TextureCubeMapArraySamplingTest(Context& context, const ExtParameters& extParams, const char* name, |
| const char* description); |
| |
| virtual ~TextureCubeMapArraySamplingTest(void) |
| { |
| } |
| |
| virtual IterateResult iterate(void); |
| |
| private: |
| /* Enums */ |
| /** Identifies vertex attribute |
| * |
| **/ |
| enum attributeId |
| { |
| Position, |
| TextureCoordinates, |
| TextureCoordinatesForGather, |
| Lod, |
| GradX, |
| GradY, |
| RefZ, |
| }; |
| |
| /** Identifies type of sampler |
| * |
| **/ |
| enum samplerType |
| { |
| Float = 0, |
| Int, |
| UInt, |
| Depth, |
| Stencil |
| }; |
| |
| /** Identifies type of sampling function |
| * |
| **/ |
| enum samplingFunction |
| { |
| Texture = 0, |
| TextureLod, |
| TextureGrad, |
| TextureGather, |
| }; |
| |
| /** Identifies shader stage |
| * |
| **/ |
| enum shaderType |
| { |
| Compute = 0, |
| Fragment, |
| Geometry, |
| Tesselation_Control, |
| Tesselation_Evaluation, |
| Vertex |
| }; |
| |
| /* Structures */ |
| /** Defines vertex attribute |
| * |
| **/ |
| struct attributeDefinition |
| { |
| const glw::GLchar* name; |
| const glw::GLchar* type; |
| attributeId attribute_id; |
| int binding; |
| }; |
| |
| /** Provide set of "getComponents" routines |
| * |
| **/ |
| struct componentProvider |
| { |
| void (*getColorFloatComponents)(glw::GLuint pixel_index, glw::GLint cube_face, glw::GLint layer_index, |
| glw::GLint n_layers, glw::GLint n_mipmap_levels, glw::GLfloat* out_components); |
| |
| void (*getColorUByteComponents)(glw::GLuint pixel_index, glw::GLint cube_face, glw::GLint layer_index, |
| glw::GLint n_layers, glw::GLint n_mipmap_levels, glw::GLubyte* out_components); |
| |
| void (*getColorUintComponents)(glw::GLuint pixel_index, glw::GLint cube_face, glw::GLint layer_index, |
| glw::GLint n_layers, glw::GLint n_mipmap_levels, glw::GLuint* out_components); |
| |
| void (*getColorIntComponents)(glw::GLuint pixel_index, glw::GLint cube_face, glw::GLint layer_index, |
| glw::GLint n_layers, glw::GLint n_mipmap_levels, glw::GLint* out_components); |
| |
| void (*getDepthComponents)(glw::GLuint pixel_index, glw::GLint cube_face, glw::GLint layer_index, |
| glw::GLint n_layers, glw::GLint n_mipmap_levels, glw::GLfloat* out_components); |
| |
| void (*getStencilComponents)(glw::GLuint pixel_index, glw::GLint cube_face, glw::GLint layer_index, |
| glw::GLint n_layers, glw::GLint n_mipmap_levels, glw::GLuint* out_components); |
| |
| void (*getCompressedComponents)(glw::GLuint pixel_index, glw::GLint cube_face, glw::GLint layer_index, |
| glw::GLint n_layers, glw::GLint n_mipmap_levels, glw::GLubyte* out_components); |
| }; |
| |
| /** Defines a GL "format" |
| * |
| **/ |
| struct formatInfo |
| { |
| formatInfo(glw::GLenum internal_format, glw::GLenum format, glw::GLenum type, bool is_compressed); |
| |
| glw::GLenum m_internal_format; |
| glw::GLenum m_format; |
| glw::GLenum m_type; |
| bool m_is_compressed; |
| }; |
| |
| /** Defines type of sampler, source and destination GL formats |
| * |
| **/ |
| struct formatDefinition |
| { |
| formatDefinition(glw::GLenum internal_format, glw::GLenum format, glw::GLenum type, bool is_compressed, |
| samplerType sampler_type, const glw::GLchar* name); |
| |
| formatDefinition(glw::GLenum src_internal_format, glw::GLenum src_format, glw::GLenum src_type, |
| bool src_is_compressed, glw::GLenum dst_internal_format, glw::GLenum dst_format, |
| glw::GLenum dst_type, samplerType sampler_type, const glw::GLchar* name); |
| |
| formatInfo m_source; |
| formatInfo m_destination; |
| samplerType m_sampler_type; |
| const glw::GLchar* m_name; |
| }; |
| |
| /** Defines cube map texture resolution |
| * |
| **/ |
| struct resolutionDefinition |
| { |
| resolutionDefinition(glw::GLuint width, glw::GLuint height, glw::GLuint depth); |
| |
| glw::GLuint m_width; |
| glw::GLuint m_height; |
| glw::GLuint m_depth; |
| }; |
| |
| /** Defines sampling function |
| * |
| **/ |
| struct samplingFunctionDefinition |
| { |
| samplingFunctionDefinition(samplingFunction function, const glw::GLchar* name); |
| |
| samplingFunction m_function; |
| const glw::GLchar* m_name; |
| }; |
| |
| /** Defines sampling shader stage and type of primitive used by draw call |
| * |
| **/ |
| struct shaderConfiguration |
| { |
| shaderConfiguration(shaderType type, glw::GLenum primitive_type, const glw::GLchar* name); |
| |
| shaderType m_type; |
| glw::GLenum m_primitive_type; |
| const glw::GLchar* m_name; |
| }; |
| |
| /* Typedefs */ |
| typedef std::vector<formatDefinition> formatsVectorType; |
| typedef std::vector<bool> mutablitiesVectorType; |
| typedef std::vector<resolutionDefinition> resolutionsVectorType; |
| typedef std::vector<samplingFunctionDefinition> samplingFunctionsVectorType; |
| typedef std::vector<shaderConfiguration> shadersVectorType; |
| |
| /* Classes */ |
| |
| /** Defines vertex buffer |
| * |
| **/ |
| class bufferDefinition |
| { |
| public: |
| bufferDefinition(); |
| ~bufferDefinition(); |
| |
| void init(const glw::Functions& gl, glw::GLsizeiptr buffer_size, glw::GLvoid* buffer_data); |
| |
| void bind(glw::GLenum target) const; |
| void bind(glw::GLenum target, glw::GLuint index) const; |
| |
| static const glw::GLuint m_invalid_buffer_object_id; |
| |
| private: |
| const glw::Functions* m_gl; |
| glw::GLuint m_buffer_object_id; |
| }; |
| |
| /** Defines a collection of vertex buffers for specific texture resolution |
| * |
| **/ |
| class bufferCollection |
| { |
| public: |
| void init(const glw::Functions& gl, const formatDefinition& format, const resolutionDefinition& resolution); |
| |
| bufferDefinition postion; |
| bufferDefinition texture_coordinate; |
| bufferDefinition texture_coordinate_for_gather; |
| bufferDefinition lod; |
| bufferDefinition grad_x; |
| bufferDefinition grad_y; |
| bufferDefinition refZ; |
| }; |
| |
| /** Wrapper for texture object id |
| * |
| **/ |
| class textureDefinition |
| { |
| public: |
| textureDefinition(); |
| ~textureDefinition(); |
| |
| void init(const glw::Functions& gl); |
| |
| void bind(glw::GLenum binding_point) const; |
| |
| glw::GLuint getTextureId() const; |
| |
| void setupImage(glw::GLuint image_unit, glw::GLenum internal_format); |
| void setupSampler(glw::GLuint texture_unit, const glw::GLchar* sampler_name, glw::GLuint program_id, |
| bool is_shadow); |
| |
| static const glw::GLuint m_invalid_uniform_location; |
| static const glw::GLuint m_invalid_texture_object_id; |
| |
| private: |
| const glw::Functions* m_gl; |
| glw::GLuint m_texture_object_id; |
| }; |
| |
| /** Wrapper for shader object id |
| * |
| **/ |
| class shaderDefinition |
| { |
| public: |
| shaderDefinition(); |
| ~shaderDefinition(); |
| |
| void init(const glw::Functions& gl, glw::GLenum shader_stage, const std::string& source, |
| class TextureCubeMapArraySamplingTest* test); |
| |
| bool compile(); |
| |
| void attach(glw::GLuint program_object_id) const; |
| |
| glw::GLuint getShaderId() const; |
| static const glw::GLuint m_invalid_shader_object_id; |
| |
| const std::string& getSource() const; |
| |
| private: |
| const glw::Functions* m_gl; |
| glw::GLenum m_shader_stage; |
| std::string m_source; |
| glw::GLuint m_shader_object_id; |
| }; |
| |
| /** Defines a collection of shaders for specific sampling routine |
| * |
| **/ |
| class shaderCollectionForSamplingRoutine |
| { |
| public: |
| shaderCollectionForSamplingRoutine() : m_sampling_function(Texture) |
| { |
| } |
| |
| ~shaderCollectionForSamplingRoutine() |
| { |
| } |
| |
| void init(const glw::Functions& gl, const formatDefinition& format, const samplingFunction& sampling_function, |
| TextureCubeMapArraySamplingTest& test); |
| |
| shaderDefinition pass_through_vertex_shader; |
| shaderDefinition pass_through_tesselation_control_shader; |
| |
| shaderDefinition sampling_compute_shader; |
| shaderDefinition sampling_fragment_shader; |
| shaderDefinition sampling_geometry_shader; |
| shaderDefinition sampling_tesselation_control_shader; |
| shaderDefinition sampling_tesselation_evaluation_shader; |
| shaderDefinition sampling_vertex_shader; |
| |
| samplingFunction m_sampling_function; |
| }; |
| |
| /** Defines a complete set of shaders for one format and sampling routine |
| * |
| **/ |
| struct shaderGroup |
| { |
| void init(); |
| |
| const shaderDefinition* pass_through_fragment_shader; |
| const shaderDefinition* pass_through_tesselation_control_shader; |
| const shaderDefinition* pass_through_tesselation_evaluation_shader; |
| const shaderDefinition* pass_through_vertex_shader; |
| const shaderDefinition* sampling_compute_shader; |
| const shaderDefinition* sampling_fragment_shader; |
| const shaderDefinition* sampling_geometry_shader; |
| const shaderDefinition* sampling_tesselation_control_shader; |
| const shaderDefinition* sampling_tesselation_evaluation_shader; |
| const shaderDefinition* sampling_vertex_shader; |
| }; |
| |
| /** Defines a collection of shaders for one format |
| * |
| **/ |
| class shaderCollectionForTextureFormat |
| { |
| public: |
| shaderCollectionForTextureFormat() |
| { |
| } |
| |
| ~shaderCollectionForTextureFormat() |
| { |
| } |
| |
| void init(const glw::Functions& gl, const formatDefinition& format, |
| const samplingFunctionsVectorType& sampling_routines, TextureCubeMapArraySamplingTest& test); |
| |
| void getShaderGroup(samplingFunction function, shaderGroup& shader_group) const; |
| |
| private: |
| shaderDefinition pass_through_fragment_shader; |
| shaderDefinition pass_through_tesselation_control_shader; |
| shaderDefinition pass_through_tesselation_evaluation_shader; |
| |
| typedef std::vector<shaderCollectionForSamplingRoutine> shaderCollectionForSamplingFunctionVectorType; |
| shaderCollectionForSamplingFunctionVectorType per_sampling_routine; |
| }; |
| |
| /** Wrapper for program object id |
| * |
| **/ |
| class programDefinition |
| { |
| public: |
| programDefinition(); |
| ~programDefinition(); |
| |
| void init(const glw::Functions& gl, const shaderGroup& shader_group, shaderType shader_type, bool isContextES); |
| |
| bool link(); |
| |
| glw::GLuint getProgramId() const; |
| static const glw::GLuint m_invalid_program_object_id; |
| |
| const shaderDefinition* getShader(shaderType shader_type) const; |
| |
| private: |
| const shaderDefinition* compute_shader; |
| const shaderDefinition* geometry_shader; |
| const shaderDefinition* fragment_shader; |
| const shaderDefinition* tesselation_control_shader; |
| const shaderDefinition* tesselation_evaluation_shader; |
| const shaderDefinition* vertex_shader; |
| |
| glw::GLuint m_program_object_id; |
| |
| private: |
| const glw::Functions* m_gl; |
| }; |
| |
| /** Collection of programs for one sampling routine |
| * |
| **/ |
| class programCollectionForFunction |
| { |
| public: |
| void init(const glw::Functions& gl, const shaderGroup& shader_group, TextureCubeMapArraySamplingTest& test, |
| bool isContextES); |
| |
| const programDefinition* getProgram(shaderType shader_type) const; |
| |
| private: |
| programDefinition program_with_sampling_compute_shader; |
| programDefinition program_with_sampling_fragment_shader; |
| programDefinition program_with_sampling_geometry_shader; |
| programDefinition program_with_sampling_tesselation_control_shader; |
| programDefinition program_with_sampling_tesselation_evaluation_shader; |
| programDefinition program_with_sampling_vertex_shader; |
| }; |
| |
| /** Program collection for one format |
| * |
| **/ |
| class programCollectionForFormat |
| { |
| public: |
| void init(const glw::Functions& gl, const shaderCollectionForTextureFormat& shader_collection, |
| TextureCubeMapArraySamplingTest& test, bool isContextES); |
| |
| const programCollectionForFunction* getPrograms(samplingFunction function) const; |
| |
| private: |
| programCollectionForFunction m_programs_for_texture; |
| programCollectionForFunction m_programs_for_textureLod; |
| programCollectionForFunction m_programs_for_textureGrad; |
| programCollectionForFunction m_programs_for_textureGather; |
| }; |
| |
| /** Wrapper for vertex array object id |
| * |
| **/ |
| class vertexArrayObjectDefinition |
| { |
| public: |
| vertexArrayObjectDefinition(); |
| ~vertexArrayObjectDefinition(); |
| |
| void init(const glw::Functions& gl, const formatDefinition& format, const samplingFunction& sampling_function, |
| const bufferCollection& buffers, glw::GLuint program_id); |
| |
| private: |
| void setupAttribute(const attributeDefinition& attribute, const bufferCollection& buffers, |
| glw::GLuint program_id); |
| |
| static const glw::GLuint m_invalid_attribute_location; |
| static const glw::GLuint m_invalid_vertex_array_object_id; |
| |
| const glw::Functions* m_gl; |
| glw::GLuint m_vertex_array_object_id; |
| }; |
| |
| /* Methods */ |
| glw::GLuint checkUniformAndResourceApi(glw::GLuint program_id, const glw::GLchar* sampler_name, |
| samplerType sampler_type); |
| |
| void compile(shaderDefinition& info); |
| |
| void dispatch(glw::GLuint program_id, glw::GLuint width, glw::GLuint height); |
| |
| void draw(glw::GLuint program_id, glw::GLenum m_primitive_type, glw::GLuint n_vertices, glw::GLenum format); |
| |
| static void getAttributes(samplerType sampler_type, const attributeDefinition*& out_attribute_definitions, |
| glw::GLuint& out_n_attributes); |
| |
| static void getAttributes(samplingFunction sampling_function, const attributeDefinition*& out_attribute_definitions, |
| glw::GLuint& out_n_attributes); |
| |
| void getColorType(samplerType sampler_type, const glw::GLchar*& out_color_type, |
| const glw::GLchar*& out_interpolation_type, const glw::GLchar*& out_sampler_type, |
| glw::GLuint& out_n_components, bool& out_is_shadow); |
| |
| void getColorType(samplerType sampler_type, const glw::GLchar*& out_color_type, |
| const glw::GLchar*& out_interpolation_type, const glw::GLchar*& out_sampler_type, |
| const glw::GLchar*& out_image_type, const glw::GLchar*& out_image_format, |
| glw::GLuint& out_n_components, bool& out_is_shadow); |
| |
| void getPassThroughFragmentShaderCode(samplerType sampler_type, std::string& out_fragment_shader_code); |
| |
| void getPassThroughTesselationControlShaderCode(const samplerType& sampler_type, |
| const samplingFunction& sampling_function, |
| std::string& out_tesselation_control_shader_code); |
| |
| void getPassThroughTesselationEvaluationShaderCode(samplerType sampler_type, |
| std::string& out_tesselation_evaluation_shader_code); |
| |
| void getPassThroughVertexShaderCode(const samplerType& sampler_type, const samplingFunction& sampling_function, |
| std::string& out_vertex_shader_code); |
| |
| void getSamplingComputeShaderCode(const samplerType& sampler_type, const samplingFunction& sampling_function, |
| std::string& out_vertex_shader_code); |
| |
| void getSamplingFragmentShaderCode(const samplerType& sampler_type, const samplingFunction& sampling_function, |
| std::string& out_fragment_shader_code); |
| |
| void getSamplingFunctionCall(samplingFunction sampling_function, const glw::GLchar* color_type, |
| glw::GLuint n_components, const glw::GLchar* attribute_name_prefix, |
| const glw::GLchar* attribute_index, const glw::GLchar* color_variable_name, |
| const glw::GLchar* color_variable_index, const glw::GLchar* sampler_name, |
| std::string& out_code); |
| |
| void getSamplingGeometryShaderCode(const samplerType& sampler_type, const samplingFunction& sampling_function, |
| std::string& out_geometry_shader_code); |
| |
| void getSamplingTesselationControlShaderCode(const samplerType& sampler_type, |
| const samplingFunction& sampling_function, |
| std::string& out_tesselation_control_shader_code); |
| |
| void getSamplingTesselationEvaluationShaderCode(const samplerType& sampler_type, |
| const samplingFunction& sampling_function, |
| std::string& out_tesselation_evaluation_shader_code); |
| |
| void getSamplingVertexShaderCode(const samplerType& sampler_type, const samplingFunction& sampling_function, |
| std::string& out_vertex_shader_code); |
| |
| void getShadowSamplingFunctionCall(samplingFunction sampling_function, const glw::GLchar* color_type, |
| glw::GLuint n_components, const glw::GLchar* attribute_name_prefix, |
| const glw::GLchar* attribute_index, const glw::GLchar* color_variable_name, |
| const glw::GLchar* color_variable_index, const glw::GLchar* sampler_name, |
| std::string& out_code); |
| |
| static bool isSamplerSupportedByFunction(const samplerType sampler_type, const samplingFunction sampling_function); |
| |
| void link(programDefinition& info); |
| |
| void logCompilationLog(const shaderDefinition& info); |
| |
| void logLinkingLog(const programDefinition& info); |
| |
| void logProgram(const programDefinition& info); |
| |
| void prepareCompresedTexture(const textureDefinition& texture, const formatDefinition& format, |
| const resolutionDefinition& resolution, bool mutability); |
| |
| void prepareTexture(const textureDefinition& texture, const formatDefinition& format, |
| const resolutionDefinition& resolution, bool mutability); |
| |
| void setupSharedStorageBuffer(const attributeDefinition& attribute, const bufferCollection& buffers, |
| glw::GLuint program_id); |
| |
| void setupSharedStorageBuffers(const formatDefinition& format, const samplingFunction& sampling_function, |
| const bufferCollection& buffers, glw::GLuint program_id); |
| |
| void testFormats(formatsVectorType& formats, resolutionsVectorType& resolutions); |
| |
| void testTexture(const formatDefinition& format, bool mutability, const resolutionDefinition& resolution, |
| textureDefinition& texture, programCollectionForFormat& program_collection); |
| |
| bool verifyResult(const formatDefinition& format, const resolutionDefinition& resolution, |
| const samplingFunction sampling_function, unsigned char* data); |
| |
| bool verifyResultHelper(const formatDefinition& format, const resolutionDefinition& resolution, |
| const componentProvider& component_provider, unsigned char* data); |
| |
| /* Fields */ |
| formatsVectorType m_formats; |
| formatsVectorType m_compressed_formats; |
| samplingFunctionsVectorType m_functions; |
| mutablitiesVectorType m_mutabilities; |
| resolutionsVectorType m_resolutions; |
| resolutionsVectorType m_compressed_resolutions; |
| shadersVectorType m_shaders; |
| |
| glw::GLuint m_framebuffer_object_id; |
| |
| /* Static variables */ |
| static const glw::GLuint m_get_type_api_status_program_resource; |
| static const glw::GLuint m_get_type_api_status_uniform; |
| |
| /* Fields */ |
| glw::GLuint compiled_shaders; |
| glw::GLuint invalid_shaders; |
| glw::GLuint linked_programs; |
| glw::GLuint invalid_programs; |
| glw::GLuint tested_cases; |
| glw::GLuint failed_cases; |
| glw::GLuint invalid_type_cases; |
| |
| /* Static variables */ |
| static const glw::GLchar* const attribute_grad_x; |
| static const glw::GLchar* const attribute_grad_y; |
| static const glw::GLchar* const attribute_lod; |
| static const glw::GLchar* const attribute_refZ; |
| static const glw::GLchar* const attribute_texture_coordinate; |
| static const glw::GLchar* const compute_shader_body; |
| static const glw::GLchar* const compute_shader_layout_binding; |
| static const glw::GLchar* const compute_shader_buffer; |
| static const glw::GLchar* const compute_shader_color; |
| static const glw::GLchar* const compute_shader_image_store; |
| static const glw::GLchar* const compute_shader_layout; |
| static const glw::GLchar* const compute_shader_param; |
| static const glw::GLchar* const fragment_shader_input; |
| static const glw::GLchar* const fragment_shader_output; |
| static const glw::GLchar* const fragment_shader_pass_through_body_code; |
| static const glw::GLchar* const fragment_shader_sampling_body_code; |
| static const glw::GLchar* const geometry_shader_emit_vertex_code; |
| static const glw::GLchar* const geometry_shader_extension; |
| static const glw::GLchar* const geometry_shader_layout; |
| static const glw::GLchar* const geometry_shader_sampling_body_code; |
| static const glw::GLchar* const image_float; |
| static const glw::GLchar* const image_int; |
| static const glw::GLchar* const image_name; |
| static const glw::GLchar* const image_uint; |
| static const glw::GLchar* const interpolation_flat; |
| static const glw::GLchar* const sampler_depth; |
| static const glw::GLchar* const sampler_float; |
| static const glw::GLchar* const sampler_int; |
| static const glw::GLchar* const sampler_name; |
| static const glw::GLchar* const sampler_uint; |
| static const glw::GLchar* const shader_code_preamble; |
| static const glw::GLchar* const shader_precision; |
| static const glw::GLchar* const shader_input; |
| static const glw::GLchar* const shader_layout; |
| static const glw::GLchar* const shader_output; |
| static const glw::GLchar* const shader_uniform; |
| static const glw::GLchar* const shader_writeonly; |
| static const glw::GLchar* const tesselation_control_shader_layout; |
| static const glw::GLchar* const tesselation_control_shader_sampling_body_code; |
| static const glw::GLchar* const tesselation_control_shader_output; |
| static const glw::GLchar* const tesselation_evaluation_shader_input; |
| static const glw::GLchar* const tesselation_evaluation_shader_layout; |
| static const glw::GLchar* const tesselation_evaluation_shader_pass_through_body_code; |
| static const glw::GLchar* const tesselation_evaluation_shader_sampling_body_code; |
| static const glw::GLchar* const tesselation_shader_extension; |
| static const glw::GLchar* const texture_func; |
| static const glw::GLchar* const textureGather_func; |
| static const glw::GLchar* const textureGrad_func; |
| static const glw::GLchar* const textureLod_func; |
| static const glw::GLchar* const type_float; |
| static const glw::GLchar* const type_ivec4; |
| static const glw::GLchar* const type_uint; |
| static const glw::GLchar* const type_uvec4; |
| static const glw::GLchar* const type_vec3; |
| static const glw::GLchar* const type_vec4; |
| static const glw::GLchar* const vertex_shader_body_code; |
| static const glw::GLchar* const vertex_shader_input; |
| static const glw::GLchar* const vertex_shader_output; |
| static const glw::GLchar* const vertex_shader_position; |
| }; |
| |
| } /* glcts */ |
| |
| #endif // _ESEXTCTEXTURECUBEMAPARRAYSAMPLING_HPP |