tests/llvmpipe/glsl/variable.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 "value.h"
  27
  28 namespace glsl
  29 {
  30    class Variable
  31    {
  32    public:
  33       enum Type {
  34          BuiltIn,
  35          Attribute,
  36          Local,
  37          Varying,
  38          Uniform,
  39          UniformSampler
  40       };
  41
  42    public:
  43       Variable()
  44          : mType(BuiltIn), mLocation(0)
  45       {
  46       }
  47
  48       Variable(const std::string& name, Type type, const Value& value)
  49          : mType(type), mName(name), mValue(value), mLocation(0)
  50       {
  51       }
  52
  53       const std::string& name() const
  54       {
  55          return mName;
  56       }
  57
  58       std::string toGLSL() const
  59       {
  60          if (mType == UniformSampler) {
  61             return std::string("uniform sampler2D ") + mName;
  62          } else if (mType == Uniform) {
  63             return std::string("uniform ") + mValue.toTypeString() + " " + mName;
  64          } else if (mType == Varying) {
  65             return std::string("varying ") + mValue.toTypeString() + " " + mName;
  66          } else if (mType == Attribute) {
  67             return std::string("attribute ") + mValue.toTypeString() + " " + mName;
  68          } else {
  69             return mValue.toTypeString() + " " + mName;
  70          }
  71       }
  72
  73       Type type() const
  74       {
  75          return mType;
  76       }
  77
  78       unsigned int location()
  79       {
  80          return mLocation;
  81       }
  82
  83       void setType(Type type)
  84       {
  85          mType = type;
  86       }
  87
  88       void setLocation(unsigned int location)
  89       {
  90          mLocation = location;
  91       }
  92
  93       bool declare() const
  94       {
  95          return isAttribute() || isVarying() || isUniform();
  96       }
  97
  98       bool isAttribute() const
  99       {
 100          return mType == Attribute;
 101       }
 102
 103       bool isUniform() const
 104       {
 105          return mType == Uniform || mType == UniformSampler;
 106       }
 107
 108       bool isVarying() const
 109       {
 110          return mType == Varying;
 111       }
 112
 113       Value value() const
 114       {
 115          return mValue;
 116       }
 117
 118       template<typename T>
 119       T* valuePtr() const
 120       {
 121          return mValue.valuePtr<T>();
 122       }
 123
 124       template<typename T>
 125       T& value() const
 126       {
 127          return mValue.value<T>();
 128       }
 129
 130       Variable& operator=(const Value& rhs)
 131       {
 132          mValue = rhs;
 133          return *this;
 134       }
 135
 136    private:
 137       Type mType;
 138       std::string mName;
 139       Value mValue;
 140       unsigned int mLocation;
 141    };
 142 }