uploade both .glslibs

jme3-core/src/main/resources/Common/ShaderLib/PBRLighting.glsllib

@@ -0,0 +1,202 @@
+#import "Common/ShaderLib/Lighting.glsllib"
+#import "Common/ShaderLib/PBR.glsllib"
+
+//declare PBR Lighting vars
+uniform vec4 g_LightData[NB_LIGHTS];
+uniform vec3 g_CameraPosition;
+uniform vec4 g_AmbientLightColor;
+
+#if NB_PROBES >= 1
+    uniform samplerCube g_PrefEnvMap;
+    uniform vec3 g_ShCoeffs[9];
+    uniform mat4 g_LightProbeData;
+#endif
+#if NB_PROBES >= 2
+    uniform samplerCube g_PrefEnvMap2;
+    uniform vec3 g_ShCoeffs2[9];
+    uniform mat4 g_LightProbeData2;
+#endif
+#if NB_PROBES == 3
+    uniform samplerCube g_PrefEnvMap3;
+    uniform vec3 g_ShCoeffs3[9];
+    uniform mat4 g_LightProbeData3;
+#endif
+
+// Specular-AA
+#ifdef SPECULAR_AA_SCREEN_SPACE_VARIANCE
+    uniform float m_SpecularAASigma;
+#endif
+#ifdef SPECULAR_AA_THRESHOLD
+    uniform float m_SpecularAAKappa;
+#endif
+
+vec3 calculatePBRLighting(in vec4 albedo, in float Metallic, in float Roughness, in vec3 lightMapColor, in vec3 ao, in float indoorSunLightExposure, in vec3 normal, in vec3 norm, in vec3 viewDir){
+    vec3 finalLightingValue;
+    
+    #ifdef SPECGLOSSPIPELINE
+
+        #ifdef USE_PACKED_SG
+            vec4 specularColor = texture2D(m_SpecularGlossinessMap, newTexCoord);
+            float glossiness = specularColor.a * m_Glossiness;
+            specularColor *= m_Specular;
+        #else
+            #ifdef SPECULARMAP
+                vec4 specularColor = texture2D(m_SpecularMap, newTexCoord);
+            #else
+                vec4 specularColor = vec4(1.0);
+            #endif
+            #ifdef GLOSSINESSMAP
+                float glossiness = texture2D(m_GlossinessMap, newTexCoord).r * m_Glossiness;
+            #else
+                float glossiness = m_Glossiness;
+            #endif
+            specularColor *= m_Specular;
+        #endif
+        vec4 diffuseColor = albedo;// * (1.0 - max(max(specularColor.r, specularColor.g), specularColor.b));
+        Roughness = 1.0 - glossiness;
+        vec3 fZero = specularColor.xyz;
+    #else
+        float specular = 0.5;
+        float nonMetalSpec = 0.08 * specular;
+        vec4 specularColor = (nonMetalSpec - nonMetalSpec * Metallic) + albedo * Metallic;
+        vec4 diffuseColor = albedo - albedo * Metallic;
+        vec3 fZero = vec3(specular);
+    #endif
+
+    #ifdef LIGHTMAP
+        #if !defined(AO_MAP)
+            finalLightingValue.rgb += diffuseColor.rgb * lightMapColor;
+        #endif
+        specularColor.rgb *= lightMapColor;
+    #endif
+    
+    #ifdef SPECULAR_AA
+        float sigma = 1.0;
+        float kappa = 0.18;
+        #ifdef SPECULAR_AA_SCREEN_SPACE_VARIANCE
+            sigma = m_SpecularAASigma;
+        #endif
+        #ifdef SPECULAR_AA_THRESHOLD
+            kappa = m_SpecularAAKappa;
+        #endif
+    #endif
+    
+    float finalLightingScale = 1.0; 
+    float brightestPointLight = 1.0;
+    
+    float ndotv = max( dot( normal, viewDir ),0.0);
+    for( int i = 0;i < NB_LIGHTS; i+=3){
+        vec4 lightColor = g_LightData[i];
+        vec4 lightData1 = g_LightData[i+1];                
+        vec4 lightDir;
+        vec3 lightVec;            
+        lightComputeDir(wPosition, lightColor.w, lightData1, lightDir, lightVec);
+
+        float fallOff = 1.0;
+        #if __VERSION__ >= 110
+            // allow use of control flow
+        if(lightColor.w > 1.0){
+        #endif
+            fallOff =  computeSpotFalloff(g_LightData[i+2], lightVec);
+        #if __VERSION__ >= 110
+        }
+        #endif
+        //point light attenuation
+        fallOff *= lightDir.w;
+
+        lightDir.xyz = normalize(lightDir.xyz);            
+        vec3 directDiffuse;
+        vec3 directSpecular;
+
+        #ifdef SPECULAR_AA
+            float hdotv = PBR_ComputeDirectLightWithSpecularAA(
+                                normal, lightDir.xyz, viewDir,
+                                lightColor.rgb, fZero, Roughness, sigma, kappa, ndotv,
+                                directDiffuse,  directSpecular);
+        #else
+            float hdotv = PBR_ComputeDirectLight(
+                                normal, lightDir.xyz, viewDir,
+                                lightColor.rgb, fZero, Roughness, ndotv,
+                                directDiffuse,  directSpecular);
+        #endif
+
+        vec3 directLighting = diffuseColor.rgb *directDiffuse + directSpecular;
+        
+        #if defined(USE_VERTEX_COLORS_AS_SUN_INTENSITY) || defined(STATIC_SUN_INTENSITY)         
+            if(fallOff == 1.0){
+                directLighting.rgb *= indoorSunLightExposure;//  used to scale down how intense just the sun is indoors, and so the ambientLighting can be scaled back up indoors based on nearest pointlight intensity (ambient and direct light are 1.0 fallOff)                
+            }
+            else{
+                brightestPointLight = max(fallOff, brightestPointLight);
+            }
+        #endif
+        
+        finalLightingValue.rgb += directLighting * fallOff;
+    }
+    
+    float minVertLighting;
+    #ifdef BRIGHTEN_INDOOR_SHADOWS
+        minVertLighting = 0.0833; //enable this when using shadows, in order to brighten indoor areas (which are naturally covered from the DL shadows) so that indoor areas are not way too dark when using IndoorLighting with shadows compared to when shadows are off
+    #else
+        minVertLighting = 0.0533;
+    #endif
+    
+    finalLightingScale = max(finalLightingScale, brightestPointLight);    
+    finalLightingScale = max(finalLightingScale, minVertLighting); //essentially just the vertColors.r (aka indoor light exposure) multiplied by the time of day scale.   
+
+    #if NB_PROBES >= 1
+        vec3 color1 = vec3(0.0);
+        vec3 color2 = vec3(0.0);
+        vec3 color3 = vec3(0.0);
+        float weight1 = 1.0;
+        float weight2 = 0.0;
+        float weight3 = 0.0;
+
+        float ndf = renderProbe(viewDir, wPosition, normal, norm, Roughness, diffuseColor, specularColor, ndotv, ao, g_LightProbeData, g_ShCoeffs, g_PrefEnvMap, color1);
+        #if NB_PROBES >= 2
+            float ndf2 = renderProbe(viewDir, wPosition, normal, norm, Roughness, diffuseColor, specularColor, ndotv, ao, g_LightProbeData2, g_ShCoeffs2, g_PrefEnvMap2, color2);
+        #endif
+        #if NB_PROBES == 3
+            float ndf3 = renderProbe(viewDir, wPosition, normal, norm, Roughness, diffuseColor, specularColor, ndotv, ao, g_LightProbeData3, g_ShCoeffs3, g_PrefEnvMap3, color3);
+        #endif
+
+        #if NB_PROBES >= 2
+            float invNdf =  max(1.0 - ndf,0.0);
+            float invNdf2 =  max(1.0 - ndf2,0.0);
+            float sumNdf = ndf + ndf2;
+            float sumInvNdf = invNdf + invNdf2;
+            #if NB_PROBES == 3
+                float invNdf3 = max(1.0 - ndf3,0.0);
+                sumNdf += ndf3;
+                sumInvNdf += invNdf3;
+                weight3 =  ((1.0 - (ndf3 / sumNdf)) / (NB_PROBES - 1)) *  (invNdf3 / sumInvNdf);
+            #endif
+
+            weight1 = ((1.0 - (ndf / sumNdf)) / (NB_PROBES - 1)) *  (invNdf / sumInvNdf);
+            weight2 = ((1.0 - (ndf2 / sumNdf)) / (NB_PROBES - 1)) *  (invNdf2 / sumInvNdf);
+
+            float weightSum = weight1 + weight2 + weight3;
+
+            weight1 /= weightSum;
+            weight2 /= weightSum;
+            weight3 /= weightSum;
+        #endif
+
+        #ifdef USE_AMBIENT_LIGHT
+            color1.rgb *= g_AmbientLightColor.rgb;
+            color2.rgb *= g_AmbientLightColor.rgb;
+            color3.rgb *= g_AmbientLightColor.rgb;
+        #endif
+        
+                // multiply probes by the finalLightingScale, as determined by pixel's 
+        // sunlightExposure and adjusted for nearby point/spot lights
+        color1.rgb *= finalLightingScale;
+        color2.rgb *= finalLightingScale;
+        color3.rgb *= finalLightingScale;
+        
+        finalLightingValue.rgb += color1 * clamp(weight1,0.0,1.0) + color2 * clamp(weight2,0.0,1.0) + color3 * clamp(weight3,0.0,1.0);
+
+    #endif
+    
+    return finalLightingValue;
+}

jme3-core/src/main/resources/Common/ShaderLib/PBRLightingParamReads.glsllib

@@ -0,0 +1,184 @@
+#import "Common/ShaderLib/Parallax.glsllib"
+
+varying vec4 Color;
+
+#ifdef BASECOLORMAP
+    uniform sampler2D m_BaseColorMap;
+#endif
+
+#ifdef USE_PACKED_MR
+    uniform sampler2D m_MetallicRoughnessMap;
+#else
+    #ifdef METALLICMAP
+        uniform sampler2D m_MetallicMap;
+    #endif
+    #ifdef ROUGHNESSMAP
+        uniform sampler2D m_RoughnessMap;
+    #endif
+#endif
+
+#ifdef EMISSIVE
+    uniform vec4 m_Emissive;
+#endif
+#ifdef EMISSIVEMAP
+    uniform sampler2D m_EmissiveMap;
+#endif
+#if defined(EMISSIVE) || defined(EMISSIVEMAP)
+    uniform float m_EmissivePower;
+    uniform float m_EmissiveIntensity;
+#endif 
+
+uniform float m_Roughness;
+uniform float m_Metallic;
+
+#ifdef SPECGLOSSPIPELINE
+    uniform vec4 m_Specular;
+    uniform float m_Glossiness;
+    #ifdef USE_PACKED_SG
+        uniform sampler2D m_SpecularGlossinessMap;
+    #else
+        uniform sampler2D m_SpecularMap;
+        uniform sampler2D m_GlossinessMap;
+    #endif
+#endif
+
+#ifdef PARALLAXMAP
+    uniform sampler2D m_ParallaxMap;  
+#endif
+#if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP)))
+    uniform float m_ParallaxHeight;
+#endif
+
+#ifdef LIGHTMAP
+    uniform sampler2D m_LightMap;
+#endif
+
+#ifdef AO_STRENGTH
+    uniform float m_AoStrength;
+#endif
+  
+#if defined(NORMALMAP) || defined(PARALLAXMAP)
+    uniform sampler2D m_NormalMap;       
+#endif
+#ifdef NORMALSCALE
+    uniform float m_NormalScale;
+#endif
+
+#if defined(USE_VERTEX_COLORS_AS_SUN_INTENSITY)
+    varying vec4 vertColors;
+#endif
+#ifdef STATIC_SUN_INTENSITY
+    uniform float m_StaticSunIntensity;
+#endif
+
+void readMatParamsAndTextures(in mat3 tbnMat, in vec3 vViewDir, inout vec4 albedo, inout float Metallic, inout float Roughness, inout vec3 lightMapColor, inout vec3 ao, inout vec3 normal, inout vec4 emissive, inout float alpha){
+    #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP)))
+        #ifdef STEEP_PARALLAX
+            #ifdef NORMALMAP_PARALLAX
+                //parallax map is stored in the alpha channel of the normal map         
+                newTexCoord = steepParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight);
+            #else
+                //parallax map is a texture
+                newTexCoord = steepParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight);         
+            #endif
+        #else
+            #ifdef NORMALMAP_PARALLAX
+                //parallax map is stored in the alpha channel of the normal map         
+                newTexCoord = classicParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight);
+            #else
+               //parallax map is a texture
+               newTexCoord = classicParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight);
+           #endif
+       #endif
+    #else
+       newTexCoord = texCoord;    
+    #endif
+    
+    #ifdef BASECOLORMAP
+        albedo = texture2D(m_BaseColorMap, newTexCoord) * Color;
+    #else
+        albedo = Color;
+    #endif
+    
+    alpha = albedo.a;
+
+    #ifdef DISCARD_ALPHA
+        if(alpha < m_AlphaDiscardThreshold){
+            discard;
+        }
+    #endif
+
+    //ao in r channel, roughness in green channel, metallic in blue channel!
+    vec3 aoRoughnessMetallicValue = vec3(1.0, 1.0, 0.0);
+    #ifdef USE_PACKED_MR
+        aoRoughnessMetallicValue = texture2D(m_MetallicRoughnessMap, newTexCoord).rgb;
+        Roughness = aoRoughnessMetallicValue.g * max(m_Roughness, 1e-4);
+        Metallic = aoRoughnessMetallicValue.b * max(m_Metallic, 0.0);
+    #else
+        #ifdef ROUGHNESSMAP
+            Roughness = texture2D(m_RoughnessMap, newTexCoord).r * max(m_Roughness, 1e-4);
+        #else
+            Roughness =  max(m_Roughness, 1e-4);
+        #endif
+        #ifdef METALLICMAP
+            Metallic = texture2D(m_MetallicMap, newTexCoord).r * max(m_Metallic, 0.0);
+        #else
+            Metallic =  max(m_Metallic, 0.0);
+        #endif
+    #endif
+ 
+    #if defined(NORMALMAP)
+        vec4 normalHeight = texture2D(m_NormalMap, newTexCoord);
+        // Note we invert directx style normal maps to opengl style
+        #ifdef NORMALSCALE
+            normal = normalize((normalHeight.xyz * vec3(2.0, NORMAL_TYPE * 2.0, 2.0) - vec3(1.0, NORMAL_TYPE * 1.0, 1.0)) * vec3(m_NormalScale, m_NormalScale, 1.0));
+        #else
+            normal = normalize((normalHeight.xyz * vec3(2.0, NORMAL_TYPE * 2.0, 2.0) - vec3(1.0, NORMAL_TYPE * 1.0, 1.0)));
+        #endif
+        normal = normalize(tbnMat * normal);
+        //normal = normalize(normal * inverse(tbnMat));
+    #else
+        normal = norm;
+    #endif
+    
+    #ifdef LIGHTMAP
+        #ifdef SEPARATE_TEXCOORD
+            lightMapColor = texture2D(m_LightMap, texCoord2).rgb;
+        #else
+            lightMapColor = texture2D(m_LightMap, texCoord).rgb;
+        #endif       
+        
+        #ifdef AO_MAP
+            lightMapColor.gb = lightMapColor.rr; 
+            ao = lightMapColor;
+        #endif
+    #endif
+    
+    #if defined(AO_PACKED_IN_MR_MAP) && defined(USE_PACKED_MR) 
+        ao = aoRoughnessMetallicValue.rrr; //note that this will override the AO value if it was previously read from a lightMap that is being used as AO_Map above. so don't try to use an AO map packed in metallic roughness while also using lightmap as ao map
+    #endif
+
+    #ifdef AO_STRENGTH
+        ao = 1.0 + m_AoStrength * (ao - 1.0);
+        // sanity check
+        ao = clamp(ao, 0.0, 1.0);
+    #endif
+    
+    #if defined(EMISSIVE) || defined (EMISSIVEMAP)
+        #ifdef EMISSIVEMAP
+            emissive = texture2D(m_EmissiveMap, newTexCoord);
+            #ifdef EMISSIVE
+            emissive *= m_Emissive;
+            #endif
+        #endif
+        emissive = emissive * pow(emissive.a, m_EmissivePower) * m_EmissiveIntensity;
+    #endif
+    
+    #ifdef STATIC_SUN_INTENSITY
+        indoorSunLightExposure = m_StaticSunIntensity; //single float value to indicate percentage of sunlight hitting the model (only suitable for small models or models with equal sunlight exposure accross the entire model
+    #endif
+    #ifdef USE_VERTEX_COLORS_AS_SUN_INTENSITY
+        indoorSunLightExposure = vertColors.r * indoorSunLightExposure;    // use red channel of vertexColors for non-uniform sunlighting accross a single model
+    #endif 
+    
+}