float4x4 brightnessMatrix( float brightness )
{
return float4x4(1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
brightness, brightness, brightness, 1 );
}
float4x4 contrastMatrix( float contrast )
{
float t = ( 1.0 - contrast ) / 2.0;
return float4x4(contrast, 0, 0, 0,
0, contrast, 0, 0,
0, 0, contrast, 0,
t, t, t, 1 );
}
float4x4 saturationMatrix( float saturation )
{
float3 luminance = float3( 0.3086, 0.6094, 0.0820 );
float oneMinusSat = 1.0 - saturation;
float3 red = float3( luminance.x * oneMinusSat, luminance.x * oneMinusSat, luminance.x * oneMinusSat );
red+= float3( saturation, 0, 0 );
float3 green = float3( luminance.y * oneMinusSat, luminance.y * oneMinusSat, luminance.y * oneMinusSat );
green += float3( 0, saturation, 0 );
float3 blue = float3( luminance.z * oneMinusSat, luminance.z * oneMinusSat, luminance.z * oneMinusSat );
blue += float3( 0, 0, saturation );
return float4x4(red, 0,
green, 0,
blue, 0,
0, 0, 0, 1 );
}
float3 Brightness(float3 color, float brightness, float contrast)
{
const float saturation = 1.0;
float4 res;
res = mul(
float4(color, 1.0),
mul(
mul(
brightnessMatrix( brightness ),
contrastMatrix( contrast )
),
saturationMatrix( saturation )
)
);
return res.rgb;
}
/////////////////////////////////////////////////////////////////////////////////////
float3 RGBToHCV( in float3 RGB )
{
float4 P = ( RGB.g < RGB.b ) ? float4( RGB.bg, -1.0f, 2.0f/3.0f ) : float4( RGB.gb, 0.0f, -1.0f/3.0f );
float4 Q1 = ( RGB.r < P.x ) ? float4( P.xyw, RGB.r ) : float4( RGB.r, P.yzx );
float C = Q1.x - min( Q1.w, Q1.y );
float H = abs(( Q1.w - Q1.y ) / ( 6.0f * C + 0.000001f ) + Q1.z );
return float3( H, C, Q1.x );
}
float3 RGBToHSL( in float3 RGB )
{
RGB.xyz = max( RGB.xyz, 0.000001f );
float3 HCV = RGBToHCV(RGB);
float L = HCV.z - HCV.y * 0.5f;
float S = HCV.y / ( 1.0f - abs( L * 2.0f - 1.0f ) + 0.000001f);
return float3( HCV.x, S, L );
}
float curve( float x, float k )
{
float s = sign( x - 0.5f );
float o = ( 1.0f + s ) / 2.0f;
return o - 0.5f * s * pow( 2.0f * ( o - s * x ), k );
}
float3 ProcessBW( float3 col, float r, float y, float g, float c, float b, float m )
{
float3 hsl = RGBToHSL( col.xyz );
float lum = 1.0f - hsl.z;
float curve_str=4.000000;
float weight_r = curve( max( 1.0f - abs( hsl.x * 6.0f ), 0.0f ), curve_str ) +
curve( max( 1.0f - abs(( hsl.x - 1.0f ) * 6.0f ), 0.0f ), curve_str );
float weight_y = curve( max( 1.0f - abs(( hsl.x - 0.166667f ) * 6.0f ), 0.0f ), curve_str );
float weight_g = curve( max( 1.0f - abs(( hsl.x - 0.333333f ) * 6.0f ), 0.0f ), curve_str );
float weight_c = curve( max( 1.0f - abs(( hsl.x - 0.5f ) * 6.0f ), 0.0f ), curve_str );
float weight_b = curve( max( 1.0f - abs(( hsl.x - 0.666667f ) * 6.0f ), 0.0f ), curve_str );
float weight_m = curve( max( 1.0f - abs(( hsl.x - 0.833333f ) * 6.0f ), 0.0f ), curve_str );
float sat = hsl.y * ( 1.0f - hsl.y ) + hsl.y;
float ret = hsl.z;
ret += ( hsl.z * ( weight_r * r ) * sat * lum );
ret += ( hsl.z * ( weight_y * y ) * sat * lum );
ret += ( hsl.z * ( weight_g * g ) * sat * lum );
ret += ( hsl.z * ( weight_c * c ) * sat * lum );
ret += ( hsl.z * ( weight_b * b ) * sat * lum );
ret += ( hsl.z * ( weight_m * m ) * sat * lum );
return saturate( ret );
}
float3 BlackandWhite(float3 color)
{
color.xyz = saturate( color.xyz );
float red; float yellow; float green;
float cyan; float blue; float magenta;
red = -0.400000;
yellow = 2.000001;
green = 3.000000;
cyan = 0.000000;
blue = -0.600000;
magenta = -0.200000;
color.xyz = ProcessBW( color.xyz, red, yellow, green, cyan, blue, magenta );
return color;
}
/////////////////////////////////////////////////////////////////////////////////////
float3 LevelsPass(float3 color)
{
const float3 InputColor = color;
float3 OutputColor = InputColor;
float3 InputBlackPoint=float3(0.000000,0.000000,0.000000);
float3 InputWhitePoint=float3(1.000000,1.000000,1.000000);
float3 OutputBlackPoint=float3(0.000000,0.000000,0.000000);
float3 OutputWhitePoint=float3(1.000000,1.000000,1.000000);
float3 InputGamma=float3(3.920000,1.000000,7.467000);
OutputColor = pow(abs(((InputColor) - InputBlackPoint)/(InputWhitePoint - InputBlackPoint)), InputGamma) * (OutputWhitePoint - OutputBlackPoint) + OutputBlackPoint;
return OutputColor;
}
//////////////////////////////////////////////////////////////////////////////////////
#define permONE 1.0f / 256.0f
#define permHALF 0.5f * permONE
#define permTexSize 256
float discreteNoise(float rand) {
return float(int(rand * 3.0) * 64) / 256.0;
}
float4 rnm( float2 tc, float t )
{
float grainAdjust=1.000000;
float noise = sin( dot( tc, float2( 12.9898, 78.233 ))) * ( 43758.5453 + t );
float noiseR = frac( noise * grainAdjust ) * 2.0 - 1.0;
float noiseG = frac( noise * 1.2154 * grainAdjust ) * 2.0 - 1.0;
float noiseB = frac( noise * 1.3453 * grainAdjust ) * 2.0 - 1.0;
float noiseA = frac( noise * 1.3647 * grainAdjust ) * 2.0 - 1.0;
return float4( noiseR, noiseG, noiseB, noiseA );
}
float4 samplerPermTex(float2 uv)
{
float4 gen = rnm(uv, 13.14381);
gen.x = discreteNoise(gen.x);
gen.y = discreteNoise(gen.y);
gen.z = discreteNoise(gen.z);
return gen;
}
float fade( float t )
{
return t * t * t * ( t * ( t * 6.0 - 15.0 ) + 10.0 );
}
float pnoise3D( float3 p, float t, float grainSize )
{
float3 pi = permONE * floor( p ) + permHALF;
pi.xy *= permTexSize;
pi.xy = round(( pi.xy - permHALF ) / grainSize ) * grainSize;
pi.xy /= permTexSize;
float3 pf = frac( p );
// Noise contributions from (x=0, y=0), z=0 and z=1
float perm00 = rnm( pi.xy, t ).x;
float3 grad000 = samplerPermTex(float2( perm00, pi.z )).xyz * 4.0 - 1.0;
float n000 = dot( grad000, pf );
float3 grad001 = samplerPermTex(float2( perm00, pi.z + permONE )).xyz * 4.0 - 1.0;
float n001 = dot( grad001, pf - float3( 0.0, 0.0, 1.0 ));
// Noise contributions from (x=0, y=1), z=0 and z=1
float perm01 = rnm( pi.xy + float2( 0.0, permONE ), t ).y ;
float3 grad010 = samplerPermTex(float2( perm01, pi.z )).xyz * 4.0 - 1.0;
float n010 = dot( grad010, pf - float3( 0.0, 1.0, 0.0 ));
float3 grad011 = samplerPermTex(float2( perm01, pi.z + permONE )).xyz * 4.0 - 1.0;
float n011 = dot( grad011, pf - float3( 0.0, 1.0, 1.0 ));
// Noise contributions from (x=1, y=0), z=0 and z=1
float perm10 = rnm( pi.xy + float2( permONE, 0.0 ), t ).z ;
float3 grad100 = samplerPermTex(float2( perm10, pi.z )).xyz * 4.0 - 1.0;
float n100 = dot( grad100, pf - float3( 1.0, 0.0, 0.0 ));
float3 grad101 = samplerPermTex(float2( perm10, pi.z + permONE )).xyz * 4.0 - 1.0;
float n101 = dot( grad101, pf - float3( 1.0, 0.0, 1.0 ));
// Noise contributions from (x=1, y=1), z=0 and z=1
float perm11 = rnm( pi.xy + float2( permONE, permONE ), t ).w ;
float3 grad110 = samplerPermTex(float2( perm11, pi.z )).xyz * 4.0 - 1.0;
float n110 = dot( grad110, pf - float3( 1.0, 1.0, 0.0 ));
float3 grad111 = samplerPermTex(float2( perm11, pi.z + permONE )).xyz * 4.0 - 1.0;
float n111 = dot( grad111, pf - float3( 1.0, 1.0, 1.0 ));
// Blend contributions along x
float4 n_x = lerp( float4( n000, n001, n010, n011 ), float4( n100, n101, n110, n111 ), fade( pf.x ));
// Blend contributions along y
float2 n_xy = lerp( n_x.xy, n_x.zw, fade( pf.y ));
// Blend contributions along z
float n_xyz = lerp( n_xy.x, n_xy.y, fade( pf.z ));
// We're done, return the final noise value
return n_xyz;
}
float3 doGrain(float3 color, float2 texcoord,
float grainSize,
float grainAmount,
float grainIntensity,
float grainColor,
float grainIntHigh,
float grainIntLow,
float grainDensity)
{
float timer = timers.x % 1000.0f;
float2 uv = texcoord.xy * float2( screen_res.x, screen_res.y );
float3 noise = pnoise3D( float3( uv.xy, 1 ), timer, grainSize );
noise.y = pnoise3D( float3( uv.xy, 2 ), timer, grainSize );
noise.z = pnoise3D( float3( uv.xy, 3 ), timer, grainSize );
// Old, practically does the same as grainAmount below
// Added back on request
noise.xyz *= grainIntensity;
// Noise saturation
noise.xyz = lerp( dot( noise.xyz, 1.0f ), noise.xyz, grainColor );
// Control noise density
noise.xyz = pow( abs( noise.xyz ), max( 11.0f - grainDensity, 0.1f )) * sign( noise.xyz );
// Mixing options
float lum = dot( color.xyz, 0.333333f ); // Just using average here
noise.xyz = lerp( noise.xyz * grainIntLow, noise.xyz * grainIntHigh, fade( lum )); // Noise adjustments based on average intensity
color.xyz = lerp( color.xyz, color.xyz + ( noise.xyz ), grainAmount );
return float3( color.xyz );
}
float3 Grain2(float3 color, float2 texcoord)
{
float grainSize = 2.0;
float grainAmount=0.023000 * 0.00004;
float grainIntensity=1.000000;
float grainColor=0.000000;
float grainIntHigh=0.000000;
float grainIntLow=1.000000;
float grainDensity=0.000000;
return doGrain(color, texcoord,
grainSize,
grainAmount,
grainIntensity,
grainColor,
grainIntHigh,
grainIntLow,
grainDensity);
}
//////////////////////////////////////////////////////////////////////////////////////
float3 Grain1(float3 color, float2 texcoord)
{
float grainSize=1.0;
float grainAmount=0.500000;
float grainIntensity=0.300000;
float grainColor=0.000000;
float grainIntHigh=0.000000;
float grainIntLow=0.500000;
float grainDensity=10.000000;
return doGrain(color, texcoord,
grainSize,
grainAmount,
grainIntensity,
grainColor,
grainIntHigh,
grainIntLow,
grainDensity);
}