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
TextureFormat(ChannelOrder order_,ChannelType type_)119 TextureFormat (ChannelOrder order_, ChannelType type_)
120 : order (order_)
121 , type (type_)
122 {
123 }
124
TextureFormat(void)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
operator ==(const TextureFormat & other) const133 bool operator== (const TextureFormat& other) const { return !(*this != other); }
operator !=(const TextureFormat & other) const134 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
Sampler(WrapMode wrapS_,WrapMode wrapT_,WrapMode wrapR_,FilterMode minFilter_,FilterMode magFilter_,float lodThreshold_=0.0f,bool normalizedCoords_=true,CompareMode compare_=COMPAREMODE_NONE,int compareChannel_=0,const Vec4 & borderColor_=Vec4 (0.0f,0.0f,0.0f,0.0f),bool seamlessCubeMap_=false,DepthStencilMode depthStencilMode_=MODE_DEPTH)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
Sampler(void)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
getFormat(void) const327 const TextureFormat& getFormat (void) const { return m_format; }
getSize(void) const328 const IVec3& getSize (void) const { return m_size; }
getWidth(void) const329 int getWidth (void) const { return m_size.x(); }
getHeight(void) const330 int getHeight (void) const { return m_size.y(); }
getDepth(void) const331 int getDepth (void) const { return m_size.z(); }
getPixelPitch(void) const332 int getPixelPitch (void) const { return m_pitch.x(); }
getRowPitch(void) const333 int getRowPitch (void) const { return m_pitch.y(); }
getSlicePitch(void) const334 int getSlicePitch (void) const { return m_pitch.z(); }
getPitch(void) const335 const IVec3& getPitch (void) const { return m_pitch; }
336
getDataPtr(void) const337 const void* getDataPtr (void) const { return m_data; }
getPixelPtr(int x,int y,int z=0) const338 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;
getPixelUint(int x,int y,int z=0) const342 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:
PixelBufferAccess(void)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
getDataPtr(void) const387 void* getDataPtr (void) const { return m_data; }
getPixelPtr(int x,int y,int z=0) const388 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;
setPixel(const tcu::UVec4 & color,int x,int y,int z=0) const392 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
getSize(void) const413 const IVec3& getSize (void) const { return m_size; }
getWidth(void) const414 int getWidth (void) const { return m_size.x(); }
getHeight(void) const415 int getHeight (void) const { return m_size.y(); }
getDepth(void) const416 int getDepth (void) const { return m_size.z(); }
isEmpty(void) const417 bool isEmpty (void) const { return m_size.x() * m_size.y() * m_size.z() == 0; }
getFormat(void) const418 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
getAccess(void)423 PixelBufferAccess getAccess (void) { return isEmpty() ? PixelBufferAccess() : PixelBufferAccess(m_format, m_size, calculatePackedPitch(m_format, m_size), getPtr()); }
getAccess(void) const424 ConstPixelBufferAccess getAccess (void) const { return isEmpty() ? ConstPixelBufferAccess() : ConstPixelBufferAccess(m_format, m_size, calculatePackedPitch(m_format, m_size), getPtr()); }
425
426 private:
getPtr(void)427 void* getPtr (void) { return m_data.getPtr(); }
getPtr(void) const428 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
CubeFaceCoordstcu::CubeFaceCoords473 CubeFaceCoords (CubeFace face_, T s_, T t_) : face(face_), s(s_), t(t_) {}
CubeFaceCoordstcu::CubeFaceCoords474 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
getNumLevels(void) const493 int getNumLevels (void) const { return m_numLevels; }
getWidth(void) const494 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; }
getLevel(int ndx) const495 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; }
getLevels(void) const496 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
Texture1DView(int numLevels,const ConstPixelBufferAccess * levels)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
sample(const Sampler & sampler,float s,float lod) const515 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
sampleOffset(const Sampler & sampler,float s,float lod,deInt32 offset) const520 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
sampleCompare(const Sampler & sampler,float ref,float s,float lod) const525 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
sampleCompareOffset(const Sampler & sampler,float ref,float s,float lod,deInt32 offset) const530 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
getNumLevels(void) const543 int getNumLevels (void) const { return m_numLevels; }
getWidth(void) const544 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; }
getHeight(void) const545 int getHeight (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; }
getLevel(int ndx) const546 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; }
getLevels(void) const547 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
Texture2DView(int numLevels,const ConstPixelBufferAccess * levels)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
sample(const Sampler & sampler,float s,float t,float lod) const569 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
sampleOffset(const Sampler & sampler,float s,float t,float lod,const IVec2 & offset) const574 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
sampleCompare(const Sampler & sampler,float ref,float s,float t,float lod) const579 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
sampleCompareOffset(const Sampler & sampler,float ref,float s,float t,float lod,const IVec2 & offset) const584 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
gatherOffsets(const Sampler & sampler,float s,float t,int componentNdx,const IVec2 (& offsets)[4]) const589 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
gatherOffsetsCompare(const Sampler & sampler,float ref,float s,float t,const IVec2 (& offsets)[4]) const594 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
getFormat(void) const609 const TextureFormat& getFormat (void) const { return m_format; }
getNumLevels(void) const610 int getNumLevels (void) const { return (int)m_access.size(); }
611
isLevelEmpty(int levelNdx) const612 bool isLevelEmpty (int levelNdx) const { DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); return m_data[(size_t)levelNdx].empty(); }
getLevel(int levelNdx) const613 const ConstPixelBufferAccess& getLevel (int levelNdx) const { DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); return m_access[(size_t)levelNdx]; }
getLevel(int levelNdx)614 const PixelBufferAccess& getLevel (int levelNdx) { DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); return m_access[(size_t)levelNdx]; }
615
getLevels(void) const616 const ConstPixelBufferAccess* getLevels (void) const { return &m_access[0]; }
getLevels(void)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
getWidth(void) const642 int getWidth (void) const { return m_width; }
getView(void) const643 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
operator Texture1DView(void) const661 operator Texture1DView (void) const { return m_view; }
662
663 private:
664 int m_width;
665 Texture1DView m_view;
666 } DE_WARN_UNUSED_TYPE;
667
sample(const Sampler & sampler,float s,float lod) const668 inline Vec4 Texture1D::sample (const Sampler& sampler, float s, float lod) const
669 {
670 return m_view.sample(sampler, s, lod);
671 }
672
sampleOffset(const Sampler & sampler,float s,float lod,deInt32 offset) const673 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
sampleCompare(const Sampler & sampler,float ref,float s,float lod) const678 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
sampleCompareOffset(const Sampler & sampler,float ref,float s,float lod,deInt32 offset) const683 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
getWidth(void) const698 int getWidth (void) const { return m_width; }
getHeight(void) const699 int getHeight (void) const { return m_height; }
getView(void) const700 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
operator Texture2DView(void) const721 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
sample(const Sampler & sampler,float s,float t,float lod) const729 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
sampleOffset(const Sampler & sampler,float s,float t,float lod,const IVec2 & offset) const734 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
sampleCompare(const Sampler & sampler,float ref,float s,float t,float lod) const739 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
sampleCompareOffset(const Sampler & sampler,float ref,float s,float t,float lod,const IVec2 & offset) const744 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
gatherOffsets(const Sampler & sampler,float s,float t,int componentNdx,const IVec2 (& offsets)[4]) const749 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
gatherOffsetsCompare(const Sampler & sampler,float ref,float s,float t,const IVec2 (& offsets)[4]) const754 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
getNumLevels(void) const768 int getNumLevels (void) const { return m_numLevels; }
getSize(void) const769 int getSize (void) const { return m_numLevels > 0 ? m_levels[0][0].getWidth() : 0; }
getLevelFace(int ndx,CubeFace face) const770 const ConstPixelBufferAccess& getLevelFace (int ndx, CubeFace face) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[face][ndx]; }
getFaceLevels(CubeFace face) const771 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
getFormat(void) const794 const TextureFormat& getFormat (void) const { return m_format; }
getSize(void) const795 int getSize (void) const { return m_size; }
796
getNumLevels(void) const797 int getNumLevels (void) const { return (int)m_access[0].size(); }
getLevelFace(int ndx,CubeFace face) const798 const ConstPixelBufferAccess& getLevelFace (int ndx, CubeFace face) const { DE_ASSERT(de::inBounds(ndx, 0, getNumLevels())); return m_access[face][(size_t)ndx]; }
getLevelFace(int ndx,CubeFace face)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);
isLevelEmpty(CubeFace face,int levelNdx) const803 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
operator TextureCubeView(void) const813 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
sample(const Sampler & sampler,float s,float t,float p,float lod) const825 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
sampleCompare(const Sampler & sampler,float ref,float s,float t,float r,float lod) const830 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
gather(const Sampler & sampler,float s,float t,float r,int componentNdx) const835 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
gatherCompare(const Sampler & sampler,float ref,float s,float t,float r) const840 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
getWidth(void) const853 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; }
getNumLayers(void) const854 int getNumLayers (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; }
getNumLevels(void) const855 int getNumLevels (void) const { return m_numLevels; }
getLevel(int ndx) const856 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; }
getLevels(void) const857 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
getWidth(void) const879 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; }
getHeight(void) const880 int getHeight (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; }
getNumLayers(void) const881 int getNumLayers (void) const { return m_numLevels > 0 ? m_levels[0].getDepth() : 0; }
getNumLevels(void) const882 int getNumLevels (void) const { return m_numLevels; }
getLevel(int ndx) const883 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; }
getLevels(void) const884 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
getWidth(void) const911 int getWidth (void) const { return m_width; }
getNumLayers(void) const912 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
operator Texture1DArrayView(void) const929 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
sample(const Sampler & sampler,float s,float t,float lod) const937 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
sampleOffset(const Sampler & sampler,float s,float t,float lod,deInt32 offset) const942 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
sampleCompare(const Sampler & sampler,float ref,float s,float t,float lod) const947 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
sampleCompareOffset(const Sampler & sampler,float ref,float s,float t,float lod,deInt32 offset) const952 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
getWidth(void) const967 int getWidth (void) const { return m_width; }
getHeight(void) const968 int getHeight (void) const { return m_height; }
getNumLayers(void) const969 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
operator Texture2DArrayView(void) const989 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
sample(const Sampler & sampler,float s,float t,float r,float lod) const998 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
sampleOffset(const Sampler & sampler,float s,float t,float r,float lod,const IVec2 & offset) const1003 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
sampleCompare(const Sampler & sampler,float ref,float s,float t,float r,float lod) const1008 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
sampleCompareOffset(const Sampler & sampler,float ref,float s,float t,float r,float lod,const IVec2 & offset) const1013 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
gatherOffsets(const Sampler & sampler,float s,float t,float r,int componentNdx,const IVec2 (& offsets)[4]) const1018 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
gatherOffsetsCompare(const Sampler & sampler,float ref,float s,float t,float r,const IVec2 (& offsets)[4]) const1023 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
getWidth(void) const1036 int getWidth (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; }
getHeight(void) const1037 int getHeight (void) const { return m_numLevels > 0 ? m_levels[0].getHeight() : 0; }
getDepth(void) const1038 int getDepth (void) const { return m_numLevels > 0 ? m_levels[0].getDepth() : 0; }
getNumLevels(void) const1039 int getNumLevels (void) const { return m_numLevels; }
getLevel(int ndx) const1040 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; }
getLevels(void) const1041 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
sample(const Sampler & sampler,float s,float t,float r,float lod) const1051 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
sampleOffset(const Sampler & sampler,float s,float t,float r,float lod,const IVec3 & offset) const1056 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
getWidth(void) const1071 int getWidth (void) const { return m_width; }
getHeight(void) const1072 int getHeight (void) const { return m_height; }
getDepth(void) const1073 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
operator Texture3DView(void) const1088 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
sample(const Sampler & sampler,float s,float t,float r,float lod) const1097 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
sampleOffset(const Sampler & sampler,float s,float t,float r,float lod,const IVec3 & offset) const1102 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
getSize(void) const1115 int getSize (void) const { return m_numLevels > 0 ? m_levels[0].getWidth() : 0; }
getDepth(void) const1116 int getDepth (void) const { return m_numLevels > 0 ? m_levels[0].getDepth() : 0; }
getNumLayers(void) const1117 int getNumLayers (void) const { return getDepth() / 6; }
getNumLevels(void) const1118 int getNumLevels (void) const { return m_numLevels; }
getLevel(int ndx) const1119 const ConstPixelBufferAccess& getLevel (int ndx) const { DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); return m_levels[ndx]; }
getLevels(void) const1120 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
getSize(void) const1144 int getSize (void) const { return m_size; }
getDepth(void) const1145 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
operator TextureCubeArrayView(void) const1162 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
sample(const Sampler & sampler,float s,float t,float r,float q,float lod) const1170 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
sampleOffset(const Sampler & sampler,float s,float t,float r,float q,float lod,const IVec2 & offset) const1175 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
sampleCompare(const Sampler & sampler,float ref,float s,float t,float r,float q,float lod) const1180 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
sampleCompareOffset(const Sampler & sampler,float ref,float s,float t,float r,float q,float lod,const IVec2 & offset) const1185 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
1200