1#ifndef _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP
2#define _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP
3/*-------------------------------------------------------------------------
4 * OpenGL Conformance Test Suite
5 * -----------------------------
6 *
7 * Copyright (c) 2014-2016 The Khronos Group Inc.
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 *      http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 */ /*!
22 * \file
23 * \brief
24 */ /*-------------------------------------------------------------------*/
25
26/*!
27 * \file  esextcTextureBufferActiveUniformValidation.hpp
28 * \brief Texture Buffer -  Active Uniform Value Validation (Test 8)
29 */ /*-------------------------------------------------------------------*/
30
31#include "../esextcTestCaseBase.hpp"
32#include <map>
33
34namespace glcts
35{
36
37/** Implementation of (Test 8) from CTS_EXT_texture_buffer. Description follows
38 *
39 *   Check whether glGetActiveUniform, glGetActiveUniformsiv and
40 *   glGetProgramResourceiv functions return correct information about active
41 *   uniform variables of the type:
42 *
43 *   SAMPLER_BUFFER_EXT
44 *   INT_SAMPLER_BUFFER_EXT
45 *   UNSIGNED_INT_SAMPLER_BUFFER_EXT
46 *   IMAGE_BUFFER_EXT
47 *   INT_IMAGE_BUFFER_EXT
48 *   UNSIGNED_INT_IMAGE_BUFFER_EXT
49 *
50 *   Category: API.
51 *
52 *   Write a fragment shader that defines the following uniform variables:
53 *
54 *   uniform highp samplerBuffer   sampler_buffer;
55 *   uniform highp isamplerBuffer  isampler_buffer;
56 *   uniform highp usamplerBuffer  usampler_buffer;
57 *
58 *   Make sure each of the uniform variables will be considered active.
59 *   A uniform variable is considered active if it is determined during the link
60 *   operation that it may be accessed during program execution. The easiest way
61 *   to make sure the above variables are active is to call texelFetch on each
62 *   texture sampler and imageLoad on each image sampler and use the returned
63 *   values to determine the output color.
64 *
65 *   Pair the fragment shader with a boilerplate vertex shader.
66 *
67 *   Compile vertex and fragment shader, attach them to a program object and link
68 *   the program object.
69 *
70 *   Get the number of active uniforms in the program object by calling
71 *   glGetProgramiv with the value GL_ACTIVE_UNIFORMS and store the result in
72 *   n_active_uniforms variable.
73 *
74 *   For index values ranging from zero to n_active_uniforms - 1 get the information
75 *   about the uniform variable by calling glGetActiveUniform.
76 *
77 *   This phase of the test passes if among the returned information
78 *   about active uniforms for the specified program object we can identify:
79 *
80 *   Name:               Type:
81 *
82 *   "sampler_buffer"    SAMPLER_BUFFER_EXT
83 *   "isampler_buffer"   INT_SAMPLER_BUFFER_EXT
84 *   "usampler_buffer"   UNSIGNED_INT_SAMPLER_BUFFER_EXT
85 *
86 *   Store which index corresponds to which variable type.
87 *
88 *   Create an array holding uniform variables' indices ranging from
89 *   zero to n_active_uniforms - 1.
90 *
91 *   Call
92 *
93 *   glGetActiveUniformsiv( po_id, n_active_uniforms, indices_array,
94 *       GL_UNIFORM_TYPE, types_array );
95 *
96 *   This phase of the test passes if the resulting types array holds for each
97 *   index value in indices_array the same uniform type as returned previously by
98 *   glGetActiveUniform called for this index.
99 *
100 *   For index values ranging from zero to n_active_uniforms - 1
101 *   get the type information about the uniform variable by calling
102 *   glGetProgramResourceiv with GL_UNIFORM program interface and GL_TYPE property.
103 *
104 *   This phase of the test passes if for each index value the returned type is
105 *   equal to the one previously returned by glGetActiveUniform.
106 *
107 *   Repeat the test for a compute shader that defines the following uniform
108 *   variables:
109 *
110 *   uniform highp   imageBuffer     image_buffer;
111 *   uniform highp   iimageBuffer    iimage_buffer;
112 *   uniform highp   uimageBuffer    uimage_buffer;
113 *
114 *   The corresponding types for the above uniform variables are:
115 *
116 *   IMAGE_BUFFER_EXT
117 *   INT_IMAGE_BUFFER_EXT
118 *   UNSIGNED_INT_IMAGE_BUFFER_EXT
119 *
120 */
121
122/* Helper Sctructure storing texture confituration parameters */
123class TextureParameters
124{
125public:
126	TextureParameters();
127	TextureParameters(glw::GLuint textureBufferSize, glw::GLenum textureFormat, glw::GLenum textureUniformType,
128					  const char* uniformName);
129
130	glw::GLuint get_texture_buffer_size() const
131	{
132		return m_texture_buffer_size;
133	}
134
135	glw::GLenum get_texture_format() const
136	{
137		return m_texture_format;
138	}
139
140	glw::GLenum get_texture_uniform_type() const
141	{
142		return m_texture_uniform_type;
143	}
144
145	std::string get_uniform_name() const
146	{
147		return m_uniform_name;
148	}
149
150private:
151	glw::GLenum m_texture_buffer_size;
152	glw::GLenum m_texture_format;
153	glw::GLenum m_texture_uniform_type;
154	std::string m_uniform_name;
155};
156
157/* Base Class */
158class TextureBufferActiveUniformValidation : public TestCaseBase
159{
160public:
161	/* Public methods */
162	TextureBufferActiveUniformValidation(Context& context, const ExtParameters& extParams, const char* name,
163										 const char* description);
164
165	virtual ~TextureBufferActiveUniformValidation()
166	{
167	}
168
169	virtual void		  deinit(void);
170	virtual IterateResult iterate(void);
171
172protected:
173	/* Protected methods */
174	void addTextureParam(glw::GLenum uniformType, glw::GLenum format, glw::GLuint size, const char* name,
175						 std::vector<TextureParameters>* params);
176
177	/* Protected variables */
178	glw::GLuint m_po_id;
179
180	static const glw::GLuint m_param_value_size;
181
182private:
183	/* Private methods */
184	virtual void configureParams(std::vector<TextureParameters>* params) = 0;
185	virtual void configureProgram(std::vector<TextureParameters>* params, glw::GLuint* texIds) = 0;
186	virtual void createProgram(void) = 0;
187
188	virtual void initTest(void);
189	const char* getUniformTypeName(glw::GLenum uniformType);
190	const TextureParameters* getParamsForType(glw::GLenum uniformType) const;
191
192	/* Variables for general usage */
193	glw::GLuint*				   m_tbo_ids;
194	glw::GLuint*				   m_tbo_tex_ids;
195	std::vector<TextureParameters> m_texture_params;
196};
197
198/* Vertex/Fragment Shader (Case 1)*/
199class TextureBufferActiveUniformValidationVSFS : public TextureBufferActiveUniformValidation
200{
201public:
202	/* Public methods */
203	TextureBufferActiveUniformValidationVSFS(Context& context, const ExtParameters& extParams, const char* name,
204											 const char* description);
205
206	virtual ~TextureBufferActiveUniformValidationVSFS()
207	{
208	}
209
210	virtual void deinit(void);
211
212private:
213	/* Private methods */
214	virtual void configureParams(std::vector<TextureParameters>* params);
215	virtual void configureProgram(std::vector<TextureParameters>* params, glw::GLuint* texIds);
216	virtual void createProgram(void);
217
218	const char* getFragmentShaderCode(void) const;
219	const char* getVertexShaderCode(void) const;
220
221	/* Variables for general usage */
222	glw::GLuint m_fs_id;
223	glw::GLuint m_vs_id;
224};
225
226/* Compute Shader (Case 2)*/
227class TextureBufferActiveUniformValidationCS : public TextureBufferActiveUniformValidation
228{
229public:
230	/* Public methods */
231	TextureBufferActiveUniformValidationCS(Context& context, const ExtParameters& extParams, const char* name,
232										   const char* description);
233
234	virtual ~TextureBufferActiveUniformValidationCS()
235	{
236	}
237
238	virtual void deinit(void);
239
240private:
241	/* Private methods */
242	virtual void configureParams(std::vector<TextureParameters>* params);
243	virtual void configureProgram(std::vector<TextureParameters>* params, glw::GLuint* texIds);
244	virtual void createProgram(void);
245
246	const char* getComputeShaderCode(void) const;
247
248	/* Variables for general usage */
249	glw::GLuint m_cs_id;
250};
251
252} // namespace glcts
253
254#endif // _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP
255