| #ifndef _TCUTEXTURE_HPP |
| #define _TCUTEXTURE_HPP |
| /*------------------------------------------------------------------------- |
| * drawElements Quality Program Tester Core |
| * ---------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Reference Texture Implementation. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "tcuDefs.hpp" |
| #include "tcuVector.hpp" |
| #include "rrGenericVector.hpp" |
| #include "deArrayBuffer.hpp" |
| |
| #include <vector> |
| #include <ostream> |
| |
| namespace tcu |
| { |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Texture format |
| *//*--------------------------------------------------------------------*/ |
| class TextureFormat |
| { |
| public: |
| enum ChannelOrder |
| { |
| R = 0, |
| A, |
| I, |
| L, |
| LA, |
| RG, |
| RA, |
| RGB, |
| RGBA, |
| ARGB, |
| ABGR, |
| BGR, |
| BGRA, |
| |
| sR, |
| sRG, |
| sRGB, |
| sRGBA, |
| sBGR, |
| sBGRA, |
| |
| D, |
| S, |
| DS, |
| |
| CHANNELORDER_LAST |
| }; |
| |
| enum ChannelType |
| { |
| SNORM_INT8 = 0, |
| SNORM_INT16, |
| SNORM_INT32, |
| UNORM_INT8, |
| UNORM_INT16, |
| UNORM_INT24, |
| UNORM_INT32, |
| UNORM_BYTE_44, |
| UNORM_SHORT_565, |
| UNORM_SHORT_555, |
| UNORM_SHORT_4444, |
| UNORM_SHORT_5551, |
| UNORM_SHORT_1555, |
| UNORM_INT_101010, |
| SNORM_INT_1010102_REV, |
| UNORM_INT_1010102_REV, |
| UNSIGNED_BYTE_44, |
| UNSIGNED_SHORT_565, |
| UNSIGNED_SHORT_4444, |
| UNSIGNED_SHORT_5551, |
| SIGNED_INT_1010102_REV, |
| UNSIGNED_INT_1010102_REV, |
| UNSIGNED_INT_11F_11F_10F_REV, |
| UNSIGNED_INT_999_E5_REV, |
| UNSIGNED_INT_16_8_8, |
| UNSIGNED_INT_24_8, |
| UNSIGNED_INT_24_8_REV, |
| SIGNED_INT8, |
| SIGNED_INT16, |
| SIGNED_INT32, |
| SIGNED_INT64, |
| UNSIGNED_INT8, |
| UNSIGNED_INT16, |
| UNSIGNED_INT24, |
| UNSIGNED_INT32, |
| UNSIGNED_INT64, |
| HALF_FLOAT, |
| FLOAT, |
| FLOAT64, |
| FLOAT_UNSIGNED_INT_24_8_REV, |
| |
| UNORM_SHORT_10, |
| UNORM_SHORT_12, |
| |
| USCALED_INT8, |
| USCALED_INT16, |
| SSCALED_INT8, |
| SSCALED_INT16, |
| USCALED_INT_1010102_REV, |
| SSCALED_INT_1010102_REV, |
| |
| CHANNELTYPE_LAST |
| }; |
| |
| ChannelOrder order; |
| ChannelType type; |
| |
| TextureFormat(ChannelOrder order_, ChannelType type_) : order(order_), type(type_) |
| { |
| } |
| |
| TextureFormat(void) : order(CHANNELORDER_LAST), type(CHANNELTYPE_LAST) |
| { |
| } |
| |
| int getPixelSize(void) const; //!< Deprecated, use tcu::getPixelSize(fmt) |
| |
| bool operator==(const TextureFormat &other) const |
| { |
| return !(*this != other); |
| } |
| bool operator!=(const TextureFormat &other) const |
| { |
| return (order != other.order || type != other.type); |
| } |
| } DE_WARN_UNUSED_TYPE; |
| |
| bool isValid(TextureFormat format); |
| int getPixelSize(TextureFormat format); |
| int getNumUsedChannels(TextureFormat::ChannelOrder order); |
| bool hasAlphaChannel(TextureFormat::ChannelOrder order); |
| int getChannelSize(TextureFormat::ChannelType type); |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Texture swizzle |
| *//*--------------------------------------------------------------------*/ |
| struct TextureSwizzle |
| { |
| enum Channel |
| { |
| // \note CHANNEL_N must equal int N |
| CHANNEL_0 = 0, |
| CHANNEL_1, |
| CHANNEL_2, |
| CHANNEL_3, |
| |
| CHANNEL_ZERO, |
| CHANNEL_ONE, |
| |
| CHANNEL_LAST |
| }; |
| |
| Channel components[4]; |
| }; |
| |
| //! get the swizzle used to expand texture data with a given channel order to RGBA form |
| const TextureSwizzle &getChannelReadSwizzle(TextureFormat::ChannelOrder order); |
| |
| //! get the swizzle used to narrow RGBA form data to native texture data with a given channel order |
| const TextureSwizzle &getChannelWriteSwizzle(TextureFormat::ChannelOrder order); |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Sampling parameters |
| *//*--------------------------------------------------------------------*/ |
| class Sampler |
| { |
| public: |
| enum WrapMode |
| { |
| CLAMP_TO_EDGE = 0, //! Clamp to edge |
| CLAMP_TO_BORDER, //! Use border color at edge |
| REPEAT_GL, //! Repeat with OpenGL semantics |
| REPEAT_CL, //! Repeat with OpenCL semantics |
| MIRRORED_REPEAT_GL, //! Mirrored repeat with OpenGL semantics |
| MIRRORED_REPEAT_CL, //! Mirrored repeat with OpenCL semantics |
| MIRRORED_ONCE, //! Mirrored once in negative directions |
| |
| WRAPMODE_LAST |
| }; |
| |
| enum FilterMode |
| { |
| NEAREST = 0, |
| LINEAR, |
| CUBIC, |
| |
| NEAREST_MIPMAP_NEAREST, |
| NEAREST_MIPMAP_LINEAR, |
| LINEAR_MIPMAP_NEAREST, |
| LINEAR_MIPMAP_LINEAR, |
| CUBIC_MIPMAP_NEAREST, |
| CUBIC_MIPMAP_LINEAR, |
| |
| FILTERMODE_LAST |
| }; |
| |
| enum ReductionMode |
| { |
| WEIGHTED_AVERAGE = 0, |
| MIN, |
| MAX, |
| |
| REDUCTIONMODE_LAST |
| }; |
| |
| enum CompareMode |
| { |
| COMPAREMODE_NONE = 0, |
| COMPAREMODE_LESS, |
| COMPAREMODE_LESS_OR_EQUAL, |
| COMPAREMODE_GREATER, |
| COMPAREMODE_GREATER_OR_EQUAL, |
| COMPAREMODE_EQUAL, |
| COMPAREMODE_NOT_EQUAL, |
| COMPAREMODE_ALWAYS, |
| COMPAREMODE_NEVER, |
| |
| COMPAREMODE_LAST |
| }; |
| |
| enum DepthStencilMode |
| { |
| MODE_DEPTH = 0, |
| MODE_STENCIL, |
| |
| MODE_LAST |
| }; |
| |
| // Wrap control |
| WrapMode wrapS; |
| WrapMode wrapT; |
| WrapMode wrapR; |
| |
| // Minifcation & magnification |
| FilterMode minFilter; |
| FilterMode magFilter; |
| |
| // min/max filtering reduction |
| ReductionMode reductionMode; |
| |
| float lodThreshold; // lod <= lodThreshold ? magnified : minified |
| |
| // Coordinate normalization |
| bool normalizedCoords; |
| |
| // Shadow comparison |
| CompareMode compare; |
| int compareChannel; |
| |
| // Border color. |
| // \note It is setter's responsibility to guarantee that the values are representable |
| // in sampled texture's internal format. |
| // \note It is setter's responsibility to guarantee that the format is compatible with the |
| // sampled texture's internal format. Otherwise results are undefined. |
| rr::GenericVec4 borderColor; |
| |
| // Seamless cube map filtering |
| bool seamlessCubeMap; |
| |
| // Depth stencil mode |
| DepthStencilMode depthStencilMode; |
| |
| 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, |
| ReductionMode reductionMode_ = WEIGHTED_AVERAGE) |
| : wrapS(wrapS_) |
| , wrapT(wrapT_) |
| , wrapR(wrapR_) |
| , minFilter(minFilter_) |
| , magFilter(magFilter_) |
| , reductionMode(reductionMode_) |
| , lodThreshold(lodThreshold_) |
| , normalizedCoords(normalizedCoords_) |
| , compare(compare_) |
| , compareChannel(compareChannel_) |
| , borderColor(borderColor_) |
| , seamlessCubeMap(seamlessCubeMap_) |
| , depthStencilMode(depthStencilMode_) |
| { |
| } |
| |
| Sampler(void) |
| : wrapS(WRAPMODE_LAST) |
| , wrapT(WRAPMODE_LAST) |
| , wrapR(WRAPMODE_LAST) |
| , minFilter(FILTERMODE_LAST) |
| , magFilter(FILTERMODE_LAST) |
| , reductionMode(REDUCTIONMODE_LAST) |
| , lodThreshold(0.0f) |
| , normalizedCoords(true) |
| , compare(COMPAREMODE_NONE) |
| , compareChannel(0) |
| , borderColor(Vec4(0.0f, 0.0f, 0.0f, 0.0f)) |
| , seamlessCubeMap(false) |
| , depthStencilMode(MODE_DEPTH) |
| { |
| } |
| } DE_WARN_UNUSED_TYPE; |
| |
| // Calculate pitches for pixel data with no padding. |
| IVec3 calculatePackedPitch(const TextureFormat &format, const IVec3 &size); |
| |
| bool isSamplerMipmapModeLinear(tcu::Sampler::FilterMode filterMode); |
| |
| class TextureLevel; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Read-only pixel data access |
| * |
| * ConstPixelBufferAccess encapsulates pixel data pointer along with |
| * format and layout information. It can be used for read-only access |
| * to arbitrary pixel buffers. |
| * |
| * Access objects are like iterators or pointers. They can be passed around |
| * as values and are valid as long as the storage doesn't change. |
| *//*--------------------------------------------------------------------*/ |
| class ConstPixelBufferAccess |
| { |
| public: |
| ConstPixelBufferAccess(void); |
| ConstPixelBufferAccess(const TextureLevel &level); |
| ConstPixelBufferAccess(const TextureFormat &format, int width, int height, int depth, const void *data); |
| ConstPixelBufferAccess(const TextureFormat &format, const IVec3 &size, const void *data); |
| ConstPixelBufferAccess(const TextureFormat &format, int width, int height, int depth, int rowPitch, int slicePitch, |
| const void *data); |
| ConstPixelBufferAccess(const TextureFormat &format, const IVec3 &size, const IVec3 &pitch, const void *data); |
| ConstPixelBufferAccess(const TextureFormat &format, const IVec3 &size, const IVec3 &pitch, const IVec3 ÷r, |
| const void *data); |
| |
| const TextureFormat &getFormat(void) const |
| { |
| return m_format; |
| } |
| const IVec3 &getSize(void) const |
| { |
| return m_size; |
| } |
| int getWidth(void) const |
| { |
| return m_size.x(); |
| } |
| int getHeight(void) const |
| { |
| return m_size.y(); |
| } |
| int getDepth(void) const |
| { |
| return m_size.z(); |
| } |
| int getPixelPitch(void) const |
| { |
| return m_pitch.x(); |
| } |
| int getRowPitch(void) const |
| { |
| return m_pitch.y(); |
| } |
| int getSlicePitch(void) const |
| { |
| return m_pitch.z(); |
| } |
| const IVec3 &getPitch(void) const |
| { |
| return m_pitch; |
| } |
| const IVec3 &getDivider(void) const |
| { |
| return m_divider; |
| } |
| |
| const void *getDataPtr(void) const |
| { |
| return m_data; |
| } |
| const void *getPixelPtr(int x, int y, int z = 0) const |
| { |
| return (const uint8_t *)m_data + (x / m_divider.x()) * m_pitch.x() + (y / m_divider.y()) * m_pitch.y() + |
| (z / m_divider.z()) * m_pitch.z(); |
| } |
| |
| Vec4 getPixel(int x, int y, int z = 0) const; |
| IVec4 getPixelInt(int x, int y, int z = 0) const; |
| UVec4 getPixelUint(int x, int y, int z = 0) const |
| { |
| return getPixelInt(x, y, z).cast<uint32_t>(); |
| } |
| I64Vec4 getPixelInt64(int x, int y, int z = 0) const; |
| U64Vec4 getPixelUint64(int x, int y, int z = 0) const |
| { |
| return getPixelInt64(x, y, z).cast<uint64_t>(); |
| } |
| U64Vec4 getPixelBitsAsUint64(int x, int y, int z = 0) const; |
| |
| template <typename T> |
| Vector<T, 4> getPixelT(int x, int y, int z = 0) const; |
| |
| float getPixDepth(int x, int y, int z = 0) const; |
| int getPixStencil(int x, int y, int z = 0) const; |
| |
| Vec4 sample1D(const Sampler &sampler, Sampler::FilterMode filter, float s, int level) const; |
| Vec4 sample2D(const Sampler &sampler, Sampler::FilterMode filter, float s, float t, int depth) const; |
| Vec4 sample3D(const Sampler &sampler, Sampler::FilterMode filter, float s, float t, float r) const; |
| |
| Vec4 sample1DOffset(const Sampler &sampler, Sampler::FilterMode filter, float s, const IVec2 &offset) const; |
| Vec4 sample2DOffset(const Sampler &sampler, Sampler::FilterMode filter, float s, float t, |
| const IVec3 &offset) const; |
| Vec4 sample3DOffset(const Sampler &sampler, Sampler::FilterMode filter, float s, float t, float r, |
| const IVec3 &offset) const; |
| |
| float sample1DCompare(const Sampler &sampler, Sampler::FilterMode filter, float ref, float s, |
| const IVec2 &offset) const; |
| float sample2DCompare(const Sampler &sampler, Sampler::FilterMode filter, float ref, float s, float t, |
| const IVec3 &offset) const; |
| |
| protected: |
| TextureFormat m_format; |
| IVec3 m_size; |
| IVec3 m_pitch; //!< (pixelPitch, rowPitch, slicePitch) |
| IVec3 m_divider; |
| mutable void *m_data; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Read-write pixel data access |
| * |
| * This class extends read-only access object by providing write functionality. |
| * |
| * \note PixelBufferAccess may not have any data members nor add any |
| * virtual functions. It must be possible to reinterpret_cast<> |
| * PixelBufferAccess to ConstPixelBufferAccess. |
| *//*--------------------------------------------------------------------*/ |
| class PixelBufferAccess : public ConstPixelBufferAccess |
| { |
| public: |
| PixelBufferAccess(void) |
| { |
| } |
| PixelBufferAccess(TextureLevel &level); |
| PixelBufferAccess(const TextureFormat &format, int width, int height, int depth, void *data); |
| PixelBufferAccess(const TextureFormat &format, const IVec3 &size, void *data); |
| PixelBufferAccess(const TextureFormat &format, int width, int height, int depth, int rowPitch, int slicePitch, |
| void *data); |
| PixelBufferAccess(const TextureFormat &format, const IVec3 &size, const IVec3 &pitch, void *data); |
| PixelBufferAccess(const TextureFormat &format, const IVec3 &size, const IVec3 &pitch, const IVec3 &block, |
| void *data); |
| |
| void *getDataPtr(void) const |
| { |
| return m_data; |
| } |
| void *getPixelPtr(int x, int y, int z = 0) const |
| { |
| return (uint8_t *)m_data + (x / m_divider.x()) * m_pitch.x() + (y / m_divider.y()) * m_pitch.y() + |
| (z / m_divider.z()) * m_pitch.z(); |
| } |
| |
| void setPixel(const tcu::Vec4 &color, int x, int y, int z = 0) const; |
| void setPixel(const tcu::IVec4 &color, int x, int y, int z = 0) const; |
| void setPixel(const tcu::UVec4 &color, int x, int y, int z = 0) const |
| { |
| setPixel(color.cast<int>(), x, y, z); |
| } |
| |
| void setPixDepth(float depth, int x, int y, int z = 0) const; |
| void setPixStencil(int stencil, int x, int y, int z = 0) const; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Generic pixel data container |
| * |
| * This container supports all valid TextureFormat combinations and |
| * both 2D and 3D textures. To read or manipulate data access object must |
| * be queried using getAccess(). |
| *//*--------------------------------------------------------------------*/ |
| class TextureLevel |
| { |
| public: |
| TextureLevel(void); |
| TextureLevel(const TextureFormat &format); |
| TextureLevel(const TextureFormat &format, int width, int height, int depth = 1); |
| ~TextureLevel(void); |
| |
| const IVec3 &getSize(void) const |
| { |
| return m_size; |
| } |
| int getWidth(void) const |
| { |
| return m_size.x(); |
| } |
| int getHeight(void) const |
| { |
| return m_size.y(); |
| } |
| int getDepth(void) const |
| { |
| return m_size.z(); |
| } |
| bool isEmpty(void) const |
| { |
| return m_size.x() * m_size.y() * m_size.z() == 0; |
| } |
| const TextureFormat getFormat(void) const |
| { |
| return m_format; |
| } |
| |
| void setStorage(const TextureFormat &format, int width, int heigth, int depth = 1); |
| void setSize(int width, int height, int depth = 1); |
| |
| PixelBufferAccess getAccess(void) |
| { |
| return isEmpty() ? PixelBufferAccess() : |
| PixelBufferAccess(m_format, m_size, calculatePackedPitch(m_format, m_size), getPtr()); |
| } |
| ConstPixelBufferAccess getAccess(void) const |
| { |
| return isEmpty() ? ConstPixelBufferAccess() : |
| ConstPixelBufferAccess(m_format, m_size, calculatePackedPitch(m_format, m_size), getPtr()); |
| } |
| |
| private: |
| void *getPtr(void) |
| { |
| return m_data.getPtr(); |
| } |
| const void *getPtr(void) const |
| { |
| return m_data.getPtr(); |
| } |
| |
| TextureFormat m_format; |
| IVec3 m_size; |
| de::ArrayBuffer<uint8_t> m_data; |
| |
| friend class ConstPixelBufferAccess; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief VK_EXT_image_view_min_lod |
| *//*--------------------------------------------------------------------*/ |
| enum ImageViewMinLodMode |
| { |
| IMAGEVIEWMINLODMODE_PREFERRED, //!< use image view min lod as-is |
| IMAGEVIEWMINLODMODE_ALTERNATIVE, //!< use floor of image view min lod, as in 'Image Level(s) Selection' in VK spec (v 1.3.206) |
| }; |
| |
| struct ImageViewMinLod |
| { |
| float value; |
| ImageViewMinLodMode mode; |
| }; |
| |
| struct ImageViewMinLodParams |
| { |
| int baseLevel; |
| ImageViewMinLod minLod; |
| bool intTexCoord; |
| }; |
| |
| Vec4 sampleLevelArray1D(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float s, int level, |
| float lod); |
| Vec4 sampleLevelArray2D(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float s, float t, |
| int depth, float lod, bool es2 = false, ImageViewMinLodParams *minLodParams = DE_NULL); |
| Vec4 sampleLevelArray3D(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float s, float t, |
| float r, float lod, ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| Vec4 sampleLevelArray1DOffset(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float s, |
| float lod, const IVec2 &offset); |
| Vec4 sampleLevelArray2DOffset(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float s, |
| float t, float lod, const IVec3 &offset, bool es2 = false, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| Vec4 sampleLevelArray3DOffset(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float s, |
| float t, float r, float lod, const IVec3 &offset, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| float sampleLevelArray1DCompare(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float ref, |
| float s, float lod, const IVec2 &offset); |
| float sampleLevelArray2DCompare(const ConstPixelBufferAccess *levels, int numLevels, const Sampler &sampler, float ref, |
| float s, float t, float lod, const IVec3 &offset); |
| |
| Vec4 gatherArray2DOffsets(const ConstPixelBufferAccess &src, const Sampler &sampler, float s, float t, int depth, |
| int componentNdx, const IVec2 (&offsets)[4]); |
| Vec4 gatherArray2DOffsetsCompare(const ConstPixelBufferAccess &src, const Sampler &sampler, float ref, float s, float t, |
| int depth, const IVec2 (&offsets)[4]); |
| |
| enum CubeFace |
| { |
| CUBEFACE_NEGATIVE_X = 0, |
| CUBEFACE_POSITIVE_X, |
| CUBEFACE_NEGATIVE_Y, |
| CUBEFACE_POSITIVE_Y, |
| CUBEFACE_NEGATIVE_Z, |
| CUBEFACE_POSITIVE_Z, |
| |
| CUBEFACE_LAST |
| }; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Coordinates projected onto cube face. |
| *//*--------------------------------------------------------------------*/ |
| template <typename T> |
| struct CubeFaceCoords |
| { |
| CubeFace face; |
| T s; |
| T t; |
| |
| CubeFaceCoords(CubeFace face_, T s_, T t_) : face(face_), s(s_), t(t_) |
| { |
| } |
| CubeFaceCoords(CubeFace face_, const Vector<T, 2> &c) : face(face_), s(c.x()), t(c.y()) |
| { |
| } |
| } DE_WARN_UNUSED_TYPE; |
| |
| typedef CubeFaceCoords<float> CubeFaceFloatCoords; |
| typedef CubeFaceCoords<int> CubeFaceIntCoords; |
| |
| CubeFace selectCubeFace(const Vec3 &coords); |
| Vec2 projectToFace(CubeFace face, const Vec3 &coords); |
| CubeFaceFloatCoords getCubeFaceCoords(const Vec3 &coords); |
| CubeFaceIntCoords remapCubeEdgeCoords(const CubeFaceIntCoords &coords, int size); |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 2D Texture View |
| *//*--------------------------------------------------------------------*/ |
| class Texture2DView |
| { |
| public: |
| Texture2DView(int numLevels, const ConstPixelBufferAccess *levels, bool es2 = false, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| int getNumLevels(void) const |
| { |
| return m_numLevels; |
| } |
| int getWidth(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getWidth() : 0; |
| } |
| int getHeight(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getHeight() : 0; |
| } |
| const ConstPixelBufferAccess &getLevel(int ndx) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); |
| return m_levels[ndx]; |
| } |
| const ConstPixelBufferAccess *getLevels(void) const |
| { |
| return m_levels; |
| } |
| bool isES2(void) const |
| { |
| return m_es2; |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float lod, const IVec2 &offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float lod, |
| const IVec2 &offset) const; |
| |
| Vec4 gatherOffsets(const Sampler &sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const; |
| Vec4 gatherOffsetsCompare(const Sampler &sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const; |
| |
| ImageViewMinLodParams *getImageViewMinLodParams(void) const |
| { |
| return m_minLodParams; |
| } |
| |
| protected: |
| int m_numLevels; |
| const ConstPixelBufferAccess *m_levels; |
| bool m_es2; |
| struct ImageViewMinLodParams *m_minLodParams; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Texture2DView::Texture2DView(int numLevels, const ConstPixelBufferAccess *levels, bool es2, |
| ImageViewMinLodParams *minLodParams) |
| : m_numLevels(numLevels) |
| , m_levels(levels) |
| , m_es2(es2) |
| , m_minLodParams(minLodParams) |
| { |
| DE_ASSERT(m_numLevels >= 0 && ((m_numLevels == 0) == !m_levels)); |
| } |
| |
| inline Vec4 Texture2DView::sample(const Sampler &sampler, float s, float t, float lod) const |
| { |
| return sampleLevelArray2D(m_levels, m_numLevels, sampler, s, t, 0 /* depth */, lod, m_es2, m_minLodParams); |
| } |
| |
| inline Vec4 Texture2DView::sampleOffset(const Sampler &sampler, float s, float t, float lod, const IVec2 &offset) const |
| { |
| return sampleLevelArray2DOffset(m_levels, m_numLevels, sampler, s, t, lod, IVec3(offset.x(), offset.y(), 0)); |
| } |
| |
| inline float Texture2DView::sampleCompare(const Sampler &sampler, float ref, float s, float t, float lod) const |
| { |
| return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(0, 0, 0)); |
| } |
| |
| inline float Texture2DView::sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float lod, |
| const IVec2 &offset) const |
| { |
| return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(offset.x(), offset.y(), 0)); |
| } |
| |
| inline Vec4 Texture2DView::gatherOffsets(const Sampler &sampler, float s, float t, int componentNdx, |
| const IVec2 (&offsets)[4]) const |
| { |
| return gatherArray2DOffsets(m_levels[0], sampler, s, t, 0, componentNdx, offsets); |
| } |
| |
| inline Vec4 Texture2DView::gatherOffsetsCompare(const Sampler &sampler, float ref, float s, float t, |
| const IVec2 (&offsets)[4]) const |
| { |
| return gatherArray2DOffsetsCompare(m_levels[0], sampler, ref, s, t, 0, offsets); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Base class for textures that have single mip-map pyramid |
| *//*--------------------------------------------------------------------*/ |
| class TextureLevelPyramid |
| { |
| public: |
| TextureLevelPyramid(const TextureFormat &format, int numLevels); |
| TextureLevelPyramid(const TextureLevelPyramid &other); |
| ~TextureLevelPyramid(void); |
| |
| const TextureFormat &getFormat(void) const |
| { |
| return m_format; |
| } |
| int getNumLevels(void) const |
| { |
| return (int)m_access.size(); |
| } |
| |
| bool isLevelEmpty(int levelNdx) const |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| return m_data[(size_t)levelNdx].empty(); |
| } |
| const ConstPixelBufferAccess &getLevel(int levelNdx) const |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| return m_access[(size_t)levelNdx]; |
| } |
| const PixelBufferAccess &getLevel(int levelNdx) |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| return m_access[(size_t)levelNdx]; |
| } |
| |
| const ConstPixelBufferAccess *getLevels(void) const |
| { |
| return &m_access[0]; |
| } |
| const PixelBufferAccess *getLevels(void) |
| { |
| return &m_access[0]; |
| } |
| |
| void allocLevel(int levelNdx, int width, int height, int depth); |
| void clearLevel(int levelNdx); |
| |
| TextureLevelPyramid &operator=(const TextureLevelPyramid &other); |
| |
| private: |
| typedef de::ArrayBuffer<uint8_t> LevelData; |
| |
| TextureFormat m_format; |
| std::vector<LevelData> m_data; |
| std::vector<PixelBufferAccess> m_access; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 2D Texture reference implementation |
| *//*--------------------------------------------------------------------*/ |
| class Texture2D : private TextureLevelPyramid |
| { |
| public: |
| Texture2D(const TextureFormat &format, int width, int height, bool es2 = false); |
| Texture2D(const TextureFormat &format, int width, int height, int mipmaps); |
| Texture2D(const Texture2D &other); |
| ~Texture2D(void); |
| |
| int getWidth(void) const |
| { |
| return m_width; |
| } |
| int getHeight(void) const |
| { |
| return m_height; |
| } |
| const Texture2DView &getView(void) const |
| { |
| return m_view; |
| } |
| bool isYUVTextureUsed(void) const |
| { |
| return m_yuvTextureUsed; |
| } |
| void allocLevel(int levelNdx); |
| |
| // Sampling |
| Vec4 sample(const Sampler &sampler, float s, float t, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float lod, const IVec2 &offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float lod, |
| const IVec2 &offset) const; |
| |
| Vec4 gatherOffsets(const Sampler &sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const; |
| Vec4 gatherOffsetsCompare(const Sampler &sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const; |
| |
| using TextureLevelPyramid::clearLevel; |
| using TextureLevelPyramid::getFormat; |
| using TextureLevelPyramid::getLevel; |
| using TextureLevelPyramid::getNumLevels; |
| using TextureLevelPyramid::isLevelEmpty; |
| |
| Texture2D &operator=(const Texture2D &other); |
| //whether this is a yuv format texture tests |
| bool m_yuvTextureUsed; |
| operator Texture2DView(void) const |
| { |
| return m_view; |
| } |
| |
| private: |
| int m_width; |
| int m_height; |
| Texture2DView m_view; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 Texture2D::sample(const Sampler &sampler, float s, float t, float lod) const |
| { |
| return m_view.sample(sampler, s, t, lod); |
| } |
| |
| inline Vec4 Texture2D::sampleOffset(const Sampler &sampler, float s, float t, float lod, const IVec2 &offset) const |
| { |
| return m_view.sampleOffset(sampler, s, t, lod, offset); |
| } |
| |
| inline float Texture2D::sampleCompare(const Sampler &sampler, float ref, float s, float t, float lod) const |
| { |
| return m_view.sampleCompare(sampler, ref, s, t, lod); |
| } |
| |
| inline float Texture2D::sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float lod, |
| const IVec2 &offset) const |
| { |
| return m_view.sampleCompareOffset(sampler, ref, s, t, lod, offset); |
| } |
| |
| inline Vec4 Texture2D::gatherOffsets(const Sampler &sampler, float s, float t, int componentNdx, |
| const IVec2 (&offsets)[4]) const |
| { |
| return m_view.gatherOffsets(sampler, s, t, componentNdx, offsets); |
| } |
| |
| inline Vec4 Texture2D::gatherOffsetsCompare(const Sampler &sampler, float ref, float s, float t, |
| const IVec2 (&offsets)[4]) const |
| { |
| return m_view.gatherOffsetsCompare(sampler, ref, s, t, offsets); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Cube Map Texture View |
| *//*--------------------------------------------------------------------*/ |
| class TextureCubeView |
| { |
| public: |
| TextureCubeView(void); |
| TextureCubeView(int numLevels, const ConstPixelBufferAccess *const (&levels)[CUBEFACE_LAST], bool es2 = false, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| int getNumLevels(void) const |
| { |
| return m_numLevels; |
| } |
| bool isES2(void) const |
| { |
| return m_es2; |
| } |
| int getSize(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0][0].getWidth() : 0; |
| } |
| const ConstPixelBufferAccess &getLevelFace(int ndx, CubeFace face) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); |
| return m_levels[face][ndx]; |
| } |
| const ConstPixelBufferAccess *getFaceLevels(CubeFace face) const |
| { |
| return m_levels[face]; |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float p, float lod) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float lod) const; |
| |
| Vec4 gather(const Sampler &sampler, float s, float t, float r, int componentNdx) const; |
| Vec4 gatherCompare(const Sampler &sampler, float ref, float s, float t, float r) const; |
| |
| ImageViewMinLodParams *getImageViewMinLodParams(void) const |
| { |
| return m_minLodParams; |
| } |
| |
| protected: |
| int m_numLevels; |
| const ConstPixelBufferAccess *m_levels[CUBEFACE_LAST]; |
| bool m_es2; |
| ImageViewMinLodParams *m_minLodParams; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Cube Map Texture reference implementation |
| *//*--------------------------------------------------------------------*/ |
| class TextureCube |
| { |
| public: |
| TextureCube(const TextureFormat &format, int size, bool es2 = false); |
| TextureCube(const TextureCube &other); |
| ~TextureCube(void); |
| |
| const TextureFormat &getFormat(void) const |
| { |
| return m_format; |
| } |
| int getSize(void) const |
| { |
| return m_size; |
| } |
| const TextureCubeView &getView(void) const |
| { |
| return m_view; |
| } |
| |
| int getNumLevels(void) const |
| { |
| return (int)m_access[0].size(); |
| } |
| const ConstPixelBufferAccess &getLevelFace(int ndx, CubeFace face) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, getNumLevels())); |
| return m_access[face][(size_t)ndx]; |
| } |
| const PixelBufferAccess &getLevelFace(int ndx, CubeFace face) |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, getNumLevels())); |
| return m_access[face][(size_t)ndx]; |
| } |
| |
| void allocLevel(CubeFace face, int levelNdx); |
| void clearLevel(CubeFace face, int levelNdx); |
| bool isLevelEmpty(CubeFace face, int levelNdx) const |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| return m_data[face][(size_t)levelNdx].empty(); |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float p, float lod) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float lod) const; |
| |
| Vec4 gather(const Sampler &sampler, float s, float t, float r, int componentNdx) const; |
| Vec4 gatherCompare(const Sampler &sampler, float ref, float s, float t, float r) const; |
| |
| TextureCube &operator=(const TextureCube &other); |
| |
| operator TextureCubeView(void) const |
| { |
| return m_view; |
| } |
| |
| private: |
| typedef de::ArrayBuffer<uint8_t> LevelData; |
| |
| TextureFormat m_format; |
| int m_size; |
| std::vector<LevelData> m_data[CUBEFACE_LAST]; |
| std::vector<PixelBufferAccess> m_access[CUBEFACE_LAST]; |
| TextureCubeView m_view; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 TextureCube::sample(const Sampler &sampler, float s, float t, float p, float lod) const |
| { |
| return m_view.sample(sampler, s, t, p, lod); |
| } |
| |
| inline float TextureCube::sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float lod) const |
| { |
| return m_view.sampleCompare(sampler, ref, s, t, r, lod); |
| } |
| |
| inline Vec4 TextureCube::gather(const Sampler &sampler, float s, float t, float r, int componentNdx) const |
| { |
| return m_view.gather(sampler, s, t, r, componentNdx); |
| } |
| |
| inline Vec4 TextureCube::gatherCompare(const Sampler &sampler, float ref, float s, float t, float r) const |
| { |
| return m_view.gatherCompare(sampler, ref, s, t, r); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 1D Texture View |
| *//*--------------------------------------------------------------------*/ |
| class Texture1DView |
| { |
| public: |
| Texture1DView(int numLevels, const ConstPixelBufferAccess *levels, bool es2, ImageViewMinLodParams *minLodParams); |
| |
| int getNumLevels(void) const |
| { |
| return m_numLevels; |
| } |
| int getWidth(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getWidth() : 0; |
| } |
| const ConstPixelBufferAccess &getLevel(int ndx) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); |
| return m_levels[ndx]; |
| } |
| const ConstPixelBufferAccess *getLevels(void) const |
| { |
| return m_levels; |
| } |
| bool isES2(void) const |
| { |
| return false; |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float lod, int32_t offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float lod, int32_t offset) const; |
| |
| ImageViewMinLodParams *getImageViewMinLodParams(void) const |
| { |
| return DE_NULL; |
| } |
| |
| protected: |
| int m_numLevels; |
| const ConstPixelBufferAccess *m_levels; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Texture1DView::Texture1DView(int numLevels, const ConstPixelBufferAccess *levels, |
| bool es2 DE_UNUSED_ATTR = false, |
| ImageViewMinLodParams *minLodParams DE_UNUSED_ATTR = DE_NULL) |
| : m_numLevels(numLevels) |
| , m_levels(levels) |
| { |
| DE_ASSERT(m_numLevels >= 0 && ((m_numLevels == 0) == !m_levels)); |
| } |
| |
| inline Vec4 Texture1DView::sample(const Sampler &sampler, float s, float lod) const |
| { |
| return sampleLevelArray1D(m_levels, m_numLevels, sampler, s, 0 /* depth */, lod); |
| } |
| |
| inline Vec4 Texture1DView::sampleOffset(const Sampler &sampler, float s, float lod, int32_t offset) const |
| { |
| return sampleLevelArray1DOffset(m_levels, m_numLevels, sampler, s, lod, IVec2(offset, 0)); |
| } |
| |
| inline float Texture1DView::sampleCompare(const Sampler &sampler, float ref, float s, float lod) const |
| { |
| return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(0, 0)); |
| } |
| |
| inline float Texture1DView::sampleCompareOffset(const Sampler &sampler, float ref, float s, float lod, |
| int32_t offset) const |
| { |
| return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(offset, 0)); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 1D Texture reference implementation |
| *//*--------------------------------------------------------------------*/ |
| class Texture1D : private TextureLevelPyramid |
| { |
| public: |
| Texture1D(const TextureFormat &format, int width); |
| Texture1D(const Texture1D &other); |
| ~Texture1D(void); |
| |
| int getWidth(void) const |
| { |
| return m_width; |
| } |
| const Texture1DView &getView(void) const |
| { |
| return m_view; |
| } |
| |
| void allocLevel(int levelNdx); |
| |
| // Sampling |
| Vec4 sample(const Sampler &sampler, float s, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float lod, int32_t offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float lod, int32_t offset) const; |
| |
| using TextureLevelPyramid::clearLevel; |
| using TextureLevelPyramid::getFormat; |
| using TextureLevelPyramid::getLevel; |
| using TextureLevelPyramid::getNumLevels; |
| using TextureLevelPyramid::isLevelEmpty; |
| |
| Texture1D &operator=(const Texture1D &other); |
| |
| operator Texture1DView(void) const |
| { |
| return m_view; |
| } |
| |
| private: |
| int m_width; |
| Texture1DView m_view; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 Texture1D::sample(const Sampler &sampler, float s, float lod) const |
| { |
| return m_view.sample(sampler, s, lod); |
| } |
| |
| inline Vec4 Texture1D::sampleOffset(const Sampler &sampler, float s, float lod, int32_t offset) const |
| { |
| return m_view.sampleOffset(sampler, s, lod, offset); |
| } |
| |
| inline float Texture1D::sampleCompare(const Sampler &sampler, float ref, float s, float lod) const |
| { |
| return m_view.sampleCompare(sampler, ref, s, lod); |
| } |
| |
| inline float Texture1D::sampleCompareOffset(const Sampler &sampler, float ref, float s, float lod, int32_t offset) const |
| { |
| return m_view.sampleCompareOffset(sampler, ref, s, lod, offset); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 1D Array Texture View |
| *//*--------------------------------------------------------------------*/ |
| class Texture1DArrayView |
| { |
| public: |
| Texture1DArrayView(int numLevels, const ConstPixelBufferAccess *levels, bool es2 = false, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| int getWidth(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getWidth() : 0; |
| } |
| int getNumLayers(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getHeight() : 0; |
| } |
| int getNumLevels(void) const |
| { |
| return m_numLevels; |
| } |
| const ConstPixelBufferAccess &getLevel(int ndx) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); |
| return m_levels[ndx]; |
| } |
| const ConstPixelBufferAccess *getLevels(void) const |
| { |
| return m_levels; |
| } |
| bool isES2(void) const |
| { |
| return false; |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float lod, int32_t offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float lod, int32_t offset) const; |
| |
| ImageViewMinLodParams *getImageViewMinLodParams(void) const |
| { |
| return DE_NULL; |
| } |
| |
| protected: |
| int selectLayer(float r) const; |
| |
| int m_numLevels; |
| const ConstPixelBufferAccess *m_levels; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 1D Array Texture reference implementation |
| *//*--------------------------------------------------------------------*/ |
| class Texture1DArray : private TextureLevelPyramid |
| { |
| public: |
| Texture1DArray(const TextureFormat &format, int width, int numLayers); |
| Texture1DArray(const Texture1DArray &other); |
| ~Texture1DArray(void); |
| |
| int getWidth(void) const |
| { |
| return m_width; |
| } |
| int getNumLayers(void) const |
| { |
| return m_numLayers; |
| } |
| |
| void allocLevel(int levelNdx); |
| |
| using TextureLevelPyramid::clearLevel; |
| using TextureLevelPyramid::getFormat; |
| using TextureLevelPyramid::getLevel; |
| using TextureLevelPyramid::getNumLevels; |
| using TextureLevelPyramid::isLevelEmpty; |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float lod, int32_t offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float lod, int32_t offset) const; |
| |
| Texture1DArray &operator=(const Texture1DArray &other); |
| |
| operator Texture1DArrayView(void) const |
| { |
| return m_view; |
| } |
| |
| private: |
| int m_width; |
| int m_numLayers; |
| Texture1DArrayView m_view; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 Texture1DArray::sample(const Sampler &sampler, float s, float t, float lod) const |
| { |
| return m_view.sample(sampler, s, t, lod); |
| } |
| |
| inline Vec4 Texture1DArray::sampleOffset(const Sampler &sampler, float s, float t, float lod, int32_t offset) const |
| { |
| return m_view.sampleOffset(sampler, s, t, lod, offset); |
| } |
| |
| inline float Texture1DArray::sampleCompare(const Sampler &sampler, float ref, float s, float t, float lod) const |
| { |
| return m_view.sampleCompare(sampler, ref, s, t, lod); |
| } |
| |
| inline float Texture1DArray::sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float lod, |
| int32_t offset) const |
| { |
| return m_view.sampleCompareOffset(sampler, ref, s, t, lod, offset); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 2D Array Texture View |
| *//*--------------------------------------------------------------------*/ |
| class Texture2DArrayView |
| { |
| public: |
| Texture2DArrayView(int numLevels, const ConstPixelBufferAccess *levels, bool es2 = false, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| int getWidth(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getWidth() : 0; |
| } |
| int getHeight(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getHeight() : 0; |
| } |
| int getNumLayers(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getDepth() : 0; |
| } |
| int getNumLevels(void) const |
| { |
| return m_numLevels; |
| } |
| const ConstPixelBufferAccess &getLevel(int ndx) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); |
| return m_levels[ndx]; |
| } |
| const ConstPixelBufferAccess *getLevels(void) const |
| { |
| return m_levels; |
| } |
| bool isES2(void) const |
| { |
| return false; |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float r, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float r, float lod, const IVec2 &offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float r, float lod, |
| const IVec2 &offset) const; |
| |
| Vec4 gatherOffsets(const Sampler &sampler, float s, float t, float r, int componentNdx, |
| const IVec2 (&offsets)[4]) const; |
| Vec4 gatherOffsetsCompare(const Sampler &sampler, float ref, float s, float t, float r, |
| const IVec2 (&offsets)[4]) const; |
| |
| ImageViewMinLodParams *getImageViewMinLodParams(void) const |
| { |
| return DE_NULL; |
| } |
| |
| protected: |
| int selectLayer(float r) const; |
| |
| int m_numLevels; |
| const ConstPixelBufferAccess *m_levels; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 2D Array Texture reference implementation |
| *//*--------------------------------------------------------------------*/ |
| class Texture2DArray : private TextureLevelPyramid |
| { |
| public: |
| Texture2DArray(const TextureFormat &format, int width, int height, int numLayers); |
| Texture2DArray(const Texture2DArray &other); |
| ~Texture2DArray(void); |
| |
| int getWidth(void) const |
| { |
| return m_width; |
| } |
| int getHeight(void) const |
| { |
| return m_height; |
| } |
| int getNumLayers(void) const |
| { |
| return m_numLayers; |
| } |
| |
| void allocLevel(int levelNdx); |
| |
| using TextureLevelPyramid::clearLevel; |
| using TextureLevelPyramid::getFormat; |
| using TextureLevelPyramid::getLevel; |
| using TextureLevelPyramid::getNumLevels; |
| using TextureLevelPyramid::isLevelEmpty; |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float r, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float r, float lod, const IVec2 &offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float r, float lod, |
| const IVec2 &offset) const; |
| |
| Vec4 gatherOffsets(const Sampler &sampler, float s, float t, float r, int componentNdx, |
| const IVec2 (&offsets)[4]) const; |
| Vec4 gatherOffsetsCompare(const Sampler &sampler, float ref, float s, float t, float r, |
| const IVec2 (&offsets)[4]) const; |
| |
| Texture2DArray &operator=(const Texture2DArray &other); |
| |
| operator Texture2DArrayView(void) const |
| { |
| return m_view; |
| } |
| |
| private: |
| int m_width; |
| int m_height; |
| int m_numLayers; |
| Texture2DArrayView m_view; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 Texture2DArray::sample(const Sampler &sampler, float s, float t, float r, float lod) const |
| { |
| return m_view.sample(sampler, s, t, r, lod); |
| } |
| |
| inline Vec4 Texture2DArray::sampleOffset(const Sampler &sampler, float s, float t, float r, float lod, |
| const IVec2 &offset) const |
| { |
| return m_view.sampleOffset(sampler, s, t, r, lod, offset); |
| } |
| |
| inline float Texture2DArray::sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, |
| float lod) const |
| { |
| return m_view.sampleCompare(sampler, ref, s, t, r, lod); |
| } |
| |
| inline float Texture2DArray::sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float r, |
| float lod, const IVec2 &offset) const |
| { |
| return m_view.sampleCompareOffset(sampler, ref, s, t, r, lod, offset); |
| } |
| |
| inline Vec4 Texture2DArray::gatherOffsets(const Sampler &sampler, float s, float t, float r, int componentNdx, |
| const IVec2 (&offsets)[4]) const |
| { |
| return m_view.gatherOffsets(sampler, s, t, r, componentNdx, offsets); |
| } |
| |
| inline Vec4 Texture2DArray::gatherOffsetsCompare(const Sampler &sampler, float ref, float s, float t, float r, |
| const IVec2 (&offsets)[4]) const |
| { |
| return m_view.gatherOffsetsCompare(sampler, ref, s, t, r, offsets); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 3D Texture View |
| *//*--------------------------------------------------------------------*/ |
| class Texture3DView |
| { |
| public: |
| Texture3DView(int numLevels, const ConstPixelBufferAccess *levels, bool es2 = false, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| int getWidth(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getWidth() : 0; |
| } |
| int getHeight(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getHeight() : 0; |
| } |
| int getDepth(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getDepth() : 0; |
| } |
| int getNumLevels(void) const |
| { |
| return m_numLevels; |
| } |
| const ConstPixelBufferAccess &getLevel(int ndx) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); |
| return m_levels[ndx]; |
| } |
| const ConstPixelBufferAccess *getLevels(void) const |
| { |
| return m_levels; |
| } |
| bool isES2(void) const |
| { |
| return m_es2; |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float r, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float r, float lod, const IVec3 &offset) const; |
| |
| ImageViewMinLodParams *getImageViewMinLodParams(void) const |
| { |
| return m_minLodParams; |
| } |
| |
| protected: |
| int m_numLevels; |
| const ConstPixelBufferAccess *m_levels; |
| bool m_es2; |
| ImageViewMinLodParams *m_minLodParams; |
| |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 Texture3DView::sample(const Sampler &sampler, float s, float t, float r, float lod) const |
| { |
| return sampleLevelArray3D(m_levels, m_numLevels, sampler, s, t, r, lod, m_minLodParams); |
| } |
| |
| inline Vec4 Texture3DView::sampleOffset(const Sampler &sampler, float s, float t, float r, float lod, |
| const IVec3 &offset) const |
| { |
| return sampleLevelArray3DOffset(m_levels, m_numLevels, sampler, s, t, r, lod, offset, m_minLodParams); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief 3D Texture reference implementation |
| *//*--------------------------------------------------------------------*/ |
| class Texture3D : private TextureLevelPyramid |
| { |
| public: |
| Texture3D(const TextureFormat &format, int width, int height, int depth); |
| Texture3D(const Texture3D &other); |
| ~Texture3D(void); |
| |
| int getWidth(void) const |
| { |
| return m_width; |
| } |
| int getHeight(void) const |
| { |
| return m_height; |
| } |
| int getDepth(void) const |
| { |
| return m_depth; |
| } |
| |
| void allocLevel(int levelNdx); |
| |
| using TextureLevelPyramid::clearLevel; |
| using TextureLevelPyramid::getFormat; |
| using TextureLevelPyramid::getLevel; |
| using TextureLevelPyramid::getNumLevels; |
| using TextureLevelPyramid::isLevelEmpty; |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float r, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float r, float lod, const IVec3 &offset) const; |
| |
| Texture3D &operator=(const Texture3D &other); |
| |
| operator Texture3DView(void) const |
| { |
| return m_view; |
| } |
| |
| private: |
| int m_width; |
| int m_height; |
| int m_depth; |
| Texture3DView m_view; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 Texture3D::sample(const Sampler &sampler, float s, float t, float r, float lod) const |
| { |
| return m_view.sample(sampler, s, t, r, lod); |
| } |
| |
| inline Vec4 Texture3D::sampleOffset(const Sampler &sampler, float s, float t, float r, float lod, |
| const IVec3 &offset) const |
| { |
| return m_view.sampleOffset(sampler, s, t, r, lod, offset); |
| } |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Cube Map Array Texture View |
| *//*--------------------------------------------------------------------*/ |
| class TextureCubeArrayView |
| { |
| public: |
| TextureCubeArrayView(int numLevels, const ConstPixelBufferAccess *levels, bool es2 = false, |
| ImageViewMinLodParams *minLodParams = DE_NULL); |
| |
| int getSize(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getWidth() : 0; |
| } |
| int getDepth(void) const |
| { |
| return m_numLevels > 0 ? m_levels[0].getDepth() : 0; |
| } |
| int getNumLayers(void) const |
| { |
| return getDepth() / 6; |
| } |
| int getNumLevels(void) const |
| { |
| return m_numLevels; |
| } |
| const ConstPixelBufferAccess &getLevel(int ndx) const |
| { |
| DE_ASSERT(de::inBounds(ndx, 0, m_numLevels)); |
| return m_levels[ndx]; |
| } |
| const ConstPixelBufferAccess *getLevels(void) const |
| { |
| return m_levels; |
| } |
| bool isES2(void) const |
| { |
| return false; |
| } |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float r, float q, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float r, float q, float lod, const IVec2 &offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float q, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float r, float q, float lod, |
| const IVec2 &offset) const; |
| |
| ImageViewMinLodParams *getImageViewMinLodParams(void) const |
| { |
| return DE_NULL; |
| } |
| |
| protected: |
| int selectLayer(float q) const; |
| |
| int m_numLevels; |
| const ConstPixelBufferAccess *m_levels; |
| } DE_WARN_UNUSED_TYPE; |
| |
| /*--------------------------------------------------------------------*//*! |
| * \brief Cube Map Array Texture reference implementation |
| *//*--------------------------------------------------------------------*/ |
| class TextureCubeArray : private TextureLevelPyramid |
| { |
| public: |
| TextureCubeArray(const TextureFormat &format, int size, int depth); |
| TextureCubeArray(const TextureCubeArray &other); |
| ~TextureCubeArray(void); |
| |
| int getSize(void) const |
| { |
| return m_size; |
| } |
| int getDepth(void) const |
| { |
| return m_depth; |
| } |
| |
| void allocLevel(int levelNdx); |
| |
| using TextureLevelPyramid::clearLevel; |
| using TextureLevelPyramid::getFormat; |
| using TextureLevelPyramid::getLevel; |
| using TextureLevelPyramid::getNumLevels; |
| using TextureLevelPyramid::isLevelEmpty; |
| |
| Vec4 sample(const Sampler &sampler, float s, float t, float r, float q, float lod) const; |
| Vec4 sampleOffset(const Sampler &sampler, float s, float t, float r, float q, float lod, const IVec2 &offset) const; |
| float sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float q, float lod) const; |
| float sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float r, float q, float lod, |
| const IVec2 &offset) const; |
| |
| TextureCubeArray &operator=(const TextureCubeArray &other); |
| |
| operator TextureCubeArrayView(void) const |
| { |
| return m_view; |
| } |
| |
| private: |
| int m_size; |
| int m_depth; |
| TextureCubeArrayView m_view; |
| } DE_WARN_UNUSED_TYPE; |
| |
| inline Vec4 TextureCubeArray::sample(const Sampler &sampler, float s, float t, float r, float q, float lod) const |
| { |
| return m_view.sample(sampler, s, t, r, q, lod); |
| } |
| |
| inline Vec4 TextureCubeArray::sampleOffset(const Sampler &sampler, float s, float t, float r, float q, float lod, |
| const IVec2 &offset) const |
| { |
| return m_view.sampleOffset(sampler, s, t, r, q, lod, offset); |
| } |
| |
| inline float TextureCubeArray::sampleCompare(const Sampler &sampler, float ref, float s, float t, float r, float q, |
| float lod) const |
| { |
| return m_view.sampleCompare(sampler, ref, s, t, r, q, lod); |
| } |
| |
| inline float TextureCubeArray::sampleCompareOffset(const Sampler &sampler, float ref, float s, float t, float r, |
| float q, float lod, const IVec2 &offset) const |
| { |
| return m_view.sampleCompareOffset(sampler, ref, s, t, r, q, lod, offset); |
| } |
| |
| // Stream operators. |
| std::ostream &operator<<(std::ostream &str, TextureFormat::ChannelOrder order); |
| std::ostream &operator<<(std::ostream &str, TextureFormat::ChannelType type); |
| std::ostream &operator<<(std::ostream &str, TextureFormat format); |
| std::ostream &operator<<(std::ostream &str, CubeFace face); |
| std::ostream &operator<<(std::ostream &str, const ConstPixelBufferAccess &access); |
| |
| } // namespace tcu |
| |
| #endif // _TCUTEXTURE_HPP |