1 #ifndef _RSGVARIABLEVALUE_HPP 2 #define _RSGVARIABLEVALUE_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 Variable Value class. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "rsgDefs.hpp" 27 #include "rsgVariableType.hpp" 28 #include "rsgVariable.hpp" 29 #include "tcuVector.hpp" 30 31 #include <algorithm> 32 33 namespace rsg 34 { 35 36 union Scalar 37 { 38 int intVal; 39 float floatVal; 40 bool boolVal; 41 42 Scalar (void) : intVal (0) {} 43 Scalar (float v) : floatVal (v) {} 44 Scalar (int v) : intVal (v) {} 45 Scalar (bool v) : boolVal (v) {} 46 47 // Bit-exact compare 48 bool operator== (Scalar other) const { return intVal == other.intVal; } 49 bool operator!= (Scalar other) const { return intVal != other.intVal; } 50 51 template <typename T> static Scalar min (void); 52 template <typename T> static Scalar max (void); 53 54 template <typename T> T as (void) const; 55 template <typename T> T& as (void); 56 }; 57 DE_STATIC_ASSERT(sizeof(Scalar) == sizeof(deUint32)); 58 59 template <> inline Scalar Scalar::min<float> (void) { return Scalar((int)0xff800000); } 60 template <> inline Scalar Scalar::max<float> (void) { return Scalar((int)0x7f800000); } 61 template <> inline Scalar Scalar::min<int> (void) { return Scalar((int)0x80000000); } 62 template <> inline Scalar Scalar::max<int> (void) { return Scalar((int)0x7fffffff); } 63 template <> inline Scalar Scalar::min<bool> (void) { return Scalar(false); } 64 template <> inline Scalar Scalar::max<bool> (void) { return Scalar(true); } 65 66 template <> inline float Scalar::as<float> (void) const { return floatVal; } 67 template <> inline float& Scalar::as<float> (void) { return floatVal; } 68 template <> inline int Scalar::as<int> (void) const { return intVal; } 69 template <> inline int& Scalar::as<int> (void) { return intVal; } 70 template <> inline bool Scalar::as<bool> (void) const { return boolVal; } 71 template <> inline bool& Scalar::as<bool> (void) { return boolVal; } 72 73 template <int Stride> 74 class StridedValueRead 75 { 76 public: 77 StridedValueRead (const VariableType& type, const Scalar* value) : m_type(type), m_value(value) {} 78 79 const VariableType& getType (void) const { return m_type; } 80 const Scalar* getValuePtr (void) const { return m_value; } 81 82 private: 83 const VariableType& m_type; 84 const Scalar* m_value; 85 }; 86 87 template <int Stride> 88 class ConstStridedValueAccess 89 { 90 public: 91 ConstStridedValueAccess (void) : m_type(DE_NULL), m_value(DE_NULL) {} 92 ConstStridedValueAccess (const VariableType& type, const Scalar* valuePtr) : m_type(&type), m_value(const_cast<Scalar*>(valuePtr)) {} 93 94 const VariableType& getType (void) const { return *m_type; } 95 96 // Read-only access 97 ConstStridedValueAccess component (int compNdx) const { return ConstStridedValueAccess(getType().getElementType(), m_value + Stride*compNdx); } 98 ConstStridedValueAccess arrayElement (int elementNdx) const { return ConstStridedValueAccess(getType().getElementType(), m_value + Stride*getType().getElementScalarOffset(elementNdx)); } 99 ConstStridedValueAccess member (int memberNdx) const { return ConstStridedValueAccess(getType().getMembers()[memberNdx].getType(), m_value + Stride*getType().getMemberScalarOffset(memberNdx)); } 100 101 float asFloat (void) const { DE_STATIC_ASSERT(Stride == 1); return m_value->floatVal; } 102 int asInt (void) const { DE_STATIC_ASSERT(Stride == 1); return m_value->intVal; } 103 bool asBool (void) const { DE_STATIC_ASSERT(Stride == 1); return m_value->boolVal; } 104 Scalar asScalar (void) const { DE_STATIC_ASSERT(Stride == 1); return *m_value; } 105 106 float asFloat (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return m_value[ndx].floatVal; } 107 int asInt (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return m_value[ndx].intVal; } 108 bool asBool (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return m_value[ndx].boolVal; } 109 Scalar asScalar (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return m_value[ndx]; } 110 111 template <typename T> 112 T as (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return this->m_value[ndx].template as<T>(); } 113 114 // For assignment: b = a.value() 115 StridedValueRead<Stride> value (void) const { return StridedValueRead<Stride>(getType(), m_value); } 116 117 protected: 118 const VariableType* m_type; 119 Scalar* m_value; // \note Non-const internal pointer is used so that ValueAccess can extend this class with RW access 120 }; 121 122 template <int Stride> 123 class StridedValueAccess : public ConstStridedValueAccess<Stride> 124 { 125 public: 126 StridedValueAccess (void) {} 127 StridedValueAccess (const VariableType& type, Scalar* valuePtr) : ConstStridedValueAccess<Stride>(type, valuePtr) {} 128 129 // Read-write access 130 StridedValueAccess component (int compNdx) { return StridedValueAccess(this->getType().getElementType(), this->m_value + Stride*compNdx); } 131 StridedValueAccess arrayElement (int elementNdx) { return StridedValueAccess(this->getType().getElementType(), this->m_value + Stride*this->getType().getElementScalarOffset(elementNdx)); } 132 StridedValueAccess member (int memberNdx) { return StridedValueAccess(this->getType().getMembers()[memberNdx].getType(), this->m_value + Stride*this->getType().getMemberScalarOffset(memberNdx)); } 133 134 float& asFloat (void) { DE_STATIC_ASSERT(Stride == 1); return this->m_value->floatVal; } 135 int& asInt (void) { DE_STATIC_ASSERT(Stride == 1); return this->m_value->intVal; } 136 bool& asBool (void) { DE_STATIC_ASSERT(Stride == 1); return this->m_value->boolVal; } 137 Scalar& asScalar (void) { DE_STATIC_ASSERT(Stride == 1); return *this->m_value; } 138 139 float& asFloat (int ndx) { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return this->m_value[ndx].floatVal; } 140 int& asInt (int ndx) { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return this->m_value[ndx].intVal; } 141 bool& asBool (int ndx) { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return this->m_value[ndx].boolVal; } 142 Scalar& asScalar (int ndx) { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return this->m_value[ndx]; } 143 144 template <typename T> 145 T& as (int ndx) { DE_ASSERT(de::inBounds(ndx, 0, Stride)); return this->m_value[ndx].template as<T>(); } 146 147 template <int SrcStride> 148 StridedValueAccess& operator= (const StridedValueRead<SrcStride>& value); 149 150 // Helpers, work only in Stride == 1 case 151 template <int Size> 152 StridedValueAccess& operator= (const tcu::Vector<float, Size>& vec); 153 StridedValueAccess& operator= (float floatVal) { asFloat() = floatVal; return *this; } 154 StridedValueAccess& operator= (int intVal) { asInt() = intVal; return *this; } 155 StridedValueAccess& operator= (bool boolVal) { asBool() = boolVal; return *this; } 156 StridedValueAccess& operator= (Scalar val) { asScalar() = val; return *this; } 157 }; 158 159 template <int Stride> 160 template <int SrcStride> 161 StridedValueAccess<Stride>& StridedValueAccess<Stride>::operator= (const StridedValueRead<SrcStride>& valueRead) 162 { 163 DE_STATIC_ASSERT(SrcStride == Stride || SrcStride == 1); 164 DE_ASSERT(this->getType() == valueRead.getType()); 165 166 int scalarSize = this->getType().getScalarSize(); 167 168 if (scalarSize == 0) 169 return *this; // Happens when void value range is copied 170 171 if (Stride == SrcStride) 172 std::copy(valueRead.getValuePtr(), valueRead.getValuePtr() + scalarSize*Stride, this->m_value); 173 else 174 { 175 for (int scalarNdx = 0; scalarNdx < scalarSize; scalarNdx++) 176 std::fill(this->m_value + scalarNdx*Stride, this->m_value + (scalarNdx+1)*Stride, valueRead.getValuePtr()[scalarNdx]); 177 } 178 179 return *this; 180 } 181 182 template <int Stride> 183 template <int Size> 184 StridedValueAccess<Stride>& StridedValueAccess<Stride>::operator= (const tcu::Vector<float, Size>& vec) 185 { 186 DE_ASSERT(this->getType() == VariableType(VariableType::TYPE_FLOAT, Size)); 187 for (int comp = 0; comp < 4; comp++) 188 component(comp).asFloat() = vec.getPtr()[comp]; 189 190 return *this; 191 } 192 193 // Typedefs for stride == 1 case 194 typedef ConstStridedValueAccess<1> ConstValueAccess; 195 typedef StridedValueAccess<1> ValueAccess; 196 197 class ConstValueRangeAccess 198 { 199 public: 200 ConstValueRangeAccess (void) : m_type(DE_NULL), m_min(DE_NULL), m_max(DE_NULL) {} 201 ConstValueRangeAccess (const VariableType& type, const Scalar* minVal, const Scalar* maxVal) : m_type(&type), m_min(const_cast<Scalar*>(minVal)), m_max(const_cast<Scalar*>(maxVal)) {} 202 203 const VariableType& getType (void) const { return *m_type; } 204 ConstValueAccess getMin (void) const { return ConstValueAccess(*m_type, m_min); } 205 ConstValueAccess getMax (void) const { return ConstValueAccess(*m_type, m_max); } 206 207 // Read-only access 208 ConstValueRangeAccess component (int compNdx) const; 209 ConstValueRangeAccess arrayElement (int elementNdx) const; 210 ConstValueRangeAccess member (int memberNdx) const; 211 212 // Set operations - tests condition for all elements 213 bool intersects (const ConstValueRangeAccess& other) const; 214 bool isSupersetOf (const ConstValueRangeAccess& other) const; 215 bool isSubsetOf (const ConstValueRangeAccess& other) const; 216 217 protected: 218 const VariableType* m_type; 219 Scalar* m_min; // \note See note in ConstValueAccess 220 Scalar* m_max; 221 }; 222 223 inline ConstValueRangeAccess ConstValueRangeAccess::component (int compNdx) const 224 { 225 return ConstValueRangeAccess(m_type->getElementType(), m_min + compNdx, m_max + compNdx); 226 } 227 228 inline ConstValueRangeAccess ConstValueRangeAccess::arrayElement (int elementNdx) const 229 { 230 int offset = m_type->getElementScalarOffset(elementNdx); 231 return ConstValueRangeAccess(m_type->getElementType(), m_min + offset, m_max + offset); 232 } 233 234 inline ConstValueRangeAccess ConstValueRangeAccess::member (int memberNdx) const 235 { 236 int offset = m_type->getMemberScalarOffset(memberNdx); 237 return ConstValueRangeAccess(m_type->getMembers()[memberNdx].getType(), m_min + offset, m_max + offset); 238 } 239 240 class ValueRangeAccess : public ConstValueRangeAccess 241 { 242 public: 243 ValueRangeAccess (const VariableType& type, Scalar* minVal, Scalar* maxVal) : ConstValueRangeAccess(type, minVal, maxVal) {} 244 245 // Read-write access 246 ValueAccess getMin (void) { return ValueAccess(*m_type, m_min); } 247 ValueAccess getMax (void) { return ValueAccess(*m_type, m_max); } 248 249 ValueRangeAccess component (int compNdx); 250 ValueRangeAccess arrayElement (int elementNdx); 251 ValueRangeAccess member (int memberNdx); 252 }; 253 254 inline ValueRangeAccess ValueRangeAccess::component (int compNdx) 255 { 256 return ValueRangeAccess(m_type->getElementType(), m_min + compNdx, m_max + compNdx); 257 } 258 259 inline ValueRangeAccess ValueRangeAccess::arrayElement (int elementNdx) 260 { 261 int offset = m_type->getElementScalarOffset(elementNdx); 262 return ValueRangeAccess(m_type->getElementType(), m_min + offset, m_max + offset); 263 } 264 265 inline ValueRangeAccess ValueRangeAccess::member (int memberNdx) 266 { 267 int offset = m_type->getMemberScalarOffset(memberNdx); 268 return ValueRangeAccess(m_type->getMembers()[memberNdx].getType(), m_min + offset, m_max + offset); 269 } 270 271 class ValueRange 272 { 273 public: 274 ValueRange (const VariableType& type); 275 ValueRange (const VariableType& type, const ConstValueAccess& minVal, const ConstValueAccess& maxVal); 276 ValueRange (const VariableType& type, const Scalar* minVal, const Scalar* maxVal); 277 ValueRange (ConstValueRangeAccess other); 278 ~ValueRange (void); 279 280 const VariableType& getType (void) const { return m_type; } 281 282 ValueAccess getMin (void) { return ValueAccess(m_type, getMinPtr()); } 283 ValueAccess getMax (void) { return ValueAccess(m_type, getMaxPtr()); } 284 285 ConstValueAccess getMin (void) const { return ConstValueAccess(m_type, getMinPtr()); } 286 ConstValueAccess getMax (void) const { return ConstValueAccess(m_type, getMaxPtr()); } 287 288 ValueRangeAccess asAccess (void) { return ValueRangeAccess(m_type, getMinPtr(), getMaxPtr()); } 289 ConstValueRangeAccess asAccess (void) const { return ConstValueRangeAccess(m_type, getMinPtr(), getMaxPtr()); } 290 291 operator ConstValueRangeAccess (void) const { return asAccess(); } 292 operator ValueRangeAccess (void) { return asAccess(); } 293 294 static void computeIntersection (ValueRangeAccess dst, const ConstValueRangeAccess& a, const ConstValueRangeAccess& b); 295 static void computeIntersection (ValueRange& dst, const ConstValueRangeAccess& a, const ConstValueRangeAccess& b); 296 297 private: 298 const Scalar* getMinPtr (void) const { return m_min.empty() ? DE_NULL : &m_min[0]; } 299 const Scalar* getMaxPtr (void) const { return m_max.empty() ? DE_NULL : &m_max[0]; } 300 301 Scalar* getMinPtr (void) { return m_min.empty() ? DE_NULL : &m_min[0]; } 302 Scalar* getMaxPtr (void) { return m_max.empty() ? DE_NULL : &m_max[0]; } 303 304 VariableType m_type; 305 std::vector<Scalar> m_min; 306 std::vector<Scalar> m_max; 307 }; 308 309 template <int Stride> 310 class ValueStorage 311 { 312 public: 313 ValueStorage (void); 314 ValueStorage (const VariableType& type); 315 316 void setStorage (const VariableType& type); 317 318 StridedValueAccess<Stride> getValue (const VariableType& type) { return StridedValueAccess<Stride>(type, &m_value[0]); } 319 ConstStridedValueAccess<Stride> getValue (const VariableType& type) const { return ConstStridedValueAccess<Stride>(type, &m_value[0]); } 320 321 private: 322 ValueStorage (const ValueStorage& other); 323 ValueStorage operator= (const ValueStorage& other); 324 325 std::vector<Scalar> m_value; 326 }; 327 328 template <int Stride> 329 ValueStorage<Stride>::ValueStorage (void) 330 { 331 } 332 333 template <int Stride> 334 ValueStorage<Stride>::ValueStorage (const VariableType& type) 335 { 336 setStorage(type); 337 } 338 339 template <int Stride> 340 void ValueStorage<Stride>::setStorage (const VariableType& type) 341 { 342 m_value.resize(type.getScalarSize() * Stride); 343 } 344 345 class VariableValue 346 { 347 public: 348 VariableValue (const Variable* variable) : m_variable(variable), m_storage(m_variable->getType()) {} 349 ~VariableValue (void) {} 350 351 const Variable* getVariable (void) const { return m_variable; } 352 ValueAccess getValue (void) { return m_storage.getValue(m_variable->getType()); } 353 ConstValueAccess getValue (void) const { return m_storage.getValue(m_variable->getType()); } 354 355 VariableValue (const VariableValue& other); 356 VariableValue& operator= (const VariableValue& other); 357 358 private: 359 const VariableType& getType (void) const { return m_variable->getType(); } 360 361 const Variable* m_variable; 362 ValueStorage<1> m_storage; 363 }; 364 365 } // rsg 366 367 #endif // _RSGVARIABLEVALUE_HPP 368
