Blockland PCSS 'r3'

#version 120
#extension GL_EXT_texture_array : require
#extension GL_EXT_texture_array : enable

// Port's Poisson Disc (Optimized) Soft Shadow Shader (2015), modified by Stealth Commander/QuadStorm
// Includes an ultra graphics version, a Percentage-Closer Soft Shadows (PCSS) implementation, and other smaller configuration variables

// Revision '3' Release
// TODO: searchDistance, lightSize autoAdjust?


// Configuration: For the adventurous!

// Configuration Guide
// |default - the values as released as a reference for tuning|
// debug - show only shadows? |false|
// ultraMode - use 2 shadow sample layers ontop of eachother for an 'ultra' graphics effect |false|
// ultraRatio - ratio in size between the normal and ambient samples |5.0f|
// PCSSToggle - toggles PCSS (dynamic soft shadow variance by distance) |true|
// depthLoopNumber - sampling loop amount around each distance point: 1 = 3x3, 2 = 5x5, 3 = 7x7, etc. |2|
// lightSize - how large the light source is -- the larger the softer shadows get faster. larger values can get messy |0.2f|
// searchDistance - the shadow depth search distance -- higher values don't 'bleed' enough and lower values are less precise with shadow depths; /decrease/ for smaller lightsizes, /increase/ for larger ones |1.0f / 1536.0f|
// superGlow - Off-like glow effect; works correctly for transparent glowing bricks |true|
// shadowOpacity - allows for changing how transparent/opaque shadows are -- see https://forum.blockland.us/index.php?topic=289446.0; this toggles the fix |true|
// occlusionBlend - strength of above effect, where 1.0f is no effect (default opaque), and 0.0f is the same as minimum shaders (no shadows) |0.925f|

// Ultra Mode

bool ultraMode = false;
float ultraRatio = 5.0f;

// PCSS

bool PCSSToggle = true;

int depthLoopNumber = 2;
float lightSize = 0.2f;
float searchDistance = 1.0f / 1536.0f;

// Superglow

bool superGlow = true;

// Shadow Opacity

bool shadowOpacity = true;
float occlusionBlend = 0.95f;

// This is blending. Shadows are rendered to separate layers based on distance.
// This may cause shadows to suddenly change appearance. Use this to change
// how long a distance they will "fade" between the two versions over.
// Blending only works with ultra mode off, since I (not port) can not figure this out

float blendAlpha = 0.7f; // bl default is 0.9f
float blendBeta = 1.0f - blendAlpha;

// These values are very important. If they're too low, you will see weird
// patterns and waves everywhere. If they're too high, shadows will be
// disconnected from their objects. They need to be adjusted carefully.
// These are set specifically for Max quality with max drawing distance.
// You'll need to change them based on your shader quality (and if you changed
// the Poisson disk below.. probably).

//const float fudgeFactor1 = 0.1f; //0.1f //0.3f ultra
//const float fudgeFactor2 = 0.15f; //0.25f
//const float fudgeFactor3 = 1.0f; //0.7f
//const float fudgeFactor4 = 1.5f; //2.66f

// this becomes quite interesting with PCSS; consider pulling up to depth for the fudgeFactors?
const float fudgeFactor1 = 0.2f; //0.1f
const float fudgeFactor2 = 0.6f; //0.25f
const float fudgeFactor3 = 1.4f; //0.7f
const float fudgeFactor4 = 3.4f; //2.66f

// How soft should the shadows be? (how far out does the edge go)
// Change this or the magic numbers below to improve your "softness" quality
// note that fancy powers of two aren't needed, but they're a good starting point

float sampleDistance = 1.0f / 1024.0f;

// Magic numbers below
// this is a mess; simply added the commented out set of points; another disk will be added sometime
// meanwhile, you can change the diskcount as another quality/performance tradeoff
int poissonDiskCount = 64;
vec2 poissonDisk[209] = vec2[](vec2(-0.2951207, -0.9343002),
                                     vec2(-0.2025318, -0.9754835),
                                     vec2(-0.2322741, -0.8530075),
                                     vec2(-0.3794108, -0.808288),
                                     vec2(-0.1266675, -0.8319663),
                                     vec2(-0.01863114, -0.9015568),
                                     vec2(-0.06881609, -0.9916408),
                                     vec2(0.03625919, -0.7313007),
                                     vec2(0.1704073, -0.9132792),
                                     vec2(0.06686038, -0.9772661),
                                     vec2(0.09106962, -0.8339218),
                                     vec2(-0.5294375, -0.6967739),
                                     vec2(-0.2751279, -0.6392725),
                                     vec2(-0.4152002, -0.7020897),
                                     vec2(-0.4876193, -0.8177729),
                                     vec2(-0.2497744, -0.7448697),
                                     vec2(0.1904383, -0.7381635),
                                     vec2(0.292437, -0.7663944),
                                     vec2(0.2319807, -0.5449511),
                                     vec2(0.3131237, -0.6188368),
                                     vec2(0.1012786, -0.6236167),
                                     vec2(0.3063431, -0.8718672),
                                     vec2(-0.1224333, -0.7319462),
                                     vec2(-0.1830873, -0.5771251),
                                     vec2(-0.4526199, -0.573145),
                                     vec2(-0.6663784, -0.5719544),
                                     vec2(-0.6240153, -0.7563403),
                                     vec2(-0.5676227, -0.5281325),
                                     vec2(-0.7336679, -0.6760617),
                                     vec2(-0.2204783, -0.4727042),
                                     vec2(-0.3604262, -0.5088236),
                                     vec2(-0.345663, -0.3854073),
                                     vec2(-0.4836178, -0.466314),
                                     vec2(0.4347835, -0.5267625),
                                     vec2(0.4727078, -0.6380735),
                                     vec2(0.3495106, -0.4735118),
                                     vec2(0.4267418, -0.7299356),
                                     vec2(0.06361873, -0.5081617),
                                     vec2(-0.05319137, -0.6068379),
                                     vec2(0.4675181, -0.8565386),
                                     vec2(-0.5446453, -0.3261547),
                                     vec2(-0.6121671, -0.4217853),
                                     vec2(-0.6014596, -0.2247451),
                                     vec2(-0.7746953, -0.351309),
                                     vec2(-0.7700586, -0.4808465),
                                     vec2(0.560814, -0.7782227),
                                     vec2(0.6570461, -0.6358915),
                                     vec2(0.612024, -0.5289025),
                                     vec2(0.221402, -0.4027204),
                                     vec2(-0.1189165, -0.4975309),
                                     vec2(-0.03218988, -0.4472675),
                                     vec2(0.1034018, -0.3736421),
                                     vec2(-0.4445997, -0.2955676),
                                     vec2(0.4332047, -0.3436776),
                                     vec2(0.5157568, -0.4210246),
                                     vec2(-0.5416557, -0.09817578),
                                     vec2(-0.6972253, -0.06088046),
                                     vec2(-0.7723264, -0.2307226),
                                     vec2(-0.6773526, -0.2991687),
                                     vec2(-0.4917368, -0.2020922),
                                     vec2(-0.2759185, -0.3109736),
                                     vec2(-0.3560376, -0.23443),
                                     vec2(0.7187951, -0.4469753),
                                     vec2(0.6253875, -0.356856),
                                     vec2(0.808909, -0.5171595),
                                     vec2(0.765902, -0.6339371),
                                     vec2(-0.05865182, -0.3482775),
                                     vec2(0.1496793, -0.2736927),
                                     vec2(0.04774111, -0.2691925),
                                     vec2(-0.8177214, -0.09871018),
                                     vec2(-0.9031715, -0.279608),
                                     vec2(-0.8882925, -0.4114621),
                                     vec2(-0.6868188, -0.1717954),
                                     vec2(-0.1557365, -0.310805),
                                     vec2(-0.08686204, -0.2269464),
                                     vec2(-0.222485, -0.2247291),
                                     vec2(-0.7836896, -0.5882354),
                                     vec2(-0.2810118, -0.1376855),
                                     vec2(-0.9514924, -0.1214282),
                                     vec2(0.2808019, -0.2283967),
                                     vec2(0.1059831, -0.1517286),
                                     vec2(0.301801, -0.3296285),
                                     vec2(-0.2445912, -0.03123893),
                                     vec2(-0.161938, -0.09983041),
                                     vec2(0.4451636, -0.2420286),
                                     vec2(0.6177441, -0.2494904),
                                     vec2(0.7318987, -0.3284208),
                                     vec2(0.7867696, -0.2420232),
                                     vec2(0.8153236, -0.4052573),
                                     vec2(0.8843613, -0.264329),
                                     vec2(-0.00229197, -0.05696198),
                                     vec2(-0.09635602, 0.08454991),
                                     vec2(-0.9292479, 0.05352603),
                                     vec2(-0.8321502, 0.01495203),
                                     vec2(-0.7348551, 0.07829034),
                                     vec2(-0.193631, 0.05622597),
                                     vec2(-0.3817181, -0.1070937),
                                     vec2(-0.3595598, 0.05719875),
                                     vec2(0.712276, -0.1465105),
                                     vec2(0.5674382, -0.06977327),
                                     vec2(0.03386426, 0.1189729),
                                     vec2(0.1788138, -0.04723169),
                                     vec2(0.1040713, 0.03609258),
                                     vec2(-0.569949, 0.1214637),
                                     vec2(-0.721159, 0.1974564),
                                     vec2(-0.7973312, 0.2668945),
                                     vec2(-0.5474234, 0.0109362),
                                     vec2(0.2180393, 0.1414685),
                                     vec2(0.1579315, 0.228581),
                                     vec2(-0.04424897, 0.23032),
                                     vec2(0.4300061, -0.09265975),
                                     vec2(0.5289854, -0.184935),
                                     vec2(0.3245598, -0.1305346),
                                     vec2(0.2996997, -0.00080162),
                                     vec2(0.3287827, 0.2064073),
                                     vec2(0.209101, 0.4146921),
                                     vec2(0.04156134, 0.3408165),
                                     vec2(0.28958, 0.3264798),
                                     vec2(-0.9228035, 0.187646),
                                     vec2(-0.6615269, 0.2966316),
                                     vec2(-0.7703046, 0.3749933),
                                     vec2(-0.8844319, 0.3460503),
                                     vec2(-0.08957069, 0.3777975),
                                     vec2(-0.1437021, 0.2932427),
                                     vec2(0.07078929, 0.4923054),
                                     vec2(-0.2759329, 0.1167137),
                                     vec2(0.5923803, 0.101566),
                                     vec2(0.457482, 0.08178765),
                                     vec2(0.6891469, -0.00306648),
                                     vec2(-0.8147062, 0.1424928),
                                     vec2(0.2488723, 0.5964142),
                                     vec2(0.3650027, 0.5276645),
                                     vec2(0.3942295, 0.4274891),
                                     vec2(0.1791255, 0.5138983),
                                     vec2(0.1131059, 0.6167271),
                                     vec2(0.7146797, 0.1158792),
                                     vec2(0.8086658, 0.02043193),
                                     vec2(-0.03414515, 0.4668858),
                                     vec2(-0.8571717, 0.4855226),
                                     vec2(-0.707948, 0.509567),
                                     vec2(-0.7782653, 0.6083164),
                                     vec2(0.6008161, 0.275326),
                                     vec2(0.8689805, 0.1892055),
                                     vec2(0.7013124, 0.2158892),
                                     vec2(0.7479842, 0.3057784),
                                     vec2(-0.6196709, 0.5650395),
                                     vec2(-0.5717591, 0.4584886),
                                     vec2(-0.6682162, 0.7286317),
                                     vec2(0.837853, -0.1029543),
                                     vec2(0.96546, -0.1640923),
                                     vec2(0.3526091, 0.09202164),
                                     vec2(-0.5646175, 0.6842291),
                                     vec2(-0.4719306, 0.7294176),
                                     vec2(-0.4208826, 0.175825),
                                     vec2(-0.4139594, -0.9041284),
                                     vec2(-0.5723238, 0.2394826),
                                     vec2(-0.5077325, 0.3716691),
                                     vec2(0.9620602, 0.1209726),
                                     vec2(0.9259917, 0.2845874),
                                     vec2(0.8684493, 0.3833033),
                                     vec2(0.01760844, 0.7894553),
                                     vec2(-0.00332467, 0.5757815),
                                     vec2(0.1388087, 0.767468),
                                     vec2(0.02823113, 0.6725987),
                                     vec2(-0.5564942, 0.8044108),
                                     vec2(-0.4678927, 0.6241901),
                                     vec2(0.5093907, 0.5000951),
                                     vec2(0.3889523, 0.6970169),
                                     vec2(0.4996837, 0.6017337),
                                     vec2(0.4321092, 0.2044095),
                                     vec2(-0.2734853, 0.5783554),
                                     vec2(-0.4053446, 0.5245019),
                                     vec2(-0.3688903, 0.6702062),
                                     vec2(-0.655607, 0.3998039),
                                     vec2(0.9495975, 0.01584288),
                                     vec2(0.8231404, 0.47525),
                                     vec2(0.6992897, 0.4347586),
                                     vec2(-0.3959191, 0.309792),
                                     vec2(-0.3130451, 0.2349889),
                                     vec2(0.147981, 0.3291484),
                                     vec2(-0.4310413, 0.8357656),
                                     vec2(-0.3203937, 0.8269374),
                                     vec2(-0.3844733, 0.4126593),
                                     vec2(-0.2666597, 0.4527372),
                                     vec2(-0.2879404, 0.3341098),
                                     vec2(0.01346299, 0.9064359),
                                     vec2(0.2652203, 0.8813863),
                                     vec2(0.2897554, 0.7522234),
                                     vec2(0.1488808, 0.9288996),
                                     vec2(0.6455848, 0.5683564),
                                     vec2(0.5777688, 0.6928319),
                                     vec2(-0.1872719, 0.191142),
                                     vec2(-0.09118005, 0.8416157),
                                     vec2(-0.131365, 0.656777),
                                     vec2(0.527427, 0.3719428),
                                     vec2(0.3832047, 0.8435738),
                                     vec2(-0.1792916, 0.8916299),
                                     vec2(-0.2196967, 0.7723015),
                                     vec2(0.4897658, 0.7962251),
                                     vec2(0.7464077, 0.5564684),
                                     vec2(0.7181923, 0.6609709),
                                     vec2(-0.4721335, 0.08780513),
                                     vec2(-0.1142876, 0.5412015),
                                     vec2(-0.02930278, 0.9983991),
                                     vec2(-0.0766276, 0.742333),
                                     vec2(0.91249, -0.3635237),
                                     vec2(0.4179139, 0.3147621),
                                     vec2(-0.3020974, 0.9318075),
                                     vec2(-0.1900815, 0.3859279));

// This has way too much acne
// int poissonDiskCount = 35;
// vec2 poissonDisk[35] = vec2[](
//   vec2(-0.05151585f, 0.3436534f),
//   vec2(0.3648908f, 0.2827295f),
//   vec2(-0.2478754f, 0.186921f),
//   vec2(0.1171809f, 0.1482293f),
//   vec2(-0.1496224f, 0.6990415f),
//   vec2(-0.456594f, 0.378567f),
//   vec2(-0.4242465f, -0.001935145f),
//   vec2(-0.1889321f, -0.2015685f),
//   vec2(0.1480272f, 0.6432338f),
//   vec2(-0.5046303f, 0.8245607f),
//   vec2(0.001617888f, 0.9789896f),
//   vec2(-0.6228038f, 0.5963655f),
//   vec2(0.4185582f, 0.7959766f),
//   vec2(0.06965782f, -0.1184023f),
//   vec2(-0.8310863f, 0.2197417f),
//   vec2(-0.869589f, 0.4893173f),
//   vec2(-0.6366982f, -0.357598f),
//   vec2(-0.2509329f, -0.5531961f),
//   vec2(-0.03994134f, -0.4170877f),
//   vec2(-0.675245f, -0.0009701257f),
//   vec2(0.3373009f, -0.4531572f),
//   vec2(0.3022793f, -0.02336982f),
//   vec2(0.6078352f, 0.5235748f),
//   vec2(-0.9277961f, -0.05385896f),
//   vec2(0.3847639f, -0.7718652f),
//   vec2(0.5278201f, -0.168486f),
//   vec2(0.1269102f, -0.8461399f),
//   vec2(0.7260014f, -0.4588331f),
//   vec2(-0.8775687f, -0.450681f),
//   vec2(-0.574103f, -0.7766181f),
//   vec2(0.6930821f, 0.2592674f),
//   vec2(-0.3360346f, -0.8594083f),
//   vec2(-0.2591985f, 0.9300818f),
//   vec2(0.939391f, -0.2374034f),
//   vec2(0.8332635f, 0.01952092f)
// );

bool debug = false;

// Varying.
varying vec4 vPos;
varying vec3 worldNormal;
varying vec3 worldPos;

// Global directional light uniforms.
uniform vec4 dirLightDir;
uniform vec4 dirLightColor;
uniform vec4 dirLightAmbient;
uniform vec4 dirShadowColor;

// Misc uniforms.
uniform vec3 camPos;
uniform mat4 obj2World;
uniform mat4 world2Cam;

uniform int isParticle;
uniform int doColorMultiply;
uniform int glow;

uniform sampler2DArray stex;
uniform sampler2D tex;

// Surface calculations, including specular power.
varying vec2 texCoord;
vec4 viewDelta;
float specular;
float NdotL;
vec3 reflectVec;

void calculateSurface(vec4 color, inout vec4 albedo)
{
   viewDelta.xyz = worldPos - camPos;
   viewDelta.w   = length(viewDelta.xyz);
   viewDelta.xyz = -normalize(viewDelta.xyz);

   vec4 texAlbedo = texture2D(tex, texCoord);
   albedo.rgb = mix(color.rgb, texAlbedo.rgb, texAlbedo.a);

   if(doColorMultiply == 1)
      albedo *= gl_Color;

   albedo.a = color.a;

   NdotL = max(dot(worldNormal, dirLightDir.xyz), 0.0f);
   reflectVec = normalize(reflect(-dirLightDir.xyz, worldNormal));
   specular = pow(max(dot(reflectVec, viewDelta.xyz), 0.0f), 12.0f) * length(texAlbedo.rgb); //change this to change the size of the sun specular reflection

   //Uncomment below line for a neat rainbow color effect on everything
   //albedo.rgb = normalize(viewDelta.xyz);
}

// Fogging.
uniform vec4 fogBaseColor;
uniform vec4 fogConsts;
uniform sampler2D fogTex;
varying vec2 fogCoords;
void applyFog(inout vec4 albedo)
{
   // Calculate fog.
   vec4 fogColor = texture2D(fogTex, fogCoords) * fogBaseColor;

   // Blend it.
   albedo = mix(albedo, fogColor, fogColor.a);
}

// Shadowing
uniform vec4 far_d;
uniform vec2 texSize; // x - size, y - 1/size
uniform vec4 zScale;
uniform int shadowSplitCount;
void calculateShadowCoords(inout vec4 shadow_coordA, inout vec4 shadow_coordB, out float blend)
{
   int index = 3;
   float fudgeFactorA = 0.0f;
   float fudgeFactorB = 0.0f;
   fudgeFactorA = fudgeFactor4 / zScale.w;
   fudgeFactorB = fudgeFactor4 / zScale.w;
   blend = 0.0f;

   // find the appropriate depth map to look up in based on the depth of this fragment
   if(vPos.y < far_d.x)
   {
      index = 0;
      if(shadowSplitCount > 1)
         blend = clamp( (vPos.y - (far_d.x * blendAlpha)) / (far_d.x * blendBeta), 0.0f, 1.0f);
      fudgeFactorA = fudgeFactor1 / zScale.x;
      fudgeFactorB = fudgeFactor2 / zScale.y;
   }
   else if(vPos.y < far_d.y)
   {
      index = 1;
      if(shadowSplitCount > 2)
         blend = clamp( (vPos.y - (far_d.y * blendAlpha)) / (far_d.x * blendBeta), 0.0f, 1.0f);
      fudgeFactorA = fudgeFactor2 / zScale.y;
      fudgeFactorB = fudgeFactor3 / zScale.z;
   }
   else if(vPos.y < far_d.z)
   {
      index = 2;
      if(shadowSplitCount > 3)
         blend = clamp( (vPos.y - (far_d.z * blendAlpha)) / (far_d.x * blendBeta), 0.0f, 1.0f);
      fudgeFactorA = fudgeFactor3 / zScale.z;
      fudgeFactorB = fudgeFactor4 / zScale.w;
   }

   // transform this fragment's position from view space to scaled light clip space
   // such that the xy coordinates are in [0;1]
   // note there is no need to divide by w for orthogonal light sources
   shadow_coordA   = gl_TextureMatrix[index]*vPos;
   shadow_coordA.w = shadow_coordA.z - fudgeFactorA; // Figure the input coordinate for PCF sampling if appropriate.
   shadow_coordA.z = float(index);                   // Encode the layer to sample.

   //don't have to set second shadow coord if we're not blending
   if(blend > 0.0f)
   {
      shadow_coordB   = gl_TextureMatrix[index + 1]*vPos;
      shadow_coordB.w = shadow_coordB.z - fudgeFactorB;
      shadow_coordB.z = float(index + 1);
   }
}

// Point lighting
uniform vec4     pointLightPos0;
uniform vec4   pointLightColor0;
uniform float pointLightRadius0;

uniform vec4     pointLightPos1;
uniform vec4   pointLightColor1;
uniform float pointLightRadius1;

uniform vec4     pointLightPos2;
uniform vec4   pointLightColor2;
uniform float pointLightRadius2;

uniform vec4     pointLightPos3;
uniform vec4   pointLightColor3;
uniform float pointLightRadius3;

uniform vec4     pointLightPos4;
uniform vec4   pointLightColor4;
uniform float pointLightRadius4;

uniform vec4     pointLightPos5;
uniform vec4   pointLightColor5;
uniform float pointLightRadius5;

uniform vec4     pointLightPos6;
uniform vec4   pointLightColor6;
uniform float pointLightRadius6;

uniform vec4     pointLightPos7;
uniform vec4   pointLightColor7;
uniform float pointLightRadius7;

vec4 accumulatePointLights()
{
   vec4 pointLightTotal = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   vec3 lightDelta = vec3(0.0f, 0.0f, 0.0f);
   float lightDot = 0.0f;
   float ratio = 0.0f;

   // Calculate effects of the 8 point lights.

   lightDelta = worldPos.xyz - pointLightPos0.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius0);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor0.xyz;

   lightDelta = worldPos.xyz - pointLightPos1.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius1);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor1.xyz;

   lightDelta = worldPos.xyz - pointLightPos2.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius2);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor2.xyz;

   lightDelta = worldPos.xyz - pointLightPos3.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius3);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor3.xyz;

   lightDelta = worldPos.xyz - pointLightPos4.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius4);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor4.xyz;

   lightDelta = worldPos.xyz - pointLightPos5.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius5);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor5.xyz;

   lightDelta = worldPos.xyz - pointLightPos6.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius6);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor6.xyz;

   lightDelta = worldPos.xyz - pointLightPos7.xyz;
   lightDot = max(dot(-normalize(lightDelta), worldNormal), 0.0f);
   ratio = 1.0f - (length(lightDelta) / pointLightRadius7);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * lightDot * pointLightColor7.xyz;

   return pointLightTotal;
}

vec4 accumulateParticlePointLights()
{
   vec4 pointLightTotal = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   vec3 lightDelta = vec3(0.0f, 0.0f, 0.0f);
   float ratio = 0.0f;

   // Calculate effects of the 8 point lights.

   lightDelta = worldPos.xyz - pointLightPos0.xyz;
   ratio = 1.0f - (length(lightDelta) / pointLightRadius0);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * pointLightColor0.xyz;

   lightDelta = worldPos.xyz - pointLightPos1.xyz;
   ratio = 1.0f - (length(lightDelta) / pointLightRadius1);
   ratio = ratio * ratio * ratio * 0.4f;
   ratio = max(ratio, 0.0f);
   pointLightTotal.xyz += ratio * pointLightColor1.xyz;

   return pointLightTotal;
}

// Combine specular and direct lighting terms.
// note: if we make combinedColor "out" only, it throws a potentially uninitialized value warning, so we've made it inout
void applyLighting(inout vec4 combinedColor, vec4 albedo, float occlusionFactor)
{
   //large normal means glowing object
   if(glow == 1 || (worldNormal.x + worldNormal.y + worldNormal.z) > 2.0f)
   {
      combinedColor = superGlow ? vec4(albedo.xyz * 1.5f, albedo.a) : albedo;
      return;
   }

   vec4 dirLightSpecular = occlusionFactor * specular * dirLightColor;
   dirLightSpecular *= 0.5f; //arbitrary adjustment
   vec4 dirLightDirect = ((NdotL * dirLightColor) * occlusionFactor) + (dirLightAmbient * occlusionFactor) + (dirShadowColor * (1.0f - occlusionFactor));

   if(NdotL <= 0.04f)
   {
      dirLightDirect = dirShadowColor;
      dirLightSpecular = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   }
   else if(NdotL <= 0.1)
   {
      float val = (NdotL - 0.04f) / (0.1f - 0.04f);
      dirLightDirect = (dirLightDirect * val) + (dirShadowColor * (1.0f - val));
      dirLightSpecular = dirLightSpecular * val;
   }

   dirLightDirect += accumulatePointLights();

   dirLightSpecular.a = length(dirLightSpecular.rgb);
   dirLightDirect.a *= min(occlusionFactor + 0.75f, 1.0f);
   combinedColor.rgb = dirLightDirect.rgb * albedo.rgb;
   combinedColor.a = albedo.a;
   combinedColor += dirLightSpecular;
}

float poissonSample(vec4 shadow_coord, float spread)
{
  int hit = 0;

  for (int i = 0; i < poissonDiskCount; i++) {
    float dist = texture2DArray(stex, vec3(shadow_coord.xy + poissonDisk[i] * spread, shadow_coord.z)).x;

    if (dist - shadow_coord.w > 0.0f)
      hit++;
  }

  return float(hit) / poissonDiskCount;
}

float distanceCalc(vec4 shadow_coord, int loopNumber, float searchDistance, float lightSize)
{
    //if (!PCSSToggle)
        //return 1.0f;
    //return 1.0f / 4096.0f;
    //if (!PCSSToggle)
        //return sampleDistance;
    float pcfDepth;
    int loop; // 3x3, 5x5, 7x7...
    // no loop..
    //for (int = 0; i < 9; i++)
    for (int x = -loopNumber; x <= loopNumber; x++)
    {
        for (int y = -loopNumber; y <= loopNumber; y++)
        {
            pcfDepth += texture2DArray(stex, vec3(shadow_coord.xy + vec2(x, y)  * searchDistance, shadow_coord.z)).x - shadow_coord.w;
            //pcfDepth += texture2DArray(stex, vec3(shadow_coord.xy + vec2(x, y) * texSize.y * 4.0f * shadow_coord.xy, shadow_coord.z)).x - shadow_coord.w;
            //pcfDepth += texture2DArray(stex, vec3(shadow_coord.xy + vec2(x, y) * texSize.y * 4.0f * shadow_coord.w, shadow_coord.z)).x - shadow_coord.w;
            //pcfDepth += texture2DArray(stex, vec3(shadow_coord.xy + vec2(x, y) * texSize.y * 1.0f, shadow_coord.z)).x - shadow_coord.w;
            loop++;
        }
    }

    pcfDepth /= loop;

    return pcfDepth * lightSize;
    //return =
    // lol
}

// not having parenthesis around the ultra mode samples looks bad thanks to order of operations; the code could probably be put back into (PCSSToggle) ? ((ultraMode) ? (true) : (false)) : ((ultraMode) ? (true) : (false)) form but this looks better
float shadowCoef()
{
    vec4 shadow_coordA = vec4(0.0f, 0.0f, 0.0f, 0.0f);
    vec4 shadow_coordB = vec4(0.0f, 0.0f, 0.0f, 0.0f);

    float blend = 0.0f;

    calculateShadowCoords(shadow_coordA, shadow_coordB, blend);

    float sampleA;

    //sampleA = ultraMode ? (poissonSample(shadow_coordA, normalSampleDistance) + poissonSample(shadow_coordA, ambientSampleDistance)) / 2 : poissonSample(shadow_coordA, normalSampleDistance * distanceCalc(shadow_coordA, lightSize));
    //if (PCSSToggle)
        //sampleA = PCSSToggle ? (ultraMode && PCSSToggle ?  :  : (ultraMode && !PCSSToggle ? ( : );
    //if (!PCSSToggle)
        //sampleA = ultraMode ? (poissonSample(shadow_coordA, sampleDistance) + poissonSample(shadow_coordA, sampleDistance * ultraRatio)) / 2 : poissonSample(shadow_coordA, sampleDistance);
    if (PCSSToggle == ultraMode == true)
    {
        sampleA = (poissonSample(shadow_coordA, pow(distanceCalc(shadow_coordA, depthLoopNumber, searchDistance, lightSize), 1)) + poissonSample(shadow_coordA, pow(distanceCalc(shadow_coordA, depthLoopNumber, searchDistance * ultraRatio, lightSize * ultraRatio), 1))) / 2;
    }
    else if (PCSSToggle == true && ultraMode == false)
    {
        sampleA = poissonSample(shadow_coordA, pow(distanceCalc(shadow_coordA, depthLoopNumber, searchDistance, lightSize), 1));
    }
    else if (PCSSToggle == false && ultraMode == true)
    {
        sampleA = (poissonSample(shadow_coordA, sampleDistance) + poissonSample(shadow_coordA, sampleDistance * ultraRatio)) / 2;
    }
    else if (PCSSToggle == ultraMode == false)
    {
        sampleA = poissonSample(shadow_coordA, sampleDistance);
    }

    if (blend > 0.0f)
    {
        float sampleB;

        //sampleB = ultraMode ? (poissonSample(shadow_coordB, normalSampleDistance) + poissonSample(shadow_coordB, ambientSampleDistance)) / 2 : poissonSample(shadow_coordB, normalSampleDistance * distanceCalc(shadow_coordA, lightSize));
        //sampleB = ultraMode ? (poissonSample(shadow_coordB, normalSampleDistance) + poissonSample(shadow_coordB, ambientSampleDistance)) / 2 : poissonSample(shadow_coordB, distanceCalc(shadow_coordB, depthLoopNumber, lightSize)) * distanceScale;
        //if (PCSSToggle)
        //  sampleB = PCSSToggle ? (ultraMode && PCSSToggle ? (poissonSample(shadow_coordB, pow(distanceCalc(shadow_coordB, depthLoopNumber, searchDistance, lightSize), 1)) + poissonSample(shadow_coordB, pow(distanceCalc(shadow_coordB, depthLoopNumber, searchDistance * ultraRatio, lightSize * ultraRatio), 1)) / 2) : poissonSample(shadow_coordB, pow(distanceCalc(shadow_coordB, depthLoopNumber, searchDistance, lightSize), 1))) : (ultraMode && !PCSSToggle ? (poissonSample(shadow_coordB, sampleDistance) + poissonSample(shadow_coordB, sampleDistance * ultraRatio) / 2) : poissonSample(shadow_coordB, sampleDistance));
        //if (!PCSSToggle)
        if (PCSSToggle == ultraMode == true)
        {
        sampleB = (poissonSample(shadow_coordB, pow(distanceCalc(shadow_coordB, depthLoopNumber, searchDistance, lightSize), 1)) + poissonSample(shadow_coordB, pow(distanceCalc(shadow_coordB, depthLoopNumber, searchDistance * ultraRatio, lightSize * ultraRatio), 1))) / 2;
        }
        else if (PCSSToggle == true && ultraMode == false)
        {
            sampleB = poissonSample(shadow_coordB, pow(distanceCalc(shadow_coordB, depthLoopNumber, searchDistance, lightSize), 1));
        }
        else if (PCSSToggle == false && ultraMode == true)
        {
            sampleB = (poissonSample(shadow_coordB, sampleDistance) + poissonSample(shadow_coordB, sampleDistance * ultraRatio)) / 2;
        }
        else if (PCSSToggle == ultraMode == false)
        {
            sampleB = poissonSample(shadow_coordB, sampleDistance);
        }

        return clamp((sampleB * blend) + (sampleA * (1.0f - blend)), 0.0f, 1.0f);
    }

    return sampleA;
}

void main()
{
   vec4 albedo = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   calculateSurface(gl_Color, albedo);

   float occlusionFactor = 0.0f;
   if(NdotL > -0.01f)
   {
      if(shadowSplitCount <= 0)
         occlusionFactor = 1.0f;
      else
         occlusionFactor = shadowCoef();
   }

   // Apply lighting and fog.
   vec4 fragColor = vec4(0.0f, 0.0f, 0.0f, 0.0f);
   if(isParticle == 1)
   {
      vec4 texAlbedo = texture2D(tex, texCoord);

      vec4 dirLightDirect = (dirLightColor * occlusionFactor) + (dirLightAmbient * occlusionFactor) + (dirShadowColor * (1.0f - occlusionFactor));
      vec4 plt = accumulateParticlePointLights();

      vec4 lightTotal = dirLightDirect + plt;
      lightTotal.x = clamp(lightTotal.x, 0.0f, 1.2f);
      lightTotal.y = clamp(lightTotal.y, 0.0f, 1.2f);
      lightTotal.z = clamp(lightTotal.z, 0.0f, 1.2f);

      fragColor = texAlbedo * gl_Color * lightTotal;

      applyFog(fragColor);
      fragColor.a = texAlbedo.a * gl_Color.a;
   }
   else
   {
        if (shadowOpacity)
            applyLighting(fragColor, albedo, 1 - (1 - occlusionFactor) * occlusionBlend);
        else
            applyLighting(fragColor, albedo, occlusionFactor);
        applyFog(fragColor);
   }

   // Uncomment to viz depth in B.
   //fragColor.z = vPos.y * 0.01f;

   gl_FragColor = fragColor;

   // Uncomment to show shadows only
   if (debug)
        gl_FragColor = vec4(occlusionFactor, occlusionFactor, occlusionFactor, 1);
}