328 lines
9.5 KiB
HLSL
328 lines
9.5 KiB
HLSL
// Remnant X
|
|
// by David Hoskins.
|
|
// Thanks to boxplorer and the folks at 'Fractalforums.com'
|
|
// HD Video:- https://www.youtube.com/watch?v=BjkK9fLXXo0
|
|
// https://www.shadertoy.com/view/4sjSW1
|
|
|
|
struct PSInput
|
|
{
|
|
float4 position : SV_POSITION;
|
|
};
|
|
|
|
cbuffer Input
|
|
{
|
|
float2 iResolution;
|
|
float iTime;
|
|
float iDummy;
|
|
};
|
|
|
|
#define PI 3.14159265f
|
|
#define SCALE 2.8
|
|
#define MINRAD2 .25
|
|
#define scale (float4(SCALE, SCALE, SCALE, abs(SCALE)) / minRad2)
|
|
|
|
static const float minRad2 = clamp(MINRAD2, 1.0e-9, 1.0);
|
|
static const float absScalem1 = abs(SCALE - 1.0);
|
|
static const float AbsScaleRaisedTo1mIters = pow(abs(SCALE), float(1-10));
|
|
static const float3 surfaceColour1 = float3(.8, .0, 0.);
|
|
static const float3 surfaceColour2 = float3(.4, .4, 0.5);
|
|
static const float3 surfaceColour3 = float3(.5, 0.3, 0.00);
|
|
static const float3 fogCol = float3(0.4, 0.4, 0.4);
|
|
|
|
static const float3 sunDir=normalize(float3(0.35,0.1,0.3));
|
|
static const float4 sunColour=float4(1.0,0.95,0.8,0.2);
|
|
|
|
|
|
float2 Rand(float2 p)
|
|
{
|
|
return(float2(frac(sin(dot(p,float2(12.9898,78.233)))*6.7416516),frac(sin(dot(p,float2(58.6542,22.6546)))*6.5465145)));
|
|
}
|
|
|
|
float2 Texture(float2 p)
|
|
{
|
|
float2 p1=Rand(floor(p*256+float2(0,0)));
|
|
float2 p2=Rand(floor(p*256+float2(0,1)));
|
|
float2 p3=Rand(floor(p*256+float2(1,0)));
|
|
float2 p4=Rand(floor(p*256+float2(1,1)));
|
|
float2 f =frac(p*256);
|
|
|
|
return lerp(lerp(p1,p2,f.y),lerp(p3,p4,f.y),f.x);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float Noise(in float3 x)
|
|
{
|
|
float3 p=floor(x);
|
|
float3 f=frac(x);
|
|
f=f*f*(3.0-2.0*f);
|
|
|
|
float2 uv=(p.xy+float2(37.0,17.0)*p.z)+f.xy;
|
|
float2 rg=Rand((uv+0.5)/256.0).yx;//texture(iChannel0,(uv+0.5)/256.0,-99.0).yx;
|
|
return lerp(rg.x,rg.y,f.z);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float Map(float3 pos)
|
|
{
|
|
|
|
float4 p=float4(pos,1);
|
|
float4 p0=p; // p.w is the distance estimate
|
|
|
|
for(int i = 0; i < 9; i++)
|
|
{
|
|
p.xyz=clamp(p.xyz,-1.0,1.0)*2.0-p.xyz;
|
|
|
|
float r2=dot(p.xyz,p.xyz);
|
|
p*=clamp(max(minRad2/r2,minRad2),0.0,1.0);
|
|
|
|
// scale, translate
|
|
p=p*scale+p0;
|
|
}
|
|
return ((length(p.xyz)-absScalem1)/p.w-AbsScaleRaisedTo1mIters);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float3 Colour(float3 pos, float sphereR)
|
|
{
|
|
float3 p=pos;
|
|
float3 p0=p;
|
|
float trap=1.0;
|
|
|
|
for(int i = 0; i < 6; i++)
|
|
{
|
|
p.xyz=clamp(p.xyz,-1.0,1.0)*2.0-p.xyz;
|
|
float r2 = dot(p.xyz,p.xyz);
|
|
p*=clamp(max(minRad2/r2,minRad2), 0.0, 1.0);
|
|
|
|
p=p*scale.xyz+p0.xyz;
|
|
trap=min(trap,r2);
|
|
}
|
|
// |c.x|: log final distance (fractional iteration count)
|
|
// |c.y|: spherical orbit trap at (0,0,0)
|
|
float2 c=clamp(float2(0.3333*log(dot(p,p))-1.0,sqrt(trap)),0.0, 1.0);
|
|
|
|
float t=fmod(length(pos)-iTime*1.5,16.0);
|
|
float3 surfaceColour=lerp(surfaceColour1,float3(0.4,3.0,5.0),pow(smoothstep(0.0,0.3,t)*smoothstep(0.6,.3,t),10.0));
|
|
return lerp(lerp(surfaceColour,surfaceColour2,c.y),surfaceColour3,c.x);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float3 GetNormal(float3 pos, float distance)
|
|
{
|
|
distance*=0.001+.0001;
|
|
float2 eps=float2(distance,0.0);
|
|
float3 nor=float3(Map(pos+eps.xyy) - Map(pos-eps.xyy),
|
|
Map(pos+eps.yxy) - Map(pos-eps.yxy),
|
|
Map(pos+eps.yyx) - Map(pos-eps.yyx));
|
|
return normalize(nor);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float GetSky(float3 pos)
|
|
{
|
|
pos*=0.02;
|
|
float2 t=0.5 *Texture(pos.xy*2.1) +0.5*Texture(pos.yz*2.3-(float2)0.53) +0.5*Texture(pos.zx*1.9+(float2)0.47)+
|
|
0.25 *Texture(pos.xy*4.7) +0.25*Texture(pos.yz*4.1+(float2)0.71) +0.25*Texture(pos.zx*4.3+(float2)0.59)+
|
|
0.125*Texture(pos.xy*8.7)+0.125*Texture(pos.yz*8.6-(float2)0.69)+0.125*Texture(pos.zx*8.3+(float2)0.95);
|
|
|
|
return(pow(t.x*t.y,0.5));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float BinarySubdivision(in float3 rO, in float3 rD, float2 t)
|
|
{
|
|
float halfwayT;
|
|
|
|
for(int i = 0; i < 6; i++)
|
|
{
|
|
|
|
halfwayT=dot(t,float2(0.5,0.5));
|
|
float d = Map(rO + halfwayT*rD);
|
|
//if (abs(d) < 0.001) break;
|
|
t=lerp(float2(t.x,halfwayT),float2(halfwayT,t.y),step(0.0005, d));
|
|
}
|
|
|
|
return halfwayT;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float2 Scene(in float3 rO, in float3 rD, in float2 fragCoord)
|
|
{
|
|
float t=.05+0.05*Texture(fragCoord.xy/256).y;//texture(iChannel0, fragCoord.xy / iChannelResolution[0].xy).y;
|
|
float3 p=float3(0.0,0.0,0.0);
|
|
float oldT=0.0;
|
|
bool hit=false;
|
|
float glow=0.0;
|
|
float2 dist;
|
|
for(int j=0; j < 100; j++)
|
|
{
|
|
if(t > 12.0)
|
|
break;
|
|
p=rO+t*rD;
|
|
|
|
float h=Map(p);
|
|
|
|
if(h<0.0005)
|
|
{
|
|
dist=float2(oldT,t);
|
|
hit=true;
|
|
break;
|
|
}
|
|
glow+=clamp(.05-h,0.0,.4);
|
|
oldT=t;
|
|
t+=h+t*0.001;
|
|
}
|
|
if(!hit)
|
|
t=1000.0;
|
|
else
|
|
t=BinarySubdivision(rO, rD, dist);
|
|
return float2(t,clamp(glow*.25, 0.0, 1.0));
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float Hash(float2 p)
|
|
{
|
|
return frac(sin(dot(p,float2(12.9898,78.233)))*33758.5453)-.5;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float3 PostEffects(float3 rgb, float2 xy)
|
|
{
|
|
// Gamma first...
|
|
|
|
|
|
// Then...
|
|
#define CONTRAST 1.08
|
|
#define SATURATION 1.5
|
|
#define BRIGHTNESS 1.5
|
|
float tmp=dot(float3(.2125, .7154, .0721),rgb*BRIGHTNESS);
|
|
rgb=lerp(float3(0.5,0.5,0.5),lerp(float3(tmp,tmp,tmp),rgb*BRIGHTNESS,SATURATION),CONTRAST);
|
|
// Noise...
|
|
//rgb = clamp(rgb+Hash(xy*iTime)*.1, 0.0, 1.0);
|
|
// Vignette...
|
|
rgb*=.5+0.5*pow(20.0*xy.x*xy.y*(1.0-xy.x)*(1.0-xy.y), 0.2);
|
|
|
|
rgb=pow(rgb,float3(0.47,0.47,0.47));
|
|
return rgb;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float Shadow(in float3 ro, in float3 rd)
|
|
{
|
|
float res=1.0;
|
|
float t=0.05;
|
|
float h;
|
|
|
|
for(int i = 0; i < 8; i++)
|
|
{
|
|
h=Map(ro+rd*t);
|
|
res=min(6.0*h/t,res);
|
|
t+=h;
|
|
}
|
|
return max(res, 0.0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float3x3 RotationMatrix(float3 axis, float angle)
|
|
{
|
|
axis = normalize(axis);
|
|
float s = sin(angle);
|
|
float c = cos(angle);
|
|
float oc = 1.0 - c;
|
|
|
|
return float3x3(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s,
|
|
oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s,
|
|
oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float3 LightSource(float3 spotLight, float3 dir, float dis)
|
|
{
|
|
float g=0.0;
|
|
if(length(spotLight) < dis)
|
|
{
|
|
g=pow(max(dot(normalize(spotLight),dir),0.0),200.0);
|
|
}
|
|
|
|
return(g*sunColour.rgb*sunColour.a);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float3 CameraPath(float t)
|
|
{
|
|
float3 p=float3(-0.78+3.0*sin(2.14*t),0.05+2.5*sin(0.942*t+1.3),.05+3.5*cos(3.594*t));
|
|
return p;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------
|
|
float4 mainImage(float2 fragCoord)
|
|
{
|
|
//float m=(iMouse.x/iResolution.x)*300.0;
|
|
//gTime = iTime+m*.01 + 15.00;
|
|
float gTime=iTime*0.01;
|
|
float2 xy =fragCoord/iResolution;
|
|
float2 uv =(-1.0+2.0*xy)*float2(iResolution.x/iResolution.y,1.0);
|
|
|
|
//return(float4(uv,0.0,1.0));
|
|
|
|
float3 cameraPos=CameraPath(gTime);
|
|
float3 camTar =CameraPath(gTime+.01);
|
|
|
|
float roll=13.0*sin(gTime*.5+.4);
|
|
float3 cw=normalize(camTar-cameraPos);
|
|
|
|
float3 cp=float3(sin(roll),cos(roll),0.0);
|
|
float3 cu=normalize(cross(cw,cp));
|
|
|
|
float3 cv=normalize(cross(cu,cw));
|
|
cw=mul(cw,RotationMatrix(cv,sin(-gTime*20.0)*.7));
|
|
float3 dir=normalize(uv.x*cu+uv.y*cv+1.3*cw);
|
|
|
|
float3 spotLight=CameraPath(gTime+.03)+float3(sin(gTime*18.4),cos(gTime*17.98),sin(gTime*22.53))*.2;
|
|
float3 col=float3(0.0,0.0,0.0);
|
|
float3 sky=float3(0.03,.04,.05)*GetSky(dir);
|
|
float2 ret=Scene(cameraPos,dir,fragCoord);
|
|
|
|
if(ret.x<900.0)
|
|
{
|
|
float3 p=cameraPos+ret.x*dir;
|
|
float3 nor=GetNormal(p,ret.x);
|
|
|
|
float3 spot=spotLight-p;
|
|
float atten=length(spot);
|
|
|
|
spot/=atten;
|
|
|
|
float shaSpot=Shadow(p,spot);
|
|
float shaSun=Shadow(p,sunDir);
|
|
|
|
float bri=max(dot(spot,nor),0.0)/pow(atten,1.5)*.15;
|
|
float briSun=max(dot(sunDir,nor),0.0)*.3;
|
|
|
|
col=Colour(p,ret.x);
|
|
col=(col*bri*shaSpot)+(col*briSun*shaSun);
|
|
|
|
float3 ref=reflect(dir,nor);
|
|
col+=pow(max(dot(spot,ref),0.0), 10.0)*2.0*shaSpot*bri;
|
|
col+=pow(max(dot(sunDir,ref),0.0),10.0)*2.0*shaSun *bri;
|
|
}
|
|
|
|
col=lerp(sky,col,min(exp(-ret.x+1.5),1.0));
|
|
col+=(float3)pow(abs(ret.y),2.) * float3(.02, .04, .1);
|
|
|
|
col+=LightSource(spotLight-cameraPos,dir,ret.x);
|
|
col=PostEffects(col, xy);
|
|
|
|
return(float4(col,1.0));
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
float4 PSMain(PSInput input) : SV_TARGET
|
|
{
|
|
return(mainImage(input.position.xy));
|
|
}
|
|
//+------------------------------------------------------------------+
|