port from perforce
This commit is contained in:
359
bp4k/party_pack/bin/FlightSim/FlightSimShader.fs
Normal file
359
bp4k/party_pack/bin/FlightSim/FlightSimShader.fs
Normal file
@@ -0,0 +1,359 @@
|
||||
// Time
|
||||
varying float T;
|
||||
|
||||
// Camera data
|
||||
varying vec3 cameraPos;
|
||||
|
||||
// Position of the fragment
|
||||
varying vec2 Z;
|
||||
|
||||
// Forward declarations
|
||||
vec4 traceRay(vec3, vec3, int);
|
||||
vec3 shade(vec4, vec3, vec3);
|
||||
|
||||
|
||||
// All data of our world
|
||||
vec3 lightDir, lightColor, waterColor, ro, rd, interlacing;
|
||||
float gf_DetailLevel, pi, eps, bigeps;
|
||||
|
||||
|
||||
// Pseudo random number base generator (credits go to iq/rgba)
|
||||
float rnd(vec2 x)
|
||||
{
|
||||
int n = int(x.x * 40 + x.y * 6400);
|
||||
n = (n << 13) ^ n;
|
||||
return 1 - float( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824;
|
||||
}
|
||||
|
||||
|
||||
// Generate cubic interpolated random values
|
||||
float smoothrnd(vec2 x)
|
||||
{
|
||||
x = mod(x,1000.0);
|
||||
vec2 a = fract(x);
|
||||
x -= a;
|
||||
vec2 u = a*a*(3.0-2.0*a);
|
||||
return mix(
|
||||
mix(rnd(x+vec2(0,0)),rnd(x+vec2(1,0)), u.x),
|
||||
mix(rnd(x+vec2(0,1)),rnd(x+vec2(1,1)), u.x), u.y);
|
||||
}
|
||||
|
||||
|
||||
// Convert the cipher range from [-1,1] to [0,1]
|
||||
float norm(float x)
|
||||
{
|
||||
return x * 0.5 + 0.5;
|
||||
}
|
||||
|
||||
|
||||
// Generate animated (t) caustic values
|
||||
float caustic(float u, float v, float t)
|
||||
{
|
||||
float a = (
|
||||
norm(sin(pi * 2 * (u + v + T*t))) +
|
||||
norm(sin(pi * (v - u - T*t))) +
|
||||
norm(sin(pi * (v + T*t))) +
|
||||
norm(sin(pi * 3 * (u - T*t)))) * 0.3;
|
||||
return pow(a, 2.0);
|
||||
}
|
||||
|
||||
|
||||
// Calculate our TV effects (interlacing, RGB mask and film grain)
|
||||
vec3 pp(vec3 color)
|
||||
{
|
||||
int c = int(mod(gl_FragCoord.x, 3.0));
|
||||
if (c==0) color *= interlacing.xyz;
|
||||
if (c==1) color *= interlacing.yzx;
|
||||
if (c==2) color *= interlacing.zxy;
|
||||
return mix(color, vec3(norm(smoothrnd(Z * 333 + rnd(vec2(T)) * 33333))), 0.03);
|
||||
}
|
||||
|
||||
|
||||
// Our fake godray effect (bad if moving fast, but awesome any other time)
|
||||
vec3 godrays(vec3 color)
|
||||
{
|
||||
vec2 dpos = Z*2-1;
|
||||
float g = dpos.x * (dpos.y + 3);
|
||||
return color + lightColor *
|
||||
caustic(g + 50 * ro.x, g + 50 * ro.z, 1.5) *
|
||||
(norm(dpos.y)) * min(-ro.y * 30, 0.3);
|
||||
}
|
||||
|
||||
|
||||
// Our heightmap calculation function, we could use some perlin noise here if it wouldn't be so performance killing
|
||||
float height(vec2 x)
|
||||
{
|
||||
return (-0.035 + pow((caustic(x.x * 10, x.y * 10, 0.0) * 2 - 1), 2.0) * 0.05)
|
||||
- (x.x - 0.1) * 0.2; // This line creates one entire continent and a big ocean!
|
||||
}
|
||||
|
||||
|
||||
// Gets the terrain normal
|
||||
vec3 getTerrainNormal(vec3 p)
|
||||
{
|
||||
return normalize(vec3(
|
||||
height(p.xz - vec2(bigeps, 0)) - height(p.xz + vec2(bigeps, 0)),
|
||||
2 * bigeps,
|
||||
height(p.xz - vec2(0, bigeps)) - height(p.xz + vec2(0, bigeps))));
|
||||
}
|
||||
|
||||
|
||||
// Global diffuse lighting formula
|
||||
vec3 diffuseLight(vec3 incolor, vec3 normal)
|
||||
{
|
||||
return (0.3 + 0.7 * max(dot(normal, lightDir), 0.0)) * lightColor * incolor;
|
||||
}
|
||||
|
||||
|
||||
// Calculates the water "waves". To reduce the bumpiness, increment the y-axis
|
||||
vec3 getWaterNormal(vec3 p)
|
||||
{
|
||||
return normalize(vec3(
|
||||
caustic(p.x * 160 - cos(p.z * 10) * 12, p.z * 140, 4.0),
|
||||
8,
|
||||
caustic(p.z * 160 - sin(p.x * 10) * 12, p.x * 140, 4.0)) * 2 - 1);
|
||||
}
|
||||
|
||||
|
||||
// Calculate the terrain color for the given voxel
|
||||
vec3 shadeTerrain(vec3 p, vec3 rd)
|
||||
{
|
||||
vec3 n = getTerrainNormal(p);
|
||||
vec3 color = mix(
|
||||
// sandy color
|
||||
vec3(0.66, 0.55, 0.4)
|
||||
|
||||
// basic color (big random color spots)
|
||||
- 0.2 * smoothrnd(abs(p.xz * 150))
|
||||
|
||||
// texture (sediment lines)
|
||||
- 0.2 * smoothrnd(abs(p.yy + 0.002 * smoothrnd(abs(p.xz * 150))) * 3000),
|
||||
|
||||
// interleaved grass, hight dependant
|
||||
vec3(0.1, 0.3, 0) * (smoothrnd(p.xz * 7000.0) * 0.4 + 0.5),
|
||||
|
||||
// mixing for the sand/grass transition
|
||||
clamp(n.y * (caustic(p.x * 111, p.z * 111, 0.0) * 0.5 - p.y * 40), 0.0, 1.0));
|
||||
|
||||
// caustics, only underwater (no cloudshadows, though)
|
||||
if (p.y <= 0)
|
||||
color += 5 * getWaterNormal(0.8 * p).x * min(0.3, -p.y * 8);
|
||||
|
||||
// Light
|
||||
return diffuseLight(color, n);
|
||||
}
|
||||
|
||||
|
||||
// Create a blueish sky transition from navy blue to badass dark blue
|
||||
vec3 shadeSky(vec3 ro, vec3 rd)
|
||||
{
|
||||
return ro.y <= -eps*eps ?
|
||||
waterColor :
|
||||
mix(vec3(-0.5, -0.25, 0), vec3(2), 1 - (rd.y * 0.5 + 0.5));
|
||||
}
|
||||
|
||||
|
||||
// Calculates the refraction and reflection of the water surface.
|
||||
// Also mixes both values by the depth of the water and the fresnel term.
|
||||
// Possible improvements: fix fake underwater reflection and refraction
|
||||
vec3 shadeWaterRefl(vec3 p, vec3 newrd)
|
||||
{
|
||||
vec3 waterNormal = getWaterNormal(p);
|
||||
|
||||
// perform raytracing/raymarching for both reflection and refraction
|
||||
// calc the water refraction, the refraction index (0.9) will decrease with the distance to allow a better over/under water transition
|
||||
vec4 refracted = traceRay(p, refract(newrd, waterNormal, 0.9), 2);//mix(0.9, 1.0, smoothstep(0.01, 0.0, length(p-ro)))), 2);
|
||||
|
||||
// calculate the depth factor (water entry point to terrain voxel) (black magic involved here!)
|
||||
float depth = clamp(pow(1.03 * (1 - length(refracted.xyz - p)), 16.0), 0.0, 1.0);
|
||||
|
||||
// Finally stir the pot =)
|
||||
return mix(
|
||||
ro.y < 0 ? shadeSky(p, newrd) : waterColor, // Water color
|
||||
mix(
|
||||
shade(traceRay(p, reflect(newrd, waterNormal), 2), p, newrd), // Reflection color
|
||||
shade(refracted, p, newrd), // Refraction color
|
||||
clamp(-rd.y + depth, 0.0, 1.0)), // fresnel term
|
||||
refracted.w == 3.0 ? 0.5 : pow(depth, 0.5)); // water color contribution
|
||||
|
||||
}
|
||||
|
||||
|
||||
// Raymarch the terrain function, returns the distance from the ray origin to the terrain voxel
|
||||
// This function was originally adopted from an implementation by iq/rgba
|
||||
float traceTerrain(vec3 ro, vec3 rd, float maxt)
|
||||
{
|
||||
float delt, lh, ly, samplePosY;
|
||||
delt = 0; // If the world would consist of only nVidia GPUs, this line wouldn't exist.
|
||||
vec3 samplePos = ro;
|
||||
|
||||
// advance our sample position from our nearplane to our farplane
|
||||
for (float t = 0; t < maxt; t += delt)
|
||||
{
|
||||
// advance our ray
|
||||
samplePos += rd * delt;
|
||||
samplePosY = samplePos.y;
|
||||
|
||||
// get the height at the given sample 2d (!) position (we could enhance this by sampling a voxel and returning only the distance to the voxel)
|
||||
float h = height(samplePos.xz);
|
||||
|
||||
if (samplePosY <= h)
|
||||
{
|
||||
// we need to know our improved (more accuracy here) real terrainposition and the old sampleposition
|
||||
// also we precalculate the traveled ray distance (its not a ray anymore if we use stuff like refraction, eg but hey lets stick to this word)
|
||||
return t - delt + delt*(lh-ly)/(samplePosY-h+lh-ly);
|
||||
}
|
||||
|
||||
// store our last height and last sampleposition on the y-axis
|
||||
// we need this to calculate the improved terrainposition which will give us a smoother transition between our samplesteps (rd*delt)
|
||||
lh = h;
|
||||
ly = samplePosY;
|
||||
|
||||
// advance our steplength the more we travel the bigger our stepsize should be
|
||||
// with this we are able to sample finer details near to our camera
|
||||
delt = 0.002 + (t/gf_DetailLevel);
|
||||
}
|
||||
|
||||
// we hit nothing
|
||||
return 9.0;
|
||||
}
|
||||
|
||||
|
||||
// Ray vs. plane intersection function
|
||||
float traceWater(vec3 ro, vec3 rd)
|
||||
{
|
||||
float tPlane = -ro.y / rd.y;
|
||||
return tPlane >= eps ? tPlane : 9.0;
|
||||
}
|
||||
|
||||
|
||||
// Raytracing entry point, returns voxel and object ID
|
||||
// IDs:
|
||||
// 0 = sky (not the armageddon, xTr1m!!)
|
||||
// 1 = terrain
|
||||
// 2 = water
|
||||
vec4 traceRay(vec3 ro, vec3 rd, int ignore)
|
||||
{
|
||||
float water, terrain, minDist;
|
||||
|
||||
// trace only the objects we need (only one could maximally be ignored)
|
||||
water = ignore != 2 ? traceWater(ro, rd) : 9.0;
|
||||
terrain = ignore != 1 ? traceTerrain(ro, rd, min(0.5, 0.002 + water)) : 9.0;
|
||||
|
||||
// auto detail level reducing (common dude, give the GPU some breathing room)
|
||||
gf_DetailLevel *= 0.75;
|
||||
|
||||
// find the nearest distance
|
||||
minDist = min(terrain, min(water, 9.0));
|
||||
|
||||
// we hit nothing or the hitpoint is too far
|
||||
if (minDist == 9)
|
||||
return vec4(0);
|
||||
|
||||
// calculate the hit/voxel position
|
||||
vec3 hitPos = ro + rd * minDist;
|
||||
|
||||
// check what we might have hit
|
||||
if (minDist == terrain)
|
||||
return vec4(hitPos, 1);
|
||||
if (minDist == water)
|
||||
return vec4(hitPos, 2);
|
||||
|
||||
// Panic, worry, die to death! Probably we'll land on the moon (this should never happen)
|
||||
//return vec4(0);
|
||||
}
|
||||
|
||||
|
||||
// Entrypoint for color calculation
|
||||
vec3 shadeRefl(vec4 hitPoint, vec3 newRo, vec3 rd)
|
||||
{
|
||||
// determine the fog color for this very precise point in the space time continuum
|
||||
vec3 myFog = newRo.y < eps ? waterColor : shadeSky(ro, rd);
|
||||
|
||||
// generate the distance value for the fog calculation
|
||||
float distance = clamp(length(hitPoint.xyz - newRo) * (ro.y <= 0 ? 4 : 2), 0.0, 1.0);
|
||||
|
||||
// get the color of the hit object and mix it with the fog
|
||||
// in most cases we allow further raytracing here (not for the terrain, its not shiny enough)
|
||||
if (hitPoint.w == 1)
|
||||
return mix(shadeTerrain(hitPoint.xyz, rd), myFog, distance);
|
||||
if (hitPoint.w == 2)
|
||||
return mix(shadeWaterRefl(hitPoint.xyz, rd), myFog, distance);
|
||||
|
||||
return shadeSky(newRo, rd);
|
||||
}
|
||||
|
||||
|
||||
// Get the color from the object we just hit (without further raytraces)
|
||||
// this is necessary because no recursion is allowed in GLSL (damn you!)
|
||||
vec3 shade(vec4 hitPoint, vec3 newRo, vec3 rd)
|
||||
{
|
||||
// determine the fog color for the very same point we discussed earlier
|
||||
vec3 myFog = newRo.y < eps ? waterColor : shadeSky(ro, rd);
|
||||
|
||||
// generate the other distance value. Paid attention? If you don't know what value I'm talking about, rtfm or gtfo.
|
||||
float distance = clamp(length(hitPoint.xyz - newRo) * (ro.y <= 0 ? 4 : 2), 0.0, 1.0);
|
||||
|
||||
// get the color of the hit object and mix it with the fog
|
||||
if (hitPoint.w == 1)
|
||||
return mix(shadeTerrain(hitPoint.xyz, rd), myFog, distance);
|
||||
if (hitPoint.w == 2)
|
||||
return mix(waterColor, myFog, distance);
|
||||
|
||||
return myFog;
|
||||
}
|
||||
|
||||
|
||||
// Now we're just being copycats. We're not creative enough to define own entry points
|
||||
// Sure, we could "#define MYENTRYPOINT main"! Or just void main(){MyEntryPoint();}
|
||||
// None of that would help us win the compo, would it?
|
||||
void main()
|
||||
{
|
||||
// Set the quality setting for the raymarcher, a higher value results in a longer processing time
|
||||
// try to find a good balance between these two, low values will result in a wobbling endresult
|
||||
// low quality = 50.0 (visual results are ok at 640x480)
|
||||
// mid quality = 100.0
|
||||
// high quality = 200.0
|
||||
gf_DetailLevel = 200;
|
||||
|
||||
// Give our saviour global variables some life!
|
||||
pi = 3.1416;
|
||||
interlacing = vec3(1.2, 0.9, 0.9);
|
||||
eps = 0.0001;
|
||||
bigeps = 0.01;
|
||||
|
||||
// Get the look direction for the current pixel (always look forwards)
|
||||
ro = cameraPos; //set ray origin
|
||||
if (ro.y < height(ro.xz) + 0.01f)
|
||||
{
|
||||
ro.y = height(ro.xz) + 0.01f;
|
||||
}
|
||||
|
||||
rd = vec3(gl_ModelViewMatrix * vec4((Z.xy - 0.5), 1, 1));
|
||||
|
||||
// Make our world pretty and worthy to live in (you can cultivate algae and eat them, they're surely enough for survival)
|
||||
lightDir = vec3(0.58, 0.58, -0.58);
|
||||
lightColor = vec3(1.2);
|
||||
waterColor = vec3(0.3, 0.33, 0.4);
|
||||
|
||||
// Our GPU feels good underwater, almost like a refreshing experience :) cool, eh?
|
||||
if (ro.y <= 0)
|
||||
{
|
||||
// Less work to do...
|
||||
gf_DetailLevel *= 0.75;
|
||||
|
||||
// ...and a cozy darker atmosphere
|
||||
lightColor *= 0.8;
|
||||
}
|
||||
|
||||
// Here we go, shoot'em rays and get the color of our fragment!
|
||||
vec3 color = shadeRefl(traceRay(ro, rd, 0), ro, rd);
|
||||
|
||||
// Underwater there are beams of light emanating from god (so called "god" rays...)
|
||||
// ...this prooves that god is nothing less than a water surface.
|
||||
if (ro.y <= 0)
|
||||
color = godrays(color);
|
||||
|
||||
// Apply post processing and fade effects to the color, and finally return it.
|
||||
gl_FragColor.xyz = pp(color);
|
||||
}
|
||||
Reference in New Issue
Block a user