bgfx/3rdparty/glsl-optimizer/tests/fragment/z-unishader-dirlm-in.txt

#extension GL_ARB_shader_texture_lod : require

vec4 xll_texCUBElod(samplerCube s, vec4 coord) {
  return textureCubeLod( s, coord.xyz, coord.w);
}
mat3 xll_transpose_mf3x3(mat3 m) {
  return mat3( m[0][0], m[1][0], m[2][0],
               m[0][1], m[1][1], m[2][1],
               m[0][2], m[1][2], m[2][2]);
}
float xll_saturate_f( float x) {
  return clamp( x, 0.0, 1.0);
}
vec3 xll_saturate_vf3( vec3 x) {
  return clamp( x, 0.0, 1.0);
}
vec3 xll_matrixindex_mf3x3_i (mat3 m, int i) { vec3 v; v.x=m[0][i]; v.y=m[1][i]; v.z=m[2][i]; return v; }
struct VertexOutput {
    vec4 pos;
    vec4 tex;
    vec4 posWorld;
    vec3 normalWorld;
    vec4 tangentWorld;
    vec3 extra;
    vec4 _ShadowCoord;
    vec3 lightDir;
};
uniform vec3 _WorldSpaceCameraPos;
uniform vec4 _ProjectionParams;
uniform vec4 _ScreenParams;
uniform vec4 _ZBufferParams;
uniform vec4 _WorldSpaceLightPos0;
uniform vec4 unity_SHAr;
uniform vec4 unity_SHAg;
uniform vec4 unity_SHAb;
uniform vec4 unity_SHBr;
uniform vec4 unity_SHBg;
uniform vec4 unity_SHBb;
uniform vec4 unity_SHC;
uniform vec4 _LightShadowData;


uniform mat4 _Object2World;
uniform mat4 _World2Object;
uniform vec4 unity_Scale;
uniform mat4 glstate_matrix_transpose_modelview0;




uniform mat4 unity_MatrixV;
uniform mat4 unity_MatrixVP;
uniform samplerCube _Cube;
uniform sampler2D _MainTex;
uniform vec4 _MainTex_ST;
uniform sampler2D _DetailAlbedoMap;
uniform vec4 _DetailAlbedoMap_ST;
uniform sampler2D _AlphaMap;
uniform sampler2D _Occlusion;
uniform sampler2D _DetailNormalMap;
uniform vec4 _DetailNormalMap_ST;
uniform float _DetailNormalMapScale;
uniform sampler2D _BumpMap;
uniform float _BumpScale;
uniform float _Exposure;
uniform float _DetailBumpScale;
uniform float _AlphaTestRef;
uniform float _DetailBumpTiling;
uniform vec4 _Color;
uniform vec4 _SpecularColor;
uniform sampler2D _SpecGlossMap;
uniform float _Glossiness;

uniform vec4 unity_ColorSpaceGrey;

uniform sampler2D _ShadowMapTexture;
uniform vec4 _LightColor0;

uniform samplerCube _SpecCube;
uniform vec4 unity_LightmapST;
uniform sampler2D unity_Lightmap;
uniform sampler2D unity_LightmapInd;
uniform float _SelfIllumScale;
uniform sampler2D _SelfIllum;

vec3 Albedo( in vec4 texcoords ) {
    vec3 albedo = (_Color.xyz * texture2D( _MainTex, texcoords.xy).xyz);
    albedo *= (2.0 * texture2D( _DetailAlbedoMap, texcoords.zw).xyz);
    return albedo;
}
float Alpha( in vec2 uv ) {
    return (texture2D( _AlphaMap, uv).w * _Color.w);
}
float BlinnPhongTerm( in float roughness, in float NdotH ) {
    float m = (pow( roughness, 4.0) + 1e-05);
    float n = ((1.0 / m) - 2.0);
    float normTerm = ((n + 1.0) / 6.28318);
    float specTerm = pow( NdotH, n);
    return (specTerm * normTerm);
}
float BlinnTerm( in vec3 normal, in vec3 halfDir ) {
    return max( 0.0, dot( normal, halfDir));
}
float FresnelTerm( in float F0, in float cosA ) {
    float _Falloff = 5.0;
    float t = pow( abs((1.0 - cosA)), _Falloff);
    return (F0 + ((1.0 - F0) * t));
}
float CTGeometricTerm( in float NdotL, in float NdotH, in float NdotV, in float VdotH ) {
    VdotH += 1e-05;
    return min( 1.0, min( (((2.0 * NdotH) * NdotV) / VdotH), (((2.0 * NdotH) * NdotL) / VdotH)));
}
float GeometricTerm( in float NdotL, in float NdotH, in float NdotV, in float VdotH, in float LdotV ) {
    return CTGeometricTerm( NdotL, NdotH, NdotV, VdotH);
}
float LambertTerm( in vec3 normal, in vec3 lightDir ) {
    return max( 0.0, dot( normal, lightDir));
}
float RGBToLuminance( in vec3 color ) {
    vec3 lumSensitivity = vec3( 0.299, 0.587, 0.114);
    float luminance = dot( color, lumSensitivity);
    return luminance;
}
vec3 BRDF_Disney_PBS( in vec3 baseColor, in vec3 lightColor, in vec3 specColor, in float specular, in float roughness, in vec3 normal, in vec3 lightDir, in vec3 viewDir, in vec3 ambient, in vec3 env ) {
    vec3 halfDir = normalize((lightDir + viewDir));
    float nl = LambertTerm( normal, lightDir);
    float nh = BlinnTerm( normal, halfDir);
    float nv = max( 0.0, dot( normal, viewDir));
    float vh = max( 0.0, dot( viewDir, halfDir));
    float lv = max( 0.0, dot( lightDir, viewDir));
    float lh = max( 0.0, dot( lightDir, halfDir));
    float F = FresnelTerm( specular, vh);
    float G = GeometricTerm( nl, nh, nv, vh, lv);
    float R = BlinnPhongTerm( roughness, nh);
    R = max( 0.0, R);
    float Fd90 = (0.5 + ((2.0 * pow( lh, 2.0)) * roughness));
    float nlPow = pow( (1.00001 - nl), 5.0);
    float nvPow = pow( (1.00001 - nv), 5.0);
    float disneyDiffuse = ((1.0 + ((Fd90 - 1.0) * nlPow)) * (1.0 + ((Fd90 - 1.0) * nvPow)));
    float specularTerm = max( 0.0, (((F * G) * R) / ((4.0 * nv) + 1e-05)));
    float diffuseTerm = (disneyDiffuse * nl);
    vec3 diffuseColor = baseColor;
    vec3 color = (((diffuseColor * (ambient + (diffuseTerm * lightColor))) + (specColor * (env + (lightColor * specularTerm)))) + ((((1.0 - RGBToLuminance( specColor)) * (1.0 - roughness)) * FresnelTerm( 0.0, nv)) * env));
    return color;
}
vec3 DecodeLightmap( in vec4 color ) {
    return ((8.0 * color.w) * color.xyz);
}
vec3 DirLightmapDiffuse( in mat3 dirBasis, in vec4 color, in vec4 scale, in vec3 normal, in bool surfFuncWritesNormal, out vec3 scalePerBasisVector ) {
    vec3 lm = DecodeLightmap( color);
    scalePerBasisVector = DecodeLightmap( scale);
    if (surfFuncWritesNormal){
        vec3 normalInRnmBasis = xll_saturate_vf3((dirBasis * normal));
        lm *= dot( normalInRnmBasis, scalePerBasisVector);
    }
    return lm;
}
void DecodeDirLightmap( in vec3 normal, in vec4 colorLM, in vec4 scaleLM, out vec3 lightColor, out vec3 lightDir ) {
    mat3 unity_DirBasis = xll_transpose_mf3x3(mat3( vec3( 0.816497, 0.0, 0.57735), vec3( -0.408248, 0.707107, 0.57735), vec3( -0.408248, -0.707107, 0.57735)));
    vec3 scalePerBasisVector;
    lightColor = DirLightmapDiffuse( unity_DirBasis, colorLM, scaleLM, normal, true, scalePerBasisVector);
    lightDir = normalize((((scalePerBasisVector.x * xll_matrixindex_mf3x3_i (unity_DirBasis, 0)) + (scalePerBasisVector.y * xll_matrixindex_mf3x3_i (unity_DirBasis, 1))) + (scalePerBasisVector.z * xll_matrixindex_mf3x3_i (unity_DirBasis, 2))));
}
vec3 EnergyCalculator( in vec3 specColor, in float specular, in vec3 baseColor ) {
    return min( baseColor, (vec3( 1.0, 1.0, 1.0) - specular));
}
float toLinearFast1( in float c ) {
    float c2 = (c * c);
    return dot( vec2( 0.7532, 0.2468), vec2( c2, (c * c2)));
}
vec3 fromRGBM( in vec4 c ) {
    return ((c.xyz * toLinearFast1( c.w)) * _Exposure);
}
vec3 EnvMap( in vec4 worldNormal ) {
    vec4 envTexel = xll_texCUBElod( _SpecCube, vec4( worldNormal.xyz, worldNormal.w));
    return fromRGBM( envTexel);
}
float Occlusion( in vec2 uv ) {
    return texture2D( _Occlusion, uv).x;
}
vec4 SpecularGloss( in vec2 uv ) {
    vec4 specGloss = texture2D( _SpecGlossMap, uv);
    return vec4( specGloss.xyz, specGloss.w);
}
vec3 BlendNormals( in vec3 n1, in vec3 n2 ) {
    return normalize(vec3( (n1.xy + n2.xy), (n1.z * n2.z)));
}
vec3 UnpackScaleNormal( in vec4 packednormal, in float bumpScale ) {
    vec3 normal;
    normal.xy = ((packednormal.wy * 2.0) - 1.0);
    normal.xy *= bumpScale;
    normal.z = sqrt((1.0 - xll_saturate_f(dot( normal.xy, normal.xy))));
    return normal;
}
vec3 TangentNormal( in vec4 texcoords ) {
    vec3 normalTangent = UnpackScaleNormal( texture2D( _BumpMap, texcoords.xy), _BumpScale);
    vec3 detailNormalTangent = UnpackScaleNormal( texture2D( _DetailNormalMap, texcoords.zw), _DetailNormalMapScale);
    normalTangent = BlendNormals( normalTangent, detailNormalTangent);
    return normalTangent;
}
mat3 TangentToWorld( in vec3 normal, in vec3 tangent, in vec3 flip ) {
    vec3 binormal = (cross( normal, tangent) * flip);
    return xll_transpose_mf3x3(mat3( tangent, binormal, normal));
}
float unitySampleShadow( in vec4 shadowCoord ) {
    float shadow = texture2DProj( _ShadowMapTexture, shadowCoord).x;
    return shadow;
}
vec4 frag( in VertexOutput i ) {
    float atten = unitySampleShadow( i._ShadowCoord);
    mat3 tanToWorld = TangentToWorld( i.normalWorld, i.tangentWorld.xyz, vec3( i.tangentWorld.w));
    i.normalWorld = normalize(i.normalWorld);
    vec3 normalTangent = TangentNormal( i.tex);
    vec3 normalWorld = (normalTangent * tanToWorld);
    vec3 eyeVec = normalize((i.posWorld.xyz - _WorldSpaceCameraPos));
    vec4 specGloss = SpecularGloss( i.tex.xy);
    vec3 specColor = specGloss.xyz;
    float specular = RGBToLuminance( specGloss.xyz);
    float roughness = (1.0 - specGloss.w);
    vec3 env = vec3( 0.0);
    env = (EnvMap( vec4( reflect( eyeVec, normalWorld), (roughness * 5.0))) * Occlusion( i.tex.xy));
    vec3 lightColor = (_LightColor0.xyz * 2.0);
    vec3 lightDir = _WorldSpaceLightPos0.xyz;
    float subsurface = 1.0;
    vec3 ambient = vec3( 0.0);
    vec4 lmtex = texture2D( unity_Lightmap, i.extra.xy);
    vec4 lmIndTex = texture2D( unity_LightmapInd, i.extra.xy);
    vec3 lightDirTangent;
    DecodeDirLightmap( normalTangent, lmtex, lmIndTex, lightColor, lightDirTangent);
    lightDir = (lightDirTangent * tanToWorld);
    lightDir = normalize(lightDir);
    vec3 baseColor = EnergyCalculator( specColor, specular, Albedo( i.tex));
    vec3 color = BRDF_Disney_PBS( baseColor, (atten * lightColor), specColor, specular, roughness, normalWorld, lightDir, (-eyeVec), ambient, env);
    color += (texture2D( _SelfIllum, i.tex.xy).xyz * _SelfIllumScale);
    float alpha = Alpha( i.tex.xy);
    return vec4( color, alpha);
}
varying vec4 xlv_TEXCOORD0;
varying vec4 xlv_TEXCOORD1;
varying vec3 xlv_TEXCOORD2;
varying vec4 xlv_TEXCOORD3;
varying vec3 xlv_TEXCOORD4;
varying vec4 xlv_TEXCOORD5;
varying vec3 xlv_TEXCOORD7;
void main() {
    vec4 xl_retval;
    VertexOutput xlt_i;
    xlt_i.pos = vec4(0.0);
    xlt_i.tex = vec4(xlv_TEXCOORD0);
    xlt_i.posWorld = vec4(xlv_TEXCOORD1);
    xlt_i.normalWorld = vec3(xlv_TEXCOORD2);
    xlt_i.tangentWorld = vec4(xlv_TEXCOORD3);
    xlt_i.extra = vec3(xlv_TEXCOORD4);
    xlt_i._ShadowCoord = vec4(xlv_TEXCOORD5);
    xlt_i.lightDir = vec3(xlv_TEXCOORD7);
    xl_retval = frag( xlt_i);
    gl_FragData[0] = vec4(xl_retval);
}