223 lines
8.1 KiB
Common Lisp
223 lines
8.1 KiB
Common Lisp
//+------------------------------------------------------------------+
|
|
//| OpenCL code |
|
|
//+------------------------------------------------------------------+
|
|
//| Based on pixel shader by Alexander Alekseev aka TDM-2014 |
|
|
//| https://www.shadertoy.com/view/Ms2SD1 |
|
|
//+------------------------------------------------------------------+
|
|
#define NUM_STEPS (int)8
|
|
#define PI (float)3.1415
|
|
#define EPSILON (float)1e-3
|
|
#define EPSILON_NRM ((float)0.1/iResolution.x)
|
|
#define ITER_GEOMETRY (int)3
|
|
#define ITER_FRAGMENT (int)5
|
|
#define SEA_HEIGHT (float)0.6
|
|
#define SEA_CHOPPY (float)4.0
|
|
#define SEA_SPEED (float)0.8
|
|
#define SEA_FREQ (float)0.16
|
|
#define SEA_BASE vec3(0.1,0.19,0.22)
|
|
#define SEA_WATER_COLOR vec3(0.8,0.9,0.6)
|
|
#define SEA_TIME ((float)1.0 + iGlobalTime * SEA_SPEED)
|
|
|
|
float max1(float v1,float v2) { if (v1>v2) return v1; return v2; }
|
|
float dot2(float2 v1,float2 v2) { return v1.x*v2.x+v1.y*v2.y; }
|
|
float dot3(float3 v1,float3 v2) { return v1.x*v2.x+v1.y*v2.y+v1.z*v2.z; }
|
|
float fract1(float p) { return p-floor(p); }
|
|
float2 fract2(float2 p) { return p-floor(p); }
|
|
float mix1(float x1,float x2,float a) { return(x1+(x2-x1)*a); }
|
|
float2 mix2(float2 x1,float2 x2,float2 a) { float2 r={x1.x+(x2.x-x1.x)*a.x,x1.y+(x2.y-x1.y)*a.y }; return(r); }
|
|
float3 mix3(float3 x1,float3 x2,float3 a) { float3 r={x1.x+(x2.x-x1.x)*a.x,x1.y+(x2.y-x1.y)*a.y,x1.z+(x2.z-x1.z)*a.z }; return(r); }
|
|
float3 vec31(float x) { float3 r={x,x,x}; return(r); }
|
|
float3 vec3(float x,float y,float z) { float3 r={x,y,z}; return(r); }
|
|
float2 vec2(float x,float y) { float2 r={x,y}; return(r); }
|
|
float4 vec4(float3 x,float y) { float4 r={x.x,x.y,x.z,y}; return(r); }
|
|
float3 reflect3(float3 I,float3 N) { return(I-(float)2.0*dot3(N,I)*N); }
|
|
float diffuse(float3 n,float3 l,float p) { return pow(dot3(n,l) * (float)0.4 + (float)0.6,p); }
|
|
float2 abs2(float2 f) { if(f.x<0) f.x=-f.x; if(f.y<0) f.y=-f.y; return(f); }
|
|
float hash(float2 p) { return fract1(sin(dot2(p,vec2((float)127.1,(float)311.7)))*43758.5453123); }
|
|
float specular(float3 n,float3 l,float3 e,float s) { return pow(max1(dot3(reflect3(e,n),l),0.0),s)*((s+(float)8.0)/(float)(3.1415 * 8.0)); }
|
|
|
|
float3 getSkyColor(float3 e)
|
|
{
|
|
e.y=max1(e.y,0.0);
|
|
float3 r2;
|
|
r2.x = (float)1.0-e.y;
|
|
r2.y = r2.x;
|
|
r2.z = (float)0.6+r2.x *(float)0.4;
|
|
r2.x = r2.x * r2.x;
|
|
return r2;
|
|
}
|
|
|
|
void fromEuler(float3 ang,float3 *r1,float3 *r2,float3 *r3)
|
|
{
|
|
float2 a1 = vec2(sin(ang.x),cos(ang.x));
|
|
float2 a2 = vec2(sin(ang.y),cos(ang.y));
|
|
float2 a3 = vec2(sin(ang.z),cos(ang.z));
|
|
*r1 = vec3(a1.y*a3.y+a1.x*a2.x*a3.x,a1.y*a2.x*a3.x+a3.y*a1.x,-a2.y*a3.x);
|
|
*r2 = vec3(-a2.y*a1.x,a1.y*a2.y,a2.x);
|
|
*r3 = vec3(a3.y*a1.x*a2.x+a1.y*a3.x,a1.x*a3.x-a1.y*a3.y*a2.x,a2.y*a3.y);
|
|
}
|
|
|
|
float noise(float2 p)
|
|
{
|
|
float2 i = floor(p);
|
|
float2 f = fract2(p);
|
|
float2 u = f * f * ((float)3.0 - (float)2.0 * f);
|
|
float mx1=mix1(hash(i+vec2(0.0,0.0)),hash(i+vec2(1.0,0.0)),u.x);
|
|
float mx2=mix1(hash(i+vec2(0.0,1.0)),hash(i+vec2(1.0,1.0)),u.x);
|
|
return (float)-1.0 + (float)2.0*mix(mx1,mx2,u.y);
|
|
}
|
|
|
|
float sea_octave(float2 uv, float choppy)
|
|
{
|
|
uv += noise(uv);
|
|
float2 wv = (float)1.0-abs2(sin(uv));
|
|
float2 swv = abs2(cos(uv));
|
|
wv = mix2(wv,swv,wv);
|
|
return pow((float)1.0-pow(wv.x * wv.y,(float)0.65),choppy);
|
|
}
|
|
|
|
float map(float3 p,float iGlobalTime)
|
|
{
|
|
float freq = SEA_FREQ;
|
|
float amp = SEA_HEIGHT;
|
|
float choppy = SEA_CHOPPY;
|
|
float2 uv = p.xz; uv.x *= (float)0.75;
|
|
float d, h = 0.0;
|
|
for(int i = 0; i < ITER_GEOMETRY; i++)
|
|
{
|
|
d = sea_octave((uv+SEA_TIME)*freq,choppy);
|
|
d += sea_octave((uv-SEA_TIME)*freq,choppy);
|
|
h += d * amp;
|
|
float2 uvt={(float)1.6*uv.x+(float)1.2*uv.y, (float)-1.2*uv.x+(float)1.6*uv.y };
|
|
uv = uvt;
|
|
freq *= (float)1.9; amp *= (float)0.22;
|
|
choppy = mix1(choppy,(float)1.0,(float)0.2);
|
|
}
|
|
return p.y - h;
|
|
}
|
|
|
|
float map_detailed(float3 p,float iGlobalTime)
|
|
{
|
|
float freq = SEA_FREQ;
|
|
float amp = SEA_HEIGHT;
|
|
float choppy = SEA_CHOPPY;
|
|
float2 uv = p.xz; uv.x *= (float)0.75;
|
|
float d, h = 0.0;
|
|
for(int i = 0; i < ITER_FRAGMENT; i++)
|
|
{
|
|
d =sea_octave((uv+SEA_TIME)*freq,choppy);
|
|
d+=sea_octave((uv-SEA_TIME)*freq,choppy);
|
|
h+=d * amp;
|
|
float2 uvt={ (float)1.6*uv.x+(float)1.2*uv.y, (float)-1.2*uv.x+(float)1.6*uv.y };
|
|
uv = uvt;
|
|
freq *= (float)1.9; amp *= (float)0.22;
|
|
choppy = mix1(choppy,(float)1.0,(float)0.2);
|
|
}
|
|
return p.y - h;
|
|
}
|
|
|
|
float3 getSeaColor(float3 p, float3 n, float3 l, float3 eye, float3 dist)
|
|
{
|
|
float fresnel = clamp((float)1.0 - dot3(n,-eye), (float)0.0, (float)1.0);
|
|
fresnel = pow(fresnel,(float)3.0) * (float)0.65;
|
|
float3 reflected = getSkyColor(reflect3(eye,n));
|
|
float3 refracted = SEA_BASE + diffuse(n,l,(float)80.0) * SEA_WATER_COLOR * (float)0.12;
|
|
float3 color = mix3(refracted,reflected,fresnel);
|
|
float atten = max1((float)1.0 - dot(dist,dist) * (float)0.001, (float)0.0);
|
|
color += SEA_WATER_COLOR * (p.y - SEA_HEIGHT) * (float)0.18 * atten;
|
|
color += vec31(specular(n,l,eye,(float)60.0));
|
|
|
|
if(isnan(color.x))
|
|
color.x=0.0;
|
|
if(isnan(color.y))
|
|
color.y=0.0;
|
|
if(isnan(color.z))
|
|
color.z=0.0;
|
|
|
|
return color;
|
|
}
|
|
|
|
float3 getNormal(float3 p, float eps,float iGlobalTime)
|
|
{
|
|
float3 n;
|
|
n.y = map_detailed(p,iGlobalTime);
|
|
n.x = map_detailed(vec3(p.x+eps,p.y,p.z),iGlobalTime) - n.y;
|
|
n.z = map_detailed(vec3(p.x,p.y,p.z+eps),iGlobalTime) - n.y;
|
|
n.y = eps;
|
|
return normalize(n);
|
|
}
|
|
|
|
float heightMapTracing(float3 ori, float3 dir,float3 *p,float iGlobalTime)
|
|
{
|
|
float tm = (float)0.0;
|
|
float tx = (float)1000.0;
|
|
float hx = map(ori + dir * tx,iGlobalTime);
|
|
if(hx > (float)0.0) return tx;
|
|
float hm = map(ori + dir * tm,iGlobalTime);
|
|
float tmid = (float)0.0;
|
|
for(int i = 0; i < NUM_STEPS; i++)
|
|
{
|
|
tmid = mix(tm,tx, hm/(hm-hx));
|
|
*p = ori + dir * tmid;
|
|
float hmid = map(*p,iGlobalTime);
|
|
if(hmid < (float)0.0)
|
|
{
|
|
tx = tmid;
|
|
hx = hmid;
|
|
}
|
|
else
|
|
{
|
|
tm = tmid;
|
|
hm = hmid;
|
|
}
|
|
}
|
|
return tmid;
|
|
}
|
|
|
|
float4 mainImage(float2 fragCoord,float iGlobalTime,float2 iResolution)
|
|
{
|
|
float4 fragColor;
|
|
float2 iMouse= {0,0};
|
|
float2 uv = fragCoord.xy / iResolution;
|
|
uv = uv * (float)2.0 - (float)1.0;
|
|
uv.x *= iResolution.x / iResolution.y;
|
|
float time = iGlobalTime * (float)0.3 + iMouse.x*(float)0.01;
|
|
float3 ang = vec3(sin(time*(float)3.0)*(float)0.1,sin(time)*(float)0.2+(float)0.3,time);
|
|
float3 ori = vec3(0.0,3.5,time*(float)5.0);
|
|
float3 dir = normalize(vec3(uv.x,uv.y,(float)-2.0)); dir.z += length(uv) * (float)0.15;
|
|
dir = normalize(dir);
|
|
float3 r1,r2,r3;
|
|
fromEuler(ang,&r1,&r2,&r3);
|
|
float3 r;
|
|
r.x=r1.x*dir.x+r1.y*dir.y+r1.z*dir.z;
|
|
r.y=r2.x*dir.x+r2.y*dir.y+r2.z*dir.z;
|
|
r.z=r3.x*dir.x+r3.y*dir.y+r3.z*dir.z;
|
|
dir=r;
|
|
float3 p;
|
|
heightMapTracing(ori,dir,&p,iGlobalTime);
|
|
float3 dist = p - ori;
|
|
float3 n = getNormal(p, dot(dist,dist) * EPSILON_NRM,iGlobalTime);
|
|
float3 light = normalize(vec3((float)0.0,(float)1.0,(float)0.8));
|
|
float3 seacol=getSeaColor(p,n,light,dir,dist);
|
|
float3 color = mix(getSkyColor(dir),seacol,pow(smoothstep((float)0.0,(float)-0.05,dir.y),(float)0.3));
|
|
fragColor = vec4(pow(color,vec31((float)0.75)),(float)1.0);
|
|
return(fragColor);
|
|
}
|
|
|
|
__kernel void Seascape(float iGlobalTime,__global uint *out)
|
|
{
|
|
size_t w = get_global_size(0);
|
|
size_t h = get_global_size(1);
|
|
float2 iRes = {(float)w,(float)h};
|
|
size_t gx = get_global_id(0);
|
|
size_t gy = get_global_id(1);
|
|
float2 coord={gx,gy};
|
|
float4 res=mainImage(coord,iGlobalTime,iRes);
|
|
uint b=(uint)(res.z*255);
|
|
uint g=(uint)(res.y*255);
|
|
uint r=(uint)(res.x*255);
|
|
if(b>255) b=255;
|
|
if(r>255) r=255;
|
|
if(g>255) g=255;
|
|
out[w*((uint)(iRes.y-1)-gy)+gx] = (r<<16)|(g<<8)|b;
|
|
};
|