framework/randomshaders/rsgExpression.hpp

   1 #ifndef _RSGEXPRESSION_HPP
   2 #define _RSGEXPRESSION_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 Expressions.
  24  *
  25  * Creating expressions:
  26  *  + Children must be created in in reverse evaluation order.
  27  *    - Must be tokenized / evaluated taking that order in account.
  28  *
  29  * Evaluation:
  30  *  + Done recursively. (Do we have enough stack?)
  31  *  + R-values: Nodes must implement getValue() in some way. Value
  32  *    must be valid after evaluate().
  33  *  + L-values: Valid writable value access proxy must be returned after
  34  *    evaluate().
  35  *//*--------------------------------------------------------------------*/
  36
  37 #include "rsgDefs.hpp"
  38 #include "rsgGeneratorState.hpp"
  39 #include "rsgVariableValue.hpp"
  40 #include "rsgVariable.hpp"
  41 #include "rsgVariableManager.hpp"
  42 #include "rsgExecutionContext.hpp"
  43
  44 namespace rsg
  45 {
  46
  47 // \todo [2011-06-10 pyry] Declare in ShaderParameters?
  48 const float unusedValueWeight = 0.05f;
  49
  50 class Expression
  51 {
  52 public:
  53         virtual                                                 ~Expression                     (void);
  54
  55         // Shader generation API
  56         virtual Expression*                             createNextChild         (GeneratorState& state) = DE_NULL;
  57         virtual void                                    tokenize                        (GeneratorState& state, TokenStream& str) const = DE_NULL;
  58
  59         // Execution API
  60         virtual void                                    evaluate                        (ExecutionContext& ctx) = DE_NULL;
  61         virtual ExecConstValueAccess    getValue                        (void) const                    = DE_NULL;
  62         virtual ExecValueAccess                 getLValue                       (void) const { DE_ASSERT(DE_FALSE); throw Exception("Expression::getLValue(): not L-value node"); }
  63
  64         static Expression*                              createRandom            (GeneratorState& state, ConstValueRangeAccess valueRange);
  65         static Expression*                              createRandomLValue      (GeneratorState& state, ConstValueRangeAccess valueRange);
  66 };
  67
  68 class VariableAccess : public Expression
  69 {
  70 public:
  71         virtual                                         ~VariableAccess         (void) {}
  72
  73         Expression*                                     createNextChild         (GeneratorState& state)                                                 { DE_UNREF(state); return DE_NULL;                                              }
  74         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const { DE_UNREF(state); str << Token(m_variable->getName()); }
  75
  76         void                                            evaluate                        (ExecutionContext& ctx);
  77         ExecConstValueAccess            getValue                        (void) const                                                                    { return m_valueAccess;                                                                 }
  78         ExecValueAccess                         getLValue                       (void) const                                                                    { return m_valueAccess;                                                                 }
  79
  80 protected:
  81                                                                 VariableAccess          (void) : m_variable(DE_NULL) {}
  82
  83         const Variable*                         m_variable;
  84         ExecValueAccess                         m_valueAccess;
  85 };
  86
  87 class VariableRead : public VariableAccess
  88 {
  89 public:
  90                                                                 VariableRead            (GeneratorState& state, ConstValueRangeAccess valueRange);
  91                                                                 VariableRead            (const Variable* variable);
  92         virtual                                         ~VariableRead           (void) {}
  93
  94         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
  95 };
  96
  97 class VariableWrite : public VariableAccess
  98 {
  99 public:
 100                                                                 VariableWrite           (GeneratorState& state, ConstValueRangeAccess valueRange);
 101         virtual                                         ~VariableWrite          (void) {}
 102
 103         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 104 };
 105
 106 class FloatLiteral : public Expression
 107 {
 108 public:
 109                                                                 FloatLiteral            (GeneratorState& state, ConstValueRangeAccess valueRange);
 110         virtual                                         ~FloatLiteral           (void) {}
 111
 112         Expression*                                     createNextChild         (GeneratorState& state) { DE_UNREF(state); return DE_NULL; }
 113         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 114
 115         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 116
 117         void                                            evaluate                        (ExecutionContext& ctx) { DE_UNREF(ctx); }
 118         ExecConstValueAccess            getValue                        (void) const { return m_value.getValue(VariableType::getScalarType(VariableType::TYPE_FLOAT)); }
 119
 120 private:
 121         ExecValueStorage                        m_value;
 122 };
 123
 124 class IntLiteral : public Expression
 125 {
 126 public:
 127                                                                 IntLiteral                      (GeneratorState& state, ConstValueRangeAccess valueRange);
 128         virtual                                         ~IntLiteral                     (void) {}
 129
 130         Expression*                                     createNextChild         (GeneratorState& state) { DE_UNREF(state); return DE_NULL; }
 131         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 132
 133         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 134
 135         void                                            evaluate                        (ExecutionContext& ctx) { DE_UNREF(ctx); }
 136         ExecConstValueAccess            getValue                        (void) const { return m_value.getValue(VariableType::getScalarType(VariableType::TYPE_INT)); }
 137
 138 private:
 139         ExecValueStorage                        m_value;
 140 };
 141
 142 class BoolLiteral : public Expression
 143 {
 144 public:
 145                                                                 BoolLiteral                     (GeneratorState& state, ConstValueRangeAccess valueRange);
 146         virtual                                         ~BoolLiteral            (void) {}
 147
 148         Expression*                                     createNextChild         (GeneratorState& state) { DE_UNREF(state); return DE_NULL; }
 149         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 150
 151         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 152
 153         void                                            evaluate                        (ExecutionContext& ctx) { DE_UNREF(ctx); }
 154         ExecConstValueAccess            getValue                        (void) const { return m_value.getValue(VariableType::getScalarType(VariableType::TYPE_BOOL)); }
 155
 156 private:
 157         ExecValueStorage                        m_value;
 158 };
 159
 160 class ConstructorOp : public Expression
 161 {
 162 public:
 163                                                                 ConstructorOp           (GeneratorState& state, ConstValueRangeAccess valueRange);
 164         virtual                                         ~ConstructorOp          (void);
 165
 166         Expression*                                     createNextChild         (GeneratorState& state);
 167         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 168
 169         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 170
 171         void                                            evaluate                        (ExecutionContext& ctx);
 172         ExecConstValueAccess            getValue                        (void) const { return m_value.getValue(m_valueRange.getType()); }
 173
 174 private:
 175         ValueRange                                      m_valueRange;
 176         ExecValueStorage                        m_value;
 177
 178         std::vector<ValueRange>         m_inputValueRanges;
 179         std::vector<Expression*>        m_inputExpressions;
 180 };
 181
 182 class AssignOp : public Expression
 183 {
 184 public:
 185                                                                 AssignOp                        (GeneratorState& state, ConstValueRangeAccess valueRange);
 186         virtual                                         ~AssignOp                       (void);
 187
 188         Expression*                                     createNextChild         (GeneratorState& state);
 189         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 190
 191         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 192
 193         // \todo [2011-02-28 pyry] LValue variant of AssignOp
 194 //      static float                            getLValueWeight         (const GeneratorState& state, ConstValueRangeAccess valueRange);
 195
 196         void                                            evaluate                        (ExecutionContext& ctx);
 197         ExecConstValueAccess            getValue                        (void) const { return m_value.getValue(m_valueRange.getType()); }
 198
 199 private:
 200         ValueRange                                      m_valueRange;
 201         ExecValueStorage                        m_value;
 202
 203         Expression*                                     m_lvalueExpr;
 204         Expression*                                     m_rvalueExpr;
 205 };
 206
 207 class ParenOp : public Expression
 208 {
 209 public:
 210                                                                 ParenOp                         (GeneratorState& state, ConstValueRangeAccess valueRange);
 211         virtual                                         ~ParenOp                        (void);
 212
 213         Expression*                                     createNextChild         (GeneratorState& state);
 214         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 215
 216         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 217
 218         void                                            evaluate                        (ExecutionContext& execCtx)             { m_child->evaluate(execCtx);   }
 219         ExecConstValueAccess            getValue                        (void) const                                    { return m_child->getValue();   }
 220
 221 private:
 222         ValueRange                                      m_valueRange;
 223         Expression*                                     m_child;
 224 };
 225
 226 class SwizzleOp : public Expression
 227 {
 228 public:
 229                                                                 SwizzleOp                       (GeneratorState& state, ConstValueRangeAccess valueRange);
 230         virtual                                         ~SwizzleOp                      (void);
 231
 232         Expression*                                     createNextChild         (GeneratorState& state);
 233         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 234
 235         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 236
 237         void                                            evaluate                        (ExecutionContext& execCtx);
 238         ExecConstValueAccess            getValue                        (void) const                                    { return m_value.getValue(m_outValueRange.getType()); }
 239
 240 private:
 241         ValueRange                                      m_outValueRange;
 242         int                                                     m_numInputElements;
 243         deUint8                                         m_swizzle[4];
 244         Expression*                                     m_child;
 245         ExecValueStorage                        m_value;
 246 };
 247
 248 class TexLookup : public Expression
 249 {
 250 public:
 251                                                                 TexLookup                       (GeneratorState& state, ConstValueRangeAccess valueRange);
 252         virtual                                         ~TexLookup                      (void);
 253
 254         Expression*                                     createNextChild         (GeneratorState& state);
 255         void                                            tokenize                        (GeneratorState& state, TokenStream& str) const;
 256
 257         static float                            getWeight                       (const GeneratorState& state, ConstValueRangeAccess valueRange);
 258
 259         void                                            evaluate                        (ExecutionContext& execCtx);
 260         ExecConstValueAccess            getValue                        (void) const { return m_value.getValue(m_valueType); }
 261
 262 private:
 263         enum Type
 264         {
 265                 TYPE_TEXTURE2D,
 266                 TYPE_TEXTURE2D_LOD,
 267                 TYPE_TEXTURE2D_PROJ,
 268                 TYPE_TEXTURE2D_PROJ_LOD,
 269
 270                 TYPE_TEXTURECUBE,
 271                 TYPE_TEXTURECUBE_LOD,
 272
 273                 TYPE_LAST
 274         };
 275
 276         Type                                            m_type;
 277         const Variable*                         m_sampler;
 278         Expression*                                     m_coordExpr;
 279         Expression*                                     m_lodBiasExpr;
 280         VariableType                            m_valueType;
 281         ExecValueStorage                        m_value;
 282 };
 283
 284 } // rsg
 285
 286 #endif // _RSGEXPRESSION_HPP