1 #ifndef _TCUTEXTURE_HPP 2 #define _TCUTEXTURE_HPP 3 /*------------------------------------------------------------------------- 4 * drawElements Quality Program Tester Core 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 Reference Texture Implementation. 24 *//*--------------------------------------------------------------------*/ 25 26 #include "tcuDefs.hpp" 27 #include "tcuVector.hpp" 28 #include "rrGenericVector.hpp" 29 #include "deArrayBuffer.hpp" 30 31 #include <vector> 32 #include <ostream> 33 34 namespace tcu 35 { 36 37 /*--------------------------------------------------------------------*//*! 38 * \brief Texture format 39 *//*--------------------------------------------------------------------*/ 40 class TextureFormat 41 { 42 public: 43 enum ChannelOrder 44 { 45 R = 0, 46 A, 47 I, 48 L, 49 LA, 50 RG, 51 RA, 52 RGB, 53 RGBA, 54 ARGB, 55 BGR, 56 BGRA, 57 58 sR, 59 sRG, 60 sRGB, 61 sRGBA, 62 sBGR, 63 sBGRA, 64 65 D, 66 S, 67 DS, 68 69 CHANNELORDER_LAST 70 }; 71 72 enum ChannelType 73 { 74 SNORM_INT8 = 0, 75 SNORM_INT16, 76 SNORM_INT32, 77 UNORM_INT8, 78 UNORM_INT16, 79 UNORM_INT24, 80 UNORM_INT32, 81 UNORM_BYTE_44, 82 UNORM_SHORT_565, 83 UNORM_SHORT_555, 84 UNORM_SHORT_4444, 85 UNORM_SHORT_5551, 86 UNORM_SHORT_1555, 87 UNORM_INT_101010, 88 SNORM_INT_1010102_REV, 89 UNORM_INT_1010102_REV, 90 UNSIGNED_BYTE_44, 91 UNSIGNED_SHORT_565, 92 UNSIGNED_SHORT_4444, 93 UNSIGNED_SHORT_5551, 94 SIGNED_INT_1010102_REV, 95 UNSIGNED_INT_1010102_REV, 96 UNSIGNED_INT_11F_11F_10F_REV, 97 UNSIGNED_INT_999_E5_REV, 98 UNSIGNED_INT_16_8_8, 99 UNSIGNED_INT_24_8, 100 UNSIGNED_INT_24_8_REV, 101 SIGNED_INT8, 102 SIGNED_INT16, 103 SIGNED_INT32, 104 UNSIGNED_INT8, 105 UNSIGNED_INT16, 106 UNSIGNED_INT24, 107 UNSIGNED_INT32, 108 HALF_FLOAT, 109 FLOAT, 110 FLOAT64, 111 FLOAT_UNSIGNED_INT_24_8_REV, 112 113 UNORM_SHORT_10, 114 UNORM_SHORT_12, 115 116 CHANNELTYPE_LAST 117 }; 118 119 ChannelOrder order; 120 ChannelType type; 121 122 TextureFormat (ChannelOrder order_, ChannelType type_) 123 : order (order_) 124 , type (type_) 125 { 126 } 127 128 TextureFormat (void) 129 : order (CHANNELORDER_LAST) 130 , type (CHANNELTYPE_LAST) 131 { 132 } 133 134 int getPixelSize (void) const; //!< Deprecated, use tcu::getPixelSize(fmt) 135 136 bool operator== (const TextureFormat& other) const { return !(*this != other); } 137 bool operator!= (const TextureFormat& other) const 138 { 139 return (order != other.order || type != other.type); 140 } 141 } DE_WARN_UNUSED_TYPE; 142 143 bool isValid (TextureFormat format); 144 int getPixelSize (TextureFormat format); 145 int getNumUsedChannels (TextureFormat::ChannelOrder order); 146 int getChannelSize (TextureFormat::ChannelType type); 147 148 /*--------------------------------------------------------------------*//*! 149 * \brief Texture swizzle 150 *//*--------------------------------------------------------------------*/ 151 struct TextureSwizzle 152 { 153 enum Channel 154 { 155 // \note CHANNEL_N must equal int N 156 CHANNEL_0 = 0, 157 CHANNEL_1, 158 CHANNEL_2, 159 CHANNEL_3, 160 161 CHANNEL_ZERO, 162 CHANNEL_ONE, 163 164 CHANNEL_LAST 165 }; 166 167 Channel components[4]; 168 }; 169 170 //! get the swizzle used to expand texture data with a given channel order to RGBA form 171 const TextureSwizzle& getChannelReadSwizzle (TextureFormat::ChannelOrder order); 172 173 //! get the swizzle used to narrow RGBA form data to native texture data with a given channel order 174 const TextureSwizzle& getChannelWriteSwizzle (TextureFormat::ChannelOrder order); 175 176 /*--------------------------------------------------------------------*//*! 177 * \brief Sampling parameters 178 *//*--------------------------------------------------------------------*/ 179 class Sampler 180 { 181 public: 182 enum WrapMode 183 { 184 CLAMP_TO_EDGE = 0, //! Clamp to edge 185 CLAMP_TO_BORDER, //! Use border color at edge 186 REPEAT_GL, //! Repeat with OpenGL semantics 187 REPEAT_CL, //! Repeat with OpenCL semantics 188 MIRRORED_REPEAT_GL, //! Mirrored repeat with OpenGL semantics 189 MIRRORED_REPEAT_CL, //! Mirrored repeat with OpenCL semantics 190 MIRRORED_ONCE, //! Mirrored once in negative directions 191 192 WRAPMODE_LAST 193 }; 194 195 enum FilterMode 196 { 197 NEAREST = 0, 198 LINEAR, 199 200 NEAREST_MIPMAP_NEAREST, 201 NEAREST_MIPMAP_LINEAR, 202 LINEAR_MIPMAP_NEAREST, 203 LINEAR_MIPMAP_LINEAR, 204 205 FILTERMODE_LAST 206 }; 207 208 enum CompareMode 209 { 210 COMPAREMODE_NONE = 0, 211 COMPAREMODE_LESS, 212 COMPAREMODE_LESS_OR_EQUAL, 213 COMPAREMODE_GREATER, 214 COMPAREMODE_GREATER_OR_EQUAL, 215 COMPAREMODE_EQUAL, 216 COMPAREMODE_NOT_EQUAL, 217 COMPAREMODE_ALWAYS, 218 COMPAREMODE_NEVER, 219 220 COMPAREMODE_LAST 221 }; 222 223 enum DepthStencilMode 224 { 225 MODE_DEPTH = 0, 226 MODE_STENCIL, 227 228 MODE_LAST 229 }; 230 231 // Wrap control 232 WrapMode wrapS; 233 WrapMode wrapT; 234 WrapMode wrapR; 235 236 // Minifcation & magnification 237 FilterMode minFilter; 238 FilterMode magFilter; 239 float lodThreshold; // lod <= lodThreshold ? magnified : minified 240 241 // Coordinate normalization 242 bool normalizedCoords; 243 244 // Shadow comparison 245 CompareMode compare; 246 int compareChannel; 247 248 // Border color. 249 // \note It is setter's responsibility to guarantee that the values are representable 250 // in sampled texture's internal format. 251 // \note It is setter's responsibility to guarantee that the format is compatible with the 252 // sampled texture's internal format. Otherwise results are undefined. 253 rr::GenericVec4 borderColor; 254 255 // Seamless cube map filtering 256 bool seamlessCubeMap; 257 258 // Depth stencil mode 259 DepthStencilMode depthStencilMode; 260 261 Sampler (WrapMode wrapS_, 262 WrapMode wrapT_, 263 WrapMode wrapR_, 264 FilterMode minFilter_, 265 FilterMode magFilter_, 266 float lodThreshold_ = 0.0f, 267 bool normalizedCoords_ = true, 268 CompareMode compare_ = COMPAREMODE_NONE, 269 int compareChannel_ = 0, 270 const Vec4& borderColor_ = Vec4(0.0f, 0.0f, 0.0f, 0.0f), 271 bool seamlessCubeMap_ = false, 272 DepthStencilMode depthStencilMode_ = MODE_DEPTH) 273 : wrapS (wrapS_) 274 , wrapT (wrapT_) 275 , wrapR (wrapR_) 276 , minFilter (minFilter_) 277 , magFilter (magFilter_) 278 , lodThreshold (lodThreshold_) 279 , normalizedCoords (normalizedCoords_) 280 , compare (compare_) 281 , compareChannel (compareChannel_) 282 , borderColor (borderColor_) 283 , seamlessCubeMap (seamlessCubeMap_) 284 , depthStencilMode (depthStencilMode_) 285 { 286 } 287 288 Sampler (void) 289 : wrapS (WRAPMODE_LAST) 290 , wrapT (WRAPMODE_LAST) 291 , wrapR (WRAPMODE_LAST) 292 , minFilter (FILTERMODE_LAST) 293 , magFilter (FILTERMODE_LAST) 294 , lodThreshold (0.0f) 295 , normalizedCoords (true) 296 , compare (COMPAREMODE_NONE) 297 , compareChannel (0) 298 , borderColor (Vec4(0.0f, 0.0f, 0.0f, 0.0f)) 299 , seamlessCubeMap (false) 300 , depthStencilMode (MODE_DEPTH) 301 { 302 } 303 } DE_WARN_UNUSED_TYPE; 304 305 // Calculate pitches for pixel data with no padding. 306 IVec3 calculatePackedPitch (const TextureFormat& format, const IVec3& size); 307 308 class TextureLevel; 309 310 /*--------------------------------------------------------------------*//*! 311 * \brief Read-only pixel data access 312 * 313 * ConstPixelBufferAccess encapsulates pixel data pointer along with 314 * format and layout information. It can be used for read-only access 315 * to arbitrary pixel buffers. 316 * 317 * Access objects are like iterators or pointers. They can be passed around 318 * as values and are valid as long as the storage doesn't change. 319 *//*--------------------------------------------------------------------*/ 320 class ConstPixelBufferAccess 321 { 322 public: 323 ConstPixelBufferAccess (void); 324 ConstPixelBufferAccess (const TextureLevel& level); 325 ConstPixelBufferAccess (const TextureFormat& format, int width, int height, int depth, const void* data); 326 ConstPixelBufferAccess (const TextureFormat& format, const IVec3& size, const void* data); 327 ConstPixelBufferAccess (const TextureFormat& format, int width, int height, int depth, int rowPitch, int slicePitch, const void* data); 328 ConstPixelBufferAccess (const TextureFormat& format, const IVec3& size, const IVec3& pitch, const void* data); 329 330 const TextureFormat& getFormat (void) const { return m_format; } 331 const IVec3& getSize (void) const { return m_size; } 332 int getWidth (void) const { return m_size.x(); } 333 int getHeight (void) const { return m_size.y(); } 334 int getDepth (void) const { return m_size.z(); } 335 int getPixelPitch (void) const { return m_pitch.x(); } 336 int getRowPitch (void) const { return m_pitch.y(); } 337 int getSlicePitch (void) const { return m_pitch.z(); } 338 const IVec3& getPitch (void) const { return m_pitch; } 339 340 const void* getDataPtr (void) const { return m_data; } 341 const void* getPixelPtr (int x, int y, int z = 0) const { return (const deUint8*)m_data + x * m_pitch.x() + y * m_pitch.y() + z * m_pitch.z(); } 342 343 Vec4 getPixel (int x, int y, int z = 0) const; 344 IVec4 getPixelInt (int x, int y, int z = 0) const; 345 UVec4 getPixelUint (int x, int y, int z = 0) const { return getPixelInt(x, y, z).cast<deUint32>(); } 346 347 template<typename T> 348 Vector<T, 4> getPixelT (int x, int y, int z = 0) const; 349 350 float getPixDepth (int x, int y, int z = 0) const; 351 int getPixStencil (int x, int y, int z = 0) const; 352 353 Vec4 sample1D (const Sampler& sampler, Sampler::FilterMode filter, float s, int level) const; 354 Vec4 sample2D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, int depth) const; 355 Vec4 sample3D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r) const; 356 357 Vec4 sample1DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, const IVec2& offset) const; 358 Vec4 sample2DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, const IVec3& offset) const; 359 Vec4 sample3DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r, const IVec3& offset) const; 360 361 float sample1DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, const IVec2& offset) const; 362 float sample2DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, float t, const IVec3& offset) const; 363 364 protected: 365 TextureFormat m_format; 366 IVec3 m_size; 367 IVec3 m_pitch; //!< (pixelPitch, rowPitch, slicePitch) 368 mutable void* m_data; 369 } DE_WARN_UNUSED_TYPE; 370 371 /*--------------------------------------------------------------------*//*! 372 * \brief Read-write pixel data access 373 * 374 * This class extends read-only access object by providing write functionality. 375 * 376 * \note PixelBufferAccess may not have any data members nor add any 377 * virtual functions. It must be possible to reinterpret_cast<> 378 * PixelBufferAccess to ConstPixelBufferAccess. 379 *//*--------------------------------------------------------------------*/ 380 class PixelBufferAccess : public ConstPixelBufferAccess 381 { 382 public: 383 PixelBufferAccess (void) {} 384 PixelBufferAccess (TextureLevel& level); 385 PixelBufferAccess (const TextureFormat& format, int width, int height, int depth, void* data); 386 PixelBufferAccess (const TextureFormat& format, const IVec3& size, void* data); 387 PixelBufferAccess (const TextureFormat& format, int width, int height, int depth, int rowPitch, int slicePitch, void* data); 388 PixelBufferAccess (const TextureFormat& format, const IVec3& size, const IVec3& pitch, void* data); 389 390 void* getDataPtr (void) const { return m_data; } 391 void* getPixelPtr (int x, int y, int z = 0) const { return (deUint8*)m_data + x * m_pitch.x() + y * m_pitch.y() + z * m_pitch.z(); } 392 393 void setPixel (const tcu::Vec4& color, int x, int y, int z = 0) const; 394 void setPixel (const tcu::IVec4& color, int x, int y, int z = 0) const; 395 void setPixel (const tcu::UVec4& color, int x, int y, int z = 0) const { setPixel(color.cast<int>(), x, y, z); } 396 397 void setPixDepth (float depth, int x, int y, int z = 0) const; 398 void setPixStencil (int stencil, int x, int y, int z = 0) const; 399 } DE_WARN_UNUSED_TYPE; 400 401 /*--------------------------------------------------------------------*//*! 402 * \brief Generic pixel data container 403 * 404 * This container supports all valid TextureFormat combinations and 405 * both 2D and 3D textures. To read or manipulate data access object must 406 * be queried using getAccess(). 407 *//*--------------------------------------------------------------------*/ 408 class TextureLevel 409 { 410 public: 411 TextureLevel (void); 412 TextureLevel (const TextureFormat& format); 413 TextureLevel (const TextureFormat& format, int width, int height, int depth = 1); 414 ~TextureLevel (void); 415 416 const IVec3& getSize (void) const { return m_size; } 417 int getWidth (void) const { return m_size.x(); } 418 int getHeight (void) const { return m_size.y(); } 419 int getDepth (void) const { return m_size.z(); } 420 bool isEmpty (void) const { return m_size.x() * m_size.y() * m_size.z() == 0; } 421 const TextureFormat getFormat (void) const { return m_format; } 422 423 void setStorage (const TextureFormat& format, int width, int heigth, int depth = 1); 424 void setSize (int width, int height, int depth = 1); 425 426 PixelBufferAccess getAccess (void) { return isEmpty() ? PixelBufferAccess() : PixelBufferAccess(m_format, m_size, calculatePackedPitch(m_format, m_size), getPtr()); } 427 ConstPixelBufferAccess getAccess (void) const { return isEmpty() ? ConstPixelBufferAccess() : ConstPixelBufferAccess(m_format, m_size, calculatePackedPitch(m_format, m_size), getPtr()); } 428 429 private: 430 void* getPtr (void) { return m_data.getPtr(); } 431 const void* getPtr (void) const { return m_data.getPtr(); } 432 433 TextureFormat m_format; 434 IVec3 m_size; 435 de::ArrayBuffer<deUint8> m_data; 436 437 friend class ConstPixelBufferAccess; 438 } DE_WARN_UNUSED_TYPE; 439 440 Vec4 sampleLevelArray1D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, int level, float lod); 441 Vec4 sampleLevelArray2D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, int depth, float lod); 442 Vec4 sampleLevelArray3D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod); 443 444 Vec4 sampleLevelArray1DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float lod, const IVec2& offset); 445 Vec4 sampleLevelArray2DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float lod, const IVec3& offset); 446 Vec4 sampleLevelArray3DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset); 447 448 float sampleLevelArray1DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float lod, const IVec2& offset); 449 float sampleLevelArray2DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float t, float lod, const IVec3& offset); 450 451 Vec4 gatherArray2DOffsets (const ConstPixelBufferAccess& src, const Sampler& sampler, float s, float t, int depth, int componentNdx, const IVec2 (&offsets)[4]); 452 Vec4 gatherArray2DOffsetsCompare (const ConstPixelBufferAccess& src, const Sampler& sampler, float ref, float s, float t, int depth, const IVec2 (&offsets)[4]); 453 454 enum CubeFace 455 { 456 CUBEFACE_NEGATIVE_X = 0, 457 CUBEFACE_POSITIVE_X, 458 CUBEFACE_NEGATIVE_Y, 459 CUBEFACE_POSITIVE_Y, 460 CUBEFACE_NEGATIVE_Z, 461 CUBEFACE_POSITIVE_Z, 462 463 CUBEFACE_LAST 464 }; 465 466 /*--------------------------------------------------------------------*//*! 467 * \brief Coordinates projected onto cube face. 468 *//*--------------------------------------------------------------------*/ 469 template<typename T> 470 struct CubeFaceCoords 471 { 472 CubeFace face; 473 T s; 474 T t; 475 476 CubeFaceCoords (CubeFace face_, T s_, T t_) : face(face_), s(s_), t(t_) {} 477 CubeFaceCoords (CubeFace face_, const Vector<T, 2>& c) : face(face_), s(c.x()), t(c.y()) {} 478 } DE_WARN_UNUSED_TYPE; 479 480 typedef CubeFaceCoords<float> CubeFaceFloatCoords; 481 typedef CubeFaceCoords<int> CubeFaceIntCoords; 482 483 CubeFace selectCubeFace (const Vec3& coords); 484 Vec2 projectToFace (CubeFace face, const Vec3& coords); 485 CubeFaceFloatCoords getCubeFaceCoords (const Vec3& coords); 486 CubeFaceIntCoords remapCubeEdgeCoords (const CubeFaceIntCoords& coords, int size); 487 488 /*--------------------------------------------------------------------*//*! 489 * \brief 1D Texture View 490 *//*--------------------------------------------------------------------*/ 491 class Texture1DView 492 { 493 public: 494 Texture1DView (int numLevels, const ConstPixelBufferAccess* levels); 495 496 int getNumLevels (void) const { return m_numLevels; } 497 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; } 498 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; } 499 const ConstPixelBufferAccess* getLevels (void) const { return m_levels; } 500 501 Vec4 sample (const Sampler& sampler, float s, float lod) const; 502 Vec4 sampleOffset (const Sampler& sampler, float s, float lod, deInt32 offset) const; 503 float sampleCompare (const Sampler& sampler, float ref, float s, float lod) const; 504 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float lod, deInt32 offset) const; 505 506 protected: 507 int m_numLevels; 508 const ConstPixelBufferAccess* m_levels; 509 } DE_WARN_UNUSED_TYPE; 510 511 inline Texture1DView::Texture1DView (int numLevels, const ConstPixelBufferAccess* levels) 512 : m_numLevels (numLevels) 513 , m_levels (levels) 514 { 515 DE_ASSERT(m_numLevels >= 0 && ((m_numLevels == 0) == !m_levels)); 516 } 517 518 inline Vec4 Texture1DView::sample (const Sampler& sampler, float s, float lod) const 519 { 520 return sampleLevelArray1D(m_levels, m_numLevels, sampler, s, 0 /* depth */, lod); 521 } 522 523 inline Vec4 Texture1DView::sampleOffset (const Sampler& sampler, float s, float lod, deInt32 offset) const 524 { 525 return sampleLevelArray1DOffset(m_levels, m_numLevels, sampler, s, lod, IVec2(offset, 0)); 526 } 527 528 inline float Texture1DView::sampleCompare (const Sampler& sampler, float ref, float s, float lod) const 529 { 530 return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(0, 0)); 531 } 532 533 inline float Texture1DView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float lod, deInt32 offset) const 534 { 535 return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(offset, 0)); 536 } 537 538 /*--------------------------------------------------------------------*//*! 539 * \brief 2D Texture View 540 *//*--------------------------------------------------------------------*/ 541 class Texture2DView 542 { 543 public: 544 Texture2DView (int numLevels, const ConstPixelBufferAccess* levels); 545 546 int getNumLevels (void) const { return m_numLevels; } 547 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; } 548 int getHeight (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; } 549 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; } 550 const ConstPixelBufferAccess* getLevels (void) const { return m_levels; } 551 552 Vec4 sample (const Sampler& sampler, float s, float t, float lod) const; 553 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float lod, const IVec2& offset) const; 554 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const; 555 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, const IVec2& offset) const; 556 557 Vec4 gatherOffsets (const Sampler& sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const; 558 Vec4 gatherOffsetsCompare(const Sampler& sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const; 559 560 protected: 561 int m_numLevels; 562 const ConstPixelBufferAccess* m_levels; 563 } DE_WARN_UNUSED_TYPE; 564 565 inline Texture2DView::Texture2DView (int numLevels, const ConstPixelBufferAccess* levels) 566 : m_numLevels (numLevels) 567 , m_levels (levels) 568 { 569 DE_ASSERT(m_numLevels >= 0 && ((m_numLevels == 0) == !m_levels)); 570 } 571 572 inline Vec4 Texture2DView::sample (const Sampler& sampler, float s, float t, float lod) const 573 { 574 return sampleLevelArray2D(m_levels, m_numLevels, sampler, s, t, 0 /* depth */, lod); 575 } 576 577 inline Vec4 Texture2DView::sampleOffset (const Sampler& sampler, float s, float t, float lod, const IVec2& offset) const 578 { 579 return sampleLevelArray2DOffset(m_levels, m_numLevels, sampler, s, t, lod, IVec3(offset.x(), offset.y(), 0)); 580 } 581 582 inline float Texture2DView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const 583 { 584 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(0, 0, 0)); 585 } 586 587 inline float Texture2DView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, const IVec2& offset) const 588 { 589 return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(offset.x(), offset.y(), 0)); 590 } 591 592 inline Vec4 Texture2DView::gatherOffsets (const Sampler& sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const 593 { 594 return gatherArray2DOffsets(m_levels[0], sampler, s, t, 0, componentNdx, offsets); 595 } 596 597 inline Vec4 Texture2DView::gatherOffsetsCompare (const Sampler& sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const 598 { 599 return gatherArray2DOffsetsCompare(m_levels[0], sampler, ref, s, t, 0, offsets); 600 } 601 602 /*--------------------------------------------------------------------*//*! 603 * \brief Base class for textures that have single mip-map pyramid 604 *//*--------------------------------------------------------------------*/ 605 class TextureLevelPyramid 606 { 607 public: 608 TextureLevelPyramid (const TextureFormat& format, int numLevels); 609 TextureLevelPyramid (const TextureLevelPyramid& other); 610 ~TextureLevelPyramid(void); 611 612 const TextureFormat& getFormat (void) const { return m_format; } 613 int getNumLevels (void) const { return (int)m_access.size(); } 614 615 bool isLevelEmpty (int levelNdx) const { DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); return m_data[(size_t)levelNdx].empty(); } 616 const ConstPixelBufferAccess& getLevel (int levelNdx) const { DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); return m_access[(size_t)levelNdx]; } 617 const PixelBufferAccess& getLevel (int levelNdx) { DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); return m_access[(size_t)levelNdx]; } 618 619 const ConstPixelBufferAccess* getLevels (void) const { return &m_access[0]; } 620 const PixelBufferAccess* getLevels (void) { return &m_access[0]; } 621 622 void allocLevel (int levelNdx, int width, int height, int depth); 623 void clearLevel (int levelNdx); 624 625 TextureLevelPyramid& operator= (const TextureLevelPyramid& other); 626 627 private: 628 typedef de::ArrayBuffer<deUint8> LevelData; 629 630 TextureFormat m_format; 631 std::vector<LevelData> m_data; 632 std::vector<PixelBufferAccess> m_access; 633 } DE_WARN_UNUSED_TYPE; 634 635 /*--------------------------------------------------------------------*//*! 636 * \brief 1D Texture reference implementation 637 *//*--------------------------------------------------------------------*/ 638 class Texture1D : private TextureLevelPyramid 639 { 640 public: 641 Texture1D (const TextureFormat& format, int width); 642 Texture1D (const Texture1D& other); 643 ~Texture1D (void); 644 645 int getWidth (void) const { return m_width; } 646 const Texture1DView& getView (void) const { return m_view; } 647 648 void allocLevel (int levelNdx); 649 650 // Sampling 651 Vec4 sample (const Sampler& sampler, float s, float lod) const; 652 Vec4 sampleOffset (const Sampler& sampler, float s, float lod, deInt32 offset) const; 653 float sampleCompare (const Sampler& sampler, float ref, float s, float lod) const; 654 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float lod, deInt32 offset) const; 655 656 using TextureLevelPyramid::getFormat; 657 using TextureLevelPyramid::getNumLevels; 658 using TextureLevelPyramid::getLevel; 659 using TextureLevelPyramid::clearLevel; 660 using TextureLevelPyramid::isLevelEmpty; 661 662 Texture1D& operator= (const Texture1D& other); 663 664 operator Texture1DView (void) const { return m_view; } 665 666 private: 667 int m_width; 668 Texture1DView m_view; 669 } DE_WARN_UNUSED_TYPE; 670 671 inline Vec4 Texture1D::sample (const Sampler& sampler, float s, float lod) const 672 { 673 return m_view.sample(sampler, s, lod); 674 } 675 676 inline Vec4 Texture1D::sampleOffset (const Sampler& sampler, float s, float lod, deInt32 offset) const 677 { 678 return m_view.sampleOffset(sampler, s, lod, offset); 679 } 680 681 inline float Texture1D::sampleCompare (const Sampler& sampler, float ref, float s, float lod) const 682 { 683 return m_view.sampleCompare(sampler, ref, s, lod); 684 } 685 686 inline float Texture1D::sampleCompareOffset (const Sampler& sampler, float ref, float s, float lod, deInt32 offset) const 687 { 688 return m_view.sampleCompareOffset(sampler, ref, s, lod, offset); 689 } 690 691 /*--------------------------------------------------------------------*//*! 692 * \brief 2D Texture reference implementation 693 *//*--------------------------------------------------------------------*/ 694 class Texture2D : private TextureLevelPyramid 695 { 696 public: 697 Texture2D (const TextureFormat& format, int width, int height); 698 Texture2D (const Texture2D& other); 699 ~Texture2D (void); 700 701 int getWidth (void) const { return m_width; } 702 int getHeight (void) const { return m_height; } 703 const Texture2DView& getView (void) const { return m_view; } 704 705 void allocLevel (int levelNdx); 706 707 // Sampling 708 Vec4 sample (const Sampler& sampler, float s, float t, float lod) const; 709 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float lod, const IVec2& offset) const; 710 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const; 711 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, const IVec2& offset) const; 712 713 Vec4 gatherOffsets (const Sampler& sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const; 714 Vec4 gatherOffsetsCompare(const Sampler& sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const; 715 716 using TextureLevelPyramid::getFormat; 717 using TextureLevelPyramid::getNumLevels; 718 using TextureLevelPyramid::getLevel; 719 using TextureLevelPyramid::clearLevel; 720 using TextureLevelPyramid::isLevelEmpty; 721 722 Texture2D& operator= (const Texture2D& other); 723 724 operator Texture2DView (void) const { return m_view; } 725 726 private: 727 int m_width; 728 int m_height; 729 Texture2DView m_view; 730 } DE_WARN_UNUSED_TYPE; 731 732 inline Vec4 Texture2D::sample (const Sampler& sampler, float s, float t, float lod) const 733 { 734 return m_view.sample(sampler, s, t, lod); 735 } 736 737 inline Vec4 Texture2D::sampleOffset (const Sampler& sampler, float s, float t, float lod, const IVec2& offset) const 738 { 739 return m_view.sampleOffset(sampler, s, t, lod, offset); 740 } 741 742 inline float Texture2D::sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const 743 { 744 return m_view.sampleCompare(sampler, ref, s, t, lod); 745 } 746 747 inline float Texture2D::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, const IVec2& offset) const 748 { 749 return m_view.sampleCompareOffset(sampler, ref, s, t, lod, offset); 750 } 751 752 inline Vec4 Texture2D::gatherOffsets (const Sampler& sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const 753 { 754 return m_view.gatherOffsets(sampler, s, t, componentNdx, offsets); 755 } 756 757 inline Vec4 Texture2D::gatherOffsetsCompare (const Sampler& sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const 758 { 759 return m_view.gatherOffsetsCompare(sampler, ref, s, t, offsets); 760 } 761 762 /*--------------------------------------------------------------------*//*! 763 * \brief Cube Map Texture View 764 *//*--------------------------------------------------------------------*/ 765 class TextureCubeView 766 { 767 public: 768 TextureCubeView (void); 769 TextureCubeView (int numLevels, const ConstPixelBufferAccess* const (&levels)[CUBEFACE_LAST]); 770 771 int getNumLevels (void) const { return m_numLevels; } 772 int getSize (void) const { return m_numLevels > 0 ? m_levels[0][0].getWidth() : 0; } 773 const ConstPixelBufferAccess& getLevelFace (int ndx, CubeFace face) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[face][ndx]; } 774 const ConstPixelBufferAccess* getFaceLevels (CubeFace face) const { return m_levels[face]; } 775 776 Vec4 sample (const Sampler& sampler, float s, float t, float p, float lod) const; 777 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const; 778 779 Vec4 gather (const Sampler& sampler, float s, float t, float r, int componentNdx) const; 780 Vec4 gatherCompare (const Sampler& sampler, float ref, float s, float t, float r) const; 781 782 protected: 783 int m_numLevels; 784 const ConstPixelBufferAccess* m_levels[CUBEFACE_LAST]; 785 } DE_WARN_UNUSED_TYPE; 786 787 /*--------------------------------------------------------------------*//*! 788 * \brief Cube Map Texture reference implementation 789 *//*--------------------------------------------------------------------*/ 790 class TextureCube 791 { 792 public: 793 TextureCube (const TextureFormat& format, int size); 794 TextureCube (const TextureCube& other); 795 ~TextureCube (void); 796 797 const TextureFormat& getFormat (void) const { return m_format; } 798 int getSize (void) const { return m_size; } 799 800 int getNumLevels (void) const { return (int)m_access[0].size(); } 801 const ConstPixelBufferAccess& getLevelFace (int ndx, CubeFace face) const { DE_ASSERT(de::inBounds(ndx, 0, getNumLevels())); return m_access[face][(size_t)ndx]; } 802 const PixelBufferAccess& getLevelFace (int ndx, CubeFace face) { DE_ASSERT(de::inBounds(ndx, 0, getNumLevels())); return m_access[face][(size_t)ndx]; } 803 804 void allocLevel (CubeFace face, int levelNdx); 805 void clearLevel (CubeFace face, int levelNdx); 806 bool isLevelEmpty (CubeFace face, int levelNdx) const { DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); return m_data[face][(size_t)levelNdx].empty(); } 807 808 Vec4 sample (const Sampler& sampler, float s, float t, float p, float lod) const; 809 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const; 810 811 Vec4 gather (const Sampler& sampler, float s, float t, float r, int componentNdx) const; 812 Vec4 gatherCompare (const Sampler& sampler, float ref, float s, float t, float r) const; 813 814 TextureCube& operator= (const TextureCube& other); 815 816 operator TextureCubeView (void) const { return m_view; } 817 818 private: 819 typedef de::ArrayBuffer<deUint8> LevelData; 820 821 TextureFormat m_format; 822 int m_size; 823 std::vector<LevelData> m_data[CUBEFACE_LAST]; 824 std::vector<PixelBufferAccess> m_access[CUBEFACE_LAST]; 825 TextureCubeView m_view; 826 } DE_WARN_UNUSED_TYPE; 827 828 inline Vec4 TextureCube::sample (const Sampler& sampler, float s, float t, float p, float lod) const 829 { 830 return m_view.sample(sampler, s, t, p, lod); 831 } 832 833 inline float TextureCube::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const 834 { 835 return m_view.sampleCompare(sampler, ref, s, t, r, lod); 836 } 837 838 inline Vec4 TextureCube::gather (const Sampler& sampler, float s, float t, float r, int componentNdx) const 839 { 840 return m_view.gather(sampler, s, t, r, componentNdx); 841 } 842 843 inline Vec4 TextureCube::gatherCompare (const Sampler& sampler, float ref, float s, float t, float r) const 844 { 845 return m_view.gatherCompare(sampler, ref, s, t, r); 846 } 847 848 /*--------------------------------------------------------------------*//*! 849 * \brief 1D Array Texture View 850 *//*--------------------------------------------------------------------*/ 851 class Texture1DArrayView 852 { 853 public: 854 Texture1DArrayView (int numLevels, const ConstPixelBufferAccess* levels); 855 856 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; } 857 int getNumLayers (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; } 858 int getNumLevels (void) const { return m_numLevels; } 859 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; } 860 const ConstPixelBufferAccess* getLevels (void) const { return m_levels; } 861 862 Vec4 sample (const Sampler& sampler, float s, float t, float lod) const; 863 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float lod, deInt32 offset) const; 864 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const; 865 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, deInt32 offset) const; 866 867 protected: 868 int selectLayer (float r) const; 869 870 int m_numLevels; 871 const ConstPixelBufferAccess* m_levels; 872 } DE_WARN_UNUSED_TYPE; 873 874 /*--------------------------------------------------------------------*//*! 875 * \brief 2D Array Texture View 876 *//*--------------------------------------------------------------------*/ 877 class Texture2DArrayView 878 { 879 public: 880 Texture2DArrayView (int numLevels, const ConstPixelBufferAccess* levels); 881 882 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; } 883 int getHeight (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; } 884 int getNumLayers (void) const { return m_numLevels > 0 ? m_levels[0].getDepth() : 0; } 885 int getNumLevels (void) const { return m_numLevels; } 886 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; } 887 const ConstPixelBufferAccess* getLevels (void) const { return m_levels; } 888 889 Vec4 sample (const Sampler& sampler, float s, float t, float r, float lod) const; 890 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec2& offset) const; 891 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const; 892 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float lod, const IVec2& offset) const; 893 894 Vec4 gatherOffsets (const Sampler& sampler, float s, float t, float r, int componentNdx, const IVec2 (&offsets)[4]) const; 895 Vec4 gatherOffsetsCompare(const Sampler& sampler, float ref, float s, float t, float r, const IVec2 (&offsets)[4]) const; 896 897 protected: 898 int selectLayer (float r) const; 899 900 int m_numLevels; 901 const ConstPixelBufferAccess* m_levels; 902 } DE_WARN_UNUSED_TYPE; 903 904 /*--------------------------------------------------------------------*//*! 905 * \brief 1D Array Texture reference implementation 906 *//*--------------------------------------------------------------------*/ 907 class Texture1DArray : private TextureLevelPyramid 908 { 909 public: 910 Texture1DArray (const TextureFormat& format, int width, int numLayers); 911 Texture1DArray (const Texture1DArray& other); 912 ~Texture1DArray (void); 913 914 int getWidth (void) const { return m_width; } 915 int getNumLayers (void) const { return m_numLayers; } 916 917 void allocLevel (int levelNdx); 918 919 using TextureLevelPyramid::getFormat; 920 using TextureLevelPyramid::getNumLevels; 921 using TextureLevelPyramid::getLevel; 922 using TextureLevelPyramid::clearLevel; 923 using TextureLevelPyramid::isLevelEmpty; 924 925 Vec4 sample (const Sampler& sampler, float s, float t, float lod) const; 926 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float lod, deInt32 offset) const; 927 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const; 928 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, deInt32 offset) const; 929 930 Texture1DArray& operator= (const Texture1DArray& other); 931 932 operator Texture1DArrayView (void) const { return m_view; } 933 934 private: 935 int m_width; 936 int m_numLayers; 937 Texture1DArrayView m_view; 938 } DE_WARN_UNUSED_TYPE; 939 940 inline Vec4 Texture1DArray::sample (const Sampler& sampler, float s, float t, float lod) const 941 { 942 return m_view.sample(sampler, s, t, lod); 943 } 944 945 inline Vec4 Texture1DArray::sampleOffset (const Sampler& sampler, float s, float t, float lod, deInt32 offset) const 946 { 947 return m_view.sampleOffset(sampler, s, t, lod, offset); 948 } 949 950 inline float Texture1DArray::sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const 951 { 952 return m_view.sampleCompare(sampler, ref, s, t, lod); 953 } 954 955 inline float Texture1DArray::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, deInt32 offset) const 956 { 957 return m_view.sampleCompareOffset(sampler, ref, s, t, lod, offset); 958 } 959 960 /*--------------------------------------------------------------------*//*! 961 * \brief 2D Array Texture reference implementation 962 *//*--------------------------------------------------------------------*/ 963 class Texture2DArray : private TextureLevelPyramid 964 { 965 public: 966 Texture2DArray (const TextureFormat& format, int width, int height, int numLayers); 967 Texture2DArray (const Texture2DArray& other); 968 ~Texture2DArray (void); 969 970 int getWidth (void) const { return m_width; } 971 int getHeight (void) const { return m_height; } 972 int getNumLayers (void) const { return m_numLayers; } 973 974 void allocLevel (int levelNdx); 975 976 using TextureLevelPyramid::getFormat; 977 using TextureLevelPyramid::getNumLevels; 978 using TextureLevelPyramid::getLevel; 979 using TextureLevelPyramid::clearLevel; 980 using TextureLevelPyramid::isLevelEmpty; 981 982 Vec4 sample (const Sampler& sampler, float s, float t, float r, float lod) const; 983 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec2& offset) const; 984 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const; 985 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float lod, const IVec2& offset) const; 986 987 Vec4 gatherOffsets (const Sampler& sampler, float s, float t, float r, int componentNdx, const IVec2 (&offsets)[4]) const; 988 Vec4 gatherOffsetsCompare(const Sampler& sampler, float ref, float s, float t, float r, const IVec2 (&offsets)[4]) const; 989 990 Texture2DArray& operator= (const Texture2DArray& other); 991 992 operator Texture2DArrayView (void) const { return m_view; } 993 994 private: 995 int m_width; 996 int m_height; 997 int m_numLayers; 998 Texture2DArrayView m_view; 999 } DE_WARN_UNUSED_TYPE; 1000 1001 inline Vec4 Texture2DArray::sample (const Sampler& sampler, float s, float t, float r, float lod) const 1002 { 1003 return m_view.sample(sampler, s, t, r, lod); 1004 } 1005 1006 inline Vec4 Texture2DArray::sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec2& offset) const 1007 { 1008 return m_view.sampleOffset(sampler, s, t, r, lod, offset); 1009 } 1010 1011 inline float Texture2DArray::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const 1012 { 1013 return m_view.sampleCompare(sampler, ref, s, t, r, lod); 1014 } 1015 1016 inline float Texture2DArray::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float lod, const IVec2& offset) const 1017 { 1018 return m_view.sampleCompareOffset(sampler, ref, s, t, r, lod, offset); 1019 } 1020 1021 inline Vec4 Texture2DArray::gatherOffsets (const Sampler& sampler, float s, float t, float r, int componentNdx, const IVec2 (&offsets)[4]) const 1022 { 1023 return m_view.gatherOffsets(sampler, s, t, r, componentNdx, offsets); 1024 } 1025 1026 inline Vec4 Texture2DArray::gatherOffsetsCompare (const Sampler& sampler, float ref, float s, float t, float r, const IVec2 (&offsets)[4]) const 1027 { 1028 return m_view.gatherOffsetsCompare(sampler, ref, s, t, r, offsets); 1029 } 1030 1031 /*--------------------------------------------------------------------*//*! 1032 * \brief 3D Texture View 1033 *//*--------------------------------------------------------------------*/ 1034 class Texture3DView 1035 { 1036 public: 1037 Texture3DView (int numLevels, const ConstPixelBufferAccess* levels); 1038 1039 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; } 1040 int getHeight (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; } 1041 int getDepth (void) const { return m_numLevels > 0 ? m_levels[0].getDepth() : 0; } 1042 int getNumLevels (void) const { return m_numLevels; } 1043 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; } 1044 const ConstPixelBufferAccess* getLevels (void) const { return m_levels; } 1045 1046 Vec4 sample (const Sampler& sampler, float s, float t, float r, float lod) const; 1047 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset) const; 1048 1049 protected: 1050 int m_numLevels; 1051 const ConstPixelBufferAccess* m_levels; 1052 } DE_WARN_UNUSED_TYPE; 1053 1054 inline Vec4 Texture3DView::sample (const Sampler& sampler, float s, float t, float r, float lod) const 1055 { 1056 return sampleLevelArray3D(m_levels, m_numLevels, sampler, s, t, r, lod); 1057 } 1058 1059 inline Vec4 Texture3DView::sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset) const 1060 { 1061 return sampleLevelArray3DOffset(m_levels, m_numLevels, sampler, s, t, r, lod, offset); 1062 } 1063 1064 /*--------------------------------------------------------------------*//*! 1065 * \brief 3D Texture reference implementation 1066 *//*--------------------------------------------------------------------*/ 1067 class Texture3D : private TextureLevelPyramid 1068 { 1069 public: 1070 Texture3D (const TextureFormat& format, int width, int height, int depth); 1071 Texture3D (const Texture3D& other); 1072 ~Texture3D (void); 1073 1074 int getWidth (void) const { return m_width; } 1075 int getHeight (void) const { return m_height; } 1076 int getDepth (void) const { return m_depth; } 1077 1078 void allocLevel (int levelNdx); 1079 1080 using TextureLevelPyramid::getFormat; 1081 using TextureLevelPyramid::getNumLevels; 1082 using TextureLevelPyramid::getLevel; 1083 using TextureLevelPyramid::clearLevel; 1084 using TextureLevelPyramid::isLevelEmpty; 1085 1086 Vec4 sample (const Sampler& sampler, float s, float t, float r, float lod) const; 1087 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset) const; 1088 1089 Texture3D& operator= (const Texture3D& other); 1090 1091 operator Texture3DView (void) const { return m_view; } 1092 1093 private: 1094 int m_width; 1095 int m_height; 1096 int m_depth; 1097 Texture3DView m_view; 1098 } DE_WARN_UNUSED_TYPE; 1099 1100 inline Vec4 Texture3D::sample (const Sampler& sampler, float s, float t, float r, float lod) const 1101 { 1102 return m_view.sample(sampler, s, t, r, lod); 1103 } 1104 1105 inline Vec4 Texture3D::sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset) const 1106 { 1107 return m_view.sampleOffset(sampler, s, t, r, lod, offset); 1108 } 1109 1110 /*--------------------------------------------------------------------*//*! 1111 * \brief Cube Map Array Texture View 1112 *//*--------------------------------------------------------------------*/ 1113 class TextureCubeArrayView 1114 { 1115 public: 1116 TextureCubeArrayView (int numLevels, const ConstPixelBufferAccess* levels); 1117 1118 int getSize (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; } 1119 int getDepth (void) const { return m_numLevels > 0 ? m_levels[0].getDepth() : 0; } 1120 int getNumLayers (void) const { return getDepth() / 6; } 1121 int getNumLevels (void) const { return m_numLevels; } 1122 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; } 1123 const ConstPixelBufferAccess* getLevels (void) const { return m_levels; } 1124 1125 Vec4 sample (const Sampler& sampler, float s, float t, float r, float q, float lod) const; 1126 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float r, float q, float lod, const IVec2& offset) const; 1127 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod) const; 1128 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod, const IVec2& offset) const; 1129 1130 protected: 1131 int selectLayer (float q) const; 1132 1133 int m_numLevels; 1134 const ConstPixelBufferAccess* m_levels; 1135 } DE_WARN_UNUSED_TYPE; 1136 1137 /*--------------------------------------------------------------------*//*! 1138 * \brief Cube Map Array Texture reference implementation 1139 *//*--------------------------------------------------------------------*/ 1140 class TextureCubeArray : private TextureLevelPyramid 1141 { 1142 public: 1143 TextureCubeArray (const TextureFormat& format, int size, int depth); 1144 TextureCubeArray (const TextureCubeArray& other); 1145 ~TextureCubeArray (void); 1146 1147 int getSize (void) const { return m_size; } 1148 int getDepth (void) const { return m_depth; } 1149 1150 void allocLevel (int levelNdx); 1151 1152 using TextureLevelPyramid::getFormat; 1153 using TextureLevelPyramid::getNumLevels; 1154 using TextureLevelPyramid::getLevel; 1155 using TextureLevelPyramid::clearLevel; 1156 using TextureLevelPyramid::isLevelEmpty; 1157 1158 Vec4 sample (const Sampler& sampler, float s, float t, float r, float q, float lod) const; 1159 Vec4 sampleOffset (const Sampler& sampler, float s, float t, float r, float q, float lod, const IVec2& offset) const; 1160 float sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod) const; 1161 float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod, const IVec2& offset) const; 1162 1163 TextureCubeArray& operator= (const TextureCubeArray& other); 1164 1165 operator TextureCubeArrayView (void) const { return m_view; } 1166 1167 private: 1168 int m_size; 1169 int m_depth; 1170 TextureCubeArrayView m_view; 1171 } DE_WARN_UNUSED_TYPE; 1172 1173 inline Vec4 TextureCubeArray::sample (const Sampler& sampler, float s, float t, float r, float q, float lod) const 1174 { 1175 return m_view.sample(sampler, s, t, r, q, lod); 1176 } 1177 1178 inline Vec4 TextureCubeArray::sampleOffset (const Sampler& sampler, float s, float t, float r, float q, float lod, const IVec2& offset) const 1179 { 1180 return m_view.sampleOffset(sampler, s, t, r, q, lod, offset); 1181 } 1182 1183 inline float TextureCubeArray::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod) const 1184 { 1185 return m_view.sampleCompare(sampler, ref, s, t, r, q, lod); 1186 } 1187 1188 inline float TextureCubeArray::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod, const IVec2& offset) const 1189 { 1190 return m_view.sampleCompareOffset(sampler, ref, s, t, r, q, lod, offset); 1191 } 1192 1193 // Stream operators. 1194 std::ostream& operator<< (std::ostream& str, TextureFormat::ChannelOrder order); 1195 std::ostream& operator<< (std::ostream& str, TextureFormat::ChannelType type); 1196 std::ostream& operator<< (std::ostream& str, TextureFormat format); 1197 std::ostream& operator<< (std::ostream& str, CubeFace face); 1198 std::ostream& operator<< (std::ostream& str, const ConstPixelBufferAccess& access); 1199 1200 } // tcu 1201 1202 #endif // _TCUTEXTURE_HPP 1203
