Add pipeline linear or gamma for scalar colors

materialsLibrary/dist/dts/babylon.pbrMaterial.d.ts

@@ -55,6 +55,7 @@ declare module BABYLON {
         opacityFresnelParameters: FresnelParameters;
         emissiveFresnelParameters: FresnelParameters;
         useMicroSurfaceFromReflectivityMapAlpha: boolean;
+        useScalarInLinearSpace: boolean;
         private _renderTargets;
         private _worldViewProjectionMatrix;
         private _globalAmbientColor;
@@ -70,12 +71,14 @@ declare module BABYLON {
         private _shouldUseAlphaFromAlbedoTexture();
         getAlphaTestTexture(): BaseTexture;
         private _checkCache(scene, mesh?, useInstances?);
+        private convertColorToLinearSpaceToRef(color, ref);
+        private static convertColorToLinearSpaceToRef(color, ref, useScalarInLinear);
         private static _scaledAlbedo;
         private static _scaledReflectivity;
         private static _scaledEmissive;
         private static _scaledReflection;
         private static _lightRadiuses;
-        static BindLights(scene: Scene, mesh: AbstractMesh, effect: Effect, defines: MaterialDefines): void;
+        static BindLights(scene: Scene, mesh: AbstractMesh, effect: Effect, defines: MaterialDefines, useScalarInLinearSpace: boolean): void;
         isReady(mesh?: AbstractMesh, useInstances?: boolean): boolean;
         unbind(): void;
         bindOnlyWorldMatrix(world: Matrix): void;

materialsLibrary/materials/pbr/babylon.pbrMaterial.ts

@@ -165,6 +165,7 @@ module BABYLON {
         public emissiveFresnelParameters: FresnelParameters;
 
         public useMicroSurfaceFromReflectivityMapAlpha = false;
+        public useScalarInLinearSpace = false;
 
         private _renderTargets = new SmartArray<RenderTargetTexture>(16);
         private _worldViewProjectionMatrix = Matrix.Zero();
@@ -243,13 +244,23 @@ module BABYLON {
             return false;
         }
       
+        private convertColorToLinearSpaceToRef (color: Color3, ref: Color3): void {
+            PBRMaterial.convertColorToLinearSpaceToRef(color, ref, this.useScalarInLinearSpace);
+        }
+        
+        private static convertColorToLinearSpaceToRef (color: Color3, ref: Color3, useScalarInLinear: boolean): void {
+            if (!useScalarInLinear) {
+                color.toLinearSpaceToRef(ref);
+            }
+        }
+        
         private static _scaledAlbedo = new Color3();
         private static _scaledReflectivity = new Color3();
         private static _scaledEmissive = new Color3();
         private static _scaledReflection = new Color3();
         private static _lightRadiuses = [1, 1, 1, 1];
 
-        public static BindLights(scene: Scene, mesh: AbstractMesh, effect: Effect, defines: MaterialDefines) {
+        public static BindLights(scene: Scene, mesh: AbstractMesh, effect: Effect, defines: MaterialDefines, useScalarInLinearSpace: boolean) {
             var lightIndex = 0;
             var depthValuesAlreadySet = false;
             for (var index = 0; index < scene.lights.length; index++) {
@@ -280,13 +291,13 @@ module BABYLON {
                 }
 
                 // GAMMA CORRECTION.
-                light.diffuse.toLinearSpaceToRef(PBRMaterial._scaledAlbedo);
+                this.convertColorToLinearSpaceToRef(light.diffuse, PBRMaterial._scaledAlbedo, useScalarInLinearSpace);
                 
                 PBRMaterial._scaledAlbedo.scaleToRef(light.intensity, PBRMaterial._scaledAlbedo);
                 effect.setColor4("vLightDiffuse" + lightIndex, PBRMaterial._scaledAlbedo, light.range);
                 
                 if (defines["SPECULARTERM"]) {
-                    light.specular.toLinearSpaceToRef(PBRMaterial._scaledReflectivity);
+                    this.convertColorToLinearSpaceToRef(light.specular, PBRMaterial._scaledReflectivity, useScalarInLinearSpace);
                     
                     PBRMaterial._scaledReflectivity.scaleToRef(light.intensity, PBRMaterial._scaledReflectivity);
                     effect.setColor3("vLightSpecular" + lightIndex, PBRMaterial._scaledReflectivity);
@@ -892,29 +903,29 @@ module BABYLON {
                 this._myScene.ambientColor.multiplyToRef(this.ambientColor, this._globalAmbientColor);
                 
                 // GAMMA CORRECTION.
-                this.reflectivityColor.toLinearSpaceToRef(PBRMaterial._scaledReflectivity);
+                this.convertColorToLinearSpaceToRef(this.reflectivityColor, PBRMaterial._scaledReflectivity);
 
                 this._effect.setVector3("vEyePosition", this._myScene._mirroredCameraPosition ? this._myScene._mirroredCameraPosition : this._myScene.activeCamera.position);
                 this._effect.setColor3("vAmbientColor", this._globalAmbientColor);
                 this._effect.setColor4("vReflectivityColor", PBRMaterial._scaledReflectivity, this.microSurface);
 
                 // GAMMA CORRECTION.
-                this.emissiveColor.toLinearSpaceToRef(PBRMaterial._scaledEmissive);
+                this.convertColorToLinearSpaceToRef(this.emissiveColor,PBRMaterial._scaledEmissive);
                 this._effect.setColor3("vEmissiveColor", PBRMaterial._scaledEmissive);
 
                 // GAMMA CORRECTION.
-                this.reflectionColor.toLinearSpaceToRef(PBRMaterial._scaledReflection);
+                this.convertColorToLinearSpaceToRef(this.reflectionColor, PBRMaterial._scaledReflection);
                 this._effect.setColor3("vReflectionColor", PBRMaterial._scaledReflection);
             }
 
             if (this._myScene.getCachedMaterial() !== this || !this.isFrozen) {
                 // GAMMA CORRECTION.
-                this.albedoColor.toLinearSpaceToRef(PBRMaterial._scaledAlbedo);
+                this.convertColorToLinearSpaceToRef(this.albedoColor, PBRMaterial._scaledAlbedo);
                 this._effect.setColor4("vAlbedoColor", PBRMaterial._scaledAlbedo, this.alpha * mesh.visibility);
 
                 // Lights
                 if (this._myScene.lightsEnabled && !this.disableLighting) {
-                    PBRMaterial.BindLights(this._myScene, mesh, this._effect, this._defines);
+                    PBRMaterial.BindLights(this._myScene, mesh, this._effect, this._defines, this.useScalarInLinearSpace);
                 }
 
                 // View
@@ -949,15 +960,15 @@ module BABYLON {
                 this._overloadedIntensity.w = this.overloadedEmissiveIntensity;
                 this._effect.setVector4("vOverloadedIntensity", this._overloadedIntensity);
 
-                this.overloadedAmbient.toLinearSpaceToRef(this._tempColor);
+                this.convertColorToLinearSpaceToRef(this.overloadedAmbient,this._tempColor);
                 this._effect.setColor3("vOverloadedAmbient", this._tempColor);
-                this.overloadedAlbedo.toLinearSpaceToRef(this._tempColor);
+                this.convertColorToLinearSpaceToRef(this.overloadedAlbedo, this._tempColor);
                 this._effect.setColor3("vOverloadedAlbedo", this._tempColor);
-                this.overloadedReflectivity.toLinearSpaceToRef(this._tempColor);
+                this.convertColorToLinearSpaceToRef(this.overloadedReflectivity, this._tempColor);
                 this._effect.setColor3("vOverloadedReflectivity", this._tempColor);
-                this.overloadedEmissive.toLinearSpaceToRef(this._tempColor);
+                this.convertColorToLinearSpaceToRef(this.overloadedEmissive, this._tempColor);
                 this._effect.setColor3("vOverloadedEmissive", this._tempColor);
-                this.overloadedReflection.toLinearSpaceToRef(this._tempColor);
+                this.convertColorToLinearSpaceToRef(this.overloadedReflection, this._tempColor);
                 this._effect.setColor3("vOverloadedReflection", this._tempColor);
 
                 this._overloadedMicroSurface.x = this.overloadedMicroSurface;
@@ -1130,6 +1141,7 @@ module BABYLON {
             newPBRMaterial.useAlphaFromAlbedoTexture = this.useAlphaFromAlbedoTexture;
             newPBRMaterial.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
             newPBRMaterial.useMicroSurfaceFromReflectivityMapAlpha = this.useMicroSurfaceFromReflectivityMapAlpha;
+            newPBRMaterial.useScalarInLinearSpace = this.useScalarInLinearSpace;
             newPBRMaterial.useSpecularOverAlpha = this.useSpecularOverAlpha;
             newPBRMaterial.indexOfRefraction = this.indexOfRefraction;
             newPBRMaterial.invertRefractionY = this.invertRefractionY;
@@ -1212,6 +1224,7 @@ module BABYLON {
             serializationObject.useAlphaFromAlbedoTexture = this.useAlphaFromAlbedoTexture;
             serializationObject.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
             serializationObject.useMicroSurfaceFromReflectivityMapAlpha = this.useMicroSurfaceFromReflectivityMapAlpha;
+            serializationObject.useScalarInLinear = this.useScalarInLinearSpace;
             serializationObject.useSpecularOverAlpha = this.useSpecularOverAlpha;
             serializationObject.indexOfRefraction = this.indexOfRefraction;
             serializationObject.invertRefractionY = this.invertRefractionY;
@@ -1307,6 +1320,7 @@ module BABYLON {
             material.useAlphaFromAlbedoTexture = source.useAlphaFromAlbedoTexture;
             material.useEmissiveAsIllumination = source.useEmissiveAsIllumination;
             material.useMicroSurfaceFromReflectivityMapAlpha = source.useMicroSurfaceFromReflectivityMapAlpha;
+            material.useScalarInLinearSpace = source.useScalarInLinear;
             material.useSpecularOverAlpha = source.useSpecularOverAlpha;
             material.indexOfRefraction = source.indexOfRefraction;
             material.invertRefractionY = source.invertRefractionY;