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