framework/common/tcuTexture.hpp

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