nmg_common_lighting.glinc

NmgCommon
{




//
// Lighting Functions
//




  lowp vec3 CalculateLighting1 (lowp vec3 normal, lowp float shadowAttenuation, lowp vec4 ambient, lowp vec4 lightDirectionMS, lowp vec4 lightColour)
  {
      lowp float diffuseScale;
      lowp vec3 diffuseColour;

    diffuseScale = dot (normal, lightDirectionMS.xyz);
      diffuseScale = max (diffuseScale, 0.0);
      
      diffuseScale *= shadowAttenuation;

      diffuseColour.rgb  = (lightColour.rgb * diffuseScale);

    lowp vec3 result;
    result = ambient.xyz + diffuseColour.xyz;
    
    return result;
  }





  lowp vec3 CalculateLighting2 (lowp vec3 normal, lowp vec2 shadowAttenuations, lowp vec4 ambient, lowp vec4 lightDirectionMS [2], lowp vec4 lightColour [2])
  {
      lowp vec2 diffuseScales;
      lowp vec3 diffuseColour;

    diffuseScales.x = dot (normal, lightDirectionMS [0].xyz);
    diffuseScales.y = dot (normal, lightDirectionMS [1].xyz);
      diffuseScales = max (diffuseScales, 0.0);

      diffuseScales.xy *= shadowAttenuations.xy;

      diffuseColour.rgb  = (lightColour [0].rgb * diffuseScales.x);
      diffuseColour.rgb += (lightColour [1].rgb * diffuseScales.y);

    lowp vec3 result;
    result = ambient.xyz + diffuseColour.xyz;

    return result;
  }





  lowp vec3 CalculateLighting3 (lowp vec3 normal, lowp vec3 shadowAttenuations, lowp vec4 ambient, lowp vec4 lightDirectionMS [3], lowp vec4 lightColour [3])
  {
      lowp vec3 diffuseScales;
      lowp vec3 diffuseColour;

    diffuseScales.x = dot (normal, lightDirectionMS [0].xyz);
    diffuseScales.y = dot (normal, lightDirectionMS [1].xyz);
    diffuseScales.z = dot (normal, lightDirectionMS [2].xyz);
      diffuseScales = max (diffuseScales, 0.0);

      diffuseScales.xyz *= shadowAttenuations.xyz;

      diffuseColour.rgb  = (lightColour [0].rgb * diffuseScales.x);
      diffuseColour.rgb += (lightColour [1].rgb * diffuseScales.y);
      diffuseColour.rgb += (lightColour [2].rgb * diffuseScales.z);

    lowp vec3 result;
    result = ambient.xyz + diffuseColour.xyz;

    return result;
  }





  lowp vec3 CalculateLighting4 (lowp vec3 normal, lowp vec4 shadowAttenuations, lowp vec4 ambient, lowp vec4 lightDirectionMS [4], lowp vec4 lightColour [4])
  {
      lowp vec4 diffuseScales;
      lowp vec3 diffuseColour;

    diffuseScales.x = dot (normal, lightDirectionMS [0].xyz);
    diffuseScales.y = dot (normal, lightDirectionMS [1].xyz);
    diffuseScales.z = dot (normal, lightDirectionMS [2].xyz);
    diffuseScales.w = dot (normal, lightDirectionMS [3].xyz);
      diffuseScales = max (diffuseScales, 0.0);
      
      diffuseScales.xyzw *= shadowAttenuations.xyzw;

      diffuseColour.rgb  = (lightColour [0].rgb * diffuseScales.x);
      diffuseColour.rgb += (lightColour [1].rgb * diffuseScales.y);
      diffuseColour.rgb += (lightColour [2].rgb * diffuseScales.z);
      diffuseColour.rgb += (lightColour [3].rgb * diffuseScales.w);

    lowp vec3 result;
    result = ambient.xyz + diffuseColour.xyz;
    
    return result;
  }





  lowp float CalculateLightAttenuations1 (highp vec3 position, lowp vec4 lightPos, lowp vec4 lightDirectionMS, mediump float lightCosMax, mediump float lightCosMul)
  {
    highp vec3 toLight0 = lightPos.xyz - position.xyz;
    lowp vec3 lightDir0 = normalize (toLight0);
    lowp float attenuations = 1.0;
    mediump float r0 = dot (lightDir0, lightDirectionMS.xyz);
    mediump float factor = clamp ((lightCosMax - r0) * lightCosMul, 0.0, 1.0);
    attenuations -= factor;

    return attenuations;
  }





  lowp vec2 CalculateLightAttenuations2 (highp vec3 position, lowp vec4 lightPos [2], lowp vec4 lightDirectionMS [2], mediump vec2 lightCosMax, mediump vec2 lightCosMul)
  {
    highp vec3 toLight0 = lightPos [0].xyz - position.xyz;
    highp vec3 toLight1 = lightPos [1].xyz - position.xyz;
    lowp vec3 lightDir0 = normalize (toLight0);
    lowp vec3 lightDir1 = normalize (toLight1);
    lowp vec2 attenuations = vec2 (1.0, 1.0);
    mediump float r0 = dot (lightDir0, lightDirectionMS [0].xyz);
    mediump float r1 = dot (lightDir1, lightDirectionMS [1].xyz);
    mediump vec2 r = vec2 (r0, r1);
    mediump vec2 factor = clamp ((lightCosMax - r) * lightCosMul, vec2 (0.0, 0.0), vec2 (1.0, 1.0));
    attenuations -= factor;

    return attenuations;
  }





  lowp vec3 CalculateLightAttenuations3 (highp vec3 position, lowp vec4 lightPos [3], lowp vec4 lightDirectionMS [3], mediump vec3 lightCosMax, mediump vec3 lightCosMul)
  {
    highp vec3 toLight0 = lightPos [0].xyz - position.xyz;
    highp vec3 toLight1 = lightPos [1].xyz - position.xyz;
    highp vec3 toLight2 = lightPos [2].xyz - position.xyz;
    lowp vec3 lightDir0 = normalize (toLight0);
    lowp vec3 lightDir1 = normalize (toLight1);
    lowp vec3 lightDir2 = normalize (toLight2);
    lowp vec3 attenuations = vec3 (1.0, 1.0, 1.0);
    mediump float r0 = dot (lightDir0, lightDirectionMS [0].xyz);
    mediump float r1 = dot (lightDir1, lightDirectionMS [1].xyz);
    mediump float r2 = dot (lightDir2, lightDirectionMS [2].xyz);
    mediump vec3 r = vec3 (r0, r1, r2);
    mediump vec3 factor = clamp ((lightCosMax - r) * lightCosMul, vec3 (0.0, 0.0, 0.0), vec3 (1.0, 1.0, 1.0));
    attenuations -= factor;

    return attenuations;
  }





  lowp vec4 CalculateLightAttenuations4 (highp vec3 position, lowp vec4 lightPos [4], lowp vec4 lightDirectionMS [4], mediump vec4 lightCosMax, mediump vec4 lightCosMul)
  {
    highp vec3 toLight0 = lightPos [0].xyz - position.xyz;
    highp vec3 toLight1 = lightPos [1].xyz - position.xyz;
    highp vec3 toLight2 = lightPos [2].xyz - position.xyz;
    highp vec3 toLight3 = lightPos [3].xyz - position.xyz;
    lowp vec3 lightDir0 = normalize (toLight0);
    lowp vec3 lightDir1 = normalize (toLight1);
    lowp vec3 lightDir2 = normalize (toLight2);
    lowp vec3 lightDir3 = normalize (toLight3);
    lowp vec4 attenuations = vec4 (1.0, 1.0, 1.0, 1.0);
    mediump float r0 = dot (lightDir0, lightDirectionMS [0].xyz);
    mediump float r1 = dot (lightDir1, lightDirectionMS [1].xyz);
    mediump float r2 = dot (lightDir2, lightDirectionMS [2].xyz);
    mediump float r3 = dot (lightDir3, lightDirectionMS [3].xyz);
    mediump vec4 r = vec4 (r0, r1, r2, r3);
    mediump vec4 factor = clamp ((lightCosMax - r) * lightCosMul, vec4 (0.0, 0.0, 0.0, 0.0), vec4 (1.0, 1.0, 1.0, 1.0));
    attenuations -= factor;

    return attenuations;
  }





  highp vec4 CalculateDiffuse1 (lowp vec3 normalIn, lowp vec3 lightDirection, mediump vec4 lightColour, highp vec3 diffuseFalloffParams)
  {
    highp vec4 diffuseColour = vec4 (0.0, 0.0, 0.0, 0.0);
    highp vec3 normal = normalIn;

    highp vec3 lightDir = lightDirection;
    highp vec4 lightCol = lightColour;

    highp float diffuseScale = -dot (normal, lightDir);

    diffuseScale = max (0.0, (diffuseScale * diffuseFalloffParams.x + diffuseFalloffParams.y) * diffuseScale + diffuseFalloffParams.z);

    diffuseColour += lightCol * diffuseScale;

    highp vec4 result = vec4 (diffuseColour.rgb, diffuseColour.a);

    return result;
  }





  highp vec4 CalculateDiffuse2 (lowp vec3 normalIn, lowp vec3 lightDirection [2], mediump vec4 lightColour [2], highp vec3 diffuseFalloffParams)
  {
    highp vec4 diffuseColour = vec4 (0.0, 0.0, 0.0, 0.0);
    highp vec3 normal = normalIn;

    for (int i = 0; i < 2; i ++)
    {
      highp vec3 lightDir = lightDirection [i];
      highp vec4 lightCol = lightColour [i];
      highp float diffuseScale = -dot (normal, lightDir);

      diffuseScale = max (0.0, (diffuseScale * diffuseFalloffParams.x + diffuseFalloffParams.y) * diffuseScale + diffuseFalloffParams.z);

      diffuseColour += lightCol * diffuseScale;
    }

    highp vec4 result = vec4 (diffuseColour.rgb, diffuseColour.a);

    return result;
  }





  highp vec4 CalculateDiffuse3 (lowp vec3 normalIn, lowp vec3 lightDirection [3], mediump vec4 lightColour [3], highp vec3 diffuseFalloffParams)
  {
    highp vec4 diffuseColour = vec4 (0.0, 0.0, 0.0, 0.0);
    highp vec3 normal = normalIn;

    for (int i = 0; i < 3; i ++)
    {
      highp vec3 lightDir = lightDirection [i];
      highp vec4 lightCol = lightColour [i];
      highp float diffuseScale = -dot (normal, lightDir);

      diffuseScale = max (0.0, (diffuseScale * diffuseFalloffParams.x + diffuseFalloffParams.y) * diffuseScale + diffuseFalloffParams.z);

      diffuseColour += lightCol * diffuseScale;
    }

    highp vec4 result = vec4 (diffuseColour.rgb, diffuseColour.a);

    return result;
  }





  highp vec4 CalculateDiffuse4 (lowp vec3 normalIn, lowp vec3 lightDirection [4], mediump vec4 lightColour [4], highp vec3 diffuseFalloffParams)
  {
    highp vec4 diffuseColour = vec4 (0.0, 0.0, 0.0, 0.0);
    highp vec3 normal = normalIn;

    for (int i = 0; i < 4; i ++)
    {
      highp vec3 lightDir = lightDirection [i];
      highp vec4 lightCol = lightColour [i];
      highp float diffuseScale = -dot (normal, lightDir);

      diffuseScale = max (0.0, (diffuseScale * diffuseFalloffParams.x + diffuseFalloffParams.y) * diffuseScale + diffuseFalloffParams.z);

      diffuseColour += lightCol * diffuseScale;
    }

    highp vec4 result = vec4 (diffuseColour.rgb, diffuseColour.a);

    return result;
  }




 
  lowp vec4 CalculateSpecular1 (lowp vec3 normal, lowp vec3 lightDirection, mediump vec4 lightColour, highp float specPower)
  {                        
    lowp vec4 specColour = vec4 (0.0, 0.0, 0.0, 0.0);

    lowp float specScale = pow (max (-dot (normal, lightDirection), 0.0), specPower);

    specColour += lightColour * specScale;

    lowp float downwards = clamp (normal.y + 1.0, 0.0, 1.0);

    specColour *= downwards;

    return vec4 (specColour.rgb, specColour.a);
  }





  lowp vec4 CalculateSpecular2 (lowp vec3 normal, lowp vec3 lightDirection [2], mediump vec4 lightColour [2], highp float specPower)
  {                        
    lowp vec4 specColour = vec4 (0.0, 0.0, 0.0, 0.0);

    for (int i = 0; i < 2; i ++)
    {
      lowp float specScale = pow (max (-dot (normal, lightDirection [i]), 0.0), specPower);

      specColour += lightColour [i] * specScale;
    }

    lowp float downwards = clamp (normal.y + 1.0, 0.0, 1.0);

    specColour *= downwards;

    return vec4 (specColour.rgb, specColour.a);
  }





  lowp vec4 CalculateSpecular3 (lowp vec3 normal, lowp vec3 lightDirection [3], mediump vec4 lightColour [3], highp float specPower)
  {                        
    lowp vec4 specColour = vec4 (0.0, 0.0, 0.0, 0.0);

    for (int i = 0; i < 3; i ++)
    {
      lowp float specScale = pow (max (-dot (normal, lightDirection [i]), 0.0), specPower);

      specColour += lightColour [i] * specScale;
    }

    lowp float downwards = clamp (normal.y + 1.0, 0.0, 1.0);

    specColour *= downwards;

    return vec4 (specColour.rgb, specColour.a);
  }





  lowp vec4 CalculateSpecular4 (lowp vec3 normal, lowp vec3 lightDirection [4], mediump vec4 lightColour [4], highp float specPower)
  {                        
    lowp vec4 specColour = vec4 (0.0, 0.0, 0.0, 0.0);

    for (int i = 0; i < 4; i ++)
    {
      lowp float specScale = pow (max (-dot (normal, lightDirection [i]), 0.0), specPower);

      specColour += lightColour [i] * specScale;
    }

    lowp float downwards = clamp (normal.y + 1.0, 0.0, 1.0);

    specColour *= downwards;

    return vec4 (specColour.rgb, specColour.a);
  }





  mediump float AshikhminShirleyBRDF (mediump vec3 halfVec, mediump float LdH, mediump float NdH, mediump float NdL, mediump float VdH, mediump float NdV, mediump vec3 binormal, mediump vec3 tangent, mediump float nu, mediump float nv)
  {
    // specific to ashikhmin...
    // half and binormal
    mediump float HdB = dot (halfVec, normalize (binormal));
    // half and tangent
    mediump float HdT = dot (halfVec, normalize (tangent));    

    // Ashikhmin Shirley Anisotropic
    // only going to do specular term for now...
    mediump float Numer1 = sqrt ((nu + 1.0) * (nv + 1.0));
    mediump float N2Power = ((nu * HdB * HdB) + (nv * HdT * HdT)) / (1.001 - (NdH * NdH));
    mediump float Numer2 = pow (NdH, N2Power);

    mediump float Denom = LdH * max (NdL, NdV); // I replaced HdL
    mediump float Specular = (Numer1 * Numer2) / (8.0 * PI * Denom);

    Specular *= NdL;  

    return Specular;
  }





  mediump float BlinnPhong (mediump float NdH, mediump float power)
  {
    return (0.125 * (power + 2.0) * pow (NdH, power));
  }





  mediump float CookTorrence (mediump float NdH, mediump float NdV, mediump float NdL, mediump float VdH, mediump float RoughSq, mediump float gauss)
  {
    // Calculate Geometric Term (approximation)
    NdV = max (NdV, 0.00001); // partially fixed black artefact areas...an issue with view vector?

    mediump float G1 = (2.0 * NdH * NdV) / VdH;
    mediump float G2 = (2.0 * NdH * NdL) / VdH;
    mediump float G = min (1.0, min (G1, G2));

    mediump float angle = acos (NdH);
    // using N dot H, but need to check this is OK...
    mediump float D = gauss * exp (-(angle * angle) / RoughSq);

    return (G * D / (PI * NdV));
  }





  mediump float CookTorrenceGGXD (mediump float NdH, mediump float NdV, mediump float NdL, mediump float VdH, mediump float RoughSq, mediump float gauss)
  {
    // Calculate Geometric Term (approximation)
    NdV = max (NdV, 0.00001); // partially fixed black artefact areas...an issue with view vector?

    mediump float G1 = (2.0 * NdH * NdV) / VdH;
    mediump float G2 = (2.0 * NdH * NdL) / VdH;
    mediump float G = min (1.0, min (G1, G2));

    // Calculate Distribution Term
    mediump float Denom1 = (NdH * NdH * (RoughSq - 1.0) + 1.0);
    mediump float Denom1Sq = Denom1 * Denom1;
    mediump float D = 4.0 * clamp (RoughSq / (PI * Denom1Sq), 0.0, 1.0); // am scaling by 2 as GGX seems a bit weak

    return (G * D / (PI * NdV));
  }





  mediump float OrenNayar (mediump float VdN, mediump float LdN, mediump vec3 L, mediump vec3 V, mediump vec3 N, mediump float roughnessSquared)
  {  
    // Simplified version of Oren Nayar
    mediump float Aterm = 1.0 - 0.5 * (roughnessSquared / (roughnessSquared + 0.57));
    mediump float Bterm = 0.45 * (roughnessSquared / (roughnessSquared + 0.09));

    mediump float Alpha = max (acos (VdN), acos (LdN));
    mediump float Beta =  min (acos (VdN), acos (LdN));
    mediump float Gamma = dot (V - N * VdN, L - N * LdN);

    return (Aterm + Bterm * max (Gamma, 0.0) * sin (Alpha) * tan(Beta));
  }





  mediump float CalulateFresnelTerm (mediump float NdV, mediump float fresnelKR, mediump float fresnelMin, mediump float fresnelExp)
  {
    mediump float KrMin = (fresnelKR * fresnelMin);
    mediump float InvFresnelExp = (1.0 / fresnelExp);
    return (2.0 * mix (fresnelKR, KrMin, pow (abs (NdV), InvFresnelExp)));
  }





  mediump float CalulateFresnelTermSchlick (mediump float NdV, mediump float fresnelSchlickFactor)
  {
    mediump float f0 = fresnelSchlickFactor;

    return (f0 + (1.00 - f0) * pow ((1.0 - NdV), 5.0));
  }





}