//  Generated on <$_SCRIBE_DATE$>
//
//  Created by Sam Gateau on 7/5/16.
//  Copyright 2016 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//



<@func declareSkyboxMap()@>
// declareSkyboxMap
uniform samplerCube skyboxMap;

vec4 evalSkyboxLight(vec3 direction, float lod) {
    // textureQueryLevels is not available until #430, so we require explicit lod
    // float mipmapLevel = lod * textureQueryLevels(skyboxMap);
    float filterLod = textureQueryLod(skyboxMap, direction).x;
    // Keep texture filtering LOD as limit to prevent aliasing on specular reflection
    lod = max(lod, filterLod);
    return textureLod(skyboxMap, direction, lod);
}
<@endfunc@>

<@func declareEvalAmbientSpecularIrradiance(supportAmbientSphere, supportAmbientMap, supportIfAmbientMapElseAmbientSphere)@>

vec3 fresnelSchlickAmbient(vec3 fresnelColor, float ndotd, float gloss) {
    float f = pow(1.0 - ndotd, 5.0);
    return fresnelColor + (max(vec3(gloss), fresnelColor) - fresnelColor) * f;
//    return fresnelColor + (vec3(1.0) - fresnelColor) * f;
}

<@if supportAmbientMap@>
<$declareSkyboxMap()$>
<@endif@>

vec3 evalAmbientSpecularIrradiance(LightAmbient ambient, SurfaceData surface) {
    vec3 lightDir = -reflect(surface.eyeDir, surface.normal);
    vec3 specularLight;
    <@if supportIfAmbientMapElseAmbientSphere@>
        if (getLightHasAmbientMap(ambient))
            <@endif@>
            <@if supportAmbientMap@>
        {
            float levels = getLightAmbientMapNumMips(ambient);
            float m = 12.0 / (1.0+11.0*surface.roughness);
            float lod = levels - m;
            lod = max(lod, 0);
            specularLight = evalSkyboxLight(lightDir, lod).xyz;
        }
    <@endif@>
        <@if supportIfAmbientMapElseAmbientSphere@>
        else
        <@endif@>
        <@if supportAmbientSphere@>
    {
        specularLight = sphericalHarmonics_evalSphericalLight(getLightAmbientSphere(ambient), lightDir).xyz;
    }
    <@endif@>

    return specularLight;
}
<@endfunc@>

<@func declareLightingAmbient(supportAmbientSphere, supportAmbientMap, supportIfAmbientMapElseAmbientSphere, supportScattering)@>

<$declareEvalAmbientSpecularIrradiance($supportAmbientSphere$, $supportAmbientMap$, $supportIfAmbientMapElseAmbientSphere$)$>

<@if supportScattering@>
float curvatureAO(in float k) {
    return 1.0f - (0.0022f * k * k) + (0.0776f * k) + 0.7369f;
}
<@endif@>

void evalLightingAmbient(out vec3 diffuse, out vec3 specular, LightAmbient ambient, SurfaceData surface, 
                         float metallic, vec3 fresnelF0, vec3 albedo, float obscurance
<@if supportScattering@>
    , float scattering, vec4 midNormalCurvature, vec4 lowNormalCurvature
<@endif@>
    ) {

    // Fresnel
    vec3 ambientFresnel = fresnelSchlickAmbient(fresnelF0, surface.ndotv, 1.0-surface.roughness);

    // Diffuse from ambient
    diffuse = (1.0 - metallic) * (vec3(1.0) - ambientFresnel) * sphericalHarmonics_evalSphericalLight(getLightAmbientSphere(ambient), surface.normal).xyz;

    // Specular highlight from ambient
    specular = evalAmbientSpecularIrradiance(ambient, surface)  * ambientFresnel;

<@if supportScattering@>
    if (scattering * isScatteringEnabled() > 0.0) {
        float ambientOcclusion = curvatureAO(lowNormalCurvature.w * 20.0f) * 0.5f;
        float ambientOcclusionHF = curvatureAO(midNormalCurvature.w * 8.0f) * 0.5f;
        ambientOcclusion = min(ambientOcclusion, ambientOcclusionHF);

        obscurance = min(obscurance, ambientOcclusion);

        // Diffuse from ambient
        diffuse = sphericalHarmonics_evalSphericalLight(getLightAmbientSphere(ambient), lowNormalCurvature.xyz).xyz;
        diffuse /= 3.1415926;
        specular = vec3(0.0);
    }
<@endif@>

    if (!(isObscuranceEnabled() > 0.0)) {
        obscurance = 1.0;
    }

    float lightEnergy = obscurance * getLightAmbientIntensity(ambient);

    if (isAlbedoEnabled() > 0.0) {
        diffuse *= albedo;
    }

    lightEnergy *= isAmbientEnabled();
    diffuse *= lightEnergy * isDiffuseEnabled();
    specular *= lightEnergy * isSpecularEnabled();
}

<@endfunc@>