tests/llvmpipe/glsl/shader.h

   1 /*
   2  * Copyright © 2012-2021 VMware, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #pragma once
  25
  26 #include "call.h"
  27 #include "constant.h"
  28 #include "immediate.h"
  29 #include "binaryoperator.h"
  30
  31 #include <map>
  32
  33 namespace glsl
  34 {
  35    class Shader
  36    {
  37    public:
  38       Shader()
  39       {
  40          addVariable(Variable("vTexture0", Variable::BuiltIn, Value::vec4));
  41          addVariable(Variable("vFragColor", Variable::BuiltIn, Value::vec4));
  42
  43          addVariable(Variable("gl_Color", Variable::BuiltIn, Value::vec4));
  44          addVariable(Variable("gl_Vertex", Variable::BuiltIn, Value::vec4));
  45          addVariable(Variable("gl_Position", Variable::BuiltIn, Value::vec4));
  46          addVariable(Variable("gl_BackColor", Variable::BuiltIn, Value::vec4));
  47          addVariable(Variable("gl_FragColor", Variable::BuiltIn, Value::vec4));
  48          addVariable(Variable("gl_FrontColor", Variable::BuiltIn, Value::vec4));
  49          addVariable(Variable("gl_TexCoord[0]", Variable::BuiltIn, Value::vec4));
  50          addVariable(Variable("gl_MultiTexCoord0", Variable::BuiltIn, Value::vec4));
  51          addVariable(Variable("gl_ModelViewProjectionMatrix", Variable::BuiltIn, Value::vec4));
  52       }
  53
  54       ~Shader()
  55       {
  56          for (std::vector<Operator*>::iterator itr = mProgram.begin(); itr != mProgram.end(); ++itr)
  57             delete *itr;
  58       }
  59
  60       Constant addLocalVec4(const std::string& name)
  61       {
  62          return addVariable(Variable(name, Variable::Local, Value::vec4));
  63       }
  64
  65       Constant addUniformVec4(const std::string& name)
  66       {
  67          return addVariable(Variable(name, Variable::Uniform, Value::vec4));
  68       }
  69
  70       Constant addUniformSampler2D(const std::string& name)
  71       {
  72          return addVariable(Variable(name, Variable::UniformSampler, Value::none));
  73       }
  74
  75       Constant addVariable(const Variable& variable)
  76       {
  77          mVariables[variable.name()] = variable;
  78          return Constant(variable);
  79       }
  80
  81       Constant operator[](const std::string& name)
  82       {
  83          std::map<std::string, Variable>::iterator itr = mVariables.find(name);
  84          assert(itr != mVariables.end());
  85          return Constant(itr->second);
  86       }
  87
  88       Variable& variable(const std::string& name)
  89       {
  90          return mVariables[name];
  91       }
  92
  93       Shader& operator<<(Operator* op)
  94       {
  95          mProgram.push_back(op);
  96          return *this;
  97       }
  98
  99       void start(ShaderState& state)
 100       {
 101          state = ShaderState(mVariables);
 102       }
 103
 104       void run(ShaderState& state)
 105       {
 106          for (std::vector<Operator*>::const_iterator itr = mProgram.begin(); itr != mProgram.end(); ++itr) {
 107             (*itr)->execute(state);
 108          }
 109       }
 110
 111       void end(ShaderState& state)
 112       {
 113       }
 114
 115       std::string toGLSL() const
 116       {
 117          std::stringstream ss;
 118          ss.precision(9);
 119
 120          for (std::map<std::string, Variable>::const_iterator itr = mVariables.begin(); itr != mVariables.end(); ++itr) {
 121             const Variable& var = itr->second;
 122
 123             if (var.declare())
 124                ss << var.toGLSL() << ";" << std::endl;
 125          }
 126
 127          if (ss.tellp())
 128             ss << std::endl;
 129
 130          ss << "void main(void)" << std::endl;
 131          ss << "{" << std::endl;
 132
 133          for (std::map<std::string, Variable>::const_iterator itr = mVariables.begin(); itr != mVariables.end(); ++itr) {
 134             const Variable& var = itr->second;
 135
 136             if (var.type() == Variable::Local)
 137                ss << "\t" << var.toGLSL() << ";" << std::endl;
 138          }
 139
 140          for (std::vector<Operator*>::const_iterator itr = mProgram.begin(); itr != mProgram.end(); ++itr) {
 141             ss << "\t" << (*itr)->toGLSL() << ";" << std::endl;
 142          }
 143
 144          ss << "}" << std::endl;
 145          return ss.str();
 146       }
 147
 148       const std::map<std::string, Variable>& variables() const
 149       {
 150          return mVariables;
 151       }
 152
 153    private:
 154       std::map<std::string, Variable> mVariables;
 155       std::vector<Operator*> mProgram;
 156    };
 157 }