801 lines
33 KiB
Plaintext
801 lines
33 KiB
Plaintext
|
//=============================================================================
|
||
|
|
// D3D11 HLSL Routines for Manual Pack/Unpack of 32-bit DXGI_FORMAT_*
|
||
|
|
//=============================================================================
|
||
|
|
//
|
||
|
|
// This file contains format conversion routines for use in the
|
||
|
|
// Compute Shader or Pixel Shader on D3D11 Hardware.
|
||
|
|
//
|
||
|
|
// Skip to the end of this comment to see a summary of the routines
|
||
|
|
// provided. The rest of the text below explains why they are needed
|
||
|
|
// and how to use them.
|
||
|
|
//
|
||
|
|
// The scenario where these can be useful is if your application
|
||
|
|
// needs to simultaneously both read and write texture - i.e. in-place
|
||
|
|
// image editing.
|
||
|
|
//
|
||
|
|
// D3D11's Unordered Access View (UAV) of a Texture1D/2D/3D resource
|
||
|
|
// allows random access reads and writes to memory from a Compute Shader
|
||
|
|
// or Pixel Shader. However, the only texture format that supports this
|
||
|
|
// is DXGI_FORMAT_R32_UINT. e.g. Other more interesting formats like
|
||
|
|
// DXGI_FORMAT_R8G8B8A8_UNORM do not support simultaneous read and
|
||
|
|
// write. You can use such formats for random access writing only
|
||
|
|
// using a UAV, or reading only using a Shader Resource View (SRV).
|
||
|
|
// But for simultaneous read+write, the format conversion hardware is
|
||
|
|
// not available.
|
||
|
|
//
|
||
|
|
// There is a workaround to this limitation, involving casting the texture
|
||
|
|
// to R32_UINT when creating a UAV, as long as the original format of the
|
||
|
|
// resource supports it (most 32 bit per element formats). This allows
|
||
|
|
// simultaneous read+write as long as the shader does manual format
|
||
|
|
// unpacking on read and packing on write.
|
||
|
|
//
|
||
|
|
// The benefit is that later on, other views such as RenderTarget Views
|
||
|
|
// or ShaderResource Views on the same texture can be used with the
|
||
|
|
// proper format (e.g. DXGI_FORMAT_R16G16_FLOAT) so the hardware can
|
||
|
|
// do the usual automatic format unpack/pack and do texture filtering etc.
|
||
|
|
// where there are no hardware limitations.
|
||
|
|
//
|
||
|
|
// The sequence of actions for an application is the following:
|
||
|
|
//
|
||
|
|
// Suppose you want to make a texture than you can use a Pixel Shader
|
||
|
|
// or Compute Shader to perform in-place editing, and that the format
|
||
|
|
// you want the data to be stored in happens to be a descendent
|
||
|
|
// of of one of these formats:
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R10G10B10A2_TYPELESS
|
||
|
|
// DXGI_FORMAT_R8G8B8A8_TYPELESS
|
||
|
|
// DXGI_FORMAT_B8G8R8A8_TYPELESS
|
||
|
|
// DXGI_FORMAT_B8G8R8X8_TYPELESS
|
||
|
|
// DXGI_FORMAT_R16G16_TYPELESS
|
||
|
|
//
|
||
|
|
// e.g. DXGI_FORMAT_R10G10B10A2_UNORM is a descendent of
|
||
|
|
// DXGI_FORMAT_R10G10B10A2_TYPELESS, so it supports the
|
||
|
|
// usage pattern described here.
|
||
|
|
//
|
||
|
|
// (Formats descending from DXGI_FORMAT_R32_TYPELESS, such as
|
||
|
|
// DXGI_FORMAT_R32_FLOAT, are trivially supported without
|
||
|
|
// needing any of the format conversion help provided here.)
|
||
|
|
//
|
||
|
|
// Steps:
|
||
|
|
//
|
||
|
|
// (1) Create a texture with the appropriate _TYPELESS format above
|
||
|
|
// along with the needed bind flags, such as
|
||
|
|
// D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE.
|
||
|
|
//
|
||
|
|
// (2) For in-place image editing, create a UAV with the format
|
||
|
|
// DXGI_FORMAT_R32_UINT. D3D normally doesn't allow casting
|
||
|
|
// between different format "families", but the API makes
|
||
|
|
// an exception here.
|
||
|
|
//
|
||
|
|
// (3) In the Compute Shader or Pixel Shader, use the appropriate
|
||
|
|
// format pack/unpack routines provided in this file.
|
||
|
|
// For example if the DXGI_FORMAT_R32_UINT UAV really holds
|
||
|
|
// DXGI_FORMAT_R10G10B10A2_UNORM data, then, after reading a
|
||
|
|
// uint from the UAV into the shader, unpack by calling:
|
||
|
|
//
|
||
|
|
// XMFLOAT4 D3DX_R10G10B10A2_UNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
//
|
||
|
|
// Then to write to the UAV in the same shader, call the following
|
||
|
|
// to pack shader data into a uint that can be written out:
|
||
|
|
//
|
||
|
|
// UINT D3DX_FLOAT4_to_R10G10B10A2_UNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// (4) Other views, such as SRVs, can be created with the desired format;
|
||
|
|
// e.g. DXGI_FORMAT_R10G10B10A2_UNORM if the resource was created as
|
||
|
|
// DXGI_FORMAT_R10G10B10A2_TYPELESS. When that view is accessed by a
|
||
|
|
// shader, the hardware can do automatic type conversion as usual.
|
||
|
|
//
|
||
|
|
// Note, again, that if the shader only needs to write to a UAV, or read
|
||
|
|
// as an SRV, then none of this is needed - fully typed UAV or SRVs can
|
||
|
|
// be used. Only if simultaneous reading and writing to a UAV of a texture
|
||
|
|
// is needed are the format conversion routines provided here potentially
|
||
|
|
// useful.
|
||
|
|
//
|
||
|
|
// The following is the list of format conversion routines included in this
|
||
|
|
// file, categorized by the DXGI_FORMAT they unpack/pack. Each of the
|
||
|
|
// formats supported descends from one of the TYPELESS formats listed
|
||
|
|
// above, and supports casting to DXGI_FORMAT_R32_UINT as a UAV.
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R10G10B10A2_UNORM:
|
||
|
|
//
|
||
|
|
// XMFLOAT4 D3DX_R10G10B10A2_UNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT4_to_R10G10B10A2_UNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R10G10B10A2_UINT:
|
||
|
|
//
|
||
|
|
// XMUINT4 D3DX_R10G10B10A2_UINT_to_UINT4(UINT packedInput)
|
||
|
|
// UINT D3DX_UINT4_to_R10G10B10A2_UINT(XMUINT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R8G8B8A8_UNORM:
|
||
|
|
//
|
||
|
|
// XMFLOAT4 D3DX_R8G8B8A8_UNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT4_to_R8G8B8A8_UNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
|
||
|
|
//
|
||
|
|
// XMFLOAT4 D3DX_R8G8B8A8_UNORM_SRGB_to_FLOAT4_inexact(UINT packedInput) *
|
||
|
|
// XMFLOAT4 D3DX_R8G8B8A8_UNORM_SRGB_to_FLOAT4(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT4_to_R8G8B8A8_UNORM_SRGB(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// * The "_inexact" function above uses shader instructions that don't
|
||
|
|
// have high enough precision to give the exact answer, albeit close.
|
||
|
|
// The alternative function uses a lookup table stored in the shader
|
||
|
|
// to give an exact SRGB->float conversion.
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R8G8B8A8_UINT:
|
||
|
|
//
|
||
|
|
// XMUINT4 D3DX_R8G8B8A8_UINT_to_UINT4(UINT packedInput)
|
||
|
|
// XMUINT D3DX_UINT4_to_R8G8B8A8_UINT(XMUINT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R8G8B8A8_SNORM:
|
||
|
|
//
|
||
|
|
// XMFLOAT4 D3DX_R8G8B8A8_SNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT4_to_R8G8B8A8_SNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R8G8B8A8_SINT:
|
||
|
|
//
|
||
|
|
// XMINT4 D3DX_R8G8B8A8_SINT_to_INT4(UINT packedInput)
|
||
|
|
// UINT D3DX_INT4_to_R8G8B8A8_SINT(XMINT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_B8G8R8A8_UNORM:
|
||
|
|
//
|
||
|
|
// XMFLOAT4 D3DX_B8G8R8A8_UNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT4_to_B8G8R8A8_UNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
|
||
|
|
//
|
||
|
|
// XMFLOAT4 D3DX_B8G8R8A8_UNORM_SRGB_to_FLOAT4_inexact(UINT packedInput) *
|
||
|
|
// XMFLOAT4 D3DX_B8G8R8A8_UNORM_SRGB_to_FLOAT4(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT4_to_R8G8B8A8_UNORM_SRGB(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
//
|
||
|
|
// * The "_inexact" function above uses shader instructions that don't
|
||
|
|
// have high enough precision to give the exact answer, albeit close.
|
||
|
|
// The alternative function uses a lookup table stored in the shader
|
||
|
|
// to give an exact SRGB->float conversion.
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_B8G8R8X8_UNORM:
|
||
|
|
//
|
||
|
|
// XMFLOAT3 D3DX_B8G8R8X8_UNORM_to_FLOAT3(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT3_to_B8G8R8X8_UNORM(hlsl_precise XMFLOAT3 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_B8G8R8X8_UNORM_SRGB:
|
||
|
|
//
|
||
|
|
// XMFLOAT3 D3DX_B8G8R8X8_UNORM_SRGB_to_FLOAT3_inexact(UINT packedInput) *
|
||
|
|
// XMFLOAT3 D3DX_B8G8R8X8_UNORM_SRGB_to_FLOAT3(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT3_to_B8G8R8X8_UNORM_SRGB(hlsl_precise XMFLOAT3 unpackedInput)
|
||
|
|
//
|
||
|
|
// * The "_inexact" function above uses shader instructions that don't
|
||
|
|
// have high enough precision to give the exact answer, albeit close.
|
||
|
|
// The alternative function uses a lookup table stored in the shader
|
||
|
|
// to give an exact SRGB->float conversion.
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R16G16_FLOAT:
|
||
|
|
//
|
||
|
|
// XMFLOAT2 D3DX_R16G16_FLOAT_to_FLOAT2(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT2_to_R16G16_FLOAT(hlsl_precise XMFLOAT2 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R16G16_UNORM:
|
||
|
|
//
|
||
|
|
// XMFLOAT2 D3DX_R16G16_UNORM_to_FLOAT2(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT2_to_R16G16_UNORM(hlsl_precise FLOAT2 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R16G16_UINT:
|
||
|
|
//
|
||
|
|
// XMUINT2 D3DX_R16G16_UINT_to_UINT2(UINT packedInput)
|
||
|
|
// UINT D3DX_UINT2_to_R16G16_UINT(XMUINT2 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R16G16_SNORM:
|
||
|
|
//
|
||
|
|
// XMFLOAT2 D3DX_R16G16_SNORM_to_FLOAT2(UINT packedInput)
|
||
|
|
// UINT D3DX_FLOAT2_to_R16G16_SNORM(hlsl_precise XMFLOAT2 unpackedInput)
|
||
|
|
//
|
||
|
|
// DXGI_FORMAT_R16G16_SINT:
|
||
|
|
//
|
||
|
|
// XMINT2 D3DX_R16G16_SINT_to_INT2(UINT packedInput)
|
||
|
|
// UINT D3DX_INT2_to_R16G16_SINT(XMINT2 unpackedInput)
|
||
|
|
//
|
||
|
|
//=============================================================================
|
||
|
|
|
||
|
|
#ifndef __D3DX_DXGI_FORMAT_CONVERT_INL___
|
||
|
|
#define __D3DX_DXGI_FORMAT_CONVERT_INL___
|
||
|
|
|
||
|
|
#if HLSL_VERSION > 0
|
||
|
|
|
||
|
|
#define D3DX11INLINE
|
||
|
|
|
||
|
|
typedef int INT;
|
||
|
|
typedef uint UINT;
|
||
|
|
|
||
|
|
typedef float2 XMFLOAT2;
|
||
|
|
typedef float3 XMFLOAT3;
|
||
|
|
typedef float4 XMFLOAT4;
|
||
|
|
typedef int2 XMINT2;
|
||
|
|
typedef int4 XMINT4;
|
||
|
|
typedef uint2 XMUINT2;
|
||
|
|
typedef uint4 XMUINT4;
|
||
|
|
|
||
|
|
#define hlsl_precise precise
|
||
|
|
|
||
|
|
#define D3DX_Saturate_FLOAT(_V) saturate(_V)
|
||
|
|
#define D3DX_IsNan(_V) isnan(_V)
|
||
|
|
#define D3DX_Truncate_FLOAT(_V) trunc(_V)
|
||
|
|
|
||
|
|
#else // HLSL_VERSION > 0
|
||
|
|
|
||
|
|
#ifndef __cplusplus
|
||
|
|
#error C++ compilation required
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include <float.h>
|
||
|
|
#include <xnamath.h>
|
||
|
|
|
||
|
|
#define hlsl_precise
|
||
|
|
|
||
|
|
D3DX11INLINE FLOAT D3DX_Saturate_FLOAT(FLOAT _V)
|
||
|
|
{
|
||
|
|
return min(max(_V, 0), 1);
|
||
|
|
}
|
||
|
|
D3DX11INLINE bool D3DX_IsNan(FLOAT _V)
|
||
|
|
{
|
||
|
|
return _V != _V;
|
||
|
|
}
|
||
|
|
D3DX11INLINE FLOAT D3DX_Truncate_FLOAT(FLOAT _V)
|
||
|
|
{
|
||
|
|
return _V >= 0 ? floor(_V) : ceil(_V);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 2D Vector; 32 bit signed integer components
|
||
|
|
typedef struct _XMINT2
|
||
|
|
{
|
||
|
|
INT x;
|
||
|
|
INT y;
|
||
|
|
} XMINT2;
|
||
|
|
|
||
|
|
// 2D Vector; 32 bit unsigned integer components
|
||
|
|
typedef struct _XMUINT2
|
||
|
|
{
|
||
|
|
UINT x;
|
||
|
|
UINT y;
|
||
|
|
} XMUINT2;
|
||
|
|
|
||
|
|
// 4D Vector; 32 bit signed integer components
|
||
|
|
typedef struct _XMINT4
|
||
|
|
{
|
||
|
|
INT x;
|
||
|
|
INT y;
|
||
|
|
INT z;
|
||
|
|
INT w;
|
||
|
|
} XMINT4;
|
||
|
|
|
||
|
|
// 4D Vector; 32 bit unsigned integer components
|
||
|
|
typedef struct _XMUINT4
|
||
|
|
{
|
||
|
|
UINT x;
|
||
|
|
UINT y;
|
||
|
|
UINT z;
|
||
|
|
UINT w;
|
||
|
|
} XMUINT4;
|
||
|
|
|
||
|
|
#endif // HLSL_VERSION > 0
|
||
|
|
|
||
|
|
//=============================================================================
|
||
|
|
// SRGB Helper Functions Called By Conversions Further Below.
|
||
|
|
//=============================================================================
|
||
|
|
// SRGB_to_FLOAT_inexact is imprecise due to precision of pow implementations.
|
||
|
|
// If exact SRGB->float conversion is needed, a table lookup is provided
|
||
|
|
// further below.
|
||
|
|
D3DX11INLINE FLOAT D3DX_SRGB_to_FLOAT_inexact(hlsl_precise FLOAT val)
|
||
|
|
{
|
||
|
|
if( val < 0.04045f )
|
||
|
|
val /= 12.92f;
|
||
|
|
else
|
||
|
|
val = pow((val + 0.055f)/1.055f,2.4f);
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const UINT D3DX_SRGBTable[] =
|
||
|
|
{
|
||
|
|
0x00000000,0x399f22b4,0x3a1f22b4,0x3a6eb40e,0x3a9f22b4,0x3ac6eb61,0x3aeeb40e,0x3b0b3e5d,
|
||
|
|
0x3b1f22b4,0x3b33070b,0x3b46eb61,0x3b5b518d,0x3b70f18d,0x3b83e1c6,0x3b8fe616,0x3b9c87fd,
|
||
|
|
0x3ba9c9b7,0x3bb7ad6f,0x3bc63549,0x3bd56361,0x3be539c1,0x3bf5ba70,0x3c0373b5,0x3c0c6152,
|
||
|
|
0x3c15a703,0x3c1f45be,0x3c293e6b,0x3c3391f7,0x3c3e4149,0x3c494d43,0x3c54b6c7,0x3c607eb1,
|
||
|
|
0x3c6ca5df,0x3c792d22,0x3c830aa8,0x3c89af9f,0x3c9085db,0x3c978dc5,0x3c9ec7c2,0x3ca63433,
|
||
|
|
0x3cadd37d,0x3cb5a601,0x3cbdac20,0x3cc5e639,0x3cce54ab,0x3cd6f7d5,0x3cdfd010,0x3ce8ddb9,
|
||
|
|
0x3cf2212c,0x3cfb9ac1,0x3d02a569,0x3d0798dc,0x3d0ca7e6,0x3d11d2af,0x3d171963,0x3d1c7c2e,
|
||
|
|
0x3d21fb3c,0x3d2796b2,0x3d2d4ebb,0x3d332380,0x3d39152b,0x3d3f23e3,0x3d454fd1,0x3d4b991c,
|
||
|
|
0x3d51ffef,0x3d58846a,0x3d5f26b7,0x3d65e6fe,0x3d6cc564,0x3d73c20f,0x3d7add29,0x3d810b67,
|
||
|
|
0x3d84b795,0x3d887330,0x3d8c3e4a,0x3d9018f6,0x3d940345,0x3d97fd4a,0x3d9c0716,0x3da020bb,
|
||
|
|
0x3da44a4b,0x3da883d7,0x3daccd70,0x3db12728,0x3db59112,0x3dba0b3b,0x3dbe95b5,0x3dc33092,
|
||
|
|
0x3dc7dbe2,0x3dcc97b6,0x3dd1641f,0x3dd6412c,0x3ddb2eef,0x3de02d77,0x3de53cd5,0x3dea5d19,
|
||
|
|
0x3def8e52,0x3df4d091,0x3dfa23e8,0x3dff8861,0x3e027f07,0x3e054280,0x3e080ea3,0x3e0ae378,
|
||
|
|
0x3e0dc105,0x3e10a754,0x3e13966b,0x3e168e52,0x3e198f10,0x3e1c98ad,0x3e1fab30,0x3e22c6a3,
|
||
|
|
0x3e25eb09,0x3e29186c,0x3e2c4ed0,0x3e2f8e41,0x3e32d6c4,0x3e362861,0x3e39831e,0x3e3ce703,
|
||
|
|
0x3e405416,0x3e43ca5f,0x3e4749e4,0x3e4ad2ae,0x3e4e64c2,0x3e520027,0x3e55a4e6,0x3e595303,
|
||
|
|
0x3e5d0a8b,0x3e60cb7c,0x3e6495e0,0x3e6869bf,0x3e6c4720,0x3e702e0c,0x3e741e84,0x3e781890,
|
||
|
|
0x3e7c1c38,0x3e8014c2,0x3e82203c,0x3e84308d,0x3e8645ba,0x3e885fc5,0x3e8a7eb2,0x3e8ca283,
|
||
|
|
0x3e8ecb3d,0x3e90f8e1,0x3e932b74,0x3e9562f8,0x3e979f71,0x3e99e0e2,0x3e9c274e,0x3e9e72b7,
|
||
|
|
0x3ea0c322,0x3ea31892,0x3ea57308,0x3ea7d289,0x3eaa3718,0x3eaca0b7,0x3eaf0f69,0x3eb18333,
|
||
|
|
0x3eb3fc18,0x3eb67a18,0x3eb8fd37,0x3ebb8579,0x3ebe12e1,0x3ec0a571,0x3ec33d2d,0x3ec5da17,
|
||
|
|
0x3ec87c33,0x3ecb2383,0x3ecdd00b,0x3ed081cd,0x3ed338cc,0x3ed5f50b,0x3ed8b68d,0x3edb7d54,
|
||
|
|
0x3ede4965,0x3ee11ac1,0x3ee3f16b,0x3ee6cd67,0x3ee9aeb6,0x3eec955d,0x3eef815d,0x3ef272ba,
|
||
|
|
0x3ef56976,0x3ef86594,0x3efb6717,0x3efe6e02,0x3f00bd2d,0x3f02460e,0x3f03d1a7,0x3f055ff9,
|
||
|
|
0x3f06f106,0x3f0884cf,0x3f0a1b56,0x3f0bb49b,0x3f0d50a0,0x3f0eef67,0x3f1090f1,0x3f12353e,
|
||
|
|
0x3f13dc51,0x3f15862b,0x3f1732cd,0x3f18e239,0x3f1a946f,0x3f1c4971,0x3f1e0141,0x3f1fbbdf,
|
||
|
|
0x3f21794e,0x3f23398e,0x3f24fca0,0x3f26c286,0x3f288b41,0x3f2a56d3,0x3f2c253d,0x3f2df680,
|
||
|
|
0x3f2fca9e,0x3f31a197,0x3f337b6c,0x3f355820,0x3f3737b3,0x3f391a26,0x3f3aff7c,0x3f3ce7b5,
|
||
|
|
0x3f3ed2d2,0x3f40c0d4,0x3f42b1be,0x3f44a590,0x3f469c4b,0x3f4895f1,0x3f4a9282,0x3f4c9201,
|
||
|
|
0x3f4e946e,0x3f5099cb,0x3f52a218,0x3f54ad57,0x3f56bb8a,0x3f58ccb0,0x3f5ae0cd,0x3f5cf7e0,
|
||
|
|
0x3f5f11ec,0x3f612eee,0x3f634eef,0x3f6571e9,0x3f6797e3,0x3f69c0d6,0x3f6beccd,0x3f6e1bbf,
|
||
|
|
0x3f704db8,0x3f7282af,0x3f74baae,0x3f76f5ae,0x3f7933b9,0x3f7b74c6,0x3f7db8e0,0x3f800000
|
||
|
|
};
|
||
|
|
|
||
|
|
D3DX11INLINE FLOAT D3DX_SRGB_to_FLOAT(UINT val)
|
||
|
|
{
|
||
|
|
#if HLSL_VERSION > 0
|
||
|
|
return asfloat(D3DX_SRGBTable[val]);
|
||
|
|
#else
|
||
|
|
return *(FLOAT*)&D3DX_SRGBTable[val];
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE FLOAT D3DX_FLOAT_to_SRGB(hlsl_precise FLOAT val)
|
||
|
|
{
|
||
|
|
if( val < 0.0031308f )
|
||
|
|
val *= 12.92f;
|
||
|
|
else
|
||
|
|
val = 1.055f * pow(val,1.0f/2.4f) - 0.055f;
|
||
|
|
return val;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE FLOAT D3DX_SaturateSigned_FLOAT(FLOAT _V)
|
||
|
|
{
|
||
|
|
if (D3DX_IsNan(_V))
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return min(max(_V, -1), 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT_to_UINT(FLOAT _V,
|
||
|
|
FLOAT _Scale)
|
||
|
|
{
|
||
|
|
return (UINT)floor(_V * _Scale + 0.5f);
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE FLOAT D3DX_INT_to_FLOAT(INT _V,
|
||
|
|
FLOAT _Scale)
|
||
|
|
{
|
||
|
|
FLOAT Scaled = (FLOAT)_V / _Scale;
|
||
|
|
// The integer is a two's-complement signed
|
||
|
|
// number so the negative range is slightly
|
||
|
|
// larger than the positive range, meaning
|
||
|
|
// the scaled value can be slight less than -1.
|
||
|
|
// Clamp to keep the float range [-1, 1].
|
||
|
|
return max(Scaled, -1.0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE INT D3DX_FLOAT_to_INT(FLOAT _V,
|
||
|
|
FLOAT _Scale)
|
||
|
|
{
|
||
|
|
return (INT)D3DX_Truncate_FLOAT(_V * _Scale + (_V >= 0 ? 0.5f : -0.5f));
|
||
|
|
}
|
||
|
|
|
||
|
|
//=============================================================================
|
||
|
|
// Conversion routines
|
||
|
|
//=============================================================================
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R10B10G10A2_UNORM <-> FLOAT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_R10G10B10A2_UNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
unpackedOutput.x = (FLOAT) (packedInput & 0x000003ff) / 1023;
|
||
|
|
unpackedOutput.y = (FLOAT)(((packedInput>>10) & 0x000003ff)) / 1023;
|
||
|
|
unpackedOutput.z = (FLOAT)(((packedInput>>20) & 0x000003ff)) / 1023;
|
||
|
|
unpackedOutput.w = (FLOAT)(((packedInput>>30) & 0x00000003)) / 3;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT4_to_R10G10B10A2_UNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.x), 1023)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.y), 1023)<<10) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.z), 1023)<<20) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.w), 3)<<30) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R10B10G10A2_UINT <-> UINT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMUINT4 D3DX_R10G10B10A2_UINT_to_UINT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
XMUINT4 unpackedOutput;
|
||
|
|
unpackedOutput.x = packedInput & 0x000003ff;
|
||
|
|
unpackedOutput.y = (packedInput>>10) & 0x000003ff;
|
||
|
|
unpackedOutput.z = (packedInput>>20) & 0x000003ff;
|
||
|
|
unpackedOutput.w = (packedInput>>30) & 0x00000003;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_UINT4_to_R10G10B10A2_UINT(XMUINT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.x = min(unpackedInput.x, 0x000003ff);
|
||
|
|
unpackedInput.y = min(unpackedInput.y, 0x000003ff);
|
||
|
|
unpackedInput.z = min(unpackedInput.z, 0x000003ff);
|
||
|
|
unpackedInput.w = min(unpackedInput.w, 0x00000003);
|
||
|
|
packedOutput = ( (unpackedInput.x) |
|
||
|
|
((unpackedInput.y)<<10) |
|
||
|
|
((unpackedInput.z)<<20) |
|
||
|
|
((unpackedInput.w)<<30) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R8G8B8A8_UNORM <-> FLOAT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_R8G8B8A8_UNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
unpackedOutput.x = (FLOAT) (packedInput & 0x000000ff) / 255;
|
||
|
|
unpackedOutput.y = (FLOAT)(((packedInput>> 8) & 0x000000ff)) / 255;
|
||
|
|
unpackedOutput.z = (FLOAT)(((packedInput>>16) & 0x000000ff)) / 255;
|
||
|
|
unpackedOutput.w = (FLOAT) (packedInput>>24) / 255;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT4_to_R8G8B8A8_UNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.x), 255)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.y), 255)<< 8) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.z), 255)<<16) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.w), 255)<<24) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R8G8B8A8_UNORM_SRGB <-> FLOAT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_R8G8B8A8_UNORM_SRGB_to_FLOAT4_inexact(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
unpackedOutput.x = D3DX_SRGB_to_FLOAT_inexact(((FLOAT) (packedInput & 0x000000ff) )/255);
|
||
|
|
unpackedOutput.y = D3DX_SRGB_to_FLOAT_inexact(((FLOAT)(((packedInput>> 8) & 0x000000ff)))/255);
|
||
|
|
unpackedOutput.z = D3DX_SRGB_to_FLOAT_inexact(((FLOAT)(((packedInput>>16) & 0x000000ff)))/255);
|
||
|
|
unpackedOutput.w = (FLOAT)(packedInput>>24) / 255;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_R8G8B8A8_UNORM_SRGB_to_FLOAT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
unpackedOutput.x = D3DX_SRGB_to_FLOAT( (packedInput & 0x000000ff) );
|
||
|
|
unpackedOutput.y = D3DX_SRGB_to_FLOAT((((packedInput>> 8) & 0x000000ff)));
|
||
|
|
unpackedOutput.z = D3DX_SRGB_to_FLOAT((((packedInput>>16) & 0x000000ff)));
|
||
|
|
unpackedOutput.w = (FLOAT)(packedInput>>24) / 255;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT4_to_R8G8B8A8_UNORM_SRGB(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.x = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.x));
|
||
|
|
unpackedInput.y = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.y));
|
||
|
|
unpackedInput.z = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.z));
|
||
|
|
unpackedInput.w = D3DX_Saturate_FLOAT(unpackedInput.w);
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(unpackedInput.x, 255)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.y, 255)<< 8) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.z, 255)<<16) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.w, 255)<<24) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R8G8B8A8_UINT <-> UINT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMUINT4 D3DX_R8G8B8A8_UINT_to_UINT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
XMUINT4 unpackedOutput;
|
||
|
|
unpackedOutput.x = packedInput & 0x000000ff;
|
||
|
|
unpackedOutput.y = (packedInput>> 8) & 0x000000ff;
|
||
|
|
unpackedOutput.z = (packedInput>>16) & 0x000000ff;
|
||
|
|
unpackedOutput.w = packedInput>>24;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_UINT4_to_R8G8B8A8_UINT(XMUINT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.x = min(unpackedInput.x, 0x000000ff);
|
||
|
|
unpackedInput.y = min(unpackedInput.y, 0x000000ff);
|
||
|
|
unpackedInput.z = min(unpackedInput.z, 0x000000ff);
|
||
|
|
unpackedInput.w = min(unpackedInput.w, 0x000000ff);
|
||
|
|
packedOutput = ( unpackedInput.x |
|
||
|
|
(unpackedInput.y<< 8) |
|
||
|
|
(unpackedInput.z<<16) |
|
||
|
|
(unpackedInput.w<<24) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R8G8B8A8_SNORM <-> FLOAT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_R8G8B8A8_SNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
XMINT4 signExtendedBits;
|
||
|
|
signExtendedBits.x = (INT)(packedInput << 24) >> 24;
|
||
|
|
signExtendedBits.y = (INT)((packedInput << 16) & 0xff000000) >> 24;
|
||
|
|
signExtendedBits.z = (INT)((packedInput << 8) & 0xff000000) >> 24;
|
||
|
|
signExtendedBits.w = (INT)(packedInput & 0xff000000) >> 24;
|
||
|
|
unpackedOutput.x = D3DX_INT_to_FLOAT(signExtendedBits.x, 127);
|
||
|
|
unpackedOutput.y = D3DX_INT_to_FLOAT(signExtendedBits.y, 127);
|
||
|
|
unpackedOutput.z = D3DX_INT_to_FLOAT(signExtendedBits.z, 127);
|
||
|
|
unpackedOutput.w = D3DX_INT_to_FLOAT(signExtendedBits.w, 127);
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT4_to_R8G8B8A8_SNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_INT(D3DX_SaturateSigned_FLOAT(unpackedInput.x), 127) & 0x000000ff) |
|
||
|
|
((D3DX_FLOAT_to_INT(D3DX_SaturateSigned_FLOAT(unpackedInput.y), 127) & 0x000000ff)<< 8) |
|
||
|
|
((D3DX_FLOAT_to_INT(D3DX_SaturateSigned_FLOAT(unpackedInput.z), 127) & 0x000000ff)<<16) |
|
||
|
|
((D3DX_FLOAT_to_INT(D3DX_SaturateSigned_FLOAT(unpackedInput.w), 127)) <<24) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R8G8B8A8_SINT <-> INT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMINT4 D3DX_R8G8B8A8_SINT_to_INT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
XMINT4 unpackedOutput;
|
||
|
|
unpackedOutput.x = (INT)(packedInput << 24) >> 24;
|
||
|
|
unpackedOutput.y = (INT)((packedInput << 16) & 0xff000000) >> 24;
|
||
|
|
unpackedOutput.z = (INT)((packedInput << 8) & 0xff000000) >> 24;
|
||
|
|
unpackedOutput.w = (INT)(packedInput & 0xff000000) >> 24;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_INT4_to_R8G8B8A8_SINT(XMINT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.x = max(min(unpackedInput.x,127),-128);
|
||
|
|
unpackedInput.y = max(min(unpackedInput.y,127),-128);
|
||
|
|
unpackedInput.z = max(min(unpackedInput.z,127),-128);
|
||
|
|
unpackedInput.w = max(min(unpackedInput.w,127),-128);
|
||
|
|
packedOutput = ( (unpackedInput.x & 0x000000ff) |
|
||
|
|
((unpackedInput.y & 0x000000ff)<< 8) |
|
||
|
|
((unpackedInput.z & 0x000000ff)<<16) |
|
||
|
|
(unpackedInput.w <<24) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// B8G8R8A8_UNORM <-> FLOAT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_B8G8R8A8_UNORM_to_FLOAT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
unpackedOutput.z = (FLOAT) (packedInput & 0x000000ff) / 255;
|
||
|
|
unpackedOutput.y = (FLOAT)(((packedInput>> 8) & 0x000000ff)) / 255;
|
||
|
|
unpackedOutput.x = (FLOAT)(((packedInput>>16) & 0x000000ff)) / 255;
|
||
|
|
unpackedOutput.w = (FLOAT) (packedInput>>24) / 255;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT4_to_B8G8R8A8_UNORM(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.z), 255)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.y), 255)<< 8) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.x), 255)<<16) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.w), 255)<<24) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// B8G8R8A8_UNORM_SRGB <-> FLOAT4
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_B8G8R8A8_UNORM_SRGB_to_FLOAT4_inexact(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
unpackedOutput.z = D3DX_SRGB_to_FLOAT_inexact(((FLOAT) (packedInput & 0x000000ff) )/255);
|
||
|
|
unpackedOutput.y = D3DX_SRGB_to_FLOAT_inexact(((FLOAT)(((packedInput>> 8) & 0x000000ff)))/255);
|
||
|
|
unpackedOutput.x = D3DX_SRGB_to_FLOAT_inexact(((FLOAT)(((packedInput>>16) & 0x000000ff)))/255);
|
||
|
|
unpackedOutput.w = (FLOAT)(packedInput>>24) / 255;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE XMFLOAT4 D3DX_B8G8R8A8_UNORM_SRGB_to_FLOAT4(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT4 unpackedOutput;
|
||
|
|
unpackedOutput.z = D3DX_SRGB_to_FLOAT( (packedInput & 0x000000ff) );
|
||
|
|
unpackedOutput.y = D3DX_SRGB_to_FLOAT((((packedInput>> 8) & 0x000000ff)));
|
||
|
|
unpackedOutput.x = D3DX_SRGB_to_FLOAT((((packedInput>>16) & 0x000000ff)));
|
||
|
|
unpackedOutput.w = (FLOAT)(packedInput>>24) / 255;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT4_to_B8G8R8A8_UNORM_SRGB(hlsl_precise XMFLOAT4 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.z = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.z));
|
||
|
|
unpackedInput.y = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.y));
|
||
|
|
unpackedInput.x = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.x));
|
||
|
|
unpackedInput.w = D3DX_Saturate_FLOAT(unpackedInput.w);
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(unpackedInput.z, 255)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.y, 255)<< 8) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.x, 255)<<16) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.w, 255)<<24) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// B8G8R8X8_UNORM <-> FLOAT3
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT3 D3DX_B8G8R8X8_UNORM_to_FLOAT3(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT3 unpackedOutput;
|
||
|
|
unpackedOutput.z = (FLOAT) (packedInput & 0x000000ff) / 255;
|
||
|
|
unpackedOutput.y = (FLOAT)(((packedInput>> 8) & 0x000000ff)) / 255;
|
||
|
|
unpackedOutput.x = (FLOAT)(((packedInput>>16) & 0x000000ff)) / 255;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT3_to_B8G8R8X8_UNORM(hlsl_precise XMFLOAT3 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.z), 255)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.y), 255)<< 8) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.x), 255)<<16) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// B8G8R8X8_UNORM_SRGB <-> FLOAT3
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT3 D3DX_B8G8R8X8_UNORM_SRGB_to_FLOAT3_inexact(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT3 unpackedOutput;
|
||
|
|
unpackedOutput.z = D3DX_SRGB_to_FLOAT_inexact(((FLOAT) (packedInput & 0x000000ff) )/255);
|
||
|
|
unpackedOutput.y = D3DX_SRGB_to_FLOAT_inexact(((FLOAT)(((packedInput>> 8) & 0x000000ff)))/255);
|
||
|
|
unpackedOutput.x = D3DX_SRGB_to_FLOAT_inexact(((FLOAT)(((packedInput>>16) & 0x000000ff)))/255);
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE XMFLOAT3 D3DX_B8G8R8X8_UNORM_SRGB_to_FLOAT3(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT3 unpackedOutput;
|
||
|
|
unpackedOutput.z = D3DX_SRGB_to_FLOAT( (packedInput & 0x000000ff) );
|
||
|
|
unpackedOutput.y = D3DX_SRGB_to_FLOAT((((packedInput>> 8) & 0x000000ff)));
|
||
|
|
unpackedOutput.x = D3DX_SRGB_to_FLOAT((((packedInput>>16) & 0x000000ff)));
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT3_to_B8G8R8X8_UNORM_SRGB(hlsl_precise XMFLOAT3 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.z = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.z));
|
||
|
|
unpackedInput.y = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.y));
|
||
|
|
unpackedInput.x = D3DX_FLOAT_to_SRGB(D3DX_Saturate_FLOAT(unpackedInput.x));
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(unpackedInput.z, 255)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.y, 255)<< 8) |
|
||
|
|
(D3DX_FLOAT_to_UINT(unpackedInput.x, 255)<<16) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R16G16_FLOAT <-> FLOAT2
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#if HLSL_VERSION > 0
|
||
|
|
|
||
|
|
D3DX11INLINE XMFLOAT2 D3DX_R16G16_FLOAT_to_FLOAT2(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT2 unpackedOutput;
|
||
|
|
unpackedOutput.x = f16tof32(packedInput&0x0000ffff);
|
||
|
|
unpackedOutput.y = f16tof32(packedInput>>16);
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT2_to_R16G16_FLOAT(hlsl_precise XMFLOAT2 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = asuint(f32tof16(unpackedInput.x)) |
|
||
|
|
(asuint(f32tof16(unpackedInput.y)) << 16);
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // HLSL_VERSION > 0
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R16G16_UNORM <-> FLOAT2
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT2 D3DX_R16G16_UNORM_to_FLOAT2(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT2 unpackedOutput;
|
||
|
|
unpackedOutput.x = (FLOAT) (packedInput & 0x0000ffff) / 65535;
|
||
|
|
unpackedOutput.y = (FLOAT) (packedInput>>16) / 65535;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT2_to_R16G16_UNORM(hlsl_precise XMFLOAT2 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.x), 65535)) |
|
||
|
|
(D3DX_FLOAT_to_UINT(D3DX_Saturate_FLOAT(unpackedInput.y), 65535)<< 16) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R16G16_UINT <-> UINT2
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMUINT2 D3DX_R16G16_UINT_to_UINT2(UINT packedInput)
|
||
|
|
{
|
||
|
|
XMUINT2 unpackedOutput;
|
||
|
|
unpackedOutput.x = packedInput & 0x0000ffff;
|
||
|
|
unpackedOutput.y = packedInput>>16;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_UINT2_to_R16G16_UINT(XMUINT2 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.x = min(unpackedInput.x,0x0000ffff);
|
||
|
|
unpackedInput.y = min(unpackedInput.y,0x0000ffff);
|
||
|
|
packedOutput = ( unpackedInput.x |
|
||
|
|
(unpackedInput.y<<16) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R16G16_SNORM <-> FLOAT2
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMFLOAT2 D3DX_R16G16_SNORM_to_FLOAT2(UINT packedInput)
|
||
|
|
{
|
||
|
|
hlsl_precise XMFLOAT2 unpackedOutput;
|
||
|
|
XMINT2 signExtendedBits;
|
||
|
|
signExtendedBits.x = (INT)(packedInput << 16) >> 16;
|
||
|
|
signExtendedBits.y = (INT)(packedInput & 0xffff0000) >> 16;
|
||
|
|
unpackedOutput.x = D3DX_INT_to_FLOAT(signExtendedBits.x, 32767);
|
||
|
|
unpackedOutput.y = D3DX_INT_to_FLOAT(signExtendedBits.y, 32767);
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_FLOAT2_to_R16G16_SNORM(hlsl_precise XMFLOAT2 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
packedOutput = ( (D3DX_FLOAT_to_INT(D3DX_SaturateSigned_FLOAT(unpackedInput.x), 32767) & 0x0000ffff) |
|
||
|
|
(D3DX_FLOAT_to_INT(D3DX_SaturateSigned_FLOAT(unpackedInput.y), 32767) <<16) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
// R16G16_SINT <-> INT2
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
D3DX11INLINE XMINT2 D3DX_R16G16_SINT_to_INT2(UINT packedInput)
|
||
|
|
{
|
||
|
|
XMINT2 unpackedOutput;
|
||
|
|
unpackedOutput.x = (INT)(packedInput << 16) >> 16;
|
||
|
|
unpackedOutput.y = (INT)(packedInput & 0xffff0000) >> 16;
|
||
|
|
return unpackedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
D3DX11INLINE UINT D3DX_INT2_to_R16G16_SINT(XMINT2 unpackedInput)
|
||
|
|
{
|
||
|
|
UINT packedOutput;
|
||
|
|
unpackedInput.x = max(min(unpackedInput.x,32767),-32768);
|
||
|
|
unpackedInput.y = max(min(unpackedInput.y,32767),-32768);
|
||
|
|
packedOutput = ( (unpackedInput.x & 0x0000ffff) |
|
||
|
|
(unpackedInput.y <<16) );
|
||
|
|
return packedOutput;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // __D3DX_DXGI_FORMAT_CONVERT_INL___
|