external/openglcts/modules/glesext/geometry_shader/esextcGeometryShaderLayeredRenderingBoundaryCondition.hpp

#ifndef _ESEXTCGEOMETRYSHADERLAYEREDRENDERINGBOUNDARYCONDITION_HPP
#define _ESEXTCGEOMETRYSHADERLAYEREDRENDERINGBOUNDARYCONDITION_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
 */ /*-------------------------------------------------------------------*/

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

namespace glcts
{
/** Implementation of "Group 10" from CTS_EXT_geometry_shader. */
class GeometryShaderLayeredRenderingBoundaryCondition : public TestCaseBase
{
public:
	/* Public methods */
	virtual void		  deinit(void);
	virtual IterateResult iterate(void);

protected:
	/* Protected data types */
	struct TextureInfo
	{
		glw::GLint  m_depth;
		glw::GLenum m_draw_buffer;
		glw::GLuint m_id;
		glw::GLenum m_texture_target;
	};

	/* Protected methods */
	GeometryShaderLayeredRenderingBoundaryCondition(Context& context, const ExtParameters& extParams, const char* name,
													const char* description);

	virtual ~GeometryShaderLayeredRenderingBoundaryCondition(void);

	virtual void		initTest(void);
	virtual const char* getFragmentShaderCode();
	virtual const char* getGeometryShaderCode();
	virtual const char* getVertexShaderCode();

	virtual bool comparePixels(glw::GLint width, glw::GLint height, glw::GLint pixelSize,
							   const unsigned char* textureData, const unsigned char* referencePixel, int att,
							   int layer);

	virtual void getReferenceColor(glw::GLint layerIndex, unsigned char* colorBuffer,
								   int colorBufferSize = m_texture_components) = 0;

protected:
	/* Protected variables */
	glw::GLenum				 m_draw_mode;
	glw::GLuint				 m_n_points;
	bool					 m_is_fbo_layered;
	std::vector<TextureInfo> m_textures_info;
	unsigned char*			 m_blue_color;
	unsigned char*			 m_green_color;
	unsigned char*			 m_red_color;
	unsigned char*			 m_white_color;

private:
	/* Private constants */
	static const glw::GLint m_height;
	static const glw::GLint m_max_depth;
	static const glw::GLint m_texture_components;
	static const glw::GLint m_width;

	/* Private variables */
	glw::GLuint m_fbo_draw_id;
	glw::GLuint m_fbo_read_id;
	glw::GLuint m_fs_id;
	glw::GLuint m_gs_id;
	glw::GLuint m_po_id;
	glw::GLuint m_vao_id;
	glw::GLuint m_vs_id;
};

/**
 *    1. Only the smallest number of layers of layered framebuffer's attachments
 *       should be affected by draw calls, if the number of layers of each
 *       attachment is not identical.
 *
 *       Category: API;
 *                 Functional Test.
 *
 *       Consider a layered FBO with the following configuration:
 *
 *       - A 3D texture object A (resolution: 4x4x2), whose base level was bound
 *         to color attachment 0;
 *       - A 3D texture object B (resolution: 4x4x4), whose base level was
 *         bound to color attachment 1;
 *
 *       All slices/layers of these texture objects are filled with black color.
 *
 *       A geometry shader should accept points on input and output triangle
 *       strips with a maximum of 4*16 vertices. The shader should emit 4
 *       "screen-space quads" (as described in test case 8.1, for instance),
 *       with each quad occupying layers at subsequently incremental indices.
 *       Each quad should have a different color (shared by all quad's vertices).
 *
 *       The test should make a draw call for a single point and then check the
 *       texture objects. Test passes if only the first two layers of the texture
 *       objects were modified.
 */
class GeometryShaderLayeredRenderingBoundaryConditionVariousTextures
	: public GeometryShaderLayeredRenderingBoundaryCondition
{
public:
	/* Public methods */
	GeometryShaderLayeredRenderingBoundaryConditionVariousTextures(Context& context, const ExtParameters& extParams,
																   const char* name, const char* description);

	virtual ~GeometryShaderLayeredRenderingBoundaryConditionVariousTextures(void)
	{
	}

protected:
	/* Protected methods */
	const char* getFragmentShaderCode();
	const char* getGeometryShaderCode();
	void getReferenceColor(glw::GLint layerIndex, unsigned char* colorBuffer, int colorBufferSize);
};

/**
 *    2. Default layer number for fragments is zero if there is no geometry shader
 *       defined for the active pipeline.
 *
 *       Category: API;
 *                 Functional Test.
 *
 *       Consider a layered FBO with the following configuration:
 *
 *       - Base level of a 3D texture object A of resolution 4x4x4 attached to
 *         color attachment 0.
 *
 *       All slices of texture object A should be filled with (0, 0, 0, 0).
 *
 *       A program object A should consist of vertex shader B and fragment shader
 *       C. Vertex shader B should:
 *
 *       - Set gl_Position to (-1, -1, 0, 1) if gl_VertexID == 0;
 *       - Set gl_Position to (-1,  1, 0, 1) if gl_VertexID == 1;
 *       - Set gl_Position to ( 1,  1, 0, 1) if gl_VertexID == 2;
 *       - Set gl_Position to ( 1, -1, 0, 1) otherwise.
 *
 *       Fragment shader C should set the only output vec4 variable to
 *       (1, 1, 1, 1).
 *
 *       Having bound the layered FBO to GL_FRAMEBUFFER targets, the test should
 *       draw a triangle fan made of 4 vertices.It should then read back first
 *       two slices of the texture object A:
 *
 *       - All texels of the first slice should be set to (255, 255, 255, 255)
 *         (assuming glReadPixels() was called with GL_RGBA format &
 *         GL_UNSIGNED_BYTE type).
 *       - All texels of the second slice should be set to (0, 0, 0, 0)
 *         (assumption as above).
 */
class GeometryShaderLayeredRenderingBoundaryConditionNoGS : public GeometryShaderLayeredRenderingBoundaryCondition
{
public:
	/* Public methods */
	GeometryShaderLayeredRenderingBoundaryConditionNoGS(Context& context, const ExtParameters& extParams,
														const char* name, const char* description);

	virtual ~GeometryShaderLayeredRenderingBoundaryConditionNoGS(void)
	{
	}

protected:
	/* Protected methods */
	const char* getVertexShaderCode();
	void getReferenceColor(glw::GLint layerIndex, unsigned char* colorBuffer, int colorBufferSize);
};

/**
 *    3. Default layer number for fragments is zero if the geometry shader used
 *       for current pipeline does not set gl_Layer in any of the execution paths.
 *
 *       Category: API;
 *                 Functional Test.
 *
 *       Modify test case 10.2 to introduce a boilerplate geometry shader that:
 *
 *       - generates a triangle strip, takes the same input and emits the same
 *         output primitive types as in test case 8.1;
 *       - does NOT set layer id for any of the outputted vertices.
 *
 *       Vertex shader can be boilerplate in this case.
 *
 *       The test should draw a single point and perform the same check as in test
 *       case 10.2.
 */
class GeometryShaderLayeredRenderingBoundaryConditionNoLayerSet : public GeometryShaderLayeredRenderingBoundaryCondition
{
public:
	/* Public methods */
	GeometryShaderLayeredRenderingBoundaryConditionNoLayerSet(Context& context, const ExtParameters& extParams,
															  const char* name, const char* description);

	virtual ~GeometryShaderLayeredRenderingBoundaryConditionNoLayerSet(void)
	{
	}

protected:
	/* Protected methods */
	const char* getGeometryShaderCode();
	void getReferenceColor(glw::GLint layerIndex, unsigned char* colorBuffer, int colorBufferSize);
};

/**    4. Layer number specified by geometry shader is ignored if current draw
 *       FBO is not layered.
 *
 *       Category: API;
 *                 Functional Test.
 *
 *       Consider a framebuffer object A with the following configuration:
 *
 *       - 3D texture object A of resolution 4x4x4, with all slices filled with
 *         (0, 0, 0, 0), is bound to color attachment 0;
 *
 *       Vertex shader can be boilerplate.
 *       Geometry shader should take form of the geometry shader described in test
 *       case 10.3. However, it should set gl_Layer to 1 for all vertices emitted.
 *       Fragment shader should take form of the vertex shader C described in test
 *       case 10.2.
 *
 *       The test should then draw a single point, read first two slices of texture
 *       object A and:
 *
 *       - make sure first slice is filled with (255, 255, 255, 255), assuming
 *         glReadPixels() call with GL_RGBA format and GL_UNSIGNED_BYTE type.
 *       - make sure second slice is filled with (0, 0, 0, 0) (assumptions as
 *         above)
 *
 */
class GeometryShaderLayeredRenderingBoundaryConditionNoLayeredFBO
	: public GeometryShaderLayeredRenderingBoundaryCondition
{
public:
	/* Public methods */
	GeometryShaderLayeredRenderingBoundaryConditionNoLayeredFBO(Context& context, const ExtParameters& extParams,
																const char* name, const char* description);

	virtual ~GeometryShaderLayeredRenderingBoundaryConditionNoLayeredFBO(void)
	{
	}

protected:
	/* Protected methods */
	virtual const char* getGeometryShaderCode();
	virtual void getReferenceColor(glw::GLint layerIndex, unsigned char* colorBuffer, int colorBufferSize);
};

} // namespace glcts

#endif // _ESEXTCGEOMETRYSHADERLAYEREDRENDERINGBOUNDARYCONDITION_HPP