Page MenuHomePhabricator (Chris)
Files F630622

moon_procedural_ps.txt
No OneTemporary
Actions

Authored By
Unknown
Size
13 KB
Referenced Files
None
Subscribers
None

moon_procedural_ps.txt
View Options

#version 120
const int nLightCount = 2;
const float pi = 3.14159265358;
const float tau = 6.28318530717;
uniform sampler2D biomes, cities, differenceNoise, lookup, cityGlow, /*testSplat, */surfaceData;
uniform samplerCube skybox;
uniform float lightRadius[2];
uniform vec4 ownerColor;
// complimentary triad color harmony, should in theory always generate an appealing theme.
vec3 colorLightsPrimary = ownerColor.rgb * 0.85 + 0.15;
vec3 colorLightsSecondary = vec3(ownerColor.brg) * 0.85 + 0.15;
vec3 colorLightsTertiary = vec3(ownerColor.gbr) * 0.85 + 0.15;
////Amount of population considered 'half full'
//const float basePopulation = 8.0;
vec2 uvClamps = vec2(1.0, 1.0);
varying vec2 uv, uv2, uv3;
varying vec3 normal, v, vertCol, origo;
varying vec4 uvNoise;
varying float pulse;
varying mat3 tcamrot;
/*
black biome is base biome, its biome color picks are also what controls the ocean color picks
red biome is secondary biome, that will splat on top of base
green biome is third biome, that will splat on top, the poles are hardcoded to be green biome, so keep it the coldest biome pick wise.
ocean and cracks a bonus biomes, so with both there can be 5 i total. Blue > 0.5 is ocean, blue < 0.5 is cracks. Ocean is using the combined height for detail, cracks is using ao to spawn in cracks.
alpha is city location and density, it rules over all others but will be build under water.
*/
//vec2(0.0, 0.0) vulcanic
//vec2(0.25, 0.0) crystal
//vec2(0.5, 0.0) mountains
//vec2(0.75, 0.0) cracked
//vec2(0.0, 0.5) ice
//vec2(0.25, 0.5) barren
//vec2(0.5, 0.5) terran
//vec2(0.75, 0.5) desert
// x = 0-1 color wheel picker, y is intensity
uniform vec4 cracksColorIntensityBiomeSeed;
uniform vec4 biomeOffsets;
varying vec2 polarGradients;
varying vec3 light[nLightCount];
varying float dist[nLightCount];
// /*varying */vec4 biomeOffsets = vec4(0.75, 0.0, 0.25, 0.5);
// /*varying */float biomePicks = (1.0 / 2048.0) * 470.0;
// parallax scale, bias and steps
const vec2 scaleBias = vec2(0.002, 0.001);
const int pStep = 0;
float deriveZ(vec2 n) {
float z = sqrt(abs(1.0 - n.x * n.x - n.y * n.y));
return z;
}
vec3 toLinear(vec3 x) {
return pow(x, vec3(2.2));
}
vec3 toGamma(vec3 x) {
return pow(x, vec3(0.45));
}
// pow alternatives
vec3 square(vec3 x) {
return x*x;
}
// pow alternatives
vec2 square(vec2 x) {
return x*x;
}
vec3 paletteBlackBody( float t )
{
t *= t;
return square(min(vec3(1.0), 0.45 + 0.35*cos( tau*((t * 0.9)+vec3(0.45, 0.55, 0.65)) ) + (1.0 - t) * 0.25));
}
float square(float x) {
return x*x;
}
float pow5(float x) {
float y = x*x;
return y*y*x;
}
float pow8(float x) {
x = x*x;
x = x*x;
return x*x;
}
// speculer term part 1, GGX.
float D_GGX(float HdotN, float Roughness)
{
float denominator = HdotN * HdotN * (Roughness - 1.0) + 1.0;
return Roughness /( pi * denominator * denominator);
}
// specular term part 2, GGX.
float V_SchlickforGGX(float Roughness, float G1V, float NdotL)
{
float G1L = NdotL * (1.0 - Roughness) + Roughness;
return 0.25f / (G1V * G1L);
}
// fresnel for specular term
vec3 Fresnel(vec3 substance, vec3 l, vec3 h)
{
return max(vec3(0.0), substance + (substance - 1.0) * pow5(1.0 - max(0.0,(dot(l, h)))));
}
// fresnel for ambient light for linear GGX.
vec3 Fresnel2(vec3 substance, float dotProduct, float roughness)
{
return substance + (1.0 - substance) * pow5((1.0 - dotProduct)) / (6.0 - 5.0 * roughness);
}
// diffuse term, fake fast approximation
float OrenNayerforDiffuseOnly(float roughness, float NdotL, float NdotV)
{
float O = 0.62 - pow(1.0 - NdotL * clamp(1.0-NdotV / 2.0, 0.0,1.0), pi) * 0.62;
return mix(O, NdotL, roughness);
}
// note feed it inverted roughness squared
float sphereLightEnergyConservation(vec3 toLightCenter, float radius, float roughness)
{
float invDistToLight = inversesqrt(dot(toLightCenter, toLightCenter));
float sphereAngle = max(0.0, radius * invDistToLight);
return square(roughness / max(0.0, roughness + 0.5 * sphereAngle));
}
vec3 sphereLightClosestPoint(vec3 l,vec3 r,float radius)
{
vec3 centerToRay = dot(l, r) * r - l;
return l + centerToRay * clamp(radius / length(centerToRay), 0.0, 1.0); // just max will make donut shaped highlights:oP
}
// cosine based palette, 4 vec3 params
vec3 palette(float t, vec3 a, vec3 b, vec3 c, vec3 d )
{
return a + b*cos( 6.28318*(c*t+d) );
}
vec3 dp1Calc(vec3 p)
{
return dFdx(p);
}
vec3 dp2Calc(vec3 p)
{
return dFdy(p);
}
vec4 duv1Calc(vec4 uv)
{
return dFdx(uv);
}
vec4 duv2Calc(vec4 uv)
{
return dFdy(uv);
}
const vec4 hashSeed = vec4(.16532,.17369,.15787, .14987);
// random noise functions ahead
float hash11(float p)
{
vec2 p2 = fract(vec2(p) * hashSeed.x);
p2 += dot(p2.yx, p2.xy+19.19);
return fract(p2.x * p2.y);
}
float noise3D(vec3 x )
{
vec3 p = floor(x);
vec3 f = fract(x);
f = f*f*(3.0-2.0*f);
float n = p.x + p.y*157.0 + 113.0*p.z;
return mix(mix(mix( hash11(n+ 0.0), hash11(n+ 1.0),f.x),
mix( hash11(n+157.0), hash11(n+158.0),f.x),f.y),
mix(mix( hash11(n+113.0), hash11(n+114.0),f.x),
mix( hash11(n+270.0), hash11(n+271.0),f.x),f.y),f.z);
}
void main() {
vec3 test = vec3(0.0);
float splatMapNoise = noise3D(origo * 0.5+ origo * vertCol.g);
float normalIntensity = 1.0;
vec4 uvS = vec4(uv, uv2);
// because we have two uvs, for poles and equator, to avoid polar distortions and hide tiling, we need two matrices for separated normal mapping
mat3 TBNA;
mat3 TBNB;
// Normal and tangent setup
vec3 dp1 = dp1Calc(-v);
vec3 dp2 = dp2Calc(-v);
vec4 duv1 = duv1Calc(uvS);
vec4 duv2 = duv2Calc(uvS);
// solve the linear system
vec3 dp2perp = cross(dp2, normal);
vec3 dp1perp = cross(normal, dp1);
vec3 tangent = dp2perp * duv1.x + dp1perp * duv2.x;
vec3 binormal = dp2perp * duv1.y + dp1perp * duv2.y;
// construct a scale-invariant frame
float invmax = pow(max(dot(tangent, tangent), dot(binormal, binormal)), -0.5);
TBNA = mat3(tangent * invmax, binormal * invmax, normal);
tangent = dp2perp * duv1.z + dp1perp * duv2.z;
binormal = dp2perp * duv1.w + dp1perp * duv2.w;
// construct a scale-invariant frame
invmax = pow(max(dot(tangent, tangent), dot(binormal, binormal)), -0.5);
TBNB = mat3(tangent * invmax, binormal * invmax, normal);
vec4 parSamp = vec4(texture2D(biomes, uvS.xy + biomeOffsets.xy).a,texture2D(biomes, uvS.xy + biomeOffsets.zw).a,texture2D(biomes, uvS.zw + biomeOffsets.xy).a,texture2D(biomes, uvS.zw + biomeOffsets.zw).a);
vec2 splatMix = min(vec2(1.0), vec2((parSamp.r + parSamp.g + splatMapNoise), (parSamp.b + parSamp.a + splatMapNoise)) * splatMapNoise);
// create combined detail texture and calculate weighted splat mapping for the two uv sets
parSamp.rg = vec2(mix(parSamp.r, parSamp.g, splatMix.r), mix(parSamp.b, parSamp.a, splatMix.g));
float NdotV = max(0.0, dot(normal, v));
// do parallax
float fDet = dot(dp1, dp2perp);
vec2 vProjVScr = (1.0/fDet) * vec2(dot(dp2perp, v), dot(dp1perp, v));
vec4 vProjVTex = (duv1 * vProjVScr.x + duv2 * vProjVScr.y);
vec2 vProjVTexZ = mix(vec2(0.0), (vec2(parSamp.r, parSamp.g) * scaleBias.r - scaleBias.g), NdotV);
uvS += (vProjVTex * vProjVTexZ.xxyy);
// sample all four biomes once for each of the first two uv sets
vec4 firstbiomeA = texture2D(biomes, uvS.xy + biomeOffsets.xy);
vec4 firstBiomeB = texture2D(biomes, uvS.zw + biomeOffsets.xy);
vec4 secondbiomeA = texture2D(biomes, uvS.xy + biomeOffsets.zw);
vec4 secondBiomeB = texture2D(biomes, uvS.zw + biomeOffsets.zw);
// mix the normals cavity and resampled heightmap
vec4 dataSampA = mix(firstbiomeA, secondbiomeA, splatMix.r);
vec4 dataSampB = mix(firstBiomeB, secondBiomeB, splatMix.g);
// create combined detail splatmask to mix the first two uv sets
float uvBlend = min(1.0, (dataSampA.a + dataSampB.a + vertCol.b) * vertCol.b);
// perform TBN matrix multiplication for each of the two normal maps separately and mix, save instructions by mix in height in alpha.
vec4 n = vec4(dataSampA.xy, dataSampB.xy);
n *= 2.0;
n -=1.0;
n = mix(vec4(normalize(TBNA * normalize(vec3(n.xy, deriveZ(n.xy)))), (dataSampA.a + dataSampA.b) * 0.5), vec4(normalize(TBNB * normalize(vec3(n.zw, deriveZ(n.zw)))), (dataSampB.a + dataSampB.b) * 0.5), uvBlend);
// move these out of the mixing later
vec3 r = normalize(reflect(-v, n.xyz));
NdotV = max(0.0, dot(n.xyz, v));
// sample albedo and roughness from lookup table
vec4 albedo = texture2D(lookup, vec2(cracksColorIntensityBiomeSeed.z, n.a)); //, 0.0
albedo.rgb = toLinear(albedo.rgb);
float metalness = 0.001;//clamp(((1.0 - dot(albedoR.xz, albedoR.xz)) - albedoR.y) * 2.0, 0.0, 1.0);// * waterMask;
vec3 substance = (0.04 - 0.04 * metalness) + albedo.rgb * metalness;// * clamp(2048.0 - 1780.0, 0.0,1.0);
albedo.rgb -= substance;
float ao = square(min(1.0,(n.a * 2.0)));
vec3 oceanColor = texture2D(lookup, vec2(cracksColorIntensityBiomeSeed.z, max(0.995, 0.05))).rgb; // from 0.0065 to 0.0025
// clamp to keep in PBR safe ranges - nothing in reality either albedo or roughness is 0 or 1 and can make the math fail
albedo = clamp(albedo, vec4(0.05), vec4(0.95));
// create sss mask
vec4 invertedAlbedo = 1.0 - albedo;
float SSSmask = mix(NdotV * 0.5 + 0.5, 1.0 - min(1.0, pow8((1.0 - invertedAlbedo.a * invertedAlbedo.b) * (1.0 - invertedAlbedo.r * invertedAlbedo.g))) * n.a, n.a);
//cracksColorIntensityBiomeSeed
albedo.a = pow(albedo.a, 0.5);
// ambient reflections
vec3 ambientFresnel = Fresnel2(substance, NdotV ,albedo.a);
vec3 color = square((textureCube(skybox, r, sqrt(albedo.a) * 8.0).rgb) + 0.024) * ambientFresnel;
// ambient light
color += square(textureCube(skybox, n.xyz, 8.0).rgb + 0.024) * albedo.rgb * (1.0 - ambientFresnel);
// pbr calculations that would be done twice in loop
vec3 roughness = vec3(square(vec2(albedo.a, albedo.a * 0.5 + 0.5)), 0.0);
roughness.r = square(roughness.r);
roughness.g *=0.5;
roughness.b = 1.0 - square(albedo.a);
float G1V = NdotV * (1.0 - roughness.g) + roughness.g;
for (int i = 0; i < nLightCount; i++) {
vec3 L = sphereLightClosestPoint((light[i]), r , lightRadius[i]);
float energy = (sphereLightEnergyConservation(L, lightRadius[i], roughness.b));
L = normalize(L);
vec2 NdotL = max(vec2(0.0), vec2(dot(mix(n.xyz, normal, 0.5),L) * 0.8 + 0.2, dot(n.xyz,L)));
float attenuation = 1.0f / (1.0f + dot(L ,L) / lightRadius[i]) * NdotL.x;
//citylights *= 1.0 - attenuation;
if (attenuation >0.0){
vec3 VplusL = L + v * 0.5;
vec3 halfVec = normalize(VplusL);
float HdotN = max(0.0, dot(halfVec, n.xyz));
vec3 F = Fresnel(substance, L, halfVec);
float D = max(0.0, D_GGX(HdotN, roughness.r));
float V = max(0.0, V_SchlickforGGX(roughness.g, G1V, NdotL.y));
float O = OrenNayerforDiffuseOnly(albedo.a, NdotL.y, NdotV);
// sub surface scattering model
float inScatter = pow(clamp(dot(L, -v), 0.0, 1.0), 12.0) * mix(8.0, 0.1, SSSmask);
float normalContribution = clamp(dot(mix(normal, n.xyz, SSSmask), halfVec) * SSSmask + 1.0 - SSSmask, 0.0, 1.0);
float backScatter = n.a * normalContribution / tau;
vec3 SSS = mix(backScatter, 1.0, inScatter) * square(oceanColor) * NdotL.x;
SSS = vec3(0.0);
color += ((D * V * F * energy) + ((1.0 - F) * O * albedo.rgb) + SSS) * toLinear(gl_LightSource[i].diffuse.rgb) * attenuation;
}
}
// hard cavity multiplier
color *= n.a * 0.5 + 1.0;
gl_FragColor.rgb = toGamma(vec3(color));
gl_FragColor.a = 1.0;
}

File Metadata

Mime Type
text/x-c
Expires
Sun, Nov 15, 9:56 AM (21 h, 39 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
142735
Default Alt Text
moon_procedural_ps.txt (13 KB)

Event Timeline