@babylonjs/core 5.0.0-alpha.61 → 5.0.0-alpha.65

package/Materials/PBR/pbrSubSurfaceConfiguration.js

@@ -1,58 +1,95 @@
-import { __decorate } from "tslib";
-import { SerializationHelper, serialize, serializeAsTexture, expandToProperty, serializeAsColor3 } from "../../Misc/decorators.js";
+import { __decorate, __extends } from "tslib";
+import { serialize, serializeAsTexture, expandToProperty, serializeAsColor3 } from "../../Misc/decorators.js";
 import { Color3 } from '../../Maths/math.color.js';
 import { MaterialFlags } from "../materialFlags.js";
 import { MaterialHelper } from "../../Materials/materialHelper.js";
 import { Scalar } from "../../Maths/math.scalar.js";
 import { TmpVectors } from "../../Maths/math.vector.js";
+import { MaterialPluginBase } from "../materialPluginBase.js";
+import { MaterialDefines } from "../materialDefines.js";
 /**
- * Define the code related to the sub surface parameters of the pbr material.
+ * @hidden
  */
-var PBRSubSurfaceConfiguration = /** @class */ (function () {
-    /**
-     * Instantiate a new instance of sub surface configuration.
-     * @param markAllSubMeshesAsTexturesDirty Callback to flag the material to dirty
-     * @param markScenePrePassDirty Callback to flag the scene as prepass dirty
-     * @param scene The scene
-     */
-    function PBRSubSurfaceConfiguration(markAllSubMeshesAsTexturesDirty, markScenePrePassDirty, scene) {
-        this._isRefractionEnabled = false;
+var MaterialSubSurfaceDefines = /** @class */ (function (_super) {
+    __extends(MaterialSubSurfaceDefines, _super);
+    function MaterialSubSurfaceDefines() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.SUBSURFACE = false;
+        _this.SS_REFRACTION = false;
+        _this.SS_REFRACTION_USE_INTENSITY_FROM_TEXTURE = false;
+        _this.SS_TRANSLUCENCY = false;
+        _this.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = false;
+        _this.SS_SCATTERING = false;
+        _this.SS_THICKNESSANDMASK_TEXTURE = false;
+        _this.SS_THICKNESSANDMASK_TEXTUREDIRECTUV = 0;
+        _this.SS_HAS_THICKNESS = false;
+        _this.SS_REFRACTIONINTENSITY_TEXTURE = false;
+        _this.SS_REFRACTIONINTENSITY_TEXTUREDIRECTUV = 0;
+        _this.SS_TRANSLUCENCYINTENSITY_TEXTURE = false;
+        _this.SS_TRANSLUCENCYINTENSITY_TEXTUREDIRECTUV = 0;
+        _this.SS_REFRACTIONMAP_3D = false;
+        _this.SS_REFRACTIONMAP_OPPOSITEZ = false;
+        _this.SS_LODINREFRACTIONALPHA = false;
+        _this.SS_GAMMAREFRACTION = false;
+        _this.SS_RGBDREFRACTION = false;
+        _this.SS_LINEARSPECULARREFRACTION = false;
+        _this.SS_LINKREFRACTIONTOTRANSPARENCY = false;
+        _this.SS_ALBEDOFORREFRACTIONTINT = false;
+        _this.SS_ALBEDOFORTRANSLUCENCYTINT = false;
+        _this.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = false;
+        _this.SS_USE_THICKNESS_AS_DEPTH = false;
+        _this.SS_MASK_FROM_THICKNESS_TEXTURE = false;
+        _this.SS_USE_GLTF_TEXTURES = false;
+        return _this;
+    }
+    return MaterialSubSurfaceDefines;
+}(MaterialDefines));
+export { MaterialSubSurfaceDefines };
+/**
+ * Plugin that implements the sub surface component of the PBR material
+ */
+var PBRSubSurfaceConfiguration = /** @class */ (function (_super) {
+    __extends(PBRSubSurfaceConfiguration, _super);
+    function PBRSubSurfaceConfiguration(material, addToPluginList) {
+        if (addToPluginList === void 0) { addToPluginList = true; }
+        var _this = _super.call(this, material, "PBRSubSurface", 130, new MaterialSubSurfaceDefines(), addToPluginList) || this;
+        _this._isRefractionEnabled = false;
         /**
          * Defines if the refraction is enabled in the material.
          */
-        this.isRefractionEnabled = false;
-        this._isTranslucencyEnabled = false;
+        _this.isRefractionEnabled = false;
+        _this._isTranslucencyEnabled = false;
         /**
          * Defines if the translucency is enabled in the material.
          */
-        this.isTranslucencyEnabled = false;
-        this._isScatteringEnabled = false;
+        _this.isTranslucencyEnabled = false;
+        _this._isScatteringEnabled = false;
         /**
          * Defines if the sub surface scattering is enabled in the material.
          */
-        this.isScatteringEnabled = false;
-        this._scatteringDiffusionProfileIndex = 0;
+        _this.isScatteringEnabled = false;
+        _this._scatteringDiffusionProfileIndex = 0;
         /**
          * Defines the refraction intensity of the material.
          * The refraction when enabled replaces the Diffuse part of the material.
          * The intensity helps transitioning between diffuse and refraction.
          */
-        this.refractionIntensity = 1;
+        _this.refractionIntensity = 1;
         /**
          * Defines the translucency intensity of the material.
          * When translucency has been enabled, this defines how much of the "translucency"
          * is added to the diffuse part of the material.
          */
-        this.translucencyIntensity = 1;
+        _this.translucencyIntensity = 1;
         /**
          * When enabled, transparent surfaces will be tinted with the albedo colour (independent of thickness)
          */
-        this.useAlbedoToTintRefraction = false;
+        _this.useAlbedoToTintRefraction = false;
         /**
          * When enabled, translucent surfaces will be tinted with the albedo colour (independent of thickness)
          */
-        this.useAlbedoToTintTranslucency = false;
-        this._thicknessTexture = null;
+        _this.useAlbedoToTintTranslucency = false;
+        _this._thicknessTexture = null;
         /**
          * Stores the average thickness of a mesh in a texture (The texture is holding the values linearly).
          * The red (or green if useGltfStyleTextures=true) channel of the texture should contain the thickness remapped between 0 and 1.
@@ -60,13 +97,14 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
          * 1 would mean maximumThickness
          * The other channels might be use as a mask to vary the different effects intensity.
          */
-        this.thicknessTexture = null;
-        this._refractionTexture = null;
+        _this.thicknessTexture = null;
+        _this._refractionTexture = null;
         /**
          * Defines the texture to use for refraction.
          */
-        this.refractionTexture = null;
-        this._indexOfRefraction = 1.5;
+        _this.refractionTexture = null;
+        /** @hidden */
+        _this._indexOfRefraction = 1.5;
         /**
          * Index of refraction of the material base layer.
          * https://en.wikipedia.org/wiki/List_of_refractive_indices
@@ -75,78 +113,81 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
          *
          * From dielectric fresnel rules: F0 = square((iorT - iorI) / (iorT + iorI))
          */
-        this.indexOfRefraction = 1.5;
-        this._volumeIndexOfRefraction = -1.0;
-        this._invertRefractionY = false;
+        _this.indexOfRefraction = 1.5;
+        _this._volumeIndexOfRefraction = -1.0;
+        _this._invertRefractionY = false;
         /**
          * Controls if refraction needs to be inverted on Y. This could be useful for procedural texture.
          */
-        this.invertRefractionY = false;
-        this._linkRefractionWithTransparency = false;
+        _this.invertRefractionY = false;
+        /** @hidden */
+        _this._linkRefractionWithTransparency = false;
         /**
          * This parameters will make the material used its opacity to control how much it is refracting against not.
          * Materials half opaque for instance using refraction could benefit from this control.
          */
-        this.linkRefractionWithTransparency = false;
+        _this.linkRefractionWithTransparency = false;
         /**
          * Defines the minimum thickness stored in the thickness map.
          * If no thickness map is defined, this value will be used to simulate thickness.
          */
-        this.minimumThickness = 0;
+        _this.minimumThickness = 0;
         /**
          * Defines the maximum thickness stored in the thickness map.
          */
-        this.maximumThickness = 1;
+        _this.maximumThickness = 1;
         /**
          * Defines that the thickness should be used as a measure of the depth volume.
          */
-        this.useThicknessAsDepth = false;
+        _this.useThicknessAsDepth = false;
         /**
         * Defines the volume tint of the material.
         * This is used for both translucency and scattering.
         */
-        this.tintColor = Color3.White();
+        _this.tintColor = Color3.White();
         /**
          * Defines the distance at which the tint color should be found in the media.
          * This is used for refraction only.
          */
-        this.tintColorAtDistance = 1;
+        _this.tintColorAtDistance = 1;
         /**
          * Defines how far each channel transmit through the media.
          * It is defined as a color to simplify it selection.
          */
-        this.diffusionDistance = Color3.White();
-        this._useMaskFromThicknessTexture = false;
+        _this.diffusionDistance = Color3.White();
+        _this._useMaskFromThicknessTexture = false;
         /**
          * Stores the intensity of the different subsurface effects in the thickness texture.
          * Note that if refractionIntensityTexture and/or translucencyIntensityTexture is provided it takes precedence over thicknessTexture + useMaskFromThicknessTexture
          * * the green (red if useGltfStyleTextures = true) channel is the refraction intensity.
          * * the blue channel is the translucency intensity.
          */
-        this.useMaskFromThicknessTexture = false;
-        this._refractionIntensityTexture = null;
+        _this.useMaskFromThicknessTexture = false;
+        _this._refractionIntensityTexture = null;
         /**
          * Stores the intensity of the refraction. If provided, it takes precedence over thicknessTexture + useMaskFromThicknessTexture
          * * the green (red if useGltfStyleTextures = true) channel is the refraction intensity.
          */
-        this.refractionIntensityTexture = null;
-        this._translucencyIntensityTexture = null;
+        _this.refractionIntensityTexture = null;
+        _this._translucencyIntensityTexture = null;
         /**
          * Stores the intensity of the translucency. If provided, it takes precedence over thicknessTexture + useMaskFromThicknessTexture
          * * the blue channel is the translucency intensity.
          */
-        this.translucencyIntensityTexture = null;
-        this._useGltfStyleTextures = false;
+        _this.translucencyIntensityTexture = null;
+        _this._useGltfStyleTextures = false;
         /**
          * Use channels layout used by glTF:
          * * thicknessTexture: the green (instead of red) channel is the thickness
          * * thicknessTexture/refractionIntensityTexture: the red (instead of green) channel is the refraction intensity
          * * thicknessTexture/translucencyIntensityTexture: no change, use the blue channel for the translucency intensity
          */
-        this.useGltfStyleTextures = false;
-        this._internalMarkAllSubMeshesAsTexturesDirty = markAllSubMeshesAsTexturesDirty;
-        this._internalMarkScenePrePassDirty = markScenePrePassDirty;
-        this._scene = scene;
+        _this.useGltfStyleTextures = false;
+        _this._scene = material.getScene();
+        _this.registerForExtraEvents = true;
+        _this._internalMarkAllSubMeshesAsTexturesDirty = material._dirtyCallbacks[1];
+        _this._internalMarkScenePrePassDirty = material._dirtyCallbacks[32];
+        return _this;
     }
     Object.defineProperty(PBRSubSurfaceConfiguration.prototype, "scatteringDiffusionProfile", {
         /**
@@ -199,6 +240,7 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
     });
     /** @hidden */
     PBRSubSurfaceConfiguration.prototype._markAllSubMeshesAsTexturesDirty = function () {
+        this._enable(this._isRefractionEnabled || this._isTranslucencyEnabled || this._isScatteringEnabled);
         this._internalMarkAllSubMeshesAsTexturesDirty();
     };
     /** @hidden */
@@ -206,13 +248,7 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
         this._internalMarkAllSubMeshesAsTexturesDirty();
         this._internalMarkScenePrePassDirty();
     };
-    /**
-     * Gets whether the submesh is ready to be used or not.
-     * @param defines the list of "defines" to update.
-     * @param scene defines the scene the material belongs to.
-     * @returns - boolean indicating that the submesh is ready or not.
-     */
-    PBRSubSurfaceConfiguration.prototype.isReadyForSubMesh = function (defines, scene) {
+    PBRSubSurfaceConfiguration.prototype.isReadyForSubMesh = function (defines, scene, engine) {
         if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled) {
             return true;
         }
@@ -233,12 +269,7 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
         }
         return true;
     };
-    /**
-     * Checks to see if a texture is used in the material.
-     * @param defines the list of "defines" to update.
-     * @param scene defines the scene to the material belongs to.
-     */
-    PBRSubSurfaceConfiguration.prototype.prepareDefines = function (defines, scene) {
+    PBRSubSurfaceConfiguration.prototype.prepareDefines = function (defines, scene, mesh) {
         if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled) {
             defines.SUBSURFACE = false;
             defines.SS_TRANSLUCENCY = false;
@@ -247,7 +278,7 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
             return;
         }
         if (defines._areTexturesDirty) {
-            defines.SUBSURFACE = false;
+            defines.SUBSURFACE = true;
             defines.SS_TRANSLUCENCY = this._isTranslucencyEnabled;
             defines.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = false;
             defines.SS_SCATTERING = this._isScatteringEnabled;
@@ -270,35 +301,32 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
             defines.SS_ALBEDOFORTRANSLUCENCYTINT = false;
             defines.SS_USE_LOCAL_REFRACTIONMAP_CUBIC = false;
             defines.SS_USE_THICKNESS_AS_DEPTH = false;
-            if (this._isRefractionEnabled || this._isTranslucencyEnabled || this._isScatteringEnabled) {
-                defines.SUBSURFACE = true;
-                var refractionIntensityTextureIsThicknessTexture = !!this._thicknessTexture &&
-                    !!this._refractionIntensityTexture &&
-                    this._refractionIntensityTexture.checkTransformsAreIdentical(this._thicknessTexture) && this._refractionIntensityTexture._texture === this._thicknessTexture._texture;
-                var translucencyIntensityTextureIsThicknessTexture = !!this._thicknessTexture &&
-                    !!this._translucencyIntensityTexture &&
-                    this._translucencyIntensityTexture.checkTransformsAreIdentical(this._thicknessTexture) && this._translucencyIntensityTexture._texture === this._thicknessTexture._texture;
-                // if true, it means the refraction/translucency textures are the same than the thickness texture so there's no need to pass them to the shader, only thicknessTexture
-                var useOnlyThicknessTexture = (refractionIntensityTextureIsThicknessTexture || !this._refractionIntensityTexture) && (translucencyIntensityTextureIsThicknessTexture || !this._translucencyIntensityTexture);
-                if (defines._areTexturesDirty) {
-                    if (scene.texturesEnabled) {
-                        if (this._thicknessTexture && MaterialFlags.ThicknessTextureEnabled) {
-                            MaterialHelper.PrepareDefinesForMergedUV(this._thicknessTexture, defines, "SS_THICKNESSANDMASK_TEXTURE");
-                        }
-                        if (this._refractionIntensityTexture && MaterialFlags.RefractionIntensityTextureEnabled && !useOnlyThicknessTexture) {
-                            MaterialHelper.PrepareDefinesForMergedUV(this._refractionIntensityTexture, defines, "SS_REFRACTIONINTENSITY_TEXTURE");
-                        }
-                        if (this._translucencyIntensityTexture && MaterialFlags.TranslucencyIntensityTextureEnabled && !useOnlyThicknessTexture) {
-                            MaterialHelper.PrepareDefinesForMergedUV(this._translucencyIntensityTexture, defines, "SS_TRANSLUCENCYINTENSITY_TEXTURE");
-                        }
+            var refractionIntensityTextureIsThicknessTexture = !!this._thicknessTexture &&
+                !!this._refractionIntensityTexture &&
+                this._refractionIntensityTexture.checkTransformsAreIdentical(this._thicknessTexture) && this._refractionIntensityTexture._texture === this._thicknessTexture._texture;
+            var translucencyIntensityTextureIsThicknessTexture = !!this._thicknessTexture &&
+                !!this._translucencyIntensityTexture &&
+                this._translucencyIntensityTexture.checkTransformsAreIdentical(this._thicknessTexture) && this._translucencyIntensityTexture._texture === this._thicknessTexture._texture;
+            // if true, it means the refraction/translucency textures are the same than the thickness texture so there's no need to pass them to the shader, only thicknessTexture
+            var useOnlyThicknessTexture = (refractionIntensityTextureIsThicknessTexture || !this._refractionIntensityTexture) && (translucencyIntensityTextureIsThicknessTexture || !this._translucencyIntensityTexture);
+            if (defines._areTexturesDirty) {
+                if (scene.texturesEnabled) {
+                    if (this._thicknessTexture && MaterialFlags.ThicknessTextureEnabled) {
+                        MaterialHelper.PrepareDefinesForMergedUV(this._thicknessTexture, defines, "SS_THICKNESSANDMASK_TEXTURE");
+                    }
+                    if (this._refractionIntensityTexture && MaterialFlags.RefractionIntensityTextureEnabled && !useOnlyThicknessTexture) {
+                        MaterialHelper.PrepareDefinesForMergedUV(this._refractionIntensityTexture, defines, "SS_REFRACTIONINTENSITY_TEXTURE");
+                    }
+                    if (this._translucencyIntensityTexture && MaterialFlags.TranslucencyIntensityTextureEnabled && !useOnlyThicknessTexture) {
+                        MaterialHelper.PrepareDefinesForMergedUV(this._translucencyIntensityTexture, defines, "SS_TRANSLUCENCYINTENSITY_TEXTURE");
                     }
                 }
-                defines.SS_HAS_THICKNESS = (this.maximumThickness - this.minimumThickness) !== 0.0;
-                defines.SS_MASK_FROM_THICKNESS_TEXTURE = (this._useMaskFromThicknessTexture || !!this._refractionIntensityTexture || !!this._translucencyIntensityTexture) && useOnlyThicknessTexture;
-                defines.SS_USE_GLTF_TEXTURES = this._useGltfStyleTextures;
-                defines.SS_REFRACTION_USE_INTENSITY_FROM_TEXTURE = (this._useMaskFromThicknessTexture || !!this._refractionIntensityTexture) && useOnlyThicknessTexture;
-                defines.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = (this._useMaskFromThicknessTexture || !!this._translucencyIntensityTexture) && useOnlyThicknessTexture;
             }
+            defines.SS_HAS_THICKNESS = (this.maximumThickness - this.minimumThickness) !== 0.0;
+            defines.SS_MASK_FROM_THICKNESS_TEXTURE = (this._useMaskFromThicknessTexture || !!this._refractionIntensityTexture || !!this._translucencyIntensityTexture) && useOnlyThicknessTexture;
+            defines.SS_USE_GLTF_TEXTURES = this._useGltfStyleTextures;
+            defines.SS_REFRACTION_USE_INTENSITY_FROM_TEXTURE = (this._useMaskFromThicknessTexture || !!this._refractionIntensityTexture) && useOnlyThicknessTexture;
+            defines.SS_TRANSLUCENCY_USE_INTENSITY_FROM_TEXTURE = (this._useMaskFromThicknessTexture || !!this._translucencyIntensityTexture) && useOnlyThicknessTexture;
             if (this._isRefractionEnabled) {
                 if (scene.texturesEnabled) {
                     var refractionTexture = this._getRefractionTexture(scene);
@@ -327,12 +355,9 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
      * @param uniformBuffer defines the Uniform buffer to fill in.
      * @param scene defines the scene the material belongs to.
      * @param engine defines the engine the material belongs to.
-     * @param isFrozen defines whether the material is frozen or not.
-     * @param lodBasedMicrosurface defines whether the material relies on lod based microsurface or not.
-     * @param realTimeFiltering defines whether the textures should be filtered on the fly.
      * @param subMesh the submesh to bind data for
     */
-    PBRSubSurfaceConfiguration.prototype.hardBindForSubMesh = function (uniformBuffer, scene, engine, isFrozen, lodBasedMicrosurface, realTimeFiltering, subMesh) {
+    PBRSubSurfaceConfiguration.prototype.hardBindForSubMesh = function (uniformBuffer, scene, engine, subMesh) {
         if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled) {
             return;
         }
@@ -340,21 +365,14 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
         var thicknessScale = Math.max(Math.abs(TmpVectors.Vector3[0].x), Math.abs(TmpVectors.Vector3[0].y), Math.abs(TmpVectors.Vector3[0].z));
         uniformBuffer.updateFloat2("vThicknessParam", this.minimumThickness * thicknessScale, (this.maximumThickness - this.minimumThickness) * thicknessScale);
     };
-    /**
-     * Binds the material data.
-     * @param uniformBuffer defines the Uniform buffer to fill in.
-     * @param scene defines the scene the material belongs to.
-     * @param engine defines the engine the material belongs to.
-     * @param isFrozen defines whether the material is frozen or not.
-     * @param lodBasedMicrosurface defines whether the material relies on lod based microsurface or not.
-     * @param realTimeFiltering defines whether the textures should be filtered on the fly.
-     * @param subMesh the submesh to bind data for
-    */
-    PBRSubSurfaceConfiguration.prototype.bindForSubMesh = function (uniformBuffer, scene, engine, isFrozen, lodBasedMicrosurface, realTimeFiltering, subMesh) {
+    PBRSubSurfaceConfiguration.prototype.bindForSubMesh = function (uniformBuffer, scene, engine, subMesh) {
         if (!this._isRefractionEnabled && !this._isTranslucencyEnabled && !this._isScatteringEnabled) {
             return;
         }
         var defines = subMesh.materialDefines;
+        var isFrozen = this._material.isFrozen;
+        var realTimeFiltering = this._material.realTimeFiltering;
+        var lodBasedMicrosurface = defines.LODBASEDMICROSFURACE;
         var refractionTexture = this._getRefractionTexture(scene);
         if (!uniformBuffer.useUbo || !isFrozen || !uniformBuffer.isSync) {
             if (this._thicknessTexture && MaterialFlags.ThicknessTextureEnabled) {
@@ -390,7 +408,7 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
                     uniformBuffer.updateVector3("vRefractionSize", cubeTexture.boundingBoxSize);
                 }
             }
-            if (this.isScatteringEnabled) {
+            if (this._isScatteringEnabled) {
                 uniformBuffer.updateFloat("scatteringDiffusionProfile", this._scatteringDiffusionProfileIndex);
             }
             uniformBuffer.updateColor3("vDiffusionDistance", this.diffusionDistance);
@@ -420,18 +438,6 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
             }
         }
     };
-    /**
-     * Unbinds the material from the mesh.
-     * @param activeEffect defines the effect that should be unbound from.
-     * @returns true if unbound, otherwise false
-     */
-    PBRSubSurfaceConfiguration.prototype.unbind = function (activeEffect) {
-        if (this._refractionTexture && this._refractionTexture.isRenderTarget) {
-            activeEffect.setTexture("refractionSampler", null);
-            return true;
-        }
-        return false;
-    };
     /**
      * Returns the texture used for refraction or null if none is used.
      * @param scene defines the scene the material belongs to.
@@ -452,7 +458,7 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
          * Returns true if alpha blending should be disabled.
          */
         get: function () {
-            return this.isRefractionEnabled && this._linkRefractionWithTransparency;
+            return this._isRefractionEnabled && this._linkRefractionWithTransparency;
         },
         enumerable: false,
         configurable: true
@@ -466,11 +472,6 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
             renderTargets.push(this._refractionTexture);
         }
     };
-    /**
-     * Checks to see if a texture is used in the material.
-     * @param texture - Base texture to use.
-     * @returns - Boolean specifying if a texture is used in the material.
-     */
     PBRSubSurfaceConfiguration.prototype.hasTexture = function (texture) {
         if (this._thicknessTexture === texture) {
             return true;
@@ -480,20 +481,12 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
         }
         return false;
     };
-    /**
-     * Gets a boolean indicating that current material needs to register RTT
-     * @returns true if this uses a render target otherwise false.
-     */
     PBRSubSurfaceConfiguration.prototype.hasRenderTargetTextures = function () {
         if (MaterialFlags.RefractionTextureEnabled && this._refractionTexture && this._refractionTexture.isRenderTarget) {
             return true;
         }
         return false;
     };
-    /**
-     * Returns an array of the actively used textures.
-     * @param activeTextures Array of BaseTextures
-     */
     PBRSubSurfaceConfiguration.prototype.getActiveTextures = function (activeTextures) {
         if (this._thicknessTexture) {
             activeTextures.push(this._thicknessTexture);
@@ -502,10 +495,6 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
             activeTextures.push(this._refractionTexture);
         }
     };
-    /**
-     * Returns the animatable textures.
-     * @param animatables Array of animatable textures.
-     */
     PBRSubSurfaceConfiguration.prototype.getAnimatables = function (animatables) {
         if (this._thicknessTexture && this._thicknessTexture.animations && this._thicknessTexture.animations.length > 0) {
             animatables.push(this._thicknessTexture);
@@ -514,10 +503,6 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
             animatables.push(this._refractionTexture);
         }
     };
-    /**
-     * Disposes the resources of the material.
-     * @param forceDisposeTextures - Forces the disposal of all textures.
-     */
     PBRSubSurfaceConfiguration.prototype.dispose = function (forceDisposeTextures) {
         if (forceDisposeTextures) {
             if (this._thicknessTexture) {
@@ -528,21 +513,10 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
             }
         }
     };
-    /**
-    * Get the current class name of the texture useful for serialization or dynamic coding.
-    * @returns "PBRSubSurfaceConfiguration"
-    */
     PBRSubSurfaceConfiguration.prototype.getClassName = function () {
         return "PBRSubSurfaceConfiguration";
     };
-    /**
-     * Add fallbacks to the effect fallbacks list.
-     * @param defines defines the Base texture to use.
-     * @param fallbacks defines the current fallback list.
-     * @param currentRank defines the current fallback rank.
-     * @returns the new fallback rank.
-     */
-    PBRSubSurfaceConfiguration.AddFallbacks = function (defines, fallbacks, currentRank) {
+    PBRSubSurfaceConfiguration.prototype.addFallbacks = function (defines, fallbacks, currentRank) {
         if (defines.SS_SCATTERING) {
             fallbacks.addFallback(currentRank++, "SS_SCATTERING");
         }
@@ -551,66 +525,31 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
         }
         return currentRank;
     };
-    /**
-     * Add the required uniforms to the current list.
-     * @param uniforms defines the current uniform list.
-     */
-    PBRSubSurfaceConfiguration.AddUniforms = function (uniforms) {
-        uniforms.push("vDiffusionDistance", "vTintColor", "vSubSurfaceIntensity", "vRefractionMicrosurfaceInfos", "vRefractionFilteringInfo", "vRefractionInfos", "vThicknessInfos", "vRefractionIntensityInfos", "vTranslucencyIntensityInfos", "vThicknessParam", "vRefractionPosition", "vRefractionSize", "refractionMatrix", "thicknessMatrix", "refractionIntensityMatrix", "translucencyIntensityMatrix", "scatteringDiffusionProfile");
-    };
-    /**
-     * Add the required samplers to the current list.
-     * @param samplers defines the current sampler list.
-     */
-    PBRSubSurfaceConfiguration.AddSamplers = function (samplers) {
+    PBRSubSurfaceConfiguration.prototype.getSamplers = function (samplers) {
         samplers.push("thicknessSampler", "refractionIntensitySampler", "translucencyIntensitySampler", "refractionSampler", "refractionSamplerLow", "refractionSamplerHigh");
     };
-    /**
-     * Add the required uniforms to the current buffer.
-     * @param uniformBuffer defines the current uniform buffer.
-     */
-    PBRSubSurfaceConfiguration.PrepareUniformBuffer = function (uniformBuffer) {
-        uniformBuffer.addUniform("vRefractionMicrosurfaceInfos", 4);
-        uniformBuffer.addUniform("vRefractionFilteringInfo", 2);
-        uniformBuffer.addUniform("vTranslucencyIntensityInfos", 2);
-        uniformBuffer.addUniform("vRefractionInfos", 4);
-        uniformBuffer.addUniform("refractionMatrix", 16);
-        uniformBuffer.addUniform("vThicknessInfos", 2);
-        uniformBuffer.addUniform("vRefractionIntensityInfos", 2);
-        uniformBuffer.addUniform("thicknessMatrix", 16);
-        uniformBuffer.addUniform("refractionIntensityMatrix", 16);
-        uniformBuffer.addUniform("translucencyIntensityMatrix", 16);
-        uniformBuffer.addUniform("vThicknessParam", 2);
-        uniformBuffer.addUniform("vDiffusionDistance", 3);
-        uniformBuffer.addUniform("vTintColor", 4);
-        uniformBuffer.addUniform("vSubSurfaceIntensity", 3);
-        uniformBuffer.addUniform("vRefractionPosition", 3);
-        uniformBuffer.addUniform("vRefractionSize", 3);
-        uniformBuffer.addUniform("scatteringDiffusionProfile", 1);
-    };
-    /**
-     * Makes a duplicate of the current configuration into another one.
-     * @param configuration define the config where to copy the info
-     */
-    PBRSubSurfaceConfiguration.prototype.copyTo = function (configuration) {
-        SerializationHelper.Clone(function () { return configuration; }, this);
-    };
-    /**
-     * Serializes this Sub Surface configuration.
-     * @returns - An object with the serialized config.
-     */
-    PBRSubSurfaceConfiguration.prototype.serialize = function () {
-        return SerializationHelper.Serialize(this);
-    };
-    /**
-     * Parses a anisotropy Configuration from a serialized object.
-     * @param source - Serialized object.
-     * @param scene Defines the scene we are parsing for
-     * @param rootUrl Defines the rootUrl to load from
-     */
-    PBRSubSurfaceConfiguration.prototype.parse = function (source, scene, rootUrl) {
-        var _this = this;
-        SerializationHelper.Parse(function () { return _this; }, source, scene, rootUrl);
+    PBRSubSurfaceConfiguration.prototype.getUniforms = function () {
+        return {
+            ubo: [
+                { name: "vRefractionMicrosurfaceInfos", size: 4, type: "vec4" },
+                { name: "vRefractionFilteringInfo", size: 2, type: "vec2" },
+                { name: "vTranslucencyIntensityInfos", size: 2, type: "vec2" },
+                { name: "vRefractionInfos", size: 4, type: "vec4" },
+                { name: "refractionMatrix", size: 16, type: "mat4" },
+                { name: "vThicknessInfos", size: 2, type: "vec2" },
+                { name: "vRefractionIntensityInfos", size: 2, type: "vec2" },
+                { name: "thicknessMatrix", size: 16, type: "mat4" },
+                { name: "refractionIntensityMatrix", size: 16, type: "mat4" },
+                { name: "translucencyIntensityMatrix", size: 16, type: "mat4" },
+                { name: "vThicknessParam", size: 2, type: "vec2" },
+                { name: "vDiffusionDistance", size: 3, type: "vec3" },
+                { name: "vTintColor", size: 4, type: "vec4" },
+                { name: "vSubSurfaceIntensity", size: 3, type: "vec3" },
+                { name: "vRefractionPosition", size: 3, type: "vec3" },
+                { name: "vRefractionSize", size: 3, type: "vec3" },
+                { name: "scatteringDiffusionProfile", size: 1, type: "float" },
+            ],
+        };
     };
     __decorate([
         serialize(),
@@ -700,6 +639,6 @@ var PBRSubSurfaceConfiguration = /** @class */ (function () {
         expandToProperty("_markAllSubMeshesAsTexturesDirty")
     ], PBRSubSurfaceConfiguration.prototype, "useGltfStyleTextures", void 0);
     return PBRSubSurfaceConfiguration;
-}());
+}(MaterialPluginBase));
 export { PBRSubSurfaceConfiguration };
 //# sourceMappingURL=pbrSubSurfaceConfiguration.js.map