1 /****************************************************************************
2 * Copyright (C) 2014-2015 Intel Corporation. All Rights Reserved.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
25 * @brief Conversion utility functions
27 ******************************************************************************/
31 // disable "potential divide by 0"
32 #pragma warning(disable: 4723)
35 //////////////////////////////////////////////////////////////////////////
36 /// @brief Convert an IEEE 754 16-bit float to an 32-bit single precision
38 /// @param val - 16-bit float
39 /// @todo Maybe move this outside of this file into a header?
40 static float ConvertSmallFloatTo32(UINT val
)
43 if ((val
& 0x7fff) == 0)
45 result
= ((uint32_t)(val
& 0x8000)) << 16;
47 else if ((val
& 0x7c00) == 0x7c00)
49 result
= ((val
& 0x3ff) == 0) ? 0x7f800000 : 0x7fc00000;
50 result
|= ((uint32_t)val
& 0x8000) << 16;
54 uint32_t sign
= (val
& 0x8000) << 16;
55 uint32_t mant
= (val
& 0x3ff) << 13;
56 uint32_t exp
= (val
>> 10) & 0x1f;
57 if ((exp
== 0) && (mant
!= 0)) // Adjust exponent and mantissa for denormals
60 while (mant
< (0x400 << 13))
65 mant
&= (0x3ff << 13);
67 exp
= ((exp
- 15 + 127) & 0xff) << 23;
68 result
= sign
| exp
| mant
;
71 return *(float*)&result
;
74 //////////////////////////////////////////////////////////////////////////
75 /// @brief Convert an IEEE 754 32-bit single precision float to an
76 /// unsigned small float with 5 exponent bits and a variable
77 /// number of mantissa bits.
78 /// @param val - 32-bit float
79 /// @todo Maybe move this outside of this file into a header?
80 template<UINT numMantissaBits
>
81 static UINT
Convert32ToSmallFloat(float val
)
83 uint32_t sign
, exp
, mant
;
86 // Extract the sign, exponent, and mantissa
87 UINT uf
= *(UINT
*)&val
;
89 sign
= (uf
& 0x80000000) >> 31;
90 exp
= (uf
& 0x7F800000) >> 23;
91 mant
= uf
& 0x007FFFFF;
93 // 10/11 bit floats are unsigned. Negative values are clamped to 0.
98 // Check for out of range
99 else if ((exp
== 0xFF) && (mant
!= 0)) // NaN
102 mant
= 1 << numMantissaBits
;
104 else if ((exp
== 0xFF) && (mant
== 0)) // INF
109 else if (exp
> (0x70 + 0x1E)) // Too big to represent
112 mant
= (1 << numMantissaBits
) - 1; // 0x3F for 6 bit mantissa.
114 else if ((exp
<= 0x70) && (exp
>= 0x66)) // It's a denorm
117 for (; exp
<= 0x70; mant
>>= 1, exp
++)
120 mant
= mant
>> (23 - numMantissaBits
);
122 else if (exp
< 0x66) // Too small to represent -> Zero
129 // Saves bits that will be shifted off for rounding
130 roundBits
= mant
& 0x1FFFu
;
131 // convert exponent and mantissa to 16 bit format
133 mant
= mant
>> (23 - numMantissaBits
);
135 // Essentially RTZ, but round up if off by only 1 lsb
136 if (roundBits
== 0x1FFFu
)
139 // check for overflow
140 if ((mant
& (0x3 << numMantissaBits
)) != 0) // 0x60 = 0x3 << (num Mantissa Bits)
142 // make sure only the needed bits are used
143 mant
&= (1 << numMantissaBits
) - 1;
147 UINT tmpVal
= (exp
<< numMantissaBits
) | mant
;
151 #if KNOB_ARCH == KNOB_ARCH_AVX
152 //////////////////////////////////////////////////////////////////////////
153 /// @brief Convert an IEEE 754 32-bit single precision float to an
154 /// 16 bit float with 5 exponent bits and a variable
155 /// number of mantissa bits.
156 /// @param val - 32-bit float
157 /// @todo Maybe move this outside of this file into a header?
158 static uint16_t Convert32To16Float(float val
)
160 uint32_t sign
, exp
, mant
;
163 // Extract the sign, exponent, and mantissa
164 uint32_t uf
= *(uint32_t*)&val
;
165 sign
= (uf
& 0x80000000) >> 31;
166 exp
= (uf
& 0x7F800000) >> 23;
167 mant
= uf
& 0x007FFFFF;
169 // Check for out of range
174 sign
= 1; // set the sign bit for NANs
176 else if (std::isinf(val
))
181 else if (exp
> (0x70 + 0x1E)) // Too big to represent -> max representable value
186 else if ((exp
<= 0x70) && (exp
>= 0x66)) // It's a denorm
189 for (; exp
<= 0x70; mant
>>= 1, exp
++)
194 else if (exp
< 0x66) // Too small to represent -> Zero
201 // Saves bits that will be shifted off for rounding
202 roundBits
= mant
& 0x1FFFu
;
203 // convert exponent and mantissa to 16 bit format
207 // Essentially RTZ, but round up if off by only 1 lsb
208 if (roundBits
== 0x1FFFu
)
211 // check for overflow
212 if ((mant
& 0xC00u
) != 0)
214 // make sure only the needed bits are used
219 uint32_t tmpVal
= (sign
<< 15) | (exp
<< 10) | mant
;
220 return (uint16_t)tmpVal
;
224 //////////////////////////////////////////////////////////////////////////
225 /// @brief Retrieve color from hot tile source which is always float.
226 /// @param pDstPixel - Pointer to destination pixel.
227 /// @param srcPixel - Pointer to source pixel (pre-swizzled according to dest).
228 template<SWR_FORMAT DstFormat
>
229 static void ConvertPixelFromFloat(
231 const float srcPixel
[4])
233 uint32_t outColor
[4] = { 0 }; // typeless bits
236 for (UINT comp
= 0; comp
< FormatTraits
<DstFormat
>::numComps
; ++comp
)
238 SWR_TYPE type
= FormatTraits
<DstFormat
>::GetType(comp
);
240 float src
= srcPixel
[comp
];
246 // Force NaN to 0. IEEE standard, comparisons involving NaN always evaluate to false.
247 src
= (src
!= src
) ? 0.0f
: src
;
250 src
= std::max(src
, 0.0f
);
251 src
= std::min(src
, 1.0f
);
254 if (FormatTraits
<DstFormat
>::isSRGB
&& comp
!= 3)
256 src
= (src
<= 0.0031308f
) ? (12.92f
* src
) : (1.055f
* powf(src
, (1.0f
/ 2.4f
)) - 0.055f
);
259 // Float scale to integer scale.
260 UINT scale
= (1 << FormatTraits
<DstFormat
>::GetBPC(comp
)) - 1;
261 src
= (float)scale
* src
;
263 outColor
[comp
] = (UINT
)src
; // Drop fractional part.
268 SWR_ASSERT(!FormatTraits
<DstFormat
>::isSRGB
);
270 // Force NaN to 0. IEEE standard, comparisons involving NaN always evaluate to false.
271 src
= (src
!= src
) ? 0.0f
: src
;
274 src
= std::max(src
, -1.0f
);
275 src
= std::min(src
, 1.0f
);
277 // Float scale to integer scale.
278 UINT scale
= (1 << (FormatTraits
<DstFormat
>::GetBPC(comp
) - 1)) - 1;
279 src
= (float)scale
* src
;
282 src
+= (src
>= 0) ? 0.5f
: -0.5f
;
286 outColor
[comp
] = *(UINT
*)&out
;
292 ///@note The *(UINT*)& is currently necessary as the hot tile appears to always be float.
293 // However, the number in the hot tile should be unsigned integer. So doing this
294 // to preserve bits intead of doing a float -> integer conversion.
295 if (FormatTraits
<DstFormat
>::GetBPC(comp
) == 32)
297 outColor
[comp
] = *(UINT
*)&src
;
301 outColor
[comp
] = *(UINT
*)&src
;
302 UINT max
= (1 << FormatTraits
<DstFormat
>::GetBPC(comp
)) - 1; // 2^numBits - 1
304 outColor
[comp
] = std::min(max
, outColor
[comp
]);
310 if (FormatTraits
<DstFormat
>::GetBPC(comp
) == 32)
312 outColor
[comp
] = *(UINT
*)&src
;
316 INT out
= *(INT
*)&src
; // Hot tile format is SINT?
317 INT max
= (1 << (FormatTraits
<DstFormat
>::GetBPC(comp
) - 1)) - 1;
320 ///@note The output is unsigned integer (bag of bits) and so performing
321 // the clamping here based on range of output component. Also, manually adding
322 // the sign bit in the appropriate spot. Maybe a better way?
323 out
= std::max(out
, min
);
324 out
= std::min(out
, max
);
326 outColor
[comp
] = *(UINT
*)&out
;
332 if (FormatTraits
<DstFormat
>::GetBPC(comp
) == 16)
334 // Convert from 32-bit float to 16-bit float using _mm_cvtps_ph
335 // @todo 16bit float instruction support is orthogonal to avx support. need to
336 // add check for F16C support instead.
337 #if KNOB_ARCH == KNOB_ARCH_AVX2
338 __m128 src128
= _mm_set1_ps(src
);
339 __m128i srci128
= _mm_cvtps_ph(src128
, _MM_FROUND_TRUNC
);
340 UINT value
= _mm_extract_epi16(srci128
, 0);
342 UINT value
= Convert32To16Float(src
);
345 outColor
[comp
] = value
;
347 else if (FormatTraits
<DstFormat
>::GetBPC(comp
) == 11)
349 outColor
[comp
] = Convert32ToSmallFloat
<6>(src
);
351 else if (FormatTraits
<DstFormat
>::GetBPC(comp
) == 10)
353 outColor
[comp
] = Convert32ToSmallFloat
<5>(src
);
357 outColor
[comp
] = *(UINT
*)&src
;
368 typename FormatTraits
<DstFormat
>::FormatT
* pPixel
= (typename FormatTraits
<DstFormat
>::FormatT
*)pDstPixel
;
370 switch (FormatTraits
<DstFormat
>::numComps
)
373 pPixel
->a
= outColor
[3];
375 pPixel
->b
= outColor
[2];
377 pPixel
->g
= outColor
[1];
379 pPixel
->r
= outColor
[0];
386 //////////////////////////////////////////////////////////////////////////
387 /// @brief Convert pixel in any format to float32
388 /// @param pDstPixel - Pointer to destination pixel.
389 /// @param srcPixel - Pointer to source pixel
390 template<SWR_FORMAT SrcFormat
>
391 INLINE
static void ConvertPixelToFloat(
395 uint32_t srcColor
[4]; // typeless bits
398 typename FormatTraits
<SrcFormat
>::FormatT
* pPixel
= (typename FormatTraits
<SrcFormat
>::FormatT
*)pSrc
;
400 // apply format defaults
401 for (uint32_t comp
= 0; comp
< 4; ++comp
)
403 uint32_t def
= FormatTraits
<SrcFormat
>::GetDefault(comp
);
404 dstPixel
[comp
] = *(float*)&def
;
408 switch (FormatTraits
<SrcFormat
>::numComps
)
411 srcColor
[3] = pPixel
->a
;
413 srcColor
[2] = pPixel
->b
;
415 srcColor
[1] = pPixel
->g
;
417 srcColor
[0] = pPixel
->r
;
423 // Convert components
424 for (uint32_t comp
= 0; comp
< FormatTraits
<SrcFormat
>::numComps
; ++comp
)
426 SWR_TYPE type
= FormatTraits
<SrcFormat
>::GetType(comp
);
428 uint32_t src
= srcColor
[comp
];
435 if (FormatTraits
<SrcFormat
>::isSRGB
&& comp
!= 3)
437 dst
= *(float*)&srgb8Table
[src
];
441 // component sizes > 16 must use fp divide to maintain ulp requirements
442 if (FormatTraits
<SrcFormat
>::GetBPC(comp
) > 16)
444 dst
= (float)src
/ (float)((1 << FormatTraits
<SrcFormat
>::GetBPC(comp
)) - 1);
448 const float scale
= (1.0f
/ (float)((1 << FormatTraits
<SrcFormat
>::GetBPC(comp
)) - 1));
449 dst
= (float)src
* scale
;
452 dstPixel
[FormatTraits
<SrcFormat
>::swizzle(comp
)] = dst
;
457 SWR_ASSERT(!FormatTraits
<SrcFormat
>::isSRGB
);
466 switch (FormatTraits
<SrcFormat
>::GetBPC(comp
))
469 dst
= (float)((int8_t)src
);
472 dst
= (float)((int16_t)src
);
475 dst
= (float)((int32_t)src
);
478 assert(0 && "attempted to load from SNORM with unsupported bpc");
482 dst
= dst
* (1.0f
/ ((1 << (FormatTraits
<SrcFormat
>::GetBPC(comp
) - 1)) - 1));
484 dstPixel
[FormatTraits
<SrcFormat
>::swizzle(comp
)] = dst
;
489 uint32_t dst
= (uint32_t)src
;
490 dstPixel
[FormatTraits
<SrcFormat
>::swizzle(comp
)] = *(float*)&dst
;
496 switch (FormatTraits
<SrcFormat
>::GetBPC(comp
))
508 assert(0 && "attempted to load from SINT with unsupported bpc");
512 dstPixel
[FormatTraits
<SrcFormat
>::swizzle(comp
)] = *(float*)&dst
;
518 if (FormatTraits
<SrcFormat
>::GetBPC(comp
) == 16)
520 #if KNOB_ARCH == KNOB_ARCH_AVX2
521 // Convert from 16-bit float to 32-bit float using _mm_cvtph_ps
522 // @todo 16bit float instruction support is orthogonal to avx support. need to
523 // add check for F16C support instead.
524 __m128i src128
= _mm_set1_epi32(src
);
525 __m128 res
= _mm_cvtph_ps(src128
);
526 _mm_store_ss(&dst
, res
);
528 dst
= ConvertSmallFloatTo32(src
);
531 else if (FormatTraits
<SrcFormat
>::GetBPC(comp
) == 11)
533 dst
= ConvertSmallFloatTo32(src
<< 4);
535 else if (FormatTraits
<SrcFormat
>::GetBPC(comp
) == 10)
537 dst
= ConvertSmallFloatTo32(src
<< 5);
544 dstPixel
[FormatTraits
<SrcFormat
>::swizzle(comp
)] = *(float*)&dst
;
554 // non-templated version of conversion functions
555 INLINE
static void ConvertPixelFromFloat(
558 const float srcPixel
[4])
562 case R32G32B32A32_FLOAT
: ConvertPixelFromFloat
<R32G32B32A32_FLOAT
>(pDst
, srcPixel
); break;
563 case R32G32B32A32_SINT
: ConvertPixelFromFloat
<R32G32B32A32_SINT
>(pDst
, srcPixel
); break;
564 case R32G32B32A32_UINT
: ConvertPixelFromFloat
<R32G32B32A32_UINT
>(pDst
, srcPixel
); break;
565 case R32G32B32X32_FLOAT
: ConvertPixelFromFloat
<R32G32B32X32_FLOAT
>(pDst
, srcPixel
); break;
566 case R32G32B32A32_SSCALED
: ConvertPixelFromFloat
<R32G32B32A32_SSCALED
>(pDst
, srcPixel
); break;
567 case R32G32B32A32_USCALED
: ConvertPixelFromFloat
<R32G32B32A32_USCALED
>(pDst
, srcPixel
); break;
568 case R32G32B32_FLOAT
: ConvertPixelFromFloat
<R32G32B32_FLOAT
>(pDst
, srcPixel
); break;
569 case R32G32B32_SINT
: ConvertPixelFromFloat
<R32G32B32_SINT
>(pDst
, srcPixel
); break;
570 case R32G32B32_UINT
: ConvertPixelFromFloat
<R32G32B32_UINT
>(pDst
, srcPixel
); break;
571 case R32G32B32_SSCALED
: ConvertPixelFromFloat
<R32G32B32_SSCALED
>(pDst
, srcPixel
); break;
572 case R32G32B32_USCALED
: ConvertPixelFromFloat
<R32G32B32_USCALED
>(pDst
, srcPixel
); break;
573 case R16G16B16A16_UNORM
: ConvertPixelFromFloat
<R16G16B16A16_UNORM
>(pDst
, srcPixel
); break;
574 case R16G16B16A16_SNORM
: ConvertPixelFromFloat
<R16G16B16A16_SNORM
>(pDst
, srcPixel
); break;
575 case R16G16B16A16_SINT
: ConvertPixelFromFloat
<R16G16B16A16_SINT
>(pDst
, srcPixel
); break;
576 case R16G16B16A16_UINT
: ConvertPixelFromFloat
<R16G16B16A16_UINT
>(pDst
, srcPixel
); break;
577 case R16G16B16A16_FLOAT
: ConvertPixelFromFloat
<R16G16B16A16_FLOAT
>(pDst
, srcPixel
); break;
578 case R32G32_FLOAT
: ConvertPixelFromFloat
<R32G32_FLOAT
>(pDst
, srcPixel
); break;
579 case R32G32_SINT
: ConvertPixelFromFloat
<R32G32_SINT
>(pDst
, srcPixel
); break;
580 case R32G32_UINT
: ConvertPixelFromFloat
<R32G32_UINT
>(pDst
, srcPixel
); break;
581 case R32_FLOAT_X8X24_TYPELESS
: ConvertPixelFromFloat
<R32_FLOAT_X8X24_TYPELESS
>(pDst
, srcPixel
); break;
582 case R16G16B16X16_UNORM
: ConvertPixelFromFloat
<R16G16B16X16_UNORM
>(pDst
, srcPixel
); break;
583 case R16G16B16X16_FLOAT
: ConvertPixelFromFloat
<R16G16B16X16_FLOAT
>(pDst
, srcPixel
); break;
584 case R16G16B16A16_SSCALED
: ConvertPixelFromFloat
<R16G16B16A16_SSCALED
>(pDst
, srcPixel
); break;
585 case R16G16B16A16_USCALED
: ConvertPixelFromFloat
<R16G16B16A16_USCALED
>(pDst
, srcPixel
); break;
586 case R32G32_SSCALED
: ConvertPixelFromFloat
<R32G32_SSCALED
>(pDst
, srcPixel
); break;
587 case R32G32_USCALED
: ConvertPixelFromFloat
<R32G32_USCALED
>(pDst
, srcPixel
); break;
588 case R32_FLOAT_X8X24_TYPELESS_LD
: ConvertPixelFromFloat
<R32_FLOAT_X8X24_TYPELESS_LD
>(pDst
, srcPixel
); break;
589 case B8G8R8A8_UNORM
: ConvertPixelFromFloat
<B8G8R8A8_UNORM
>(pDst
, srcPixel
); break;
590 case B8G8R8A8_UNORM_SRGB
: ConvertPixelFromFloat
<B8G8R8A8_UNORM_SRGB
>(pDst
, srcPixel
); break;
591 case R10G10B10A2_UNORM
: ConvertPixelFromFloat
<R10G10B10A2_UNORM
>(pDst
, srcPixel
); break;
592 case R10G10B10A2_UNORM_SRGB
: ConvertPixelFromFloat
<R10G10B10A2_UNORM_SRGB
>(pDst
, srcPixel
); break;
593 case R10G10B10A2_UINT
: ConvertPixelFromFloat
<R10G10B10A2_UINT
>(pDst
, srcPixel
); break;
594 case R8G8B8A8_UNORM
: ConvertPixelFromFloat
<R8G8B8A8_UNORM
>(pDst
, srcPixel
); break;
595 case R8G8B8A8_UNORM_SRGB
: ConvertPixelFromFloat
<R8G8B8A8_UNORM_SRGB
>(pDst
, srcPixel
); break;
596 case R8G8B8A8_SNORM
: ConvertPixelFromFloat
<R8G8B8A8_SNORM
>(pDst
, srcPixel
); break;
597 case R8G8B8A8_SINT
: ConvertPixelFromFloat
<R8G8B8A8_SINT
>(pDst
, srcPixel
); break;
598 case R8G8B8A8_UINT
: ConvertPixelFromFloat
<R8G8B8A8_UINT
>(pDst
, srcPixel
); break;
599 case R16G16_UNORM
: ConvertPixelFromFloat
<R16G16_UNORM
>(pDst
, srcPixel
); break;
600 case R16G16_SNORM
: ConvertPixelFromFloat
<R16G16_SNORM
>(pDst
, srcPixel
); break;
601 case R16G16_SINT
: ConvertPixelFromFloat
<R16G16_SINT
>(pDst
, srcPixel
); break;
602 case R16G16_UINT
: ConvertPixelFromFloat
<R16G16_UINT
>(pDst
, srcPixel
); break;
603 case R16G16_FLOAT
: ConvertPixelFromFloat
<R16G16_FLOAT
>(pDst
, srcPixel
); break;
604 case B10G10R10A2_UNORM
: ConvertPixelFromFloat
<B10G10R10A2_UNORM
>(pDst
, srcPixel
); break;
605 case B10G10R10A2_UNORM_SRGB
: ConvertPixelFromFloat
<B10G10R10A2_UNORM_SRGB
>(pDst
, srcPixel
); break;
606 case R11G11B10_FLOAT
: ConvertPixelFromFloat
<R11G11B10_FLOAT
>(pDst
, srcPixel
); break;
607 case R32_SINT
: ConvertPixelFromFloat
<R32_SINT
>(pDst
, srcPixel
); break;
608 case R32_UINT
: ConvertPixelFromFloat
<R32_UINT
>(pDst
, srcPixel
); break;
609 case R32_FLOAT
: ConvertPixelFromFloat
<R32_FLOAT
>(pDst
, srcPixel
); break;
610 case R24_UNORM_X8_TYPELESS
: ConvertPixelFromFloat
<R24_UNORM_X8_TYPELESS
>(pDst
, srcPixel
); break;
611 case R24_UNORM_X8_TYPELESS_LD
: ConvertPixelFromFloat
<R24_UNORM_X8_TYPELESS_LD
>(pDst
, srcPixel
); break;
612 case A32_FLOAT
: ConvertPixelFromFloat
<A32_FLOAT
>(pDst
, srcPixel
); break;
613 case B8G8R8X8_UNORM
: ConvertPixelFromFloat
<B8G8R8X8_UNORM
>(pDst
, srcPixel
); break;
614 case B8G8R8X8_UNORM_SRGB
: ConvertPixelFromFloat
<B8G8R8X8_UNORM_SRGB
>(pDst
, srcPixel
); break;
615 case R8G8B8X8_UNORM
: ConvertPixelFromFloat
<R8G8B8X8_UNORM
>(pDst
, srcPixel
); break;
616 case R8G8B8X8_UNORM_SRGB
: ConvertPixelFromFloat
<R8G8B8X8_UNORM_SRGB
>(pDst
, srcPixel
); break;
617 case R9G9B9E5_SHAREDEXP
: ConvertPixelFromFloat
<R9G9B9E5_SHAREDEXP
>(pDst
, srcPixel
); break;
618 case B10G10R10X2_UNORM
: ConvertPixelFromFloat
<B10G10R10X2_UNORM
>(pDst
, srcPixel
); break;
619 case R10G10B10X2_USCALED
: ConvertPixelFromFloat
<R10G10B10X2_USCALED
>(pDst
, srcPixel
); break;
620 case R8G8B8A8_SSCALED
: ConvertPixelFromFloat
<R8G8B8A8_SSCALED
>(pDst
, srcPixel
); break;
621 case R8G8B8A8_USCALED
: ConvertPixelFromFloat
<R8G8B8A8_USCALED
>(pDst
, srcPixel
); break;
622 case R16G16_SSCALED
: ConvertPixelFromFloat
<R16G16_SSCALED
>(pDst
, srcPixel
); break;
623 case R16G16_USCALED
: ConvertPixelFromFloat
<R16G16_USCALED
>(pDst
, srcPixel
); break;
624 case R32_SSCALED
: ConvertPixelFromFloat
<R32_SSCALED
>(pDst
, srcPixel
); break;
625 case R32_USCALED
: ConvertPixelFromFloat
<R32_USCALED
>(pDst
, srcPixel
); break;
626 case B5G6R5_UNORM
: ConvertPixelFromFloat
<B5G6R5_UNORM
>(pDst
, srcPixel
); break;
627 case B5G6R5_UNORM_SRGB
: ConvertPixelFromFloat
<B5G6R5_UNORM_SRGB
>(pDst
, srcPixel
); break;
628 case B5G5R5A1_UNORM
: ConvertPixelFromFloat
<B5G5R5A1_UNORM
>(pDst
, srcPixel
); break;
629 case B5G5R5A1_UNORM_SRGB
: ConvertPixelFromFloat
<B5G5R5A1_UNORM_SRGB
>(pDst
, srcPixel
); break;
630 case B4G4R4A4_UNORM
: ConvertPixelFromFloat
<B4G4R4A4_UNORM
>(pDst
, srcPixel
); break;
631 case B4G4R4A4_UNORM_SRGB
: ConvertPixelFromFloat
<B4G4R4A4_UNORM_SRGB
>(pDst
, srcPixel
); break;
632 case R8G8_UNORM
: ConvertPixelFromFloat
<R8G8_UNORM
>(pDst
, srcPixel
); break;
633 case R8G8_SNORM
: ConvertPixelFromFloat
<R8G8_SNORM
>(pDst
, srcPixel
); break;
634 case R8G8_SINT
: ConvertPixelFromFloat
<R8G8_SINT
>(pDst
, srcPixel
); break;
635 case R8G8_UINT
: ConvertPixelFromFloat
<R8G8_UINT
>(pDst
, srcPixel
); break;
636 case R16_UNORM
: ConvertPixelFromFloat
<R16_UNORM
>(pDst
, srcPixel
); break;
637 case R16_SNORM
: ConvertPixelFromFloat
<R16_SNORM
>(pDst
, srcPixel
); break;
638 case R16_SINT
: ConvertPixelFromFloat
<R16_SINT
>(pDst
, srcPixel
); break;
639 case R16_UINT
: ConvertPixelFromFloat
<R16_UINT
>(pDst
, srcPixel
); break;
640 case R16_FLOAT
: ConvertPixelFromFloat
<R16_FLOAT
>(pDst
, srcPixel
); break;
641 case A16_UNORM
: ConvertPixelFromFloat
<A16_UNORM
>(pDst
, srcPixel
); break;
642 case A16_FLOAT
: ConvertPixelFromFloat
<A16_FLOAT
>(pDst
, srcPixel
); break;
643 case B5G5R5X1_UNORM
: ConvertPixelFromFloat
<B5G5R5X1_UNORM
>(pDst
, srcPixel
); break;
644 case B5G5R5X1_UNORM_SRGB
: ConvertPixelFromFloat
<B5G5R5X1_UNORM_SRGB
>(pDst
, srcPixel
); break;
645 case R8G8_SSCALED
: ConvertPixelFromFloat
<R8G8_SSCALED
>(pDst
, srcPixel
); break;
646 case R8G8_USCALED
: ConvertPixelFromFloat
<R8G8_USCALED
>(pDst
, srcPixel
); break;
647 case R16_SSCALED
: ConvertPixelFromFloat
<R16_SSCALED
>(pDst
, srcPixel
); break;
648 case R16_USCALED
: ConvertPixelFromFloat
<R16_USCALED
>(pDst
, srcPixel
); break;
649 case R8_UNORM
: ConvertPixelFromFloat
<R8_UNORM
>(pDst
, srcPixel
); break;
650 case R8_SNORM
: ConvertPixelFromFloat
<R8_SNORM
>(pDst
, srcPixel
); break;
651 case R8_SINT
: ConvertPixelFromFloat
<R8_SINT
>(pDst
, srcPixel
); break;
652 case R8_UINT
: ConvertPixelFromFloat
<R8_UINT
>(pDst
, srcPixel
); break;
653 case A8_UNORM
: ConvertPixelFromFloat
<A8_UNORM
>(pDst
, srcPixel
); break;
654 case R8_SSCALED
: ConvertPixelFromFloat
<R8_SSCALED
>(pDst
, srcPixel
); break;
655 case R8_USCALED
: ConvertPixelFromFloat
<R8_USCALED
>(pDst
, srcPixel
); break;
656 case YCRCB_SWAPUVY
: ConvertPixelFromFloat
<YCRCB_SWAPUVY
>(pDst
, srcPixel
); break;
657 case BC1_UNORM
: ConvertPixelFromFloat
<BC1_UNORM
>(pDst
, srcPixel
); break;
658 case BC2_UNORM
: ConvertPixelFromFloat
<BC2_UNORM
>(pDst
, srcPixel
); break;
659 case BC3_UNORM
: ConvertPixelFromFloat
<BC3_UNORM
>(pDst
, srcPixel
); break;
660 case BC4_UNORM
: ConvertPixelFromFloat
<BC4_UNORM
>(pDst
, srcPixel
); break;
661 case BC5_UNORM
: ConvertPixelFromFloat
<BC5_UNORM
>(pDst
, srcPixel
); break;
662 case BC1_UNORM_SRGB
: ConvertPixelFromFloat
<BC1_UNORM_SRGB
>(pDst
, srcPixel
); break;
663 case BC2_UNORM_SRGB
: ConvertPixelFromFloat
<BC2_UNORM_SRGB
>(pDst
, srcPixel
); break;
664 case BC3_UNORM_SRGB
: ConvertPixelFromFloat
<BC3_UNORM_SRGB
>(pDst
, srcPixel
); break;
665 case YCRCB_SWAPUV
: ConvertPixelFromFloat
<YCRCB_SWAPUV
>(pDst
, srcPixel
); break;
666 case R8G8B8_UNORM
: ConvertPixelFromFloat
<R8G8B8_UNORM
>(pDst
, srcPixel
); break;
667 case R8G8B8_SNORM
: ConvertPixelFromFloat
<R8G8B8_SNORM
>(pDst
, srcPixel
); break;
668 case R8G8B8_SSCALED
: ConvertPixelFromFloat
<R8G8B8_SSCALED
>(pDst
, srcPixel
); break;
669 case R8G8B8_USCALED
: ConvertPixelFromFloat
<R8G8B8_USCALED
>(pDst
, srcPixel
); break;
670 case BC4_SNORM
: ConvertPixelFromFloat
<BC4_SNORM
>(pDst
, srcPixel
); break;
671 case BC5_SNORM
: ConvertPixelFromFloat
<BC5_SNORM
>(pDst
, srcPixel
); break;
672 case R16G16B16_FLOAT
: ConvertPixelFromFloat
<R16G16B16_FLOAT
>(pDst
, srcPixel
); break;
673 case R16G16B16_UNORM
: ConvertPixelFromFloat
<R16G16B16_UNORM
>(pDst
, srcPixel
); break;
674 case R16G16B16_SNORM
: ConvertPixelFromFloat
<R16G16B16_SNORM
>(pDst
, srcPixel
); break;
675 case R16G16B16_SSCALED
: ConvertPixelFromFloat
<R16G16B16_SSCALED
>(pDst
, srcPixel
); break;
676 case R16G16B16_USCALED
: ConvertPixelFromFloat
<R16G16B16_USCALED
>(pDst
, srcPixel
); break;
677 case BC7_UNORM
: ConvertPixelFromFloat
<BC7_UNORM
>(pDst
, srcPixel
); break;
678 case BC7_UNORM_SRGB
: ConvertPixelFromFloat
<BC7_UNORM_SRGB
>(pDst
, srcPixel
); break;
679 case R8G8B8_UNORM_SRGB
: ConvertPixelFromFloat
<R8G8B8_UNORM_SRGB
>(pDst
, srcPixel
); break;
680 case R16G16B16_UINT
: ConvertPixelFromFloat
<R16G16B16_UINT
>(pDst
, srcPixel
); break;
681 case R16G16B16_SINT
: ConvertPixelFromFloat
<R16G16B16_SINT
>(pDst
, srcPixel
); break;
682 case R10G10B10A2_SNORM
: ConvertPixelFromFloat
<R10G10B10A2_SNORM
>(pDst
, srcPixel
); break;
683 case R10G10B10A2_USCALED
: ConvertPixelFromFloat
<R10G10B10A2_USCALED
>(pDst
, srcPixel
); break;
684 case R10G10B10A2_SSCALED
: ConvertPixelFromFloat
<R10G10B10A2_SSCALED
>(pDst
, srcPixel
); break;
685 case R10G10B10A2_SINT
: ConvertPixelFromFloat
<R10G10B10A2_SINT
>(pDst
, srcPixel
); break;
686 case B10G10R10A2_SNORM
: ConvertPixelFromFloat
<B10G10R10A2_SNORM
>(pDst
, srcPixel
); break;
687 case B10G10R10A2_USCALED
: ConvertPixelFromFloat
<B10G10R10A2_USCALED
>(pDst
, srcPixel
); break;
688 case B10G10R10A2_SSCALED
: ConvertPixelFromFloat
<B10G10R10A2_SSCALED
>(pDst
, srcPixel
); break;
689 case B10G10R10A2_UINT
: ConvertPixelFromFloat
<B10G10R10A2_UINT
>(pDst
, srcPixel
); break;
690 case B10G10R10A2_SINT
: ConvertPixelFromFloat
<B10G10R10A2_SINT
>(pDst
, srcPixel
); break;
691 case R8G8B8_UINT
: ConvertPixelFromFloat
<R8G8B8_UINT
>(pDst
, srcPixel
); break;
692 case R8G8B8_SINT
: ConvertPixelFromFloat
<R8G8B8_SINT
>(pDst
, srcPixel
); break;