framework/randomshaders/rsgShader.hpp

   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
  46         const VariableType&                     getReturnType           (void) const                            { return m_returnType;          }
  47         void                                            setReturnType           (const VariableType& type)      { m_returnType = type;          }
  48
  49         void                                            addParameter            (Variable* variable);
  50
  51         BlockStatement&                         getBody                         (void)                  { return m_functionBlock;       }
  52         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);
  68                                                                 ~ShaderInput            (void) {}
  69
  70         const Variable*                         getVariable                     (void) const    { return m_variable;    }
  71         ConstValueRangeAccess           getValueRange           (void) const    { return ConstValueRangeAccess(m_variable->getType(), &m_min[0], &m_max[0]);    }
  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
  94         Type                                            getType                         (void) const    { return m_type;                                }
  95         const char*                                     getSource                       (void) const    { return m_source.c_str();              }
  96
  97         void                                            execute                         (ExecutionContext& execCtx) const;
  98
  99         // For generator implementation only
 100         Function&                                       getMain                         (void)                  { return m_mainFunction;                }
 101         Function&                                       allocateFunction        (void);
 102
 103         VariableScope&                          getGlobalScope          (void)                  { return m_globalScope;                 }
 104         std::vector<Statement*>&        getGlobalStatements     (void)                  { return m_globalStatements;    }
 105
 106         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 107         void                                            setSource                       (const char* source) { m_source = source;               }
 108
 109         std::vector<ShaderInput*>&      getInputs                       (void)                  { return m_inputs;                              }
 110         std::vector<ShaderInput*>&      getUniforms                     (void)                  { return m_uniforms;                    }
 111
 112         // For executor
 113         const std::vector<ShaderInput*>&        getInputs       (void) const    { return m_inputs;                              }
 114         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