| /*------------------------------------------------------------------------- |
| * 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 "tcuTexture.hpp" |
| #include "deInt32.h" |
| #include "deFloat16.h" |
| #include "deMath.h" |
| #include "deMemory.h" |
| #include "tcuTestLog.hpp" |
| #include "tcuSurface.hpp" |
| #include "tcuFloat.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "deStringUtil.hpp" |
| #include "deArrayUtil.hpp" |
| |
| #include <limits> |
| |
| namespace tcu |
| { |
| |
| // \note No sign. Denorms are supported. |
| typedef Float<deUint32, 5, 6, 15, FLOAT_SUPPORT_DENORM> Float11; |
| typedef Float<deUint32, 5, 5, 15, FLOAT_SUPPORT_DENORM> Float10; |
| |
| namespace |
| { |
| |
| // Optimized getters for common formats. |
| // \todo [2012-11-14 pyry] Use intrinsics if available. |
| |
| inline Vec4 readRGBA8888Float (const deUint8* ptr) { return Vec4(ptr[0]/255.0f, ptr[1]/255.0f, ptr[2]/255.0f, ptr[3]/255.0f); } |
| inline Vec4 readRGB888Float (const deUint8* ptr) { return Vec4(ptr[0]/255.0f, ptr[1]/255.0f, ptr[2]/255.0f, 1.0f); } |
| inline IVec4 readRGBA8888Int (const deUint8* ptr) { return IVec4(ptr[0], ptr[1], ptr[2], ptr[3]); } |
| inline IVec4 readRGB888Int (const deUint8* ptr) { return IVec4(ptr[0], ptr[1], ptr[2], 1); } |
| |
| // Optimized setters. |
| |
| inline void writeRGBA8888Int (deUint8* ptr, const IVec4& val) |
| { |
| ptr[0] = (deUint8)de::clamp(val[0], 0, 255); |
| ptr[1] = (deUint8)de::clamp(val[1], 0, 255); |
| ptr[2] = (deUint8)de::clamp(val[2], 0, 255); |
| ptr[3] = (deUint8)de::clamp(val[3], 0, 255); |
| } |
| |
| inline void writeRGB888Int (deUint8* ptr, const IVec4& val) |
| { |
| ptr[0] = (deUint8)de::clamp(val[0], 0, 255); |
| ptr[1] = (deUint8)de::clamp(val[1], 0, 255); |
| ptr[2] = (deUint8)de::clamp(val[2], 0, 255); |
| } |
| |
| inline void writeRGBA8888Float (deUint8* ptr, const Vec4& val) |
| { |
| ptr[0] = floatToU8(val[0]); |
| ptr[1] = floatToU8(val[1]); |
| ptr[2] = floatToU8(val[2]); |
| ptr[3] = floatToU8(val[3]); |
| } |
| |
| inline void writeRGB888Float (deUint8* ptr, const Vec4& val) |
| { |
| ptr[0] = floatToU8(val[0]); |
| ptr[1] = floatToU8(val[1]); |
| ptr[2] = floatToU8(val[2]); |
| } |
| |
| inline void writeUint24 (deUint8* dst, deUint32 val) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| dst[0] = (deUint8)((val & 0x0000FFu) >> 0u); |
| dst[1] = (deUint8)((val & 0x00FF00u) >> 8u); |
| dst[2] = (deUint8)((val & 0xFF0000u) >> 16u); |
| #else |
| dst[0] = (deUint8)((val & 0xFF0000u) >> 16u); |
| dst[1] = (deUint8)((val & 0x00FF00u) >> 8u); |
| dst[2] = (deUint8)((val & 0x0000FFu) >> 0u); |
| #endif |
| } |
| |
| inline deUint32 readUint24 (const deUint8* src) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| return (((deUint32)src[0]) << 0u) | |
| (((deUint32)src[1]) << 8u) | |
| (((deUint32)src[2]) << 16u); |
| #else |
| return (((deUint32)src[0]) << 16u) | |
| (((deUint32)src[1]) << 8u) | |
| (((deUint32)src[2]) << 0u); |
| #endif |
| } |
| |
| inline deUint8 readUint32Low8 (const deUint8* src) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffsetBits0To8 = 0; //!< least significant byte in the lowest address |
| #else |
| const deUint32 uint32ByteOffsetBits0To8 = 3; //!< least significant byte in the highest address |
| #endif |
| |
| return src[uint32ByteOffsetBits0To8]; |
| } |
| |
| inline deUint8 readUint32High8 (const deUint8* src) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffsetBits24To32 = 3; |
| #else |
| const deUint32 uint32ByteOffsetBits24To32 = 0; |
| #endif |
| |
| return src[uint32ByteOffsetBits24To32]; |
| } |
| |
| inline void writeUint32Low8 (deUint8* dst, deUint8 val) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffsetBits0To8 = 0; //!< least significant byte in the lowest address |
| #else |
| const deUint32 uint32ByteOffsetBits0To8 = 3; //!< least significant byte in the highest address |
| #endif |
| |
| dst[uint32ByteOffsetBits0To8] = val; |
| } |
| |
| inline void writeUint32High8 (deUint8* dst, deUint8 val) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffsetBits24To32 = 3; |
| #else |
| const deUint32 uint32ByteOffsetBits24To32 = 0; |
| #endif |
| |
| dst[uint32ByteOffsetBits24To32] = val; |
| } |
| |
| inline deUint32 readUint32High16 (const deUint8* src) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffset16To32 = 2; |
| #else |
| const deUint32 uint32ByteOffset16To32 = 0; |
| #endif |
| |
| return *(const deUint16*)(src + uint32ByteOffset16To32); |
| } |
| |
| inline void writeUint32High16 (deUint8* dst, deUint16 val) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffset16To32 = 2; |
| #else |
| const deUint32 uint32ByteOffset16To32 = 0; |
| #endif |
| |
| *(deUint16*)(dst + uint32ByteOffset16To32) = val; |
| } |
| |
| inline deUint32 readUint32Low24 (const deUint8* src) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffset0To24 = 0; |
| #else |
| const deUint32 uint32ByteOffset0To24 = 1; |
| #endif |
| |
| return readUint24(src + uint32ByteOffset0To24); |
| } |
| |
| inline deUint32 readUint32High24 (const deUint8* src) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffset8To32 = 1; |
| #else |
| const deUint32 uint32ByteOffset8To32 = 0; |
| #endif |
| |
| return readUint24(src + uint32ByteOffset8To32); |
| } |
| |
| inline void writeUint32Low24 (deUint8* dst, deUint32 val) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffset0To24 = 0; |
| #else |
| const deUint32 uint32ByteOffset0To24 = 1; |
| #endif |
| |
| writeUint24(dst + uint32ByteOffset0To24, val); |
| } |
| |
| inline void writeUint32High24 (deUint8* dst, deUint32 val) |
| { |
| #if (DE_ENDIANNESS == DE_LITTLE_ENDIAN) |
| const deUint32 uint32ByteOffset8To32 = 1; |
| #else |
| const deUint32 uint32ByteOffset8To32 = 0; |
| #endif |
| |
| writeUint24(dst + uint32ByteOffset8To32, val); |
| } |
| |
| // \todo [2011-09-21 pyry] Move to tcutil? |
| template <typename T> |
| inline T convertSatRte (float f) |
| { |
| // \note Doesn't work for 64-bit types |
| DE_STATIC_ASSERT(sizeof(T) < sizeof(deUint64)); |
| DE_STATIC_ASSERT((-3 % 2 != 0) && (-4 % 2 == 0)); |
| |
| deInt64 minVal = std::numeric_limits<T>::min(); |
| deInt64 maxVal = std::numeric_limits<T>::max(); |
| float q = deFloatFrac(f); |
| deInt64 intVal = (deInt64)(f-q); |
| |
| // Rounding. |
| if (q == 0.5f) |
| { |
| if (intVal % 2 != 0) |
| intVal++; |
| } |
| else if (q > 0.5f) |
| intVal++; |
| // else Don't add anything |
| |
| // Saturate. |
| intVal = de::max(minVal, de::min(maxVal, intVal)); |
| |
| return (T)intVal; |
| } |
| |
| inline deUint32 convertSatRteUint24 (float f) |
| { |
| const deUint32 rounded = convertSatRte<deUint32>(f); |
| const deUint32 maxUint24 = 0xFFFFFFu; |
| return de::min(rounded, maxUint24); |
| } |
| |
| int getChannelSize (TextureFormat::ChannelType type) |
| { |
| // make sure this table is updated if format table is updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); |
| |
| switch (type) |
| { |
| case TextureFormat::SNORM_INT8: return 1; |
| case TextureFormat::SNORM_INT16: return 2; |
| case TextureFormat::SNORM_INT32: return 4; |
| case TextureFormat::UNORM_INT8: return 1; |
| case TextureFormat::UNORM_INT16: return 2; |
| case TextureFormat::UNORM_INT24: return 3; |
| case TextureFormat::UNORM_INT32: return 4; |
| case TextureFormat::SIGNED_INT8: return 1; |
| case TextureFormat::SIGNED_INT16: return 2; |
| case TextureFormat::SIGNED_INT32: return 4; |
| case TextureFormat::UNSIGNED_INT8: return 1; |
| case TextureFormat::UNSIGNED_INT16: return 2; |
| case TextureFormat::UNSIGNED_INT24: return 3; |
| case TextureFormat::UNSIGNED_INT32: return 4; |
| case TextureFormat::HALF_FLOAT: return 2; |
| case TextureFormat::FLOAT: return 4; |
| case TextureFormat::FLOAT64: return 8; |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0; |
| } |
| } |
| |
| int getNumUsedChannels (TextureFormat::ChannelOrder order) |
| { |
| // make sure this table is updated if type table is updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); |
| |
| switch (order) |
| { |
| case TextureFormat::R: return 1; |
| case TextureFormat::A: return 1; |
| case TextureFormat::I: return 1; |
| case TextureFormat::L: return 1; |
| case TextureFormat::LA: return 2; |
| case TextureFormat::RG: return 2; |
| case TextureFormat::RA: return 2; |
| case TextureFormat::RGB: return 3; |
| case TextureFormat::RGBA: return 4; |
| case TextureFormat::ARGB: return 4; |
| case TextureFormat::BGR: return 3; |
| case TextureFormat::BGRA: return 4; |
| case TextureFormat::sR: return 1; |
| case TextureFormat::sRG: return 2; |
| case TextureFormat::sRGB: return 3; |
| case TextureFormat::sRGBA: return 4; |
| case TextureFormat::sBGR: return 3; |
| case TextureFormat::sBGRA: return 4; |
| case TextureFormat::D: return 1; |
| case TextureFormat::S: return 1; |
| case TextureFormat::DS: return 2; |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0; |
| } |
| } |
| |
| inline float channelToFloat (const deUint8* value, TextureFormat::ChannelType type) |
| { |
| // make sure this table is updated if format table is updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); |
| |
| switch (type) |
| { |
| case TextureFormat::SNORM_INT8: return de::max(-1.0f, (float)*((const deInt8*)value) / 127.0f); |
| case TextureFormat::SNORM_INT16: return de::max(-1.0f, (float)*((const deInt16*)value) / 32767.0f); |
| case TextureFormat::SNORM_INT32: return de::max(-1.0f, (float)*((const deInt32*)value) / 2147483647.0f); |
| case TextureFormat::UNORM_INT8: return (float)*((const deUint8*)value) / 255.0f; |
| case TextureFormat::UNORM_INT16: return (float)*((const deUint16*)value) / 65535.0f; |
| case TextureFormat::UNORM_INT24: return (float)readUint24(value) / 16777215.0f; |
| case TextureFormat::UNORM_INT32: return (float)*((const deUint32*)value) / 4294967295.0f; |
| case TextureFormat::SIGNED_INT8: return (float)*((const deInt8*)value); |
| case TextureFormat::SIGNED_INT16: return (float)*((const deInt16*)value); |
| case TextureFormat::SIGNED_INT32: return (float)*((const deInt32*)value); |
| case TextureFormat::UNSIGNED_INT8: return (float)*((const deUint8*)value); |
| case TextureFormat::UNSIGNED_INT16: return (float)*((const deUint16*)value); |
| case TextureFormat::UNSIGNED_INT24: return (float)readUint24(value); |
| case TextureFormat::UNSIGNED_INT32: return (float)*((const deUint32*)value); |
| case TextureFormat::HALF_FLOAT: return deFloat16To32(*(const deFloat16*)value); |
| case TextureFormat::FLOAT: return *((const float*)value); |
| case TextureFormat::FLOAT64: return (float)*((const double*)value); |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| inline int channelToInt (const deUint8* value, TextureFormat::ChannelType type) |
| { |
| // make sure this table is updated if format table is updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); |
| |
| switch (type) |
| { |
| case TextureFormat::SNORM_INT8: return (int)*((const deInt8*)value); |
| case TextureFormat::SNORM_INT16: return (int)*((const deInt16*)value); |
| case TextureFormat::SNORM_INT32: return (int)*((const deInt32*)value); |
| case TextureFormat::UNORM_INT8: return (int)*((const deUint8*)value); |
| case TextureFormat::UNORM_INT16: return (int)*((const deUint16*)value); |
| case TextureFormat::UNORM_INT24: return (int)readUint24(value); |
| case TextureFormat::UNORM_INT32: return (int)*((const deUint32*)value); |
| case TextureFormat::SIGNED_INT8: return (int)*((const deInt8*)value); |
| case TextureFormat::SIGNED_INT16: return (int)*((const deInt16*)value); |
| case TextureFormat::SIGNED_INT32: return (int)*((const deInt32*)value); |
| case TextureFormat::UNSIGNED_INT8: return (int)*((const deUint8*)value); |
| case TextureFormat::UNSIGNED_INT16: return (int)*((const deUint16*)value); |
| case TextureFormat::UNSIGNED_INT24: return (int)readUint24(value); |
| case TextureFormat::UNSIGNED_INT32: return (int)*((const deUint32*)value); |
| case TextureFormat::HALF_FLOAT: return (int)deFloat16To32(*(const deFloat16*)value); |
| case TextureFormat::FLOAT: return (int)*((const float*)value); |
| case TextureFormat::FLOAT64: return (int)*((const double*)value); |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0; |
| } |
| } |
| |
| void floatToChannel (deUint8* dst, float src, TextureFormat::ChannelType type) |
| { |
| // make sure this table is updated if format table is updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); |
| |
| switch (type) |
| { |
| case TextureFormat::SNORM_INT8: *((deInt8*)dst) = convertSatRte<deInt8> (src * 127.0f); break; |
| case TextureFormat::SNORM_INT16: *((deInt16*)dst) = convertSatRte<deInt16> (src * 32767.0f); break; |
| case TextureFormat::SNORM_INT32: *((deInt32*)dst) = convertSatRte<deInt32> (src * 2147483647.0f); break; |
| case TextureFormat::UNORM_INT8: *((deUint8*)dst) = convertSatRte<deUint8> (src * 255.0f); break; |
| case TextureFormat::UNORM_INT16: *((deUint16*)dst) = convertSatRte<deUint16> (src * 65535.0f); break; |
| case TextureFormat::UNORM_INT24: writeUint24(dst, convertSatRteUint24 (src * 16777215.0f)); break; |
| case TextureFormat::UNORM_INT32: *((deUint32*)dst) = convertSatRte<deUint32> (src * 4294967295.0f); break; |
| case TextureFormat::SIGNED_INT8: *((deInt8*)dst) = convertSatRte<deInt8> (src); break; |
| case TextureFormat::SIGNED_INT16: *((deInt16*)dst) = convertSatRte<deInt16> (src); break; |
| case TextureFormat::SIGNED_INT32: *((deInt32*)dst) = convertSatRte<deInt32> (src); break; |
| case TextureFormat::UNSIGNED_INT8: *((deUint8*)dst) = convertSatRte<deUint8> (src); break; |
| case TextureFormat::UNSIGNED_INT16: *((deUint16*)dst) = convertSatRte<deUint16> (src); break; |
| case TextureFormat::UNSIGNED_INT24: writeUint24(dst, convertSatRteUint24 (src)); break; |
| case TextureFormat::UNSIGNED_INT32: *((deUint32*)dst) = convertSatRte<deUint32> (src); break; |
| case TextureFormat::HALF_FLOAT: *((deFloat16*)dst) = deFloat32To16 (src); break; |
| case TextureFormat::FLOAT: *((float*)dst) = src; break; |
| case TextureFormat::FLOAT64: *((double*)dst) = (double)src; break; |
| default: |
| DE_ASSERT(DE_FALSE); |
| } |
| } |
| |
| template <typename T, typename S> |
| static inline T convertSat (S src) |
| { |
| S min = (S)std::numeric_limits<T>::min(); |
| S max = (S)std::numeric_limits<T>::max(); |
| |
| if (src < min) |
| return (T)min; |
| else if (src > max) |
| return (T)max; |
| else |
| return (T)src; |
| } |
| |
| template <typename S> |
| static inline deUint32 convertSatUint24 (S src) |
| { |
| S min = (S)0u; |
| S max = (S)0xFFFFFFu; |
| |
| if (src < min) |
| return (deUint32)min; |
| else if (src > max) |
| return (deUint32)max; |
| else |
| return (deUint32)src; |
| } |
| |
| void intToChannel (deUint8* dst, int src, TextureFormat::ChannelType type) |
| { |
| // make sure this table is updated if format table is updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); |
| |
| switch (type) |
| { |
| case TextureFormat::SNORM_INT8: *((deInt8*)dst) = convertSat<deInt8> (src); break; |
| case TextureFormat::SNORM_INT16: *((deInt16*)dst) = convertSat<deInt16> (src); break; |
| case TextureFormat::UNORM_INT8: *((deUint8*)dst) = convertSat<deUint8> (src); break; |
| case TextureFormat::UNORM_INT16: *((deUint16*)dst) = convertSat<deUint16> (src); break; |
| case TextureFormat::UNORM_INT24: writeUint24(dst, convertSatUint24 (src)); break; |
| case TextureFormat::SIGNED_INT8: *((deInt8*)dst) = convertSat<deInt8> (src); break; |
| case TextureFormat::SIGNED_INT16: *((deInt16*)dst) = convertSat<deInt16> (src); break; |
| case TextureFormat::SIGNED_INT32: *((deInt32*)dst) = convertSat<deInt32> (src); break; |
| case TextureFormat::UNSIGNED_INT8: *((deUint8*)dst) = convertSat<deUint8> ((deUint32)src); break; |
| case TextureFormat::UNSIGNED_INT16: *((deUint16*)dst) = convertSat<deUint16> ((deUint32)src); break; |
| case TextureFormat::UNSIGNED_INT24: writeUint24(dst, convertSatUint24 ((deUint32)src)); break; |
| case TextureFormat::UNSIGNED_INT32: *((deUint32*)dst) = convertSat<deUint32> ((deUint32)src); break; |
| case TextureFormat::HALF_FLOAT: *((deFloat16*)dst) = deFloat32To16((float)src); break; |
| case TextureFormat::FLOAT: *((float*)dst) = (float)src; break; |
| case TextureFormat::FLOAT64: *((double*)dst) = (double)src; break; |
| default: |
| DE_ASSERT(DE_FALSE); |
| } |
| } |
| |
| inline float channelToUnormFloat (deUint32 src, int bits) |
| { |
| const deUint32 maxVal = (1u << bits) - 1; |
| |
| // \note Will lose precision if bits > 23 |
| return (float)src / (float)maxVal; |
| } |
| |
| //! Extend < 32b signed integer to 32b |
| inline deInt32 signExtend (deUint32 src, int bits) |
| { |
| const deUint32 signBit = 1u << (bits-1); |
| |
| src |= ~((src & signBit) - 1); |
| |
| return (deInt32)src; |
| } |
| |
| inline float channelToSnormFloat (deUint32 src, int bits) |
| { |
| const deUint32 range = (1u << (bits-1)) - 1; |
| |
| // \note Will lose precision if bits > 24 |
| return de::max(-1.0f, (float)signExtend(src, bits) / (float)range); |
| } |
| |
| inline deUint32 unormFloatToChannel (float src, int bits) |
| { |
| const deUint32 maxVal = (1u << bits) - 1; |
| const deUint32 intVal = convertSatRte<deUint32>(src * (float)maxVal); |
| |
| return de::min(intVal, maxVal); |
| } |
| |
| inline deUint32 snormFloatToChannel (float src, int bits) |
| { |
| const deInt32 range = (deInt32)((1u << (bits-1)) - 1u); |
| const deUint32 mask = (1u << bits) - 1; |
| const deInt32 intVal = convertSatRte<deInt32>(src * (float)range); |
| |
| return (deUint32)de::clamp(intVal, -range, range) & mask; |
| } |
| |
| inline deUint32 uintToChannel (deUint32 src, int bits) |
| { |
| const deUint32 maxVal = (1u << bits) - 1; |
| return de::min(src, maxVal); |
| } |
| |
| inline deUint32 intToChannel (deInt32 src, int bits) |
| { |
| const deInt32 minVal = -(deInt32)(1u << (bits-1)); |
| const deInt32 maxVal = (deInt32)((1u << (bits-1)) - 1u); |
| const deUint32 mask = (1u << bits) - 1; |
| |
| return (deUint32)de::clamp(src, minVal, maxVal) & mask; |
| } |
| |
| tcu::Vec4 unpackRGB999E5 (deUint32 color) |
| { |
| const int mBits = 9; |
| const int eBias = 15; |
| |
| deUint32 exp = color >> 27; |
| deUint32 bs = (color >> 18) & ((1<<9)-1); |
| deUint32 gs = (color >> 9) & ((1<<9)-1); |
| deUint32 rs = color & ((1<<9)-1); |
| |
| float e = deFloatPow(2.0f, (float)((int)exp - eBias - mBits)); |
| float r = (float)rs * e; |
| float g = (float)gs * e; |
| float b = (float)bs * e; |
| |
| return tcu::Vec4(r, g, b, 1.0f); |
| } |
| |
| bool isColorOrder (TextureFormat::ChannelOrder order) |
| { |
| DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); |
| |
| switch (order) |
| { |
| case TextureFormat::R: |
| case TextureFormat::A: |
| case TextureFormat::I: |
| case TextureFormat::L: |
| case TextureFormat::LA: |
| case TextureFormat::RG: |
| case TextureFormat::RA: |
| case TextureFormat::RGB: |
| case TextureFormat::RGBA: |
| case TextureFormat::ARGB: |
| case TextureFormat::BGR: |
| case TextureFormat::BGRA: |
| case TextureFormat::sR: |
| case TextureFormat::sRG: |
| case TextureFormat::sRGB: |
| case TextureFormat::sRGBA: |
| case TextureFormat::sBGR: |
| case TextureFormat::sBGRA: |
| return true; |
| |
| default: |
| return false; |
| } |
| } |
| |
| } // anonymous |
| |
| bool isValid (TextureFormat format) |
| { |
| const bool isColor = isColorOrder(format.order); |
| |
| switch (format.type) |
| { |
| case TextureFormat::SNORM_INT8: |
| case TextureFormat::SNORM_INT16: |
| case TextureFormat::SNORM_INT32: |
| return isColor; |
| |
| case TextureFormat::UNORM_INT8: |
| case TextureFormat::UNORM_INT16: |
| case TextureFormat::UNORM_INT24: |
| case TextureFormat::UNORM_INT32: |
| return isColor || format.order == TextureFormat::D; |
| |
| case TextureFormat::UNORM_BYTE_44: |
| case TextureFormat::UNSIGNED_BYTE_44: |
| return format.order == TextureFormat::RG; |
| |
| case TextureFormat::UNORM_SHORT_565: |
| case TextureFormat::UNORM_SHORT_555: |
| case TextureFormat::UNSIGNED_SHORT_565: |
| return format.order == TextureFormat::RGB || format.order == TextureFormat::BGR; |
| |
| case TextureFormat::UNORM_SHORT_4444: |
| case TextureFormat::UNORM_SHORT_5551: |
| case TextureFormat::UNSIGNED_SHORT_4444: |
| case TextureFormat::UNSIGNED_SHORT_5551: |
| return format.order == TextureFormat::RGBA || format.order == TextureFormat::BGRA; |
| |
| case TextureFormat::UNORM_SHORT_1555: |
| return format.order == TextureFormat::ARGB; |
| |
| case TextureFormat::UNORM_INT_101010: |
| return format.order == TextureFormat::RGB; |
| |
| case TextureFormat::SNORM_INT_1010102_REV: |
| case TextureFormat::UNORM_INT_1010102_REV: |
| case TextureFormat::SIGNED_INT_1010102_REV: |
| case TextureFormat::UNSIGNED_INT_1010102_REV: |
| return format.order == TextureFormat::RGBA || format.order == TextureFormat::BGRA; |
| |
| case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: |
| case TextureFormat::UNSIGNED_INT_999_E5_REV: |
| return format.order == TextureFormat::RGB; |
| |
| case TextureFormat::UNSIGNED_INT_16_8_8: |
| return format.order == TextureFormat::DS; |
| |
| case TextureFormat::UNSIGNED_INT_24_8: |
| case TextureFormat::UNSIGNED_INT_24_8_REV: |
| return format.order == TextureFormat::D || format.order == TextureFormat::DS; |
| |
| case TextureFormat::SIGNED_INT8: |
| case TextureFormat::SIGNED_INT16: |
| case TextureFormat::SIGNED_INT32: |
| return isColor; |
| |
| case TextureFormat::UNSIGNED_INT8: |
| case TextureFormat::UNSIGNED_INT16: |
| case TextureFormat::UNSIGNED_INT24: |
| case TextureFormat::UNSIGNED_INT32: |
| return isColor || format.order == TextureFormat::S; |
| |
| case TextureFormat::HALF_FLOAT: |
| case TextureFormat::FLOAT: |
| case TextureFormat::FLOAT64: |
| return isColor || format.order == TextureFormat::D; |
| |
| case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: |
| return format.order == TextureFormat::DS; |
| |
| default: |
| DE_FATAL("Unknown format"); |
| return 0u; |
| } |
| |
| DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); |
| } |
| |
| /** Get pixel size in bytes. */ |
| int getPixelSize (TextureFormat format) |
| { |
| const TextureFormat::ChannelOrder order = format.order; |
| const TextureFormat::ChannelType type = format.type; |
| |
| DE_ASSERT(isValid(format)); |
| |
| // make sure this table is updated if format table is updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 38); |
| |
| switch (type) |
| { |
| case TextureFormat::UNORM_BYTE_44: |
| case TextureFormat::UNSIGNED_BYTE_44: |
| return 1; |
| |
| case TextureFormat::UNORM_SHORT_565: |
| case TextureFormat::UNORM_SHORT_555: |
| case TextureFormat::UNORM_SHORT_4444: |
| case TextureFormat::UNORM_SHORT_5551: |
| case TextureFormat::UNORM_SHORT_1555: |
| case TextureFormat::UNSIGNED_SHORT_565: |
| case TextureFormat::UNSIGNED_SHORT_4444: |
| case TextureFormat::UNSIGNED_SHORT_5551: |
| return 2; |
| |
| case TextureFormat::UNORM_INT_101010: |
| case TextureFormat::UNSIGNED_INT_999_E5_REV: |
| case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: |
| case TextureFormat::SNORM_INT_1010102_REV: |
| case TextureFormat::UNORM_INT_1010102_REV: |
| case TextureFormat::SIGNED_INT_1010102_REV: |
| case TextureFormat::UNSIGNED_INT_1010102_REV: |
| case TextureFormat::UNSIGNED_INT_24_8: |
| case TextureFormat::UNSIGNED_INT_24_8_REV: |
| case TextureFormat::UNSIGNED_INT_16_8_8: |
| return 4; |
| |
| case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: |
| return 8; |
| |
| default: |
| return getNumUsedChannels(order) * getChannelSize(type); |
| } |
| } |
| |
| int TextureFormat::getPixelSize (void) const |
| { |
| return ::tcu::getPixelSize(*this); |
| } |
| |
| const TextureSwizzle& getChannelReadSwizzle (TextureFormat::ChannelOrder order) |
| { |
| // make sure to update these tables when channel orders are updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); |
| |
| static const TextureSwizzle INV = {{ TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; |
| static const TextureSwizzle R = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; |
| static const TextureSwizzle A = {{ TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_0 }}; |
| static const TextureSwizzle I = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0 }}; |
| static const TextureSwizzle L = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ONE }}; |
| static const TextureSwizzle LA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1 }}; |
| static const TextureSwizzle RG = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; |
| static const TextureSwizzle RA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_1 }}; |
| static const TextureSwizzle RGB = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_ONE }}; |
| static const TextureSwizzle RGBA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3 }}; |
| static const TextureSwizzle BGR = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ONE }}; |
| static const TextureSwizzle BGRA = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3 }}; |
| static const TextureSwizzle ARGB = {{ TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_0 }}; |
| static const TextureSwizzle D = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; |
| static const TextureSwizzle S = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE }}; |
| |
| switch (order) |
| { |
| case TextureFormat::R: return R; |
| case TextureFormat::A: return A; |
| case TextureFormat::I: return I; |
| case TextureFormat::L: return L; |
| case TextureFormat::LA: return LA; |
| case TextureFormat::RG: return RG; |
| case TextureFormat::RA: return RA; |
| case TextureFormat::RGB: return RGB; |
| case TextureFormat::RGBA: return RGBA; |
| case TextureFormat::ARGB: return ARGB; |
| case TextureFormat::BGR: return BGR; |
| case TextureFormat::BGRA: return BGRA; |
| case TextureFormat::sR: return R; |
| case TextureFormat::sRG: return RG; |
| case TextureFormat::sRGB: return RGB; |
| case TextureFormat::sRGBA: return RGBA; |
| case TextureFormat::sBGR: return BGR; |
| case TextureFormat::sBGRA: return BGRA; |
| case TextureFormat::D: return D; |
| case TextureFormat::S: return S; |
| |
| case TextureFormat::DS: |
| DE_ASSERT(false); // combined formats cannot be read from |
| return INV; |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return INV; |
| } |
| } |
| |
| const TextureSwizzle& getChannelWriteSwizzle (TextureFormat::ChannelOrder order) |
| { |
| // make sure to update these tables when channel orders are updated |
| DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 21); |
| |
| static const TextureSwizzle INV = {{ TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle R = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle A = {{ TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle I = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle L = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle LA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle RG = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle RA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle RGB = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle RGBA = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3 }}; |
| static const TextureSwizzle BGR = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle BGRA = {{ TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3 }}; |
| static const TextureSwizzle ARGB = {{ TextureSwizzle::CHANNEL_3, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2 }}; |
| static const TextureSwizzle D = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| static const TextureSwizzle S = {{ TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST, TextureSwizzle::CHANNEL_LAST }}; |
| |
| switch (order) |
| { |
| case TextureFormat::R: return R; |
| case TextureFormat::A: return A; |
| case TextureFormat::I: return I; |
| case TextureFormat::L: return L; |
| case TextureFormat::LA: return LA; |
| case TextureFormat::RG: return RG; |
| case TextureFormat::RA: return RA; |
| case TextureFormat::RGB: return RGB; |
| case TextureFormat::RGBA: return RGBA; |
| case TextureFormat::ARGB: return ARGB; |
| case TextureFormat::BGR: return BGR; |
| case TextureFormat::BGRA: return BGRA; |
| case TextureFormat::sR: return R; |
| case TextureFormat::sRG: return RG; |
| case TextureFormat::sRGB: return RGB; |
| case TextureFormat::sRGBA: return RGBA; |
| case TextureFormat::sBGR: return BGR; |
| case TextureFormat::sBGRA: return BGRA; |
| case TextureFormat::D: return D; |
| case TextureFormat::S: return S; |
| |
| case TextureFormat::DS: |
| DE_ASSERT(false); // combined formats cannot be written to |
| return INV; |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return INV; |
| } |
| } |
| |
| IVec3 calculatePackedPitch (const TextureFormat& format, const IVec3& size) |
| { |
| const int pixelSize = format.getPixelSize(); |
| const int rowPitch = pixelSize * size.x(); |
| const int slicePitch = rowPitch * size.y(); |
| |
| return IVec3(pixelSize, rowPitch, slicePitch); |
| } |
| |
| ConstPixelBufferAccess::ConstPixelBufferAccess (void) |
| : m_size (0) |
| , m_pitch (0) |
| , m_data (DE_NULL) |
| { |
| } |
| |
| ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, int width, int height, int depth, const void* data) |
| : m_format (format) |
| , m_size (width, height, depth) |
| , m_pitch (calculatePackedPitch(m_format, m_size)) |
| , m_data ((void*)data) |
| { |
| DE_ASSERT(isValid(format)); |
| } |
| |
| ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, const IVec3& size, const void* data) |
| : m_format (format) |
| , m_size (size) |
| , m_pitch (calculatePackedPitch(m_format, m_size)) |
| , m_data ((void*)data) |
| { |
| DE_ASSERT(isValid(format)); |
| } |
| |
| ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, int width, int height, int depth, int rowPitch, int slicePitch, const void* data) |
| : m_format (format) |
| , m_size (width, height, depth) |
| , m_pitch (format.getPixelSize(), rowPitch, slicePitch) |
| , m_data ((void*)data) |
| { |
| DE_ASSERT(isValid(format)); |
| } |
| |
| ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureFormat& format, const IVec3& size, const IVec3& pitch, const void* data) |
| : m_format (format) |
| , m_size (size) |
| , m_pitch (pitch) |
| , m_data ((void*)data) |
| { |
| DE_ASSERT(isValid(format)); |
| DE_ASSERT(m_format.getPixelSize() <= m_pitch.x()); |
| } |
| |
| ConstPixelBufferAccess::ConstPixelBufferAccess (const TextureLevel& level) |
| : m_format (level.getFormat()) |
| , m_size (level.getSize()) |
| , m_pitch (calculatePackedPitch(m_format, m_size)) |
| , m_data ((void*)level.getPtr()) |
| { |
| } |
| |
| PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, int width, int height, int depth, void* data) |
| : ConstPixelBufferAccess(format, width, height, depth, data) |
| { |
| } |
| |
| PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, const IVec3& size, void* data) |
| : ConstPixelBufferAccess(format, size, data) |
| { |
| } |
| |
| PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, int width, int height, int depth, int rowPitch, int slicePitch, void* data) |
| : ConstPixelBufferAccess(format, width, height, depth, rowPitch, slicePitch, data) |
| { |
| } |
| |
| PixelBufferAccess::PixelBufferAccess (const TextureFormat& format, const IVec3& size, const IVec3& pitch, void* data) |
| : ConstPixelBufferAccess(format, size, pitch, data) |
| { |
| } |
| |
| PixelBufferAccess::PixelBufferAccess (TextureLevel& level) |
| : ConstPixelBufferAccess(level) |
| { |
| } |
| |
| //! Swizzle RGB(A) <-> BGR(A) |
| template<typename T> |
| Vector<T, 4> swizzleRB (const Vector<T, 4>& v, TextureFormat::ChannelOrder src, TextureFormat::ChannelOrder dst) |
| { |
| if (src == dst) |
| return v; |
| else |
| { |
| DE_ASSERT((src == TextureFormat::RGB && dst == TextureFormat::BGR) || |
| (src == TextureFormat::BGR && dst == TextureFormat::RGB) || |
| (src == TextureFormat::RGBA && dst == TextureFormat::BGRA) || |
| (src == TextureFormat::BGRA && dst == TextureFormat::RGBA)); |
| return v.swizzle(2,1,0,3); |
| } |
| } |
| |
| Vec4 ConstPixelBufferAccess::getPixel (int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, m_size.x())); |
| DE_ASSERT(de::inBounds(y, 0, m_size.y())); |
| DE_ASSERT(de::inBounds(z, 0, m_size.z())); |
| DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly |
| DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly |
| |
| const deUint8* pixelPtr = (const deUint8*)getPixelPtr(x, y, z); |
| |
| // Optimized fomats. |
| if (m_format.type == TextureFormat::UNORM_INT8) |
| { |
| if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) |
| return readRGBA8888Float(pixelPtr); |
| else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) |
| return readRGB888Float(pixelPtr); |
| } |
| |
| #define UI8(OFFS, COUNT) ((*((const deUint8*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) |
| #define UI16(OFFS, COUNT) ((*((const deUint16*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) |
| #define UI32(OFFS, COUNT) ((*((const deUint32*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) |
| #define SI32(OFFS, COUNT) signExtend(UI32(OFFS, COUNT), (COUNT)) |
| #define UN8(OFFS, COUNT) channelToUnormFloat(UI8 (OFFS, COUNT), (COUNT)) |
| #define UN16(OFFS, COUNT) channelToUnormFloat(UI16(OFFS, COUNT), (COUNT)) |
| #define UN32(OFFS, COUNT) channelToUnormFloat(UI32(OFFS, COUNT), (COUNT)) |
| #define SN32(OFFS, COUNT) channelToSnormFloat(UI32(OFFS, COUNT), (COUNT)) |
| |
| // Packed formats. |
| switch (m_format.type) |
| { |
| case TextureFormat::UNORM_BYTE_44: return Vec4(UN8 (4, 4), UN8 ( 0, 4), 0.0f, 1.0f); |
| case TextureFormat::UNSIGNED_BYTE_44: return UVec4(UI8 (4, 4), UI8 ( 0, 4), 0u, 1u).cast<float>(); |
| case TextureFormat::UNORM_SHORT_565: return swizzleRB( Vec4(UN16(11, 5), UN16( 5, 6), UN16( 0, 5), 1.0f), m_format.order, TextureFormat::RGB); |
| case TextureFormat::UNSIGNED_SHORT_565: return swizzleRB(UVec4(UI16(11, 5), UI16( 5, 6), UI16( 0, 5), 1u), m_format.order, TextureFormat::RGB).cast<float>(); |
| case TextureFormat::UNORM_SHORT_555: return swizzleRB( Vec4(UN16(10, 5), UN16( 5, 5), UN16( 0, 5), 1.0f), m_format.order, TextureFormat::RGB); |
| case TextureFormat::UNORM_SHORT_4444: return swizzleRB( Vec4(UN16(12, 4), UN16( 8, 4), UN16( 4, 4), UN16( 0, 4)), m_format.order, TextureFormat::RGBA); |
| case TextureFormat::UNSIGNED_SHORT_4444: return swizzleRB(UVec4(UI16(12, 4), UI16( 8, 4), UI16( 4, 4), UI16( 0, 4)), m_format.order, TextureFormat::RGBA).cast<float>(); |
| case TextureFormat::UNORM_SHORT_5551: return swizzleRB( Vec4(UN16(11, 5), UN16( 6, 5), UN16( 1, 5), UN16( 0, 1)), m_format.order, TextureFormat::RGBA); |
| case TextureFormat::UNSIGNED_SHORT_5551: return swizzleRB(UVec4(UI16(11, 5), UI16( 6, 5), UI16( 1, 5), UI16( 0, 1)), m_format.order, TextureFormat::RGBA).cast<float>(); |
| case TextureFormat::UNORM_INT_101010: return Vec4(UN32(22, 10), UN32(12, 10), UN32( 2, 10), 1.0f); |
| case TextureFormat::UNORM_INT_1010102_REV: return swizzleRB( Vec4(UN32( 0, 10), UN32(10, 10), UN32(20, 10), UN32(30, 2)), m_format.order, TextureFormat::RGBA); |
| case TextureFormat::SNORM_INT_1010102_REV: return swizzleRB( Vec4(SN32( 0, 10), SN32(10, 10), SN32(20, 10), SN32(30, 2)), m_format.order, TextureFormat::RGBA); |
| case TextureFormat::UNSIGNED_INT_1010102_REV: return swizzleRB( UVec4(UI32(0, 10), UI32(10, 10), UI32(20, 10), UI32(30, 2)), m_format.order, TextureFormat::RGBA).cast<float>(); |
| case TextureFormat::SIGNED_INT_1010102_REV: return swizzleRB( UVec4(SI32(0, 10), SI32(10, 10), SI32(20, 10), SI32(30, 2)), m_format.order, TextureFormat::RGBA).cast<float>(); |
| case TextureFormat::UNSIGNED_INT_999_E5_REV: return unpackRGB999E5(*((const deUint32*)pixelPtr)); |
| |
| case TextureFormat::UNORM_SHORT_1555: |
| DE_ASSERT(m_format.order == TextureFormat::ARGB); |
| return Vec4(UN16(15, 1), UN16(10, 5), UN16(5, 5), UN16(0, 5)).swizzle(1,2,3,0); // ARGB -> RGBA |
| |
| case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: |
| return Vec4(Float11(UI32(0, 11)).asFloat(), Float11(UI32(11, 11)).asFloat(), Float10(UI32(22, 10)).asFloat(), 1.0f); |
| |
| default: |
| break; |
| } |
| |
| #undef UN8 |
| #undef UN16 |
| #undef UN32 |
| #undef SN32 |
| #undef SI32 |
| #undef UI8 |
| #undef UI16 |
| #undef UI32 |
| |
| // Generic path. |
| Vec4 result; |
| const TextureSwizzle::Channel* channelMap = getChannelReadSwizzle(m_format.order).components; |
| int channelSize = getChannelSize(m_format.type); |
| |
| for (int c = 0; c < 4; c++) |
| { |
| switch (channelMap[c]) |
| { |
| case TextureSwizzle::CHANNEL_0: |
| case TextureSwizzle::CHANNEL_1: |
| case TextureSwizzle::CHANNEL_2: |
| case TextureSwizzle::CHANNEL_3: |
| result[c] = channelToFloat(pixelPtr + channelSize*((int)channelMap[c]), m_format.type); |
| break; |
| |
| case TextureSwizzle::CHANNEL_ZERO: |
| result[c] = 0.0f; |
| break; |
| |
| case TextureSwizzle::CHANNEL_ONE: |
| result[c] = 1.0f; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| return result; |
| } |
| |
| IVec4 ConstPixelBufferAccess::getPixelInt (int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, m_size.x())); |
| DE_ASSERT(de::inBounds(y, 0, m_size.y())); |
| DE_ASSERT(de::inBounds(z, 0, m_size.z())); |
| DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly |
| DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly |
| |
| const deUint8* const pixelPtr = (const deUint8*)getPixelPtr(x, y, z); |
| IVec4 result; |
| |
| // Optimized fomats. |
| if (m_format.type == TextureFormat::UNORM_INT8) |
| { |
| if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) |
| return readRGBA8888Int(pixelPtr); |
| else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) |
| return readRGB888Int(pixelPtr); |
| } |
| |
| #define U8(OFFS, COUNT) ((*((const deUint8* )pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) |
| #define U16(OFFS, COUNT) ((*((const deUint16*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) |
| #define U32(OFFS, COUNT) ((*((const deUint32*)pixelPtr) >> (OFFS)) & ((1<<(COUNT))-1)) |
| #define S32(OFFS, COUNT) signExtend(U32(OFFS, COUNT), (COUNT)) |
| |
| switch (m_format.type) |
| { |
| case TextureFormat::UNSIGNED_BYTE_44: // Fall-through |
| case TextureFormat::UNORM_BYTE_44: return UVec4(U8 ( 4, 4), U8 ( 0, 4), 0u, 1u).cast<int>(); |
| case TextureFormat::UNSIGNED_SHORT_565: // Fall-through |
| case TextureFormat::UNORM_SHORT_565: return swizzleRB(UVec4(U16(11, 5), U16( 5, 6), U16( 0, 5), 1).cast<int>(), m_format.order, TextureFormat::RGB); |
| case TextureFormat::UNORM_SHORT_555: return swizzleRB(UVec4(U16(10, 5), U16( 5, 5), U16( 0, 5), 1).cast<int>(), m_format.order, TextureFormat::RGB); |
| case TextureFormat::UNSIGNED_SHORT_4444: // Fall-through |
| case TextureFormat::UNORM_SHORT_4444: return swizzleRB(UVec4(U16(12, 4), U16( 8, 4), U16( 4, 4), U16( 0, 4)).cast<int>(), m_format.order, TextureFormat::RGBA); |
| case TextureFormat::UNSIGNED_SHORT_5551: // Fall-through |
| case TextureFormat::UNORM_SHORT_5551: return swizzleRB(UVec4(U16(11, 5), U16( 6, 5), U16( 1, 5), U16( 0, 1)).cast<int>(), m_format.order, TextureFormat::RGBA); |
| case TextureFormat::UNORM_INT_101010: return UVec4(U32(22, 10), U32(12, 10), U32( 2, 10), 1).cast<int>(); |
| case TextureFormat::UNORM_INT_1010102_REV: // Fall-through |
| case TextureFormat::UNSIGNED_INT_1010102_REV: return swizzleRB(UVec4(U32( 0, 10), U32(10, 10), U32(20, 10), U32(30, 2)), m_format.order, TextureFormat::RGBA).cast<int>(); |
| case TextureFormat::SNORM_INT_1010102_REV: // Fall-through |
| case TextureFormat::SIGNED_INT_1010102_REV: return swizzleRB(IVec4(S32( 0, 10), S32(10, 10), S32(20, 10), S32(30, 2)), m_format.order, TextureFormat::RGBA); |
| |
| case TextureFormat::UNORM_SHORT_1555: |
| DE_ASSERT(m_format.order == TextureFormat::ARGB); |
| return UVec4(U16(15, 1), U16(10, 5), U16(5, 5), U16(0, 5)).cast<int>().swizzle(1,2,3,0); // ARGB -> RGBA |
| |
| default: |
| break; // To generic path. |
| } |
| |
| #undef U8 |
| #undef U16 |
| #undef U32 |
| #undef S32 |
| |
| // Generic path. |
| const TextureSwizzle::Channel* channelMap = getChannelReadSwizzle(m_format.order).components; |
| int channelSize = getChannelSize(m_format.type); |
| |
| for (int c = 0; c < 4; c++) |
| { |
| switch (channelMap[c]) |
| { |
| case TextureSwizzle::CHANNEL_0: |
| case TextureSwizzle::CHANNEL_1: |
| case TextureSwizzle::CHANNEL_2: |
| case TextureSwizzle::CHANNEL_3: |
| result[c] = channelToInt(pixelPtr + channelSize*((int)channelMap[c]), m_format.type); |
| break; |
| |
| case TextureSwizzle::CHANNEL_ZERO: |
| result[c] = 0; |
| break; |
| |
| case TextureSwizzle::CHANNEL_ONE: |
| result[c] = 1; |
| break; |
| |
| default: |
| DE_ASSERT(false); |
| } |
| } |
| |
| return result; |
| } |
| |
| template<> |
| Vec4 ConstPixelBufferAccess::getPixelT (int x, int y, int z) const |
| { |
| return getPixel(x, y, z); |
| } |
| |
| template<> |
| IVec4 ConstPixelBufferAccess::getPixelT (int x, int y, int z) const |
| { |
| return getPixelInt(x, y, z); |
| } |
| |
| template<> |
| UVec4 ConstPixelBufferAccess::getPixelT (int x, int y, int z) const |
| { |
| return getPixelUint(x, y, z); |
| } |
| |
| float ConstPixelBufferAccess::getPixDepth (int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, getWidth())); |
| DE_ASSERT(de::inBounds(y, 0, getHeight())); |
| DE_ASSERT(de::inBounds(z, 0, getDepth())); |
| |
| const deUint8* const pixelPtr = (const deUint8*)getPixelPtr(x, y, z); |
| |
| switch (m_format.type) |
| { |
| case TextureFormat::UNSIGNED_INT_16_8_8: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| return (float)readUint32High16(pixelPtr) / 65535.0f; |
| |
| case TextureFormat::UNSIGNED_INT_24_8: |
| DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); |
| return (float)readUint32High24(pixelPtr) / 16777215.0f; |
| |
| case TextureFormat::UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); |
| return (float)readUint32Low24(pixelPtr) / 16777215.0f; |
| |
| case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| return *((const float*)pixelPtr); |
| |
| default: |
| DE_ASSERT(m_format.order == TextureFormat::D); // no other combined depth stencil types |
| return channelToFloat(pixelPtr, m_format.type); |
| } |
| } |
| |
| int ConstPixelBufferAccess::getPixStencil (int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, getWidth())); |
| DE_ASSERT(de::inBounds(y, 0, getHeight())); |
| DE_ASSERT(de::inBounds(z, 0, getDepth())); |
| |
| const deUint8* const pixelPtr = (const deUint8*)getPixelPtr(x, y, z); |
| |
| switch (m_format.type) |
| { |
| case TextureFormat::UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| return (int)readUint32High8(pixelPtr); |
| |
| case TextureFormat::UNSIGNED_INT_16_8_8: |
| case TextureFormat::UNSIGNED_INT_24_8: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| return (int)readUint32Low8(pixelPtr); |
| |
| case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| return (int)readUint32Low8(pixelPtr + 4); |
| |
| default: |
| { |
| DE_ASSERT(m_format.order == TextureFormat::S); // no other combined depth stencil types |
| return channelToInt(pixelPtr, m_format.type); |
| } |
| } |
| } |
| |
| void PixelBufferAccess::setPixel (const Vec4& color, int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, getWidth())); |
| DE_ASSERT(de::inBounds(y, 0, getHeight())); |
| DE_ASSERT(de::inBounds(z, 0, getDepth())); |
| DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly |
| DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly |
| |
| deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); |
| |
| // Optimized fomats. |
| if (m_format.type == TextureFormat::UNORM_INT8) |
| { |
| if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) |
| { |
| writeRGBA8888Float(pixelPtr, color); |
| return; |
| } |
| else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) |
| { |
| writeRGB888Float(pixelPtr, color); |
| return; |
| } |
| } |
| |
| #define PN(VAL, OFFS, BITS) (unormFloatToChannel((VAL), (BITS)) << (OFFS)) |
| #define PS(VAL, OFFS, BITS) (snormFloatToChannel((VAL), (BITS)) << (OFFS)) |
| #define PU(VAL, OFFS, BITS) (uintToChannel((VAL), (BITS)) << (OFFS)) |
| #define PI(VAL, OFFS, BITS) (intToChannel((VAL), (BITS)) << (OFFS)) |
| |
| switch (m_format.type) |
| { |
| case TextureFormat::UNORM_BYTE_44: *((deUint8 *)pixelPtr) = (deUint8)(PN(color[0], 4, 4) | PN(color[1], 0, 4)); break; |
| case TextureFormat::UNSIGNED_BYTE_44: *((deUint8 *)pixelPtr) = (deUint8)(PU((deUint32)color[0], 4, 4) | PU((deUint32)color[1], 0, 4)); break; |
| case TextureFormat::UNORM_INT_101010: *((deUint32*)pixelPtr) = PN(color[0], 22, 10) | PN(color[1], 12, 10) | PN(color[2], 2, 10); break; |
| |
| case TextureFormat::UNORM_SHORT_565: |
| { |
| const Vec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 11, 5) | PN(swizzled[1], 5, 6) | PN(swizzled[2], 0, 5)); |
| break; |
| } |
| |
| case TextureFormat::UNSIGNED_SHORT_565: |
| { |
| const UVec4 swizzled = swizzleRB(color.cast<deUint32>(), TextureFormat::RGB, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 5, 6) | PU(swizzled[2], 0, 5)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_555: |
| { |
| const Vec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 10, 5) | PN(swizzled[1], 5, 5) | PN(swizzled[2], 0, 5)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_4444: |
| { |
| const Vec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 12, 4) | PN(swizzled[1], 8, 4) | PN(swizzled[2], 4, 4) | PN(swizzled[3], 0, 4)); |
| break; |
| } |
| |
| case TextureFormat::UNSIGNED_SHORT_4444: |
| { |
| const UVec4 swizzled = swizzleRB(color.cast<deUint32>(), TextureFormat::RGBA, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 12, 4) | PU(swizzled[1], 8, 4) | PU(swizzled[2], 4, 4) | PU(swizzled[3], 0, 4)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_5551: |
| { |
| const Vec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 11, 5) | PN(swizzled[1], 6, 5) | PN(swizzled[2], 1, 5) | PN(swizzled[3], 0, 1)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_1555: |
| { |
| const Vec4 swizzled = color.swizzle(3,0,1,2); // RGBA -> ARGB |
| *((deUint16*)pixelPtr) = (deUint16)(PN(swizzled[0], 15, 1) | PN(swizzled[1], 10, 5) | PN(swizzled[2], 5, 5) | PN(swizzled[3], 0, 5)); |
| break; |
| } |
| |
| case TextureFormat::UNSIGNED_SHORT_5551: |
| { |
| const UVec4 swizzled = swizzleRB(color.cast<deUint32>(), TextureFormat::RGBA, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 6, 5) | PU(swizzled[2], 1, 5) | PU(swizzled[3], 0, 1)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_INT_1010102_REV: |
| { |
| const Vec4 u = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint32*)pixelPtr) = PN(u[0], 0, 10) | PN(u[1], 10, 10) | PN(u[2], 20, 10) | PN(u[3], 30, 2); |
| break; |
| } |
| |
| case TextureFormat::SNORM_INT_1010102_REV: |
| { |
| const Vec4 u = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint32*)pixelPtr) = PS(u[0], 0, 10) | PS(u[1], 10, 10) | PS(u[2], 20, 10) | PS(u[3], 30, 2); |
| break; |
| } |
| |
| case TextureFormat::UNSIGNED_INT_1010102_REV: |
| { |
| const UVec4 u = swizzleRB(color.cast<deUint32>(), TextureFormat::RGBA, m_format.order); |
| *((deUint32*)pixelPtr) = PU(u[0], 0, 10) | PU(u[1], 10, 10) | PU(u[2], 20, 10) | PU(u[3], 30, 2); |
| break; |
| } |
| |
| case TextureFormat::SIGNED_INT_1010102_REV: |
| { |
| const IVec4 u = swizzleRB(color.cast<deInt32>(), TextureFormat::RGBA, m_format.order); |
| *((deUint32*)pixelPtr) = PI(u[0], 0, 10) | PI(u[1], 10, 10) | PI(u[2], 20, 10) | PI(u[3], 30, 2); |
| break; |
| } |
| |
| case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV: |
| *((deUint32*)pixelPtr) = Float11(color[0]).bits() | (Float11(color[1]).bits() << 11) | (Float10(color[2]).bits() << 22); |
| break; |
| |
| case TextureFormat::UNSIGNED_INT_999_E5_REV: |
| *((deUint32*)pixelPtr) = packRGB999E5(color); |
| break; |
| |
| default: |
| { |
| // Generic path. |
| int numChannels = getNumUsedChannels(m_format.order); |
| const TextureSwizzle::Channel* map = getChannelWriteSwizzle(m_format.order).components; |
| int channelSize = getChannelSize(m_format.type); |
| |
| for (int c = 0; c < numChannels; c++) |
| { |
| DE_ASSERT(deInRange32(map[c], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3)); |
| floatToChannel(pixelPtr + channelSize*c, color[map[c]], m_format.type); |
| } |
| break; |
| } |
| } |
| |
| #undef PN |
| #undef PS |
| #undef PU |
| #undef PI |
| } |
| |
| void PixelBufferAccess::setPixel (const IVec4& color, int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, getWidth())); |
| DE_ASSERT(de::inBounds(y, 0, getHeight())); |
| DE_ASSERT(de::inBounds(z, 0, getDepth())); |
| DE_ASSERT(!isCombinedDepthStencilType(m_format.type)); // combined types cannot be accessed directly |
| DE_ASSERT(m_format.order != TextureFormat::DS); // combined formats cannot be accessed directly |
| |
| deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); |
| |
| // Optimized fomats. |
| if (m_format.type == TextureFormat::UNORM_INT8) |
| { |
| if (m_format.order == TextureFormat::RGBA || m_format.order == TextureFormat::sRGBA) |
| { |
| writeRGBA8888Int(pixelPtr, color); |
| return; |
| } |
| else if (m_format.order == TextureFormat::RGB || m_format.order == TextureFormat::sRGB) |
| { |
| writeRGB888Int(pixelPtr, color); |
| return; |
| } |
| } |
| |
| #define PU(VAL, OFFS, BITS) (uintToChannel((deUint32)(VAL), (BITS)) << (OFFS)) |
| #define PI(VAL, OFFS, BITS) (intToChannel((deUint32)(VAL), (BITS)) << (OFFS)) |
| |
| switch (m_format.type) |
| { |
| case TextureFormat::UNSIGNED_BYTE_44: // Fall-through |
| case TextureFormat::UNORM_BYTE_44: *((deUint8 *)pixelPtr) = (deUint8 )(PU(color[0], 4, 4) | PU(color[1], 0, 4)); break; |
| case TextureFormat::UNORM_INT_101010: *((deUint32*)pixelPtr) = PU(color[0], 22, 10) | PU(color[1], 12, 10) | PU(color[2], 2, 10); break; |
| |
| case TextureFormat::UNORM_SHORT_565: |
| case TextureFormat::UNSIGNED_SHORT_565: |
| { |
| const IVec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 5, 6) | PU(swizzled[2], 0, 5)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_555: |
| { |
| const IVec4 swizzled = swizzleRB(color, TextureFormat::RGB, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 10, 5) | PU(swizzled[1], 5, 5) | PU(swizzled[2], 0, 5)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_4444: |
| case TextureFormat::UNSIGNED_SHORT_4444: |
| { |
| const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 12, 4) | PU(swizzled[1], 8, 4) | PU(swizzled[2], 4, 4) | PU(swizzled[3], 0, 4)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_5551: |
| case TextureFormat::UNSIGNED_SHORT_5551: |
| { |
| const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 11, 5) | PU(swizzled[1], 6, 5) | PU(swizzled[2], 1, 5) | PU(swizzled[3], 0, 1)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_SHORT_1555: |
| { |
| const IVec4 swizzled = color.swizzle(3,0,1,2); // RGBA -> ARGB |
| *((deUint16*)pixelPtr) = (deUint16)(PU(swizzled[0], 15, 1) | PU(swizzled[1], 10, 5) | PU(swizzled[2], 5, 5) | PU(swizzled[3], 0, 5)); |
| break; |
| } |
| |
| case TextureFormat::UNORM_INT_1010102_REV: |
| case TextureFormat::UNSIGNED_INT_1010102_REV: |
| { |
| const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint32*)pixelPtr) = PU(swizzled[0], 0, 10) | PU(swizzled[1], 10, 10) | PU(swizzled[2], 20, 10) | PU(swizzled[3], 30, 2); |
| break; |
| } |
| |
| case TextureFormat::SNORM_INT_1010102_REV: |
| case TextureFormat::SIGNED_INT_1010102_REV: |
| { |
| const IVec4 swizzled = swizzleRB(color, TextureFormat::RGBA, m_format.order); |
| *((deUint32*)pixelPtr) = PI(swizzled[0], 0, 10) | PI(swizzled[1], 10, 10) | PI(swizzled[2], 20, 10) | PI(swizzled[3], 30, 2); |
| break; |
| } |
| |
| default: |
| { |
| // Generic path. |
| int numChannels = getNumUsedChannels(m_format.order); |
| const TextureSwizzle::Channel* map = getChannelWriteSwizzle(m_format.order).components; |
| int channelSize = getChannelSize(m_format.type); |
| |
| for (int c = 0; c < numChannels; c++) |
| { |
| DE_ASSERT(deInRange32(map[c], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3)); |
| intToChannel(pixelPtr + channelSize*c, color[map[c]], m_format.type); |
| } |
| break; |
| } |
| } |
| |
| #undef PU |
| #undef PI |
| } |
| |
| void PixelBufferAccess::setPixDepth (float depth, int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, getWidth())); |
| DE_ASSERT(de::inBounds(y, 0, getHeight())); |
| DE_ASSERT(de::inBounds(z, 0, getDepth())); |
| |
| deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); |
| |
| switch (m_format.type) |
| { |
| case TextureFormat::UNSIGNED_INT_16_8_8: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| writeUint32High16(pixelPtr, convertSatRte<deUint16>(depth * 65535.0f)); |
| break; |
| |
| case TextureFormat::UNSIGNED_INT_24_8: |
| DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); |
| writeUint32High24(pixelPtr, convertSatRteUint24(depth * 16777215.0f)); |
| break; |
| |
| case TextureFormat::UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::D || m_format.order == TextureFormat::DS); |
| writeUint32Low24(pixelPtr, convertSatRteUint24(depth * 16777215.0f)); |
| break; |
| |
| case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| *((float*)pixelPtr) = depth; |
| break; |
| |
| default: |
| DE_ASSERT(m_format.order == TextureFormat::D); // no other combined depth stencil types |
| floatToChannel(pixelPtr, depth, m_format.type); |
| break; |
| } |
| } |
| |
| void PixelBufferAccess::setPixStencil (int stencil, int x, int y, int z) const |
| { |
| DE_ASSERT(de::inBounds(x, 0, getWidth())); |
| DE_ASSERT(de::inBounds(y, 0, getHeight())); |
| DE_ASSERT(de::inBounds(z, 0, getDepth())); |
| |
| deUint8* const pixelPtr = (deUint8*)getPixelPtr(x, y, z); |
| |
| switch (m_format.type) |
| { |
| case TextureFormat::UNSIGNED_INT_16_8_8: |
| case TextureFormat::UNSIGNED_INT_24_8: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| writeUint32Low8(pixelPtr, convertSat<deUint8>((deUint32)stencil)); |
| break; |
| |
| case TextureFormat::UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| writeUint32High8(pixelPtr, convertSat<deUint8>((deUint32)stencil)); |
| break; |
| |
| case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV: |
| DE_ASSERT(m_format.order == TextureFormat::DS); |
| writeUint32Low8(pixelPtr + 4, convertSat<deUint8>((deUint32)stencil)); |
| break; |
| |
| default: |
| DE_ASSERT(m_format.order == TextureFormat::S); // no other combined depth stencil types |
| intToChannel(pixelPtr, stencil, m_format.type); |
| break; |
| } |
| } |
| |
| static inline int imod (int a, int b) |
| { |
| int m = a % b; |
| return m < 0 ? m + b : m; |
| } |
| |
| static inline int mirror (int a) |
| { |
| return a >= 0.0f ? a : -(1 + a); |
| } |
| |
| // Nearest-even rounding in case of tie (fractional part 0.5), otherwise ordinary rounding. |
| static inline float rint (float a) |
| { |
| DE_STATIC_ASSERT((-3 % 2 != 0) && (-4 % 2 == 0)); |
| |
| float fracVal = deFloatFrac(a); |
| |
| if (fracVal != 0.5f) |
| return deFloatRound(a); // Ordinary case. |
| |
| float floorVal = a - fracVal; |
| bool roundUp = (deInt64)floorVal % 2 != 0; |
| |
| return floorVal + (roundUp ? 1.0f : 0.0f); |
| } |
| |
| static inline int wrap (Sampler::WrapMode mode, int c, int size) |
| { |
| switch (mode) |
| { |
| case tcu::Sampler::CLAMP_TO_BORDER: |
| return deClamp32(c, -1, size); |
| |
| case tcu::Sampler::CLAMP_TO_EDGE: |
| return deClamp32(c, 0, size-1); |
| |
| case tcu::Sampler::REPEAT_GL: |
| return imod(c, size); |
| |
| case tcu::Sampler::REPEAT_CL: |
| return imod(c, size); |
| |
| case tcu::Sampler::MIRRORED_ONCE: |
| c = deClamp32(c, -size, size); |
| // Fall-through |
| |
| case tcu::Sampler::MIRRORED_REPEAT_GL: |
| return (size - 1) - mirror(imod(c, 2*size) - size); |
| |
| case tcu::Sampler::MIRRORED_REPEAT_CL: |
| return deClamp32(c, 0, size-1); // \note Actual mirroring done already in unnormalization function. |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0; |
| } |
| } |
| |
| // Special unnormalization for REPEAT_CL and MIRRORED_REPEAT_CL wrap modes; otherwise ordinary unnormalization. |
| static inline float unnormalize (Sampler::WrapMode mode, float c, int size) |
| { |
| switch (mode) |
| { |
| case tcu::Sampler::CLAMP_TO_EDGE: |
| case tcu::Sampler::CLAMP_TO_BORDER: |
| case tcu::Sampler::REPEAT_GL: |
| case tcu::Sampler::MIRRORED_REPEAT_GL: |
| case tcu::Sampler::MIRRORED_ONCE: // Fall-through (ordinary case). |
| return (float)size*c; |
| |
| case tcu::Sampler::REPEAT_CL: |
| return (float)size * (c - deFloatFloor(c)); |
| |
| case tcu::Sampler::MIRRORED_REPEAT_CL: |
| return (float)size * deFloatAbs(c - 2.0f * rint(0.5f * c)); |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| static bool isFixedPointDepthTextureFormat (const tcu::TextureFormat& format) |
| { |
| DE_ASSERT(format.order == TextureFormat::D); |
| |
| const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type); |
| if (channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT) |
| return false; |
| else if (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT) |
| return true; |
| else |
| { |
| DE_ASSERT(false); |
| return false; |
| } |
| } |
| |
| // Texel lookup with color conversion. |
| static inline Vec4 lookup (const ConstPixelBufferAccess& access, int i, int j, int k) |
| { |
| const TextureFormat& format = access.getFormat(); |
| |
| if (isSRGB(format)) |
| { |
| if (format.type == TextureFormat::UNORM_INT8 && format.order == TextureFormat::sRGB) |
| return sRGB8ToLinear(access.getPixelUint(i, j, k)); |
| else if (format.type == TextureFormat::UNORM_INT8 && format.order == TextureFormat::sRGBA) |
| return sRGBA8ToLinear(access.getPixelUint(i, j, k)); |
| else |
| return sRGBToLinear(access.getPixel(i, j, k)); |
| } |
| else |
| { |
| return access.getPixel(i, j, k); |
| } |
| } |
| |
| // Border texel lookup with color conversion. |
| static inline Vec4 lookupBorder (const tcu::TextureFormat& format, const tcu::Sampler& sampler) |
| { |
| // "lookup" for a combined format does not make sense, disallow |
| DE_ASSERT(!isCombinedDepthStencilType(format.type)); |
| |
| const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type); |
| const bool isFloat = channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT; |
| const bool isFixed = channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT || |
| channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT; |
| const bool isPureInteger = channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER; |
| const bool isPureUnsignedInteger = channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER; |
| |
| if (isFloat || isFixed) |
| return sampleTextureBorder<float>(format, sampler); |
| else if (isPureInteger) |
| return sampleTextureBorder<deInt32>(format, sampler).cast<float>(); |
| else if (isPureUnsignedInteger) |
| return sampleTextureBorder<deUint32>(format, sampler).cast<float>(); |
| else |
| { |
| DE_ASSERT(false); |
| return Vec4(-1.0); |
| } |
| } |
| |
| static inline float execCompare (const tcu::Vec4& color, Sampler::CompareMode compare, int chanNdx, float ref_, bool isFixedPoint) |
| { |
| const bool clampValues = isFixedPoint; // if comparing against a floating point texture, ref (and value) is not clamped |
| const float cmp = (clampValues) ? (de::clamp(color[chanNdx], 0.0f, 1.0f)) : (color[chanNdx]); |
| const float ref = (clampValues) ? (de::clamp(ref_, 0.0f, 1.0f)) : (ref_); |
| bool res = false; |
| |
| switch (compare) |
| { |
| case Sampler::COMPAREMODE_LESS: res = ref < cmp; break; |
| case Sampler::COMPAREMODE_LESS_OR_EQUAL: res = ref <= cmp; break; |
| case Sampler::COMPAREMODE_GREATER: res = ref > cmp; break; |
| case Sampler::COMPAREMODE_GREATER_OR_EQUAL: res = ref >= cmp; break; |
| case Sampler::COMPAREMODE_EQUAL: res = ref == cmp; break; |
| case Sampler::COMPAREMODE_NOT_EQUAL: res = ref != cmp; break; |
| case Sampler::COMPAREMODE_ALWAYS: res = true; break; |
| case Sampler::COMPAREMODE_NEVER: res = false; break; |
| default: |
| DE_ASSERT(false); |
| } |
| |
| return res ? 1.0f : 0.0f; |
| } |
| |
| static Vec4 sampleNearest1D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, const IVec2& offset) |
| { |
| int width = access.getWidth(); |
| |
| int x = deFloorFloatToInt32(u)+offset.x(); |
| |
| // Check for CLAMP_TO_BORDER. |
| if (sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) |
| return lookupBorder(access.getFormat(), sampler); |
| |
| int i = wrap(sampler.wrapS, x, width); |
| |
| return lookup(access, i, offset.y(), 0); |
| } |
| |
| static Vec4 sampleNearest2D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, const IVec3& offset) |
| { |
| int width = access.getWidth(); |
| int height = access.getHeight(); |
| |
| int x = deFloorFloatToInt32(u)+offset.x(); |
| int y = deFloorFloatToInt32(v)+offset.y(); |
| |
| // Check for CLAMP_TO_BORDER. |
| if ((sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) || |
| (sampler.wrapT == Sampler::CLAMP_TO_BORDER && !deInBounds32(y, 0, height))) |
| return lookupBorder(access.getFormat(), sampler); |
| |
| int i = wrap(sampler.wrapS, x, width); |
| int j = wrap(sampler.wrapT, y, height); |
| |
| return lookup(access, i, j, offset.z()); |
| } |
| |
| static Vec4 sampleNearest3D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, float w, const IVec3& offset) |
| { |
| int width = access.getWidth(); |
| int height = access.getHeight(); |
| int depth = access.getDepth(); |
| |
| int x = deFloorFloatToInt32(u)+offset.x(); |
| int y = deFloorFloatToInt32(v)+offset.y(); |
| int z = deFloorFloatToInt32(w)+offset.z(); |
| |
| // Check for CLAMP_TO_BORDER. |
| if ((sampler.wrapS == Sampler::CLAMP_TO_BORDER && !deInBounds32(x, 0, width)) || |
| (sampler.wrapT == Sampler::CLAMP_TO_BORDER && !deInBounds32(y, 0, height)) || |
| (sampler.wrapR == Sampler::CLAMP_TO_BORDER && !deInBounds32(z, 0, depth))) |
| return lookupBorder(access.getFormat(), sampler); |
| |
| int i = wrap(sampler.wrapS, x, width); |
| int j = wrap(sampler.wrapT, y, height); |
| int k = wrap(sampler.wrapR, z, depth); |
| |
| return lookup(access, i, j, k); |
| } |
| |
| static Vec4 sampleLinear1D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, const IVec2& offset) |
| { |
| int w = access.getWidth(); |
| |
| int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); |
| int x1 = x0+1; |
| |
| int i0 = wrap(sampler.wrapS, x0, w); |
| int i1 = wrap(sampler.wrapS, x1, w); |
| |
| float a = deFloatFrac(u-0.5f); |
| |
| bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); |
| bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); |
| |
| // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. |
| Vec4 p0 = i0UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, offset.y(), 0); |
| Vec4 p1 = i1UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, offset.y(), 0); |
| |
| // Interpolate. |
| return p0 * (1.0f - a) + p1 * a; |
| } |
| |
| static Vec4 sampleLinear2D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, const IVec3& offset) |
| { |
| int w = access.getWidth(); |
| int h = access.getHeight(); |
| |
| int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); |
| int x1 = x0+1; |
| int y0 = deFloorFloatToInt32(v-0.5f)+offset.y(); |
| int y1 = y0+1; |
| |
| int i0 = wrap(sampler.wrapS, x0, w); |
| int i1 = wrap(sampler.wrapS, x1, w); |
| int j0 = wrap(sampler.wrapT, y0, h); |
| int j1 = wrap(sampler.wrapT, y1, h); |
| |
| float a = deFloatFrac(u-0.5f); |
| float b = deFloatFrac(v-0.5f); |
| |
| bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); |
| bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); |
| bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, h); |
| bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, h); |
| |
| // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. |
| Vec4 p00 = (i0UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, offset.z()); |
| Vec4 p10 = (i1UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, offset.z()); |
| Vec4 p01 = (i0UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, offset.z()); |
| Vec4 p11 = (i1UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, offset.z()); |
| |
| // Interpolate. |
| return (p00*(1.0f-a)*(1.0f-b)) + |
| (p10*( a)*(1.0f-b)) + |
| (p01*(1.0f-a)*( b)) + |
| (p11*( a)*( b)); |
| } |
| |
| static float sampleLinear1DCompare (const ConstPixelBufferAccess& access, const Sampler& sampler, float ref, float u, const IVec2& offset, bool isFixedPointDepthFormat) |
| { |
| int w = access.getWidth(); |
| |
| int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); |
| int x1 = x0+1; |
| |
| int i0 = wrap(sampler.wrapS, x0, w); |
| int i1 = wrap(sampler.wrapS, x1, w); |
| |
| float a = deFloatFrac(u-0.5f); |
| |
| bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); |
| bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); |
| |
| // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. |
| Vec4 p0Clr = i0UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, offset.y(), 0); |
| Vec4 p1Clr = i1UseBorder ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, offset.y(), 0); |
| |
| // Execute comparisons. |
| float p0 = execCompare(p0Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); |
| float p1 = execCompare(p1Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); |
| |
| // Interpolate. |
| return (p0 * (1.0f - a)) + (p1 * a); |
| } |
| |
| static float sampleLinear2DCompare (const ConstPixelBufferAccess& access, const Sampler& sampler, float ref, float u, float v, const IVec3& offset, bool isFixedPointDepthFormat) |
| { |
| int w = access.getWidth(); |
| int h = access.getHeight(); |
| |
| int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); |
| int x1 = x0+1; |
| int y0 = deFloorFloatToInt32(v-0.5f)+offset.y(); |
| int y1 = y0+1; |
| |
| int i0 = wrap(sampler.wrapS, x0, w); |
| int i1 = wrap(sampler.wrapS, x1, w); |
| int j0 = wrap(sampler.wrapT, y0, h); |
| int j1 = wrap(sampler.wrapT, y1, h); |
| |
| float a = deFloatFrac(u-0.5f); |
| float b = deFloatFrac(v-0.5f); |
| |
| bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, w); |
| bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, w); |
| bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, h); |
| bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, h); |
| |
| // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. |
| Vec4 p00Clr = (i0UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, offset.z()); |
| Vec4 p10Clr = (i1UseBorder || j0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, offset.z()); |
| Vec4 p01Clr = (i0UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, offset.z()); |
| Vec4 p11Clr = (i1UseBorder || j1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, offset.z()); |
| |
| // Execute comparisons. |
| float p00 = execCompare(p00Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); |
| float p10 = execCompare(p10Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); |
| float p01 = execCompare(p01Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); |
| float p11 = execCompare(p11Clr, sampler.compare, sampler.compareChannel, ref, isFixedPointDepthFormat); |
| |
| // Interpolate. |
| return (p00*(1.0f-a)*(1.0f-b)) + |
| (p10*( a)*(1.0f-b)) + |
| (p01*(1.0f-a)*( b)) + |
| (p11*( a)*( b)); |
| } |
| |
| static Vec4 sampleLinear3D (const ConstPixelBufferAccess& access, const Sampler& sampler, float u, float v, float w, const IVec3& offset) |
| { |
| int width = access.getWidth(); |
| int height = access.getHeight(); |
| int depth = access.getDepth(); |
| |
| int x0 = deFloorFloatToInt32(u-0.5f)+offset.x(); |
| int x1 = x0+1; |
| int y0 = deFloorFloatToInt32(v-0.5f)+offset.y(); |
| int y1 = y0+1; |
| int z0 = deFloorFloatToInt32(w-0.5f)+offset.z(); |
| int z1 = z0+1; |
| |
| int i0 = wrap(sampler.wrapS, x0, width); |
| int i1 = wrap(sampler.wrapS, x1, width); |
| int j0 = wrap(sampler.wrapT, y0, height); |
| int j1 = wrap(sampler.wrapT, y1, height); |
| int k0 = wrap(sampler.wrapR, z0, depth); |
| int k1 = wrap(sampler.wrapR, z1, depth); |
| |
| float a = deFloatFrac(u-0.5f); |
| float b = deFloatFrac(v-0.5f); |
| float c = deFloatFrac(w-0.5f); |
| |
| bool i0UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i0, 0, width); |
| bool i1UseBorder = sampler.wrapS == Sampler::CLAMP_TO_BORDER && !de::inBounds(i1, 0, width); |
| bool j0UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j0, 0, height); |
| bool j1UseBorder = sampler.wrapT == Sampler::CLAMP_TO_BORDER && !de::inBounds(j1, 0, height); |
| bool k0UseBorder = sampler.wrapR == Sampler::CLAMP_TO_BORDER && !de::inBounds(k0, 0, depth); |
| bool k1UseBorder = sampler.wrapR == Sampler::CLAMP_TO_BORDER && !de::inBounds(k1, 0, depth); |
| |
| // Border color for out-of-range coordinates if using CLAMP_TO_BORDER, otherwise execute lookups. |
| Vec4 p000 = (i0UseBorder || j0UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, k0); |
| Vec4 p100 = (i1UseBorder || j0UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, k0); |
| Vec4 p010 = (i0UseBorder || j1UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, k0); |
| Vec4 p110 = (i1UseBorder || j1UseBorder || k0UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, k0); |
| Vec4 p001 = (i0UseBorder || j0UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j0, k1); |
| Vec4 p101 = (i1UseBorder || j0UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j0, k1); |
| Vec4 p011 = (i0UseBorder || j1UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i0, j1, k1); |
| Vec4 p111 = (i1UseBorder || j1UseBorder || k1UseBorder) ? lookupBorder(access.getFormat(), sampler) : lookup(access, i1, j1, k1); |
| |
| // Interpolate. |
| return (p000*(1.0f-a)*(1.0f-b)*(1.0f-c)) + |
| (p100*( a)*(1.0f-b)*(1.0f-c)) + |
| (p010*(1.0f-a)*( b)*(1.0f-c)) + |
| (p110*( a)*( b)*(1.0f-c)) + |
| (p001*(1.0f-a)*(1.0f-b)*( c)) + |
| (p101*( a)*(1.0f-b)*( c)) + |
| (p011*(1.0f-a)*( b)*( c)) + |
| (p111*( a)*( b)*( c)); |
| } |
| |
| Vec4 ConstPixelBufferAccess::sample1D (const Sampler& sampler, Sampler::FilterMode filter, float s, int level) const |
| { |
| // check selected layer exists |
| DE_ASSERT(de::inBounds(level, 0, m_size.y())); |
| |
| return sample1DOffset(sampler, filter, s, tcu::IVec2(0, level)); |
| } |
| |
| Vec4 ConstPixelBufferAccess::sample2D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, int depth) const |
| { |
| // check selected layer exists |
| DE_ASSERT(de::inBounds(depth, 0, m_size.z())); |
| |
| return sample2DOffset(sampler, filter, s, t, tcu::IVec3(0, 0, depth)); |
| } |
| |
| Vec4 ConstPixelBufferAccess::sample3D (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r) const |
| { |
| return sample3DOffset(sampler, filter, s, t, r, tcu::IVec3(0, 0, 0)); |
| } |
| |
| Vec4 ConstPixelBufferAccess::sample1DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, const IVec2& offset) const |
| { |
| // check selected layer exists |
| // \note offset.x is X offset, offset.y is the selected layer |
| DE_ASSERT(de::inBounds(offset.y(), 0, m_size.y())); |
| |
| // Non-normalized coordinates. |
| float u = s; |
| |
| if (sampler.normalizedCoords) |
| u = unnormalize(sampler.wrapS, s, m_size.x()); |
| |
| switch (filter) |
| { |
| case Sampler::NEAREST: return sampleNearest1D (*this, sampler, u, offset); |
| case Sampler::LINEAR: return sampleLinear1D (*this, sampler, u, offset); |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| Vec4 ConstPixelBufferAccess::sample2DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, const IVec3& offset) const |
| { |
| // check selected layer exists |
| // \note offset.xy is the XY offset, offset.z is the selected layer |
| DE_ASSERT(de::inBounds(offset.z(), 0, m_size.z())); |
| |
| // Non-normalized coordinates. |
| float u = s; |
| float v = t; |
| |
| if (sampler.normalizedCoords) |
| { |
| u = unnormalize(sampler.wrapS, s, m_size.x()); |
| v = unnormalize(sampler.wrapT, t, m_size.y()); |
| } |
| |
| switch (filter) |
| { |
| case Sampler::NEAREST: return sampleNearest2D (*this, sampler, u, v, offset); |
| case Sampler::LINEAR: return sampleLinear2D (*this, sampler, u, v, offset); |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| Vec4 ConstPixelBufferAccess::sample3DOffset (const Sampler& sampler, Sampler::FilterMode filter, float s, float t, float r, const IVec3& offset) const |
| { |
| // Non-normalized coordinates. |
| float u = s; |
| float v = t; |
| float w = r; |
| |
| if (sampler.normalizedCoords) |
| { |
| u = unnormalize(sampler.wrapS, s, m_size.x()); |
| v = unnormalize(sampler.wrapT, t, m_size.y()); |
| w = unnormalize(sampler.wrapR, r, m_size.z()); |
| } |
| |
| switch (filter) |
| { |
| case Sampler::NEAREST: return sampleNearest3D (*this, sampler, u, v, w, offset); |
| case Sampler::LINEAR: return sampleLinear3D (*this, sampler, u, v, w, offset); |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| float ConstPixelBufferAccess::sample1DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, const IVec2& offset) const |
| { |
| // check selected layer exists |
| // \note offset.x is X offset, offset.y is the selected layer |
| DE_ASSERT(de::inBounds(offset.y(), 0, m_size.y())); |
| |
| // Format information for comparison function |
| const bool isFixedPointDepth = isFixedPointDepthTextureFormat(m_format); |
| |
| // Non-normalized coordinates. |
| float u = s; |
| |
| if (sampler.normalizedCoords) |
| u = unnormalize(sampler.wrapS, s, m_size.x()); |
| |
| switch (filter) |
| { |
| case Sampler::NEAREST: return execCompare(sampleNearest1D(*this, sampler, u, offset), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth); |
| case Sampler::LINEAR: return sampleLinear1DCompare(*this, sampler, ref, u, offset, isFixedPointDepth); |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| float ConstPixelBufferAccess::sample2DCompare (const Sampler& sampler, Sampler::FilterMode filter, float ref, float s, float t, const IVec3& offset) const |
| { |
| // check selected layer exists |
| // \note offset.xy is XY offset, offset.z is the selected layer |
| DE_ASSERT(de::inBounds(offset.z(), 0, m_size.z())); |
| |
| // Format information for comparison function |
| const bool isFixedPointDepth = isFixedPointDepthTextureFormat(m_format); |
| |
| // Non-normalized coordinates. |
| float u = s; |
| float v = t; |
| |
| if (sampler.normalizedCoords) |
| { |
| u = unnormalize(sampler.wrapS, s, m_size.x()); |
| v = unnormalize(sampler.wrapT, t, m_size.y()); |
| } |
| |
| switch (filter) |
| { |
| case Sampler::NEAREST: return execCompare(sampleNearest2D(*this, sampler, u, v, offset), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth); |
| case Sampler::LINEAR: return sampleLinear2DCompare(*this, sampler, ref, u, v, offset, isFixedPointDepth); |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| TextureLevel::TextureLevel (void) |
| : m_format () |
| , m_size (0) |
| { |
| } |
| |
| TextureLevel::TextureLevel (const TextureFormat& format) |
| : m_format (format) |
| , m_size (0) |
| { |
| } |
| |
| TextureLevel::TextureLevel (const TextureFormat& format, int width, int height, int depth) |
| : m_format (format) |
| , m_size (0) |
| { |
| setSize(width, height, depth); |
| } |
| |
| TextureLevel::~TextureLevel (void) |
| { |
| } |
| |
| void TextureLevel::setStorage (const TextureFormat& format, int width, int height, int depth) |
| { |
| m_format = format; |
| setSize(width, height, depth); |
| } |
| |
| void TextureLevel::setSize (int width, int height, int depth) |
| { |
| int pixelSize = m_format.getPixelSize(); |
| |
| m_size = IVec3(width, height, depth); |
| |
| m_data.setStorage(m_size.x() * m_size.y() * m_size.z() * pixelSize); |
| } |
| |
| Vec4 sampleLevelArray1D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, int depth, float lod) |
| { |
| return sampleLevelArray1DOffset(levels, numLevels, sampler, s, lod, IVec2(0, depth)); // y-offset in 1D textures is layer selector |
| } |
| |
| Vec4 sampleLevelArray2D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, int depth, float lod) |
| { |
| return sampleLevelArray2DOffset(levels, numLevels, sampler, s, t, lod, IVec3(0, 0, depth)); // z-offset in 2D textures is layer selector |
| } |
| |
| Vec4 sampleLevelArray3D (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod) |
| { |
| return sampleLevelArray3DOffset(levels, numLevels, sampler, s, t, r, lod, IVec3(0, 0, 0)); |
| } |
| |
| Vec4 sampleLevelArray1DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float lod, const IVec2& offset) |
| { |
| bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: return levels[0].sample1DOffset(sampler, filterMode, s, offset); |
| case Sampler::LINEAR: return levels[0].sample1DOffset(sampler, filterMode, s, offset); |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| return levels[level].sample1DOffset(sampler, levelFilter, s, offset); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| tcu::Vec4 t0 = levels[level0].sample1DOffset(sampler, levelFilter, s, offset); |
| tcu::Vec4 t1 = levels[level1].sample1DOffset(sampler, levelFilter, s, offset); |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| Vec4 sampleLevelArray2DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float lod, const IVec3& offset) |
| { |
| bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: return levels[0].sample2DOffset(sampler, filterMode, s, t, offset); |
| case Sampler::LINEAR: return levels[0].sample2DOffset(sampler, filterMode, s, t, offset); |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| return levels[level].sample2DOffset(sampler, levelFilter, s, t, offset); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| tcu::Vec4 t0 = levels[level0].sample2DOffset(sampler, levelFilter, s, t, offset); |
| tcu::Vec4 t1 = levels[level1].sample2DOffset(sampler, levelFilter, s, t, offset); |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| Vec4 sampleLevelArray3DOffset (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float s, float t, float r, float lod, const IVec3& offset) |
| { |
| bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: return levels[0].sample3DOffset(sampler, filterMode, s, t, r, offset); |
| case Sampler::LINEAR: return levels[0].sample3DOffset(sampler, filterMode, s, t, r, offset); |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| return levels[level].sample3DOffset(sampler, levelFilter, s, t, r, offset); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| tcu::Vec4 t0 = levels[level0].sample3DOffset(sampler, levelFilter, s, t, r, offset); |
| tcu::Vec4 t1 = levels[level1].sample3DOffset(sampler, levelFilter, s, t, r, offset); |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| float sampleLevelArray1DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float lod, const IVec2& offset) |
| { |
| bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: return levels[0].sample1DCompare(sampler, filterMode, ref, s, offset); |
| case Sampler::LINEAR: return levels[0].sample1DCompare(sampler, filterMode, ref, s, offset); |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| return levels[level].sample1DCompare(sampler, levelFilter, ref, s, offset); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| float t0 = levels[level0].sample1DCompare(sampler, levelFilter, ref, s, offset); |
| float t1 = levels[level1].sample1DCompare(sampler, levelFilter, ref, s, offset); |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| float sampleLevelArray2DCompare (const ConstPixelBufferAccess* levels, int numLevels, const Sampler& sampler, float ref, float s, float t, float lod, const IVec3& offset) |
| { |
| bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: return levels[0].sample2DCompare(sampler, filterMode, ref, s, t, offset); |
| case Sampler::LINEAR: return levels[0].sample2DCompare(sampler, filterMode, ref, s, t, offset); |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| return levels[level].sample2DCompare(sampler, levelFilter, ref, s, t, offset); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| float t0 = levels[level0].sample2DCompare(sampler, levelFilter, ref, s, t, offset); |
| float t1 = levels[level1].sample2DCompare(sampler, levelFilter, ref, s, t, offset); |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| static Vec4 fetchGatherArray2DOffsets (const ConstPixelBufferAccess& src, const Sampler& sampler, float s, float t, int depth, int componentNdx, const IVec2 (&offsets)[4]) |
| { |
| DE_ASSERT(de::inBounds(componentNdx, 0, 4)); |
| |
| const int w = src.getWidth(); |
| const int h = src.getHeight(); |
| const float u = unnormalize(sampler.wrapS, s, w); |
| const float v = unnormalize(sampler.wrapT, t, h); |
| const int x0 = deFloorFloatToInt32(u-0.5f); |
| const int y0 = deFloorFloatToInt32(v-0.5f); |
| |
| Vec4 result; |
| |
| for (int i = 0; i < 4; i++) |
| { |
| const int sampleX = wrap(sampler.wrapS, x0 + offsets[i].x(), w); |
| const int sampleY = wrap(sampler.wrapT, y0 + offsets[i].y(), h); |
| Vec4 pixel; |
| |
| if (deInBounds32(sampleX, 0, w) && deInBounds32(sampleY, 0, h)) |
| pixel = lookup(src, sampleX, sampleY, depth); |
| else |
| pixel = lookupBorder(src.getFormat(), sampler); |
| |
| result[i] = pixel[componentNdx]; |
| } |
| |
| return result; |
| } |
| |
| Vec4 gatherArray2DOffsets (const ConstPixelBufferAccess& src, const Sampler& sampler, float s, float t, int depth, int componentNdx, const IVec2 (&offsets)[4]) |
| { |
| DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); |
| DE_ASSERT(de::inBounds(componentNdx, 0, 4)); |
| |
| return fetchGatherArray2DOffsets(src, sampler, s, t, depth, componentNdx, offsets); |
| } |
| |
| Vec4 gatherArray2DOffsetsCompare (const ConstPixelBufferAccess& src, const Sampler& sampler, float ref, float s, float t, int depth, const IVec2 (&offsets)[4]) |
| { |
| DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); |
| DE_ASSERT(src.getFormat().order == TextureFormat::D || src.getFormat().order == TextureFormat::DS); |
| DE_ASSERT(sampler.compareChannel == 0); |
| |
| const bool isFixedPoint = isFixedPointDepthTextureFormat(src.getFormat()); |
| const Vec4 gathered = fetchGatherArray2DOffsets(src, sampler, s, t, depth, 0 /* component 0: depth */, offsets); |
| Vec4 result; |
| |
| for (int i = 0; i < 4; i++) |
| result[i] = execCompare(gathered, sampler.compare, i, ref, isFixedPoint); |
| |
| return result; |
| } |
| |
| static Vec4 sampleCubeSeamlessNearest (const ConstPixelBufferAccess& faceAccess, const Sampler& sampler, float s, float t, int depth) |
| { |
| Sampler clampingSampler = sampler; |
| clampingSampler.wrapS = Sampler::CLAMP_TO_EDGE; |
| clampingSampler.wrapT = Sampler::CLAMP_TO_EDGE; |
| return faceAccess.sample2D(clampingSampler, Sampler::NEAREST, s, t, depth); |
| } |
| |
| CubeFace selectCubeFace (const Vec3& coords) |
| { |
| const float x = coords.x(); |
| const float y = coords.y(); |
| const float z = coords.z(); |
| const float ax = deFloatAbs(x); |
| const float ay = deFloatAbs(y); |
| const float az = deFloatAbs(z); |
| |
| if (ay < ax && az < ax) |
| return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; |
| else if (ax < ay && az < ay) |
| return y >= 0.0f ? CUBEFACE_POSITIVE_Y : CUBEFACE_NEGATIVE_Y; |
| else if (ax < az && ay < az) |
| return z >= 0.0f ? CUBEFACE_POSITIVE_Z : CUBEFACE_NEGATIVE_Z; |
| else |
| { |
| // Some of the components are equal. Use tie-breaking rule. |
| if (ax == ay) |
| { |
| if (ax < az) |
| return z >= 0.0f ? CUBEFACE_POSITIVE_Z : CUBEFACE_NEGATIVE_Z; |
| else |
| return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; |
| } |
| else if (ax == az) |
| { |
| if (az < ay) |
| return y >= 0.0f ? CUBEFACE_POSITIVE_Y : CUBEFACE_NEGATIVE_Y; |
| else |
| return z >= 0.0f ? CUBEFACE_POSITIVE_Z : CUBEFACE_NEGATIVE_Z; |
| } |
| else if (ay == az) |
| { |
| if (ay < ax) |
| return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; |
| else |
| return y >= 0.0f ? CUBEFACE_POSITIVE_Y : CUBEFACE_NEGATIVE_Y; |
| } |
| else |
| return x >= 0.0f ? CUBEFACE_POSITIVE_X : CUBEFACE_NEGATIVE_X; |
| } |
| } |
| |
| Vec2 projectToFace (CubeFace face, const Vec3& coord) |
| { |
| const float rx = coord.x(); |
| const float ry = coord.y(); |
| const float rz = coord.z(); |
| float sc = 0.0f; |
| float tc = 0.0f; |
| float ma = 0.0f; |
| float s; |
| float t; |
| |
| switch (face) |
| { |
| case CUBEFACE_NEGATIVE_X: sc = +rz; tc = -ry; ma = -rx; break; |
| case CUBEFACE_POSITIVE_X: sc = -rz; tc = -ry; ma = +rx; break; |
| case CUBEFACE_NEGATIVE_Y: sc = +rx; tc = -rz; ma = -ry; break; |
| case CUBEFACE_POSITIVE_Y: sc = +rx; tc = +rz; ma = +ry; break; |
| case CUBEFACE_NEGATIVE_Z: sc = -rx; tc = -ry; ma = -rz; break; |
| case CUBEFACE_POSITIVE_Z: sc = +rx; tc = -ry; ma = +rz; break; |
| default: |
| DE_ASSERT(DE_FALSE); |
| } |
| |
| // Compute s, t |
| s = ((sc / ma) + 1.0f) / 2.0f; |
| t = ((tc / ma) + 1.0f) / 2.0f; |
| |
| return Vec2(s, t); |
| } |
| |
| CubeFaceFloatCoords getCubeFaceCoords (const Vec3& coords) |
| { |
| const CubeFace face = selectCubeFace(coords); |
| return CubeFaceFloatCoords(face, projectToFace(face, coords)); |
| } |
| |
| // Checks if origCoords.coords is in bounds defined by size; if not, return a CubeFaceIntCoords with face set to the appropriate neighboring face and coords transformed accordingly. |
| // \note If both x and y in origCoords.coords are out of bounds, this returns with face CUBEFACE_LAST, signifying that there is no unique neighboring face. |
| CubeFaceIntCoords remapCubeEdgeCoords (const CubeFaceIntCoords& origCoords, int size) |
| { |
| bool uInBounds = de::inBounds(origCoords.s, 0, size); |
| bool vInBounds = de::inBounds(origCoords.t, 0, size); |
| |
| if (uInBounds && vInBounds) |
| return origCoords; |
| |
| if (!uInBounds && !vInBounds) |
| return CubeFaceIntCoords(CUBEFACE_LAST, -1, -1); |
| |
| IVec2 coords(wrap(Sampler::CLAMP_TO_BORDER, origCoords.s, size), |
| wrap(Sampler::CLAMP_TO_BORDER, origCoords.t, size)); |
| IVec3 canonizedCoords; |
| |
| // Map the uv coordinates to canonized 3d coordinates. |
| |
| switch (origCoords.face) |
| { |
| case CUBEFACE_NEGATIVE_X: canonizedCoords = IVec3(0, size-1-coords.y(), coords.x()); break; |
| case CUBEFACE_POSITIVE_X: canonizedCoords = IVec3(size-1, size-1-coords.y(), size-1-coords.x()); break; |
| case CUBEFACE_NEGATIVE_Y: canonizedCoords = IVec3(coords.x(), 0, size-1-coords.y()); break; |
| case CUBEFACE_POSITIVE_Y: canonizedCoords = IVec3(coords.x(), size-1, coords.y()); break; |
| case CUBEFACE_NEGATIVE_Z: canonizedCoords = IVec3(size-1-coords.x(), size-1-coords.y(), 0); break; |
| case CUBEFACE_POSITIVE_Z: canonizedCoords = IVec3(coords.x(), size-1-coords.y(), size-1); break; |
| default: DE_ASSERT(false); |
| } |
| |
| // Find an appropriate face to re-map the coordinates to. |
| |
| if (canonizedCoords.x() == -1) |
| return CubeFaceIntCoords(CUBEFACE_NEGATIVE_X, IVec2(canonizedCoords.z(), size-1-canonizedCoords.y())); |
| |
| if (canonizedCoords.x() == size) |
| return CubeFaceIntCoords(CUBEFACE_POSITIVE_X, IVec2(size-1-canonizedCoords.z(), size-1-canonizedCoords.y())); |
| |
| if (canonizedCoords.y() == -1) |
| return CubeFaceIntCoords(CUBEFACE_NEGATIVE_Y, IVec2(canonizedCoords.x(), size-1-canonizedCoords.z())); |
| |
| if (canonizedCoords.y() == size) |
| return CubeFaceIntCoords(CUBEFACE_POSITIVE_Y, IVec2(canonizedCoords.x(), canonizedCoords.z())); |
| |
| if (canonizedCoords.z() == -1) |
| return CubeFaceIntCoords(CUBEFACE_NEGATIVE_Z, IVec2(size-1-canonizedCoords.x(), size-1-canonizedCoords.y())); |
| |
| if (canonizedCoords.z() == size) |
| return CubeFaceIntCoords(CUBEFACE_POSITIVE_Z, IVec2(canonizedCoords.x(), size-1-canonizedCoords.y())); |
| |
| DE_ASSERT(false); |
| return CubeFaceIntCoords(CUBEFACE_LAST, IVec2(-1)); |
| } |
| |
| static void getCubeLinearSamples (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, float u, float v, int depth, Vec4 (&dst)[4]) |
| { |
| DE_ASSERT(faceAccesses[0].getWidth() == faceAccesses[0].getHeight()); |
| int size = faceAccesses[0].getWidth(); |
| int x0 = deFloorFloatToInt32(u-0.5f); |
| int x1 = x0+1; |
| int y0 = deFloorFloatToInt32(v-0.5f); |
| int y1 = y0+1; |
| IVec2 baseSampleCoords[4] = |
| { |
| IVec2(x0, y0), |
| IVec2(x1, y0), |
| IVec2(x0, y1), |
| IVec2(x1, y1) |
| }; |
| Vec4 sampleColors[4]; |
| bool hasBothCoordsOutOfBounds[4]; //!< Whether correctCubeFace() returns CUBEFACE_LAST, i.e. both u and v are out of bounds. |
| |
| // Find correct faces and coordinates for out-of-bounds sample coordinates. |
| |
| for (int i = 0; i < 4; i++) |
| { |
| CubeFaceIntCoords coords = remapCubeEdgeCoords(CubeFaceIntCoords(baseFace, baseSampleCoords[i]), size); |
| hasBothCoordsOutOfBounds[i] = coords.face == CUBEFACE_LAST; |
| if (!hasBothCoordsOutOfBounds[i]) |
| sampleColors[i] = lookup(faceAccesses[coords.face], coords.s, coords.t, depth); |
| } |
| |
| // If a sample was out of bounds in both u and v, we get its color from the average of the three other samples. |
| // \note This averaging behavior is not required by the GLES3 spec (though it is recommended). GLES3 spec only |
| // requires that if the three other samples all have the same color, then the doubly-out-of-bounds sample |
| // must have this color as well. |
| |
| { |
| int bothOutOfBoundsNdx = -1; |
| for (int i = 0; i < 4; i++) |
| { |
| if (hasBothCoordsOutOfBounds[i]) |
| { |
| DE_ASSERT(bothOutOfBoundsNdx < 0); // Only one sample can be out of bounds in both u and v. |
| bothOutOfBoundsNdx = i; |
| } |
| } |
| if (bothOutOfBoundsNdx != -1) |
| { |
| sampleColors[bothOutOfBoundsNdx] = Vec4(0.0f); |
| for (int i = 0; i < 4; i++) |
| if (i != bothOutOfBoundsNdx) |
| sampleColors[bothOutOfBoundsNdx] += sampleColors[i]; |
| |
| sampleColors[bothOutOfBoundsNdx] = sampleColors[bothOutOfBoundsNdx] * (1.0f/3.0f); |
| } |
| } |
| |
| for (int i = 0; i < DE_LENGTH_OF_ARRAY(sampleColors); i++) |
| dst[i] = sampleColors[i]; |
| } |
| |
| // \todo [2014-02-19 pyry] Optimize faceAccesses |
| static Vec4 sampleCubeSeamlessLinear (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, const Sampler& sampler, float s, float t, int depth) |
| { |
| DE_ASSERT(faceAccesses[0].getWidth() == faceAccesses[0].getHeight()); |
| |
| int size = faceAccesses[0].getWidth(); |
| // Non-normalized coordinates. |
| float u = s; |
| float v = t; |
| |
| if (sampler.normalizedCoords) |
| { |
| u = unnormalize(sampler.wrapS, s, size); |
| v = unnormalize(sampler.wrapT, t, size); |
| } |
| |
| // Get sample colors. |
| |
| Vec4 sampleColors[4]; |
| getCubeLinearSamples(faceAccesses, baseFace, u, v, depth, sampleColors); |
| |
| // Interpolate. |
| |
| float a = deFloatFrac(u-0.5f); |
| float b = deFloatFrac(v-0.5f); |
| |
| return (sampleColors[0]*(1.0f-a)*(1.0f-b)) + |
| (sampleColors[1]*( a)*(1.0f-b)) + |
| (sampleColors[2]*(1.0f-a)*( b)) + |
| (sampleColors[3]*( a)*( b)); |
| } |
| |
| static Vec4 sampleLevelArrayCubeSeamless (const ConstPixelBufferAccess* const (&faces)[CUBEFACE_LAST], int numLevels, CubeFace face, const Sampler& sampler, float s, float t, int depth, float lod) |
| { |
| bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: |
| return sampleCubeSeamlessNearest(faces[face][0], sampler, s, t, depth); |
| |
| case Sampler::LINEAR: |
| { |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = faces[i][0]; |
| |
| return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, depth); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| if (levelFilter == Sampler::NEAREST) |
| return sampleCubeSeamlessNearest(faces[face][level], sampler, s, t, depth); |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = faces[i][level]; |
| |
| return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, depth); |
| } |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| Vec4 t0; |
| Vec4 t1; |
| |
| if (levelFilter == Sampler::NEAREST) |
| { |
| t0 = sampleCubeSeamlessNearest(faces[face][level0], sampler, s, t, depth); |
| t1 = sampleCubeSeamlessNearest(faces[face][level1], sampler, s, t, depth); |
| } |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; |
| ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| { |
| faceAccesses0[i] = faces[i][level0]; |
| faceAccesses1[i] = faces[i][level1]; |
| } |
| |
| t0 = sampleCubeSeamlessLinear(faceAccesses0, face, sampler, s, t, depth); |
| t1 = sampleCubeSeamlessLinear(faceAccesses1, face, sampler, s, t, depth); |
| } |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| static float sampleCubeSeamlessNearestCompare (const ConstPixelBufferAccess& faceAccess, const Sampler& sampler, float ref, float s, float t, int depth = 0) |
| { |
| Sampler clampingSampler = sampler; |
| clampingSampler.wrapS = Sampler::CLAMP_TO_EDGE; |
| clampingSampler.wrapT = Sampler::CLAMP_TO_EDGE; |
| return faceAccess.sample2DCompare(clampingSampler, Sampler::NEAREST, ref, s, t, IVec3(0, 0, depth)); |
| } |
| |
| static float sampleCubeSeamlessLinearCompare (const ConstPixelBufferAccess (&faceAccesses)[CUBEFACE_LAST], CubeFace baseFace, const Sampler& sampler, float ref, float s, float t) |
| { |
| DE_ASSERT(faceAccesses[0].getWidth() == faceAccesses[0].getHeight()); |
| |
| int size = faceAccesses[0].getWidth(); |
| // Non-normalized coordinates. |
| float u = s; |
| float v = t; |
| |
| if (sampler.normalizedCoords) |
| { |
| u = unnormalize(sampler.wrapS, s, size); |
| v = unnormalize(sampler.wrapT, t, size); |
| } |
| |
| int x0 = deFloorFloatToInt32(u-0.5f); |
| int x1 = x0+1; |
| int y0 = deFloorFloatToInt32(v-0.5f); |
| int y1 = y0+1; |
| IVec2 baseSampleCoords[4] = |
| { |
| IVec2(x0, y0), |
| IVec2(x1, y0), |
| IVec2(x0, y1), |
| IVec2(x1, y1) |
| }; |
| float sampleRes[4]; |
| bool hasBothCoordsOutOfBounds[4]; //!< Whether correctCubeFace() returns CUBEFACE_LAST, i.e. both u and v are out of bounds. |
| |
| // Find correct faces and coordinates for out-of-bounds sample coordinates. |
| |
| for (int i = 0; i < 4; i++) |
| { |
| CubeFaceIntCoords coords = remapCubeEdgeCoords(CubeFaceIntCoords(baseFace, baseSampleCoords[i]), size); |
| hasBothCoordsOutOfBounds[i] = coords.face == CUBEFACE_LAST; |
| |
| if (!hasBothCoordsOutOfBounds[i]) |
| { |
| const bool isFixedPointDepth = isFixedPointDepthTextureFormat(faceAccesses[coords.face].getFormat()); |
| |
| sampleRes[i] = execCompare(faceAccesses[coords.face].getPixel(coords.s, coords.t), sampler.compare, sampler.compareChannel, ref, isFixedPointDepth); |
| } |
| } |
| |
| // If a sample was out of bounds in both u and v, we get its color from the average of the three other samples. |
| // \note This averaging behavior is not required by the GLES3 spec (though it is recommended). GLES3 spec only |
| // requires that if the three other samples all have the same color, then the doubly-out-of-bounds sample |
| // must have this color as well. |
| |
| { |
| int bothOutOfBoundsNdx = -1; |
| for (int i = 0; i < 4; i++) |
| { |
| if (hasBothCoordsOutOfBounds[i]) |
| { |
| DE_ASSERT(bothOutOfBoundsNdx < 0); // Only one sample can be out of bounds in both u and v. |
| bothOutOfBoundsNdx = i; |
| } |
| } |
| if (bothOutOfBoundsNdx != -1) |
| { |
| sampleRes[bothOutOfBoundsNdx] = 0.0f; |
| for (int i = 0; i < 4; i++) |
| if (i != bothOutOfBoundsNdx) |
| sampleRes[bothOutOfBoundsNdx] += sampleRes[i]; |
| |
| sampleRes[bothOutOfBoundsNdx] = sampleRes[bothOutOfBoundsNdx] * (1.0f/3.0f); |
| } |
| } |
| |
| // Interpolate. |
| |
| float a = deFloatFrac(u-0.5f); |
| float b = deFloatFrac(v-0.5f); |
| |
| return (sampleRes[0]*(1.0f-a)*(1.0f-b)) + |
| (sampleRes[1]*( a)*(1.0f-b)) + |
| (sampleRes[2]*(1.0f-a)*( b)) + |
| (sampleRes[3]*( a)*( b)); |
| } |
| |
| static float sampleLevelArrayCubeSeamlessCompare (const ConstPixelBufferAccess* const (&faces)[CUBEFACE_LAST], int numLevels, CubeFace face, const Sampler& sampler, float ref, float s, float t, float lod) |
| { |
| bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: |
| return sampleCubeSeamlessNearestCompare(faces[face][0], sampler, ref, s, t); |
| |
| case Sampler::LINEAR: |
| { |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = faces[i][0]; |
| |
| return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| if (levelFilter == Sampler::NEAREST) |
| return sampleCubeSeamlessNearestCompare(faces[face][level], sampler, ref, s, t); |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = faces[i][level]; |
| |
| return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); |
| } |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| float t0; |
| float t1; |
| |
| if (levelFilter == Sampler::NEAREST) |
| { |
| t0 = sampleCubeSeamlessNearestCompare(faces[face][level0], sampler, ref, s, t); |
| t1 = sampleCubeSeamlessNearestCompare(faces[face][level1], sampler, ref, s, t); |
| } |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; |
| ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| { |
| faceAccesses0[i] = faces[i][level0]; |
| faceAccesses1[i] = faces[i][level1]; |
| } |
| |
| t0 = sampleCubeSeamlessLinearCompare(faceAccesses0, face, sampler, ref, s, t); |
| t1 = sampleCubeSeamlessLinearCompare(faceAccesses1, face, sampler, ref, s, t); |
| } |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| // Cube map array sampling |
| |
| static inline ConstPixelBufferAccess getCubeArrayFaceAccess (const ConstPixelBufferAccess* const levels, int levelNdx, int slice, CubeFace face) |
| { |
| const ConstPixelBufferAccess& level = levels[levelNdx]; |
| const int depth = (slice * 6) + getCubeArrayFaceIndex(face); |
| |
| return getSubregion(level, 0, 0, depth, level.getWidth(), level.getHeight(), 1); |
| } |
| |
| static Vec4 sampleCubeArraySeamless (const ConstPixelBufferAccess* const levels, int numLevels, int slice, CubeFace face, const Sampler& sampler, float s, float t, float lod) |
| { |
| const int faceDepth = (slice * 6) + getCubeArrayFaceIndex(face); |
| const bool magnified = lod <= sampler.lodThreshold; |
| const Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: |
| return sampleCubeSeamlessNearest(levels[0], sampler, s, t, faceDepth); |
| |
| case Sampler::LINEAR: |
| { |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = getCubeArrayFaceAccess(levels, 0, slice, (CubeFace)i); |
| |
| return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, 0); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| if (levelFilter == Sampler::NEAREST) |
| return sampleCubeSeamlessNearest(levels[level], sampler, s, t, faceDepth); |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = getCubeArrayFaceAccess(levels, level, slice, (CubeFace)i); |
| |
| return sampleCubeSeamlessLinear(faceAccesses, face, sampler, s, t, 0); |
| } |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| Vec4 t0; |
| Vec4 t1; |
| |
| if (levelFilter == Sampler::NEAREST) |
| { |
| t0 = sampleCubeSeamlessNearest(levels[level0], sampler, s, t, faceDepth); |
| t1 = sampleCubeSeamlessNearest(levels[level1], sampler, s, t, faceDepth); |
| } |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; |
| ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| { |
| faceAccesses0[i] = getCubeArrayFaceAccess(levels, level0, slice, (CubeFace)i); |
| faceAccesses1[i] = getCubeArrayFaceAccess(levels, level1, slice, (CubeFace)i); |
| } |
| |
| t0 = sampleCubeSeamlessLinear(faceAccesses0, face, sampler, s, t, 0); |
| t1 = sampleCubeSeamlessLinear(faceAccesses1, face, sampler, s, t, 0); |
| } |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return Vec4(0.0f); |
| } |
| } |
| |
| static float sampleCubeArraySeamlessCompare (const ConstPixelBufferAccess* const levels, int numLevels, int slice, CubeFace face, const Sampler& sampler, float ref, float s, float t, float lod) |
| { |
| const int faceDepth = (slice * 6) + getCubeArrayFaceIndex(face); |
| const bool magnified = lod <= sampler.lodThreshold; |
| Sampler::FilterMode filterMode = magnified ? sampler.magFilter : sampler.minFilter; |
| |
| switch (filterMode) |
| { |
| case Sampler::NEAREST: |
| return sampleCubeSeamlessNearestCompare(levels[0], sampler, ref, s, t, faceDepth); |
| |
| case Sampler::LINEAR: |
| { |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = getCubeArrayFaceAccess(levels, 0, slice, (CubeFace)i); |
| |
| return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); |
| } |
| |
| case Sampler::NEAREST_MIPMAP_NEAREST: |
| case Sampler::LINEAR_MIPMAP_NEAREST: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level = deClamp32((int)deFloatCeil(lod + 0.5f) - 1, 0, maxLevel); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_NEAREST) ? Sampler::LINEAR : Sampler::NEAREST; |
| |
| if (levelFilter == Sampler::NEAREST) |
| return sampleCubeSeamlessNearestCompare(levels[level], sampler, ref, s, t, faceDepth); |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = getCubeArrayFaceAccess(levels, level, slice, (CubeFace)i); |
| |
| return sampleCubeSeamlessLinearCompare(faceAccesses, face, sampler, ref, s, t); |
| } |
| } |
| |
| case Sampler::NEAREST_MIPMAP_LINEAR: |
| case Sampler::LINEAR_MIPMAP_LINEAR: |
| { |
| int maxLevel = (int)numLevels-1; |
| int level0 = deClamp32((int)deFloatFloor(lod), 0, maxLevel); |
| int level1 = de::min(maxLevel, level0 + 1); |
| Sampler::FilterMode levelFilter = (filterMode == Sampler::LINEAR_MIPMAP_LINEAR) ? Sampler::LINEAR : Sampler::NEAREST; |
| float f = deFloatFrac(lod); |
| float t0; |
| float t1; |
| |
| if (levelFilter == Sampler::NEAREST) |
| { |
| t0 = sampleCubeSeamlessNearestCompare(levels[level0], sampler, ref, s, t, faceDepth); |
| t1 = sampleCubeSeamlessNearestCompare(levels[level1], sampler, ref, s, t, faceDepth); |
| } |
| else |
| { |
| DE_ASSERT(levelFilter == Sampler::LINEAR); |
| |
| ConstPixelBufferAccess faceAccesses0[CUBEFACE_LAST]; |
| ConstPixelBufferAccess faceAccesses1[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| { |
| faceAccesses0[i] = getCubeArrayFaceAccess(levels, level0, slice, (CubeFace)i); |
| faceAccesses1[i] = getCubeArrayFaceAccess(levels, level1, slice, (CubeFace)i); |
| } |
| |
| t0 = sampleCubeSeamlessLinearCompare(faceAccesses0, face, sampler, ref, s, t); |
| t1 = sampleCubeSeamlessLinearCompare(faceAccesses1, face, sampler, ref, s, t); |
| } |
| |
| return t0*(1.0f - f) + t1*f; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return 0.0f; |
| } |
| } |
| |
| inline int computeMipPyramidLevels (int size) |
| { |
| return deLog2Floor32(size)+1; |
| } |
| |
| inline int computeMipPyramidLevels (int width, int height) |
| { |
| return deLog2Floor32(de::max(width, height))+1; |
| } |
| |
| inline int computeMipPyramidLevels (int width, int height, int depth) |
| { |
| return deLog2Floor32(de::max(width, de::max(height, depth)))+1; |
| } |
| |
| inline int getMipPyramidLevelSize (int baseLevelSize, int levelNdx) |
| { |
| return de::max(baseLevelSize >> levelNdx, 1); |
| } |
| |
| // TextureLevelPyramid |
| |
| TextureLevelPyramid::TextureLevelPyramid (const TextureFormat& format, int numLevels) |
| : m_format (format) |
| , m_data (numLevels) |
| , m_access (numLevels) |
| { |
| } |
| |
| TextureLevelPyramid::TextureLevelPyramid (const TextureLevelPyramid& other) |
| : m_format (other.m_format) |
| , m_data (other.getNumLevels()) |
| , m_access (other.getNumLevels()) |
| { |
| for (int levelNdx = 0; levelNdx < other.getNumLevels(); levelNdx++) |
| { |
| if (!other.isLevelEmpty(levelNdx)) |
| { |
| const tcu::ConstPixelBufferAccess& srcLevel = other.getLevel(levelNdx); |
| |
| m_data[levelNdx] = other.m_data[levelNdx]; |
| m_access[levelNdx] = PixelBufferAccess(srcLevel.getFormat(), srcLevel.getWidth(), srcLevel.getHeight(), srcLevel.getDepth(), m_data[levelNdx].getPtr()); |
| } |
| } |
| } |
| |
| TextureLevelPyramid& TextureLevelPyramid::operator= (const TextureLevelPyramid& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| m_format = other.m_format; |
| m_data.resize(other.getNumLevels()); |
| m_access.resize(other.getNumLevels()); |
| |
| for (int levelNdx = 0; levelNdx < other.getNumLevels(); levelNdx++) |
| { |
| if (!other.isLevelEmpty(levelNdx)) |
| { |
| const tcu::ConstPixelBufferAccess& srcLevel = other.getLevel(levelNdx); |
| |
| m_data[levelNdx] = other.m_data[levelNdx]; |
| m_access[levelNdx] = PixelBufferAccess(srcLevel.getFormat(), srcLevel.getWidth(), srcLevel.getHeight(), srcLevel.getDepth(), m_data[levelNdx].getPtr()); |
| } |
| else if (!isLevelEmpty(levelNdx)) |
| clearLevel(levelNdx); |
| } |
| |
| return *this; |
| } |
| |
| TextureLevelPyramid::~TextureLevelPyramid (void) |
| { |
| } |
| |
| void TextureLevelPyramid::allocLevel (int levelNdx, int width, int height, int depth) |
| { |
| const int size = m_format.getPixelSize()*width*height*depth; |
| |
| DE_ASSERT(isLevelEmpty(levelNdx)); |
| |
| m_data[levelNdx].setStorage(size); |
| m_access[levelNdx] = PixelBufferAccess(m_format, width, height, depth, m_data[levelNdx].getPtr()); |
| } |
| |
| void TextureLevelPyramid::clearLevel (int levelNdx) |
| { |
| DE_ASSERT(!isLevelEmpty(levelNdx)); |
| |
| m_data[levelNdx].clear(); |
| m_access[levelNdx] = PixelBufferAccess(); |
| } |
| |
| // Texture1D |
| |
| Texture1D::Texture1D (const TextureFormat& format, int width) |
| : TextureLevelPyramid (format, computeMipPyramidLevels(width)) |
| , m_width (width) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture1D::Texture1D (const Texture1D& other) |
| : TextureLevelPyramid (other) |
| , m_width (other.m_width) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture1D& Texture1D::operator= (const Texture1D& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| TextureLevelPyramid::operator=(other); |
| |
| m_width = other.m_width; |
| m_view = Texture1DView(getNumLevels(), getLevels()); |
| |
| return *this; |
| } |
| |
| Texture1D::~Texture1D (void) |
| { |
| } |
| |
| void Texture1D::allocLevel (int levelNdx) |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| |
| const int width = getMipPyramidLevelSize(m_width, levelNdx); |
| |
| TextureLevelPyramid::allocLevel(levelNdx, width, 1, 1); |
| } |
| |
| // Texture2D |
| |
| Texture2D::Texture2D (const TextureFormat& format, int width, int height) |
| : TextureLevelPyramid (format, computeMipPyramidLevels(width, height)) |
| , m_width (width) |
| , m_height (height) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture2D::Texture2D (const Texture2D& other) |
| : TextureLevelPyramid (other) |
| , m_width (other.m_width) |
| , m_height (other.m_height) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture2D& Texture2D::operator= (const Texture2D& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| TextureLevelPyramid::operator=(other); |
| |
| m_width = other.m_width; |
| m_height = other.m_height; |
| m_view = Texture2DView(getNumLevels(), getLevels()); |
| |
| return *this; |
| } |
| |
| Texture2D::~Texture2D (void) |
| { |
| } |
| |
| void Texture2D::allocLevel (int levelNdx) |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| |
| const int width = getMipPyramidLevelSize(m_width, levelNdx); |
| const int height = getMipPyramidLevelSize(m_height, levelNdx); |
| |
| TextureLevelPyramid::allocLevel(levelNdx, width, height, 1); |
| } |
| |
| // TextureCubeView |
| |
| TextureCubeView::TextureCubeView (void) |
| : m_numLevels(0) |
| { |
| for (int ndx = 0; ndx < CUBEFACE_LAST; ndx++) |
| m_levels[ndx] = DE_NULL; |
| } |
| |
| TextureCubeView::TextureCubeView (int numLevels, const ConstPixelBufferAccess* const (&levels) [CUBEFACE_LAST]) |
| : m_numLevels(numLevels) |
| { |
| for (int ndx = 0; ndx < CUBEFACE_LAST; ndx++) |
| m_levels[ndx] = levels[ndx]; |
| } |
| |
| tcu::Vec4 TextureCubeView::sample (const Sampler& sampler, float s, float t, float r, float lod) const |
| { |
| DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); |
| |
| // Computes (face, s, t). |
| const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); |
| if (sampler.seamlessCubeMap) |
| return sampleLevelArrayCubeSeamless(m_levels, m_numLevels, coords.face, sampler, coords.s, coords.t, 0 /* depth */, lod); |
| else |
| return sampleLevelArray2D(m_levels[coords.face], m_numLevels, sampler, coords.s, coords.t, 0 /* depth */, lod); |
| } |
| |
| float TextureCubeView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const |
| { |
| DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); |
| |
| // Computes (face, s, t). |
| const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); |
| if (sampler.seamlessCubeMap) |
| return sampleLevelArrayCubeSeamlessCompare(m_levels, m_numLevels, coords.face, sampler, ref, coords.s, coords.t, lod); |
| else |
| return sampleLevelArray2DCompare(m_levels[coords.face], m_numLevels, sampler, ref, coords.s, coords.t, lod, IVec3(0, 0, 0)); |
| } |
| |
| Vec4 TextureCubeView::gather (const Sampler& sampler, float s, float t, float r, int componentNdx) const |
| { |
| DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); |
| |
| ConstPixelBufferAccess faceAccesses[CUBEFACE_LAST]; |
| for (int i = 0; i < (int)CUBEFACE_LAST; i++) |
| faceAccesses[i] = m_levels[i][0]; |
| |
| const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); |
| const int size = faceAccesses[0].getWidth(); |
| // Non-normalized coordinates. |
| float u = coords.s; |
| float v = coords.t; |
| |
| if (sampler.normalizedCoords) |
| { |
| u = unnormalize(sampler.wrapS, coords.s, size); |
| v = unnormalize(sampler.wrapT, coords.t, size); |
| } |
| |
| Vec4 sampleColors[4]; |
| getCubeLinearSamples(faceAccesses, coords.face, u, v, 0, sampleColors); |
| |
| const int sampleIndices[4] = { 2, 3, 1, 0 }; // \note Gather returns the samples in a non-obvious order. |
| Vec4 result; |
| for (int i = 0; i < 4; i++) |
| result[i] = sampleColors[sampleIndices[i]][componentNdx]; |
| |
| return result; |
| } |
| |
| Vec4 TextureCubeView::gatherCompare (const Sampler& sampler, float ref, float s, float t, float r) const |
| { |
| DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); |
| DE_ASSERT(m_levels[0][0].getFormat().order == TextureFormat::D || m_levels[0][0].getFormat().order == TextureFormat::DS); |
| DE_ASSERT(sampler.compareChannel == 0); |
| |
| Sampler noCompareSampler = sampler; |
| noCompareSampler.compare = Sampler::COMPAREMODE_NONE; |
| |
| const Vec4 gathered = gather(noCompareSampler, s, t, r, 0 /* component 0: depth */); |
| const bool isFixedPoint = isFixedPointDepthTextureFormat(m_levels[0][0].getFormat()); |
| Vec4 result; |
| for (int i = 0; i < 4; i++) |
| result[i] = execCompare(gathered, sampler.compare, i, ref, isFixedPoint); |
| |
| return result; |
| } |
| |
| // TextureCube |
| |
| TextureCube::TextureCube (const TextureFormat& format, int size) |
| : m_format (format) |
| , m_size (size) |
| { |
| const int numLevels = computeMipPyramidLevels(m_size); |
| const ConstPixelBufferAccess* levels[CUBEFACE_LAST]; |
| |
| for (int face = 0; face < CUBEFACE_LAST; face++) |
| { |
| m_data[face].resize(numLevels); |
| m_access[face].resize(numLevels); |
| levels[face] = &m_access[face][0]; |
| } |
| |
| m_view = TextureCubeView(numLevels, levels); |
| } |
| |
| TextureCube::TextureCube (const TextureCube& other) |
| : m_format (other.m_format) |
| , m_size (other.m_size) |
| { |
| const int numLevels = computeMipPyramidLevels(m_size); |
| const ConstPixelBufferAccess* levels[CUBEFACE_LAST]; |
| |
| for (int face = 0; face < CUBEFACE_LAST; face++) |
| { |
| m_data[face].resize(numLevels); |
| m_access[face].resize(numLevels); |
| levels[face] = &m_access[face][0]; |
| } |
| |
| m_view = TextureCubeView(numLevels, levels); |
| |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| for (int face = 0; face < CUBEFACE_LAST; face++) |
| { |
| if (!other.isLevelEmpty((CubeFace)face, levelNdx)) |
| { |
| allocLevel((CubeFace)face, levelNdx); |
| copy(getLevelFace(levelNdx, (CubeFace)face), |
| other.getLevelFace(levelNdx, (CubeFace)face)); |
| } |
| } |
| } |
| } |
| |
| TextureCube& TextureCube::operator= (const TextureCube& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| const int numLevels = computeMipPyramidLevels(other.m_size); |
| const ConstPixelBufferAccess* levels[CUBEFACE_LAST]; |
| |
| for (int face = 0; face < CUBEFACE_LAST; face++) |
| { |
| m_data[face].resize(numLevels); |
| m_access[face].resize(numLevels); |
| levels[face] = &m_access[face][0]; |
| } |
| |
| m_format = other.m_format; |
| m_size = other.m_size; |
| m_view = TextureCubeView(numLevels, levels); |
| |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| for (int face = 0; face < CUBEFACE_LAST; face++) |
| { |
| if (!isLevelEmpty((CubeFace)face, levelNdx)) |
| clearLevel((CubeFace)face, levelNdx); |
| |
| if (!other.isLevelEmpty((CubeFace)face, levelNdx)) |
| { |
| allocLevel((CubeFace)face, levelNdx); |
| copy(getLevelFace(levelNdx, (CubeFace)face), |
| other.getLevelFace(levelNdx, (CubeFace)face)); |
| } |
| } |
| } |
| |
| return *this; |
| } |
| |
| TextureCube::~TextureCube (void) |
| { |
| } |
| |
| void TextureCube::allocLevel (tcu::CubeFace face, int levelNdx) |
| { |
| const int size = getMipPyramidLevelSize(m_size, levelNdx); |
| const int dataSize = m_format.getPixelSize()*size*size; |
| DE_ASSERT(isLevelEmpty(face, levelNdx)); |
| |
| m_data[face][levelNdx].setStorage(dataSize); |
| m_access[face][levelNdx] = PixelBufferAccess(m_format, size, size, 1, m_data[face][levelNdx].getPtr()); |
| } |
| |
| void TextureCube::clearLevel (tcu::CubeFace face, int levelNdx) |
| { |
| DE_ASSERT(!isLevelEmpty(face, levelNdx)); |
| m_data[face][levelNdx].clear(); |
| m_access[face][levelNdx] = PixelBufferAccess(); |
| } |
| |
| // Texture1DArrayView |
| |
| Texture1DArrayView::Texture1DArrayView (int numLevels, const ConstPixelBufferAccess* levels) |
| : m_numLevels (numLevels) |
| , m_levels (levels) |
| { |
| } |
| |
| inline int Texture1DArrayView::selectLayer (float r) const |
| { |
| DE_ASSERT(m_numLevels > 0 && m_levels); |
| return de::clamp(deFloorFloatToInt32(r + 0.5f), 0, m_levels[0].getHeight()-1); |
| } |
| |
| Vec4 Texture1DArrayView::sample (const Sampler& sampler, float s, float t, float lod) const |
| { |
| return sampleLevelArray1D(m_levels, m_numLevels, sampler, s, selectLayer(t), lod); |
| } |
| |
| Vec4 Texture1DArrayView::sampleOffset (const Sampler& sampler, float s, float t, float lod, deInt32 offset) const |
| { |
| return sampleLevelArray1DOffset(m_levels, m_numLevels, sampler, s, lod, IVec2(offset, selectLayer(t))); |
| } |
| |
| float Texture1DArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const |
| { |
| return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(0, selectLayer(t))); |
| } |
| |
| float Texture1DArrayView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, deInt32 offset) const |
| { |
| return sampleLevelArray1DCompare(m_levels, m_numLevels, sampler, ref, s, lod, IVec2(offset, selectLayer(t))); |
| } |
| |
| // Texture2DArrayView |
| |
| Texture2DArrayView::Texture2DArrayView (int numLevels, const ConstPixelBufferAccess* levels) |
| : m_numLevels (numLevels) |
| , m_levels (levels) |
| { |
| } |
| |
| inline int Texture2DArrayView::selectLayer (float r) const |
| { |
| DE_ASSERT(m_numLevels > 0 && m_levels); |
| return de::clamp(deFloorFloatToInt32(r + 0.5f), 0, m_levels[0].getDepth()-1); |
| } |
| |
| Vec4 Texture2DArrayView::sample (const Sampler& sampler, float s, float t, float r, float lod) const |
| { |
| return sampleLevelArray2D(m_levels, m_numLevels, sampler, s, t, selectLayer(r), lod); |
| } |
| |
| float Texture2DArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float lod) const |
| { |
| return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(0, 0, selectLayer(r))); |
| } |
| |
| Vec4 Texture2DArrayView::sampleOffset (const Sampler& sampler, float s, float t, float r, float lod, const IVec2& offset) const |
| { |
| return sampleLevelArray2DOffset(m_levels, m_numLevels, sampler, s, t, lod, IVec3(offset.x(), offset.y(), selectLayer(r))); |
| } |
| |
| float Texture2DArrayView::sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float r, float lod, const IVec2& offset) const |
| { |
| return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, s, t, lod, IVec3(offset.x(), offset.y(), selectLayer(r))); |
| } |
| |
| Vec4 Texture2DArrayView::gatherOffsets (const Sampler& sampler, float s, float t, float r, int componentNdx, const IVec2 (&offsets)[4]) const |
| { |
| return gatherArray2DOffsets(m_levels[0], sampler, s, t, selectLayer(r), componentNdx, offsets); |
| } |
| |
| Vec4 Texture2DArrayView::gatherOffsetsCompare (const Sampler& sampler, float ref, float s, float t, float r, const IVec2 (&offsets)[4]) const |
| { |
| return gatherArray2DOffsetsCompare(m_levels[0], sampler, ref, s, t, selectLayer(r), offsets); |
| } |
| |
| // Texture1DArray |
| |
| Texture1DArray::Texture1DArray (const TextureFormat& format, int width, int numLayers) |
| : TextureLevelPyramid (format, computeMipPyramidLevels(width)) |
| , m_width (width) |
| , m_numLayers (numLayers) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture1DArray::Texture1DArray (const Texture1DArray& other) |
| : TextureLevelPyramid (other) |
| , m_width (other.m_width) |
| , m_numLayers (other.m_numLayers) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture1DArray& Texture1DArray::operator= (const Texture1DArray& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| TextureLevelPyramid::operator=(other); |
| |
| m_width = other.m_width; |
| m_numLayers = other.m_numLayers; |
| m_view = Texture1DArrayView(getNumLevels(), getLevels()); |
| |
| return *this; |
| } |
| |
| Texture1DArray::~Texture1DArray (void) |
| { |
| } |
| |
| void Texture1DArray::allocLevel (int levelNdx) |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| |
| const int width = getMipPyramidLevelSize(m_width, levelNdx); |
| |
| TextureLevelPyramid::allocLevel(levelNdx, width, m_numLayers, 1); |
| } |
| |
| // Texture2DArray |
| |
| Texture2DArray::Texture2DArray (const TextureFormat& format, int width, int height, int numLayers) |
| : TextureLevelPyramid (format, computeMipPyramidLevels(width, height)) |
| , m_width (width) |
| , m_height (height) |
| , m_numLayers (numLayers) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture2DArray::Texture2DArray (const Texture2DArray& other) |
| : TextureLevelPyramid (other) |
| , m_width (other.m_width) |
| , m_height (other.m_height) |
| , m_numLayers (other.m_numLayers) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture2DArray& Texture2DArray::operator= (const Texture2DArray& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| TextureLevelPyramid::operator=(other); |
| |
| m_width = other.m_width; |
| m_height = other.m_height; |
| m_numLayers = other.m_numLayers; |
| m_view = Texture2DArrayView(getNumLevels(), getLevels()); |
| |
| return *this; |
| } |
| |
| Texture2DArray::~Texture2DArray (void) |
| { |
| } |
| |
| void Texture2DArray::allocLevel (int levelNdx) |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| |
| const int width = getMipPyramidLevelSize(m_width, levelNdx); |
| const int height = getMipPyramidLevelSize(m_height, levelNdx); |
| |
| TextureLevelPyramid::allocLevel(levelNdx, width, height, m_numLayers); |
| } |
| |
| // Texture3DView |
| |
| Texture3DView::Texture3DView (int numLevels, const ConstPixelBufferAccess* levels) |
| : m_numLevels (numLevels) |
| , m_levels (levels) |
| { |
| } |
| |
| // Texture3D |
| |
| Texture3D::Texture3D (const TextureFormat& format, int width, int height, int depth) |
| : TextureLevelPyramid (format, computeMipPyramidLevels(width, height, depth)) |
| , m_width (width) |
| , m_height (height) |
| , m_depth (depth) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture3D::Texture3D (const Texture3D& other) |
| : TextureLevelPyramid (other) |
| , m_width (other.m_width) |
| , m_height (other.m_height) |
| , m_depth (other.m_depth) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| } |
| |
| Texture3D& Texture3D::operator= (const Texture3D& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| TextureLevelPyramid::operator=(other); |
| |
| m_width = other.m_width; |
| m_height = other.m_height; |
| m_depth = other.m_depth; |
| m_view = Texture3DView(getNumLevels(), getLevels()); |
| |
| return *this; |
| } |
| |
| Texture3D::~Texture3D (void) |
| { |
| } |
| |
| void Texture3D::allocLevel (int levelNdx) |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| |
| const int width = getMipPyramidLevelSize(m_width, levelNdx); |
| const int height = getMipPyramidLevelSize(m_height, levelNdx); |
| const int depth = getMipPyramidLevelSize(m_depth, levelNdx); |
| |
| TextureLevelPyramid::allocLevel(levelNdx, width, height, depth); |
| } |
| |
| // TextureCubeArrayView |
| |
| TextureCubeArrayView::TextureCubeArrayView (int numLevels, const ConstPixelBufferAccess* levels) |
| : m_numLevels (numLevels) |
| , m_levels (levels) |
| { |
| } |
| |
| inline int TextureCubeArrayView::selectLayer (float q) const |
| { |
| DE_ASSERT(m_numLevels > 0 && m_levels); |
| DE_ASSERT((m_levels[0].getDepth() % 6) == 0); |
| |
| return de::clamp(deFloorFloatToInt32(q + 0.5f), 0, (m_levels[0].getDepth() / 6)-1); |
| } |
| |
| tcu::Vec4 TextureCubeArrayView::sample (const Sampler& sampler, float s, float t, float r, float q, float lod) const |
| { |
| const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); |
| const int layer = selectLayer(q); |
| const int faceDepth = (layer * 6) + getCubeArrayFaceIndex(coords.face); |
| |
| DE_ASSERT(sampler.compare == Sampler::COMPAREMODE_NONE); |
| |
| if (sampler.seamlessCubeMap) |
| return sampleCubeArraySeamless(m_levels, m_numLevels, layer, coords.face, sampler, coords.s, coords.t, lod); |
| else |
| return sampleLevelArray2D(m_levels, m_numLevels, sampler, coords.s, coords.t, faceDepth, lod); |
| } |
| |
| float TextureCubeArrayView::sampleCompare (const Sampler& sampler, float ref, float s, float t, float r, float q, float lod) const |
| { |
| const CubeFaceFloatCoords coords = getCubeFaceCoords(Vec3(s, t, r)); |
| const int layer = selectLayer(q); |
| const int faceDepth = (layer * 6) + getCubeArrayFaceIndex(coords.face); |
| |
| DE_ASSERT(sampler.compare != Sampler::COMPAREMODE_NONE); |
| |
| if (sampler.seamlessCubeMap) |
| return sampleCubeArraySeamlessCompare(m_levels, m_numLevels, layer, coords.face, sampler, ref, coords.s, coords.t, lod); |
| else |
| return sampleLevelArray2DCompare(m_levels, m_numLevels, sampler, ref, coords.s, coords.t, lod, IVec3(0, 0, faceDepth)); |
| } |
| |
| // TextureCubeArray |
| |
| TextureCubeArray::TextureCubeArray (const TextureFormat& format, int size, int depth) |
| : TextureLevelPyramid (format, computeMipPyramidLevels(size)) |
| , m_size (size) |
| , m_depth (depth) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| DE_ASSERT(m_depth % 6 == 0); |
| } |
| |
| TextureCubeArray::TextureCubeArray (const TextureCubeArray& other) |
| : TextureLevelPyramid (other) |
| , m_size (other.m_size) |
| , m_depth (other.m_depth) |
| , m_view (getNumLevels(), getLevels()) |
| { |
| DE_ASSERT(m_depth % 6 == 0); |
| } |
| |
| TextureCubeArray& TextureCubeArray::operator= (const TextureCubeArray& other) |
| { |
| if (this == &other) |
| return *this; |
| |
| TextureLevelPyramid::operator=(other); |
| |
| m_size = other.m_size; |
| m_depth = other.m_depth; |
| m_view = TextureCubeArrayView(getNumLevels(), getLevels()); |
| |
| DE_ASSERT(m_depth % 6 == 0); |
| |
| return *this; |
| } |
| |
| TextureCubeArray::~TextureCubeArray (void) |
| { |
| } |
| |
| void TextureCubeArray::allocLevel (int levelNdx) |
| { |
| DE_ASSERT(de::inBounds(levelNdx, 0, getNumLevels())); |
| |
| const int size = getMipPyramidLevelSize(m_size, levelNdx); |
| |
| TextureLevelPyramid::allocLevel(levelNdx, size, size, m_depth); |
| } |
| |
| std::ostream& operator<< (std::ostream& str, TextureFormat::ChannelOrder order) |
| { |
| const char* const orderStrings[] = |
| { |
| "R", |
| "A", |
| "I", |
| "L", |
| "LA", |
| "RG", |
| "RA", |
| "RGB", |
| "RGBA", |
| "ARGB", |
| "BGR", |
| "BGRA", |
| |
| "sR", |
| "sRG", |
| "sRGB", |
| "sRGBA", |
| "sBGR", |
| "sBGRA", |
| |
| "D", |
| "S", |
| "DS" |
| }; |
| |
| return str << de::getSizedArrayElement<TextureFormat::CHANNELORDER_LAST>(orderStrings, order); |
| } |
| |
| std::ostream& operator<< (std::ostream& str, TextureFormat::ChannelType type) |
| { |
| const char* const typeStrings[] = |
| { |
| "SNORM_INT8", |
| "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", |
| "UNSIGNED_INT8", |
| "UNSIGNED_INT16", |
| "UNSIGNED_INT24", |
| "UNSIGNED_INT32", |
| "HALF_FLOAT", |
| "FLOAT", |
| "FLOAT64", |
| "FLOAT_UNSIGNED_INT_24_8_REV" |
| }; |
| |
| return str << de::getSizedArrayElement<TextureFormat::CHANNELTYPE_LAST>(typeStrings, type); |
| } |
| |
| std::ostream& operator<< (std::ostream& str, CubeFace face) |
| { |
| switch (face) |
| { |
| case CUBEFACE_NEGATIVE_X: return str << "CUBEFACE_NEGATIVE_X"; |
| case CUBEFACE_POSITIVE_X: return str << "CUBEFACE_POSITIVE_X"; |
| case CUBEFACE_NEGATIVE_Y: return str << "CUBEFACE_NEGATIVE_Y"; |
| case CUBEFACE_POSITIVE_Y: return str << "CUBEFACE_POSITIVE_Y"; |
| case CUBEFACE_NEGATIVE_Z: return str << "CUBEFACE_NEGATIVE_Z"; |
| case CUBEFACE_POSITIVE_Z: return str << "CUBEFACE_POSITIVE_Z"; |
| case CUBEFACE_LAST: return str << "CUBEFACE_LAST"; |
| default: return str << "UNKNOWN(" << (int)face << ")"; |
| } |
| } |
| |
| std::ostream& operator<< (std::ostream& str, TextureFormat format) |
| { |
| return str << format.order << ", " << format.type << ""; |
| } |
| |
| std::ostream& operator<< (std::ostream& str, const ConstPixelBufferAccess& access) |
| { |
| return str << "format = (" << access.getFormat() << "), size = " |
| << access.getWidth() << " x " << access.getHeight() << " x " << access.getDepth() |
| << ", pitch = " << access.getRowPitch() << " / " << access.getSlicePitch(); |
| } |
| |
| } // tcu |