1 #ifndef _RSGSHADER_HPP
2 #define _RSGSHADER_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program Random Shader Generator
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 Class.
24  *//*--------------------------------------------------------------------*/
25 
26 #include "rsgDefs.hpp"
27 #include "rsgVariable.hpp"
28 #include "rsgStatement.hpp"
29 #include "rsgVariableManager.hpp"
30 #include "rsgToken.hpp"
31 #include "rsgExecutionContext.hpp"
32 
33 #include <vector>
34 #include <string>
35 
36 namespace rsg
37 {
38 
39 class Function
40 {
41 public:
42 								Function			(void);
43 								Function			(const char* name);
44 								~Function			(void);
45 
getReturnType(void) const46 	const VariableType&			getReturnType		(void) const				{ return m_returnType;		}
setReturnType(const VariableType & type)47 	void						setReturnType		(const VariableType& type)	{ m_returnType = type;		}
48 
49 	void						addParameter		(Variable* variable);
50 
getBody(void)51 	BlockStatement&				getBody				(void)			{ return m_functionBlock;	}
getBody(void) const52 	const BlockStatement&		getBody				(void) const	{ return m_functionBlock;	}
53 
54 	void						tokenize			(GeneratorState& state, TokenStream& stream) const;
55 
56 private:
57 	std::string					m_name;
58 	std::vector<Variable*>		m_parameters;
59 	VariableType				m_returnType;
60 
61 	BlockStatement				m_functionBlock;
62 };
63 
64 class ShaderInput
65 {
66 public:
67 								ShaderInput			(const Variable* variable, ConstValueRangeAccess valueRange);
~ShaderInput(void)68 								~ShaderInput		(void) {}
69 
getVariable(void) const70 	const Variable*				getVariable			(void) const	{ return m_variable;	}
getValueRange(void) const71 	ConstValueRangeAccess		getValueRange		(void) const	{ return ConstValueRangeAccess(m_variable->getType(), &m_min[0], &m_max[0]);	}
getValueRange(void)72 	ValueRangeAccess			getValueRange		(void)			{ return ValueRangeAccess(m_variable->getType(), &m_min[0], &m_max[0]);			}
73 
74 private:
75 	const Variable*				m_variable;
76 	std::vector<Scalar>			m_min;
77 	std::vector<Scalar>			m_max;
78 };
79 
80 class Shader
81 {
82 public:
83 	enum Type
84 	{
85 		TYPE_VERTEX = 0,
86 		TYPE_FRAGMENT,
87 
88 		TYPE_LAST
89 	};
90 
91 								Shader				(Type type);
92 								~Shader				(void);
93 
getType(void) const94 	Type						getType				(void) const	{ return m_type;				}
getSource(void) const95 	const char*					getSource			(void) const	{ return m_source.c_str();		}
96 
97 	void						execute				(ExecutionContext& execCtx) const;
98 
99 	// For generator implementation only
getMain(void)100 	Function&					getMain				(void)			{ return m_mainFunction;		}
101 	Function&					allocateFunction	(void);
102 
getGlobalScope(void)103 	VariableScope&				getGlobalScope		(void)			{ return m_globalScope;			}
getGlobalStatements(void)104 	std::vector<Statement*>&	getGlobalStatements	(void)			{ return m_globalStatements;	}
105 
106 	void						tokenize			(GeneratorState& state, TokenStream& str) const;
setSource(const char * source)107 	void						setSource			(const char* source) { m_source = source;		}
108 
getInputs(void)109 	std::vector<ShaderInput*>&	getInputs			(void)			{ return m_inputs;				}
getUniforms(void)110 	std::vector<ShaderInput*>&	getUniforms			(void)			{ return m_uniforms;			}
111 
112 	// For executor
getInputs(void) const113 	const std::vector<ShaderInput*>&	getInputs	(void) const	{ return m_inputs;				}
getUniforms(void) const114 	const std::vector<ShaderInput*>&	getUniforms	(void) const	{ return m_uniforms;			}
115 	void								getOutputs	(std::vector<const Variable*>& outputs) const;
116 
117 private:
118 	Type						m_type;
119 
120 	VariableScope				m_globalScope;
121 	std::vector<Statement*>		m_globalStatements;
122 
123 	std::vector<ShaderInput*>	m_inputs;
124 	std::vector<ShaderInput*>	m_uniforms;
125 
126 	std::vector<Function*>		m_functions;
127 	Function					m_mainFunction;
128 
129 	std::string					m_source;
130 };
131 
132 } // rsg
133 
134 #endif // _RSGSHADER_HPP
135