Home | History | Annotate | Download | only in referencerenderer
      1 #ifndef _RRSHADERS_HPP
      2 #define _RRSHADERS_HPP
      3 /*-------------------------------------------------------------------------
      4  * drawElements Quality Program Reference Renderer
      5  * -----------------------------------------------
      6  *
      7  * Copyright 2014 The Android Open Source Project
      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 Shader interfaces.
     24  *//*--------------------------------------------------------------------*/
     25 
     26 #include "rrDefs.hpp"
     27 #include "rrVertexAttrib.hpp"
     28 #include "rrVertexPacket.hpp"
     29 #include "rrFragmentPacket.hpp"
     30 #include "rrPrimitivePacket.hpp"
     31 #include "rrShadingContext.hpp"
     32 #include "deString.h"
     33 
     34 namespace rr
     35 {
     36 
     37 /*--------------------------------------------------------------------*//*!
     38  * \brief Vertex shader input information
     39  *//*--------------------------------------------------------------------*/
     40 struct VertexInputInfo
     41 {
     42 	VertexInputInfo (void)
     43 	{
     44 		// sensible defaults
     45 		type = GENERICVECTYPE_LAST;
     46 	}
     47 
     48 	GenericVecType	type;
     49 };
     50 
     51 /*--------------------------------------------------------------------*//*!
     52  * \brief Shader varying information
     53  *//*--------------------------------------------------------------------*/
     54 struct VertexVaryingInfo
     55 {
     56 	VertexVaryingInfo (void)
     57 	{
     58 		// sensible defaults
     59 		type		= GENERICVECTYPE_LAST;
     60 		flatshade	= false;
     61 	}
     62 
     63 	// \note used by std::vector<T>::operator==() const
     64 	bool operator== (const VertexVaryingInfo& other) const
     65 	{
     66 		return	type == other.type &&
     67 				flatshade == other.flatshade;
     68 	}
     69 
     70 	GenericVecType	type;
     71 	bool			flatshade;
     72 };
     73 
     74 typedef VertexVaryingInfo VertexOutputInfo;
     75 typedef VertexVaryingInfo FragmentInputInfo;
     76 typedef VertexVaryingInfo GeometryInputInfo;
     77 typedef VertexVaryingInfo GeometryOutputInfo;
     78 
     79 /*--------------------------------------------------------------------*//*!
     80  * \brief Fragment shader output information
     81  *//*--------------------------------------------------------------------*/
     82 struct FragmentOutputInfo
     83 {
     84 	FragmentOutputInfo (void)
     85 	{
     86 		// sensible defaults
     87 		type = GENERICVECTYPE_LAST;
     88 	}
     89 
     90 	GenericVecType type;
     91 };
     92 
     93 /*--------------------------------------------------------------------*//*!
     94  * \brief Vertex shader interface
     95  *
     96  * Vertex shaders execute shading for set of vertex packets. See VertexPacket
     97  * documentation for more details on shading API.
     98  *//*--------------------------------------------------------------------*/
     99 class VertexShader
    100 {
    101 public:
    102 											VertexShader		(size_t numInputs, size_t numOutputs) : m_inputs(numInputs), m_outputs(numOutputs) {}
    103 
    104 	virtual void							shadeVertices		(const VertexAttrib* inputs, VertexPacket* const* packets, const int numPackets) const = 0;
    105 
    106 	const std::vector<VertexInputInfo>&		getInputs() const	{ return m_inputs; }
    107 	const std::vector<VertexOutputInfo>&	getOutputs() const	{ return m_outputs; }
    108 
    109 protected:
    110 											~VertexShader() {}; // \note Renderer will not delete any objects passed in.
    111 
    112 	std::vector<VertexInputInfo>			m_inputs;
    113 	std::vector<VertexOutputInfo>			m_outputs;
    114 };
    115 
    116 /*--------------------------------------------------------------------*//*!
    117  * \brief Fragment shader interface
    118  *
    119  * Fragment shader executes shading for list of fragment packets. See
    120  * FragmentPacket documentation for more details on shading API.
    121  *//*--------------------------------------------------------------------*/
    122 class FragmentShader
    123 {
    124 public:
    125 											FragmentShader		(size_t numInputs, size_t numOutputs) : m_inputs(numInputs), m_outputs(numOutputs) {}
    126 
    127 	const std::vector<FragmentInputInfo>&	getInputs() const	{ return m_inputs; }
    128 	const std::vector<FragmentOutputInfo>&	getOutputs() const	{ return m_outputs; }
    129 
    130 	virtual void							shadeFragments		(FragmentPacket* packets, const int numPackets, const FragmentShadingContext& context) const = 0; // \note numPackets must be greater than zero.
    131 
    132 protected:
    133 											~FragmentShader() {}; // \note Renderer will not delete any objects passed in.
    134 
    135 	std::vector<FragmentInputInfo>			m_inputs;
    136 	std::vector<FragmentOutputInfo>			m_outputs;
    137 };
    138 
    139 /*--------------------------------------------------------------------*//*!
    140  * \brief Geometry shader input primitive type
    141  *//*--------------------------------------------------------------------*/
    142 enum GeometryShaderInputType
    143 {
    144 	GEOMETRYSHADERINPUTTYPE_POINTS = 0,
    145 	GEOMETRYSHADERINPUTTYPE_LINES,
    146 	GEOMETRYSHADERINPUTTYPE_LINES_ADJACENCY,
    147 	GEOMETRYSHADERINPUTTYPE_TRIANGLES,
    148 	GEOMETRYSHADERINPUTTYPE_TRIANGLES_ADJACENCY,
    149 
    150 	GEOMETRYSHADERINPUTTYPE_LAST
    151 };
    152 
    153 /*--------------------------------------------------------------------*//*!
    154  * \brief Geometry shader output primitive type
    155  *//*--------------------------------------------------------------------*/
    156 enum GeometryShaderOutputType
    157 {
    158 	GEOMETRYSHADEROUTPUTTYPE_POINTS = 0,
    159 	GEOMETRYSHADEROUTPUTTYPE_LINE_STRIP,
    160 	GEOMETRYSHADEROUTPUTTYPE_TRIANGLE_STRIP,
    161 
    162 	GEOMETRYSHADEROUTPUTTYPE_LAST
    163 };
    164 
    165 /*--------------------------------------------------------------------*//*!
    166  * \brief Geometry shader interface
    167  *
    168  * Geometry shader executes a list of primitive packets and outputs
    169  * a new set of vertex packets for new primitives.
    170  *//*--------------------------------------------------------------------*/
    171 class GeometryShader
    172 {
    173 public:
    174 											GeometryShader		(size_t numVaryingInputs,
    175 																 size_t numVaryingOutputs,
    176 																 GeometryShaderInputType inputType,
    177 																 GeometryShaderOutputType outputType,
    178 																 size_t numVerticesOut,
    179 																 size_t numInvocations);
    180 
    181 	virtual void							shadePrimitives		(GeometryEmitter& output, int verticesIn, const PrimitivePacket* packets, const int numPackets, int invocationID) const = 0;
    182 
    183 	const std::vector<GeometryInputInfo>&	getInputs			(void) const { return m_inputs; }
    184 	const std::vector<GeometryOutputInfo>&	getOutputs			(void) const { return m_outputs; }
    185 	inline GeometryShaderInputType			getInputType		(void) const { return m_inputType; }
    186 	inline GeometryShaderOutputType			getOutputType		(void) const { return m_outputType; }
    187 	inline size_t							getNumVerticesOut	(void) const { return m_numVerticesOut; }
    188 	inline size_t							getNumInvocations	(void) const { return m_numInvocations; }
    189 
    190 protected:
    191 	const GeometryShaderInputType			m_inputType;
    192 	const GeometryShaderOutputType			m_outputType;
    193 	const size_t							m_numVerticesOut;
    194 	const size_t							m_numInvocations;
    195 
    196 	std::vector<GeometryInputInfo>			m_inputs;
    197 	std::vector<GeometryOutputInfo>			m_outputs;
    198 };
    199 
    200 // Helpers for shader implementations.
    201 
    202 template<class Shader>
    203 class VertexShaderLoop : public VertexShader
    204 {
    205 public:
    206 					VertexShaderLoop	(const Shader& shader) : m_shader(shader) {}
    207 
    208 	void			shadeVertices		(const VertexAttrib* inputs, VertexPacket* packets, const int numPackets) const;
    209 
    210 private:
    211 	const Shader&	m_shader;
    212 };
    213 
    214 template<class Shader>
    215 void VertexShaderLoop<Shader>::shadeVertices (const VertexAttrib* inputs, VertexPacket* packets, const int numPackets) const
    216 {
    217 	for (int ndx = 0; ndx < numPackets; ndx++)
    218 		m_shader.shadeVertex(inputs, packets[ndx]);
    219 }
    220 
    221 template<class Shader>
    222 class FragmentShaderLoop : public FragmentShader
    223 {
    224 public:
    225 					FragmentShaderLoop	(const Shader& shader) : m_shader(shader) {}
    226 
    227 	void			shadeFragments		(FragmentPacket* packets, const int numPackets) const;
    228 
    229 private:
    230 	const Shader&	m_shader;
    231 };
    232 
    233 template<class Shader>
    234 void FragmentShaderLoop<Shader>::shadeFragments (FragmentPacket* packets, const int numPackets) const
    235 {
    236 	for (int ndx = 0; ndx < numPackets; ndx++)
    237 		m_shader.shadeFragment(packets[ndx]);
    238 }
    239 
    240 } // rr
    241 
    242 #endif // _RRSHADERS_HPP
    243