external/openglcts/modules/glesext/texture_buffer/esextcTextureBufferActiveUniformValidation.hpp

#ifndef _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP
#define _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_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  esextcTextureBufferActiveUniformValidation.hpp
 * \brief Texture Buffer -  Active Uniform Value Validation (Test 8)
 */ /*-------------------------------------------------------------------*/

#include "../esextcTestCaseBase.hpp"
#include <map>

namespace glcts
{

/** Implementation of (Test 8) from CTS_EXT_texture_buffer. Description follows
 *
 *   Check whether glGetActiveUniform, glGetActiveUniformsiv and
 *   glGetProgramResourceiv functions return correct information about active
 *   uniform variables of the type:
 *
 *   SAMPLER_BUFFER_EXT
 *   INT_SAMPLER_BUFFER_EXT
 *   UNSIGNED_INT_SAMPLER_BUFFER_EXT
 *   IMAGE_BUFFER_EXT
 *   INT_IMAGE_BUFFER_EXT
 *   UNSIGNED_INT_IMAGE_BUFFER_EXT
 *
 *   Category: API.
 *
 *   Write a fragment shader that defines the following uniform variables:
 *
 *   uniform highp samplerBuffer   sampler_buffer;
 *   uniform highp isamplerBuffer  isampler_buffer;
 *   uniform highp usamplerBuffer  usampler_buffer;
 *
 *   Make sure each of the uniform variables will be considered active.
 *   A uniform variable is considered active if it is determined during the link
 *   operation that it may be accessed during program execution. The easiest way
 *   to make sure the above variables are active is to call texelFetch on each
 *   texture sampler and imageLoad on each image sampler and use the returned
 *   values to determine the output color.
 *
 *   Pair the fragment shader with a boilerplate vertex shader.
 *
 *   Compile vertex and fragment shader, attach them to a program object and link
 *   the program object.
 *
 *   Get the number of active uniforms in the program object by calling
 *   glGetProgramiv with the value GL_ACTIVE_UNIFORMS and store the result in
 *   n_active_uniforms variable.
 *
 *   For index values ranging from zero to n_active_uniforms - 1 get the information
 *   about the uniform variable by calling glGetActiveUniform.
 *
 *   This phase of the test passes if among the returned information
 *   about active uniforms for the specified program object we can identify:
 *
 *   Name:               Type:
 *
 *   "sampler_buffer"    SAMPLER_BUFFER_EXT
 *   "isampler_buffer"   INT_SAMPLER_BUFFER_EXT
 *   "usampler_buffer"   UNSIGNED_INT_SAMPLER_BUFFER_EXT
 *
 *   Store which index corresponds to which variable type.
 *
 *   Create an array holding uniform variables' indices ranging from
 *   zero to n_active_uniforms - 1.
 *
 *   Call
 *
 *   glGetActiveUniformsiv( po_id, n_active_uniforms, indices_array,
 *       GL_UNIFORM_TYPE, types_array );
 *
 *   This phase of the test passes if the resulting types array holds for each
 *   index value in indices_array the same uniform type as returned previously by
 *   glGetActiveUniform called for this index.
 *
 *   For index values ranging from zero to n_active_uniforms - 1
 *   get the type information about the uniform variable by calling
 *   glGetProgramResourceiv with GL_UNIFORM program interface and GL_TYPE property.
 *
 *   This phase of the test passes if for each index value the returned type is
 *   equal to the one previously returned by glGetActiveUniform.
 *
 *   Repeat the test for a compute shader that defines the following uniform
 *   variables:
 *
 *   uniform highp   imageBuffer     image_buffer;
 *   uniform highp   iimageBuffer    iimage_buffer;
 *   uniform highp   uimageBuffer    uimage_buffer;
 *
 *   The corresponding types for the above uniform variables are:
 *
 *   IMAGE_BUFFER_EXT
 *   INT_IMAGE_BUFFER_EXT
 *   UNSIGNED_INT_IMAGE_BUFFER_EXT
 *
 */

/* Helper Sctructure storing texture confituration parameters */
class TextureParameters
{
public:
	TextureParameters();
	TextureParameters(glw::GLuint textureBufferSize, glw::GLenum textureFormat, glw::GLenum textureUniformType,
					  const char* uniformName);

	glw::GLuint get_texture_buffer_size() const
	{
		return m_texture_buffer_size;
	}

	glw::GLenum get_texture_format() const
	{
		return m_texture_format;
	}

	glw::GLenum get_texture_uniform_type() const
	{
		return m_texture_uniform_type;
	}

	std::string get_uniform_name() const
	{
		return m_uniform_name;
	}

private:
	glw::GLenum m_texture_buffer_size;
	glw::GLenum m_texture_format;
	glw::GLenum m_texture_uniform_type;
	std::string m_uniform_name;
};

/* Base Class */
class TextureBufferActiveUniformValidation : public TestCaseBase
{
public:
	/* Public methods */
	TextureBufferActiveUniformValidation(Context& context, const ExtParameters& extParams, const char* name,
										 const char* description);

	virtual ~TextureBufferActiveUniformValidation()
	{
	}

	virtual void		  deinit(void);
	virtual IterateResult iterate(void);

protected:
	/* Protected methods */
	void addTextureParam(glw::GLenum uniformType, glw::GLenum format, glw::GLuint size, const char* name,
						 std::vector<TextureParameters>* params);

	/* Protected variables */
	glw::GLuint m_po_id;

	static const glw::GLuint m_param_value_size;

private:
	/* Private methods */
	virtual void configureParams(std::vector<TextureParameters>* params) = 0;
	virtual void configureProgram(std::vector<TextureParameters>* params, glw::GLuint* texIds) = 0;
	virtual void createProgram(void) = 0;

	virtual void initTest(void);
	const char* getUniformTypeName(glw::GLenum uniformType);
	const TextureParameters* getParamsForType(glw::GLenum uniformType) const;

	/* Variables for general usage */
	glw::GLuint*				   m_tbo_ids;
	glw::GLuint*				   m_tbo_tex_ids;
	std::vector<TextureParameters> m_texture_params;
};

/* Vertex/Fragment Shader (Case 1)*/
class TextureBufferActiveUniformValidationVSFS : public TextureBufferActiveUniformValidation
{
public:
	/* Public methods */
	TextureBufferActiveUniformValidationVSFS(Context& context, const ExtParameters& extParams, const char* name,
											 const char* description);

	virtual ~TextureBufferActiveUniformValidationVSFS()
	{
	}

	virtual void deinit(void);

private:
	/* Private methods */
	virtual void configureParams(std::vector<TextureParameters>* params);
	virtual void configureProgram(std::vector<TextureParameters>* params, glw::GLuint* texIds);
	virtual void createProgram(void);

	const char* getFragmentShaderCode(void) const;
	const char* getVertexShaderCode(void) const;

	/* Variables for general usage */
	glw::GLuint m_fs_id;
	glw::GLuint m_vs_id;
};

/* Compute Shader (Case 2)*/
class TextureBufferActiveUniformValidationCS : public TextureBufferActiveUniformValidation
{
public:
	/* Public methods */
	TextureBufferActiveUniformValidationCS(Context& context, const ExtParameters& extParams, const char* name,
										   const char* description);

	virtual ~TextureBufferActiveUniformValidationCS()
	{
	}

	virtual void deinit(void);

private:
	/* Private methods */
	virtual void configureParams(std::vector<TextureParameters>* params);
	virtual void configureProgram(std::vector<TextureParameters>* params, glw::GLuint* texIds);
	virtual void createProgram(void);

	const char* getComputeShaderCode(void) const;

	/* Variables for general usage */
	glw::GLuint m_cs_id;
};

} // namespace glcts

#endif // _ESEXTCTEXTUREBUFFERACTIVEUNIFORMVALIDATION_HPP