Justin Marshall
572 lines
27 KiB
C++
572 lines
27 KiB
C++
/*
|
|
|
|
Do not use render parms in this file directly or they will be included in every single
|
|
vertex and fragment program which may come at a significant performance penalty.
|
|
For convenience render parms may be used in a #define declared in this file and such
|
|
a define may then be used in the actual vertex or fragment program that needs it.
|
|
|
|
*/
|
|
|
|
#if defined( XBOX )
|
|
#define BRANCH [branch]
|
|
#define IFANY [ifAny]
|
|
#elif defined( PS3 )
|
|
#define BRANCH [branch]
|
|
#define IFANY
|
|
#else
|
|
#define BRANCH
|
|
#define IFANY
|
|
#endif
|
|
|
|
static float dot2( float2 a, float2 b ) { return dot( a, b ); }
|
|
static float dot3( float3 a, float3 b ) { return dot( a, b ); }
|
|
static float dot3( float3 a, float4 b ) { return dot( a, b.xyz ); }
|
|
static float dot3( float4 a, float3 b ) { return dot( a.xyz, b ); }
|
|
static float dot3( float4 a, float4 b ) { return dot( a.xyz, b.xyz ); }
|
|
static float dot4( float4 a, float4 b ) { return dot( a, b ); }
|
|
static float dot4( float2 a, float4 b ) { return dot( float4( a, 0, 1 ), b ); }
|
|
|
|
#ifdef PC_D3D
|
|
#define sampler2D Texture2D
|
|
#define samplerCUBE TextureCube
|
|
#define samplerRECT Texture2D // FIXME: Rect support
|
|
#endif
|
|
|
|
#ifdef GLSL
|
|
#define anyEqual( x, y ) any( equal( x, y ) )
|
|
#define anyNotEqual( x, y ) any( notEqual( x, y ) )
|
|
#define anyNotEqualZero( x ) max( sign( x ), 0.0 )
|
|
#define fmod( x, y ) mod( x, y )
|
|
#define SineCosine( x, s, c ) s = sin( x ); c = cos( x );
|
|
#else
|
|
#define anyEqual( x, y ) any( (x) == (y) )
|
|
#define anyNotEqual( x, y ) any( (x) != (y) )
|
|
#define anyNotEqualZero( x ) any( (x) )
|
|
#define greaterThanEqual( x, y ) ( (x) >= (y) )
|
|
#define SineCosine( x, s, c ) sincos( x, s, c );
|
|
|
|
static half dot2( half2 a, half2 b ) { return dot( a, b ); }
|
|
static half dot3( half3 a, half3 b ) { return dot( a, b ); }
|
|
static half dot3( half3 a, half4 b ) { return dot( a, b.xyz ); }
|
|
static half dot3( half4 a, half3 b ) { return dot( a.xyz, b ); }
|
|
static half dot3( half4 a, half4 b ) { return dot( a.xyz, b.xyz ); }
|
|
static half dot4( half4 a, half4 b ) { return dot( a, b ); }
|
|
static half dot4( half2 a, half4 b ) { return dot( half4( a, 0, 1 ), b ); }
|
|
|
|
#define sampler2DShadow sampler2D
|
|
#define samplerCUBEShadow samplerCUBE
|
|
#define samplerRECTShadow samplerRECT
|
|
#endif
|
|
|
|
static half PAGE_SIZE = 128;
|
|
static half PAGE_BORDER = 4;
|
|
static half PAGE_SIZE_LOG2 = 7;
|
|
static half PAYLOAD_SIZE = PAGE_SIZE - 2 * PAGE_BORDER;
|
|
static half PAYLOAD_SIZE_LOG2 = 6.907;
|
|
|
|
#ifdef XBOX
|
|
// these are here because HLSL does not implement vector constructors with a single scalar parameter
|
|
half2 _half2( float x ) { return half2( x, x ); }
|
|
half3 _half3( float x ) { return half3( x, x, x ); }
|
|
half4 _half4( float x ) { return half4( x, x, x, x ); }
|
|
float2 _float2( float x ) { return float2( x, x ); }
|
|
float3 _float3( float x ) { return float3( x, x, x ); }
|
|
float4 _float4( float x ) { return float4( x, x, x, x ); }
|
|
|
|
static float4 h4tex2D( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 h4tex2Dproj( sampler2D image, float3 texcoord ) { return tex2Dproj( image, float4( texcoord.xy, 0, texcoord.z ) ); }
|
|
static float4 texPhys( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return tex2D( image, texcoord, dx, dy ); }
|
|
static float4 h4texPhys( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 h4texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return tex2D( image, texcoord, dx, dy ); }
|
|
// return the depth value at texcoord.xy
|
|
static float tex2Ddepth( sampler2D image, float2 texcoord ) { return 1.0 - tex2D( image, texcoord ).x; }
|
|
static float tex2Ddepth_fast( sampler2D image, float2 texcoord ) { return 1.0 - tex2D( image, texcoord ).x; }
|
|
// compare texcoord.z with the depth value at texcoord.xy and return 1 if less and 0 if larger equal
|
|
static float shadow2Ddepth( sampler2DShadow image, float3 texcoord ) { return float( ( 1.0 - tex2D( image, texcoord.xy ).x ) >= texcoord.z ); }
|
|
static float4 swizzleColor( float4 color ) { return color.abgr; }
|
|
static float2 screenPosToTexcoord( float2 pos, float4 bias_scale ) { return ( pos * bias_scale.zw + bias_scale.xy ); }
|
|
bool bHardwareSkinning : register(b1);
|
|
bool bHardwareMorphing : register(b2);
|
|
#endif
|
|
|
|
#ifdef PS3
|
|
#define _half2( x ) half2( x )
|
|
#define _half3( x ) half3( x )
|
|
#define _half4( x ) half4( x )
|
|
#define _float2( x ) float2( x )
|
|
#define _float3( x ) float3( x )
|
|
#define _float4( x ) float4( x )
|
|
|
|
static float4 texPhys( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return tex2D( image, texcoord, dx, dy ); }
|
|
static half4 h4texPhys( sampler2D image, float2 texcoord ) { return h4tex2D( image, texcoord ); }
|
|
static half4 h4texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return h4tex2D( image, texcoord, dx, dy ); }
|
|
// return the depth value at texcoord.xy
|
|
static float tex2Ddepth( sampler2D image, float2 texcoord ) { return texDepth2D_precise( image, texcoord ); }
|
|
static float tex2Ddepth_fast( sampler2D image, float2 texcoord ) {
|
|
// Perform most accurate integer reconstruction using a half precision multiply.
|
|
// Make sure the assember code looks like this:
|
|
//
|
|
// TEXR H0, R1, TEX0;
|
|
// MULH H0, H0, {0x437f0000(255), 0x00000000(0), 0x00000000(0), 0x00000000(0)}.x;
|
|
// DP3R R1.z, H0, {0x3b800000(0.00390625), 0x37800000(1.52588e-005), 0x33800000(5.96046e-008), 0x00000000(0)};
|
|
//
|
|
half4 dt = h4tex2D( image, texcoord ) * half( 255.0 );
|
|
return dot( dt, float4( 1.0 / 256, 1.0 / 256 / 256, 1.0 / 256 / 256 / 256, 0.0 ) );
|
|
}
|
|
// compare the depth value at texcoord.xy with texcoord.z and return 0 if less and 1 if larger equal
|
|
static float shadow2Ddepth( sampler2DShadow image, float3 texcoord ) { return tex2D( image, texcoord ).x; }
|
|
static float4 swizzleColor( float4 color ) { return color; }
|
|
static float2 screenPosToTexcoord( float2 pos, float4 bias_scale ) { return ( pos * bias_scale.zw + bias_scale.xy ); }
|
|
bool hardwareSkinning : b1;
|
|
bool hardwareMorphing : b2;
|
|
#endif
|
|
|
|
#if defined( PC_D3D )
|
|
|
|
// these are here because HLSL does not implement vector constructors with a single scalar parameter
|
|
half2 _half2( float x ) { return half2( x, x ); }
|
|
half3 _half3( float x ) { return half3( x, x, x ); }
|
|
half4 _half4( float x ) { return half4( x, x, x, x ); }
|
|
float2 _float2( float x ) { return float2( x, x ); }
|
|
float3 _float3( float x ) { return float3( x, x, x ); }
|
|
float4 _float4( float x ) { return float4( x, x, x, x ); }
|
|
|
|
SamplerState samplerGeneric : register( s0 ); // FIXME
|
|
static float4 tex2D( sampler2D image, float2 texcoord ) { return image.Sample( samplerGeneric, texcoord ); }
|
|
static float4 tex2Dproj( sampler2D image, float3 texcoord ) { return image.Sample( samplerGeneric, texcoord ); }
|
|
static float4 tex2DGrad( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return image.SampleGrad( samplerGeneric, texcoord, dx, dy ); }
|
|
static float4 tex2Dlod( sampler2D image, float4 texcoord ) { return image.SampleLevel( samplerGeneric, texcoord.xy, texcoord.w, 0 ); }
|
|
static float4 tex2Dbias( sampler2D image, float4 texcoord ) { return image.SampleBias( samplerGeneric, texcoord.xy, texcoord.w ); }
|
|
static float4 texCUBE( samplerCUBE image, float3 texcoord ) { return image.Sample( samplerGeneric, texcoord ); }
|
|
static float4 texCUBElod( samplerCUBE image, float4 texcoord ) { return image.SampleLevel( samplerGeneric, texcoord.xyz, texcoord.w ); }
|
|
|
|
static float4 h4tex2D( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 h4tex2Dproj( sampler2D image, float3 texcoord ) { return tex2Dproj( image, float4( texcoord.xy, 0, texcoord.z ) ); }
|
|
static float4 texPhys( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return tex2DGrad( image, texcoord, dx, dy ); }
|
|
static float4 h4texPhys( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 h4texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return tex2DGrad( image, texcoord, dx, dy ); }
|
|
// return the depth value at texcoord.xy
|
|
static float tex2Ddepth( sampler2D image, float2 texcoord ) { return 1.0 - tex2D( image, texcoord ).x; }
|
|
static float tex2Ddepth_fast( sampler2D image, float2 texcoord ) { return 1.0 - tex2D( image, texcoord ).x; }
|
|
// compare texcoord.z with the depth value at texcoord.xy and return 1 if less and 0 if larger equal
|
|
static float shadow2Ddepth( sampler2DShadow image, float3 texcoord ) { return float( ( 1.0 - tex2D( image, texcoord.xy ).x ) >= texcoord.z ); }
|
|
static float4 swizzleColor( float4 color ) { return color.rgba; }
|
|
static float2 screenPosToTexcoord( float2 pos, float4 bias_scale ) { return ( pos * bias_scale.zw + bias_scale.xy ); }
|
|
bool bHardwareSkinning : register(b1);
|
|
bool bHardwareMorphing : register(b2);
|
|
#elif defined( PC )
|
|
|
|
#define _half2( x ) half2( x )
|
|
#define _half3( x ) half3( x )
|
|
#define _half4( x ) half4( x )
|
|
#define _float2( x ) float2( x )
|
|
#define _float3( x ) float3( x )
|
|
#define _float4( x ) float4( x )
|
|
|
|
static float4 h4tex2D( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 h4tex2Dproj( sampler2D image, float3 texcoord ) { return tex2Dproj( image, texcoord ); }
|
|
static float4 texPhys( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return tex2D( image, texcoord, dx, dy ); }
|
|
static float4 h4texPhys( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ); }
|
|
static float4 h4texPhys( sampler2D image, float2 texcoord, float2 dx, float2 dy ) { return tex2D( image, texcoord, dx, dy ); }
|
|
// return the depth value at texcoord.xy
|
|
static float tex2Ddepth( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ).x; }
|
|
static float tex2Ddepth_fast( sampler2D image, float2 texcoord ) { return tex2D( image, texcoord ).x; }
|
|
// compare the depth value at texcoord.xy with texcoord.z and return 0 if less and 1 if larger equal
|
|
static float shadow2Ddepth( sampler2DShadow image, float3 texcoord ) { return tex2D( image, texcoord ).x; }
|
|
static float4 swizzleColor( float4 color ) { return color; }
|
|
static float2 screenPosToTexcoord( float2 pos, float4 bias_scale ) { return ( pos * bias_scale.zw + bias_scale.xy ); }
|
|
#endif
|
|
|
|
static const half4 matrixRGB1toCoCg1YX = half4( 0.50, 0.0, -0.50, 0.50196078 ); // Co
|
|
static const half4 matrixRGB1toCoCg1YY = half4( -0.25, 0.5, -0.25, 0.50196078 ); // Cg
|
|
static const half4 matrixRGB1toCoCg1YZ = half4( 0.0, 0.0, 0.0, 1.0 ); // 1.0
|
|
static const half4 matrixRGB1toCoCg1YW = half4( 0.25, 0.5, 0.25, 0.0 ); // Y
|
|
|
|
static const half4 matrixCoCg1YtoRGB1X = half4( 1.0, -1.0, 0.0, 1.0 );
|
|
static const half4 matrixCoCg1YtoRGB1Y = half4( 0.0, 1.0, -0.50196078, 1.0 ); // -0.5 * 256.0 / 255.0
|
|
static const half4 matrixCoCg1YtoRGB1Z = half4( -1.0, -1.0, 1.00392156, 1.0 ); // +1.0 * 256.0 / 255.0
|
|
|
|
// uses texel space coordinates, not normalized coordinates
|
|
static float ComputeLOD( float2 virtCoords ) {
|
|
float2 dx = ddx( virtCoords.xy );
|
|
float2 dy = ddy( virtCoords.xy );
|
|
|
|
float px = dot2( dx, dx );
|
|
float py = dot2( dy, dy );
|
|
|
|
float maxLod = 0.5 * log2( max( px, py ) ); // log2(sqrt()) = 0.5*log2()
|
|
return maxLod;
|
|
}
|
|
|
|
// uses texel space coordinates, not normalized coordinates
|
|
static float ComputeAnisoLOD( float2 virtCoords, float maxAnisoLog2 ) {
|
|
float2 dx = ddx( virtCoords.xy );
|
|
float2 dy = ddy( virtCoords.xy );
|
|
|
|
float px = dot2( dx, dx );
|
|
float py = dot2( dy, dy );
|
|
|
|
float maxLod = 0.5 * log2( max( px, py ) ); // log2(sqrt()) = 0.5*log2()
|
|
float minLod = 0.5 * log2( min( px, py ) );
|
|
|
|
return maxLod - min( maxAnisoLog2, maxLod - minLod );
|
|
}
|
|
|
|
static float4 ComputeVirtualLOD( float4 filterParms, float4 feedbackFloat, float4 virtMapping, float2 virtCoords ) {
|
|
// Used for the land generation tool path.
|
|
float drawBias = filterParms.x;
|
|
float maxAnisoLog2 = filterParms.z;
|
|
float widthInPages = feedbackFloat.y;
|
|
|
|
// take just the fractional part of the original texture coordinate to give texture wrapping
|
|
// scale and bias it by the source to virtual texture mapping
|
|
float4 virtualTexCoord;
|
|
virtualTexCoord.zw = _float2( 0.0 );
|
|
virtualTexCoord.xy = frac( virtCoords );
|
|
virtualTexCoord.xy = virtualTexCoord.xy * virtMapping.xy + virtMapping.zw;
|
|
|
|
// look up the proper LOD in the dedicated LOD texture, based on the original, non-wrapped,
|
|
// non-paged texture coordinates to avoid discontinuities. Still need to multiply by virtualMapping.xy
|
|
// to account for the dimensions of the original texture.
|
|
virtualTexCoord.w = ComputeAnisoLOD( virtCoords * virtMapping.xy * widthInPages * PAYLOAD_SIZE, maxAnisoLog2 );
|
|
|
|
// adjust for the LOD bias already applied in the virtToPhysPage sampler (log2TexelSizeRatio)
|
|
virtualTexCoord.w -= PAYLOAD_SIZE_LOG2 + drawBias;
|
|
|
|
return virtualTexCoord;
|
|
}
|
|
|
|
#if defined( XBOX ) || ( defined( ATI ) && !defined( ATI_CLAMPED_ANISO ) )
|
|
// use the virtual texture coordinate instead of the physical texture coordinate for the anisotropic texture lookup
|
|
#define USE_VIRTUAL_ANISO_FOOTPRINT
|
|
#endif
|
|
|
|
// bias the page table lookup anticipating an anisotropic texture lookup
|
|
// this is expensive but may be a nice quality improvement for high end PCs
|
|
//#define USE_ANISO_PAGE_TABLE_LOOKUP
|
|
|
|
static float4 PageTableBiasForAniso( float2 virtCoords ) {
|
|
const float minAnisoBias = -2; // -log2( maxAniso )
|
|
|
|
// calculate a bias for the page table lookup based on the size of the anisotropic footprint
|
|
float2 dx = ddx( virtCoords.xy );
|
|
float2 dy = ddy( virtCoords.xy );
|
|
|
|
float px = dot2( dx, dx );
|
|
float py = dot2( dy, dy );
|
|
|
|
float maxLod = 0.5 * log2( max( px, py ) ); // log2(sqrt()) = 0.5*log2()
|
|
float minLod = 0.5 * log2( min( px, py ) );
|
|
|
|
float anisoBias = max( minLod - maxLod, minAnisoBias );
|
|
|
|
return float4( virtCoords.x, virtCoords.y, 0, anisoBias );
|
|
}
|
|
|
|
#ifdef USE_ANISO_PAGE_TABLE_LOOKUP
|
|
#define tex2DPageTable( sampler, coords ) tex2Dbias( sampler, PageTableBiasForAniso( coords ) )
|
|
#else
|
|
#define tex2DPageTable( sampler, coords ) tex2D( sampler, coords )
|
|
#endif
|
|
|
|
//#define PAGE_TABLE_ONLY_8888
|
|
#if defined( PS3 ) || defined( XBOX )
|
|
#define PAGE_TABLE_ONLY_565
|
|
#endif
|
|
//#define MAPPING_IMAGE_3X_FLOAT32
|
|
//#define MAPPING_IMAGE_2X_FIXED16
|
|
|
|
#if defined( PAGE_TABLE_ONLY_8888 )
|
|
|
|
// using only the page table in 8-bit per component RGBA format
|
|
#define UniqueVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 32 )
|
|
#define UniqueDiffuseOnlyVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 32 )
|
|
#define UniqueDiffuseOnly2VirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 32 )
|
|
#define VmtrVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 16 )
|
|
#define VmtrVirtualLODToPhysical( virtMapping, coords ) VirtualToPhysical2( $vmtrPageTableMap, coords, 16 ).xy
|
|
|
|
static float3 VirtualToPhysical2( sampler2D virtToPhysPage, float2 virtCoords, float physPagesWide ) {
|
|
// constants
|
|
const float pageWidth = 128;
|
|
const float pageBorder = 4;
|
|
//const float physPagesWide = 32;
|
|
|
|
#if defined( PS3 ) || defined( XBOX )
|
|
const float floatToByte = 255.0 + 1.0 / 256;
|
|
#else
|
|
const float floatToByte = 255.0;
|
|
#endif
|
|
|
|
// derived constants
|
|
const float pageFracScale = ( pageWidth - 2 * pageBorder ) / pageWidth / physPagesWide;
|
|
const float borderOffset = pageBorder / pageWidth / physPagesWide;
|
|
const float4 texScale = {
|
|
floatToByte / physPagesWide,
|
|
floatToByte / physPagesWide,
|
|
floatToByte * 1.0 / 16.0,
|
|
floatToByte * 256.0 / 16.0
|
|
};
|
|
const float4 texBias = { borderOffset, borderOffset, 0, 0 };
|
|
|
|
// translation
|
|
float4 physPage = tex2DPageTable( virtToPhysPage, virtCoords ) * texScale + texBias;
|
|
float2 pageFrac = frac( virtCoords * ( physPage.z + physPage.w ) );
|
|
float3 physCoord;
|
|
physCoord.xy = pageFrac * pageFracScale + physPage.xy;
|
|
physCoord.z = ( physPage.z + physPage.w ) * pageFracScale;
|
|
return physCoord;
|
|
}
|
|
|
|
#elif defined( PAGE_TABLE_ONLY_565 )
|
|
|
|
// using only the page table in 565 RGB format
|
|
#define UniqueVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 32 )
|
|
#define UniqueDiffuseOnlyVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 32 )
|
|
#define UniqueDiffuseOnly2VirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 32 )
|
|
#define VmtrVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, coords, 16 )
|
|
#define VmtrVirtualLODToPhysical( virtMapping, coords ) VirtualToPhysical2( $vmtrPageTableMap, coords, 16 ).xy
|
|
|
|
static float3 VirtualToPhysical2( sampler2D virtToPhysPage, float2 virtCoords, float physPagesWide ) {
|
|
// constants
|
|
const float pageWidth = 128;
|
|
const float pageBorder = 4;
|
|
//const float physPagesWide = 32;
|
|
|
|
#if defined( PS3 )
|
|
const float floatToPagesWide = ( 255.0 + 1.0 / 256 ) / 256.0 * physPagesWide;
|
|
const float floatToMip = ( 255.0 + 1.0 / 256 ) / 256.0 * 64.0;
|
|
#elif defined( XBOX )
|
|
const float floatToPagesWide = ( 31.0 + 1.0 / 33.0 ) / 32.0 * physPagesWide;
|
|
const float floatToMip = ( 63.0 + 1.0 / 65.0 );
|
|
#else
|
|
const float floatToPagesWide = 255.0 / 256.0 * physPagesWide;
|
|
const float floatToMip = 255.0 / 256.0 * 64.0;
|
|
#endif
|
|
|
|
// derived constants
|
|
const float pageFracScale = ( pageWidth - 2 * pageBorder ) / pageWidth / physPagesWide;
|
|
const float borderOffset = pageBorder / pageWidth / physPagesWide;
|
|
const float4 texScale = {
|
|
floatToPagesWide,
|
|
floatToMip,
|
|
floatToPagesWide,
|
|
0
|
|
};
|
|
float4 texBias = { 0, 1.0 / 4096.0, 0, 0 };
|
|
|
|
// translation
|
|
half4 physPage = tex2DPageTable( virtToPhysPage, virtCoords ) * texScale + texBias; // NOTE: must be half4 for PS3 ?
|
|
physPage.y = exp2( physPage.y );
|
|
physPage = floor( physPage );
|
|
float2 pageFrac = frac( virtCoords * physPage.y );
|
|
float3 physCoord;
|
|
physCoord.xy = pageFrac * pageFracScale + physPage.xz / physPagesWide + borderOffset;
|
|
physCoord.z = physPage.y * pageFracScale;
|
|
return physCoord;
|
|
}
|
|
|
|
#elif defined( MAPPING_IMAGE_2X_FIXED16 )
|
|
|
|
// using two unsigned fixed point 16-bit mapping textures, one with a single channel and one with two channels
|
|
#define UniqueVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueMappingsMap0, $physicalUniqueMappingsMap1, coords )
|
|
#define UniqueDiffuseOnlyVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueDiffuseOnlyMappingsMap0, $physicalUniqueDiffuseOnlyMappingsMap1, coords )
|
|
#define UniqueDiffuseOnly2VirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueDiffuseOnly2MappingsMap0, $physicalUniqueDiffuseOnly2MappingsMap1, coords )
|
|
#define VmtrVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalVmtrMappingsMap0, $physicalVmtrMappingsMap1, coords )
|
|
#define VmtrVirtualLODToPhysical( virtMapping, coords ) VirtualToPhysical2( $vmtrPageTableMap, $physicalVmtrMappingsMap0, $physicalVmtrMappingsMap1, coords ).xy
|
|
|
|
static float3 VirtualToPhysical2( sampler2D virtToPhysPage, sampler2D physPageToXform0, sampler2D physPageToXform1, float2 virtCoords ) {
|
|
half2 physPage = tex2DPageTable( virtToPhysPage, virtCoords ).xy;
|
|
float4 xform0 = tex2D( physPageToXform0, physPage ) * 32.0;
|
|
float4 xform1 = tex2D( physPageToXform1, physPage ) * 32.0;
|
|
float3 physCoord;
|
|
physCoord.xy = virtCoords * xform0.y + xform1.xw - 30.0;
|
|
physCoord.z = 0.0f;
|
|
return physCoord;
|
|
}
|
|
|
|
#elif defined( MAPPING_IMAGE_3X_FLOAT32 )
|
|
|
|
// using three single channel float 32 mapping textures, one for each component
|
|
#define UniqueVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueMappingsMap0, $physicalUniqueMappingsMap1, $physicalUniqueMappingsMap2, coords )
|
|
#define UniqueDiffuseOnlyVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueDiffuseOnlyMappingsMap0, $physicalUniqueDiffuseOnlyMappingsMap1, $physicalUniqueDiffuseOnlyMappingsMap2, coords )
|
|
#define UniqueDiffuseOnly2VirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueDiffuseOnly2MappingsMap0, $physicalUniqueDiffuseOnly2MappingsMap1, $physicalUniqueDiffuseOnly2MappingsMap2, coords )
|
|
#define VmtrVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalVmtrMappingsMap0, $physicalVmtrMappingsMap1, $physicalVmtrMappingsMap2, coords )
|
|
#define VmtrVirtualLODToPhysical( virtMapping, coords ) VirtualToPhysical2( $vmtrPageTableMap, $physicalVmtrMappingsMap0, $physicalVmtrMappingsMap1, $physicalVmtrMappingsMap2, coords ).xy
|
|
|
|
static float3 VirtualToPhysical2( sampler2D virtToPhysPage, sampler2D physPageToXform0, sampler2D physPageToXform1, sampler2D physPageToXform2, float2 virtCoords ) {
|
|
half2 physPage = tex2DPageTable( virtToPhysPage, virtCoords ).xy;
|
|
float xform0 = tex2D( physPageToXform0, physPage ).x;
|
|
float xform1 = tex2D( physPageToXform1, physPage ).x;
|
|
float xform2 = tex2D( physPageToXform2, physPage ).x;
|
|
float3 physCoord;
|
|
physCoord.xy = virtCoords * xform0 + float2( xform1, xform2 );
|
|
physCoord.z = 0.0f;
|
|
return physCoord;
|
|
}
|
|
|
|
#else
|
|
|
|
// using a single 4 channel float 32 mapping texture
|
|
#define UniqueVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueMappingsMap0, coords )
|
|
#define UniqueDiffuseOnlyVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueDiffuseOnlyMappingsMap0, coords )
|
|
#define UniqueDiffuseOnly2VirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalUniqueDiffuseOnly2MappingsMap0, coords )
|
|
#define VmtrVirtualToPhysical( coords ) VirtualToPhysical2( $pageTableMap, $physicalVmtrMappingsMap0, coords )
|
|
#define VmtrVirtualLODToPhysical( virtMapping, coords ) VirtualLODToPhysical2( $vmtrPageTableMap, $physicalVmtrMappingsMap0, ComputeVirtualLOD( $physicalVmtrFilterParms, $virtualTextureFeedbackFloat, virtMapping, coords ) )
|
|
|
|
static float3 VirtualToPhysical2( sampler2D virtToPhysPage, sampler2D physPageToXform0, float2 virtCoords ) {
|
|
half2 physPage = tex2DPageTable( virtToPhysPage, virtCoords ).xy;
|
|
float4 xform = tex2D( physPageToXform0, physPage );
|
|
float3 physCoord;
|
|
physCoord.xy = virtCoords * xform.x + xform.zw;
|
|
physCoord.z = xform.y;
|
|
return physCoord;
|
|
}
|
|
|
|
static float2 VirtualLODToPhysical2( sampler2D virtToPhysPage, sampler2D physPageToXform0, float4 virtCoords ) {
|
|
half2 physPage = tex2Dlod( virtToPhysPage, virtCoords ).xy;
|
|
float4 xform = tex2D( physPageToXform0, physPage );
|
|
return virtCoords.xy * xform.x + xform.zw;
|
|
}
|
|
|
|
#endif
|
|
|
|
static float ComputeSoftParticleScale( sampler2D image, float2 tc, float interpolatedZOverW, float softness ) {
|
|
// This instruction handles the 1.0 - depth calc automatically when using an inverted depth buffer
|
|
float depth = tex2Ddepth( image, tc );
|
|
|
|
// Approximate a linear depth difference
|
|
float r1 = 1.0 / ( 1.0 - depth );
|
|
float r2 = 1.0 / ( 1.0 - interpolatedZOverW );
|
|
return saturate( ( r1 - r2 ) * softness );
|
|
}
|
|
|
|
static half4 ComputeAnimCrossFadeColor( sampler2D image, float2 tc0, float2 tc1, float frameFrac ) {
|
|
// For strip animations, we need to cross-fade
|
|
half4 result0 = tex2D( image, tc0 ) * ( 1.0 - frameFrac );
|
|
half4 result1 = tex2D( image, tc1 ) * ( frameFrac ); // when frameFrac is 0, no contribution
|
|
return ( result0 + result1 );
|
|
}
|
|
|
|
// the 'distortVec' is in the range [-1.0, 1.0] for each component where 1.0 is the
|
|
// full screen width or height respectively
|
|
// the 'blur' value is in the range [0.0, 1.0] where 1.0 offsets the mip level by 8
|
|
static float4 ComputeDistortion( float2 distortVec, float blur ) {
|
|
// The distortion vector is usually very small so store a close to normalized vector
|
|
// in 'xy' and store a scale value in 'z'.
|
|
// The blur value is moved in the range [0.5, 1.0] which allows multiple distortions
|
|
// to be blended with GL_ONE_MINUS_DST_ALPHA GL_DST_ALPHA. The 'blur' (alpha channel) in
|
|
// the distortion map is initialized to zero such that the first distortion fully contributes
|
|
// and then consecutive distortions will blend in with a value in the range [0.0, 0.5].
|
|
// Blending based on the blur value is of course wrong but it works if no blurring is applied.
|
|
// Also, as the blur value goes up, additional distortions contribute less which is
|
|
// fine because the distortions won't be noticeable when there is a lot of blurring.
|
|
// A linear blend of the two vectors with separate scale values does not result in the
|
|
// same vector as a linear blend of the original vectors. However, the resulting vector
|
|
// is still nicely bounded between the original vectors and representative of accumulated
|
|
// distortions.
|
|
// To decode the distortion vector and blur value in the post process we use:
|
|
// half4 distortion = h4tex2D( $postDistortionMap, texcoord.xy ) - ( 127.0 / 255.0 );
|
|
// perturb += distortion.xy * distortion.z;
|
|
// blur += saturate( distortion.w ) * 16;
|
|
float4 final;
|
|
final.z = 0.125 + sqrt( dot( distortVec, distortVec ) );
|
|
final.xy = distortVec / final.z;
|
|
final.w = blur * 0.5;
|
|
return final + ( 127.0 / 255.0 );
|
|
}
|
|
|
|
static half2 ComputeTransAtlasCoord( half2 tc, half4 scaleBias ) {
|
|
// Figure out half texel, pick fraction from texture coordinates and clamp it inside [ 0+halfTexel, 1-halfTexel ]
|
|
half2 halfScale = scaleBias.xy * _half2( 0.5 );
|
|
half2 result = max( min( frac( tc ), _half2( 1.0 ) - halfScale ), halfScale );
|
|
|
|
// Scale and bias clamped texture coordinates
|
|
return result * scaleBias.xy + scaleBias.zw;
|
|
}
|
|
|
|
static float4 ComputeDistortionMV( float2 distortVec, float blur ) {
|
|
float4 final;
|
|
final.xy = saturate( distortVec * 0.5 + 0.5 );
|
|
final.z = blur * 0.5 + 0.5;
|
|
final.w = 1.0;
|
|
return final;
|
|
}
|
|
|
|
static float3 CoCgScYToRGB( float4 CoCgScY ) {
|
|
float3 rgb;
|
|
CoCgScY.z = ( CoCgScY.z * 31.875 ) + 1.0; //z = z * 255.0/8.0 + 1.0
|
|
CoCgScY.z = 1.0 / CoCgScY.z;
|
|
CoCgScY.xy *= CoCgScY.z;
|
|
rgb.x = dot4( CoCgScY, matrixCoCg1YtoRGB1X );
|
|
rgb.y = dot4( CoCgScY, matrixCoCg1YtoRGB1Y );
|
|
rgb.z = dot4( CoCgScY, matrixCoCg1YtoRGB1Z );
|
|
return rgb;
|
|
}
|
|
|
|
static float4 CoCgScYToRGB1( float4 CoCgScY ) {
|
|
float4 rgba;
|
|
rgba.xyz = CoCgScYToRGB( CoCgScY );
|
|
rgba.w = 1;
|
|
return rgba;
|
|
}
|
|
|
|
static float3 ScaleSpecular( float3 unscaled, float factor ) {
|
|
return ( unscaled * 8.0 ) / ( factor * 255.0 + 8.0 );
|
|
}
|
|
|
|
//#define FEEDBACK_FORMAT_FLOAT32
|
|
|
|
static float4 CalculateFeedback( float2 texCoords, float4 feedbackParms, float4 filterParms ) {
|
|
float4 feedback;
|
|
|
|
float bias = filterParms.y;
|
|
float maxAnisoLog2 = filterParms.z;
|
|
float widthInPages = feedbackParms.y;
|
|
|
|
// xy is the integral page coordinates
|
|
feedback.xy = texCoords * widthInPages;
|
|
|
|
// compute the desired LOD for anisotropic filtering
|
|
float desiredLod = ComputeAnisoLOD( feedback.xy * PAYLOAD_SIZE, maxAnisoLog2 ) + bias;
|
|
|
|
// z is the lod level, never adjust below 0
|
|
feedback.z = max( 0.0, desiredLod );
|
|
|
|
// w holds the virtual texture index
|
|
feedback.w = feedbackParms.x;
|
|
|
|
return feedback;
|
|
}
|
|
|
|
/*
|
|
pageX = ( data[0] & 0xFF ) + ( data[2] & 0x0F ) << 8 );
|
|
pageY = ( data[1] & 0xFF ) + ( data[2] & 0xF0 ) << 4 );
|
|
pageLOD = ( data[3] & 0x0F );
|
|
pageSource = ( data[3] & 0xF0 ) >> 4;
|
|
*/
|
|
static float4 PackFeedback( float4 feedback ) {
|
|
#ifdef FEEDBACK_FORMAT_FLOAT32
|
|
return feedback;
|
|
#else
|
|
feedback = floor( feedback ) / 256.0;
|
|
float2 xy_low = frac( feedback.xy + 0.5 / 256.0 );
|
|
float2 xy_high = floor( feedback.xy ) / 256.0;
|
|
|
|
float4 color;
|
|
color.xy = xy_low;
|
|
color.z = xy_high.y * 16.0 + xy_high.x;
|
|
color.w = feedback.w * 16.0 + feedback.z;
|
|
#if defined( XBOX )
|
|
return color.zyxw; // stored as B-G-R-A
|
|
#elif defined( PS3 )
|
|
return color.yzwx; // stored as A-R-G-B
|
|
#else
|
|
return color;
|
|
#endif
|
|
#endif
|
|
}
|