diff options
Diffstat (limited to 'src/gallium/drivers/swr/rasterizer/memory/Convert.h')
| -rw-r--r-- | src/gallium/drivers/swr/rasterizer/memory/Convert.h | 698 |
1 files changed, 698 insertions, 0 deletions
diff --git a/src/gallium/drivers/swr/rasterizer/memory/Convert.h b/src/gallium/drivers/swr/rasterizer/memory/Convert.h new file mode 100644 index 00000000000..0f9e0ad4bd8 --- /dev/null +++ b/src/gallium/drivers/swr/rasterizer/memory/Convert.h @@ -0,0 +1,698 @@ +/**************************************************************************** +* Copyright (C) 2014-2015 Intel Corporation. All Rights Reserved. +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice (including the next +* paragraph) shall be included in all copies or substantial portions of the +* Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +* IN THE SOFTWARE. +* +* @file Convert.h +* +* @brief Conversion utility functions +* +******************************************************************************/ +#pragma once + +#if defined(_WIN32) +// disable "potential divide by 0" +#pragma warning(disable: 4723) +#endif + +////////////////////////////////////////////////////////////////////////// +/// @brief Convert an IEEE 754 16-bit float to an 32-bit single precision +/// float +/// @param val - 16-bit float +/// @todo Maybe move this outside of this file into a header? +static float ConvertSmallFloatTo32(UINT val) +{ + UINT result; + if ((val & 0x7fff) == 0) + { + result = ((uint32_t)(val & 0x8000)) << 16; + } + else if ((val & 0x7c00) == 0x7c00) + { + result = ((val & 0x3ff) == 0) ? 0x7f800000 : 0x7fc00000; + result |= ((uint32_t)val & 0x8000) << 16; + } + else + { + uint32_t sign = (val & 0x8000) << 16; + uint32_t mant = (val & 0x3ff) << 13; + uint32_t exp = (val >> 10) & 0x1f; + if ((exp == 0) && (mant != 0)) // Adjust exponent and mantissa for denormals + { + mant <<= 1; + while (mant < (0x400 << 13)) + { + exp--; + mant <<= 1; + } + mant &= (0x3ff << 13); + } + exp = ((exp - 15 + 127) & 0xff) << 23; + result = sign | exp | mant; + } + + return *(float*)&result; +} + +////////////////////////////////////////////////////////////////////////// +/// @brief Convert an IEEE 754 32-bit single precision float to an +/// unsigned small float with 5 exponent bits and a variable +/// number of mantissa bits. +/// @param val - 32-bit float +/// @todo Maybe move this outside of this file into a header? +template<UINT numMantissaBits> +static UINT Convert32ToSmallFloat(float val) +{ + uint32_t sign, exp, mant; + uint32_t roundBits; + + // Extract the sign, exponent, and mantissa + UINT uf = *(UINT*)&val; + + sign = (uf & 0x80000000) >> 31; + exp = (uf & 0x7F800000) >> 23; + mant = uf & 0x007FFFFF; + + // 10/11 bit floats are unsigned. Negative values are clamped to 0. + if (sign != 0) + { + exp = mant = 0; + } + // Check for out of range + else if ((exp == 0xFF) && (mant != 0)) // NaN + { + exp = 0x1F; + mant = 1 << numMantissaBits; + } + else if ((exp == 0xFF) && (mant == 0)) // INF + { + exp = 0x1F; + mant = 0; + } + else if (exp > (0x70 + 0x1E)) // Too big to represent + { + exp = 0x1Eu; + mant = (1 << numMantissaBits) - 1; // 0x3F for 6 bit mantissa. + } + else if ((exp <= 0x70) && (exp >= 0x66)) // It's a denorm + { + mant |= 0x00800000; + for (; exp <= 0x70; mant >>= 1, exp++) + ; + exp = 0; + mant = mant >> (23 - numMantissaBits); + } + else if (exp < 0x66) // Too small to represent -> Zero + { + exp = 0; + mant = 0; + } + else + { + // Saves bits that will be shifted off for rounding + roundBits = mant & 0x1FFFu; + // convert exponent and mantissa to 16 bit format + exp = exp - 0x70u; + mant = mant >> (23 - numMantissaBits); + + // Essentially RTZ, but round up if off by only 1 lsb + if (roundBits == 0x1FFFu) + { + mant++; + // check for overflow + if ((mant & (0x3 << numMantissaBits)) != 0) // 0x60 = 0x3 << (num Mantissa Bits) + exp++; + // make sure only the needed bits are used + mant &= (1 << numMantissaBits) - 1; + } + } + + UINT tmpVal = (exp << numMantissaBits) | mant; + return tmpVal; +} + +#if KNOB_ARCH == KNOB_ARCH_AVX +////////////////////////////////////////////////////////////////////////// +/// @brief Convert an IEEE 754 32-bit single precision float to an +/// 16 bit float with 5 exponent bits and a variable +/// number of mantissa bits. +/// @param val - 32-bit float +/// @todo Maybe move this outside of this file into a header? +static uint16_t Convert32To16Float(float val) +{ + uint32_t sign, exp, mant; + uint32_t roundBits; + + // Extract the sign, exponent, and mantissa + uint32_t uf = *(uint32_t*)&val; + sign = (uf & 0x80000000) >> 31; + exp = (uf & 0x7F800000) >> 23; + mant = uf & 0x007FFFFF; + + // Check for out of range + if (std::isnan(val)) + { + exp = 0x1F; + mant = 0x200; + sign = 1; // set the sign bit for NANs + } + else if (std::isinf(val)) + { + exp = 0x1f; + mant = 0x0; + } + else if (exp > (0x70 + 0x1E)) // Too big to represent -> max representable value + { + exp = 0x1E; + mant = 0x3FF; + } + else if ((exp <= 0x70) && (exp >= 0x66)) // It's a denorm + { + mant |= 0x00800000; + for (; exp <= 0x70; mant >>= 1, exp++) + ; + exp = 0; + mant = mant >> 13; + } + else if (exp < 0x66) // Too small to represent -> Zero + { + exp = 0; + mant = 0; + } + else + { + // Saves bits that will be shifted off for rounding + roundBits = mant & 0x1FFFu; + // convert exponent and mantissa to 16 bit format + exp = exp - 0x70; + mant = mant >> 13; + + // Essentially RTZ, but round up if off by only 1 lsb + if (roundBits == 0x1FFFu) + { + mant++; + // check for overflow + if ((mant & 0xC00u) != 0) + exp++; + // make sure only the needed bits are used + mant &= 0x3FF; + } + } + + uint32_t tmpVal = (sign << 15) | (exp << 10) | mant; + return (uint16_t)tmpVal; +} +#endif + +////////////////////////////////////////////////////////////////////////// +/// @brief Retrieve color from hot tile source which is always float. +/// @param pDstPixel - Pointer to destination pixel. +/// @param srcPixel - Pointer to source pixel (pre-swizzled according to dest). +template<SWR_FORMAT DstFormat> +static void ConvertPixelFromFloat( + BYTE* pDstPixel, + const float srcPixel[4]) +{ + UINT outColor[4]; // typeless bits + + // Store component + for (UINT comp = 0; comp < FormatTraits<DstFormat>::numComps; ++comp) + { + SWR_TYPE type = FormatTraits<DstFormat>::GetType(comp); + + float src = srcPixel[comp]; + + switch (type) + { + case SWR_TYPE_UNORM: + { + // Force NaN to 0. IEEE standard, comparisons involving NaN always evaluate to false. + src = (src != src) ? 0.0f : src; + + // Clamp [0, 1] + src = std::max(src, 0.0f); + src = std::min(src, 1.0f); + + // SRGB + if (FormatTraits<DstFormat>::isSRGB && comp != 3) + { + src = (src <= 0.0031308f) ? (12.92f * src) : (1.055f * powf(src, (1.0f / 2.4f)) - 0.055f); + } + + // Float scale to integer scale. + UINT scale = (1 << FormatTraits<DstFormat>::GetBPC(comp)) - 1; + src = (float)scale * src; + src = roundf(src); + outColor[comp] = (UINT)src; // Drop fractional part. + break; + } + case SWR_TYPE_SNORM: + { + SWR_ASSERT(!FormatTraits<DstFormat>::isSRGB); + + // Force NaN to 0. IEEE standard, comparisons involving NaN always evaluate to false. + src = (src != src) ? 0.0f : src; + + // Clamp [-1, 1] + src = std::max(src, -1.0f); + src = std::min(src, 1.0f); + + // Float scale to integer scale. + UINT scale = (1 << (FormatTraits<DstFormat>::GetBPC(comp) - 1)) - 1; + src = (float)scale * src; + + // Round + src += (src >= 0) ? 0.5f : -0.5f; + + INT out = (INT)src; + + outColor[comp] = *(UINT*)&out; + + break; + } + case SWR_TYPE_UINT: + { + ///@note The *(UINT*)& is currently necessary as the hot tile appears to always be float. + // However, the number in the hot tile should be unsigned integer. So doing this + // to preserve bits intead of doing a float -> integer conversion. + if (FormatTraits<DstFormat>::GetBPC(comp) == 32) + { + outColor[comp] = *(UINT*)&src; + } + else + { + outColor[comp] = *(UINT*)&src; + UINT max = (1 << FormatTraits<DstFormat>::GetBPC(comp)) - 1; // 2^numBits - 1 + + outColor[comp] = std::min(max, outColor[comp]); + } + break; + } + case SWR_TYPE_SINT: + { + if (FormatTraits<DstFormat>::GetBPC(comp) == 32) + { + outColor[comp] = *(UINT*)&src; + } + else + { + INT out = *(INT*)&src; // Hot tile format is SINT? + INT max = (1 << (FormatTraits<DstFormat>::GetBPC(comp) - 1)) - 1; + INT min = -1 - max; + + ///@note The output is unsigned integer (bag of bits) and so performing + // the clamping here based on range of output component. Also, manually adding + // the sign bit in the appropriate spot. Maybe a better way? + out = std::max(out, min); + out = std::min(out, max); + + outColor[comp] = *(UINT*)&out; + } + break; + } + case SWR_TYPE_FLOAT: + { + if (FormatTraits<DstFormat>::GetBPC(comp) == 16) + { + // Convert from 32-bit float to 16-bit float using _mm_cvtps_ph + // @todo 16bit float instruction support is orthogonal to avx support. need to + // add check for F16C support instead. +#if KNOB_ARCH == KNOB_ARCH_AVX2 + __m128 src128 = _mm_set1_ps(src); + __m128i srci128 = _mm_cvtps_ph(src128, _MM_FROUND_TRUNC); + UINT value = _mm_extract_epi16(srci128, 0); +#else + UINT value = Convert32To16Float(src); +#endif + + outColor[comp] = value; + } + else if (FormatTraits<DstFormat>::GetBPC(comp) == 11) + { + outColor[comp] = Convert32ToSmallFloat<6>(src); + } + else if (FormatTraits<DstFormat>::GetBPC(comp) == 10) + { + outColor[comp] = Convert32ToSmallFloat<5>(src); + } + else + { + outColor[comp] = *(UINT*)&src; + } + + break; + } + default: + SWR_ASSERT(0); + break; + } + } + + typename FormatTraits<DstFormat>::FormatT* pPixel = (typename FormatTraits<DstFormat>::FormatT*)pDstPixel; + + switch (FormatTraits<DstFormat>::numComps) + { + case 4: + pPixel->a = outColor[3]; + case 3: + pPixel->b = outColor[2]; + case 2: + pPixel->g = outColor[1]; + case 1: + pPixel->r = outColor[0]; + break; + default: + SWR_ASSERT(0); + } +} + +////////////////////////////////////////////////////////////////////////// +/// @brief Convert pixel in any format to float32 +/// @param pDstPixel - Pointer to destination pixel. +/// @param srcPixel - Pointer to source pixel +template<SWR_FORMAT SrcFormat> +INLINE static void ConvertPixelToFloat( + float dstPixel[4], + const BYTE* pSrc) +{ + UINT srcColor[4]; // typeless bits + + // unpack src pixel + typename FormatTraits<SrcFormat>::FormatT* pPixel = (typename FormatTraits<SrcFormat>::FormatT*)pSrc; + + // apply format defaults + for (uint32_t comp = 0; comp < 4; ++comp) + { + uint32_t def = FormatTraits<SrcFormat>::GetDefault(comp); + dstPixel[comp] = *(float*)&def; + } + + // load format data + switch (FormatTraits<SrcFormat>::numComps) + { + case 4: + srcColor[3] = pPixel->a; + case 3: + srcColor[2] = pPixel->b; + case 2: + srcColor[1] = pPixel->g; + case 1: + srcColor[0] = pPixel->r; + break; + default: + SWR_ASSERT(0); + } + + // Convert components + for (UINT comp = 0; comp < FormatTraits<SrcFormat>::numComps; ++comp) + { + SWR_TYPE type = FormatTraits<SrcFormat>::GetType(comp); + + UINT src = srcColor[comp]; + + switch (type) + { + case SWR_TYPE_UNORM: + { + float dst; + if (FormatTraits<SrcFormat>::isSRGB && comp != 3) + { + dst = *(float*)&srgb8Table[src]; + } + else + { + // component sizes > 16 must use fp divide to maintain ulp requirements + if (FormatTraits<SrcFormat>::GetBPC(comp) > 16) + { + dst = (float)src / (float)((1 << FormatTraits<SrcFormat>::GetBPC(comp)) - 1); + } + else + { + const float scale = (1.0f / (float)((1 << FormatTraits<SrcFormat>::GetBPC(comp)) - 1)); + dst = (float)src * scale; + } + } + dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = dst; + break; + } + case SWR_TYPE_SNORM: + { + SWR_ASSERT(!FormatTraits<SrcFormat>::isSRGB); + + float dst; + if (src == 0x10) + { + dst = -1.0f; + } + else + { + switch (FormatTraits<SrcFormat>::GetBPC(comp)) + { + case 8: + dst = (float)((int8_t)src); + break; + case 16: + dst = (float)((int16_t)src); + break; + case 32: + dst = (float)((int32_t)src); + break; + default: + assert(0 && "attempted to load from SNORM with unsupported bpc"); + dst = 0.0f; + break; + } + dst = dst * (1.0f / ((1 << (FormatTraits<SrcFormat>::GetBPC(comp) - 1)) - 1)); + } + dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = dst; + break; + } + case SWR_TYPE_UINT: + { + UINT dst = (UINT)src; + dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = *(float*)&dst; + break; + } + case SWR_TYPE_SINT: + { + int dst; + switch (FormatTraits<SrcFormat>::GetBPC(comp)) + { + case 8: + dst = (int8_t)src; + break; + case 16: + dst = (int16_t)src; + break; + case 32: + dst = (int32_t)src; + break; + default: + assert(0 && "attempted to load from SINT with unsupported bpc"); + dst = 0; + break; + } + dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = *(float*)&dst; + break; + } + case SWR_TYPE_FLOAT: + { + float dst; + if (FormatTraits<SrcFormat>::GetBPC(comp) == 16) + { +#if KNOB_ARCH == KNOB_ARCH_AVX2 + // Convert from 16-bit float to 32-bit float using _mm_cvtph_ps + // @todo 16bit float instruction support is orthogonal to avx support. need to + // add check for F16C support instead. + __m128i src128 = _mm_set1_epi32(src); + __m128 res = _mm_cvtph_ps(src128); + _mm_store_ss(&dst, res); +#else + dst = ConvertSmallFloatTo32(src); +#endif + } + else if (FormatTraits<SrcFormat>::GetBPC(comp) == 11) + { + dst = ConvertSmallFloatTo32(src << 4); + } + else if (FormatTraits<SrcFormat>::GetBPC(comp) == 10) + { + dst = ConvertSmallFloatTo32(src << 5); + } + else + { + dst = *(float*)&src; + } + + dstPixel[FormatTraits<SrcFormat>::swizzle(comp)] = *(float*)&dst; + break; + } + default: + SWR_ASSERT(0); + break; + } + } +} + +// non-templated version of conversion functions +INLINE static void ConvertPixelFromFloat( + SWR_FORMAT format, + uint8_t* pDst, + const float srcPixel[4]) +{ + switch (format) + { + case R32G32B32A32_FLOAT: ConvertPixelFromFloat<R32G32B32A32_FLOAT>(pDst, srcPixel); break; + case R32G32B32A32_SINT: ConvertPixelFromFloat<R32G32B32A32_SINT>(pDst, srcPixel); break; + case R32G32B32A32_UINT: ConvertPixelFromFloat<R32G32B32A32_UINT>(pDst, srcPixel); break; + case R32G32B32X32_FLOAT: ConvertPixelFromFloat<R32G32B32X32_FLOAT>(pDst, srcPixel); break; + case R32G32B32A32_SSCALED: ConvertPixelFromFloat<R32G32B32A32_SSCALED>(pDst, srcPixel); break; + case R32G32B32A32_USCALED: ConvertPixelFromFloat<R32G32B32A32_USCALED>(pDst, srcPixel); break; + case R32G32B32_FLOAT: ConvertPixelFromFloat<R32G32B32_FLOAT>(pDst, srcPixel); break; + case R32G32B32_SINT: ConvertPixelFromFloat<R32G32B32_SINT>(pDst, srcPixel); break; + case R32G32B32_UINT: ConvertPixelFromFloat<R32G32B32_UINT>(pDst, srcPixel); break; + case R32G32B32_SSCALED: ConvertPixelFromFloat<R32G32B32_SSCALED>(pDst, srcPixel); break; + case R32G32B32_USCALED: ConvertPixelFromFloat<R32G32B32_USCALED>(pDst, srcPixel); break; + case R16G16B16A16_UNORM: ConvertPixelFromFloat<R16G16B16A16_UNORM>(pDst, srcPixel); break; + case R16G16B16A16_SNORM: ConvertPixelFromFloat<R16G16B16A16_SNORM>(pDst, srcPixel); break; + case R16G16B16A16_SINT: ConvertPixelFromFloat<R16G16B16A16_SINT>(pDst, srcPixel); break; + case R16G16B16A16_UINT: ConvertPixelFromFloat<R16G16B16A16_UINT>(pDst, srcPixel); break; + case R16G16B16A16_FLOAT: ConvertPixelFromFloat<R16G16B16A16_FLOAT>(pDst, srcPixel); break; + case R32G32_FLOAT: ConvertPixelFromFloat<R32G32_FLOAT>(pDst, srcPixel); break; + case R32G32_SINT: ConvertPixelFromFloat<R32G32_SINT>(pDst, srcPixel); break; + case R32G32_UINT: ConvertPixelFromFloat<R32G32_UINT>(pDst, srcPixel); break; + case R32_FLOAT_X8X24_TYPELESS: ConvertPixelFromFloat<R32_FLOAT_X8X24_TYPELESS>(pDst, srcPixel); break; + case R16G16B16X16_UNORM: ConvertPixelFromFloat<R16G16B16X16_UNORM>(pDst, srcPixel); break; + case R16G16B16X16_FLOAT: ConvertPixelFromFloat<R16G16B16X16_FLOAT>(pDst, srcPixel); break; + case R16G16B16A16_SSCALED: ConvertPixelFromFloat<R16G16B16A16_SSCALED>(pDst, srcPixel); break; + case R16G16B16A16_USCALED: ConvertPixelFromFloat<R16G16B16A16_USCALED>(pDst, srcPixel); break; + case R32G32_SSCALED: ConvertPixelFromFloat<R32G32_SSCALED>(pDst, srcPixel); break; + case R32G32_USCALED: ConvertPixelFromFloat<R32G32_USCALED>(pDst, srcPixel); break; + case R32_FLOAT_X8X24_TYPELESS_LD: ConvertPixelFromFloat<R32_FLOAT_X8X24_TYPELESS_LD>(pDst, srcPixel); break; + case B8G8R8A8_UNORM: ConvertPixelFromFloat<B8G8R8A8_UNORM>(pDst, srcPixel); break; + case B8G8R8A8_UNORM_SRGB: ConvertPixelFromFloat<B8G8R8A8_UNORM_SRGB>(pDst, srcPixel); break; + case R10G10B10A2_UNORM: ConvertPixelFromFloat<R10G10B10A2_UNORM>(pDst, srcPixel); break; + case R10G10B10A2_UNORM_SRGB: ConvertPixelFromFloat<R10G10B10A2_UNORM_SRGB>(pDst, srcPixel); break; + case R10G10B10A2_UINT: ConvertPixelFromFloat<R10G10B10A2_UINT>(pDst, srcPixel); break; + case R8G8B8A8_UNORM: ConvertPixelFromFloat<R8G8B8A8_UNORM>(pDst, srcPixel); break; + case R8G8B8A8_UNORM_SRGB: ConvertPixelFromFloat<R8G8B8A8_UNORM_SRGB>(pDst, srcPixel); break; + case R8G8B8A8_SNORM: ConvertPixelFromFloat<R8G8B8A8_SNORM>(pDst, srcPixel); break; + case R8G8B8A8_SINT: ConvertPixelFromFloat<R8G8B8A8_SINT>(pDst, srcPixel); break; + case R8G8B8A8_UINT: ConvertPixelFromFloat<R8G8B8A8_UINT>(pDst, srcPixel); break; + case R16G16_UNORM: ConvertPixelFromFloat<R16G16_UNORM>(pDst, srcPixel); break; + case R16G16_SNORM: ConvertPixelFromFloat<R16G16_SNORM>(pDst, srcPixel); break; + case R16G16_SINT: ConvertPixelFromFloat<R16G16_SINT>(pDst, srcPixel); break; + case R16G16_UINT: ConvertPixelFromFloat<R16G16_UINT>(pDst, srcPixel); break; + case R16G16_FLOAT: ConvertPixelFromFloat<R16G16_FLOAT>(pDst, srcPixel); break; + case B10G10R10A2_UNORM: ConvertPixelFromFloat<B10G10R10A2_UNORM>(pDst, srcPixel); break; + case B10G10R10A2_UNORM_SRGB: ConvertPixelFromFloat<B10G10R10A2_UNORM_SRGB>(pDst, srcPixel); break; + case R11G11B10_FLOAT: ConvertPixelFromFloat<R11G11B10_FLOAT>(pDst, srcPixel); break; + case R32_SINT: ConvertPixelFromFloat<R32_SINT>(pDst, srcPixel); break; + case R32_UINT: ConvertPixelFromFloat<R32_UINT>(pDst, srcPixel); break; + case R32_FLOAT: ConvertPixelFromFloat<R32_FLOAT>(pDst, srcPixel); break; + case R24_UNORM_X8_TYPELESS: ConvertPixelFromFloat<R24_UNORM_X8_TYPELESS>(pDst, srcPixel); break; + case R24_UNORM_X8_TYPELESS_LD: ConvertPixelFromFloat<R24_UNORM_X8_TYPELESS_LD>(pDst, srcPixel); break; + case A32_FLOAT: ConvertPixelFromFloat<A32_FLOAT>(pDst, srcPixel); break; + case B8G8R8X8_UNORM: ConvertPixelFromFloat<B8G8R8X8_UNORM>(pDst, srcPixel); break; + case B8G8R8X8_UNORM_SRGB: ConvertPixelFromFloat<B8G8R8X8_UNORM_SRGB>(pDst, srcPixel); break; + case R8G8B8X8_UNORM: ConvertPixelFromFloat<R8G8B8X8_UNORM>(pDst, srcPixel); break; + case R8G8B8X8_UNORM_SRGB: ConvertPixelFromFloat<R8G8B8X8_UNORM_SRGB>(pDst, srcPixel); break; + case R9G9B9E5_SHAREDEXP: ConvertPixelFromFloat<R9G9B9E5_SHAREDEXP>(pDst, srcPixel); break; + case B10G10R10X2_UNORM: ConvertPixelFromFloat<B10G10R10X2_UNORM>(pDst, srcPixel); break; + case R10G10B10X2_USCALED: ConvertPixelFromFloat<R10G10B10X2_USCALED>(pDst, srcPixel); break; + case R8G8B8A8_SSCALED: ConvertPixelFromFloat<R8G8B8A8_SSCALED>(pDst, srcPixel); break; + case R8G8B8A8_USCALED: ConvertPixelFromFloat<R8G8B8A8_USCALED>(pDst, srcPixel); break; + case R16G16_SSCALED: ConvertPixelFromFloat<R16G16_SSCALED>(pDst, srcPixel); break; + case R16G16_USCALED: ConvertPixelFromFloat<R16G16_USCALED>(pDst, srcPixel); break; + case R32_SSCALED: ConvertPixelFromFloat<R32_SSCALED>(pDst, srcPixel); break; + case R32_USCALED: ConvertPixelFromFloat<R32_USCALED>(pDst, srcPixel); break; + case B5G6R5_UNORM: ConvertPixelFromFloat<B5G6R5_UNORM>(pDst, srcPixel); break; + case B5G6R5_UNORM_SRGB: ConvertPixelFromFloat<B5G6R5_UNORM_SRGB>(pDst, srcPixel); break; + case B5G5R5A1_UNORM: ConvertPixelFromFloat<B5G5R5A1_UNORM>(pDst, srcPixel); break; + case B5G5R5A1_UNORM_SRGB: ConvertPixelFromFloat<B5G5R5A1_UNORM_SRGB>(pDst, srcPixel); break; + case B4G4R4A4_UNORM: ConvertPixelFromFloat<B4G4R4A4_UNORM>(pDst, srcPixel); break; + case B4G4R4A4_UNORM_SRGB: ConvertPixelFromFloat<B4G4R4A4_UNORM_SRGB>(pDst, srcPixel); break; + case R8G8_UNORM: ConvertPixelFromFloat<R8G8_UNORM>(pDst, srcPixel); break; + case R8G8_SNORM: ConvertPixelFromFloat<R8G8_SNORM>(pDst, srcPixel); break; + case R8G8_SINT: ConvertPixelFromFloat<R8G8_SINT>(pDst, srcPixel); break; + case R8G8_UINT: ConvertPixelFromFloat<R8G8_UINT>(pDst, srcPixel); break; + case R16_UNORM: ConvertPixelFromFloat<R16_UNORM>(pDst, srcPixel); break; + case R16_SNORM: ConvertPixelFromFloat<R16_SNORM>(pDst, srcPixel); break; + case R16_SINT: ConvertPixelFromFloat<R16_SINT>(pDst, srcPixel); break; + case R16_UINT: ConvertPixelFromFloat<R16_UINT>(pDst, srcPixel); break; + case R16_FLOAT: ConvertPixelFromFloat<R16_FLOAT>(pDst, srcPixel); break; + case A16_UNORM: ConvertPixelFromFloat<A16_UNORM>(pDst, srcPixel); break; + case A16_FLOAT: ConvertPixelFromFloat<A16_FLOAT>(pDst, srcPixel); break; + case B5G5R5X1_UNORM: ConvertPixelFromFloat<B5G5R5X1_UNORM>(pDst, srcPixel); break; + case B5G5R5X1_UNORM_SRGB: ConvertPixelFromFloat<B5G5R5X1_UNORM_SRGB>(pDst, srcPixel); break; + case R8G8_SSCALED: ConvertPixelFromFloat<R8G8_SSCALED>(pDst, srcPixel); break; + case R8G8_USCALED: ConvertPixelFromFloat<R8G8_USCALED>(pDst, srcPixel); break; + case R16_SSCALED: ConvertPixelFromFloat<R16_SSCALED>(pDst, srcPixel); break; + case R16_USCALED: ConvertPixelFromFloat<R16_USCALED>(pDst, srcPixel); break; + case R8_UNORM: ConvertPixelFromFloat<R8_UNORM>(pDst, srcPixel); break; + case R8_SNORM: ConvertPixelFromFloat<R8_SNORM>(pDst, srcPixel); break; + case R8_SINT: ConvertPixelFromFloat<R8_SINT>(pDst, srcPixel); break; + case R8_UINT: ConvertPixelFromFloat<R8_UINT>(pDst, srcPixel); break; + case A8_UNORM: ConvertPixelFromFloat<A8_UNORM>(pDst, srcPixel); break; + case R8_SSCALED: ConvertPixelFromFloat<R8_SSCALED>(pDst, srcPixel); break; + case R8_USCALED: ConvertPixelFromFloat<R8_USCALED>(pDst, srcPixel); break; + case YCRCB_SWAPUVY: ConvertPixelFromFloat<YCRCB_SWAPUVY>(pDst, srcPixel); break; + case BC1_UNORM: ConvertPixelFromFloat<BC1_UNORM>(pDst, srcPixel); break; + case BC2_UNORM: ConvertPixelFromFloat<BC2_UNORM>(pDst, srcPixel); break; + case BC3_UNORM: ConvertPixelFromFloat<BC3_UNORM>(pDst, srcPixel); break; + case BC4_UNORM: ConvertPixelFromFloat<BC4_UNORM>(pDst, srcPixel); break; + case BC5_UNORM: ConvertPixelFromFloat<BC5_UNORM>(pDst, srcPixel); break; + case BC1_UNORM_SRGB: ConvertPixelFromFloat<BC1_UNORM_SRGB>(pDst, srcPixel); break; + case BC2_UNORM_SRGB: ConvertPixelFromFloat<BC2_UNORM_SRGB>(pDst, srcPixel); break; + case BC3_UNORM_SRGB: ConvertPixelFromFloat<BC3_UNORM_SRGB>(pDst, srcPixel); break; + case YCRCB_SWAPUV: ConvertPixelFromFloat<YCRCB_SWAPUV>(pDst, srcPixel); break; + case R8G8B8_UNORM: ConvertPixelFromFloat<R8G8B8_UNORM>(pDst, srcPixel); break; + case R8G8B8_SNORM: ConvertPixelFromFloat<R8G8B8_SNORM>(pDst, srcPixel); break; + case R8G8B8_SSCALED: ConvertPixelFromFloat<R8G8B8_SSCALED>(pDst, srcPixel); break; + case R8G8B8_USCALED: ConvertPixelFromFloat<R8G8B8_USCALED>(pDst, srcPixel); break; + case BC4_SNORM: ConvertPixelFromFloat<BC4_SNORM>(pDst, srcPixel); break; + case BC5_SNORM: ConvertPixelFromFloat<BC5_SNORM>(pDst, srcPixel); break; + case R16G16B16_FLOAT: ConvertPixelFromFloat<R16G16B16_FLOAT>(pDst, srcPixel); break; + case R16G16B16_UNORM: ConvertPixelFromFloat<R16G16B16_UNORM>(pDst, srcPixel); break; + case R16G16B16_SNORM: ConvertPixelFromFloat<R16G16B16_SNORM>(pDst, srcPixel); break; + case R16G16B16_SSCALED: ConvertPixelFromFloat<R16G16B16_SSCALED>(pDst, srcPixel); break; + case R16G16B16_USCALED: ConvertPixelFromFloat<R16G16B16_USCALED>(pDst, srcPixel); break; + case BC7_UNORM: ConvertPixelFromFloat<BC7_UNORM>(pDst, srcPixel); break; + case BC7_UNORM_SRGB: ConvertPixelFromFloat<BC7_UNORM_SRGB>(pDst, srcPixel); break; + case R8G8B8_UNORM_SRGB: ConvertPixelFromFloat<R8G8B8_UNORM_SRGB>(pDst, srcPixel); break; + case R16G16B16_UINT: ConvertPixelFromFloat<R16G16B16_UINT>(pDst, srcPixel); break; + case R16G16B16_SINT: ConvertPixelFromFloat<R16G16B16_SINT>(pDst, srcPixel); break; + case R10G10B10A2_SNORM: ConvertPixelFromFloat<R10G10B10A2_SNORM>(pDst, srcPixel); break; + case R10G10B10A2_USCALED: ConvertPixelFromFloat<R10G10B10A2_USCALED>(pDst, srcPixel); break; + case R10G10B10A2_SSCALED: ConvertPixelFromFloat<R10G10B10A2_SSCALED>(pDst, srcPixel); break; + case R10G10B10A2_SINT: ConvertPixelFromFloat<R10G10B10A2_SINT>(pDst, srcPixel); break; + case B10G10R10A2_SNORM: ConvertPixelFromFloat<B10G10R10A2_SNORM>(pDst, srcPixel); break; + case B10G10R10A2_USCALED: ConvertPixelFromFloat<B10G10R10A2_USCALED>(pDst, srcPixel); break; + case B10G10R10A2_SSCALED: ConvertPixelFromFloat<B10G10R10A2_SSCALED>(pDst, srcPixel); break; + case B10G10R10A2_UINT: ConvertPixelFromFloat<B10G10R10A2_UINT>(pDst, srcPixel); break; + case B10G10R10A2_SINT: ConvertPixelFromFloat<B10G10R10A2_SINT>(pDst, srcPixel); break; + case R8G8B8_UINT: ConvertPixelFromFloat<R8G8B8_UINT>(pDst, srcPixel); break; + case R8G8B8_SINT: ConvertPixelFromFloat<R8G8B8_SINT>(pDst, srcPixel); break; + default: + break; + } +} + + |