dreyndev/JD2022-TU1
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
JD2022-TU1/data/EngineData/Shaders/Unified/autodance.fx

3098 lines
92 KiB
HLSL
Raw Permalink Blame History

#ifndef AUTODANCE__FX
#define AUTODANCE__FX
#define CB_AUTODANCE
#ifdef ITF_X360
#define ALT_TOONSHADER
#endif
#if defined DX11_SHADERS || defined DX12_SHADERS
#define ALT_TOONSHADER
#endif
#include "PlatformAdapter.fxh"
#include "ShaderParameters.fxh"
REGISTER_SAMPLER(samp, 0);
REGISTER_SAMPLER(samp, 1);
REGISTER_SAMPLER(samp, 2);
REGISTER_SAMPLER(samp, 3);
#define PI 3.14159265359f
#define EPSILON 0.0001f
#define DEFINE_CONSTANTS \
const float3 rgb_to_y = float3( 0.212671f, 0.715160f, 0.072169f ); \
const float2 vec2_zero = float2(0.0f,0.0f); \
const float2 vec2_one = float2(1.0f,1.0f); \
const float3 vec3_zero = float3(0.0f,0.0f,0.0f); \
const float3 vec3_one = float3(1.0f,1.0f,1.0f); \
const float4 vec4_zero = float4(0.0f,0.0f,0.0f,0.0f); \
const float4 vec4_one = float4(1.0f,1.0f,1.0f,1.0f);
struct VS_IN
{
float4 Position : POSITION;
float2 uv0 : TEXCOORD0;
};
struct VS_OUT
{
float4 Position : VS_OUT_POS;
float2 uv0 : TEXCOORD0;
};
struct VS_OUT_T2
{
float4 Position : VS_OUT_POS;
float4 uv0 : TEXCOORD0;
};
struct VS_PLANE_OUT
{
float4 Position : VS_OUT_POS;
float2 uv0 : TEXCOORD0;
float4 pospostvs : TEXCOORD1;
};
struct PS_OUT
{
float4 clr : PS_OUT_COLOR;
};
/////////////////////////////
// Perspective correction
/////////////////////////////
struct VS_PC_IN
{
float4 Position : POSITION;
float4 col : COLOR0;
float2 uv0 : TEXCOORD0;
float4 uv1 : TEXCOORD1;
float4 uv2 : TEXCOORD2;
float2 uv3 : TEXCOORD3;
};
struct VS_PC_OUT
{
float4 Position : VS_OUT_POS;
float3 uv : TEXCOORD0;
float4 uv2 : TEXCOORD1;
};
struct VS_Particle_OUT
{
float4 Position : VS_OUT_POS;
float4 uv : TEXCOORD0;
float4 uv2 : TEXCOORD1;
};
float3 XYZ2RGB(float3 input)
{
const float3 rFactors = float3(3.2404542f, -1.5371385f, -0.4985314f);
const float3 gFactors = float3(-0.9692660f, 1.8760108f, 0.0415560f);
const float3 bFactors = float3(0.0556434f, -0.2040259f, 1.0572252f);
float r = dot(input,rFactors);
float g = dot(input,gFactors);
float b = dot(input,bFactors);
return float3(r,g,b);
}
float3 XYY2XYZ(float3 input)
{
float x = 0.0f;
float y = 0.0f;
float z = 0.0f;
if (input.y > 0.001f)
{
x = (input.x * input.z) / input.y;
y = input.z;
z = ((1.0f - input.x - input.y) * input.z) / input.y;
}
return float3(x,y,z);
}
float3 RGB2XYZ(float3 input)
{
const float3 xFactors = float3(0.4124f, 0.3576f, 0.1805f);
const float3 yFactors = float3(0.2126f, 0.7152f, 0.0722f);
const float3 zFactors = float3(0.0193f, 0.1192f, 0.9505f);
float x = dot(input,xFactors);
float y = dot(input,yFactors);
float z = dot(input,zFactors);
return float3(x,y,z);
}
float3 XYZ2XYY(float3 input)
{
float sum = max(1e-6f, input.x + input.y + input.z);
float rx = input.x / sum;
float ry = input.y / sum;
float rY = input.y;
return float3(rx,ry,rY);
}
float3 XYY2RGB(float3 input)
{
float3 valXYZ = XYY2XYZ(input);
return saturate(XYZ2RGB(valXYZ));
}
float3 RGB2XYY(float3 input)
{
float3 valXYZ = RGB2XYZ(input);
return XYZ2XYY(valXYZ);
}
#ifdef VERTEX_PROFILE
VS_OUT vs_copy_as_is( VS_IN input )
{
VS_OUT output;
output.Position = input.Position;
output.uv0 = input.uv0;
return output;
}
VS_OUT_T2 vs_copy_as_is_embedded( VS_IN input )
{
VS_OUT_T2 output;
output.Position = input.Position;
output.uv0.zw = frac(input.uv0);
output.uv0.xy = (input.uv0 - output.uv0.zw) / 256.0f;
return output;
}
VS_PLANE_OUT vs_worldviewproj(VS_IN input)
{
VS_PLANE_OUT output;
output.Position = mul(input.Position, vs_mWorldViewProjection);
output.Position.z = clamp(output.Position.z, 0.0f, output.Position.w);
output.uv0 = input.uv0;
output.pospostvs = output.Position;
return output;
}
// Perspective correction
VS_PC_OUT vs_copy_as_is_PC( VS_PC_IN input )
{
VS_PC_OUT output;
output.Position = input.Position;
output.uv = input.uv1.xyz;
output.uv2 = input.uv2;
return output;
}
#if defined( _CAFE_ ) || defined ( _NX_ )
VS_Particle_OUT vs_particles( VS_PC_IN input )
{
VS_Particle_OUT output;
output.Position = input.Position;
output.uv = float4(input.uv1.xyz,1);
output.uv2 = input.uv2;
return output;
}
#else
// particles stuff
VS_Particle_OUT vs_particles( VS_PC_IN input )
{
VS_Particle_OUT output;
const float startRadius = vs_reg0.x;
const float endRadius = vs_reg0.y;
const float minSpin = vs_reg0.z;
const float maxSpin = vs_reg0.w;
const float minWanderAmp = vs_reg1.x * 0.01f;
const float maxWanderAmp = vs_reg1.y * 0.01f;
const float radiusVar = vs_reg1.z;
const float time = vs_reg1.w;
const float minSpeed = vs_reg2.x;
const float maxSpeed = vs_reg2.y;
const float dirX = vs_reg2.z;
const float dirY = vs_reg2.w;
const float minWanderRate = vs_reg3.x;
const float maxWanderRate = vs_reg3.y;
const float radiusNoiseAmp = vs_reg3.z;
const float radiusNoiseRate = vs_reg3.w;
const float3 stColxyY = vs_reg4.xyz;
const float stAlpha = vs_reg4.w;
const float3 edColxyY = vs_reg5.xyz;
const float edAlpha = vs_reg5.w;
const float imageU = vs_reg6.x;
const float motionPower = vs_reg6.y;
const float aspect = vs_reg6.z;
const float4 randVals = input.uv1;
const float4 sinRateCoeffs = float4(1.0f,2.0f,4.0f,8.0f) * radiusNoiseRate;
const float4 sinAmpCoeffs = float4(0.53333f,0.26667f,0.13333f,0.06667f);
float2 currPos = input.Position.xy;
float2 cornerOffset = (input.uv0 * 2.0f) - float2(1.0f,1.0f);
float2 dirVector = vs_reg2.zw;
float2 edgeVector = float2(-dirVector.y,dirVector.x);
float posdot = dot(currPos,dirVector);
float edgedot = dot(currPos,edgeVector);
float currAngle = time * lerp(minSpin,maxSpin,randVals.w);
currAngle += atan2(dirVector.y,dirVector.x) - (1.57f);
float sinAng = sin(currAngle);
float cosAng = cos(currAngle);
float2 cornerPos = float2((cornerOffset.x * cosAng) + (cornerOffset.y * -sinAng),(cornerOffset.x * sinAng) + (cornerOffset.y * cosAng));
float lifeRatio = frac((time * lerp(minSpeed,maxSpeed,randVals.x)) + posdot);
lifeRatio = pow(lifeRatio,motionPower);
float linePos = ((lifeRatio * 2.0f) - 1.0f) * 1.414f;
float4 radNoiseLoops = sin((lifeRatio.xxxx + randVals) * sinRateCoeffs) * radiusNoiseAmp;
float radiusNoise = dot(radNoiseLoops,sinAmpCoeffs);
float radius = (1.0f / 40.0f) * max(0.0f,lerp(startRadius,endRadius,lifeRatio) * (1.0f + radiusNoise + (radiusVar * ((randVals.y * 2.0f) - 1.0f))));
float lineWander = sin(time * lerp(minWanderRate,maxWanderRate,randVals.z)) * lerp(minWanderAmp,maxWanderAmp,randVals.x);
float3 colRGB = XYY2RGB(lerp(stColxyY,edColxyY,lifeRatio * (0.5f + (randVals.x * 1.0f))));
float colAlpha = lerp(stAlpha,edAlpha,lifeRatio);
edgedot += lineWander;
currPos = (dirVector * linePos) + (edgeVector * edgedot);
cornerPos *= radius;
cornerPos.x *= 1.0f / aspect;
float2 finalPos = currPos + cornerPos;
output.Position = float4(finalPos,0,input.Position.w);
output.uv.xy = input.uv0;
output.uv.x *= (1.0f / 12.0f);
output.uv.x += imageU;
output.uv.z = 0.0f;
output.uv.w = 0.0f;
output.uv2 = float4(colRGB.xyz,colAlpha);
return output;
}
#endif // not _CAFE_ and not _NX_
#endif // VERTEX_PROFILE
#ifdef PIXEL_PROFILE
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Utility functions
inline float linStep( float xmin, float xmax, float x )
{
float a = 1.0/( xmax - xmin );
float b = -a * xmin;
return saturate( ( a*x )+b );
}
inline float rectFunc( float xmin, float xmax, float x )
{
return step(xmin, x) * ( 1.0f - step(xmax, x) );
}
inline float2 rectFunc( float xmin, float xmax, float2 x )
{
return step(xmin, x) * ( 1.0f - step(xmax, x) );
}
inline float3 rectFunc( float xmin, float xmax, float3 x )
{
return step(xmin, x) * ( 1.0f - step(xmax, x) );
}
inline float4 rectFunc( float4 xmin, float4 xmax, float4 x )
{
return step(xmin, x) * ( 1.0f - step(xmax, x) );
}
inline float colorDistance_max( float3 a, float3 b )
{
return max
(
max
(
abs( a.x-b.x ), abs( a.y-b.y )
),
abs( a.z-b.z )
);
}
inline float colorDistance_avg( float3 a, float3 b )
{
float3 dist = abs( a - b );
return ( dist.x + dist.y + dist.z ) / 3.0f;
}
inline float colorDistance_euclidean( float3 a, float3 b )
{
const float sqrt3 = 1.7321f;
float3 dist = abs( a - b );
return (float) length( dist ) / sqrt3;
}
inline float Max( float f1, float4 v )
{
float2 v1 = float2( v.x, v.y );
float2 v2 = float2( v.z, v.w );
v1 = max( v1, v2 );
v1 = max( v1.x, v1.y );
return max( f1, v1.x );
}
inline float Max( float4 v )
{
float2 v1 = float2( v.x, v.y );
float2 v2 = float2( v.z, v.w );
v1 = max( v1, v2 );
return max( v1.x, v1.y );
}
inline float Min( float f1, float4 v )
{
float2 v1 = float2( v.x, v.y );
float2 v2 = float2( v.z, v.w );
v1 = min( v1, v2 );
v1 = min( v1.x, v1.y );
return min( f1, v1.x );
}
inline float Min( float4 v )
{
float2 v1 = float2( v.x, v.y );
float2 v2 = float2( v.z, v.w );
v1 = min( v1, v2 );
return min( v1.x, v1.y );
}
inline float Sum( float4 v )
{
const float4 vec4_one = float4(1.0f,1.0f,1.0f,1.0f);
return dot( v, vec4_one );
}
float4 tex2D_blurFast( float2 uv, float2 texelOffset )
{
float2 off = texelOffset;
float2 off_h = off * 0.5;
float4 tCenter = TEXTURE_READ_2D( samp, 0, uv );
float4 t0 = TEXTURE_READ_2D( samp, 0, uv + float2( -off_h.x, off.y ) );
float4 t1 = TEXTURE_READ_2D( samp, 0, uv + float2( off.x, off_h.y ) );
float4 t2 = TEXTURE_READ_2D( samp, 0, uv + float2( off_h.x, -off.y ) );
float4 t3 = TEXTURE_READ_2D( samp, 0, uv + float2( -off.x, -off_h.y ) );
return( ( t0+t1+t2+t3 )*0.25*0.4 ) +( tCenter*0.6 );
}
float4 tex2D_blurG3( float2 uv, float2 texelOffset )
{
float2 off = texelOffset;
float4 res = TEXTURE_READ_2D( samp, 0, uv + float2( -1*off.x, -1*off.y ) ) *0.07511;
res += TEXTURE_READ_2D( samp, 0, uv + float2( 0*off.x, -1*off.y ) ) *0.12384;
res += TEXTURE_READ_2D( samp, 0, uv + float2( 1*off.x, -1*off.y ) ) *0.07511;
res += TEXTURE_READ_2D( samp, 0, uv + float2( -1*off.x, 0*off.y ) ) *0.12384;
res += TEXTURE_READ_2D( samp, 0, uv + float2( 0*off.x, 0*off.y ) ) *0.20418;
res += TEXTURE_READ_2D( samp, 0, uv + float2( 1*off.x, 0*off.y ) ) *0.12384;
res += TEXTURE_READ_2D( samp, 0, uv + float2( -1*off.x, 1*off.y ) ) *0.07511;
res += TEXTURE_READ_2D( samp, 0, uv + float2( 0*off.x, 1*off.y ) ) *0.12384;
res += TEXTURE_READ_2D( samp, 0, uv + float2( 1*off.x, 1*off.y ) ) *0.07511;
return res;
}
float4 tex2D_blurH( float2 uv, float2 texelOffset )
{
float2 off = texelOffset;
float4 res = TEXTURE_READ_2D( samp, 0, float2(uv.x - 4.0*off.x, uv.y)) * 0.05;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x - 3.0*off.x, uv.y)) * 0.09;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x - 2.0*off.x, uv.y)) * 0.12;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x - off.x, uv.y)) * 0.15;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y)) * 0.16;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x + off.x, uv.y)) * 0.15;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x + 2.0*off.x, uv.y)) * 0.12;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x + 3.0*off.x, uv.y)) * 0.09;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x + 4.0*off.x, uv.y)) * 0.05;
return res;
}
float4 tex2D_blurV( float2 uv, float2 texelOffset )
{
float2 off = texelOffset;
float4 res = TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y - 4.0*off.y )) * 0.05;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y - 3.0*off.y )) * 0.09;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y - 2.0*off.y )) * 0.12;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y - off.y )) * 0.15;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y )) * 0.16;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y + off.y )) * 0.15;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y + 2.0*off.y )) * 0.12;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y + 3.0*off.y )) * 0.09;
res += TEXTURE_READ_2D( samp, 0, float2(uv.x, uv.y + 4.0*off.y )) * 0.05;
return res;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Pixel Shaders( filters )
PS_OUT ps_add_color_then_blend( VS_OUT input )
{
float4 oldImage = TEXTURE_READ_2D( samp, 0, input.uv0 ) + ps_reg0;
float4 newImage = TEXTURE_READ_2D( samp, 1, input.uv0 );
float finalAlpha = newImage.w +( oldImage.w*( 1.0-newImage.w ) );
float3 finalClr =( newImage.xyz * newImage.w ) +( oldImage.xyz*oldImage.w*( 1.0-newImage.w ) );
finalClr /= finalAlpha + 0.001f;
PS_OUT output;
output.clr = float4( finalClr, finalAlpha );
return output;
}
PS_OUT ps_alpha_blend( VS_OUT input )
{
float4 oldImage = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 newImage = TEXTURE_READ_2D( samp, 1, input.uv0 );
float finalAlpha = newImage.w +( oldImage.w*( 1.0-newImage.w ) );
float3 finalClr =( newImage.xyz * newImage.w ) +( oldImage.xyz*oldImage.w*( 1.0-newImage.w ) );
finalClr /= finalAlpha + 0.001f;
PS_OUT output;
output.clr = float4( finalClr, finalAlpha );
return output;
}
PS_OUT ps_blur_g3( VS_OUT input )
{
PS_OUT output;
output.clr = tex2D_blurG3( input.uv0, ps_samp0Size.zw ).xyzw;
return output;
}
PS_OUT ps_blur_h( VS_OUT input )
{
PS_OUT output;
output.clr = tex2D_blurH( input.uv0, ps_samp0Size.zw ).xyzw;
return output;
}
PS_OUT ps_blur_v( VS_OUT input )
{
PS_OUT output;
output.clr = tex2D_blurV( input.uv0, ps_samp0Size.zw ).xyzw;
return output;
}
PS_OUT ps_color_grading( VS_OUT input )
{
float3 img_c = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyz;
float3 recolored;
float recoloredOpacity;
{
float3 clr3 = img_c * 0.333333;
float clr = clr3.x + clr3.y + clr3.z;
float lowToMid = ps_reg3.x;
float lowToMidWidth = ps_reg3.y;
float midToHigh = ps_reg3.z;
float midToHighWidth = ps_reg3.w;
float d0 = linStep( lowToMid+( 0.5*lowToMidWidth ), lowToMid-( 0.5*lowToMidWidth ), clr );
float d2 = linStep( midToHigh-( 0.5*midToHighWidth ), midToHigh+( 0.5*midToHighWidth ), clr );
float d1 = 1.0-( d0+d2 );
recoloredOpacity =
( d0 * ps_reg0.w )
+( d1 * ps_reg1.w )
+( d2 * ps_reg2.w );
recolored = ( ps_reg0.xyz * d0 * clr/lowToMid )
+( ps_reg1.xyz * d1 )
+( ps_reg2.xyz * d2 *( clr/( 1.0-midToHigh )+midToHigh ) );
}
#if defined DX11_SHADERS || defined DX12_SHADERS
if( ps_alphaTest.x )
{
clip( recoloredOpacity - ps_alphaTest.y );
}
#endif
PS_OUT output;
output.clr = float4( recolored, recoloredOpacity );
return output;
}
PS_OUT ps_copy_as_is( VS_OUT input )
{
PS_OUT output;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
return output;
}
PS_OUT ps_copy_fix_edge( VS_OUT input )
{
#if 1
PS_OUT output;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
return output;
#else
PS_OUT output;
const float2 pixelOffset = ps_samp0Size.zw * 2.0f;
const float2 UV0c = input.uv0 + float2(-pixelOffset.x,0);
const float2 UV1c = input.uv0 + float2(pixelOffset.x,0);
const float2 UVcc = input.uv0;
const float2 UVc0 = input.uv0 + float2(0,-pixelOffset.y);
const float2 UVc1 = input.uv0 + float2(0,pixelOffset.y);
float4 col = TEXTURE_READ_2D( samp, 0, UVcc);
float col0c = TEXTURE_READ_2D( samp, 0, UV0c).r;
float col1c = TEXTURE_READ_2D( samp, 0, UV1c).r;
float colcc = col.r;
float colc0 = TEXTURE_READ_2D( samp, 0, UVc0).r;
float colc1 = TEXTURE_READ_2D( samp, 0, UVc1).r;
float xdist = col1c - col0c;
float ydist = colc1 - colc0;
float dist = sqrt((xdist * xdist) + (ydist * ydist));
float scale = saturate(colcc * dist);
output.clr = scale * col;
output.clr = float4(dist.xxx,1.0f);
return output;
#endif
}
PS_OUT ps_copy_as_is_alpha_test(VS_OUT input)
{
float4 color = TEXTURE_READ_2D( samp, 0, input.uv0 );
#if defined DX11_SHADERS || defined DX12_SHADERS
if( ps_alphaTest.x )
{
clip( color.a - ps_alphaTest.y );
}
#endif
PS_OUT output;
output.clr = color;
return output;
}
PS_OUT ps_blend_with_mask( VS_OUT input )
{
PS_OUT output;
float4 clr0 = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 clr1 = TEXTURE_READ_2D( samp, 1, input.uv0 );
float mask = TEXTURE_READ_2D( samp, 2, input.uv0 ).r;
float4 clr = lerp( clr0, clr1, mask );
float alpha = lerp( saturate(clr0.a * ps_reg0.x + clr1.a * ps_reg0.y),
clr.a,
ps_reg0.x * ps_reg0.y );
output.clr = float4( clr.rgb, alpha );
return output;
}
PS_OUT ps_blend_with_mask_color( VS_OUT input )
{
PS_OUT output;
float4 clr0 = ps_reg1;
float4 clr1 = TEXTURE_READ_2D( samp, 0, input.uv0 );
float mask = TEXTURE_READ_2D( samp, 1, input.uv0 ).r;
float4 clr = lerp( clr0, clr1, mask );
float alpha = lerp( saturate(clr0.a * ps_reg0.x + clr1.a * ps_reg0.y),
clr.a,
ps_reg0.x * ps_reg0.y );
output.clr = float4( clr.rgb, alpha );
return output;
}
PS_OUT ps_blend_premul( VS_OUT input )
{
PS_OUT output;
float4 clr0 = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 clr1 = TEXTURE_READ_2D( samp, 1, input.uv0 );
clr1 *= (1.0f - clr0.a);
output.clr = float4(clr1.rgb + clr0.rgb,1.0f);
return output;
}
PS_OUT ps_mask_smoothstepped_img( VS_OUT input )
{
float playerMask = TEXTURE_READ_2D( samp, 1, input.uv0 /*- float2( ps_samp1Size.z*2, -ps_samp1Size.w*2 )*/ ).x;
playerMask = linStep( ps_reg2.x, ps_reg2.y, playerMask );
float4 color = float4( TEXTURE_READ_2D( samp, 0, input.uv0 ).xyz, playerMask );
PS_OUT output;
output.clr = color;
return output;
}
PS_OUT ps_mask_spike_clr( VS_OUT input )
{
float tinput = TEXTURE_READ_2D( samp, 1, input.uv0 - float2( ps_samp1Size.z*2, -ps_samp1Size.w*2 ) ).x;
float middle = ps_reg2.x;
float thickness = ps_reg2.y;
float smoothFactor = ps_reg2.z;
float lowStart = middle -( thickness*0.5 ) - smoothFactor;
float lowEnd = middle -( thickness*0.5 );
float highStart = middle +( thickness*0.5 ) + smoothFactor;
float highEnd = middle +( thickness*0.5 );
float contourMask = min(
smoothstep( lowStart, lowEnd, tinput ),
smoothstep( highStart, highEnd, tinput ) );
#if defined DX11_SHADERS || defined DX12_SHADERS
if( ps_alphaTest.x )
{
clip( (ps_reg3.w*contourMask) - ps_alphaTest.y );
}
#endif
PS_OUT output;
output.clr = float4( ps_reg3.xyz, ps_reg3.w*contourMask );
return output;
}
PS_OUT ps_mul_color( VS_OUT input )
{
PS_OUT output;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
output.clr *= ps_reg0;
return output;
}
#if defined DX11_SHADERS || defined DX12_SHADERS
float GetIRBulbCorrection(float2 screenUV)
{
float2 posVal,posExp;
float val = 0.0f;
float2 pos = screenUV;
pos *= 2.0f;
pos -= 1.0f;
pos.y *= -1.0f;
pos = (pos * float2(2.307619f,1.216094f)) + float2(-0.430332f,-0.036529f);
pos = pos * pos;
posExp = pos * float2(-0.921264f,-0.683528f);
posVal = float2(0.474407f,0.779357f) / (1.0f - (posExp * 0.93138945f) + (posExp * posExp * 0.79807341f));
val += posVal.x * posVal.y;
pos = (pos * float2(4.335279f,2.030378f)) + float2(0.109023f,-0.406690f);
pos = pos * pos;
posExp = pos * float2(-0.004911f,-0.419739f);
posVal = float2(0.945161f,0.999998f) / (1.0f - (posExp * 0.93138945f) + (posExp * posExp * 0.79807341f));
val += posVal.x * posVal.y;
pos = (pos * float2(0.064690f,6.608789f)) + float2(0.521754f,-0.082028f);
pos = pos * pos;
posExp = pos * float2(-0.134696f,-0.393378f);
posVal = float2(0.213287f,-0.909062f) / (1.0f - (posExp * 0.93138945f) + (posExp * posExp * 0.79807341f));
val += posVal.x * posVal.y;
pos = (pos * float2(4.686698f,1.812515f)) + float2(-0.245583f,-0.135284f);
pos = pos * pos;
posExp = pos * float2(-0.422476f,-0.000599f);
posVal = float2(-0.482204f,0.487757f) / (1.0f - (posExp * 0.93138945f) + (posExp * posExp * 0.79807341f));
val += posVal.x * posVal.y;
//< subtle balance bodge to avoid any zero divides.
val = 0.01f + (val * 0.99f);
return 1.0f / saturate(val);
}
float ApplyImprovementMask( float player, VS_OUT input, float discrete )
{
//< get centre pixel values for IR, depth and player ID
const float offx = 4.0f / (512.0f * 1.99f);
const float offy = 4.0f / (424.0f * 1.99f);
const float2 uv0c = float2(-offx,0) + input.uv0;
const float2 uv1c = float2(offx,0) + input.uv0;
const float2 uvc0 = float2(0,-offy) + input.uv0;
const float2 uvc1 = float2(0,offy) + input.uv0;
float lumcc = TEXTURE_READ_2D( samp , 2, input.uv0).r;
float lumIR = TEXTURE_READ_2D( samp , 1, input.uv0).r;
float bulbCorrection = GetIRBulbCorrection(input.uv0);
lumIR = lumIR * bulbCorrection;
float originalIR = lumIR;
float IRDist = lumIR * (lumcc * lumcc);
float lum0c = TEXTURE_READ_2D( samp, 2, uv0c ).r;
float lum1c = TEXTURE_READ_2D( samp, 2, uv1c ).r;
float lumc0 = TEXTURE_READ_2D( samp, 2, uvc0 ).r;
float lumc1 = TEXTURE_READ_2D( samp, 2, uvc1 ).r;
float4 plPixels = float4(TEXTURE_READ_2D( samp, 0, uv0c ).r,TEXTURE_READ_2D( samp, 0, uv1c ).r,TEXTURE_READ_2D( samp, 0, uvc0 ).r,TEXTURE_READ_2D( samp, 0, uvc1 ).r);
float avgs = dot(plPixels,float4(0.25f,0.25f,0.25f,0.25f));//< calculate the average depth
float errx = abs(lumcc - ((lum0c + lum1c) * 0.5f)); //< estimate the error in depth across the pixel on the X axis (the general pixel error without light atenuation bais)
float erry = abs(lumcc - ((lumc0 + lumc1) * 0.5f)); //< estimate the error in depth across the pixel on the Y axis (the general pixel error without light atenuation bais)
float errScale = exp(-50.0f * (errx + erry));
float lum = saturate(errScale * (IRDist * 300000.0f));
lum *= step( 0.3f, lum );
lum = lerp( lum, ceil(lum), discrete );
return player * lum;
}
#endif
PS_OUT ps_player_ir_correction( VS_OUT input )
{
float player = TEXTURE_READ_2D( samp, 0, input.uv0 ).x;
#if defined DX11_SHADERS || defined DX12_SHADERS
player = ApplyImprovementMask( player, input, ps_reg0.x );
#endif
PS_OUT output;
output.clr = float4( player, player, player, player );
return output;
}
PS_OUT ps_player_to_rgba( VS_OUT input )
{
float player = saturate( TEXTURE_READ_2D( samp, 0, input.uv0 ).x * 255.0 );
PS_OUT output;
output.clr = float4( player, player, player, player );
return output;
}
PS_OUT ps_player_to_rgba_extract( VS_OUT input )
{
float playerVal = TEXTURE_READ_2D( samp, 0, input.uv0 ).x;
float player = rectFunc( ps_reg0.x, ps_reg0.y, playerVal );
player = saturate( player * 255.0 );
PS_OUT output;
output.clr = float4( player, player, player, player );
return output;
}
PS_OUT ps_rgba_to_yuv( VS_OUT input )
{
float3 rgb = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z*0.25, 0.0 ) );
float3 rgbRight = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z*1.25, 0.0 ) ).xyz;
PS_OUT output;
output.clr.a = -0.148*rgb.r - 0.291*rgb.g + 0.439*rgb.b + (128.0/255.0); // U
output.clr.b = 0.257*rgb.r + 0.504*rgb.g + 0.098*rgb.b + ( 16.0/255.0); // Y
output.clr.g = 0.439*rgbRight.r - 0.368*rgbRight.g - 0.071*rgbRight.b + (128.0/255.0); // V
output.clr.r = 0.257*rgbRight.r + 0.504*rgbRight.g + 0.098*rgbRight.b + ( 16.0/255.0); // Y
#if defined(ITF_WIN32)
// Windows DX9 & DX11
output.clr.rgba = output.clr.gbar;
#elif defined(DX11_SHADERS) || defined(DX12_SHADERS)
// Durango & Orbis
output.clr.rgba = output.clr.gbar;
#elif defined(_CAFE_) || defined(_NX_)
// Cafe
output.clr.rgba = output.clr.abgr; // Output actual UYVY
#endif
return output;
}
float4 calcSobel_samp0(VS_OUT In,float edgeWidth,float colScale)
{
float2 offset = ps_samp0Size.zw*edgeWidth;
float OffsetX = offset.x;
float OffsetY = offset.y;
float4 s00 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( -OffsetX, -OffsetY ) ) );
float4 s01 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( 0.0, -OffsetY ) ) );
float4 s02 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( OffsetX, -OffsetY ) ) );
float4 s10 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( -OffsetX, 0.0 ) ) );
float4 s12 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( OffsetX, 0.0 ) ) );
float4 s20 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( -OffsetX, OffsetY ) ) );
float4 s21 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( 0.0, OffsetY ) ) );
float4 s22 = TEXTURE_READ_2D( samp, 0, In.uv0 + ( float2( OffsetX, OffsetY ) ) );
// Calc X gradient
float4 GradX = s00 + 2.0*s10 + s20 - ( s02 + 2.0*s12 + s22 );
float4 GradY = s00 + 2.0*s01 + s02 - ( s20 + 2.0*s21 + s22 );
float asum = max(max(max(s00.a,s01.a),max(s02.a,s10.a)),max(max(s12.a,s20.a),max(s21.a,s22.a)));
#if defined DX11_SHADERS || defined DX12_SHADERS
if( ps_alphaTest.x )
{
clip( asum - ps_alphaTest.y );
}
#endif
float4 SquareGrad = GradX*GradX + GradY*GradY;
float4 final = sqrt( SquareGrad )*colScale;
final.rgb *= asum;
return final;
}
float4 calcSobel_samp1(VS_OUT In,float edgeWidth,float colScale)
{
float2 offset = ps_samp0Size.zw*edgeWidth;
float OffsetX = offset.x;
float OffsetY = offset.y;
float4 s00 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( -OffsetX, -OffsetY ) ) );
float4 s01 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( 0.0, -OffsetY ) ) );
float4 s02 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( OffsetX, -OffsetY ) ) );
float4 s10 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( -OffsetX, 0.0 ) ) );
float4 s12 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( OffsetX, 0.0 ) ) );
float4 s20 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( -OffsetX, OffsetY ) ) );
float4 s21 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( 0.0, OffsetY ) ) );
float4 s22 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( OffsetX, OffsetY ) ) );
// Calc X gradient
float4 GradX = s00 + 2.0*s10 + s20 - ( s02 + 2.0*s12 + s22 );
float4 GradY = s00 + 2.0*s01 + s02 - ( s20 + 2.0*s21 + s22 );
float asum = max(max(max(s00.a,s01.a),max(s02.a,s10.a)),max(max(s12.a,s20.a),max(s21.a,s22.a)));
#if defined DX11_SHADERS || defined DX12_SHADERS
if( ps_alphaTest.x )
{
clip( asum - ps_alphaTest.y );
}
#endif
float4 SquareGrad = GradX*GradX + GradY*GradY;
float4 final = sqrt( SquareGrad )*colScale;
final.rgb *= asum;
return final;
}
float4 calcSobelGradiant_samp1Red(VS_OUT In,float edgeWidth,float scale)
{
float2 offset = ps_samp0Size.zw*edgeWidth;
float OffsetX = offset.x;
float OffsetY = offset.y;
float s00 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( -OffsetX, -OffsetY ) ) ).x;
float s01 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( 0.0, -OffsetY ) ) ).x;
float s02 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( OffsetX, -OffsetY ) ) ).x;
float s10 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( -OffsetX, 0.0 ) ) ).x;
float s11 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( 0.0, 0.0 ) ) ).x;
float s12 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( OffsetX, 0.0 ) ) ).x;
float s20 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( -OffsetX, OffsetY ) ) ).x;
float s21 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( 0.0, OffsetY ) ) ).x;
float s22 = TEXTURE_READ_2D( samp, 1, In.uv0 + ( float2( OffsetX, OffsetY ) ) ).x;
float2 Grad = float2(s00 + 2.0*s10 + s20 - ( s02 + 2.0*s12 + s22 ),s00 + 2.0*s01 + s02 - ( s20 + 2.0*s21 + s22 ));
float4 bright0 = float4(s00,s01,s02,s10);
float4 bright1 = float4(s12,s20,s21,s22);
//< 9-tap gaussian on red channel only
float bright0Avg = dot(bright0,float4(0.07511f,0.12384f,0.07511f,0.12384f));
float bright1Avg = dot(bright1,float4(0.12384,0.07511,0.12384f,0.07511f));
float brightAvg = bright0Avg + bright1Avg + (s11.x * 0.20418);
float sobel = sqrt(dot(Grad,Grad)) * scale;
float4 final = float4(Grad.x * scale,Grad.y * scale,brightAvg,sobel);
return final;
}
//#ifdef ALT_TOONSHADER
//PS_OUT ps_sobel_colored( VS_OUT In )
//{
// float4 FragCol = calcSobel_samp0(In,1.0f,1.0f);
//
// PS_OUT output;
// output.clr = FragCol;
// return output;
//}
//#else
PS_OUT ps_sobel_colored( VS_OUT input )
{
float3 img_c = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyz;
float3 img_l = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, 0.0 ) ).xyz;
float3 img_r = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0.0 ) ).xyz;
float3 img_u = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, ps_samp0Size.w ) ).xyz;
float3 img_d = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w ) ).xyz;
float4 sobel;
{
float l_dot = colorDistance_euclidean( img_c, img_l );
float r_dot = colorDistance_euclidean( img_c, img_r );
float max_lr = max( l_dot, r_dot );
float u_dot = colorDistance_euclidean( img_c, img_u );
float d_dot = colorDistance_euclidean( img_c, img_d );
float max_ud = max( u_dot, d_dot );
float delta = max( max_lr, max_ud );
sobel = ps_reg2;
sobel.w *= saturate( pow( delta, ps_reg0.x ) * ps_reg0.y );
}
PS_OUT output;
output.clr = sobel;
return output;
}
//#endif
PS_OUT ps_yuv_pack_to_rgba( VS_OUT input )
{
float2 clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).xy;
float2 clrRight = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0.0 ) ).xy;
float2 clrLeft = TEXTURE_READ_2D( samp, 0, input.uv0 - float2( ps_samp0Size.z, 0.0 ) ).xy;
float Fact = 1.164123535;
float3 Crc = float3( 1.595794678, -0.813476563, 0.0 );
float3 Crb = float3( 0.0, -0.391448975, 2.017822266 );
float3 Adj = float3( -0.87065506, 0.529705048, -1.081668854 );
float3x3 matToRgb = float3x3(
float3(Crc.x, Crc.y, Crc.z),
float3(Crb.x, Crb.y, Crb.z),
float3(Adj.x, Adj.y, Adj.z) );
float y, u, v;
int isOdd = floor( input.uv0.x * ps_samp0Size.x );
isOdd = isOdd -( ( isOdd / 2 ) * 2 );
y = clr.x;
if( isOdd )
{
u = clrLeft.y;
v = clr.y;
}
else
{
u = clr.y;
v = clrRight.y;
}
float3 res = mul( float3( v, u, 1.0 ), matToRgb );
res += float3( y, y, y ) * Fact;
PS_OUT output;
output.clr = float4( res, 1.0 );
return output;
}
PS_OUT ps_yuv_to_yuv_pack( VS_OUT input )
{
// unpack YUV :
// x <=> Y
// y <=> U
// z <=> Y
// packed YUV :
// x <=> U or V( half rez )
// y <=> Y
float3 yuv = TEXTURE_READ_2D( samp, 0, input.uv0 );
float3 yuv_right = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0.0 ) ).xyz;
float3 yuv_left = TEXTURE_READ_2D( samp, 0, input.uv0 - float2( ps_samp0Size.z, 0.0 ) ).xyz;
float3 yuv_pack;
int isOdd = floor( input.uv0.x * ps_samp0Size.x );
isOdd = isOdd -( ( isOdd / 2 ) * 2 );
if( isOdd )
{
yuv_pack.y = yuv.x; // Y
yuv_pack.x =( yuv.z + yuv_left.z ) * 0.5; //V
yuv_pack.z = 0.0;
}
else
{
yuv_pack.y = yuv.x; // Y
yuv_pack.x =( yuv.y + yuv_right.y ) * 0.5; //U
yuv_pack.z = 0.0;
}
PS_OUT output;
output.clr = float4( yuv_pack, 1.0 );
return output;
}
PS_OUT ps_copy_depth( VS_OUT input )
{
PS_OUT output;
float depth = TEXTURE_READ_2D( samp, 0, input.uv0 ).x;
float band_size = ps_reg0.x;
float banded = fmod(depth.x, band_size);
float contour = abs((banded / (band_size / 2)) - 1);
output.clr.rgba = float4(depth.x, contour, depth.x, 1);
return output;
}
// RGB / HSL conversions
float3 rgb_to_hsl(float3 rgb)
{
float3 hsl = 0;
float2 MinMax;
float delta;
MinMax.x = min( rgb.r, min(rgb.g, rgb.b) );
MinMax.y = max( rgb.r, max(rgb.g, rgb.b) );
hsl.z = 0.5 * (MinMax.x + MinMax.y);
if (MinMax.x != MinMax.y)
{
delta = (MinMax.y - MinMax.x);
if (hsl.z > 0.5)
hsl.y = delta / (2 - MinMax.x - MinMax.y);
else
hsl.y = delta / (MinMax.x + MinMax.y);
if (rgb.r == MinMax.y)
hsl.x = ( (rgb.g - rgb.b) / delta );
else if (rgb.g == MinMax.y)
hsl.x = 2 + (rgb.b - rgb.r) / delta;
else
hsl.x = 4 + (rgb.r - rgb.g) / delta;
hsl.x /= 6.0;
if (hsl.x < 0.0)
hsl.x += 1.0;
}
return hsl;
}
float hsl_value(float n1, float n2, float hue)
{
float val;
if (hue > 6.0)
hue -= 6.0;
else if (hue < 0.0)
hue += 6.0;
if (hue < 1.0)
val = n1 + (n2 - n1) * hue;
else if (hue < 3.0)
val = n2;
else if (hue < 4.0)
val = n1 + (n2 - n1) * (4.0 - hue);
else
val = n1;
return val;
}
float3 hsl_to_rgb(float3 hsl)
{
float3 rgb = 0;
if (hsl.y == 0)
{
rgb.r = hsl.z;
rgb.g = hsl.z;
rgb.b = hsl.z;
}
else
{
float m1, m2;
if (hsl.z <= 0.5)
m2 = hsl.z * (1.0 + hsl.y);
else
m2 = hsl.z + hsl.y - hsl.z * hsl.y;
m1 = 2.0 * hsl.z - m2;
rgb.r = hsl_value (m1, m2, hsl.x * 6.0 + 2.0);
rgb.g = hsl_value (m1, m2, hsl.x * 6.0);
rgb.b = hsl_value (m1, m2, hsl.x * 6.0 - 2.0);
}
return rgb;
}
// Contrast
float EnhanceContrast(float lighting)
{
float weight = step(0.5f, lighting);
float lNew = smoothstep(0.0f, 1.0f, lighting);
lNew = lNew * 2.0f - 1.0f;
lNew = lerp( saturate(pow(lNew + 1, ps_reg0.z)), saturate(pow(1 - lNew, ps_reg0.z)), weight );
lNew = lerp( lNew - 1, 1 - lNew, weight );
lNew = lNew * 0.5f + 0.5f;
return lNew;
}
// UV Blackout
PS_OUT ps_uv_blackout( VS_OUT input )
{
PS_OUT output;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
float lightness = TEXTURE_READ_2D( samp, 1, input.uv0 ).a;
// Convert to HSL
float3 hsl = rgb_to_hsl( output.clr.rgb );
// Desaturate
hsl.y *= ps_reg0.y;
// Enhance lighting contrast
hsl.z = EnhanceContrast(lightness);
// Convert to RGB
float3 clr = hsl_to_rgb( hsl );
// Negative
clr = 1 - clr;
// Tint
clr *= ps_reg1.rgb;
// Brightness
clr += ps_reg0.w;
// Factor
output.clr.rgb = lerp( output.clr.rgb, clr, ps_reg0.x );
return output;
}
// --------------------------------------------------------------------
// 3x3 Median
// Based on Morgan McGuire and Kyle Whitson implementation in Shader X6
#define s2(a, b) temp = a; a = min(a, b); b = max(temp, b);
#define mn3(a, b, c) s2(a, b); s2(a, c);
#define mx3(a, b, c) s2(b, c); s2(a, c);
#define mnmx3(a, b, c) mx3(a, b, c); s2(a, b); // 3 exchanges
#define mnmx4(a, b, c, d) s2(a, b); s2(c, d); s2(a, c); s2(b, d); // 4 exchanges
#define mnmx5(a, b, c, d, e) s2(a, b); s2(c, d); mn3(a, c, e); mx3(b, d, e); // 6 exchanges
#define mnmx6(a, b, c, d, e, f) s2(a, d); s2(b, e); s2(c, f); mn3(a, b, c); mx3(d, e, f); // 7 exchanges
float4 ps_autodance_median3x3( VS_OUT In, float4 clrCenter )
{
const float offx = 1.0f / 900.0f;
const float offy = 1.0f / 600.0f;
float4 v[9], temp;
v[0] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( -offx, -offy ) ).xyzw;
v[1] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( 0.0, -offy ) ).xyzw;
v[2] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( offx, -offy ) ).xyzw;
v[3] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( -offx, 0.0 ) ).xyzw;
v[4] = clrCenter;
v[5] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( offx, 0.0 ) ).xyzw;
v[6] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( -offx, offy ) ).xyzw;
v[7] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( 0.0, offy ) ).xyzw;
v[8] = TEXTURE_READ_2D( samp, 0, In.uv0 + float2( offx, offy ) ).xyzw;
// Starting with a subset of size 6, remove the min and max each time
mnmx6(v[0], v[1], v[2], v[3], v[4], v[5]);
mnmx5(v[1], v[2], v[3], v[4], v[6]);
mnmx4(v[2], v[3], v[4], v[7]);
mnmx3(v[3], v[4], v[8]);
return v[4];
}
#ifdef ALT_TOONSHADER
// Toon shader
PS_OUT ps_toon( VS_OUT input )
{
DEFINE_CONSTANTS;
PS_OUT output;
float4 clrCenter = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgba;
float4 col = ps_autodance_median3x3(input, clrCenter);
// Convert to HSL
float3 hsl = rgb_to_hsl( col.rgb );
// apply toon banding.
hsl.z = (ceil((hsl.z * ps_reg0.y) + 0.5f) - 0.5f) / ps_reg0.y;
hsl.y = (ceil((hsl.y * ps_reg0.y) + 0.5f) - 0.5f) / ps_reg0.y;
// Convert back to RGB
float3 clr = hsl_to_rgb( hsl );
float4 refCol = float4(clr,1);
// Factor
output.clr.rgb = lerp( clrCenter.rgb, refCol.rgb, ps_reg0.x );
output.clr.a = col.a;
return output;
}
float SmoothRect(float x,float loStart,float loRange,float hiStart,float hiRange)
{
float lo = ((x - loStart) / loRange);
float hi = 1.0 - ((x - hiStart) / hiRange);
float res = min(lo,hi);
return saturate(res);
}
PS_OUT ps_toon_outline( VS_OUT input )
{
DEFINE_CONSTANTS;
PS_OUT output;
const float lowThreshold = 0.01f;
const float highThreshold = 1.0f - lowThreshold;
float4 playerMaskData = calcSobelGradiant_samp1Red(input,4.0f,0.25f);
float playerMask = max(0,playerMaskData.z - (0.5f * (saturate(((1.0f - playerMaskData.z) - 0.5f) * 2.0f) * (1.0f - playerMaskData.w))));
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgba;
float finalAlpha = SmoothRect(playerMask,0.0f,0.1f,0.6f,0.2f) * ps_reg1.x;
float colBW = (1.0f - saturate((playerMask - 0.35f) * 10.0f)) * finalAlpha;
float4 outline = float4(colBW.xxx,finalAlpha);
output.clr = (output.clr * (1.0f - outline.a)) + outline;
return output;
}
#else
// Toon shader
PS_OUT ps_toon( VS_OUT input )
{
DEFINE_CONSTANTS;
PS_OUT output;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgba;
float sobel = TEXTURE_READ_2D( samp, 1, input.uv0 ).w;
// Convert to HSL
float3 hsl = rgb_to_hsl( output.clr );
float lightness = hsl.z;
// Cut out
float bandSize = floor( 256.0f / ps_reg0.y );
float bandIndex = 1.0f + floor(hsl.z * 255.0f / bandSize);
hsl.z = saturate( bandIndex * bandSize / 255.0f );
// Convert to RGB
float3 clr = hsl_to_rgb( hsl );
// Multiply blend mode
clr *= clr;
// Overlay blend mode
float weight = step(0.5f, lightness);
clr = lerp(
clamp( pow(clr * output.clr.rgb, ps_reg0.z), vec3_zero, output.clr.rgb ),
vec3_one - (vec3_one - clr) * (vec3_one - output.clr.rgb),
weight);
// Photocopy filter
clr *= 1.0f - sobel;
// Factor
output.clr.rgb = lerp( output.clr.rgb, clr, ps_reg0.x );
return output;
}
PS_OUT ps_toon_outline( VS_OUT input )
{
DEFINE_CONSTANTS;
PS_OUT output;
const float lowThreshold = 0.01f;
const float highThreshold = 1.0f - lowThreshold;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgba;
float playerMask = TEXTURE_READ_2D( samp, 1, input.uv0 ).x;
// Black contour
float middle = ps_reg0.x;
float thickness = ps_reg0.y;
float smoothFactor = ps_reg0.z;
float lowStart = middle -( thickness*0.5 ) - smoothFactor;
float lowEnd = middle -( thickness*0.5 );
float highStart = middle +( thickness*0.5 ) + smoothFactor;
float highEnd = middle +( thickness*0.5 );
lowStart = max(lowStart, lowThreshold);
lowEnd = max(lowEnd, lowThreshold);
highStart = min(highStart, highThreshold);
highEnd = min(highEnd, highThreshold);
float contourMaskBlack = min(
smoothstep( lowStart, lowEnd, playerMask ),
smoothstep( highStart, highEnd, playerMask ) );
// White contour
middle = middle - (0.5 * ps_reg0.w * thickness + 0.5 * thickness + smoothFactor);
thickness *= ps_reg0.w;
lowStart = middle -( thickness*0.5 ) - smoothFactor;
lowEnd = middle -( thickness*0.5 );
highStart = middle +( thickness*0.5 ) + smoothFactor;
highEnd = middle +( thickness*0.5 );
lowStart = max(lowStart, lowThreshold);
lowEnd = max(lowEnd, lowThreshold);
highStart = min(highStart, highThreshold);
highEnd = min(highEnd, highThreshold);
float contourMaskWhite = min(
smoothstep( lowStart, lowEnd, playerMask ),
smoothstep( highStart, highEnd, playerMask ) );
// Blend
float4 clr = output.clr;
clr.rgb = lerp( clr.rgb, vec3_one, contourMaskWhite );
clr.rgb = lerp( clr.rgb, vec3_zero, contourMaskBlack );
// Set Alpha at the outline
clr.a = lerp( output.clr.a, 1.0f, max( contourMaskWhite, contourMaskBlack ) );
// Factor
output.clr = lerp( output.clr, clr, ps_reg1.x );
return output;
}
#endif
// Half tone
PS_OUT ps_half_tone( VS_OUT input )
{
const float factor = 0.35f;
PS_OUT output;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
float lightness = TEXTURE_READ_2D( samp, 2, input.uv0 ).r;
// Convert to HSL
float3 hsl = rgb_to_hsl( output.clr );
// Cut out
float bandSize = floor( 256.0f / ps_reg0.y );
float bandIndex = clamp( floor(hsl.z * 255.0f / bandSize), 1.0f, ps_reg0.y );
hsl.z = bandIndex * bandSize / 255.0f;
// Convert to RGB
float3 clr = hsl_to_rgb( hsl );
// Apply halftone pattern
const float4 xmin = float4(0.0f, 0.15f, 0.3f, 0.45f);
const float4 xmax = float4(0.15f, 0.3f, 0.45f, 0.6f);
const float tiling = 40.0;
float4 halftoneTx = TEXTURE_READ_2D( samp, 1, input.uv0 * tiling ).xyzw;
float4 halftone = halftoneTx * rectFunc(xmin, xmax, lightness);
halftone = factor * dot(halftone, float4(1,1,1,1));
halftone = 1.0f - halftone;
// Blend layers
output.clr.rgb = lerp( output.clr.rgb, clr * halftone.x, ps_reg0.x );
return output;
}
PS_OUT ps_mask_body_part(VS_OUT input)
{
float playerMask = TEXTURE_READ_2D( samp, 1, input.uv0.xy ).x;
playerMask = linStep( ps_reg2.x, ps_reg2.y, max(0,playerMask ));
float4 color = float4( TEXTURE_READ_2D( samp, 0, input.uv0 ).xyz, playerMask );
PS_OUT output;
output.clr = color;
return output;
}
PS_OUT ps_mask_body_part_hide(VS_OUT input)
{
float3 color0 = TEXTURE_READ_2D( samp, 0, ps_reg0.xy ).xyz;
float3 color1 = TEXTURE_READ_2D( samp, 0, ps_reg0.zw ).xyz;
float3 color2 = TEXTURE_READ_2D( samp, 0, ps_reg1.xy ).xyz;
float3 color3 = TEXTURE_READ_2D( samp, 0, ps_reg1.zw ).xyz;
float playerMask = TEXTURE_READ_2D( samp, 1, input.uv0 ).x;
playerMask = linStep( ps_reg2.x, ps_reg2.y, playerMask );
float4 color = float4( TEXTURE_READ_2D( samp, 0, input.uv0.xy ).xyz, playerMask );
float4 colorF = float4( ( ( color0 + color1 + color2 + color3 ) / 4.0f), playerMask );
PS_OUT output;
output.clr = lerp( color, colorF, playerMask);
//output.clr = float4(playerMask.xxx,1.0f);
return output;
}
// Perspective correction
PS_OUT ps_mask_body_part_PC(VS_PC_OUT input)
{
float2 uv = input.uv.xy / input.uv.z;
float playerMask = TEXTURE_READ_2D( samp, 1, uv ).x;
playerMask = linStep( ps_reg2.x, ps_reg2.y, playerMask );
float4 color = float4( TEXTURE_READ_2D( samp, 0, uv ).xyz, playerMask );
float2 uv2 = input.uv2.xy / input.uv2.z;
float playerMask2 = TEXTURE_READ_2D( samp, 2, uv2 ).x;
playerMask2 = linStep( ps_reg2.x, ps_reg2.y, playerMask2 );
float4 color2 = float4( TEXTURE_READ_2D( samp, 0, uv2 ).xyz, playerMask2 );
float val = 0.0f;
val += ( 1.0f - rectFunc( 0.0f, ps_reg2.z, input.uv2.w ) ) * ( 1.0f - rectFunc( ps_reg2.z, 1.0f, input.uv2.w ) ) ;
val += rectFunc( ps_reg2.z, ps_reg2.w, input.uv2.w ) * ( ( input.uv2.w - ps_reg2.z ) / ( ps_reg2.w - ps_reg2.z ) );
val += rectFunc( ps_reg2.w, 1.0f, input.uv2.w );
val = saturate(val);
PS_OUT output;
output.clr = lerp( color, color2, val );
return output;
}
PS_OUT ps_mask_body_part_depth(VS_OUT input)
{
float playerMask = TEXTURE_READ_2D( samp, 1, input.uv0 ).x;
playerMask = linStep( ps_reg2.x, ps_reg2.y, playerMask );
float4 color = float4( TEXTURE_READ_2D( samp, 0, input.uv0 ).xyz, playerMask );
clip( playerMask - 1.0/255.0f );
PS_OUT output;
output.clr = color;
return output;
}
// Perspective correction
PS_OUT ps_mask_body_part_depth_PC(VS_PC_OUT input)
{
float2 uv = input.uv.xy / input.uv.z;
float playerMask = TEXTURE_READ_2D( samp, 1, uv ).x;
playerMask = linStep( ps_reg2.x, ps_reg2.y, playerMask );
float4 color = float4( TEXTURE_READ_2D( samp, 0, uv ).xyz, playerMask );
float2 uv2 = input.uv2.xy / input.uv2.z;
float playerMask2 = TEXTURE_READ_2D( samp, 2, uv2 ).x;
playerMask2 = linStep( ps_reg2.x, ps_reg2.y, playerMask2 );
float4 color2 = float4( TEXTURE_READ_2D( samp, 0, uv2 ).xyz, playerMask2 );
float val = 0.0f;
val += ( 1.0f - rectFunc( 0.0f, ps_reg2.z, input.uv2.w ) ) * ( 1.0f - rectFunc( ps_reg2.z, 1.0f, input.uv2.w ) ) ;
val += rectFunc( ps_reg2.z, ps_reg2.w, input.uv2.w ) * ( ( input.uv2.w - ps_reg2.z ) / ( ps_reg2.w - ps_reg2.z ) );
val += rectFunc( ps_reg2.w, 1.0f, input.uv2.w );
val = saturate(val);
float4 colorRes = lerp( color, color2, val );
clip( colorRes.w - 1.0/255.0f );
PS_OUT output;
output.clr = colorRes;
return output;
}
#define BODY_PART_HEAD 1.0f
#define BODY_PART_HAND_LEFT 2.0f
#define BODY_PART_HAND_RIGHT 3.0f
#define BODY_PART_FOOT_LEFT 4.0f
#define BODY_PART_FOOT_RIGHT 5.0f
#define BODY_PART_MAX BODY_PART_FOOT_RIGHT
#define BODY_PART_MARGIN 0.5f / BODY_PART_MAX
float isPart( float partIndex, float bodyPart )
{
return rectFunc( bodyPart - BODY_PART_MARGIN, bodyPart + BODY_PART_MARGIN, partIndex );
}
PS_OUT ps_mask_body_part_index(VS_OUT input)
{
float playerMask = TEXTURE_READ_2D( samp, 0, input.uv0 ).x;
#if defined DX11_SHADERS || defined DX12_SHADERS
if( ps_alphaTest.x )
{
clip( playerMask - ps_alphaTest.y );
}
#endif
PS_OUT output;
output.clr = ps_reg2.x / BODY_PART_MAX;
output.clr.a = playerMask;
return output;
}
PS_OUT ps_mask_body_part_index_PC(VS_PC_OUT input)
{
float2 uv = input.uv.xy / input.uv.z;
float playerMask = TEXTURE_READ_2D( samp, 0, uv ).x;
#if defined DX11_SHADERS || defined DX12_SHADERS
if( ps_alphaTest.x )
{
clip( playerMask - ps_alphaTest.y );
}
#endif
PS_OUT output;
output.clr = ps_reg2.x / BODY_PART_MAX;
output.clr.a = playerMask;
return output;
}
PS_OUT ps_update_lightness( VS_OUT input )
{
PS_OUT output;
float3 clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgb;
float4 lightPrev = TEXTURE_READ_2D( samp, 1, input.uv0 );
float3 hsl = rgb_to_hsl( clr );
float4 lightNew = hsl.z;
output.clr = lerp( lightPrev, lightNew, ps_reg0 );
return output;
}
// NuiToWorld (see DepthVisualizer example)
float3 NuiToWorld( float3 vNuiPosition )
{
float3 vWorldPosition;
vWorldPosition.xy = vNuiPosition.z * ps_reg0.xy * ( vNuiPosition.xy - 0.5f );
vWorldPosition.z = vNuiPosition.z;
return vWorldPosition;
}
// Normal Map
PS_OUT ps_normal_map(VS_OUT input)
{
float4 depths = float4(
TEXTURE_READ_2D( samp, 0, input.uv0 ).r,
TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0.0 ) ).r,
TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, ps_samp0Size.w ) ).r,
1.0f );
// Recover the 3 worldspace sample coordinates
float3 vWorld00 = NuiToWorld( float3( input.uv0, depths.x ) );
float3 vWorld10 = NuiToWorld( float3( input.uv0 + float2( ps_samp0Size.z, 0.0 ), depths.y ) );
float3 vWorld01 = NuiToWorld( float3( input.uv0 + float2( 0.0, ps_samp0Size.w ), depths.z ) );
// From the change in depth in the x and the y direction, compute the viewspace normal vector
float3 vTangent = vWorld10 - vWorld00;
float3 vBinormal = vWorld01 - vWorld00;
float3 vNormal = normalize( cross( vTangent, vBinormal ) );
PS_OUT output;
output.clr = float4( vNormal * 0.5f + 0.5f, 1.0f );
return output;
}
// Bilateral depth filter
#define KER_HALFSIZE 3 // Fixed kernel size
#define KER_DIRECTION ps_reg0.xy
#define BILATERAL_ATT ps_reg0.z
#define KER_WEIGHTS ps_reg1
PS_OUT ps_filter_depth(VS_OUT input)
{
// Construct weights
float vWeights[ KER_HALFSIZE * 2 + 1 ] = { KER_WEIGHTS.w, KER_WEIGHTS.z, KER_WEIGHTS.y, KER_WEIGHTS.x, KER_WEIGHTS.y, KER_WEIGHTS.z, KER_WEIGHTS.w };
// Take samples
float vSamples[ KER_HALFSIZE * 2 + 1 ];
for (int i = -KER_HALFSIZE; i <= KER_HALFSIZE; ++i)
{
float2 uvOffset = KER_DIRECTION * ps_samp0Size.zw * i;
vSamples[ KER_HALFSIZE + i ] = TEXTURE_READ_2D( samp, 0, input.uv0 + uvOffset ).r;
}
// Average them taking edges into account
float fCenterDepth = vSamples[KER_HALFSIZE];
float fDepthWeighted = 0.0f;
float fTotalWeight = 0.0f;
float denormalize = 1.0f;
#ifdef ITF_DURANGO
denormalize = 3500.0f;
#endif
for (int i = -KER_HALFSIZE; i <= KER_HALFSIZE; ++i)
{
float fDepth = vSamples[ KER_HALFSIZE + i ];
float fWeight = vWeights[ KER_HALFSIZE + i ];
float fDepthDist = fCenterDepth - fDepth;
float fFalloff = exp2( -BILATERAL_ATT * fDepthDist * denormalize * fDepthDist * denormalize );
fWeight *= fFalloff;
fDepthWeighted += fWeight * fDepth;
fTotalWeight += fWeight;
}
PS_OUT output;
output.clr = fDepthWeighted / fTotalWeight;
return output;
}
#undef KER_DIRECTION
#undef KER_HALFSIZE
#undef KER_WEIGHTS
#undef BILATERAL_ATT
#define KER_HALFSIZE 3 // Fixed kernel size
#define KER_DIRECTION ps_reg0.xy
#define KER_WEIGHTS ps_reg1
PS_OUT ps_filter_mask(VS_OUT input)
{
// Construct weights
float vWeights[ KER_HALFSIZE * 2 + 1 ] = { KER_WEIGHTS.w, KER_WEIGHTS.z, KER_WEIGHTS.y, KER_WEIGHTS.x, KER_WEIGHTS.y, KER_WEIGHTS.z, KER_WEIGHTS.w };
// Take samples
float vSamples[ KER_HALFSIZE * 2 + 1 ];
for (int i = -KER_HALFSIZE; i <= KER_HALFSIZE; ++i)
{
float2 uvOffset = KER_DIRECTION * ps_samp0Size.zw * i;
vSamples[ KER_HALFSIZE + i ] = TEXTURE_READ_2D( samp, 0, input.uv0 + uvOffset ).r;
}
// Average them taking edges into account
float fMaskWeighted = 0.0f;
float fTotalWeight = 0.0f;
for (int i = -KER_HALFSIZE; i <= KER_HALFSIZE; ++i)
{
float3 fClr = vSamples[ KER_HALFSIZE + i ];
float fWeight = vWeights[ KER_HALFSIZE + i ];
fMaskWeighted += fWeight * fClr;
fTotalWeight += fWeight;
}
float fRes = fMaskWeighted / fTotalWeight;
PS_OUT output;
output.clr = fRes;
return output;
}
#undef KER_DIRECTION
#undef KER_HALFSIZE
#undef KER_WEIGHTS
PS_OUT ps_refraction(VS_OUT input)
{
float2 normal = TEXTURE_READ_2D( samp, 2, input.uv0 ).xy;
normal = ( normal * 2.0f ) - 1.0f;
float2 refractTexCoord = input.uv0 + ( normal.xy * ps_reg0.xy );
float4 iceColor = float4( TEXTURE_READ_2D( samp, 1, input.uv0 ).xyz * ps_reg1.xyz, 1.0f );
float4 refractedColor = TEXTURE_READ_2D( samp, 0, refractTexCoord );
float4 cleanColor = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 refractionResult = float4( lerp(refractedColor, iceColor, ps_reg0.z).xyz, cleanColor.w );
PS_OUT output;
output.clr = lerp( cleanColor, refractionResult, ps_reg0.w);
return output;
}
PS_OUT ps_alpha_gradient(VS_OUT input)
{
float min = ps_reg0.x;
float max = ps_reg0.y;
float4 vOrigColor = TEXTURE_READ_2D( samp, 0, input.uv0 );
float fAlpha = clamp(((1.0f-input.uv0.y) - min) / (max-min), 0.0f, 1.0f);
PS_OUT output;
output.clr = float4(vOrigColor.rgb, fAlpha * vOrigColor.a);
return output;
}
PS_OUT ps_colored_shiva_alpha_blend( VS_OUT input )
{
float4 oldImage = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 newImage = TEXTURE_READ_2D( samp, 1, input.uv0 );
float finalAlpha = newImage.w +( oldImage.w*( 1.0-newImage.w ) );
float3 finalClr =( newImage.xyz * newImage.w ) +( oldImage.xyz*oldImage.w*( 1.0-newImage.w ) );
finalClr /= finalAlpha + 0.001f;
if( newImage.w >= ps_reg0.x && newImage.w < ps_reg0.y )
{
finalClr = lerp( finalClr, ps_reg1.xyz, ps_reg1.w );
}
else if( newImage.w >= ps_reg0.y && newImage.w < ps_reg0.z )
{
finalClr = lerp( finalClr, ps_reg2.xyz, ps_reg2.w );
}
else if( newImage.w >= ps_reg0.z && newImage.w < ps_reg0.w )
{
finalClr = lerp( finalClr, ps_reg3.xyz, ps_reg3.w );
}
PS_OUT output;
output.clr = float4( finalClr, finalAlpha );
return output;
}
float GetShivaAlpha(float2 uv)
{
return TEXTURE_READ_2D( samp, 0, uv ).a;
}
float4 GetShivaColourFromAlpha(float alpha,float alphaDelta,float4 defaultCol)
{
float finalAlpha = alpha;//max(alpha,alphaDelta);
float3 finalClr = defaultCol * alpha;
finalClr = lerp(ps_reg1.xyz,finalClr,finalAlpha);
if( alpha >= ps_reg0.x && alpha < ps_reg0.y )
{
finalClr = lerp( finalClr, ps_reg1.xyz, ps_reg1.w );
}
else if( alpha >= ps_reg0.y && alpha < ps_reg0.z )
{
finalClr = lerp( finalClr, ps_reg2.xyz, ps_reg2.w );
}
else if( alpha >= ps_reg0.z && alpha < ps_reg0.w )
{
finalClr = lerp( finalClr, ps_reg3.xyz, ps_reg3.w );
}
return float4(RGB2XYY(finalClr),alpha);
}
float4 GetShivaColour(float2 uv)
{
float4 newImage = TEXTURE_READ_2D( samp, 0, uv );
float finalAlpha = newImage.w;
float3 finalClr = newImage.xyz * newImage.w;
finalClr = lerp(ps_reg1.xyz,finalClr,finalAlpha);
if( newImage.w >= ps_reg0.x && newImage.w < ps_reg0.y )
{
finalClr = lerp( finalClr, ps_reg1.xyz, ps_reg1.w );
//finalAlpha = ps_reg1.w;
}
else if( newImage.w >= ps_reg0.y && newImage.w < ps_reg0.z )
{
finalClr = lerp( finalClr, ps_reg2.xyz, ps_reg2.w );
//finalAlpha = ps_reg2.w;
}
else if( newImage.w >= ps_reg0.z && newImage.w < ps_reg0.w )
{
finalClr = lerp( finalClr, ps_reg3.xyz, ps_reg3.w );
//finalAlpha = ps_reg3.w;
}
return float4(RGB2XYY(finalClr),finalAlpha);
}
PS_OUT ps_colored_shiva( VS_OUT input )
{
float ou = ddx(input.uv0.x) * 1.5f;
float ov = ddy(input.uv0.y) * 1.5f;
float3 baseColour = RGB2XYY(TEXTURE_READ_2D( samp, 0, input.uv0 ).rgb);
float4 colcc = GetShivaColour(input.uv0);
float alpha00 = GetShivaAlpha(input.uv0 + float2(-ou,0));
float alpha10 = GetShivaAlpha(input.uv0 + float2(ou,0));
float alpha11 = GetShivaAlpha(input.uv0 + float2(0,ov));
float alpha01 = GetShivaAlpha(input.uv0 + float2(0,-ov));
float alphaDelta = max(abs(alpha01 - alpha00),abs(alpha11 - alpha10));
float alphaSum = alpha00 + alpha10 + alpha11 + alpha01 + colcc.a;
float alphaMax = max(max(max(max(alpha00,alpha10),alpha11),alpha01),colcc.a);
float4 col00 = GetShivaColourFromAlpha(alpha00,alphaDelta,colcc);
float4 col10 = GetShivaColourFromAlpha(alpha10,alphaDelta,colcc);
float4 col11 = GetShivaColourFromAlpha(alpha11,alphaDelta,colcc);
float4 col01 = GetShivaColourFromAlpha(alpha01,alphaDelta,colcc);
float4 finalClr = (col01 + col11 + col10 + col00 + colcc) * 0.2f;
float blend = saturate((finalClr.a - 0.85f) * 10.0f);
finalClr.rgb = XYY2RGB(lerp(finalClr.rgb,baseColour.rgb,blend));
finalClr.a = saturate((finalClr.a - alphaDelta) * 10.0f);
PS_OUT output;
output.clr = finalClr;
return output;
}
// Saturation
PS_OUT ps_saturation( VS_OUT input )
{
float4 sourceColor = TEXTURE_READ_2D( samp, 0, input.uv0 );
float3 sourceColorHSL = rgb_to_hsl( sourceColor );
sourceColorHSL.y = clamp( sourceColorHSL.y + ps_reg0.x, 0.0f, 1.0f );
float3 modifiedColor = hsl_to_rgb( sourceColorHSL );
PS_OUT output;
output.clr = float4( modifiedColor, sourceColor.w );
return output;
}
// Ghostbusters Slime Effect
// .. Get downward player edges
PS_OUT ps_slime_mask_p0(VS_OUT input)
{
float clr_0 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w *ps_reg0.x) ).r);
float clr_1 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w *ps_reg0.x*2 ) ).r);
float clr_2 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, ps_samp0Size.w *ps_reg0.x ) ).r);
float clr_3 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, ps_samp0Size.w *ps_reg0.x*2 ) ).r);
float fRes = step( 1.5f, ( clr_2 + clr_3 - clr_0 - clr_1 ) );
PS_OUT output;
output.clr = float4( fRes, fRes, fRes, 1.0f );
return output;
}
// .. Get upward normals
PS_OUT ps_slime_mask_p1(VS_OUT input)
{
float3 normal = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgb * 2.0f - 1.0f;
float fRes = step( ps_reg0.y, normal.y );
PS_OUT output;
output.clr = float4( fRes, fRes, fRes, 1.0f );
return output;
}
// .. Drip
PS_OUT ps_slime_mask_drip(VS_OUT input)
{
float clr_c = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 ).r);
float clr_0 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w ) ).r);
float clr_1 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w * 2 ) ).r);
float clr_2 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w * 3 ) ).r);
float clr_3 = saturate(TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w * 4 ) ).r);
float2 uv = ( input.uv0 - float2( 0.0f, 0.75f ) ) / float2( 0.25f, 0.25f );
float partIndex = TEXTURE_READ_2D( samp, 1, uv ).r * BODY_PART_MAX;
float fRes = ceil( ( clr_c.x + clr_0 + clr_1 + clr_2 + clr_3 ) / 5.0f );
// Do not drip if head
fRes = lerp( fRes, clr_c, isPart(partIndex, BODY_PART_HEAD) );
PS_OUT output;
output.clr = float4( fRes, fRes, fRes, 1.0f );
return output;
}
// .. Slime
#define SLIME_FACTOR ps_reg0.x
#define SLIME_COLOR ps_reg0.gba
#define NORMAL_TILING ps_reg1.xy
#define LIGHT_ANGLE_X ps_reg1.z
#define LIGHT_ANGLE_Z ps_reg1.w
#define REFRACTION_AMOUNT ps_reg2.x
#define REFRACTION_INDEX ps_reg2.y
#define SPECULAR_AMOUNT ps_reg2.z
#define SPECULAR_POWER ps_reg2.w
#define SLIME_AMBIENT ps_reg3.x
#define SLIME_OPACITY ps_reg3.y
PS_OUT ps_slime(VS_OUT input)
{
const float3 down = float3(0.0f, -1.0f, 0.0f);
const float3 toEye = float3(0,0,-1);
float3 normal = TEXTURE_READ_2D( samp, 1, input.uv0 ).rgb * 2.0f - 1.0f;
float3 normalDistortion = TEXTURE_READ_2D( samp, 2, input.uv0 * NORMAL_TILING ).rbg * 2.0f - 1.0f;
// Transform normal
float3 tg = cross(normal, down);
float3 binormal = cross(normal, tg);
tg = cross(binormal, normal);
float3x3 tgToWorld = float3x3(
float3(tg.x, tg.y, tg.z),
float3(normal.x, normal.y, normal.z),
float3(binormal.x, binormal.y, binormal.z ));
float3 newNormal = normalize( mul( normalDistortion, tgToWorld ) );
// Compute the reflection vector.
float3 gLightVecW = float3( LIGHT_ANGLE_X, 0.0f, LIGHT_ANGLE_Z );
gLightVecW = normalize(gLightVecW);
float3 vReflect = reflect(gLightVecW, newNormal);
// Specular light
float spec = pow(max(dot(vReflect, toEye), 0.0f), SPECULAR_POWER);
// Refraction
float3 vRefract = refract(-toEye, newNormal, REFRACTION_INDEX) * REFRACTION_AMOUNT;
float2 uvRefract = vRefract.xy;
// Refracted color
float4 clrSrc = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 clrRefr = TEXTURE_READ_2D( samp, 0, input.uv0 + uvRefract );
clrRefr.rgb = lerp( clrSrc.rgb, clrRefr.rgb, clrRefr.a );
// Final color
float3 vAmbient = SLIME_COLOR * SLIME_AMBIENT;
float3 vDiffuse = SLIME_COLOR;// * dot(newNormal, -gLightVecW);
float3 vTransmitted = clrRefr.rgb * SLIME_COLOR;
float3 vSpecular = (spec * SLIME_COLOR) * SPECULAR_AMOUNT;
float3 finalClr = vAmbient +
lerp( vTransmitted, vDiffuse, SLIME_OPACITY ) +
vSpecular;
PS_OUT output;
output.clr = float4( lerp( clrSrc.rgb, finalClr, SLIME_FACTOR ), clrSrc.a );
return output;
}
#undef SLIME_FACTOR
#undef SLIME_COLOR
#undef NORMAL_TILING
#undef LIGHT_ANGLE_X
#undef LIGHT_ANGLE_Z
#undef REFRACTION_AMOUNT
#undef REFRACTION_INDEX
#undef SPECULAR_AMOUNT
#undef SPECULAR_POWER
PS_OUT ps_replace_color_pow_alpha( VS_OUT input )
{
PS_OUT output;
float alpha = TEXTURE_READ_2D( samp, 0, input.uv0 ).a;
output.clr = float4(ps_reg0.xyz, pow(alpha, ps_reg0.w));
return output;
}
PS_OUT ps_replace_tex_pow_alpha( VS_OUT input )
{
PS_OUT output;
float alpha = TEXTURE_READ_2D( samp, 0, input.uv0 ).a;
float4 clr = TEXTURE_READ_2D( samp, 1, input.uv0 * ps_reg0.zz ).rgba;
output.clr = float4(clr.rgb, clr.a * pow(alpha, ps_reg0.x) * ps_reg0.y );
return output;
}
PS_OUT ps_overlay_grayscale_color( VS_OUT input )
{
DEFINE_CONSTANTS;
PS_OUT output;
float4 color = float4(0.0f, 0.0f, 0.0f, 1.0f);
float3 bcolor = ps_reg0.xyz;
float3 acolor = TEXTURE_READ_2D( samp, 1, input.uv0 ).xyz;
float4 sourceColor = TEXTURE_READ_2D( samp, 0, input.uv0 );
float k = saturate(ceil(0.5f - acolor.r));
color.rgb = lerp( (2.0f*acolor*bcolor), (vec3_one - 2.0f*(vec3_one - acolor)*( vec3_one - bcolor)), k);
#if !defined DX11_SHADERS && !defined DX12_SHADERS
//Revert gamma correction on 360
color.rgb = pow(color.rgb, 2.2);
#endif
output.clr = lerp(sourceColor, color, ps_reg0.w);
return output;
}
PS_OUT ps_overlay_grayscale_color_2( VS_OUT input )
{
PS_OUT output;
float4 color = float4(0.0f, 0.0f, 0.0f, 1.0f);
const float3 vec3_one = float3(1.0f,1.0f,1.0f);
const float3 vec3_zero = float3(0.0f,0.0f,0.0f);
float4 sourceColor = TEXTURE_READ_2D( samp, 0, input.uv0 );
float l = 0;
float2 MinMax;
MinMax.x = min( sourceColor.r, min(sourceColor.g, sourceColor.b) );
MinMax.y = max( sourceColor.r, max(sourceColor.g, sourceColor.b) );
l = 0.5 * (MinMax.x + MinMax.y);
float3 bcolor = ps_reg1.xyz;
float3 acolor = float3(l,l,l);
float k = saturate(ceil(0.5f - l));
float3 overlayBelnded = lerp( (2.0f*acolor*bcolor), (vec3_one - 2.0f*(vec3_one - acolor)*( vec3_one - bcolor)), k);
output.clr = float4(lerp(sourceColor.rgb, overlayBelnded, ps_reg1.w), sourceColor.a);
return output;
}
PS_OUT ps_lerp_copy_as_is( VS_OUT input )
{
PS_OUT output;
output.clr = lerp( TEXTURE_READ_2D( samp, 0, input.uv0 ), TEXTURE_READ_2D( samp, 1, input.uv0 ), ps_reg0.x );
return output;
}
PS_OUT ps_tint_mul_color( VS_OUT input )
{
PS_OUT output;
float4 color = TEXTURE_READ_2D( samp, 0, input.uv0 );
float3 colorTint = ps_reg1.xyz;
float l = 0;
float2 MinMax;
MinMax.x = min( color.r, min(color.g, color.b) );
MinMax.y = max( color.r, max(color.g, color.b) );
l = 0.5 * (MinMax.x + MinMax.y);
output.clr = lerp(color, float4( colorTint * l, color.a), ps_reg0.x );
return output;
}
PS_OUT ps_particles( VS_Particle_OUT input )
{
PS_OUT output;
float2 texUV = input.uv;
float4 texCol = TEXTURE_READ_2D( samp, 0, texUV );
texCol.a = dot(texCol.rgb,float3(0.299f, 0.587f, 0.114f));
output.clr = input.uv2 * texCol;
return output;
}
PS_OUT ps_lobbytoy_explode( VS_OUT input )
{
PS_OUT output;
output.clr = float4(0,0,0,0);
float fPerc = ps_reg0.x;
float2 vDir = float2(0.5, 0.5) - input.uv0;
float2 vExplode = vDir * fPerc;
float2 vSrc = input.uv0 + vExplode;
output.clr = TEXTURE_READ_2D(samp, 0, vSrc);;
return output;
}
// ---------------------------------------Player Mask --------------------------------------
// Buffers info
//
// Body info: ( Mask, MaxDilation, IgnoreHoles, MaxSize )
// DilatedMask: ( Mask Dilated, MaxDilation Dilated, ", Mask Original )
// Shrink: ( Mask Shrinked, ", Mask Dilated, Mask Original )
// Fill color: ( Mask Filling, Color rgb for comparison )
// Fill Holes: ( Mask Filling, MaxDilation Dilated, Mask Dilated, Dilation Count )
//
// Body part info
#ifdef ITF_DURANGO
#define DILATION_MAX 4.0f
#define DILATION_HEAD 4.0f
#define DILATION_HANDS 2.0f
#define DILATION_FEET 2.0f
#else
#define DILATION_MAX 6.0f
#define DILATION_HEAD 6.0f
#define DILATION_HANDS 3.0f
#define DILATION_FEET 3.0f
#endif
#define DILATION_NORM (1.0f / DILATION_MAX)
// Player Utility functions
#define GET_NEIGHBORHOOD_INFO \
float4 mask_t = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w ) ).xyzw; \
float4 mask_l = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, 0.0 ) ).xyzw; \
float4 mask_c = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw; \
float4 mask_r = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0.0 ) ).xyzw; \
float4 mask_b = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, ps_samp0Size.w ) ).xyzw; \
float isMask = ceil(mask_c.x); \
float4 neighbors_x = float4( mask_l.x, mask_r.x, mask_t.x, mask_b.x ); \
float4 neighbors_y = float4( mask_l.y, mask_r.y, mask_t.y, mask_b.y ); \
float4 neighbors_z = float4( mask_l.z, mask_r.z, mask_t.z, mask_b.z ); \
float4 neighbors_w = float4( mask_l.w, mask_r.w, mask_t.w, mask_b.w );
#define GET_NEIGHBORHOOD_INFO_EX \
float4 mask_tt = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w * 2 ) ).xyzw; \
float4 mask_ll = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z * 2, 0.0 ) ).xyzw; \
float4 mask_rr = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z * 2, 0.0 ) ).xyzw; \
float4 mask_bb = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, ps_samp0Size.w * 2 ) ).xyzw; \
float4 neighborsEx_x = float4( mask_ll.x, mask_rr.x, mask_tt.x, mask_bb.x ); \
float4 neighborsEx_y = float4( mask_ll.y, mask_rr.y, mask_tt.y, mask_bb.y ); \
float4 neighborsEx_z = float4( mask_ll.z, mask_rr.z, mask_tt.z, mask_bb.z ); \
float4 neighborsEx_w = float4( mask_ll.w, mask_rr.w, mask_tt.w, mask_bb.w );
inline float Neighborhood_SamePlayers( float mask_c, float4 mask_neighbors )
{
float fPlayerIdxMax = Max( mask_c, mask_neighbors );
float fPlayersCount = ceil(mask_c) + Sum( ceil(mask_neighbors) );
float fPlayerIdxAvg = ( mask_c + Sum( mask_neighbors ) ) / fPlayersCount;
return step( abs( fPlayerIdxMax - fPlayerIdxAvg ), EPSILON );
}
inline float Neighborhood_CommonPlayerIdx( float mask_c, float4 mask_neighbors )
{
float samePlayers = Neighborhood_SamePlayers( mask_c, mask_neighbors );
float fPlayerIdxMax = Max( mask_c.x, mask_neighbors );
return samePlayers * fPlayerIdxMax;
}
inline float Neighborhood_AllMask( float mask_c, float4 mask_neighbors )
{
return ITF_ALL2( float2( mask_c, ITF_ALL2( mask_neighbors ) ) );
}
inline float Neighborhood_AnyMask( float mask_c, float4 mask_neighbors )
{
return ITF_ANY2( float2( mask_c, ITF_ANY2( mask_neighbors ) ) );
}
float Neighborhood_SameRegions( float4 mask_neighbors, float4 mask_neighborsEx )
{
float4 v1 = float4( mask_neighbors.x, mask_neighborsEx.x, mask_neighbors.y, mask_neighborsEx.y );
float4 v2 = float4( mask_neighbors.z, mask_neighborsEx.z, mask_neighbors.w, mask_neighborsEx.w );
float4 maskTexels1 = ceil(v1);
float4 maskTexels2 = ceil(v2);
float maskTexelsCount = Sum( maskTexels1 + maskTexels2 );
float maskTexels = Sum( v1 + v2 );
float maskTexelsAvg = maskTexels / maskTexelsCount;
float4 maskTexelsDiff1 = step( EPSILON, abs( v1 - maskTexels1 * maskTexelsAvg ) );
float4 maskTexelsDiff2 = step( EPSILON, abs( v2 - maskTexels2 * maskTexelsAvg ) );
return 1.0f - saturate( float( ITF_ANY4( maskTexelsDiff1 ) + ITF_ANY4( maskTexelsDiff2 ) ) );
}
// CMA (Cumulative Movement Average Buffer)
PS_OUT ps_cma_copy( VS_OUT input )
{
PS_OUT output;
output.clr.rgb = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgb;
output.clr.a = 1.0f; // Set pixel invalid
return output;
}
PS_OUT ps_cma( VS_OUT input )
{
PS_OUT output;
output.clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgba;
float3 clr = TEXTURE_READ_2D( samp, 1, input.uv0 ).rgb;
#ifdef ITF_DURANGO
float playerMask = ceil( TEXTURE_READ_2D( samp, 2, input.uv0 ).x );
#else
float playerMask = ceil( TEXTURE_READ_2D( samp, 2, input.uv0 ).y );
#endif
float3 cma = output.clr.rgb;
// If the pixel has never been written (invalid), we will write the clr completely
float bgFactor = max( ps_reg0.x, output.clr.a );
// Accumulate only background
output.clr.rgb = lerp( lerp( cma, clr, bgFactor ), cma, playerMask );
// Set valid pixel
output.clr.a = min( output.clr.a, playerMask );
return output;
}
// Edge Diff
PS_OUT ps_edge_diff_intensity(VS_OUT input)
{
DEFINE_CONSTANTS;
float3 clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgb;
float4 cma = TEXTURE_READ_2D( samp, 1, input.uv0 ).rgba;
float fClrI = dot( rgb_to_y, clr.rgb );
float fCmaI = dot( rgb_to_y, cma.rgb );
PS_OUT output;
output.clr = float4( fClrI, fCmaI, cma.a, 1.0f );
return output;
}
PS_OUT ps_edge_diff_blur(VS_OUT input)
{
float2 fRes = 0;
float3 img_c = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0, 0 ) ).xyz;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, -ps_samp0Size.w ) ).xy * 0.07511f;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0, -ps_samp0Size.w ) ).xy * 0.12384f;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, -ps_samp0Size.w ) ).xy * 0.07511f;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, 0 ) ).xy * 0.12384f;
fRes += img_c.xy * 0.20418f;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0 ) ).xy * 0.12384f;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, ps_samp0Size.w ) ).xy * 0.07511f;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0, ps_samp0Size.w ) ).xy * 0.12384f;
fRes += TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, ps_samp0Size.w ) ).xy * 0.07511f;
PS_OUT output;
output.clr = float4(fRes, img_c.z, 1.0f);
return output;
}
// Canny Edge detection
PS_OUT ps_edge_diff_canny_gradient( VS_OUT input )
{
float2 img_00 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, -ps_samp0Size.w ) ).xy;
float2 img_01 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0, -ps_samp0Size.w ) ).xy;
float2 img_02 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, -ps_samp0Size.w ) ).xy;
float2 img_10 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, 0 ) ).xy;
float2 img_12 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0 ) ).xy;
float2 img_20 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, ps_samp0Size.w ) ).xy;
float2 img_21 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0, ps_samp0Size.w ) ).xy;
float2 img_22 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, ps_samp0Size.w ) ).xy;
float2 fGradIntensityX = img_02 + 2.0f * img_12 + img_22 - img_00 - 2.0f * img_10 - img_20;
float2 fGradIntensityY = img_00 + 2.0f * img_01 + img_02 - img_20 - 2.0f * img_21 - img_22;
float2 fGradIntensity = abs(fGradIntensityX) + abs(fGradIntensityY);
float2 fGradDir = atan2( fGradIntensityY, fGradIntensityX );
// Invalid cma
float valid = 1.0f - TEXTURE_READ_2D( samp, 0, input.uv0 ).z;
fGradIntensity.y *= valid;
fGradDir.y *= valid;
PS_OUT output;
output.clr = float4( fGradIntensity / 4.0f, (fGradDir / PI) * 0.5f + 0.5f );
return output;
}
float2 IsDirection(float2 angle1, float2 angle2, float direction)
{
const float DIRECTION_GROUP_SIZE = 1.0f / 4.0f;
const float DIRECTION_GROUP_OFFSET = 1.0f / 16.0f;
float2 g1 = floor( frac(2.0 * (angle1 + DIRECTION_GROUP_OFFSET)) / DIRECTION_GROUP_SIZE );
float2 g2 = floor( frac(2.0 * (angle2 + DIRECTION_GROUP_OFFSET)) / DIRECTION_GROUP_SIZE );
return step( abs(g1 - g2), EPSILON ) * step( abs(g1 - direction), EPSILON );
}
float2 IsSameDirection(float2 angles)
{
const float DIRECTION_GROUP_SIZE = 1.0f / 4.0f;
const float DIRECTION_GROUP_OFFSET = 1.0f / 16.0f;
float2 g = floor( frac(2.0 * (angles + DIRECTION_GROUP_OFFSET)) / DIRECTION_GROUP_SIZE );
return step( abs(g.x - g.y), EPSILON );
}
PS_OUT ps_edge_diff_canny_non_max_suppresion_and_diff( VS_OUT input )
{
DEFINE_CONSTANTS;
float4 img_00 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, -ps_samp0Size.w ) ).xyzw;
float4 img_01 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0, -ps_samp0Size.w ) ).xyzw;
float4 img_02 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, -ps_samp0Size.w ) ).xyzw;
float4 img_10 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, 0 ) ).xyzw;
float4 img_c = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
float4 img_12 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0 ) ).xyzw;
float4 img_20 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, ps_samp0Size.w ) ).xyzw;
float4 img_21 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0, ps_samp0Size.w ) ).xyzw;
float4 img_22 = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, ps_samp0Size.w ) ).xyzw;
//float4 maskDilated = TEXTURE_READ_2D( samp, 1, input.uv0 ).xyzw;
// Classify direction groups
float2 g_00 = IsDirection(img_c.zw, img_00.zw, 3.0f);
float2 g_01 = IsDirection(img_c.zw, img_01.zw, 2.0f);
float2 g_02 = IsDirection(img_c.zw, img_02.zw, 1.0f);
float2 g_10 = IsDirection(img_c.zw, img_10.zw, 0.0f);
float2 g_12 = IsDirection(img_c.zw, img_12.zw, 0.0f);
float2 g_20 = IsDirection(img_c.zw, img_20.zw, 1.0f);
float2 g_21 = IsDirection(img_c.zw, img_21.zw, 2.0f);
float2 g_22 = IsDirection(img_c.zw, img_22.zw, 3.0f);
// Compare gradient direction with that of its neighbors
float2 fIsEdge =
lerp( vec2_one, step( img_00.xy, img_c.xy ), g_00 ) *
lerp( vec2_one, step( img_01.xy, img_c.xy ), g_01 ) *
lerp( vec2_one, step( img_02.xy, img_c.xy ), g_02 ) *
lerp( vec2_one, step( img_10.xy, img_c.xy ), g_10 ) *
lerp( vec2_one, step( img_12.xy, img_c.xy ), g_12 ) *
lerp( vec2_one, step( img_20.xy, img_c.xy ), g_20 ) *
lerp( vec2_one, step( img_21.xy, img_c.xy ), g_21 ) *
lerp( vec2_one, step( img_22.xy, img_c.xy ), g_22 );
float2 fGradIntensity = fIsEdge * img_c.xy;
// Apply threshold
fGradIntensity = step( ps_reg0.x, fGradIntensity );
// Output edges that are in foreground but not in background
float fRes = saturate( fGradIntensity.x - fGradIntensity.y * IsSameDirection(img_c.zw) );
PS_OUT output;
output.clr = float4( fRes, fRes, fRes, 1.0f );
return output;
}
// Short Edges Suppresion
PS_OUT ps_edge_diff_length(VS_OUT input)
{
float4 img_tl = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, -ps_samp0Size.w ) ) * ps_reg0.x;
float4 img_t = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, -ps_samp0Size.w ) ) * ps_reg0.x;
float4 img_tr = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, -ps_samp0Size.w ) ) * ps_reg0.x;
float4 img_l = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, 0.0 ) ) * ps_reg0.x;
float4 img_c = TEXTURE_READ_2D( samp, 0, input.uv0 ) * ps_reg0.x;
float4 img_r = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, 0.0 ) ) * ps_reg0.x;
float4 img_bl = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( -ps_samp0Size.z, ps_samp0Size.w ) ) * ps_reg0.x;
float4 img_b = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( 0.0, ps_samp0Size.w ) ) * ps_reg0.x;
float4 img_br = TEXTURE_READ_2D( samp, 0, input.uv0 + float2( ps_samp0Size.z, ps_samp0Size.w ) ) * ps_reg0.x;
float fConnectTl = (1.0f - saturate( img_t.x + img_l.x ));
float fConnectTr = (1.0f - saturate( img_t.x + img_r.x ));
float fConnectBl = (1.0f - saturate( img_b.x + img_l.x ));
float fConnectBr = (1.0f - saturate( img_b.x + img_r.x ));
float fToReceive = img_tl.y * fConnectTl;
fToReceive += img_tr.y * fConnectTr;
fToReceive += img_bl.y * fConnectBl;
fToReceive += img_br.y * fConnectBr;
fToReceive += img_t.y + img_l.y + img_r.y + img_b.y;
fToReceive *= saturate(img_c.x);
fToReceive -= img_c.w * ps_reg0.w; // Subtract what was given before and has come back
float fConnectionsAcc = img_c.x * ps_reg0.w + max(fToReceive, 0);
fToReceive -= ps_reg0.z; // Subtract 1 only at initialization
float fGiveConnections = saturate(img_t.x);
fGiveConnections += saturate(img_l.x);
fGiveConnections += saturate(img_r.x);
fGiveConnections += saturate(img_b.x);
fGiveConnections += saturate(img_tl.x) * fConnectTl;
fGiveConnections += saturate(img_tr.x) * fConnectTr;
fGiveConnections += saturate(img_bl.x) * fConnectBl;
fGiveConnections += saturate(img_br.x) * fConnectBr;
fGiveConnections *= saturate(img_c.x);
float fToGive = (fGiveConnections - 1.0f * ps_reg0.w) * fToReceive; // Do not keep connection that will not come back
float fToGivePrev = img_c.z * ps_reg0.w;
PS_OUT output;
output.clr = float4(fConnectionsAcc * ps_reg0.y, fToReceive * ps_reg0.y, fToGive * ps_reg0.y, fToGivePrev * ps_reg0.y);
return output;
}
PS_OUT ps_edge_diff_length_suppresion(VS_OUT input)
{
float edge = TEXTURE_READ_2D( samp, 0, input.uv0 ).x * ps_reg0.x;
float fRes = step( ps_reg0.y, edge );
PS_OUT output;
output.clr = float4(fRes, fRes, fRes, 1.0f);
return output;
}
// Remove isolated pixels
PS_OUT ps_mask_remove_isolated_erode(VS_OUT input)
{
// Get info
GET_NEIGHBORHOOD_INFO;
// Check if one of the neighbors is background
float wantErode = 1.0f - Neighborhood_AllMask( 1, neighbors_x );
// Check if can erode
float canErode = isMask * wantErode;
// Output
float fMask = mask_c.x * (1.0f - canErode);
PS_OUT output;
output.clr = fMask;
return output;
}
PS_OUT ps_mask_remove_isolated_dilate(VS_OUT input)
{
// Get info
GET_NEIGHBORHOOD_INFO;
GET_NEIGHBORHOOD_INFO_EX;
float fPlayerIdx = Neighborhood_CommonPlayerIdx( mask_c.x, neighbors_x );
// Check if one of the neighbors is mask
float wantDilate = Neighborhood_AnyMask( mask_c.x, neighbors_x );
// Check if can dilate
float canDilate = (1.0f - isMask) * wantDilate;
// Output
float fMask = lerp( mask_c.x, fPlayerIdx, canDilate );
PS_OUT output;
output.clr = fMask;
return output;
}
// Body Part info
PS_OUT ps_mask_part_info_init(VS_OUT input)
{
float mask = TEXTURE_READ_2D( samp, 0, input.uv0 ).r; // Player Input
PS_OUT output;
output.clr = float4( mask, 0.0f, 0.0f, 0.0f );
return output;
}
PS_OUT ps_mask_part_info_mark(VS_OUT input)
{
DEFINE_CONSTANTS;
ITF_CONST float kDilationHead = DILATION_HEAD;
ITF_CONST float kDilationHands = DILATION_HANDS;
ITF_CONST float kDilationFeet = DILATION_FEET;
ITF_CONST float4 kDilationLimb = float4( kDilationHands.xx, kDilationFeet.xx );
ITF_CONST float4 sizeLimbs = ps_reg2.xyzw;
ITF_CONST float sizeHead = ps_reg3.z;
ITF_CONST float4 sizeFactorMarkLimbs = float4( ps_reg3.ww, ps_reg4.xx );
ITF_CONST float sizeFactorMarkHead = ps_reg4.yy;
// Get info
float mask = TEXTURE_READ_2D( samp, 0, input.uv0 ).r;
// Calculate distances
float4 fDirToLimbsX = float4( input.uv0.x - ps_reg0 );
float4 fDirToLimbsY = float4( input.uv0.y - ps_reg1 );
float4 fDistLimbs = sqrt(fDirToLimbsX*fDirToLimbsX + fDirToLimbsY*fDirToLimbsY) - sizeLimbs * sizeFactorMarkLimbs;
float fDistHead = length(input.uv0.xy - ps_reg3.xy) - sizeHead * sizeFactorMarkHead;
fDistLimbs = vec4_one - step( EPSILON, fDistLimbs );
fDistHead = 1.0f - step( EPSILON, fDistHead );
// Calculate dilations
float4 fDilationLimbs = kDilationLimb * fDistLimbs;
float fDilationHead = kDilationHead * fDistHead;
float fDilation = Max( fDilationHead, fDilationLimbs );
// Mark the size that the region needs to grow
float4 fSizeLimbs = sizeLimbs * fDistLimbs;
float fSizeHead = sizeHead * fDistHead;
float fSize = Max( fSizeHead, fSizeLimbs );
// Mark if region needs to keep holes
float fIgnoreHoles = step( EPSILON, fDistHead );
// Check if texel belongs to current player
float isPlayer = rectFunc( ps_reg4.z, ps_reg4.w, mask );
// Output
float3 outputValues = float3( fDilation * DILATION_NORM, fIgnoreHoles, fSize );
outputValues *= isPlayer;
PS_OUT output;
output.clr = float4( 0.0f, outputValues );
return output;
}
PS_OUT ps_mask_part_info_dilate(VS_OUT input)
{
// Get info
GET_NEIGHBORHOOD_INFO;
// Do not dilate if different players
float samePlayers = Neighborhood_SamePlayers( mask_c.x, neighbors_x );
// Dilation
float fDilation = Max( neighbors_y );
float wantDilate = ceil(fDilation);
// Ignore holes
float fIgnoreHoles = ITF_ANY4( neighbors_z );
// Size
float fSize = Max( neighbors_w );
fSize -= ps_samp0Size.z;
float maxSizeNotReached = step( 0, fSize );
// Check if can dilate
float noDilationInfo = 1.0f - ceil(mask_c.y);
float canDilate = (isMask * wantDilate * noDilationInfo * samePlayers * maxSizeNotReached);
// Output
float3 outputValues = float3( fDilation, fIgnoreHoles, fSize );
outputValues = lerp( mask_c.yzw, outputValues, canDilate );
PS_OUT output;
output.clr = float4( mask_c.x, outputValues );
return output;
}
// Dilate Background
PS_OUT ps_mask_dilated_init(VS_OUT input)
{
float4 mask = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
float fMaxDilation = ceil(mask.x) * max( mask.y, DILATION_NORM );
PS_OUT output;
output.clr = float4( mask.x, fMaxDilation, mask.zx ); // Mask, MaxDilation, IgnoreHoles, Mask Original
return output;
}
PS_OUT ps_mask_dilated_dilate(VS_OUT input)
{
DEFINE_CONSTANTS;
// Get info
GET_NEIGHBORHOOD_INFO;
GET_NEIGHBORHOOD_INFO_EX;
// Do not dilate if different players
float samePlayers = Neighborhood_SamePlayers( mask_c.x, neighbors_x );
// Check if we should keep the existent holes to the minimum width
float fIgnoreHolesMarked = ITF_ANY4( neighbors_z );
float fIgnoreHoles = Neighborhood_SameRegions( neighbors_y, neighborsEx_y );
if ( fIgnoreHolesMarked < 0.5f )
{
float4 v1 = float4( neighbors_x.xz, neighborsEx_x.xz );
float4 v2 = float4( neighbors_x.yw, neighborsEx_x.yw );
v1 = vec4_one - min( v1, v2 );
float nonConnect = floor( v1.x * v1.y * v1.z * v1.w );
fIgnoreHoles = min( nonConnect, fIgnoreHoles );
}
// Dilate if possible
float fPlayerIdx = Max( mask_c.x, neighbors_x );
float wantDilate = ceil( Sum( neighbors_x ) / 4.0f );
float fRes = fPlayerIdx;
// Ensure maximum dilation for that pixel is not reached
float fMaxDilation = Max( neighbors_y );
float fMaxDilationNotReached = step( ps_reg0.x, fMaxDilation * DILATION_MAX - 0.5f );
// Check if can dilate
float canDilate = (1.0f - isMask) * wantDilate * fIgnoreHoles * samePlayers * fMaxDilationNotReached;
// Output
float3 outputValues = float3( fRes, fMaxDilation, fIgnoreHolesMarked );
outputValues = lerp( mask_c.xyz, outputValues, canDilate );
PS_OUT output;
output.clr = float4(outputValues, mask_c.w);
return output;
}
// Mask Shrink
PS_OUT ps_mask_refine_region_shrink_init(VS_OUT input)
{
float4 mask = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
PS_OUT output;
output.clr = mask.xyxw; // Mask Dilated, MaxDilation, Mask Dilated, Mask Original
return output;
}
PS_OUT ps_mask_refine_region_shrink(VS_OUT input)
{
// Get info
GET_NEIGHBORHOOD_INFO;
float edge = TEXTURE_READ_2D( samp, 1, input.uv0 ).r;
float playerMask = ceil(mask_c.w);
// Check neigbhors
float fAllMask = Neighborhood_AllMask( 1, neighbors_x );
float fAnyMask = Neighborhood_AnyMask( 0, neighbors_x );
// Stop if foreground
float isBackground = 1.0f - max( edge, playerMask );
// Check if needs shrinking
float wantShrink = fAnyMask * (1.0f - fAllMask);
// Max Dilation
float fMaxShrinkNotReached = step( ps_reg0.x, mask_c.y * DILATION_MAX - 0.5f );
// Check if can shrink
float canShrink = isMask * wantShrink * isBackground * fMaxShrinkNotReached;
// Output
float fMask = mask_c.x * (1.0f - canShrink);
PS_OUT output;
output.clr = float4(fMask, mask_c.yzw);
return output;
}
// Fill color
PS_OUT ps_mask_fill_color_init(VS_OUT input)
{
float mask = TEXTURE_READ_2D( samp, 0, input.uv0 ).r;
float3 clr = TEXTURE_READ_2D( samp, 1, input.uv0 ).rgb;
PS_OUT output;
output.clr = float4( mask, ceil(mask) * clr.rgb );
return output;
}
PS_OUT ps_mask_fill_color_dilate(VS_OUT input)
{
DEFINE_CONSTANTS;
// Get info
GET_NEIGHBORHOOD_INFO;
float3 clr = TEXTURE_READ_2D( samp, 1, input.uv0 ).rgb;
float4 cma = TEXTURE_READ_2D( samp, 2, input.uv0 ).rgba;
// Check if dilating the pixel would connect two different players
float fPlayerIdx = Neighborhood_CommonPlayerIdx( mask_c.x, neighbors_x );
float fSamePlayers = ceil(fPlayerIdx);
// Check if one of the neighbors is mask and its color is continuous
float4 masks = ceil( neighbors_x );
float4 colorDistance = float4( colorDistance_avg( clr, mask_l.gba ),
colorDistance_avg( clr, mask_r.gba ),
colorDistance_avg( clr, mask_t.gba ),
colorDistance_avg( clr, mask_b.gba ) );
colorDistance += vec4_one - masks;
colorDistance += step( ps_reg0.yyyy, colorDistance );
float colorDistanceMin = Min( 0.95f, colorDistance );
float4 weights = step( colorDistance, colorDistanceMin );
float wantDilate = ITF_ANY4(weights);
float3 clrNeighbor = lerp( max( max( mask_l.gba * weights.x, mask_r.gba * weights.y ),
max( mask_t.gba * weights.z, mask_b.gba * weights.w ) ),
mask_c.gba,
isMask );
// Check if it's foreground, so that it can continue
float isForeground = step( ps_reg0.z, colorDistance_avg( clr, cma.rgb ) + cma.a );
// Check if can dilate
float canDilate = (1.0f - isMask) * fSamePlayers * wantDilate * isForeground;
// Output
float fMask = lerp( mask_c.x, fPlayerIdx, canDilate );
PS_OUT output;
output.clr = float4( fMask, clrNeighbor );
return output;
}
PS_OUT ps_mask_fill_color_combine(VS_OUT input)
{
float4 clr0 = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgba; // Shrink
float4 clr1 = TEXTURE_READ_2D( samp, 1, input.uv0 ).rgba; // Fill color
float bg = ceil(TEXTURE_READ_2D( samp, 2, input.uv0 ).r);
PS_OUT output;
output.clr = float4( max(clr0.x, clr1.x * bg), clr0.yzw );
return output;
}
// Fill holes
PS_OUT ps_mask_fill_holes_init(VS_OUT input)
{
float4 mask = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
PS_OUT output;
output.clr = float4( mask.xyz, 0.0f ); // Mask Shrinked, MaxDilation Dilated, Mask Dilated, Dilation Count
return output;
}
PS_OUT ps_mask_fill_holes_dilate(VS_OUT input)
{
// Get info
GET_NEIGHBORHOOD_INFO;
#ifdef ITF_DURANGO
GET_NEIGHBORHOOD_INFO_EX;
#endif
// Check if dilating the pixel would connect two different players
float fPlayerIdx = Neighborhood_CommonPlayerIdx( mask_c.x, neighbors_x );
float fSamePlayers = ceil(fPlayerIdx);
// Check collision with background mask of other player
fSamePlayers *= Neighborhood_SamePlayers( mask_c.x, neighbors_z );
#ifdef ITF_DURANGO
// Check collision with other regions of same player
fSamePlayers *= Neighborhood_SameRegions( neighbors_y, neighborsEx_y );
#endif
// Check if one of the neighbors is mask
float wantDilate = Neighborhood_AnyMask( mask_c.x, neighbors_x );
// Check if can dilate
float canDilate = (1.0f - isMask) * fSamePlayers * wantDilate;
// Output
float2 outputValues = float2( fPlayerIdx, ps_reg0.x );
outputValues = lerp( mask_c.xw, outputValues, canDilate );
PS_OUT output;
output.clr = float4( outputValues.x, mask_c.yz, outputValues.y );
return output;
}
PS_OUT ps_mask_fill_holes_erode(VS_OUT input)
{
// Get info
GET_NEIGHBORHOOD_INFO;
// Check if one of the neighbors is background
float wantErode = 1.0f - Neighborhood_AllMask( 1, neighbors_x );
// Check if is in same dilate iteration
float fSameDilateIteration = step( ps_reg0.x, mask_c.w + ps_reg0.y );
// Check if can erode
float canErode = isMask * wantErode * fSameDilateIteration;
// Output
float fMask = mask_c.x * (1.0f - canErode);
PS_OUT output;
output.clr = float4( fMask, mask_c.yzw );
return output;
}
PS_OUT ps_mask_fill_holes_final(VS_OUT input)
{
// Get info
float4 mask_c = TEXTURE_READ_2D( samp, 0, input.uv0 ).xyzw;
// Output
float fMask = mask_c.x * ceil(mask_c.z);
PS_OUT output;
output.clr = float4(fMask, mask_c.yzw);
return output;
}
PS_OUT ps_mask_final_erode(VS_OUT input)
{
// Get info
GET_NEIGHBORHOOD_INFO;
float originalMask = ceil( TEXTURE_READ_2D( samp, 1, input.uv0 ).w );
// Check if one of the neighbors is background
float wantErode = 1.0f - Neighborhood_AllMask( 1, neighbors_x );
// Ensure we don't go beyond the original mask
float keepOriginalMask = 1.0f - originalMask;
// Check if can erode
float canErode = isMask * wantErode * keepOriginalMask;
// Output
float fMask = mask_c.x * (1.0f - canErode);
PS_OUT output;
output.clr = float4( fMask, mask_c.yzw );
return output;
}
PS_OUT ps_temp(VS_OUT input)
{
float4 clr = TEXTURE_READ_2D( samp, 0, input.uv0 ).rgba;
PS_OUT output;
output.clr = ps_reg0 * lerp( clr.rgba, ceil(clr.rgba), ps_reg1 );
output.clr.rgb += output.clr.a;
output.clr.a = 1.0f;
return output;
}
PS_OUT ps_plane_mask( VS_OUT input )
{
PS_OUT output;
float depth = TEXTURE_READ_2D( samp, 0, input.uv0 ).r;
float hasDepth = ceil(saturate(depth)); //0 no depth 1 depth
float3 rayOrig = NuiToWorld( float3(input.uv0, depth))/1000.0f;
float3 normal = normalize(ps_reg1.xyz);
float d = ps_reg1.w;
float t = clamp( dot( rayOrig, normal) + d - ps_reg0.z, 0.0f, 999.0f);
float finalValue = saturate(1.0f - saturate(ceil(t)) + ( 1.0f - hasDepth));
output.clr = float4( finalValue, finalValue, finalValue, finalValue);
return output;
}
PS_OUT ps_blend_plane( VS_PLANE_OUT input )
{
PS_OUT output;
float3 ndc = (input.pospostvs/input.pospostvs.w+1.0f)/2.0f;
float2 uvPlaneMask = float2(ndc.x, 1.0f - ndc.y);
//Animate
//ps_reg1 -> x,y :water speed z:"wave" speed w: time
float2 offsetWave = ps_reg1.z * float2( sin( ps_reg1.w + ndc.x*10.0f), sin( ps_reg1.w + ndc.y*10.0f));
float2 offsetLinear = ps_reg1.xy * ps_reg1.w;
float4 planeColor = TEXTURE_READ_2D(samp, 0, input.uv0 + offsetWave + offsetLinear);
float planeMaskAlpha = TEXTURE_READ_2D( samp, 1, uvPlaneMask ).x;
float planeTopPointScreen = lerp( ps_reg0.x, ps_reg0.y, ndc.x);
float alpha = planeColor.w * (1.0f - ndc.y/planeTopPointScreen) * planeMaskAlpha * ps_reg0.z;
output.clr = float4( planeColor.xyz, pow( alpha, 0.5f ));
return output;
}
PS_OUT ps_lighten_blend( VS_OUT input )
{
PS_OUT output;
float4 colorA = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 colorB = TEXTURE_READ_2D( samp, 1, input.uv0 );
output.clr = lerp( colorA, float4(max(colorA.r, colorB.r), max(colorA.g, colorB.g), max(colorA.b, colorB.b), colorA.a ), pow(colorB.a, 0.5f));
return output;
}
PS_OUT ps_screen_blend_inverse_alpha( VS_OUT input )
{
PS_OUT output;
const float3 vec3_one = float3(1.0f,1.0f,1.0f);
float4 colorA = TEXTURE_READ_2D( samp, 0, input.uv0 );
float4 colorB = TEXTURE_READ_2D( samp, 1, ((input.uv0 -0.5f) * ps_reg1.xy) + 0.5f + ps_reg1.zw );
float3 screenBlendColor = (vec3_one - ( vec3_one - colorA.rgb ) * ( vec3_one - colorB.rgb ));
output.clr = lerp( colorA, float4( lerp(screenBlendColor, colorA.rgb, ceil(colorB.a)), colorA.a), ps_reg0.x );
return output;
}
PS_OUT ps_triple_layer_background ( VS_OUT input )
{
PS_OUT output;
ITF_CONST float factor = ps_reg0.x;
ITF_CONST float speedX = ps_reg0.y;
ITF_CONST float speedY = ps_reg0.z;
ITF_CONST float time = ps_reg0.w;
ITF_CONST float3 tintColor = ps_reg1.xyz;
// Sample sources
float3 firstLayerColor = TEXTURE_READ_2D( samp, 0, input.uv0 );
float3 secondLayerColor = TEXTURE_READ_2D( samp, 1, input.uv0 );
float3 thirdLayerColor = TEXTURE_READ_2D( samp, 2, input.uv0 + float2( speedX, speedY )*time );
float3 videoColor = TEXTURE_READ_2D( samp, 3, input.uv0 );
// Tint third layer color
float3 tintedLayeredColor = thirdLayerColor * tintColor;
// Compute final color from layers
float3 finalLayeredColor = lerp( firstLayerColor, tintedLayeredColor, 1.0f - secondLayerColor.r );
// Final color
float3 finalColor = lerp( videoColor, finalLayeredColor, factor );
output.clr = float4( finalColor, 1.0f );
return output;
}
//note: uniformly distributed, normalized rand, [0;1[
float nrand( float2 n )
{
return frac(sin(dot(n.xy, float2(12.9898, 78.233)))* 43758.5453);
}
PS_OUT ps_transition ( VS_OUT input )
{
PS_OUT output;
float3 oldImage = TEXTURE_READ_2D( samp, 0, input.uv0 );
float nrnd = nrand( input.uv0 + 0.07*ps_reg0.y );
output.clr = float4( ps_reg0.x*float3(nrnd,nrnd,nrnd) + (1. - ps_reg0.x)*oldImage, 1. );
return output;
}
PS_OUT ps_transition2 ( VS_OUT input )
{
PS_OUT output;
float progress = ps_reg0.x;
float time = ps_reg0.y;
float maxColorModificationRatio = ps_reg0.z;
float maxNoiseRatio = ps_reg0.w;
float timeOffset = frac((time+pow(1.f+frac(time),5.f))/10.f);
float offsetU = sin((input.uv0.y+timeOffset)*2.0f*PI)*0.05f;
offsetU += sin((input.uv0.y*10.f+frac(timeOffset))*2.f*PI)*0.05f;
offsetU += sin((input.uv0.y*5.f+frac(timeOffset*2.f))*2.f*PI)*0.05f;
offsetU *= progress;
float2 newUVCoord = input.uv0;
newUVCoord.x = fmod(input.uv0.x + offsetU, 1.f);
newUVCoord.y = fmod(newUVCoord.y + abs(sin(time/10.f))*sin(progress*3.f+time)*0.3f, 1.f);
float3 oldImage = TEXTURE_READ_2D( samp, 0, newUVCoord );
float colorCoef1 = abs(cos((newUVCoord.y+time)*4.f*PI));
float colorCoef2 = abs(cos((newUVCoord.y+time*7.f)*8.f*PI));
output.clr = float4(oldImage*(1.f-progress*maxColorModificationRatio) + progress*maxColorModificationRatio*float3(0.f,colorCoef1*colorCoef2*0.6f,1.f),1.f);
float nrnd = nrand( input.uv0 + 0.07*frac(time) );
output.clr = output.clr*(1.f-progress*maxNoiseRatio) + output.clr*progress*maxNoiseRatio*float4(nrnd,nrnd,nrnd,1.f);
return output;
}
#endif // PIXEL_PROFILE
#endif //AUTODANCE__FX
Reference in a new issue View git blame Copy permalink