1 #ifndef _RSGGENERATORSTATE_HPP 2 #define _RSGGENERATORSTATE_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 Generator state. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "rsgDefs.hpp" 27 #include "rsgParameters.hpp" 28 #include "deRandom.hpp" 29 #include "rsgNameAllocator.hpp" 30 31 #include <vector> 32 33 namespace rsg 34 { 35 36 class Shader; 37 class VariableManager; 38 class VariableType; 39 class Statement; 40 41 enum ExpressionFlags 42 { 43 CONST_EXPR = (1 << 0), 44 NO_VAR_ALLOCATION = (1 << 1) 45 }; 46 47 enum 48 { 49 PRECEDENCE_MAX = 100 50 }; 51 52 class GeneratorState 53 { 54 public: 55 GeneratorState(const ProgramParameters &programParams, de::Random &random); 56 ~GeneratorState(void); 57 getProgramParameters(void) const58 const ProgramParameters &getProgramParameters(void) const 59 { 60 return m_programParams; 61 } getRandom(void)62 de::Random &getRandom(void) 63 { 64 return m_random; 65 } 66 getShaderParameters(void) const67 const ShaderParameters &getShaderParameters(void) const 68 { 69 return *m_shaderParams; 70 } getShader(void)71 Shader &getShader(void) 72 { 73 return *m_shader; 74 } 75 76 void setShader(const ShaderParameters ¶ms, Shader &shader); 77 getNameAllocator(void)78 NameAllocator &getNameAllocator(void) 79 { 80 return m_nameAllocator; 81 } getVariableManager(void)82 VariableManager &getVariableManager(void) 83 { 84 return *m_varManager; 85 } getVariableManager(void) const86 const VariableManager &getVariableManager(void) const 87 { 88 return *m_varManager; 89 } setVariableManager(VariableManager & varManager)90 void setVariableManager(VariableManager &varManager) 91 { 92 m_varManager = &varManager; 93 } 94 95 // \todo [2011-06-10 pyry] Could we not expose whole statement stack to everyone? getStatementDepth(void) const96 int getStatementDepth(void) const 97 { 98 return (int)m_statementStack->size(); 99 } setStatementStack(std::vector<Statement * > & stack)100 void setStatementStack(std::vector<Statement *> &stack) 101 { 102 m_statementStack = &stack; 103 } getStatementStackEntry(int ndx) const104 const Statement *getStatementStackEntry(int ndx) const 105 { 106 return m_statementStack->at(ndx); 107 } 108 getExpressionDepth(void) const109 int getExpressionDepth(void) const 110 { 111 return m_expressionDepth; 112 } setExpressionDepth(int depth)113 void setExpressionDepth(int depth) 114 { 115 m_expressionDepth = depth; 116 } 117 118 // \todo [2011-03-21 pyry] A bit of a hack... Move to ValueRange? getExpressionFlags(void) const119 uint32_t getExpressionFlags(void) const 120 { 121 return m_exprFlagStack.back(); 122 } pushExpressionFlags(uint32_t flags)123 void pushExpressionFlags(uint32_t flags) 124 { 125 m_exprFlagStack.push_back(flags); 126 } popExpressionFlags(void)127 void popExpressionFlags(void) 128 { 129 m_exprFlagStack.pop_back(); 130 } 131 getPrecedence(void) const132 int getPrecedence(void) const 133 { 134 return m_precedenceStack.back(); 135 } pushPrecedence(int precedence)136 void pushPrecedence(int precedence) 137 { 138 m_precedenceStack.push_back(precedence); 139 } popPrecedence(void)140 void popPrecedence(void) 141 { 142 m_precedenceStack.pop_back(); 143 } 144 145 private: 146 const ProgramParameters &m_programParams; 147 de::Random &m_random; 148 149 const ShaderParameters *m_shaderParams; 150 Shader *m_shader; 151 152 NameAllocator m_nameAllocator; 153 VariableManager *m_varManager; 154 155 std::vector<Statement *> *m_statementStack; 156 int m_expressionDepth; 157 std::vector<uint32_t> m_exprFlagStack; 158 std::vector<int> m_precedenceStack; 159 }; 160 161 } // namespace rsg 162 163 #endif // _RSGGENERATORSTATE_HPP 164