| #ifndef _RSGSHADER_HPP |
| #define _RSGSHADER_HPP |
| /*------------------------------------------------------------------------- |
| * drawElements Quality Program Random Shader Generator |
| * ---------------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * 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 Shader Class. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "rsgDefs.hpp" |
| #include "rsgVariable.hpp" |
| #include "rsgStatement.hpp" |
| #include "rsgVariableManager.hpp" |
| #include "rsgToken.hpp" |
| #include "rsgExecutionContext.hpp" |
| |
| #include <vector> |
| #include <string> |
| |
| namespace rsg |
| { |
| |
| class Function |
| { |
| public: |
| Function(void); |
| Function(const char *name); |
| ~Function(void); |
| |
| const VariableType &getReturnType(void) const |
| { |
| return m_returnType; |
| } |
| void setReturnType(const VariableType &type) |
| { |
| m_returnType = type; |
| } |
| |
| void addParameter(Variable *variable); |
| |
| BlockStatement &getBody(void) |
| { |
| return m_functionBlock; |
| } |
| const BlockStatement &getBody(void) const |
| { |
| return m_functionBlock; |
| } |
| |
| void tokenize(GeneratorState &state, TokenStream &stream) const; |
| |
| private: |
| std::string m_name; |
| std::vector<Variable *> m_parameters; |
| VariableType m_returnType; |
| |
| BlockStatement m_functionBlock; |
| }; |
| |
| class ShaderInput |
| { |
| public: |
| ShaderInput(const Variable *variable, ConstValueRangeAccess valueRange); |
| ~ShaderInput(void) |
| { |
| } |
| |
| const Variable *getVariable(void) const |
| { |
| return m_variable; |
| } |
| ConstValueRangeAccess getValueRange(void) const |
| { |
| return ConstValueRangeAccess(m_variable->getType(), &m_min[0], &m_max[0]); |
| } |
| ValueRangeAccess getValueRange(void) |
| { |
| return ValueRangeAccess(m_variable->getType(), &m_min[0], &m_max[0]); |
| } |
| |
| private: |
| const Variable *m_variable; |
| std::vector<Scalar> m_min; |
| std::vector<Scalar> m_max; |
| }; |
| |
| class Shader |
| { |
| public: |
| enum Type |
| { |
| TYPE_VERTEX = 0, |
| TYPE_FRAGMENT, |
| |
| TYPE_LAST |
| }; |
| |
| Shader(Type type); |
| ~Shader(void); |
| |
| Type getType(void) const |
| { |
| return m_type; |
| } |
| const char *getSource(void) const |
| { |
| return m_source.c_str(); |
| } |
| |
| void execute(ExecutionContext &execCtx) const; |
| |
| // For generator implementation only |
| Function &getMain(void) |
| { |
| return m_mainFunction; |
| } |
| Function &allocateFunction(void); |
| |
| VariableScope &getGlobalScope(void) |
| { |
| return m_globalScope; |
| } |
| std::vector<Statement *> &getGlobalStatements(void) |
| { |
| return m_globalStatements; |
| } |
| |
| void tokenize(GeneratorState &state, TokenStream &str) const; |
| void setSource(const char *source) |
| { |
| m_source = source; |
| } |
| |
| std::vector<ShaderInput *> &getInputs(void) |
| { |
| return m_inputs; |
| } |
| std::vector<ShaderInput *> &getUniforms(void) |
| { |
| return m_uniforms; |
| } |
| |
| // For executor |
| const std::vector<ShaderInput *> &getInputs(void) const |
| { |
| return m_inputs; |
| } |
| const std::vector<ShaderInput *> &getUniforms(void) const |
| { |
| return m_uniforms; |
| } |
| void getOutputs(std::vector<const Variable *> &outputs) const; |
| |
| private: |
| Type m_type; |
| |
| VariableScope m_globalScope; |
| std::vector<Statement *> m_globalStatements; |
| |
| std::vector<ShaderInput *> m_inputs; |
| std::vector<ShaderInput *> m_uniforms; |
| |
| std::vector<Function *> m_functions; |
| Function m_mainFunction; |
| |
| std::string m_source; |
| }; |
| |
| } // namespace rsg |
| |
| #endif // _RSGSHADER_HPP |