Page MenuHomePhabricator (Chris)
Files F630935

planet_procedural_clean_ps.txt
No OneTemporary
Actions

Authored By
Unknown
Size
20 KB
Referenced Files
None
Subscribers
None

planet_procedural_clean_ps.txt
View Options

#version 120
const bool advancedProcedurals = #{{level:extreme}};
const bool parallax = #{{level:extreme}};
const bool scattering = #{{level:extreme}};
const bool pbrLight = #{{level:high}};
const bool simpleProcedurals = #{{level:high}};
const bool advancedAmbience = #{{level:high}};
const bool normalMapping = #{{level:medium}};
const bool simpleAmbience = #{{level:medium}};
const bool selfIllumination = #{{level:medium}};
const int nLightCount = 2;
const float pi = 3.14159265358;
const float tau = 6.28318530717;
// constants for emissive lights and starlight intensity
const float emissiveIntensity = 2.5;
const float lightIntensity = 1.0;
uniform sampler2D biomes, cities, differenceNoise, lookup, cityGlow, surfaceData;
uniform samplerCube skybox;
uniform float lightRadius[nLightCount];
uniform vec4 ownerColor;
uniform float population;
vec4 playerPlateProfile = vec4(vec3((1.0 - ownerColor.rgb) * 0.2 + 0.8), 0.75);
// complimentary triad color harmony, should in theory always generate an appealing theme.
vec3 colorLightsPrimary = ownerColor.rgb * 0.45 + 0.55;
vec3 colorLightsSecondary = vec3(ownerColor.brg) * 0.45 + 0.55;
vec3 colorLightsTertiary = vec3(ownerColor.gbr) * 0.85 + 0.15;
const float splatSharpness = 2.0;
////Amount of population considered 'half full'
const vec3 basePopulation = vec3(1.0, 0.25, 0.25);
varying vec2 uv, uv2, uv3, uvB[5];
varying vec4 uvNoise, pos;
varying vec3 light[nLightCount];
varying vec3 lightColor[nLightCount];
varying float dist[nLightCount];
varying vec3 normal, npos, vertCol;
varying float pulse;
/*
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 vec2 cracksColorIntensity;
uniform vec4[3] biomesPicks;
// parallax scale, bias and steps
const vec2 scaleBias = vec2(0.005, 0.0025);
// smoothstep without the edges
float smoothCurve(float x){
return x * x * (3.0 - 2.0 * x);
}
vec3 toLinear(vec3 x) {
return pow(x, vec3(2.2));
}
vec3 toGamma(vec3 x) {
return pow(x, vec3(0.45));
}
vec3 square(vec3 x) {
return x*x;
}
float square(float x) {
return x*x;
}
vec2 square(vec2 x) {
return x*x;
}
float pow5(float x) {
float y = x*x;
return y*y*x;
}
vec2 pow5(vec2 x) {
vec2 y = x*x;
return y*y*x;
}
vec3 pow5(vec3 x) {
vec3 y = x*x;
return y*y*x;
}
vec3 pow3(vec3 x) {
return x*x*x;
}
vec2 pow3(vec2 x) {
return x*x*x;
}
float pow3(float x) {
return x*x*x;
}
float pow8(float x) {
x = x*x;
x = x*x;
return x*x;
}
// speculer term part 1
float D_GGX(float HdotN, float Roughness)
{
float m = Roughness * Roughness;
float m2 = m * m;
float denominator = HdotN * HdotN * (m2 - 1.0) + 1.0;
float D = m2 /( pi * denominator * denominator);
return D;
}
// specular term part 2
float V_SchlickforGGX(float Roughness, float NdotV, float NdotL)
{
float k = Roughness * Roughness * 0.5f;
float G1V = NdotV * (1.0 - k) + k;
float G1L = NdotL * (1.0 - k) + k;
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) * pow(1.0 - max(0.0,(dot(l, h))), 5.0));
}
// fresnel for ambient light
vec3 Fresnel2(vec3 substance, float dotProduct, float roughness)
{
return substance + (1.0 - substance) * pow((1.0 - dotProduct), 5.0) / (6.0 - 5.0 * roughness);
}
// diffuse term
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;
O = mix(O, NdotL, roughness);
return O;
}
// fail-safe get normal map z component
float deriveZ(vec2 n) {
float z = pow(abs(1.0 - n.x * n.x - n.y * n.y), 0.5);
return z;
}
// calculates palette for cracks
vec3 paletteCracks(float c)
{
return 0.5 + 0.5 * cos(tau * (1.0 * c + vec3(0.0, 0.33, 0.67)) );
}
// calculates light tinting, simulating atmospheric scattering.
vec3 paletteAtmoTint( float t )
{
t *= t;
return square(min(vec3(1.0), 0.45 + 0.45*cos( tau*((t * 0.9)+vec3(0.45, 0.55, 0.65)) ) + (1.0 - t) * 0.25));
}
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);
}
void main() {
vec4 splatMap = texture2D(surfaceData, uvB[0]) * 2.0;
for (int i = 0; i < 4; i++) {
splatMap.rgb += texture2D(surfaceData, uvB[i+1]).rgb;
}
splatMap.rgb *= 0.166666666;
float poleMask = smoothCurve(1.0 - square(vertCol.b));
splatMap.rg *= poleMask;
// poles are made to be ruled by green, and water/cracks masks are made to never reach the poles - where they blend particular bad due to all splatmap grids meeing in a point
splatMap.gb = mix(vec2(1.0, 0.5), splatMap.gb, poleMask);
vec2 cracksWaterMask = vec2((splatMap.b - 0.5) * 2.0);
cracksWaterMask = max(vec2(0.0),vec2(-1.0 * cracksWaterMask.x, cracksWaterMask.y));
vec4 uvS = vec4(uv, uv2);
vec3 v = normalize(npos);
vec4 n = vec4(normalize(normal), 0.5); // heightmap is stored in a later
vec2 NdotV = vec2(max(0.0, dot(n.xyz, v)), 0.0);
vec3 r = n.xyz;
vec4 albedoR = vec4(0.0); // pure color of a surface and roughness
vec3 substance = vec3(0.0); // essentially an rgb specular color extracted from the albedo through metalness
float metalness = 0.0; // dielectric or metallic surface
float cavity = 0.5; // hard multiplier
float ao = 1.0; // detail occluder for lights
// results
vec3 color = vec3(0.0);
vec3 lights = vec3(0.0);
vec3 citylights = vec3(0.0);
// because we have two uvs, for poles and equator, to avoid polar distortions and hide tiling, we need to run most things twice
mat3 TBNA = mat3(0.0);
mat3 TBNB = mat3(0.0);
// build splatting basis
vec3 detailSampA = vec3(texture2D(biomes, uvS.xy + biomesPicks[0].xy).a, texture2D(biomes, uvS.xy + biomesPicks[1].xy).a, texture2D(biomes, uvS.xy + biomesPicks[2].xy).a);
vec3 detailSampB = vec3(texture2D(biomes, uvS.zw + biomesPicks[0].xy).a, texture2D(biomes, uvS.zw + biomesPicks[1].xy).a, texture2D(biomes, uvS.zw + biomesPicks[2].xy).a);
vec3 splatMaskMixedA = vec3(detailSampA.r + detailSampA.g, detailSampA.g + detailSampA.b, detailSampA.b); // last one comes later
vec3 splatMaskMixedB = vec3(detailSampB.r + detailSampB.g, detailSampB.g + detailSampB.b, detailSampB.b); // last one comes later
splatMaskMixedA = min(vec3(1.0), (splatMaskMixedA.rgb + splatMap.rgb) * splatMap.rgb);
splatMaskMixedB = min(vec3(1.0), (splatMaskMixedB.rgb + splatMap.rgb) * splatMap.rgb);
// optional
splatMaskMixedA = pow(splatMaskMixedA.rgb, vec3(splatSharpness));
splatMaskMixedB = pow(splatMaskMixedB.rgb, vec3(splatSharpness));
// create combined detail texture and calculate weighted splat mapping for the two uv sets
detailSampA.r = mix(mix(detailSampA.r, detailSampA.g, splatMaskMixedA.r), detailSampA.b, splatMaskMixedA.g) - cracksWaterMask.y;
detailSampB.r = mix(mix(detailSampB.r, detailSampB.g, splatMaskMixedB.r), detailSampB.b, splatMaskMixedB.g) - cracksWaterMask.y;
if (normalMapping){
vec3 dp1 = dp1Calc(-v);
vec3 dp2 = dp2Calc(-v);
// derive for both uv's
vec4 duv1 = duv1Calc(uvS);
vec4 duv2 = duv2Calc(uvS);
vec3 dp2perp = cross(dp2, normal);
vec3 dp1perp = cross(normal, dp1);
// create matrix A
vec3 tangent = dp2perp * duv1.x + dp1perp * duv2.x;
vec3 binormal = dp2perp * duv1.y + dp1perp * duv2.y;
float invmax = pow(max(dot(tangent, tangent), dot(binormal, binormal)), -0.5);
TBNA = mat3(tangent * invmax, binormal * invmax, normal);
// create matrix B
tangent = dp2perp * duv1.z + dp1perp * duv2.z;
binormal = dp2perp * duv1.w + dp1perp * duv2.w;
invmax = pow(max(dot(tangent, tangent), dot(binormal, binormal)), -0.5);
TBNB = mat3(tangent * invmax, binormal * invmax, normal);
if (parallax){
// water depth refraction
float depthRefraction = mix(1.33,0.66, square(NdotV.r)); // water refraction index is 1.33, square so transparency wont cancel it out later
detailSampA.r *= mix(depthRefraction, 1.0, ceil(1.0 - detailSampA.r));
detailSampB.r *= mix(depthRefraction, 1.0, ceil(1.0 - detailSampB.r));
// 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 = NdotV.r * (vec2(detailSampA.r, detailSampB.r) * scaleBias.r - scaleBias.g);
uvS += vProjVTex * vProjVTexZ.xxyy;
}
}
// sample all four biomes once for each of the first two uv sets
vec4 firstbiomeA = texture2D(biomes, uvS.xy + biomesPicks[0].xy);//red
vec4 firstBiomeB = texture2D(biomes, uvS.zw + biomesPicks[0].xy);//red
vec4 secondbiomeA = texture2D(biomes, uvS.xy + biomesPicks[1].xy);//green
vec4 secondBiomeB = texture2D(biomes, uvS.zw + biomesPicks[1].xy);//green
vec4 thirdbiomeA = texture2D(biomes, uvS.xy + biomesPicks[2].xy);//black
vec4 thirdBiomeB = texture2D(biomes, uvS.zw + biomesPicks[2].xy);//black
// mix the normals cavity and resampled heightmap
vec4 dataSampA = mix(mix(firstbiomeA, secondbiomeA, splatMaskMixedA.r), thirdbiomeA, splatMaskMixedA.g);
vec4 dataSampB = mix(mix(firstBiomeB, secondBiomeB, splatMaskMixedB.r), thirdBiomeB, splatMaskMixedB.g);
// create combined detail splatmask to mix the first two uv sets
float uvBlend = min(1.0, (dataSampA.a + dataSampB.a + vertCol.r) * vertCol.r);
// mix the height for accurate combined watermask and add cavity just because we can
vec4 dataSamp = vec4(mix(dataSampA.ba, dataSampB.ba, uvBlend), 0.0, 0.0);
dataSamp.a = dataSamp.g - cracksWaterMask.y;
dataSamp.z = max(0.0, ceil(dataSamp.a));
cracksWaterMask.y = 1.0 - cracksWaterMask.y;
dataSamp.x = mix(0.5, dataSamp.x, dataSamp.z);
ao = min(1.0,(dataSamp.x * 2.0));
// yeah the edges will make horrible distortions but we lerp them out and save a sample
float waterLavaMix = (mix(8.0, (1.0 - ao * 0.01 + pulse * 0.01) * 2.0, dataSamp.z));
vec4 textureNoise = mix(texture2D(differenceNoise, uvNoise.xy * waterLavaMix), texture2D(differenceNoise, uvNoise.zw * waterLavaMix), vertCol.r);
vec2 cracksWaterNorms = vec2(mix(vec2(textureNoise.r, textureNoise.g), vec2(textureNoise.g, textureNoise.b), pulse)) - 0.5;// // could maybe be replaced by a small simple 2D noise function
float cracks = min(1.0, square(1.0 - ao) * cracksWaterMask.r);
// cracksWaterNorms is just noise, so it can work for cracks intensity here
lights = pow3(paletteCracks(fract(cracks * 0.025 + cracksColorIntensity.x)) * cracks * cracksColorIntensity.y);
float underWaterBlur = pow((1.0 - dataSamp.z) * (1.0 - dataSamp.a - 1.0), 0.5) * 7.0 + 1.0;
vec4 cityA = texture2D(cities, uvS.xy * vec2(4.0, 2.0), underWaterBlur);
vec4 cityB = texture2D(cities, uvS.zw * vec2(4.0, 2.0), underWaterBlur);
vec3 lightsA = texture2D(cityGlow, uvS.xy * vec2(4.0, 2.0), underWaterBlur).rgb;
vec3 lightsB = texture2D(cityGlow, uvS.zw * vec2(4.0, 2.0), underWaterBlur).rgb;
vec2 citySplat = clamp(vec2(pow5((1.0 - abs(vec2(dataSampA.a, dataSampB.a) - 0.5) * 2.0)) * (abs(vec2(cityA.a, cityB.a) - 0.5) + vec2(cityA.a, cityB.a))) * splatMap.a, vec2(0.0), vec2(1.0));
if (normalMapping){
// perform TBN matrix multiplication for each of the two normal maps separately and mix, save instructions by mix in height in alpha.
n = vec4(mix(dataSampA.xy, cityA.xy, citySplat.r), mix(dataSampB.xy, cityB.xy, citySplat.g));
n *= 2.0;
n -=1.0;
//create waterNormalMap
n = mix(vec4(cracksWaterNorms, cracksWaterNorms) * 0.1, n, dataSamp.z - (1.0 - square(ao)) * cracksWaterMask.x);
vec3 nA = vec3(n.xy, deriveZ(n.xy));
vec3 nB = vec3(n.zw, deriveZ(n.zw));
n = mix(vec4(normalize(TBNA * nA), dataSampA.a), vec4(normalize(TBNB * nB), dataSampB.a), uvBlend);
r = normalize(reflect(-v, n.xyz));
}
vec3 cityData = mix(vec3(cityA.ba, citySplat.r), vec3(cityB.ba, citySplat.g), uvBlend);
// create combined lookup gradients for all four biomes, clamped to not wrap the texture.
vec3 albedoGradients = mix(vec3(firstbiomeA.a, secondbiomeA.a, thirdbiomeA.a), vec3(firstBiomeB.a, secondBiomeB.a, thirdBiomeB.a), uvBlend);
// and make the flat slopes have less color shifts - think silt vs cliff sides.
albedoGradients = clamp((1 - albedoGradients) + (vec3(biomesPicks[0].w,biomesPicks[1].w,biomesPicks[2].w) * vertCol.g), vec3(0.00390625), vec3(0.984375));
// sample albedo and roughness from lookup table
vec4 firstBiomesAlbedoR = texture2D(lookup, vec2(biomesPicks[0].z, albedoGradients.r)); //, 0.0
vec4 secondBiomesAlbedoR = texture2D(lookup, vec2(biomesPicks[1].z, albedoGradients.g)); //, 0.0
vec4 thirdBiomesAlbedoR = texture2D(lookup, vec2(biomesPicks[2].z, albedoGradients.b)); //, 0.0
// create final splatmap , save instructions by mix in cavity in alpha.
vec4 albedoSplatCavity = mix(vec4(splatMaskMixedA, dataSampA.b), vec4(splatMaskMixedB, dataSampB.b), uvBlend);
// mix final albedo and tweak with cavity roughness values
albedoR = mix(mix(firstBiomesAlbedoR, secondBiomesAlbedoR, albedoSplatCavity.r), thirdBiomesAlbedoR, albedoSplatCavity.g);
cityData.rg = cityData.rg * 0.33 + 0.5;
albedoR = mix(albedoR, vec4(playerPlateProfile.rgb * cityData.g, playerPlateProfile.a) * cityData.r, cityData.b);
NdotV.g = (1.0 - NdotV.r) * 0.5 + 0.5;
NdotV.r = dot(n.xyz, v);
NdotV = max(vec2(0.0), NdotV);
// creates ocean color
vec3 oceanColor = texture2D(lookup, vec2(biomesPicks[0].z, max(0.995, cracksWaterMask.y * 0.05))).rgb; // from 0.0065 to 0.0025
//creates lights
citylights += mix(lightsA, lightsB, uvBlend);
citylights.rg *= (1.5 - underWaterBlur * 0.1) * min(1.0, cityData.b + (1.0 - dataSamp.z) * 0.5 * splatMap.a);
citylights.g *= 0.5;
citylights.b *= splatMap.a * 0.5;
citylights = clamp(vec3(population) - vec3(0.0, 15.0, 30.0), vec3(0.0), vec3(1.0)) * citylights * emissiveIntensity;
citylights = toLinear(citylights.r * colorLightsPrimary) + toLinear(citylights.g * colorLightsSecondary) + toLinear(citylights.b * colorLightsTertiary);
citylights *= min(vec3(1.0), square(oceanColor.rgb) + dataSamp.z);
//
// creates oceans
albedoR = mix(vec4((oceanColor / (1.0 + (1.0 - NdotV.y) * 0.75)) * mix(min(1.0, dataSamp.y * dataSamp.x * pow3(cracksWaterMask.y) * 16.0 + 0.25), 1.0, NdotV.y), 0.25), albedoR, dataSamp.z);
// clamp to keep in PBR safe ranges - nothing in reality either albedo nor roughness is 0 or 1 and can make the math fail
albedoR = clamp(albedoR, vec4(0.05), vec4(0.975));
// create sss mask
vec4 invertedAlbedo = 1.0 - albedoR;
float SSSmask = mix(NdotV.r * 0.5 + 0.5, 1.0 - min(1.0, pow8((1.0 - invertedAlbedo.a * invertedAlbedo.b) * (1.0 - invertedAlbedo.r * invertedAlbedo.g))) * dataSamp.y * dataSamp.x, dataSamp.z);
// creates a metalness value if biomes are above 1950 on the lookup, for metallic specular on crystals.
metalness = square(n.a) * ceil(mix(mix(biomesPicks[0].z, biomesPicks[1].z, albedoSplatCavity.r), biomesPicks[2].z, albedoSplatCavity.g) - 0.9521484375) * dataSamp.z;
albedoR.rgb = toLinear(albedoR.rgb);
substance = (0.04 - 0.04 * metalness) + albedoR.rgb * metalness;
albedoR.rgb -= substance;
// actual shading starts here
vec3 ambientFresnel = Fresnel2(substance, NdotV.r ,albedoR.a);
if (advancedAmbience){
color += square((textureCube(skybox, r, sqrt(albedoR.a) * 8.0).rgb) + 0.024) * ambientFresnel;
// ambient light
color += square(textureCube(skybox, n.xyz, 8.0).rgb + 0.024) * albedoR.rgb * (1.0 - ambientFresnel);
}
else if (simpleAmbience){
// Ambient reflections with fix mip and n instead of refect
color += square(textureCube(skybox, r, 3.0).rgb * ambientFresnel);
// Ambient light - average color of skybox squared
color += vec3(0.006724, 0.014884, 0.067081) * albedoR.rgb * (1.0 - ambientFresnel);
}
else{
// Ambient
color += vec3(0.006724, 0.014884, 0.067081) * (ambientFresnel + albedoR.rgb * (1.0 - ambientFresnel));
}
if (pbrLight){
for (int i = 0; i < nLightCount; i++) {
float distance = length(gl_LightSource[i].position.xyz - pos.xyz); // EYE SPACE, I'm sorry:o(
// rest is world space
vec3 L = normalize(light[i] / distance);
vec2 NdotL = max(vec2(0.0), vec2(dot(mix(n.xyz, normalize(normal), 0.5),L) * 0.8 + 0.2, dot(n.xyz,L)));
float sqrLightRadius = square(lightRadius[i]);
float illuminance = lightIntensity * pi * (sqrLightRadius / (max(sqrLightRadius, dot(L,L) )));
// note the square to kill hard spec in deep space!
float attenuation = square(1.0 / (1.0 + (gl_LightSource[i].constantAttenuation
+ gl_LightSource[i].linearAttenuation * distance
+ gl_LightSource[i].quadraticAttenuation * square(distance)))) * illuminance * NdotL.x;
citylights *= clamp(1.0 - attenuation, 0.0, 1.0);
if (attenuation >0.0){
vec3 VplusL = L + v * 0.5; // *0.5 is not correct but without it grazing angle specular fails, propably somewhere something is flipped space/normal space
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, albedoR.a));
float V = max(0.0, V_SchlickforGGX((1.0 + albedoR.a) * 0.5, NdotV.r, NdotL.y));
float O = OrenNayerforDiffuseOnly(albedoR.a, NdotL.y, NdotV.r);
vec3 A = vec3(1.0);
vec3 SSS = vec3(0.0);
if (scattering) {
// atmospheric light tinting simulating scattering
A = vec3(paletteAtmoTint(1.0 - max(0.0, min(0.33, dot(normal,L) + 0.15))));
// 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 = dataSamp.x * normalContribution / tau;
SSS = mix(backScatter, 1.0, inScatter) * square(oceanColor) * NdotL.x;
}
color += ((D * V * F) + ((1.0 - F) * O * albedoR.rgb) + SSS) * gl_LightSource[i].diffuse.rgb * A * attenuation;
}
}
// hard cavity multiplier
color *= dataSamp.x - metalness + 1.0;
}
// probably not worth it to check NdotL like pbr
else{
for (int i = 0; i < nLightCount; i++) {
float distance = length(gl_LightSource[i].position.xyz - pos.xyz); // EYE SPACE, I'm sorry:o(
// rest is world space
vec3 L = normalize(light[i] / distance);
float NdotL = max(0.0, dot(n.xyz,L));
float sqrLightRadius = square(lightRadius[i]);
float illuminance = lightIntensity * pi * (sqrLightRadius / (max(sqrLightRadius, dot(L,L))));
// note the square to kill hard spec in deep space!
float attenuation = square(1.0 / (1.0 + (gl_LightSource[i].constantAttenuation
+ gl_LightSource[i].linearAttenuation * distance
+ gl_LightSource[i].quadraticAttenuation * square(distance)))) * illuminance * NdotL;
citylights *= clamp(1.0 - attenuation, 0.0, 1.0);
vec3 VplusL = L + v;
vec3 halfVec = normalize(VplusL);
float HdotN = max(0.0, dot(halfVec, n.xyz));
vec3 S = Fresnel2(substance, HdotN ,albedoR.a);
// albedoR.rgb * (dataSamp.x * 0.75) to sorta hack albedo into a classical diffuse texture
lights += max(vec3(0.001), albedoR.rgb * (dataSamp.x * 0.75) + pow(S * HdotN, vec3(albedoR.a + 5.0))) * gl_LightSource[i].diffuse.rgb * attenuation;
}
}
gl_FragColor.rgb = toGamma(clamp(color + lights + citylights, vec3(0.0), vec3(1.0)));
gl_FragColor.a = 1.0;
}

File Metadata

Mime Type
text/x-c
Expires
Sun, Nov 15, 10:46 AM (1 d, 21 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
140566
Default Alt Text
planet_procedural_clean_ps.txt (20 KB)

Event Timeline