1 // 2 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved. 3 // Use of this source code is governed by a BSD-style license that can be 4 // found in the LICENSE file. 5 // 6 7 #ifndef _CONSTANT_UNION_INCLUDED_ 8 #define _CONSTANT_UNION_INCLUDED_ 9 10 #include <assert.h> 11 12 class ConstantUnion { 13 public: 14 15 POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator) 16 void setIConst(int i) {iConst = i; type = EbtInt; } 17 void setFConst(float f) {fConst = f; type = EbtFloat; } 18 void setBConst(bool b) {bConst = b; type = EbtBool; } 19 20 int getIConst() { return iConst; } 21 float getFConst() { return fConst; } 22 bool getBConst() { return bConst; } 23 int getIConst() const { return iConst; } 24 float getFConst() const { return fConst; } 25 bool getBConst() const { return bConst; } 26 27 bool operator==(const int i) const 28 { 29 if (i == iConst) 30 return true; 31 32 return false; 33 } 34 35 bool operator==(const float f) const 36 { 37 if (f == fConst) 38 return true; 39 40 return false; 41 } 42 43 bool operator==(const bool b) const 44 { 45 if (b == bConst) 46 return true; 47 48 return false; 49 } 50 51 bool operator==(const ConstantUnion& constant) const 52 { 53 if (constant.type != type) 54 return false; 55 56 switch (type) { 57 case EbtInt: 58 if (constant.iConst == iConst) 59 return true; 60 61 break; 62 case EbtFloat: 63 if (constant.fConst == fConst) 64 return true; 65 66 break; 67 case EbtBool: 68 if (constant.bConst == bConst) 69 return true; 70 71 break; 72 } 73 74 return false; 75 } 76 77 bool operator!=(const int i) const 78 { 79 return !operator==(i); 80 } 81 82 bool operator!=(const float f) const 83 { 84 return !operator==(f); 85 } 86 87 bool operator!=(const bool b) const 88 { 89 return !operator==(b); 90 } 91 92 bool operator!=(const ConstantUnion& constant) const 93 { 94 return !operator==(constant); 95 } 96 97 bool operator>(const ConstantUnion& constant) const 98 { 99 assert(type == constant.type); 100 switch (type) { 101 case EbtInt: 102 if (iConst > constant.iConst) 103 return true; 104 105 return false; 106 case EbtFloat: 107 if (fConst > constant.fConst) 108 return true; 109 110 return false; 111 default: 112 assert(false && "Default missing"); 113 return false; 114 } 115 116 return false; 117 } 118 119 bool operator<(const ConstantUnion& constant) const 120 { 121 assert(type == constant.type); 122 switch (type) { 123 case EbtInt: 124 if (iConst < constant.iConst) 125 return true; 126 127 return false; 128 case EbtFloat: 129 if (fConst < constant.fConst) 130 return true; 131 132 return false; 133 default: 134 assert(false && "Default missing"); 135 return false; 136 } 137 138 return false; 139 } 140 141 ConstantUnion operator+(const ConstantUnion& constant) const 142 { 143 ConstantUnion returnValue; 144 assert(type == constant.type); 145 switch (type) { 146 case EbtInt: returnValue.setIConst(iConst + constant.iConst); break; 147 case EbtFloat: returnValue.setFConst(fConst + constant.fConst); break; 148 default: assert(false && "Default missing"); 149 } 150 151 return returnValue; 152 } 153 154 ConstantUnion operator-(const ConstantUnion& constant) const 155 { 156 ConstantUnion returnValue; 157 assert(type == constant.type); 158 switch (type) { 159 case EbtInt: returnValue.setIConst(iConst - constant.iConst); break; 160 case EbtFloat: returnValue.setFConst(fConst - constant.fConst); break; 161 default: assert(false && "Default missing"); 162 } 163 164 return returnValue; 165 } 166 167 ConstantUnion operator*(const ConstantUnion& constant) const 168 { 169 ConstantUnion returnValue; 170 assert(type == constant.type); 171 switch (type) { 172 case EbtInt: returnValue.setIConst(iConst * constant.iConst); break; 173 case EbtFloat: returnValue.setFConst(fConst * constant.fConst); break; 174 default: assert(false && "Default missing"); 175 } 176 177 return returnValue; 178 } 179 180 ConstantUnion operator%(const ConstantUnion& constant) const 181 { 182 ConstantUnion returnValue; 183 assert(type == constant.type); 184 switch (type) { 185 case EbtInt: returnValue.setIConst(iConst % constant.iConst); break; 186 default: assert(false && "Default missing"); 187 } 188 189 return returnValue; 190 } 191 192 ConstantUnion operator>>(const ConstantUnion& constant) const 193 { 194 ConstantUnion returnValue; 195 assert(type == constant.type); 196 switch (type) { 197 case EbtInt: returnValue.setIConst(iConst >> constant.iConst); break; 198 default: assert(false && "Default missing"); 199 } 200 201 return returnValue; 202 } 203 204 ConstantUnion operator<<(const ConstantUnion& constant) const 205 { 206 ConstantUnion returnValue; 207 assert(type == constant.type); 208 switch (type) { 209 case EbtInt: returnValue.setIConst(iConst << constant.iConst); break; 210 default: assert(false && "Default missing"); 211 } 212 213 return returnValue; 214 } 215 216 ConstantUnion operator&(const ConstantUnion& constant) const 217 { 218 ConstantUnion returnValue; 219 assert(type == constant.type); 220 switch (type) { 221 case EbtInt: returnValue.setIConst(iConst & constant.iConst); break; 222 default: assert(false && "Default missing"); 223 } 224 225 return returnValue; 226 } 227 228 ConstantUnion operator|(const ConstantUnion& constant) const 229 { 230 ConstantUnion returnValue; 231 assert(type == constant.type); 232 switch (type) { 233 case EbtInt: returnValue.setIConst(iConst | constant.iConst); break; 234 default: assert(false && "Default missing"); 235 } 236 237 return returnValue; 238 } 239 240 ConstantUnion operator^(const ConstantUnion& constant) const 241 { 242 ConstantUnion returnValue; 243 assert(type == constant.type); 244 switch (type) { 245 case EbtInt: returnValue.setIConst(iConst ^ constant.iConst); break; 246 default: assert(false && "Default missing"); 247 } 248 249 return returnValue; 250 } 251 252 ConstantUnion operator&&(const ConstantUnion& constant) const 253 { 254 ConstantUnion returnValue; 255 assert(type == constant.type); 256 switch (type) { 257 case EbtBool: returnValue.setBConst(bConst && constant.bConst); break; 258 default: assert(false && "Default missing"); 259 } 260 261 return returnValue; 262 } 263 264 ConstantUnion operator||(const ConstantUnion& constant) const 265 { 266 ConstantUnion returnValue; 267 assert(type == constant.type); 268 switch (type) { 269 case EbtBool: returnValue.setBConst(bConst || constant.bConst); break; 270 default: assert(false && "Default missing"); 271 } 272 273 return returnValue; 274 } 275 276 TBasicType getType() const { return type; } 277 private: 278 279 union { 280 int iConst; // used for ivec, scalar ints 281 bool bConst; // used for bvec, scalar bools 282 float fConst; // used for vec, mat, scalar floats 283 } ; 284 285 TBasicType type; 286 }; 287 288 #endif // _CONSTANT_UNION_INCLUDED_ 289
