New parametrables shader includes

Small optimization for shaders minifier

Tools/Gulp/gulp-removeShaderComments.js

@@ -18,6 +18,22 @@ function uncomment(str, opts) {
     str = str.replace(/\r\n/g, '\n');
     str = str.replace(/[ \f\t\v]+/g, ' ');
     str = str.replace(/^\s*\n/gm, '');
+    str = str.replace(/ \+ /g, '+');
+    str = str.replace(/ \- /g, '-');
+    str = str.replace(/ \/ /g, '/');
+    str = str.replace(/ \* /g, '*');
+    str = str.replace(/ > /g, '>');
+    str = str.replace(/ < /g, '<');
+    str = str.replace(/ >= /g, '>=');
+    str = str.replace(/ <= /g, '<=');
+    str = str.replace(/ \+= /g, '+=');
+    str = str.replace(/ \-= /g, '-=');
+    str = str.replace(/ \/= /g, '/=');
+    str = str.replace(/ \*= /g, '*=');
+    str = str.replace(/ = /g, '=');
+    str = str.replace(/, /g, ',');
+    str = str.replace(/\n\n/g, '\n');
+    str = str.replace(/\n /g, '\n');
     
 	for (var i = 0; i < str.length; i++) {
 		currentChar = str[i];

materialsLibrary/gulp-removeShaderComments.js

@@ -18,6 +18,22 @@ function uncomment(str, opts) {
     str = str.replace(/\r\n/g, '\n');
     str = str.replace(/[ \f\t\v]+/g, ' ');
     str = str.replace(/^\s*\n/gm, '');
+    str = str.replace(/ \+ /g, '+');
+    str = str.replace(/ \- /g, '-');
+    str = str.replace(/ \/ /g, '/');
+    str = str.replace(/ \* /g, '*');
+    str = str.replace(/ > /g, '>');
+    str = str.replace(/ < /g, '<');
+    str = str.replace(/ >= /g, '>=');
+    str = str.replace(/ <= /g, '<=');
+    str = str.replace(/ \+= /g, '+=');
+    str = str.replace(/ \-= /g, '-=');
+    str = str.replace(/ \/= /g, '/=');
+    str = str.replace(/ \*= /g, '*=');
+    str = str.replace(/ = /g, '=');
+    str = str.replace(/, /g, ',');
+    str = str.replace(/\n\n/g, '\n');
+    str = str.replace(/\n /g, '\n');
     
 	for (var i = 0; i < str.length; i++) {
 		currentChar = str[i];

materialsLibrary/materials/gradient/gradient.fragment.fx

@@ -23,10 +23,10 @@ varying vec4 vColor;
 
 // Lights
 
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 
 #include<lightsFragmentFunctions>
@@ -79,13 +79,14 @@ void main(void) {
 
 	// Lighting
 	vec3 diffuseBase = vec3(0., 0., 0.);
+    lightingInfo info;
 	float shadow = 1.;
     float glossiness = 0.;
     
-#include<light0Fragment>
-#include<light1Fragment>
-#include<light2Fragment>
-#include<light3Fragment>
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
 
 #ifdef VERTEXALPHA
 	alpha *= vColor.a;
@@ -99,4 +100,4 @@ void main(void) {
 #include<fogFragment>
 
 	gl_FragColor = color;
-}
+}

materialsLibrary/materials/lava/lava.fragment.fx

@@ -27,10 +27,10 @@ varying vec4 vColor;
 #endif
 
 // Lights
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 
 #include<lightsFragmentFunctions>
@@ -121,13 +121,14 @@ void main(void) {
 
 	// Lighting
 	vec3 diffuseBase = vec3(0., 0., 0.);
+    lightingInfo info;
 	float shadow = 1.;
     float glossiness = 0.;
     
-#include<light0Fragment>
-#include<light1Fragment>
-#include<light2Fragment>
-#include<light3Fragment>
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
 
 
 #ifdef VERTEXALPHA

materialsLibrary/materials/normal/normal.fragment.fx

@@ -16,10 +16,10 @@ varying vec4 vColor;
 #endif
 
 // Lights
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 
 #include<lightsFragmentFunctions>
@@ -77,13 +77,14 @@ void main(void) {
 
 	// Lighting
 	vec3 diffuseBase = vec3(0., 0., 0.);
+    lightingInfo info;
 	float shadow = 1.;
     float glossiness = 0.;
     
-#include<light0Fragment>
-#include<light1Fragment>
-#include<light2Fragment>
-#include<light3Fragment>
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
 
 
 #ifdef VERTEXALPHA

materialsLibrary/materials/pbr/legacypbr.fragment.fx

@@ -189,10 +189,10 @@ varying vec4 vColor;
 #endif
 
 // Lights
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 // Samplers
 #ifdef ALBEDO

materialsLibrary/materials/pbr/pbr.fragment.fx

@@ -343,10 +343,10 @@ varying vec4 vColor;
 #endif
 
 // Lights
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 // Samplers
 #ifdef ALBEDO

materialsLibrary/materials/simple/simple.fragment.fx

@@ -16,10 +16,10 @@ varying vec4 vColor;
 #endif
 
 // Lights
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 
 #include<lightsFragmentFunctions>
@@ -73,13 +73,14 @@ void main(void) {
 
 	// Lighting
 	vec3 diffuseBase = vec3(0., 0., 0.);
+    lightingInfo info;
 	float shadow = 1.;
     float glossiness = 0.;
     
-#include<light0Fragment>
-#include<light1Fragment>
-#include<light2Fragment>
-#include<light3Fragment>
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
 
 
 #ifdef VERTEXALPHA

src/Materials/Textures/babylon.hdrCubeTexture.js

@@ -24,8 +24,8 @@ var BABYLON;
             this.hasAlpha = false;
             this._size = size;
             this._useInGammaSpace = useInGammaSpace;
-            this._usePMREMGenerator = usePMREMGenerator;
-            this.isPMREM = usePMREMGenerator;
+            this._usePMREMGenerator = usePMREMGenerator && scene.getEngine().getCaps().textureLOD;
+            this.isPMREM = this._usePMREMGenerator;
             if (!url) {
                 return;
             }

src/Materials/Textures/babylon.hdrcubetexture.ts

@@ -35,7 +35,7 @@ module BABYLON {
             this._useInGammaSpace = useInGammaSpace;
             this._usePMREMGenerator = usePMREMGenerator && scene.getEngine().getCaps().textureLOD;
             this.isPMREM = this._usePMREMGenerator;
-            
+
             if (!url) {
                 return;
             }
@@ -196,4 +196,3 @@ module BABYLON {
         }
     }
 } 
-

src/Materials/babylon.effect.js

@@ -189,7 +189,7 @@ var BABYLON;
         };
         Effect.prototype._processIncludes = function (sourceCode, callback) {
             var _this = this;
-            var regex = /#include<(.+)>(\((.*)\))*/g;
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
             var match = regex.exec(sourceCode);
             var returnValue = new String(sourceCode);
             while (match != null) {
@@ -198,13 +198,16 @@ var BABYLON;
                     // Substitution
                     var includeContent = Effect.IncludesShadersStore[includeFile];
                     if (match[2]) {
-                        var splits = match[2].substr(1, match[2].length - 2).split(",");
+                        var splits = match[3].split(",");
                         for (var index = 0; index < splits.length; index += 2) {
                             var source = new RegExp(splits[index], "g");
                             var dest = splits[index + 1];
                             includeContent = includeContent.replace(source, dest);
                         }
                     }
+                    if (match[4]) {
+                        includeContent = includeContent.replace(/\{X\}/g, match[5]);
+                    }
                     // Replace
                     returnValue = returnValue.replace(match[0], includeContent);
                 }

src/Materials/babylon.effect.ts

@@ -237,7 +237,7 @@
         }
 
         private _processIncludes(sourceCode: string, callback: (data: any) => void): void {
-            var regex = /#include<(.+)>(\((.*)\))*/g;
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
             var match = regex.exec(sourceCode);
 
             var returnValue = new String(sourceCode);
@@ -249,8 +249,8 @@
                     // Substitution
                     var includeContent = Effect.IncludesShadersStore[includeFile];
                     if (match[2]) {
-                        var splits = match[2].substr(1, match[2].length - 2).split(",");
-
+                        var splits = match[3].split(",");
+                      
                         for (var index = 0; index < splits.length; index += 2) {
                             var source = new RegExp(splits[index], "g");
                             var dest = splits[index + 1];
@@ -259,6 +259,10 @@
                         }
                     }
 
+                    if (match[4]) {
+                        includeContent = includeContent.replace(/\{X\}/g, match[5]);
+                    }
+
                     // Replace
                     returnValue = returnValue.replace(match[0], includeContent);
                 } else {

src/Math/babylon.math.ts

@@ -1593,19 +1593,19 @@
             return this;
         }
 
-        public conjugateToRef(ref: Quaternion) {
+        public conjugateToRef(ref: Quaternion): Quaternion {
             ref.copyFromFloats(-this.x, -this.y, -this.z, this.w);
             return this;
         }
 
-        public conjugateInPlace() {
+        public conjugateInPlace(): Quaternion {
             this.x *= -1;
             this.y *= -1;
             this.z *= -1;
             return this;
         }
 
-        public conjugate() {
+        public conjugate(): Quaternion {
             var result = new Quaternion(-this.x, -this.y, -this.z, this.w);
             return result;
         }

src/Physics/babylon.physicsImpostor.js

@@ -23,6 +23,9 @@ var BABYLON;
                 if (_this._deltaRotationConjugated) {
                     _this.mesh.rotationQuaternion.multiplyToRef(_this._deltaRotationConjugated, _this._tmpRotationWithDelta);
                 }
+                else {
+                    _this._tmpRotationWithDelta.copyFrom(_this.mesh.rotationQuaternion);
+                }
                 _this._physicsEngine.getPhysicsPlugin().setPhysicsBodyTransformation(_this, _this._tmpPositionWithDelta, _this._tmpRotationWithDelta);
                 _this._onBeforePhysicsStepCallbacks.forEach(function (func) {
                     func(_this);

src/Physics/babylon.physicsImpostor.ts

@@ -235,7 +235,7 @@ module BABYLON {
             this._physicsEngine.getPhysicsPlugin().setTransformationFromPhysicsBody(this);
 
             this.mesh.position.addInPlace(this._deltaPosition)
-            if(this._deltaRotation) {
+            if (this._deltaRotation) {
                 this.mesh.rotationQuaternion.multiplyInPlace(this._deltaRotation);
             }
         }
@@ -304,7 +304,7 @@ module BABYLON {
             if (this.parent) {
                 this.parent.forceUpdate();
             } else {
-                this.mesh.getChildMeshes().forEach(function(mesh) {
+                this.mesh.getChildMeshes().forEach(function (mesh) {
                     if (mesh.physicsImpostor) {
                         if (disposeChildren) {
                             mesh.physicsImpostor.dispose();
@@ -320,7 +320,7 @@ module BABYLON {
         }
 
         public setDeltaRotation(rotation: Quaternion) {
-            if(!this._deltaRotation) {
+            if (!this._deltaRotation) {
                 this._deltaRotation = new Quaternion();
             }
             this._deltaRotation.copyFrom(rotation);
@@ -340,4 +340,4 @@ module BABYLON {
         public static HeightmapImpostor = 9;
     }
 
-}
+}

src/Shaders/ShadersInclude/light0Fragment.fx

@@ -1,39 +0,0 @@
-#ifdef LIGHT0
-	#ifndef SPECULARTERM
-		vec3 vLightSpecular0 = vec3(0.0);
-	#endif
-	#ifdef SPOTLIGHT0
-		lightingInfo info = computeSpotLighting(viewDirectionW, normalW, vLightData0, vLightDirection0, vLightDiffuse0.rgb, vLightSpecular0, vLightDiffuse0.a, glossiness);
-	#endif
-	#ifdef HEMILIGHT0
-		lightingInfo info = computeHemisphericLighting(viewDirectionW, normalW, vLightData0, vLightDiffuse0.rgb, vLightSpecular0, vLightGround0, glossiness);
-	#endif
-	#if defined(POINTLIGHT0) || defined(DIRLIGHT0)
-		lightingInfo info = computeLighting(viewDirectionW, normalW, vLightData0, vLightDiffuse0.rgb, vLightSpecular0, vLightDiffuse0.a, glossiness);
-	#endif
-	#ifdef SHADOW0
-		#ifdef SHADOWVSM0
-			shadow = computeShadowWithVSM(vPositionFromLight0, shadowSampler0, shadowsInfo0.z, shadowsInfo0.x);
-		#else
-		#ifdef SHADOWPCF0
-			#if defined(POINTLIGHT0)
-				shadow = computeShadowWithPCFCube(vLightData0.xyz, shadowSampler0, shadowsInfo0.y, shadowsInfo0.z, shadowsInfo0.x);
-			#else
-				shadow = computeShadowWithPCF(vPositionFromLight0, shadowSampler0, shadowsInfo0.y, shadowsInfo0.z, shadowsInfo0.x);
-			#endif
-		#else
-			#if defined(POINTLIGHT0)
-				shadow = computeShadowCube(vLightData0.xyz, shadowSampler0, shadowsInfo0.x, shadowsInfo0.z);
-			#else
-				shadow = computeShadow(vPositionFromLight0, shadowSampler0, shadowsInfo0.x, shadowsInfo0.z);
-			#endif
-		#endif
-	#endif
-	#else
-		shadow = 1.;
-	#endif
-		diffuseBase += info.diffuse * shadow;
-	#ifdef SPECULARTERM
-		specularBase += info.specular * shadow;
-	#endif
-#endif

src/Shaders/ShadersInclude/light0FragmentDeclaration.fx

@@ -1,22 +0,0 @@
-#ifdef LIGHT0
-	uniform vec4 vLightData0;
-	uniform vec4 vLightDiffuse0;
-	#ifdef SPECULARTERM
-		uniform vec3 vLightSpecular0;
-	#endif
-	#ifdef SHADOW0
-		#if defined(SPOTLIGHT0) || defined(DIRLIGHT0)
-			varying vec4 vPositionFromLight0;
-			uniform sampler2D shadowSampler0;
-		#else
-			uniform samplerCube shadowSampler0;
-		#endif
-		uniform vec3 shadowsInfo0;
-	#endif
-	#ifdef SPOTLIGHT0
-		uniform vec4 vLightDirection0;
-	#endif
-	#ifdef HEMILIGHT0
-		uniform vec3 vLightGround0;
-	#endif
-#endif

src/Shaders/ShadersInclude/light1Fragment.fx

@@ -1,39 +0,0 @@
-#ifdef LIGHT1
-	#ifndef SPECULARTERM
-		vec3 vLightSpecular1 = vec3(0.0);
-	#endif
-	#ifdef SPOTLIGHT1
-		info = computeSpotLighting(viewDirectionW, normalW, vLightData1, vLightDirection1, vLightDiffuse1.rgb, vLightSpecular1, vLightDiffuse1.a, glossiness);
-	#endif
-	#ifdef HEMILIGHT1
-		info = computeHemisphericLighting(viewDirectionW, normalW, vLightData1, vLightDiffuse1.rgb, vLightSpecular1, vLightGround1, glossiness);
-	#endif
-	#if defined(POINTLIGHT1) || defined(DIRLIGHT1)
-		info = computeLighting(viewDirectionW, normalW, vLightData1, vLightDiffuse1.rgb, vLightSpecular1, vLightDiffuse1.a, glossiness);
-	#endif
-	#ifdef SHADOW1
-		#ifdef SHADOWVSM1
-			shadow = computeShadowWithVSM(vPositionFromLight1, shadowSampler1, shadowsInfo1.z, shadowsInfo1.x);
-		#else
-			#ifdef SHADOWPCF1
-				#if defined(POINTLIGHT1)
-					shadow = computeShadowWithPCFCube(vLightData1.xyz, shadowSampler1, shadowsInfo1.y, shadowsInfo1.z, shadowsInfo1.x);
-				#else
-					shadow = computeShadowWithPCF(vPositionFromLight1, shadowSampler1, shadowsInfo1.y, shadowsInfo1.z, shadowsInfo1.x);
-				#endif
-			#else
-				#if defined(POINTLIGHT1)
-					shadow = computeShadowCube(vLightData1.xyz, shadowSampler1, shadowsInfo1.x, shadowsInfo1.z);
-				#else
-					shadow = computeShadow(vPositionFromLight1, shadowSampler1, shadowsInfo1.x, shadowsInfo1.z);
-				#endif
-			#endif
-		#endif
-		#else
-			shadow = 1.;
-	#endif
-	diffuseBase += info.diffuse * shadow;
-	#ifdef SPECULARTERM
-		specularBase += info.specular * shadow;
-	#endif
-#endif

src/Shaders/ShadersInclude/light1FragmentDeclaration.fx

@@ -1,22 +0,0 @@
-#ifdef LIGHT1
-	uniform vec4 vLightData1;
-	uniform vec4 vLightDiffuse1;
-	#ifdef SPECULARTERM
-		uniform vec3 vLightSpecular1;
-	#endif
-	#ifdef SHADOW1
-		#if defined(SPOTLIGHT1) || defined(DIRLIGHT1)
-			varying vec4 vPositionFromLight1;
-			uniform sampler2D shadowSampler1;
-		#else
-			uniform samplerCube shadowSampler1;
-		#endif
-		uniform vec3 shadowsInfo1;
-	#endif
-	#ifdef SPOTLIGHT1
-		uniform vec4 vLightDirection1;
-	#endif
-	#ifdef HEMILIGHT1
-		uniform vec3 vLightGround1;
-	#endif
-#endif

src/Shaders/ShadersInclude/light2Fragment.fx

@@ -1,39 +0,0 @@
-#ifdef LIGHT2
-	#ifndef SPECULARTERM
-		vec3 vLightSpecular2 = vec3(0.0);
-	#endif
-	#ifdef SPOTLIGHT2
-		info = computeSpotLighting(viewDirectionW, normalW, vLightData2, vLightDirection2, vLightDiffuse2.rgb, vLightSpecular2, vLightDiffuse2.a, glossiness);
-	#endif
-	#ifdef HEMILIGHT2
-		info = computeHemisphericLighting(viewDirectionW, normalW, vLightData2, vLightDiffuse2.rgb, vLightSpecular2, vLightGround2, glossiness);
-	#endif
-	#if defined(POINTLIGHT2) || defined(DIRLIGHT2)
-		info = computeLighting(viewDirectionW, normalW, vLightData2, vLightDiffuse2.rgb, vLightSpecular2, vLightDiffuse2.a, glossiness);
-	#endif
-	#ifdef SHADOW2
-		#ifdef SHADOWVSM2
-			shadow = computeShadowWithVSM(vPositionFromLight2, shadowSampler2, shadowsInfo2.z, shadowsInfo2.x);
-		#else
-			#ifdef SHADOWPCF2
-				#if defined(POINTLIGHT2)
-					shadow = computeShadowWithPCFCube(vLightData2.xyz, shadowSampler2, shadowsInfo2.y, shadowsInfo2.z, shadowsInfo2.x);
-				#else
-					shadow = computeShadowWithPCF(vPositionFromLight2, shadowSampler2, shadowsInfo2.y, shadowsInfo2.z, shadowsInfo2.x);
-				#endif
-			#else
-				#if defined(POINTLIGHT2)
-					shadow = computeShadowCube(vLightData2.xyz, shadowSampler2, shadowsInfo2.x, shadowsInfo2.z);
-				#else
-					shadow = computeShadow(vPositionFromLight2, shadowSampler2, shadowsInfo2.x, shadowsInfo2.z);
-				#endif
-			#endif	
-		#endif	
-		#else
-		shadow = 1.;
-	#endif
-	diffuseBase += info.diffuse * shadow;
-	#ifdef SPECULARTERM
-		specularBase += info.specular * shadow;
-	#endif
-#endif

src/Shaders/ShadersInclude/light2FragmentDeclaration.fx

@@ -1,22 +0,0 @@
-#ifdef LIGHT2
-	uniform vec4 vLightData2;
-	uniform vec4 vLightDiffuse2;
-	#ifdef SPECULARTERM
-		uniform vec3 vLightSpecular2;
-	#endif
-	#ifdef SHADOW2
-		#if defined(SPOTLIGHT2) || defined(DIRLIGHT2)
-			varying vec4 vPositionFromLight2;
-			uniform sampler2D shadowSampler2;
-		#else
-			uniform samplerCube shadowSampler2;
-		#endif
-		uniform vec3 shadowsInfo2;
-	#endif
-	#ifdef SPOTLIGHT2
-		uniform vec4 vLightDirection2;
-	#endif
-	#ifdef HEMILIGHT2
-		uniform vec3 vLightGround2;
-	#endif
-#endif

src/Shaders/ShadersInclude/light3Fragment.fx

@@ -1,39 +0,0 @@
-#ifdef LIGHT3
-	#ifndef SPECULARTERM
-		vec3 vLightSpecular3 = vec3(0.0);
-	#endif
-	#ifdef SPOTLIGHT3
-		info = computeSpotLighting(viewDirectionW, normalW, vLightData3, vLightDirection3, vLightDiffuse3.rgb, vLightSpecular3, vLightDiffuse3.a, glossiness);
-	#endif
-	#ifdef HEMILIGHT3
-		info = computeHemisphericLighting(viewDirectionW, normalW, vLightData3, vLightDiffuse3.rgb, vLightSpecular3, vLightGround3, glossiness);
-	#endif
-	#if defined(POINTLIGHT3) || defined(DIRLIGHT3)
-		info = computeLighting(viewDirectionW, normalW, vLightData3, vLightDiffuse3.rgb, vLightSpecular3, vLightDiffuse3.a, glossiness);
-	#endif
-	#ifdef SHADOW3
-		#ifdef SHADOWVSM3
-			shadow = computeShadowWithVSM(vPositionFromLight3, shadowSampler3, shadowsInfo3.z, shadowsInfo3.x);
-		#else
-			#ifdef SHADOWPCF3
-				#if defined(POINTLIGHT3)
-					shadow = computeShadowWithPCFCube(vLightData3.xyz, shadowSampler3, shadowsInfo3.y, shadowsInfo3.z, shadowsInfo3.x);
-				#else
-					shadow = computeShadowWithPCF(vPositionFromLight3, shadowSampler3, shadowsInfo3.y, shadowsInfo3.z, shadowsInfo3.x);
-				#endif
-			#else
-				#if defined(POINTLIGHT3)
-					shadow = computeShadowCube(vLightData3.xyz, shadowSampler3, shadowsInfo3.x, shadowsInfo3.z);
-				#else
-					shadow = computeShadow(vPositionFromLight3, shadowSampler3, shadowsInfo3.x, shadowsInfo3.z);
-				#endif
-			#endif	
-		#endif	
-	#else
-		shadow = 1.;
-	#endif
-	diffuseBase += info.diffuse * shadow;
-	#ifdef SPECULARTERM
-		specularBase += info.specular * shadow;
-	#endif
-#endif

src/Shaders/ShadersInclude/light3FragmentDeclaration.fx

@@ -1,22 +0,0 @@
-#ifdef LIGHT3
-	uniform vec4 vLightData3;
-	uniform vec4 vLightDiffuse3;
-	#ifdef SPECULARTERM
-		uniform vec3 vLightSpecular3;
-	#endif
-	#ifdef SHADOW3
-		#if defined(SPOTLIGHT3) || defined(DIRLIGHT3)
-			varying vec4 vPositionFromLight3;
-			uniform sampler2D shadowSampler3;
-		#else
-			uniform samplerCube shadowSampler3;
-		#endif
-		uniform vec3 shadowsInfo3;
-	#endif
-	#ifdef SPOTLIGHT3
-		uniform vec4 vLightDirection3;
-	#endif
-	#ifdef HEMILIGHT3
-		uniform vec3 vLightGround3;
-	#endif
-#endif

src/Shaders/ShadersInclude/lightFragment.fx

@@ -0,0 +1,39 @@
+#ifdef LIGHT{X}
+	#ifndef SPECULARTERM
+		vec3 vLightSpecular{X} = vec3(0.);
+	#endif
+	#ifdef SPOTLIGHT{X}
+		info = computeSpotLighting(viewDirectionW, normalW, vLightData{X}, vLightDirection{X}, vLightDiffuse{X}.rgb, vLightSpecular{X}, vLightDiffuse{X}.a, glossiness);
+	#endif
+	#ifdef HEMILIGHT{X}
+		info = computeHemisphericLighting(viewDirectionW, normalW, vLightData{X}, vLightDiffuse{X}.rgb, vLightSpecular{X}, vLightGround{X}, glossiness);
+	#endif
+	#if defined(POINTLIGHT{X}) || defined(DIRLIGHT{X})
+		info = computeLighting(viewDirectionW, normalW, vLightData{X}, vLightDiffuse{X}.rgb, vLightSpecular{X}, vLightDiffuse{X}.a, glossiness);
+	#endif
+	#ifdef SHADOW{X}
+		#ifdef SHADOWVSM{X}
+			shadow = computeShadowWithVSM(vPositionFromLight{X}, shadowSampler{X}, shadowsInfo{X}.z, shadowsInfo{X}.x);
+		#else
+		#ifdef SHADOWPCF{X}
+			#if defined(POINTLIGHT{X})
+				shadow = computeShadowWithPCFCube(vLightData{X}.xyz, shadowSampler{X}, shadowsInfo{X}.y, shadowsInfo{X}.z, shadowsInfo{X}.x);
+			#else
+				shadow = computeShadowWithPCF(vPositionFromLight{X}, shadowSampler{X}, shadowsInfo{X}.y, shadowsInfo{X}.z, shadowsInfo{X}.x);
+			#endif
+		#else
+			#if defined(POINTLIGHT{X})
+				shadow = computeShadowCube(vLightData{X}.xyz, shadowSampler{X}, shadowsInfo{X}.x, shadowsInfo{X}.z);
+			#else
+				shadow = computeShadow(vPositionFromLight{X}, shadowSampler{X}, shadowsInfo{X}.x, shadowsInfo{X}.z);
+			#endif
+		#endif
+	#endif
+	#else
+		shadow = 1.;
+	#endif
+		diffuseBase += info.diffuse * shadow;
+	#ifdef SPECULARTERM
+		specularBase += info.specular * shadow;
+	#endif
+#endif

src/Shaders/ShadersInclude/lightFragmentDeclaration.fx

@@ -0,0 +1,22 @@
+#ifdef LIGHT{X}
+	uniform vec4 vLightData{X};
+	uniform vec4 vLightDiffuse{X};
+	#ifdef SPECULARTERM
+		uniform vec3 vLightSpecular{X};
+	#endif
+	#ifdef SHADOW{X}
+		#if defined(SPOTLIGHT{X}) || defined(DIRLIGHT{X})
+			varying vec4 vPositionFromLight{X};
+			uniform sampler2D shadowSampler{X};
+		#else
+			uniform samplerCube shadowSampler{X};
+		#endif
+		uniform vec3 shadowsInfo{X};
+	#endif
+	#ifdef SPOTLIGHT{X}
+		uniform vec4 vLightDirection{X};
+	#endif
+	#ifdef HEMILIGHT{X}
+		uniform vec3 vLightGround{X};
+	#endif
+#endif

src/Shaders/default.fragment.fx

@@ -34,10 +34,10 @@ varying vec4 vColor;
 #include<helperFunctions>
 
 // Lights
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 #include<lightsFragmentFunctions>
 #include<shadowsFragmentFunctions>
@@ -221,15 +221,16 @@ void main(void) {
 
 	// Lighting
 	vec3 diffuseBase = vec3(0., 0., 0.);
+	lightingInfo info;
 #ifdef SPECULARTERM
 	vec3 specularBase = vec3(0., 0., 0.);
 #endif
 	float shadow = 1.;
 
-#include<light0Fragment>
-#include<light1Fragment>
-#include<light2Fragment>
-#include<light3Fragment>
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
 
 	// Refraction
 	vec3 refractionColor = vec3(0., 0., 0.);

src/Shaders/legacydefault.fragment.fx

@@ -20,10 +20,10 @@ varying vec4 vColor;
 #endif
 
 // Lights
-#include<light0FragmentDeclaration>
-#include<light1FragmentDeclaration>
-#include<light2FragmentDeclaration>
-#include<light3FragmentDeclaration>
+#include<lightFragmentDeclaration>[0]
+#include<lightFragmentDeclaration>[1]
+#include<lightFragmentDeclaration>[2]
+#include<lightFragmentDeclaration>[3]
 
 #include<lightsFragmentFunctions>
 #include<shadowsFragmentFunctions>
@@ -130,6 +130,7 @@ void main(void) {
 
 	// Lighting
 	vec3 diffuseBase = vec3(0., 0., 0.);
+	lightingInfo info;
 	float glossiness = 0.;
 #ifdef SPECULARTERM
 	vec3 specularBase = vec3(0., 0., 0.);
@@ -137,10 +138,10 @@ void main(void) {
 #endif
 	float shadow = 1.;
 
-#include<light0Fragment>
-#include<light1Fragment>
-#include<light2Fragment>
-#include<light3Fragment>
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
 
 	// Reflection
 	vec3 reflectionColor = vec3(0., 0., 0.);

src/Tools/HDR/babylon.tools.pmremgenerator.js

@@ -365,8 +365,8 @@ var BABYLON;
                 return PMREMGenerator._vectorTemp;
             };
             //--------------------------------------------------------------------------------------
-            //Original code from Ignacio Casta�o
-            // This formula is from Manne �hrstr�m's thesis.
+            //Original code from Ignacio CastaÒo
+            // This formula is from Manne ÷hrstrˆm's thesis.
             // Take two coordiantes in the range [-1, 1] that define a portion of a
             // cube face and return the area of the projection of that portion on the
             // surface of the sphere.

src/Tools/HDR/babylon.tools.pmremgenerator.ts

@@ -1,4 +1,4 @@
-//_______________________________________________________________
+//_______________________________________________________________
 // Extracted from CubeMapGen: 
 // https://code.google.com/archive/p/cubemapgen/
 //
@@ -596,8 +596,8 @@ namespace BABYLON.Internals {
         }
         
         //--------------------------------------------------------------------------------------
-        //Original code from Ignacio CastaÒo
-        // This formula is from Manne ÷hrstrˆm's thesis.
+        //Original code from Ignacio CastaÃ’o
+        // This formula is from Manne ÷hrstrˆm's thesis.
         // Take two coordiantes in the range [-1, 1] that define a portion of a
         // cube face and return the area of the projection of that portion on the
         // surface of the sphere.