tests/llvmpipe/glsl/value.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 <string>
  27 #include <vector>
  28 #include <sstream>
  29
  30 #include "../utils/colour.h"
  31
  32 namespace glsl
  33 {
  34    class Value
  35    {
  36    public:
  37       static const Value none;
  38       static const Value vec2;
  39       static const Value vec3;
  40       static const Value vec4;
  41
  42    public:
  43       Value()
  44          : mSize(0)
  45       {
  46       }
  47
  48       Value(int components, float value)
  49          : mSize(0)
  50       {
  51          for (int i = 0; i < components; ++i)
  52             add(value);
  53       }
  54
  55       Value(float x)
  56          : mSize(0)
  57       {
  58          add(x);
  59       }
  60
  61       Value(float x, float y)
  62          : mSize(0)
  63       {
  64          add(x);
  65          add(y);
  66       }
  67
  68       Value(float x, float y, float z)
  69          : mSize(0)
  70       {
  71          add(x);
  72          add(y);
  73          add(z);
  74       }
  75
  76       Value(float x, float y, float z, float w)
  77          : mSize(0)
  78       {
  79          add(x);
  80          add(y);
  81          add(z);
  82          add(w);
  83       }
  84
  85       Value(const Colour& colour)
  86          : mSize(4)
  87       {
  88          memcpy(mValue, (const float*)colour, sizeof(float) * 4);
  89       }
  90
  91       Value(const Value& other)
  92          : mSize(other.mSize)
  93       {
  94          memcpy(mValue, other.mValue, sizeof(float) * 4);
  95       }
  96
  97       template<typename T>
  98       static Value create(const T& val)
  99       {
 100          Value value;
 101          *(value.valuePtr<T>()) = val;
 102          return value;
 103       }
 104
 105       float& x()
 106       {
 107          assert(mSize >= 1);
 108          return mValue[0];
 109       }
 110
 111       float& y()
 112       {
 113          assert(mSize >= 2);
 114          return mValue[1];
 115       }
 116
 117       float& z()
 118       {
 119          assert(mSize >= 3);
 120          return mValue[2];
 121       }
 122
 123       float& w()
 124       {
 125          assert(mSize == 4);
 126          return mValue[3];
 127       }
 128
 129       float& operator[](int i)
 130       {
 131          return mValue[i];
 132       }
 133
 134       const float& operator[](int i) const
 135       {
 136          return mValue[i];
 137       }
 138
 139       operator const GLfloat*() const
 140       {
 141          return mValue;
 142       }
 143
 144       size_t size() const
 145       {
 146          return mSize;
 147       }
 148
 149       void add(float value)
 150       {
 151          assert(mSize < 4);
 152          mValue[mSize++] = value;
 153       }
 154
 155       template<typename T>
 156       T* valuePtr() const
 157       {
 158          return (T*)&mValue;
 159       }
 160
 161       template<typename T>
 162       T& value() const
 163       {
 164          return *(T*)&mValue;
 165       }
 166
 167       std::string toTypeString() const
 168       {
 169          if (mSize == 1)
 170             return "float";
 171
 172          std::string type = "vec";
 173          type.push_back((char)('0' + mSize));
 174          return type;
 175       }
 176
 177       std::string toString() const
 178       {
 179          std::stringstream ss;
 180          ss.precision(9);
 181
 182          ss << std::fixed;
 183
 184          if (mSize > 1)
 185             ss << "vec" << mSize << "(";
 186
 187          for (size_t i = 0; i < mSize; ++i) {
 188             if (i > 0)
 189                ss << ", ";
 190
 191             ss << mValue[i];
 192          }
 193
 194          if (mSize > 1)
 195             ss << ")";
 196
 197          return ss.str();
 198       }
 199
 200       bool operator >(const Value& rhs) const
 201       {
 202          assert(mSize == rhs.mSize);
 203
 204          for (size_t i = 0; i < mSize; ++i) {
 205             if (! (mValue[i] > rhs[i]) )
 206                return false;
 207          }
 208
 209          return true;
 210       }
 211
 212       bool operator <(const Value& rhs) const
 213       {
 214          assert(mSize == rhs.mSize);
 215
 216          for (size_t i = 0; i < mSize; ++i) {
 217             if (! (mValue[i] < rhs[i]) )
 218                return false;
 219          }
 220
 221          return true;
 222       }
 223
 224       bool operator >=(const Value& rhs) const
 225       {
 226          assert(mSize == rhs.mSize);
 227
 228          for (size_t i = 0; i < mSize; ++i) {
 229             if (! (mValue[i] >= rhs[i]) )
 230                return false;
 231          }
 232
 233          return true;
 234       }
 235
 236       bool operator <=(const Value& rhs) const
 237       {
 238          assert(mSize == rhs.mSize);
 239
 240          for (size_t i = 0; i < mSize; ++i) {
 241             if (! (mValue[i] <= rhs[i]) )
 242                return false;
 243          }
 244
 245          return true;
 246       }
 247
 248       Value& operator =(const Value& rhs)
 249       {
 250          mSize = rhs.mSize;
 251          memcpy(mValue, rhs.mValue, sizeof(float) * 4);
 252          return *this;
 253       }
 254
 255       Value& operator =(const Colour& rhs)
 256       {
 257          mSize = 4;
 258          memcpy(mValue, (const float*)rhs, sizeof(float) * 4);
 259          return *this;
 260       }
 261
 262       Value& operator +=(const Value& rhs)
 263       {
 264          *this = *this + rhs;
 265          return *this;
 266       }
 267
 268       Value& operator -=(const Value& rhs)
 269       {
 270          *this = *this- rhs;
 271          return *this;
 272       }
 273
 274       Value& operator *=(const Value& rhs)
 275       {
 276          *this = *this * rhs;
 277          return *this;
 278       }
 279
 280       Value& operator /=(const Value& rhs)
 281       {
 282          *this = *this / rhs;
 283          return *this;
 284       }
 285
 286       Value operator +(const Value& rhs) const
 287       {
 288          assert(mSize == rhs.mSize);
 289
 290          Value result;
 291          result.mSize = mSize;
 292
 293          for (size_t i = 0; i < mSize; ++i)
 294             result.mValue[i] = mValue[i] + rhs.mValue[i];
 295
 296          return result;
 297       }
 298
 299       Value operator -(const Value& rhs) const
 300       {
 301          assert(mSize == rhs.mSize);
 302
 303          Value result;
 304          result.mSize = mSize;
 305
 306          for (size_t i = 0; i < mSize; ++i)
 307             result.mValue[i] = mValue[i] - rhs.mValue[i];
 308
 309          return result;
 310       }
 311
 312       Value operator *(const Value& rhs) const
 313       {
 314          assert(mSize == rhs.mSize || rhs.mSize == 1);
 315
 316          Value result;
 317          result.mSize = mSize;
 318
 319          if (rhs.mSize == 1) {
 320             for (size_t i = 0; i < rhs.mSize; ++i) {
 321                result.mValue[i] = mValue[i] * rhs.mValue[0];
 322             }
 323          } else {
 324             for (size_t i = 0; i < mSize; ++i) {
 325                result.mValue[i] = mValue[i] * rhs.mValue[i];
 326             }
 327          }
 328
 329          return result;
 330       }
 331
 332       Value operator /(const Value& rhs) const
 333       {
 334          assert(mSize == rhs.mSize || rhs.mSize == 1);
 335
 336          Value result;
 337          result.mSize = mSize;
 338
 339          if (rhs.mSize == 1) {
 340             for (size_t i = 0; i < rhs.mSize; ++i) {
 341                result.mValue[i] = mValue[i] / rhs.mValue[0];
 342             }
 343          } else {
 344             for (size_t i = 0; i < mSize; ++i) {
 345                result.mValue[i] = mValue[i] / rhs.mValue[i];
 346             }
 347          }
 348
 349          return result;
 350       }
 351
 352    protected:
 353       size_t mSize;
 354       float mValue[4];
 355    };
 356
 357    Value vec2(float x, float y);
 358    Value vec3(float x, float y, float z);
 359    Value vec4(float x, float y, float z, float w);
 360 }