@babylonjs-toolkit/next 9.12.1 → 9.12.1011

package/lib/scenemanager.js

@@ -9,7 +9,7 @@ import { Light } from '@babylonjs/core/Lights/light';
 import { Vector3, Quaternion, Vector2, Vector4, Matrix, TmpVectors } from '@babylonjs/core/Maths/math.vector';
 import { FreeCamera } from '@babylonjs/core/Cameras/freeCamera';
 import { Engine } from '@babylonjs/core/Engines/engine';
-import { SphericalPolynomial, HDRCubeTexture, EXRCubeTexture, SphericalHarmonics, Constants, PostProcess, BlurPostProcess, DefaultRenderingPipeline, SSAORenderingPipeline, SSRRenderingPipeline, MotionBlurPostProcess } from '@babylonjs/core';
+import { SphericalPolynomial, HDRCubeTexture, EXRCubeTexture, SphericalHarmonics, Constants, SerializationHelper, PostProcess, BlurPostProcess, DefaultRenderingPipeline, SSAORenderingPipeline, SSRRenderingPipeline, MotionBlurPostProcess } from '@babylonjs/core';
 import { Material } from '@babylonjs/core/Materials/material';
 import { InstancedMesh } from '@babylonjs/core/Meshes/instancedMesh';
 import { CreateNavigationPluginAsync } from '@babylonjs/addons';
@@ -53,7 +53,7 @@ import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial';
 import { MultiMaterial } from '@babylonjs/core/Materials/multiMaterial';
 import { HemisphericLight } from '@babylonjs/core/Lights/hemisphericLight';
 import { MaterialPluginBase } from '@babylonjs/core/Materials/materialPluginBase';
-import { ShaderLanguage, RawTexture2DArray, RawTexture, ShadowDepthWrapper, ImageProcessingConfiguration, ColorCurves } from '@babylonjs/core/Materials';
+import { ShaderLanguage, RawTexture, ShadowDepthWrapper, ImageProcessingConfiguration, ColorCurves, RawTexture2DArray } from '@babylonjs/core/Materials';
 import { SpotLight } from '@babylonjs/core/Lights/spotLight';
 import { UniversalCamera } from '@babylonjs/core/Cameras/universalCamera';
 import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight';
@@ -98,7 +98,7 @@ import { ShadowOnlyMaterial } from '@babylonjs/materials/shadowOnly/shadowOnlyMa
 import { SkyMaterial } from '@babylonjs/materials/sky/skyMaterial';
 import { WaterMaterial } from '@babylonjs/materials/water/waterMaterial';
 export class SceneManager {
-    static get Version() { return "9.12.1 - R1"; }
+    static get Version() { return "9.12.1011 - R1"; }
     static get Copyright() { return "All rights reserved (c) 2024 Mackey Kinard"; }
     static GetEngine(scene) {
         let result = null;
@@ -2824,9 +2824,15 @@ export class ScriptComponent {
         return SceneManager.GetSkinnedMesh(this.transform);
     }
     getTransformMesh() {
+        const atransform = this.transform;
+        if (atransform._skinnedMesh)
+            return atransform._skinnedMesh;
         return (this._transform instanceof Mesh) ? this._transform : null;
     }
     getAbstractMesh() {
+        const atransform = this.transform;
+        if (atransform._skinnedMesh)
+            return atransform._skinnedMesh;
         return (this._transform instanceof AbstractMesh) ? this._transform : null;
     }
     getInstancedMesh() {
@@ -3797,6 +3803,21 @@ export class CVTOOLS_unity_metadata {
             internal._sphericalPolynomialComputed = true;
         }
     }
+    static ApplyGlobalReflectionProbeDiffuse(texture, scene, createPolynomialsFromFaces = false) {
+        if (texture == null || createPolynomialsFromFaces === true)
+            return;
+        const sp = (scene != null) ? SceneManager.GetImageBasedLighting(scene) : null;
+        if (sp == null) {
+            CVTOOLS_unity_metadata.SuppressReflectionProbeDiffuse(texture);
+            return;
+        }
+        texture.sphericalPolynomial = sp;
+        const internal = texture._texture;
+        if (internal != null) {
+            internal._sphericalPolynomial = sp;
+            internal._sphericalPolynomialComputed = true;
+        }
+    }
     constructor(loader) {
         this.name = SceneManager.CVTOOLS_NAME;
         this.enabled = false;
@@ -4154,6 +4175,7 @@ export class CVTOOLS_unity_metadata {
                 }
             }
         }
+        const createPolynomialsFromFaces = scene.extras?.metadata?.createpolynomials ?? false;
         if (this._reflectionMap != null && this._reflectionCache != null) {
             let tindex = 0;
             for (const key in this._reflectionMap) {
@@ -4173,7 +4195,7 @@ export class CVTOOLS_unity_metadata {
                                             if (cachedCubeTexture != null) {
                                                 if (ctx.material != null && Utilities.HasOwnProperty(ctx.material, "reflectionTexture")) {
                                                     ctx.material.reflectionTexture = cachedCubeTexture;
-                                                    CVTOOLS_unity_metadata.SuppressReflectionProbeDiffuse(cachedCubeTexture);
+                                                    CVTOOLS_unity_metadata.ApplyGlobalReflectionProbeDiffuse(cachedCubeTexture, this._babylonScene, createPolynomialsFromFaces);
                                                 }
                                             }
                                             else {
@@ -4186,8 +4208,8 @@ export class CVTOOLS_unity_metadata {
                                                     buffer: bytes,
                                                     prefiltered: true,
                                                     forcedExtension: newCubeExtension,
-                                                    createPolynomials: false,
-                                                    onLoad: () => { CVTOOLS_unity_metadata.SuppressReflectionProbeDiffuse(newCubeTexture); },
+                                                    createPolynomials: createPolynomialsFromFaces,
+                                                    onLoad: () => { CVTOOLS_unity_metadata.ApplyGlobalReflectionProbeDiffuse(newCubeTexture, this._babylonScene, createPolynomialsFromFaces); },
                                                     onError: (msg, ex) => console.error(msg, ex),
                                                 });
                                                 newCubeTexture.name = ctx.name;
@@ -4200,7 +4222,7 @@ export class CVTOOLS_unity_metadata {
                                                 this._reflectionCache[ctx.mapkey] = newCubeTexture;
                                                 if (ctx.material != null && Utilities.HasOwnProperty(ctx.material, "reflectionTexture")) {
                                                     ctx.material.reflectionTexture = newCubeTexture;
-                                                    CVTOOLS_unity_metadata.SuppressReflectionProbeDiffuse(newCubeTexture);
+                                                    CVTOOLS_unity_metadata.ApplyGlobalReflectionProbeDiffuse(newCubeTexture, this._babylonScene, createPolynomialsFromFaces);
                                                 }
                                             }
                                         }
@@ -4605,28 +4627,19 @@ export class CVTOOLS_unity_metadata {
                     }
                 }
                 if (ascene._AmbientLight != null) {
-                    if (metadata.ambientskymode === "skybox") {
-                        ascene._AmbientLight.name = "Ambient Skybox";
-                        ascene._AmbientLight.diffuse = (metadata.ambientskycolor != null) ? Utilities.ParseColor3(metadata.ambientskycolor, Color3.Black()) : Color3.Black();
+                    ascene._AmbientLight.diffuse = (metadata.ambientskycolor != null) ? Utilities.ParseColor3(metadata.ambientskycolor, Color3.Gray()) : Color3.Gray();
+                    ascene._AmbientLight.specular = (metadata.ambientspecularcolor != null) ? Color3.Black() : Color3.Black();
+                    ascene._AmbientLight.groundColor = (metadata.ambientgroundcolor != null) ? Utilities.ParseColor3(metadata.ambientgroundcolor, Color3.Gray()) : Color3.Gray();
+                    ascene._AmbientLight.intensity = (metadata.ambientlightintensity != null) ? metadata.ambientlightintensity : 1.0;
+                    if (SceneManager.GetImageBasedLighting(babylonScene) != null) {
+                        ascene._AmbientLight.name = "Ambient Blacklight";
+                        ascene._AmbientLight.diffuse = Color3.Black();
                         ascene._AmbientLight.specular = Color3.Black();
-                        ascene._AmbientLight.groundColor = (metadata.ambientgroundcolor != null) ? Utilities.ParseColor3(metadata.ambientgroundcolor, Color3.Black()) : Color3.Black();
-                        if (metadata.ambientlightintensity != null)
-                            ascene._AmbientLight.intensity = metadata.ambientlightintensity;
-                        ascene._AmbientLight.intensity *= SceneManager.AmbientLightIntensity;
-                        ascene._AmbientLight.intensityMode = Light.INTENSITYMODE_ILLUMINANCE;
-                    }
-                    else {
-                        if (metadata.ambientskycolor != null)
-                            ascene._AmbientLight.diffuse = Utilities.ParseColor3(metadata.ambientskycolor, Color3.Gray());
-                        if (metadata.ambientspecularcolor != null)
-                            ascene._AmbientLight.specular = Color3.Black();
-                        if (metadata.ambientgroundcolor != null)
-                            ascene._AmbientLight.groundColor = Utilities.ParseColor3(metadata.ambientgroundcolor, Color3.Gray());
-                        if (metadata.ambientlightintensity != null)
-                            ascene._AmbientLight.intensity = (metadata.ambientlightintensity * 0.5);
-                        ascene._AmbientLight.intensity *= SceneManager.AmbientLightIntensity;
-                        ascene._AmbientLight.intensityMode = Light.INTENSITYMODE_ILLUMINANCE;
+                        ascene._AmbientLight.groundColor = Color3.Black();
+                        ascene._AmbientLight.intensity = 1.0;
                     }
+                    ascene._AmbientLight.intensity *= SceneManager.AmbientLightIntensity;
+                    ascene._AmbientLight.intensityMode = Light.INTENSITYMODE_ILLUMINANCE;
                 }
             }
             if (metadata.fogmode != null) {
@@ -4844,7 +4857,7 @@ export class CVTOOLS_unity_metadata {
             const IBL_MAX = 10.0;
             const LEVEL_MAX = 1000.0;
             const derivedRefl = (refl != null) ? refl : (ibl * lvl);
-            const diffuseIbl = 1.0;
+            const diffuseIbl = Scalar.Clamp(ibl, 0.0, IBL_MAX);
             const specIbl = Scalar.Clamp(derivedRefl, 0.0, LEVEL_MAX);
             const hasDiffuseIbl = Array.isArray(environment.sh) && environment.sh.length === 27;
             const useUnitySH = (mode === 0 && hasDiffuseIbl === true);
@@ -5483,6 +5496,7 @@ export class CVTOOLS_unity_metadata {
 CVTOOLS_unity_metadata.IBL_TINY_VALUE = 0.001;
 CVTOOLS_unity_metadata.IBL_SPEC_FACTOR = 1.0;
 CVTOOLS_unity_metadata.IBL_PROBE_FACTOR = 1.0;
+CVTOOLS_unity_metadata._boxProjectionShaderPatched = false;
 CVTOOLS_unity_metadata.ScriptBundleCache = {};
 export class CVTOOLS_babylon_mesh {
     constructor(loader) {
@@ -5530,10 +5544,18 @@ export class CustomShaderMaterial extends PBRMaterial {
         this.shader = null;
         this.plugin = null;
         this._unityLightingPlugin = null;
+        this._skinArray = false;
+        this._skinArrayNormal = false;
+        this._skinArrayMetalRough = false;
+        this._skinArrayEmissive = false;
+        this._skinLayerUniform = false;
+        this._skinArraySwitchingPlugin = null;
         this.shader = "CustomShaderMaterial";
         this.addFloatUniform("tkIblDiffuseScale", 1.0);
         this.addFloatUniform("tkIblSpecularScale", 1.0);
+        this.addFloatUniform("tkSkinLayerUni", 0.0);
         this._unityLightingPlugin = new UnityStyleLightingPlugin(this, this.shader);
+        this._skinArraySwitchingPlugin = new SkinArraySwitchingPlugin(this);
     }
     initMaterial() {
         if (this["awake"])
@@ -5567,6 +5589,108 @@ export class CustomShaderMaterial extends PBRMaterial {
         this.plugin?.markAllDefinesAsDirty();
         this._unityLightingPlugin?.markAllDefinesAsDirty();
     }
+    enableSkinArray(layerUniform = false) {
+        this._skinArray = true;
+        this._skinLayerUniform = layerUniform;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        this.plugin?.markAllDefinesAsDirty();
+        this._unityLightingPlugin?.markAllDefinesAsDirty();
+        this._skinArraySwitchingPlugin?.markAllDefinesAsDirty();
+        return this;
+    }
+    setSkinLayer(layer) {
+        this._skinLayerUniform = true;
+        this.setFloatValue("tkSkinLayerUni", Math.max(0, Math.floor(layer)));
+        return this;
+    }
+    enableSkinArrayNormal(enabled = true) {
+        this._skinArrayNormal = enabled;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        this.plugin?.markAllDefinesAsDirty();
+        this._unityLightingPlugin?.markAllDefinesAsDirty();
+        this._skinArraySwitchingPlugin?.markAllDefinesAsDirty();
+        return this;
+    }
+    enableSkinArrayMetalRough(enabled = true) {
+        this._skinArrayMetalRough = enabled;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        this.plugin?.markAllDefinesAsDirty();
+        this._unityLightingPlugin?.markAllDefinesAsDirty();
+        this._skinArraySwitchingPlugin?.markAllDefinesAsDirty();
+        return this;
+    }
+    enableSkinArrayEmissive(enabled = true) {
+        this._skinArrayEmissive = enabled;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        this.plugin?.markAllDefinesAsDirty();
+        this._unityLightingPlugin?.markAllDefinesAsDirty();
+        this._skinArraySwitchingPlugin?.markAllDefinesAsDirty();
+        return this;
+    }
+    setSkinArrayLayerMode(uniform) {
+        this._skinLayerUniform = uniform;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        this._skinArraySwitchingPlugin?.markAllDefinesAsDirty();
+        return this;
+    }
+    addTextureArrayUniform(name, texture) {
+        if (this._samplers.indexOf(name) === -1)
+            this._samplers.push(name);
+        this._textures[name] = texture;
+        this.markTextureAsRaw(name);
+        return this;
+    }
+    get skinArray() { return this._skinArray; }
+    get skinArrayNormal() { return this._skinArrayNormal; }
+    get skinArrayMetalRough() { return this._skinArrayMetalRough; }
+    get skinArrayEmissive() { return this._skinArrayEmissive; }
+    get skinArrayActive() {
+        return this._skinArray || this._skinArrayNormal || this._skinArrayMetalRough || this._skinArrayEmissive;
+    }
+    get skinLayerUniform() { return this._skinLayerUniform; }
+    clone(name, cloneTexturesOnlyOnce = true, rootUrl = "") {
+        const scene = this.getScene();
+        const ctor = this.constructor;
+        const result = SerializationHelper.Clone(() => new ctor(name, scene), this, { cloneTexturesOnlyOnce });
+        if (result == null)
+            return result;
+        result.id = name;
+        result.name = name;
+        if (this.stencil && result.stencil)
+            this.stencil.copyTo(result.stencil);
+        this.copyCustomStateTo(result);
+        return result;
+    }
+    copyCustomStateTo(result) {
+        result.universalMaterial = this.universalMaterial;
+        result._defines = Object.assign({}, this._defines);
+        result._uniforms = this._uniforms.slice();
+        result._samplers = this._samplers.slice();
+        result._attributes = this._attributes.slice();
+        result._ubos = (this._ubos != null) ? this._ubos.map((u) => ({ name: u.name, size: u.size, type: u.type, arraySize: u.arraySize })) : null;
+        result._textures = Object.assign({}, this._textures);
+        result._noMatrixTextures = (this._noMatrixTextures != null) ? new Set(this._noMatrixTextures) : null;
+        result._vectors4 = {};
+        for (const n in this._vectors4)
+            result._vectors4[n] = this._vectors4[n].clone();
+        result._vectors3 = {};
+        for (const n in this._vectors3)
+            result._vectors3[n] = this._vectors3[n].clone();
+        result._vectors2 = {};
+        for (const n in this._vectors2)
+            result._vectors2[n] = this._vectors2[n].clone();
+        result._floats = Object.assign({}, this._floats);
+        result._bools = Object.assign({}, this._bools);
+        result._skinArray = this._skinArray;
+        result._skinArrayNormal = this._skinArrayNormal;
+        result._skinArrayMetalRough = this._skinArrayMetalRough;
+        result._skinArrayEmissive = this._skinArrayEmissive;
+        result._skinLayerUniform = this._skinLayerUniform;
+        result.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        result.plugin?.markAllDefinesAsDirty();
+        result._unityLightingPlugin?.markAllDefinesAsDirty();
+        result._skinArraySwitchingPlugin?.markAllDefinesAsDirty();
+    }
     addTextureUniform(name, texture) {
         this.checkSampler(name, texture);
         this._textures[name] = texture;
@@ -6009,6 +6133,301 @@ export class UnityStyleLightingPlugin extends CustomShaderMaterialPlugin {
         this.getCustomShaderMaterial().updateCustomBindings(uniformBuffer);
     }
 }
+export class SkinArraySwitchingPlugin extends CustomShaderMaterialPlugin {
+    constructor(material) {
+        super(material, "SkinArraySwitchingPlugin", 21, { TOOLKIT_SKIN_ARRAY: false, TOOLKIT_SKIN_LAYER_UNIFORM: false, TOOLKIT_SKIN_ARRAY_ALBEDO: false, TOOLKIT_SKIN_ARRAY_NORMAL: false, TOOLKIT_SKIN_ARRAY_MR: false, TOOLKIT_SKIN_ARRAY_EMISSIVE: false }, true, true, false);
+    }
+    isCompatible(shaderLanguage) {
+        return (shaderLanguage === ShaderLanguage.WGSL || shaderLanguage === ShaderLanguage.GLSL);
+    }
+    getClassName() {
+        return "SkinArraySwitchingPlugin";
+    }
+    getAttributes(attributes, scene, mesh) {
+        const mat = this.getCustomShaderMaterial();
+        if (!mat.skinArrayActive)
+            return;
+        if (mat.skinLayerUniform !== true && attributes.indexOf("tkSkinLayer") === -1)
+            attributes.push("tkSkinLayer");
+    }
+    getSamplers(samplers) {
+        const mat = this.getCustomShaderMaterial();
+        if (!mat.skinArrayActive)
+            return;
+        const customSamplers = mat.getCustomSamplers();
+        if (customSamplers != null) {
+            for (const s of customSamplers)
+                if (samplers.indexOf(s) === -1)
+                    samplers.push(s);
+        }
+    }
+    prepareDefines(defines, scene, mesh) {
+        const mat = this.getCustomShaderMaterial();
+        defines.TOOLKIT_SKIN_ARRAY = !!mat.skinArrayActive;
+        defines.TOOLKIT_SKIN_LAYER_UNIFORM = !!mat.skinLayerUniform;
+        defines.TOOLKIT_SKIN_ARRAY_ALBEDO = !!mat.skinArray;
+        defines.TOOLKIT_SKIN_ARRAY_NORMAL = !!mat.skinArrayNormal;
+        defines.TOOLKIT_SKIN_ARRAY_MR = !!mat.skinArrayMetalRough;
+        defines.TOOLKIT_SKIN_ARRAY_EMISSIVE = !!mat.skinArrayEmissive;
+    }
+    getCustomCode(shaderType, shaderLanguage) {
+        const wgsl = (shaderLanguage === ShaderLanguage.WGSL);
+        if (shaderType === "vertex") {
+            if (wgsl) {
+                return {
+                    CUSTOM_VERTEX_DEFINITIONS: this.getWGSLVertexDefinitions(),
+                    CUSTOM_VERTEX_MAIN_END: this.getWGSLVertexMainEnd()
+                };
+            }
+            return {
+                CUSTOM_VERTEX_DEFINITIONS: this.getGLSLVertexDefinitions(),
+                CUSTOM_VERTEX_MAIN_END: this.getGLSLVertexMainEnd()
+            };
+        }
+        if (shaderType === "fragment") {
+            if (wgsl) {
+                return {
+                    CUSTOM_FRAGMENT_DEFINITIONS: this.getWGSLFragmentDefinitions(),
+                    CUSTOM_FRAGMENT_UPDATE_ALBEDO: this.getWGSLAlbedoCode() + this.getWGSLMetalRoughSampleCode(),
+                    CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.getWGSLNormalCode(),
+                    CUSTOM_FRAGMENT_UPDATE_METALLICROUGHNESS: this.getWGSLMetalRoughApplyCode(),
+                    CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION: this.getWGSLEmissiveCode()
+                };
+            }
+            return {
+                CUSTOM_FRAGMENT_DEFINITIONS: this.getGLSLFragmentDefinitions(),
+                CUSTOM_FRAGMENT_UPDATE_ALBEDO: this.getGLSLAlbedoCode() + this.getGLSLMetalRoughSampleCode(),
+                CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.getGLSLNormalCode(),
+                CUSTOM_FRAGMENT_UPDATE_METALLICROUGHNESS: this.getGLSLMetalRoughApplyCode(),
+                CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION: this.getGLSLEmissiveCode()
+            };
+        }
+        return null;
+    }
+    getGLSLVertexDefinitions() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY
+        #ifndef TOOLKIT_SKIN_V_DEFINED
+        #define TOOLKIT_SKIN_V_DEFINED
+        #ifdef TOOLKIT_SKIN_LAYER_UNIFORM
+        uniform float tkSkinLayerUni;
+        #else
+        attribute float tkSkinLayer;
+        #endif
+        varying float vSkinLayer;
+        varying vec2 vSkinUV;
+        #endif
+        #endif
+      `;
+    }
+    getGLSLVertexMainEnd() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY
+        #ifdef UV1
+          #ifdef TOOLKIT_SKIN_LAYER_UNIFORM
+            vSkinLayer = tkSkinLayerUni;
+          #else
+            vSkinLayer = tkSkinLayer;
+          #endif
+          vSkinUV = uv;
+        #else
+          vSkinLayer = 0.0;
+          vSkinUV = vec2(0.0);
+        #endif
+        #endif
+      `;
+    }
+    getGLSLFragmentDefinitions() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY
+        #ifndef TOOLKIT_SKIN_F_DEFINED
+        #define TOOLKIT_SKIN_F_DEFINED
+        varying float vSkinLayer;
+        varying vec2 vSkinUV;
+        #ifdef TOOLKIT_SKIN_ARRAY_ALBEDO
+        uniform sampler2DArray tkAlbedoArray;
+        #endif
+        #ifdef TOOLKIT_SKIN_ARRAY_NORMAL
+        uniform sampler2DArray tkNormalArray;
+        #endif
+        #ifdef TOOLKIT_SKIN_ARRAY_MR
+        uniform sampler2DArray tkMetalRoughArray;
+        vec2 _tkMR;
+        #endif
+        #ifdef TOOLKIT_SKIN_ARRAY_EMISSIVE
+        uniform sampler2DArray tkEmissiveArray;
+        #endif
+        #endif
+        #endif
+      `;
+    }
+    getGLSLAlbedoCode() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY_ALBEDO
+        {
+          float _tkLayer = floor(vSkinLayer + 0.5);
+          vec4 _tkAlb = texture(tkAlbedoArray, vec3(vSkinUV, _tkLayer));
+          #ifdef GAMMAALBEDO
+            surfaceAlbedo = toLinearSpace(_tkAlb.rgb) * vAlbedoColor.rgb;
+          #else
+            surfaceAlbedo = _tkAlb.rgb * vAlbedoColor.rgb;
+          #endif
+          #ifdef ALPHATEST
+            if (_tkAlb.a < alphaCutOff) discard;
+          #endif
+        }
+        #endif
+      `;
+    }
+    getGLSLNormalCode() {
+        return `
+        #if defined(TOOLKIT_SKIN_ARRAY) && defined(TOOLKIT_SKIN_ARRAY_NORMAL) && defined(BUMP) && defined(TANGENT) && defined(NORMAL)
+        {
+          vec3 _tkNrmTexel = texture(tkNormalArray, vec3(vSkinUV, floor(vSkinLayer + 0.5))).xyz;
+          normalW = perturbNormal(vTBN, _tkNrmTexel, vBumpInfos.y);
+        }
+        #endif
+      `;
+    }
+    getGLSLMetalRoughSampleCode() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY_MR
+        {
+          vec4 _tkMRtexel = texture(tkMetalRoughArray, vec3(vSkinUV, floor(vSkinLayer + 0.5)));
+          _tkMR = vec2(_tkMRtexel.b, _tkMRtexel.g);
+        }
+        #endif
+      `;
+    }
+    getGLSLMetalRoughApplyCode() {
+        return `
+        #if defined(TOOLKIT_SKIN_ARRAY_MR) && defined(METALLICWORKFLOW)
+        metallicRoughness.r = _tkMR.x;
+        metallicRoughness.g = _tkMR.y;
+        #endif
+      `;
+    }
+    getGLSLEmissiveCode() {
+        return `
+        #if defined(TOOLKIT_SKIN_ARRAY) && defined(TOOLKIT_SKIN_ARRAY_EMISSIVE)
+        {
+          vec3 _tkEmis = texture(tkEmissiveArray, vec3(vSkinUV, floor(vSkinLayer + 0.5))).rgb;
+          finalEmissive = toLinearSpace(_tkEmis);
+        }
+        #endif
+      `;
+    }
+    getWGSLVertexDefinitions() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY
+        #ifndef TOOLKIT_SKIN_LAYER_UNIFORM
+        attribute tkSkinLayer: f32;
+        #endif
+        varying vSkinLayer: f32;
+        varying vSkinUV: vec2<f32>;
+        #endif
+      `;
+    }
+    getWGSLVertexMainEnd() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY
+        #ifdef UV1
+          #ifdef TOOLKIT_SKIN_LAYER_UNIFORM
+            vertexOutputs.vSkinLayer = uniforms.tkSkinLayerUni;
+          #else
+            vertexOutputs.vSkinLayer = vertexInputs.tkSkinLayer;
+          #endif
+          vertexOutputs.vSkinUV = vertexInputs.uv;
+        #else
+          vertexOutputs.vSkinLayer = 0.0;
+          vertexOutputs.vSkinUV = vec2f(0.0);
+        #endif
+        #endif
+      `;
+    }
+    getWGSLFragmentDefinitions() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY
+        varying vSkinLayer: f32;
+        varying vSkinUV: vec2<f32>;
+        #ifdef TOOLKIT_SKIN_ARRAY_ALBEDO
+        var tkAlbedoArray: texture_2d_array<f32>;
+        var tkAlbedoArraySampler: sampler;
+        #endif
+        #ifdef TOOLKIT_SKIN_ARRAY_NORMAL
+        var tkNormalArray: texture_2d_array<f32>;
+        var tkNormalArraySampler: sampler;
+        #endif
+        #ifdef TOOLKIT_SKIN_ARRAY_MR
+        var tkMetalRoughArray: texture_2d_array<f32>;
+        var tkMetalRoughArraySampler: sampler;
+        var<private> _tkMR: vec2<f32>;
+        #endif
+        #ifdef TOOLKIT_SKIN_ARRAY_EMISSIVE
+        var tkEmissiveArray: texture_2d_array<f32>;
+        var tkEmissiveArraySampler: sampler;
+        #endif
+        #endif
+      `;
+    }
+    getWGSLAlbedoCode() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY_ALBEDO
+        {
+          let _tkLayer = i32(fragmentInputs.vSkinLayer + 0.5);
+          let _tkAlb = textureSample(tkAlbedoArray, tkAlbedoArraySampler, fragmentInputs.vSkinUV, _tkLayer);
+          #ifdef GAMMAALBEDO
+            surfaceAlbedo = toLinearSpaceVec3(_tkAlb.rgb) * vAlbedoColor.rgb;
+          #else
+            surfaceAlbedo = _tkAlb.rgb * vAlbedoColor.rgb;
+          #endif
+          #ifdef ALPHATEST
+            if (_tkAlb.a < alphaCutOff) { discard; }
+          #endif
+        }
+        #endif
+      `;
+    }
+    getWGSLNormalCode() {
+        return `
+        #if defined(TOOLKIT_SKIN_ARRAY) && defined(TOOLKIT_SKIN_ARRAY_NORMAL) && defined(BUMP) && defined(TANGENT) && defined(NORMAL)
+        {
+          let _tkNrmTexel = textureSample(tkNormalArray, tkNormalArraySampler, fragmentInputs.vSkinUV, i32(fragmentInputs.vSkinLayer + 0.5)).rgb;
+          let _tkNrmTBN = mat3x3<f32>(fragmentInputs.vTBN0, fragmentInputs.vTBN1, fragmentInputs.vTBN2);
+          normalW = perturbNormal(_tkNrmTBN, _tkNrmTexel, uniforms.vBumpInfos.y);
+        }
+        #endif
+      `;
+    }
+    getWGSLMetalRoughSampleCode() {
+        return `
+        #ifdef TOOLKIT_SKIN_ARRAY_MR
+        {
+          let _tkMRtexel = textureSample(tkMetalRoughArray, tkMetalRoughArraySampler, fragmentInputs.vSkinUV, i32(fragmentInputs.vSkinLayer + 0.5));
+          _tkMR = vec2<f32>(_tkMRtexel.b, _tkMRtexel.g);
+        }
+        #endif
+      `;
+    }
+    getWGSLMetalRoughApplyCode() {
+        return `
+        #if defined(TOOLKIT_SKIN_ARRAY_MR) && defined(METALLICWORKFLOW)
+        metallicRoughness.r = _tkMR.x;
+        metallicRoughness.g = _tkMR.y;
+        #endif
+      `;
+    }
+    getWGSLEmissiveCode() {
+        return `
+        #if defined(TOOLKIT_SKIN_ARRAY) && defined(TOOLKIT_SKIN_ARRAY_EMISSIVE)
+        {
+          let _tkEmis = textureSample(tkEmissiveArray, tkEmissiveArraySampler, fragmentInputs.vSkinUV, i32(fragmentInputs.vSkinLayer + 0.5)).rgb;
+          finalEmissive = toLinearSpaceVec3(_tkEmis);
+        }
+        #endif
+      `;
+    }
+}
 export class UniversalShaderMaterial extends CustomShaderMaterial {
     constructor(name, scene) {
         super(name, scene);
@@ -11736,8 +12155,10 @@ export class VertexAnimationMaterial extends CustomShaderMaterial {
     constructor(name, scene) {
         super(name, scene);
         this.controller = null;
-        this.runtimeAlbedoSkins = null;
-        this.runtimeNormalSkins = null;
+        this._vatSkinArray = false;
+        this._vatSkinArrayNormal = false;
+        this._vatSkinArrayMetalRough = false;
+        this._vatSkinArrayEmissive = false;
         this.shader = this.getShaderName();
         this.addAttribute("g_vatAnim0");
         this.addAttribute("g_vatAnim1");
@@ -11793,97 +12214,90 @@ export class VertexAnimationMaterial extends CustomShaderMaterial {
         cloned.alpha = this.alpha;
         cloned.alphaMode = this.alphaMode;
         cloned.transparencyMode = this.transparencyMode;
-        cloned.runtimeAlbedoSkins = this.runtimeAlbedoSkins;
-        cloned.runtimeNormalSkins = this.runtimeNormalSkins;
-        cloned._notifyPluginOfRuntimeSkinChange();
+        if (this._vatSkinArray) {
+            const arr = this.getTextureValue("tkAlbedoArray");
+            if (arr != null)
+                cloned.addTextureArrayUniform("tkAlbedoArray", arr);
+            cloned.enableVatSkinArray();
+        }
+        if (this._vatSkinArrayNormal) {
+            const narr = this.getTextureValue("tkNormalArray");
+            if (narr != null)
+                cloned.addTextureArrayUniform("tkNormalArray", narr);
+            cloned.enableVatSkinArrayNormal();
+        }
+        if (this._vatSkinArrayMetalRough) {
+            const mrarr = this.getTextureValue("tkMetalRoughArray");
+            if (mrarr != null)
+                cloned.addTextureArrayUniform("tkMetalRoughArray", mrarr);
+            cloned.enableVatSkinArrayMetalRough();
+        }
+        if (this._vatSkinArrayEmissive) {
+            const earr = this.getTextureValue("tkEmissiveArray");
+            if (earr != null)
+                cloned.addTextureArrayUniform("tkEmissiveArray", earr);
+            cloned.enableVatSkinArrayEmissive();
+        }
         return cloned;
     }
-    setRuntimeSkinArrays(albedoArray, normalArray, nullOutDefaults = true) {
-        this.runtimeAlbedoSkins = albedoArray || null;
-        this.runtimeNormalSkins = normalArray || null;
-        if (nullOutDefaults) {
-            this.albedoTexture = null;
-            this.bumpTexture = null;
-        }
-        this._notifyPluginOfRuntimeSkinChange();
+    enableVatSkinArray() {
+        this._vatSkinArray = true;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
+        return this;
     }
-    clearRuntimeSkinArrays() {
-        this.runtimeAlbedoSkins = null;
-        this.runtimeNormalSkins = null;
-        this._notifyPluginOfRuntimeSkinChange();
+    disableVatSkinArray() {
+        this._vatSkinArray = false;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
     }
-    async installSkinsFromUrlsAsync(layers, width, height, options) {
-        if (!layers || layers.length === 0) {
-            throw new Error("VertexAnimationMaterial.installSkinsFromUrlsAsync: layers list is empty.");
-        }
-        const opts = options || {};
-        const nullOutDefaults = opts.nullOutDefaults !== false;
-        const rootUrl = opts.rootUrl || "";
-        const generateMipMaps = opts.generateMipMaps !== false;
-        const samplingMode = (opts.samplingMode != null) ? opts.samplingMode : Texture.TRILINEAR_SAMPLINGMODE;
-        const scene = this.getScene();
-        const layerCount = layers.length;
-        const bytesPerLayer = width * height * 4;
-        const albedoData = new Uint8Array(bytesPerLayer * layerCount);
-        const normalData = new Uint8Array(bytesPerLayer * layerCount);
-        const resolveUrl = (rel) => {
-            if (!rel)
-                return "";
-            if (rel.indexOf("://") >= 0 || rel.indexOf("blob:") === 0 || rel.indexOf("data:") === 0 || rel.indexOf("/") === 0)
-                return rel;
-            if (rootUrl) {
-                const sep = rootUrl.charAt(rootUrl.length - 1) === "/" ? "" : "/";
-                return rootUrl + sep + rel;
-            }
-            return rel;
-        };
-        const loadAndCopy = (url, dst, layerIdx, label) => {
-            return new Promise((resolve, reject) => {
-                const fullUrl = resolveUrl(url);
-                const tex = new Texture(fullUrl, scene, true, true, samplingMode, () => {
-                    const size = tex.getSize();
-                    if (size.width !== width || size.height !== height) {
-                        tex.dispose();
-                        reject(new Error(`${label} '${fullUrl}' is ${size.width}x${size.height}, expected ${width}x${height}.`));
-                        return;
-                    }
-                    const pixelsPromise = tex.readPixels();
-                    const onPixels = (pixels) => {
-                        if (!pixels) {
-                            tex.dispose();
-                            reject(new Error(`${label} '${fullUrl}': readPixels returned null.`));
-                            return;
-                        }
-                        dst.set(new Uint8Array(pixels.buffer, pixels.byteOffset, pixels.byteLength), layerIdx * bytesPerLayer);
-                        tex.dispose();
-                        resolve();
-                    };
-                    if (pixelsPromise && typeof pixelsPromise.then === "function") {
-                        pixelsPromise.then(onPixels).catch((e) => { tex.dispose(); reject(e); });
-                    }
-                    else {
-                        onPixels(pixelsPromise);
-                    }
-                }, (msg) => reject(new Error(`${label} '${fullUrl}' load failed: ${msg}`)));
-            });
-        };
-        const tasks = [];
-        for (let i = 0; i < layerCount; i++) {
-            tasks.push(loadAndCopy(layers[i].albedo, albedoData, i, "Skin albedo"));
-            tasks.push(loadAndCopy(layers[i].normal, normalData, i, "Skin normal"));
-        }
-        await Promise.all(tasks);
-        const albedoArray = RawTexture2DArray.CreateRGBATexture(albedoData, width, height, layerCount, scene, generateMipMaps, false, samplingMode);
-        const normalArray = RawTexture2DArray.CreateRGBATexture(normalData, width, height, layerCount, scene, generateMipMaps, false, samplingMode);
-        normalArray.gammaSpace = false;
-        this.setRuntimeSkinArrays(albedoArray, normalArray, nullOutDefaults);
-    }
-    _notifyPluginOfRuntimeSkinChange() {
-        const plug = this.plugin;
-        if (plug && typeof plug.onRuntimeSkinArraysChanged === "function") {
-            plug.onRuntimeSkinArraysChanged();
-        }
+    enableVatSkinArrayNormal() {
+        this._vatSkinArrayNormal = true;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
+        return this;
+    }
+    disableVatSkinArrayNormal() {
+        this._vatSkinArrayNormal = false;
         this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
+    }
+    enableVatSkinArrayMetalRough() {
+        this._vatSkinArrayMetalRough = true;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
+        return this;
+    }
+    disableVatSkinArrayMetalRough() {
+        this._vatSkinArrayMetalRough = false;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
+    }
+    enableVatSkinArrayEmissive() {
+        this._vatSkinArrayEmissive = true;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
+        return this;
+    }
+    disableVatSkinArrayEmissive() {
+        this._vatSkinArrayEmissive = false;
+        this.markAsDirty(Constants.MATERIAL_AllDirtyFlag);
+        if (this.plugin)
+            this.plugin.markAllDefinesAsDirty();
+    }
+    get vatSkinArray() { return this._vatSkinArray; }
+    get vatSkinArrayNormal() { return this._vatSkinArrayNormal; }
+    get vatSkinArrayMetalRough() { return this._vatSkinArrayMetalRough; }
+    get vatSkinArrayEmissive() { return this._vatSkinArrayEmissive; }
+    get vatSkinArrayActive() {
+        return this._vatSkinArray || this._vatSkinArrayNormal || this._vatSkinArrayMetalRough || this._vatSkinArrayEmissive;
     }
 }
 export class VertexAnimationController {
@@ -11918,15 +12332,15 @@ export class VertexAnimationController {
         }
         return result;
     }
-    static SetSkinIndex(mesh, skinIndex) {
+    static SetAtlasCellIndex(mesh, cellIndex) {
         if (!mesh)
             return;
-        mesh.runtimeSkinIndex = Math.max(0, Math.floor(skinIndex || 0));
+        mesh.atlasCellIndex = Math.max(0, Math.floor(cellIndex || 0));
     }
-    static GetSkinIndex(mesh) {
+    static GetAtlasCellIndex(mesh) {
         if (!mesh)
             return 0;
-        const v = mesh.runtimeSkinIndex;
+        const v = mesh.atlasCellIndex;
         return (typeof v === "number" && isFinite(v) && v >= 0) ? Math.floor(v) : 0;
     }
     static DisposeAll(scene) {
@@ -12010,39 +12424,6 @@ export class VertexAnimationController {
     }
     setSpeed(speed) { this._speed = speed; }
     setLoop(loop) { this._manualLoopOverride = loop; this._loop = loop; }
-    setRuntimeSkinArrays(albedoArray, normalArray, nullOutDefaults = true) {
-        for (let i = 0; i < this._plugins.length; i++) {
-            const plugin = this._plugins[i];
-            const mat = plugin.getCustomShaderMaterial();
-            if (mat)
-                mat.setRuntimeSkinArrays(albedoArray, normalArray, nullOutDefaults);
-        }
-    }
-    clearRuntimeSkinArrays() {
-        for (let i = 0; i < this._plugins.length; i++) {
-            const plugin = this._plugins[i];
-            const mat = plugin.getCustomShaderMaterial();
-            if (mat)
-                mat.clearRuntimeSkinArrays();
-        }
-    }
-    async installSkinsFromUrlsAsync(layers, width, height, options) {
-        if (this._plugins.length === 0) {
-            throw new Error("VertexAnimationController.installSkinsFromUrlsAsync: no registered VAT materials.");
-        }
-        const opts = options || {};
-        const effectiveOptions = { ...opts, rootUrl: opts.rootUrl || this.rootUrl };
-        const nullOutDefaults = opts.nullOutDefaults !== false;
-        const firstMat = this._plugins[0].getCustomShaderMaterial();
-        await firstMat.installSkinsFromUrlsAsync(layers, width, height, effectiveOptions);
-        const sharedAlbedo = firstMat.runtimeAlbedoSkins;
-        const sharedNormal = firstMat.runtimeNormalSkins;
-        for (let i = 1; i < this._plugins.length; i++) {
-            const mat = this._plugins[i].getCustomShaderMaterial();
-            if (mat)
-                mat.setRuntimeSkinArrays(sharedAlbedo, sharedNormal, nullOutDefaults);
-        }
-    }
     setCurrentTime(time) {
         if (!this._currentClip)
             return;
@@ -12252,9 +12633,9 @@ export class VertexAnimationController {
                 const s = current.settings;
                 anim0.set(this._time * s.vertexfps, s.vertexframes, current.fromRow, this._blendWeight);
                 const loopFlag = this._loopBlend ? 1.0 : 0.0;
-                const meshSkinRaw = imesh.runtimeSkinIndex;
-                const meshSkin = (typeof meshSkinRaw === "number" && meshSkinRaw >= 0) ? meshSkinRaw : 0;
-                anim1.w = meshSkin * 2.0 + loopFlag;
+                const cellRaw = imesh.atlasCellIndex;
+                const cell = (typeof cellRaw === "number" && cellRaw >= 0) ? Math.floor(cellRaw) : 0;
+                anim1.w = cell * 2.0 + loopFlag;
                 const prev = this.getPreviousRendererClip(rendererGuid);
                 if (prev && this._previousClip && this._blendWeight < 0.999 && this._isRendererPositionReady(prev)) {
                     const ps = prev.settings;
@@ -12424,17 +12805,17 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
         super(customMaterial, shaderName, 100, {
             VERTEXANIMATIONMATERIAL: false,
             VAT_NORMAL_SEPARATE: false,
-            RUNTIME_SKINS_ALBEDO: false,
-            RUNTIME_SKINS_NORMAL: false,
-            RUNTIME_SKINS_NORMAL_DERIVE_TBN: false
+            VAT_SKIN_ARRAY: false,
+            VAT_SKIN_ARRAY_ALBEDO: false,
+            VAT_SKIN_ARRAY_NORMAL: false,
+            VAT_SKIN_ARRAY_MR: false,
+            VAT_SKIN_ARRAY_EMISSIVE: false
         });
         this.vertexAnimations = null;
         this.controller = null;
         this._rendererTargets = [];
         this._targetRendererGuid = "";
         this._placeholderTexture = null;
-        this._placeholderAlbedoArray = null;
-        this._placeholderNormalArray = null;
         this._cc_posTex = null;
         this._cc_normTex = null;
         this._cc_prevPosTex = null;
@@ -12456,24 +12837,12 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
         customMaterial.setTextureValue("vatNormal", this._placeholderTexture);
         customMaterial.setTextureValue("vatPrevPosition", this._placeholderTexture);
         customMaterial.setTextureValue("vatPrevNormal", this._placeholderTexture);
-        const greyArr = new Uint8Array([128, 128, 128, 255]);
-        const flatNormalArr = new Uint8Array([128, 128, 255, 255]);
-        this._placeholderAlbedoArray = RawTexture2DArray.CreateRGBATexture(greyArr, 1, 1, 1, scene, false, false, Texture.NEAREST_SAMPLINGMODE);
-        this._placeholderNormalArray = RawTexture2DArray.CreateRGBATexture(flatNormalArr, 1, 1, 1, scene, false, false, Texture.NEAREST_SAMPLINGMODE);
     }
     dispose() {
         if (this._placeholderTexture) {
             this._placeholderTexture.dispose();
             this._placeholderTexture = null;
         }
-        if (this._placeholderAlbedoArray) {
-            this._placeholderAlbedoArray.dispose();
-            this._placeholderAlbedoArray = null;
-        }
-        if (this._placeholderNormalArray) {
-            this._placeholderNormalArray.dispose();
-            this._placeholderNormalArray = null;
-        }
         super.dispose();
     }
     isCompatible(shaderLanguage) {
@@ -12487,28 +12856,32 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                     CUSTOM_VERTEX_DEFINITIONS: this.getWGSLVertexDefinitions(),
                     CUSTOM_VERTEX_UPDATE_POSITION: this.getWGSLVertexPositionCode(),
                     CUSTOM_VERTEX_UPDATE_NORMAL: this.getWGSLVertexNormalCode(),
-                    CUSTOM_VERTEX_MAIN_END: this.getWGSLVertexMainEnd()
+                    CUSTOM_VERTEX_MAIN_END: this.getWGSLSkinLayerVaryingCode()
                 };
             }
             return {
                 CUSTOM_VERTEX_DEFINITIONS: this.getGLSLVertexDefinitions(),
                 CUSTOM_VERTEX_UPDATE_POSITION: this.getGLSLVertexPositionCode(),
                 CUSTOM_VERTEX_UPDATE_NORMAL: this.getGLSLVertexNormalCode(),
-                CUSTOM_VERTEX_MAIN_END: this.getGLSLVertexMainEnd()
+                CUSTOM_VERTEX_MAIN_END: this.getGLSLSkinLayerVaryingCode()
             };
         }
         if (shaderType === "fragment") {
             if (wgsl) {
                 return {
-                    CUSTOM_FRAGMENT_DEFINITIONS: this.getWGSLFragmentDefinitions(),
-                    CUSTOM_FRAGMENT_UPDATE_ALBEDO: this.getWGSLFragmentAlbedoCode(),
-                    CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.getWGSLFragmentNormalCode()
+                    CUSTOM_FRAGMENT_DEFINITIONS: this.getWGSLSkinFragmentDefs(),
+                    CUSTOM_FRAGMENT_UPDATE_ALBEDO: this.getWGSLSkinAlbedoCode() + this.getWGSLSkinMetalRoughSampleCode(),
+                    CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.getWGSLSkinNormalCode(),
+                    CUSTOM_FRAGMENT_UPDATE_METALLICROUGHNESS: this.getWGSLSkinMetalRoughApplyCode(),
+                    CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION: this.getWGSLSkinEmissiveCode()
                 };
             }
             return {
-                CUSTOM_FRAGMENT_DEFINITIONS: this.getGLSLFragmentDefinitions(),
-                CUSTOM_FRAGMENT_UPDATE_ALBEDO: this.getGLSLFragmentAlbedoCode(),
-                CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.getGLSLFragmentNormalCode()
+                CUSTOM_FRAGMENT_DEFINITIONS: this.getGLSLSkinFragmentDefs(),
+                CUSTOM_FRAGMENT_UPDATE_ALBEDO: this.getGLSLSkinAlbedoCode() + this.getGLSLSkinMetalRoughSampleCode(),
+                CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.getGLSLSkinNormalCode(),
+                CUSTOM_FRAGMENT_UPDATE_METALLICROUGHNESS: this.getGLSLSkinMetalRoughApplyCode(),
+                CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION: this.getGLSLSkinEmissiveCode()
             };
         }
         return null;
@@ -12523,13 +12896,6 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
         const customSamplers = this.getCustomShaderMaterial().getCustomSamplers();
         if (customSamplers != null && customSamplers.length > 0)
             samplers.push(...customSamplers);
-        const mat = this.getCustomShaderMaterial();
-        if (mat) {
-            if (samplers.indexOf("runtimeAlbedoSkins") === -1)
-                samplers.push("runtimeAlbedoSkins");
-            if (samplers.indexOf("runtimeNormalSkins") === -1)
-                samplers.push("runtimeNormalSkins");
-        }
     }
     getAttributes(attributes, scene, mesh) {
         const customAttributes = this.getCustomShaderMaterial().getCustomAttributes();
@@ -12545,15 +12911,12 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
         defines.VAT_NORMAL_SEPARATE = (mode === "separate");
         const engine = scene ? scene.getEngine() : null;
         defines.UV3 = !(engine && engine.isWebGPU);
-        const mat = this.getCustomShaderMaterial();
-        const hasAlbedoArr = !!(mat && mat.runtimeAlbedoSkins);
-        const hasNormalArr = !!(mat && mat.runtimeNormalSkins);
-        defines.RUNTIME_SKINS_ALBEDO = hasAlbedoArr;
-        defines.RUNTIME_SKINS_NORMAL = hasNormalArr;
-        defines.RUNTIME_SKINS_NORMAL_DERIVE_TBN = hasNormalArr && !(mat && mat.bumpTexture);
-    }
-    onRuntimeSkinArraysChanged() {
-        this.markAllDefinesAsDirty();
+        const matSkin = this.getCustomShaderMaterial();
+        defines.VAT_SKIN_ARRAY = !!(matSkin && matSkin.vatSkinArrayActive);
+        defines.VAT_SKIN_ARRAY_ALBEDO = !!(matSkin && matSkin.vatSkinArray);
+        defines.VAT_SKIN_ARRAY_NORMAL = !!(matSkin && matSkin.vatSkinArrayNormal);
+        defines.VAT_SKIN_ARRAY_MR = !!(matSkin && matSkin.vatSkinArrayMetalRough);
+        defines.VAT_SKIN_ARRAY_EMISSIVE = !!(matSkin && matSkin.vatSkinArrayEmissive);
     }
     bindForSubMesh(uniformBuffer, scene, engine, subMesh) {
         if (!this.getIsEnabled())
@@ -12561,16 +12924,6 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
         const renderMesh = subMesh && subMesh.getRenderingMesh ? subMesh.getRenderingMesh() : null;
         this._captureRendererTarget(renderMesh || (subMesh ? subMesh.getMesh() : null));
         this._pushVATUniforms(uniformBuffer, false);
-        this._pushRuntimeSkinSamplers(uniformBuffer);
-    }
-    _pushRuntimeSkinSamplers(buf) {
-        const mat = this.getCustomShaderMaterial();
-        const albedoArr = (mat && mat.runtimeAlbedoSkins && mat.runtimeAlbedoSkins.isReady && mat.runtimeAlbedoSkins.isReady())
-            ? mat.runtimeAlbedoSkins : this._placeholderAlbedoArray;
-        const normalArr = (mat && mat.runtimeNormalSkins && mat.runtimeNormalSkins.isReady && mat.runtimeNormalSkins.isReady())
-            ? mat.runtimeNormalSkins : this._placeholderNormalArray;
-        buf.setTexture("runtimeAlbedoSkins", albedoArr);
-        buf.setTexture("runtimeNormalSkins", normalArr);
     }
     setupAnimations(settings, controllerId, rootUrl = "", lazyLoadTextures = false) {
         this.vertexAnimations = settings;
@@ -12823,7 +13176,6 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
     }
     bindVATToEffect(effect) {
         this._pushVATUniforms(effect, true);
-        this._pushRuntimeSkinSamplers(effect);
     }
     _pushVATUniforms(buf, isEffect) {
         const fb = this._placeholderTexture;
@@ -12896,13 +13248,12 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                 uniform sampler2D vatPrevPosition;
                 uniform sampler2D vatPrevNormal;
                 #endif
-                // Runtime-skin varyings — pass packed skin index + UV0 to the fragment stage so
-                // fragment can sample runtimeAlbedoSkins[layer]/runtimeNormalSkins[layer]. Always
-                // emitted (cheap) so the shader compiles regardless of the runtime-skin defines.
-                #ifndef TOOLKIT_VAT_RUNTIMESKIN_VARYINGS
-                #define TOOLKIT_VAT_RUNTIMESKIN_VARYINGS
-                varying float vRuntimeSkinIndex;
-                varying vec2 vRuntimeSkinUV;
+                #ifdef VAT_SKIN_ARRAY
+                #ifndef TOOLKIT_VAT_SKIN_V_DEFINED
+                #define TOOLKIT_VAT_SKIN_V_DEFINED
+                varying float vVatSkinLayer;
+                varying vec2 vVatSkinUV;
+                #endif
                 #endif
             `;
     }
@@ -12916,8 +13267,11 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                 float vatPrevFrame = g_vatAnim1.x;
                 float vatPrevFrameCount = g_vatAnim1.y;
                 float vatPrevFromRow = g_vatAnim1.z;
-                float vatPackedSkinLoop = g_vatAnim1.w;
-                float vatLoopBlend = mod(vatPackedSkinLoop, 2.0);
+                #ifdef VAT_SKIN_ARRAY
+                float vatLoopBlend = mod(g_vatAnim1.w, 2.0); // low bit is loop-blend, high bits carry the skin layer index
+                #else
+                float vatLoopBlend = g_vatAnim1.w;
+                #endif
                 if (vatFrameCount > 0.5) {
                     // GLSL path uses the third UV channel:
                     //   Unity uv3 -> glTF TEXCOORD_2 -> Babylon shader uv3
@@ -12985,9 +13339,11 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                 float vatNormFrame = g_vatAnim0.x;
                 float vatNormFrameCount = g_vatAnim0.y;
                 float vatNormFromRow = g_vatAnim0.z;
-                
-                float vatNormPackedSkinLoop = g_vatAnim1.w;
-                float vatNormLoopBlend = mod(vatNormPackedSkinLoop, 2.0);
+                #ifdef VAT_SKIN_ARRAY
+                float vatNormLoopBlend = mod(g_vatAnim1.w, 2.0);
+                #else
+                float vatNormLoopBlend = g_vatAnim1.w;
+                #endif
 
                 if (vatNormFrameCount > 0.5) {
                     // GLSL path uses the third UV channel:
@@ -13033,9 +13389,10 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                 var vatPrevPositionSampler: sampler;
                 var vatPrevNormal: texture_2d<f32>;
                 var vatPrevNormalSampler: sampler;
-                // Runtime-skin varyings — packed skin index and UV0, passed to fragment.
-                varying vRuntimeSkinIndex: f32;
-                varying vRuntimeSkinUV: vec2<f32>;
+                #endif
+                #ifdef VAT_SKIN_ARRAY
+                varying vVatSkinLayer: f32;
+                varying vVatSkinUV: vec2<f32>;
                 #endif
             `;
     }
@@ -13049,8 +13406,11 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                 let vatPrevFrame = vertexInputs.g_vatAnim1.x;
                 let vatPrevFrameCount = vertexInputs.g_vatAnim1.y;
                 let vatPrevFromRow = vertexInputs.g_vatAnim1.z;
-                let packedSkinLoop = vertexInputs.g_vatAnim1.w;
-                let vatLoopBlend = packedSkinLoop % 2.0;
+                #ifdef VAT_SKIN_ARRAY
+                let vatLoopBlend = vertexInputs.g_vatAnim1.w % 2.0; // low bit is loop-blend, high bits carry the skin layer index
+                #else
+                let vatLoopBlend = vertexInputs.g_vatAnim1.w;
+                #endif
                 if (vatFrameCount > 0.5) {
                     // WGSL path derives the VAT texel coordinate from the vertex index instead
                     // of consuming a dedicated uv3 vertex-buffer slot.
@@ -13119,8 +13479,11 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                 let vatNormFrame = vertexInputs.g_vatAnim0.x;
                 let vatNormFrameCount = vertexInputs.g_vatAnim0.y;
                 let vatNormFromRow = vertexInputs.g_vatAnim0.z;
-                let vatNormPackedSkinLoop = vertexInputs.g_vatAnim1.w;
-                let vatNormLoopBlend = vatNormPackedSkinLoop % 2.0;
+                #ifdef VAT_SKIN_ARRAY
+                let vatNormLoopBlend = vertexInputs.g_vatAnim1.w % 2.0;
+                #else
+                let vatNormLoopBlend = vertexInputs.g_vatAnim1.w;
+                #endif
                 if (vatNormFrameCount > 0.5) {
                     // WGSL path derives the VAT texel coordinate from the vertex index instead
                     // of consuming a dedicated uv3 vertex-buffer slot.
@@ -13157,130 +13520,187 @@ export class VertexAnimationMaterialPlugin extends CustomShaderMaterialPlugin {
                 #endif
             `;
     }
-    getGLSLVertexMainEnd() {
+    getGLSLSkinLayerVaryingCode() {
         return `
-                #ifdef VERTEXANIMATIONMATERIAL
-                {
-                    float _rsPackedSkinLoop = g_vatAnim1.w;
-                    vRuntimeSkinIndex = floor(_rsPackedSkinLoop * 0.5 + 0.0001);
-                    #ifdef UV1
-                        vRuntimeSkinUV = uv;
-                    #else
-                        vRuntimeSkinUV = vec2(0.0, 0.0);
-                    #endif
-                }
+                #ifdef VAT_SKIN_ARRAY
+                #ifdef UV1
+                    vVatSkinLayer = floor(g_vatAnim1.w * 0.5 + 0.0001);
+                    vVatSkinUV = uv;
+                #else
+                    vVatSkinLayer = 0.0;
+                    vVatSkinUV = vec2(0.0);
+                #endif
                 #endif
             `;
     }
-    getWGSLVertexMainEnd() {
+    getGLSLSkinFragmentDefs() {
         return `
-                #ifdef VERTEXANIMATIONMATERIAL
+                #ifdef VAT_SKIN_ARRAY
+                varying float vVatSkinLayer;
+                varying vec2 vVatSkinUV;
+                #ifdef VAT_SKIN_ARRAY_ALBEDO
+                uniform sampler2DArray tkAlbedoArray;
+                #endif
+                #ifdef VAT_SKIN_ARRAY_NORMAL
+                uniform sampler2DArray tkNormalArray;
+                #endif
+                #ifdef VAT_SKIN_ARRAY_MR
+                uniform sampler2DArray tkMetalRoughArray;
+                vec2 _tkMR;
+                #endif
+                #ifdef VAT_SKIN_ARRAY_EMISSIVE
+                uniform sampler2DArray tkEmissiveArray;
+                #endif
+                #endif
+            `;
+    }
+    getGLSLSkinAlbedoCode() {
+        return `
+                #ifdef VAT_SKIN_ARRAY_ALBEDO
                 {
-                    let _rsPackedSkinLoop = vertexInputs.g_vatAnim1.w;
-                    vertexOutputs.vRuntimeSkinIndex = floor(_rsPackedSkinLoop * 0.5 + 0.0001);
-                    #ifdef UV1
-                        vertexOutputs.vRuntimeSkinUV = vertexInputs.uv;
+                    vec4 _vatSkinAlbedo = texture(tkAlbedoArray, vec3(vVatSkinUV, floor(vVatSkinLayer + 0.5)));
+                    // Match Babylon's native albedo: sRGB -> linear when the albedo is gamma-space.
+                    #ifdef GAMMAALBEDO
+                        surfaceAlbedo = toLinearSpace(_vatSkinAlbedo.rgb) * vAlbedoColor.rgb;
                     #else
-                        vertexOutputs.vRuntimeSkinUV = vec2f(0.0, 0.0);
+                        surfaceAlbedo = _vatSkinAlbedo.rgb * vAlbedoColor.rgb;
+                    #endif
+                    #ifdef ALPHATEST
+                        if (_vatSkinAlbedo.a < alphaCutOff) discard;
                     #endif
                 }
                 #endif
             `;
     }
-    getGLSLFragmentDefinitions() {
+    getGLSLSkinNormalCode() {
         return `
-                #ifndef TOOLKIT_VAT_RUNTIMESKIN_F_UNIFORMS
-                #define TOOLKIT_VAT_RUNTIMESKIN_F_UNIFORMS
-                varying float vRuntimeSkinIndex;
-                varying vec2 vRuntimeSkinUV;
-                uniform highp sampler2DArray runtimeAlbedoSkins;
-                uniform highp sampler2DArray runtimeNormalSkins;
+                #if defined(VAT_SKIN_ARRAY) && defined(VAT_SKIN_ARRAY_NORMAL) && defined(BUMP) && defined(TANGENT) && defined(NORMAL)
+                {
+                    vec3 _vatNrmTexel = texture(tkNormalArray, vec3(vVatSkinUV, floor(vVatSkinLayer + 0.5))).xyz;
+                    normalW = perturbNormal(vTBN, _vatNrmTexel, vBumpInfos.y);
+                }
                 #endif
             `;
     }
-    getGLSLFragmentAlbedoCode() {
+    getGLSLSkinMetalRoughSampleCode() {
         return `
-                #ifdef RUNTIME_SKINS_ALBEDO
+                #ifdef VAT_SKIN_ARRAY_MR
                 {
-                    float _rsLayer = max(0.0, floor(vRuntimeSkinIndex + 0.5));
-                    vec4 _rsAlbedo = texture(runtimeAlbedoSkins, vec3(vRuntimeSkinUV, _rsLayer));
-                    surfaceAlbedo = _rsAlbedo.rgb * vAlbedoColor.rgb;
-                    #ifdef ALPHATEST
-                        if (_rsAlbedo.a < alphaCutOff) discard;
-                    #endif
+                    vec4 _vatMRtexel = texture(tkMetalRoughArray, vec3(vVatSkinUV, floor(vVatSkinLayer + 0.5)));
+                    _tkMR = vec2(_vatMRtexel.b, _vatMRtexel.g);
                 }
                 #endif
             `;
     }
-    getGLSLFragmentNormalCode() {
+    getGLSLSkinMetalRoughApplyCode() {
         return `
-                #ifdef RUNTIME_SKINS_NORMAL
+                #if defined(VAT_SKIN_ARRAY_MR) && defined(METALLICWORKFLOW)
+                metallicRoughness.r = _tkMR.x;
+                metallicRoughness.g = _tkMR.y;
+                #endif
+            `;
+    }
+    getGLSLSkinEmissiveCode() {
+        return `
+                #if defined(VAT_SKIN_ARRAY) && defined(VAT_SKIN_ARRAY_EMISSIVE)
                 {
-                    float _rsLayer = max(0.0, floor(vRuntimeSkinIndex + 0.5));
-                    vec3 _rsNormalSample = texture(runtimeNormalSkins, vec3(vRuntimeSkinUV, _rsLayer)).xyz;
-                    vec3 _rsNormalTS = _rsNormalSample * 2.0 - 1.0;
-                    vec3 _rsP   = vPositionW;
-                    vec3 _rsN   = normalize(vNormalW);
-                    vec3 _rsDp1 = dFdx(_rsP);
-                    vec3 _rsDp2 = dFdy(_rsP);
-                    vec2 _rsDuv1 = dFdx(vRuntimeSkinUV);
-                    vec2 _rsDuv2 = dFdy(vRuntimeSkinUV);
-                    vec3 _rsDp2perp = cross(_rsDp2, _rsN);
-                    vec3 _rsDp1perp = cross(_rsN, _rsDp1);
-                    vec3 _rsT = _rsDp2perp * _rsDuv1.x + _rsDp1perp * _rsDuv2.x;
-                    vec3 _rsB = _rsDp2perp * _rsDuv1.y + _rsDp1perp * _rsDuv2.y;
-                    float _rsInvMax = inversesqrt(max(dot(_rsT, _rsT), dot(_rsB, _rsB)));
-                    mat3 _rsTBN = mat3(_rsT * _rsInvMax, _rsB * _rsInvMax, _rsN);
-                    normalW = normalize(_rsTBN * _rsNormalTS);
+                    vec3 _vatEmis = texture(tkEmissiveArray, vec3(vVatSkinUV, floor(vVatSkinLayer + 0.5))).rgb;
+                    finalEmissive = toLinearSpace(_vatEmis);
                 }
                 #endif
             `;
     }
-    getWGSLFragmentDefinitions() {
+    getWGSLSkinLayerVaryingCode() {
         return `
-                varying vRuntimeSkinIndex: f32;
-                varying vRuntimeSkinUV: vec2<f32>;
-                var runtimeAlbedoSkins: texture_2d_array<f32>;
-                var runtimeAlbedoSkinsSampler: sampler;
-                var runtimeNormalSkins: texture_2d_array<f32>;
-                var runtimeNormalSkinsSampler: sampler;
+                #ifdef VAT_SKIN_ARRAY
+                #ifdef UV1
+                    vertexOutputs.vVatSkinLayer = floor(vertexInputs.g_vatAnim1.w * 0.5 + 0.0001);
+                    vertexOutputs.vVatSkinUV = vertexInputs.uv;
+                #else
+                    vertexOutputs.vVatSkinLayer = 0.0;
+                    vertexOutputs.vVatSkinUV = vec2f(0.0);
+                #endif
+                #endif
             `;
     }
-    getWGSLFragmentAlbedoCode() {
+    getWGSLSkinFragmentDefs() {
         return `
-                #ifdef RUNTIME_SKINS_ALBEDO
+                #ifdef VAT_SKIN_ARRAY
+                varying vVatSkinLayer: f32;
+                varying vVatSkinUV: vec2<f32>;
+                #ifdef VAT_SKIN_ARRAY_ALBEDO
+                var tkAlbedoArray: texture_2d_array<f32>;
+                var tkAlbedoArraySampler: sampler;
+                #endif
+                #ifdef VAT_SKIN_ARRAY_NORMAL
+                var tkNormalArray: texture_2d_array<f32>;
+                var tkNormalArraySampler: sampler;
+                #endif
+                #ifdef VAT_SKIN_ARRAY_MR
+                var tkMetalRoughArray: texture_2d_array<f32>;
+                var tkMetalRoughArraySampler: sampler;
+                var<private> _tkMR: vec2<f32>;
+                #endif
+                #ifdef VAT_SKIN_ARRAY_EMISSIVE
+                var tkEmissiveArray: texture_2d_array<f32>;
+                var tkEmissiveArraySampler: sampler;
+                #endif
+                #endif
+            `;
+    }
+    getWGSLSkinAlbedoCode() {
+        return `
+                #ifdef VAT_SKIN_ARRAY_ALBEDO
                 {
-                    let _rsLayer = i32(max(0.0, floor(fragmentInputs.vRuntimeSkinIndex + 0.5)));
-                    let _rsAlbedo = textureSample(runtimeAlbedoSkins, runtimeAlbedoSkinsSampler, fragmentInputs.vRuntimeSkinUV, _rsLayer);
-                    surfaceAlbedo = _rsAlbedo.rgb * vAlbedoColor.rgb;
+                    let _vatSkinAlbedo = textureSample(tkAlbedoArray, tkAlbedoArraySampler, fragmentInputs.vVatSkinUV, i32(fragmentInputs.vVatSkinLayer + 0.5));
+                    // Match Babylon's native albedo: sRGB -> linear when the albedo is gamma-space.
+                    #ifdef GAMMAALBEDO
+                        surfaceAlbedo = toLinearSpaceVec3(_vatSkinAlbedo.rgb) * vAlbedoColor.rgb;
+                    #else
+                        surfaceAlbedo = _vatSkinAlbedo.rgb * vAlbedoColor.rgb;
+                    #endif
                     #ifdef ALPHATEST
-                        if (_rsAlbedo.a < alphaCutOff) { discard; }
+                        if (_vatSkinAlbedo.a < alphaCutOff) { discard; }
                     #endif
                 }
                 #endif
             `;
     }
-    getWGSLFragmentNormalCode() {
+    getWGSLSkinNormalCode() {
+        return `
+                #if defined(VAT_SKIN_ARRAY) && defined(VAT_SKIN_ARRAY_NORMAL) && defined(BUMP) && defined(TANGENT) && defined(NORMAL)
+                {
+                    let _vatNrmTexel = textureSample(tkNormalArray, tkNormalArraySampler, fragmentInputs.vVatSkinUV, i32(fragmentInputs.vVatSkinLayer + 0.5)).rgb;
+                    let _vatNrmTBN = mat3x3<f32>(fragmentInputs.vTBN0, fragmentInputs.vTBN1, fragmentInputs.vTBN2);
+                    normalW = perturbNormal(_vatNrmTBN, _vatNrmTexel, uniforms.vBumpInfos.y);
+                }
+                #endif
+            `;
+    }
+    getWGSLSkinMetalRoughSampleCode() {
         return `
-                #ifdef RUNTIME_SKINS_NORMAL
+                #ifdef VAT_SKIN_ARRAY_MR
                 {
-                    let _rsLayer = i32(max(0.0, floor(fragmentInputs.vRuntimeSkinIndex + 0.5)));
-                    let _rsNormalSample = textureSample(runtimeNormalSkins, runtimeNormalSkinsSampler, fragmentInputs.vRuntimeSkinUV, _rsLayer).xyz;
-                    let _rsNormalTS = _rsNormalSample * 2.0 - vec3f(1.0);
-                    let _rsP = fragmentInputs.vPositionW;
-                    let _rsN = normalize(fragmentInputs.vNormalW);
-                    let _rsDp1 = dpdx(_rsP);
-                    let _rsDp2 = dpdy(_rsP);
-                    let _rsDuv1 = dpdx(fragmentInputs.vRuntimeSkinUV);
-                    let _rsDuv2 = dpdy(fragmentInputs.vRuntimeSkinUV);
-                    let _rsDp2perp = cross(_rsDp2, _rsN);
-                    let _rsDp1perp = cross(_rsN, _rsDp1);
-                    let _rsT = _rsDp2perp * _rsDuv1.x + _rsDp1perp * _rsDuv2.x;
-                    let _rsB = _rsDp2perp * _rsDuv1.y + _rsDp1perp * _rsDuv2.y;
-                    let _rsInvMax = inverseSqrt(max(dot(_rsT, _rsT), dot(_rsB, _rsB)));
-                    let _rsTcol = _rsT * _rsInvMax;
-                    let _rsBcol = _rsB * _rsInvMax;
-                    normalW = normalize(_rsTcol * _rsNormalTS.x + _rsBcol * _rsNormalTS.y + _rsN * _rsNormalTS.z);
+                    let _vatMRtexel = textureSample(tkMetalRoughArray, tkMetalRoughArraySampler, fragmentInputs.vVatSkinUV, i32(fragmentInputs.vVatSkinLayer + 0.5));
+                    _tkMR = vec2<f32>(_vatMRtexel.b, _vatMRtexel.g);
+                }
+                #endif
+            `;
+    }
+    getWGSLSkinMetalRoughApplyCode() {
+        return `
+                #if defined(VAT_SKIN_ARRAY_MR) && defined(METALLICWORKFLOW)
+                metallicRoughness.r = _tkMR.x;
+                metallicRoughness.g = _tkMR.y;
+                #endif
+            `;
+    }
+    getWGSLSkinEmissiveCode() {
+        return `
+                #if defined(VAT_SKIN_ARRAY) && defined(VAT_SKIN_ARRAY_EMISSIVE)
+                {
+                    let _vatEmis = textureSample(tkEmissiveArray, tkEmissiveArraySampler, fragmentInputs.vVatSkinUV, i32(fragmentInputs.vVatSkinLayer + 0.5)).rgb;
+                    finalEmissive = toLinearSpaceVec3(_vatEmis);
                 }
                 #endif
             `;
@@ -27680,6 +28100,138 @@ ShurikenParticles.UNITY_TO_BABYLON_LIFETIME_RATIO = 0.65;
 ShurikenParticles.UNITY_TO_BABYLON_DEATH_FADE_ALPHA = 0.2;
 ShurikenParticles.EMITTER_POSITION_OFFSET = new Vector3(0, 0, 0);
 ShurikenParticles.EMITTER_ROTATION_OFFSET = new Vector3(90, 0, 0);
+export class SkinTextureArray {
+    static Build(scene, urls, options = {}) {
+        const requested = (urls || []).filter((u) => u != null && String(u).length > 0);
+        if (requested.length === 0)
+            return Promise.resolve(null);
+        const maxLayers = SkinTextureArray._maxArrayLayers(scene.getEngine());
+        let list = requested;
+        if (requested.length > maxLayers) {
+            console.warn("SkinTextureArray: " + requested.length + " slices exceeds GPU maxTextureArrayLayers ("
+                + maxLayers + ") — clamping to " + maxLayers + ". Skin indices >= " + maxLayers + " will be unavailable.");
+            list = requested.slice(0, maxLayers);
+        }
+        const optKey = "m" + (options.mipmaps === false ? 0 : 1)
+            + "|y" + (options.invertY === true ? 1 : 0)
+            + "|s" + (options.samplingMode != null ? options.samplingMode : "d");
+        const key = list.join("|") + "||" + optKey;
+        if (SkinTextureArray._cache[key] != null)
+            return SkinTextureArray._cache[key];
+        const built = SkinTextureArray._loadImages(list).then((images) => {
+            if (images == null || images.length === 0)
+                return null;
+            const w = images[0].width, h = images[0].height, depth = images.length;
+            const canvas = document.createElement("canvas");
+            canvas.width = w;
+            canvas.height = h;
+            const ctx = canvas.getContext("2d");
+            const data = new Uint8Array(w * h * 4 * depth);
+            const flipY = (options.invertY != null) ? options.invertY : false;
+            for (let i = 0; i < depth; i++) {
+                ctx.setTransform(1, 0, 0, 1, 0, 0);
+                ctx.clearRect(0, 0, w, h);
+                if (flipY)
+                    ctx.setTransform(1, 0, 0, -1, 0, h);
+                ctx.drawImage(images[i], 0, 0, w, h);
+                const id = ctx.getImageData(0, 0, w, h).data;
+                data.set(id, i * w * h * 4);
+            }
+            const engine = scene.getEngine();
+            const isWebGPU = (engine != null && engine.isWebGPU === true);
+            const genMips = (options.mipmaps !== false);
+            const mipCount = genMips ? (Math.floor(Math.log2(Math.max(w, h))) + 1) : 1;
+            const samplingMode = (options.samplingMode != null) ? options.samplingMode
+                : (genMips ? Texture.TRILINEAR_SAMPLINGMODE : Texture.BILINEAR_SAMPLINGMODE);
+            const arr = new RawTexture2DArray(data, w, h, depth, Constants.TEXTUREFORMAT_RGBA, scene, genMips, false, samplingMode, Constants.TEXTURETYPE_UNSIGNED_BYTE, 0, mipCount);
+            if (genMips && isWebGPU && mipCount > 1)
+                SkinTextureArray._uploadMipChain(scene, arr, data, w, h, depth);
+            arr.wrapU = Texture.CLAMP_ADDRESSMODE;
+            arr.wrapV = Texture.CLAMP_ADDRESSMODE;
+            arr.anisotropicFilteringLevel = (options.aniso != null) ? options.aniso : 8;
+            return arr;
+        }).catch((e) => { console.warn("SkinTextureArray: build failed", e); delete SkinTextureArray._cache[key]; return null; });
+        SkinTextureArray._cache[key] = built;
+        return built;
+    }
+    static _uploadMipChain(scene, arr, base, w, h, depth) {
+        const engine = scene.getEngine();
+        const itex = arr.getInternalTexture();
+        if (itex == null || typeof engine.updateRawTexture2DArray !== "function")
+            return;
+        const count = Math.floor(Math.log2(Math.max(w, h))) + 1;
+        try {
+            let prev = base, pw = w, ph = h;
+            for (let m = 1; m < count; m++) {
+                const nw = Math.max(1, pw >> 1), nh = Math.max(1, ph >> 1);
+                const mip = SkinTextureArray._downsampleLayers(prev, pw, ph, depth, nw, nh);
+                engine.updateRawTexture2DArray(itex, mip, Constants.TEXTUREFORMAT_RGBA, false, null, Constants.TEXTURETYPE_UNSIGNED_BYTE, m);
+                prev = mip;
+                pw = nw;
+                ph = nh;
+            }
+        }
+        catch (e) {
+            console.warn("SkinTextureArray: mip-chain upload failed, using base level only", e);
+        }
+    }
+    static _downsampleLayers(src, sw, sh, depth, dw, dh) {
+        const out = new Uint8Array(dw * dh * 4 * depth);
+        for (let L = 0; L < depth; L++) {
+            const so = L * sw * sh * 4, doo = L * dw * dh * 4;
+            for (let y = 0; y < dh; y++) {
+                for (let x = 0; x < dw; x++) {
+                    const sx = x * 2, sy = y * 2;
+                    const sx1 = Math.min(sx + 1, sw - 1), sy1 = Math.min(sy + 1, sh - 1);
+                    for (let c = 0; c < 4; c++) {
+                        const a = src[so + (sy * sw + sx) * 4 + c], b = src[so + (sy * sw + sx1) * 4 + c], e = src[so + (sy1 * sw + sx) * 4 + c], d = src[so + (sy1 * sw + sx1) * 4 + c];
+                        out[doo + (y * dw + x) * 4 + c] = (a + b + e + d) >> 2;
+                    }
+                }
+            }
+        }
+        return out;
+    }
+    static _maxArrayLayers(engine) {
+        try {
+            const dev = (engine != null) ? (engine._device || (typeof engine.getDevice === "function" ? engine.getDevice() : null)) : null;
+            if (dev != null && dev.limits != null && typeof dev.limits.maxTextureArrayLayers === "number" && dev.limits.maxTextureArrayLayers > 0) {
+                return dev.limits.maxTextureArrayLayers;
+            }
+            const gl = (engine != null) ? engine._gl : null;
+            if (gl != null && typeof gl.getParameter === "function") {
+                const MAX_ARRAY_TEXTURE_LAYERS = 0x88FF;
+                const v = gl.getParameter(MAX_ARRAY_TEXTURE_LAYERS);
+                if (typeof v === "number" && v > 0)
+                    return v;
+            }
+        }
+        catch (e) { }
+        return 256;
+    }
+    static _loadImages(urls) {
+        return Promise.all(urls.map((u) => new Promise((resolve, reject) => {
+            const img = document.createElement("img");
+            img.crossOrigin = "anonymous";
+            img.onload = () => resolve(img);
+            img.onerror = () => reject(new Error("SkinTextureArray: failed to load " + u));
+            img.src = u;
+        })));
+    }
+    static Clear() {
+        const entries = [];
+        for (const k in SkinTextureArray._cache) {
+            if (SkinTextureArray._cache[k] != null)
+                entries.push(SkinTextureArray._cache[k]);
+        }
+        SkinTextureArray._cache = {};
+        for (const p of entries) {
+            p.then((arr) => { if (arr != null)
+                arr.dispose(); }).catch(() => { });
+        }
+    }
+}
+SkinTextureArray._cache = {};
 export class MeshNormalProxy {
     constructor() {
         this.blendWithPhysicsNormal = 0.0;
@@ -29254,6 +29806,410 @@ TerrainBuilder.detailChunkMaxTotalChunks = 256;
 TerrainBuilder.meshDetailChunkMode = 1;
 TerrainBuilder.meshDetailChunkTargetInstances = 20000;
 TerrainBuilder.meshDetailChunkWorldSize = 64;
+export class TextureAtlasSkin extends ScriptComponent {
+    constructor(transform, scene, properties = {}, alias = "TextureAtlasSkin") {
+        super(transform, scene, properties, alias);
+        this.abtractMesh = null;
+        this.textureData = null;
+        this.defaultIndex = 0;
+        this.skinnedParts = [];
+        this.albedoSlices = null;
+        this.normalSlices = null;
+        this.metallicSlices = null;
+        this.occlusionSlices = null;
+        this.emissiveSlices = null;
+        this._applied = false;
+        this._manifest = null;
+        this._currentIndex = 0;
+        this._targets = [];
+        this._clonedMultiMaterial = null;
+    }
+    awake() {
+        this.abtractMesh = this.getAbstractMesh();
+        this.albedoSlices = this.getProperty("albedoSlices", null);
+        this.normalSlices = this.getProperty("normalSlices", null);
+        this.metallicSlices = this.getProperty("metallicSlices", null);
+        this.occlusionSlices = this.getProperty("occlusionSlices", null);
+        this.emissiveSlices = this.getProperty("emissiveSlices", null);
+        window["__" + this.transform.name] = this;
+    }
+    start() {
+        this.applySkins();
+    }
+    applySkins() {
+        if (this._applied)
+            return;
+        const mesh = this.abtractMesh || this.getAbstractMesh();
+        if (mesh == null) {
+            console.warn("TextureAtlasSkin: no abstract mesh on " + this.transform.name);
+            return;
+        }
+        let manifest = this.parseManifest();
+        if (manifest == null) {
+            const sliceCount = this.maxChannelSliceCount();
+            if (sliceCount > 0) {
+                const skins = [];
+                for (let i = 0; i < sliceCount; i++)
+                    skins.push({ index: i, name: "skin_" + i });
+                manifest = { skinArray: true, count: sliceCount, skins: skins };
+            }
+            else {
+                console.warn("TextureAtlasSkin: no textureData manifest and no channel slices on " + this.transform.name);
+                return;
+            }
+        }
+        this._manifest = manifest;
+        this._currentIndex = this.clampIndex(this.toInt(this.defaultIndex, 0), "defaultIndex");
+        const isInstanced = this.isInstancedSetup(mesh);
+        const slots = this.getMeshSlots(mesh);
+        const parts = this.skinnedParts || [];
+        if (parts.length === 0) {
+            console.warn("TextureAtlasSkin: no skinnedParts on " + this.transform.name);
+            return;
+        }
+        for (const part of parts) {
+            const targetMat = this.resolvePartMaterial(part);
+            const slot = this.matchSlot(slots, targetMat, part);
+            if (slot == null || !(slot.material instanceof CustomShaderMaterial)) {
+                console.warn("TextureAtlasSkin: skinned part not found / not a CustomShaderMaterial on " + this.transform.name, part);
+                continue;
+            }
+            let material = slot.material;
+            const isVat = (material instanceof VertexAnimationMaterial);
+            const kind = isVat ? "vat" : (isInstanced ? "instanced" : "regular");
+            if (kind === "regular") {
+                material = this.cloneForRegular(mesh, slot, material);
+            }
+            this.configureMaterial(material, manifest, kind);
+            this._targets.push({ material: material, kind: kind });
+            console.warn(">>> TextureAtlasSkin: " + this.transform.name + " — part '" + material.name + "' → " + this.describeKind(kind) + " setup");
+        }
+        this.applyIndexToTargets(mesh, this._currentIndex);
+        this._applied = true;
+    }
+    setSkinIndex(index) {
+        const requested = this.toInt(index, 0);
+        this._currentIndex = this.clampIndex(requested, "skin index");
+        const mesh = this.abtractMesh || this.getAbstractMesh();
+        this.applyIndexToTargets(mesh, this._currentIndex);
+        return this._currentIndex;
+    }
+    clampIndex(index, label) {
+        const count = this.skinCount();
+        const max = Math.max(0, count - 1);
+        const clamped = (index < 0) ? 0 : (index > max ? max : index);
+        if (clamped !== index) {
+            console.warn("TextureAtlasSkin: " + label + " " + index + " out of range [0, " + max + "] on " + this.transform.name + " — clamped to " + clamped);
+        }
+        return clamped;
+    }
+    skinCount() {
+        const m = this._manifest;
+        if (m == null)
+            return this.maxChannelSliceCount();
+        const skins = m.skins || [];
+        if (skins.length > 0)
+            return skins.length;
+        const c = this.toInt(m.count, 0);
+        if (c > 0)
+            return c;
+        return this.maxChannelSliceCount();
+    }
+    maxChannelSliceCount() {
+        const lens = [this.albedoSlices, this.normalSlices, this.metallicSlices, this.occlusionSlices, this.emissiveSlices]
+            .map((s) => (s != null) ? s.length : 0);
+        return Math.max(0, lens[0], lens[1], lens[2], lens[3], lens[4]);
+    }
+    getSkinIndex() {
+        return this._currentIndex;
+    }
+    configureMaterial(material, manifest, kind) {
+        const shared = (kind !== "regular");
+        if (shared && this.isConfigured(material))
+            return;
+        if (shared)
+            this.markConfigured(material);
+        if (kind === "instanced")
+            this.ensureSkinLayerBuffer(this.abtractMesh || this.getAbstractMesh());
+        const albedoUrls = this.albedoChannelUrls(manifest);
+        const normalUrls = this.normalChannelUrls(manifest);
+        const mrUrls = this.metalRoughChannelUrls(manifest);
+        const emissiveUrls = this.emissiveChannelUrls(manifest);
+        const has = (u) => (u != null && u.length > 0);
+        if (!has(albedoUrls) && !has(normalUrls) && !has(mrUrls) && !has(emissiveUrls)) {
+            console.warn("TextureAtlasSkin: no channel slices to build a skin array on " + this.transform.name);
+            return;
+        }
+        if (kind !== "vat")
+            material.setSkinArrayLayerMode(kind === "regular");
+        const build = (urls, mipped) => has(urls) ? SkinTextureArray.Build(this.scene, urls, mipped ? {} : { mipmaps: false }) : Promise.resolve(null);
+        Promise.all([build(albedoUrls, true), build(normalUrls, false), build(mrUrls, true), build(emissiveUrls, true)])
+            .then(([albTex, nrmTex, mrTex, emisTex]) => {
+            const vmat = (kind === "vat") ? material : null;
+            if (albTex != null) {
+                material.addTextureArrayUniform("tkAlbedoArray", albTex);
+                if (vmat != null)
+                    vmat.enableVatSkinArray();
+                else
+                    material.enableSkinArray(kind === "regular");
+            }
+            if (nrmTex != null) {
+                material.addTextureArrayUniform("tkNormalArray", nrmTex);
+                if (vmat != null)
+                    vmat.enableVatSkinArrayNormal();
+                else
+                    material.enableSkinArrayNormal();
+            }
+            if (mrTex != null) {
+                material.addTextureArrayUniform("tkMetalRoughArray", mrTex);
+                if (vmat != null)
+                    vmat.enableVatSkinArrayMetalRough();
+                else
+                    material.enableSkinArrayMetalRough();
+            }
+            if (emisTex != null) {
+                material.addTextureArrayUniform("tkEmissiveArray", emisTex);
+                if (vmat != null)
+                    vmat.enableVatSkinArrayEmissive();
+                else
+                    material.enableSkinArrayEmissive();
+            }
+            if (albTex == null && nrmTex == null && mrTex == null && emisTex == null) {
+                console.warn("TextureAtlasSkin: all channel arrays failed to build on " + this.transform.name);
+                return;
+            }
+            this.applyLayerToMaterial(material, kind, this._currentIndex);
+        });
+    }
+    albedoChannelUrls(manifest) {
+        const fromSlices = this.sliceUrls(this.albedoSlices);
+        if (fromSlices != null)
+            return fromSlices;
+        const layers = (manifest != null) ? manifest.albedoLayers : null;
+        if (Array.isArray(layers)) {
+            const out = layers.filter((x) => x != null && String(x).length > 0).map((x) => this.resolveLayerUrl(String(x)));
+            return (out.length > 0) ? out : null;
+        }
+        return null;
+    }
+    normalChannelUrls(manifest) {
+        const fromSlices = this.sliceUrls(this.normalSlices);
+        if (fromSlices != null)
+            return fromSlices;
+        const layers = (manifest != null) ? manifest.normalLayers : null;
+        if (Array.isArray(layers)) {
+            const out = layers.filter((x) => x != null && String(x).length > 0).map((x) => this.resolveLayerUrl(String(x)));
+            return (out.length > 0) ? out : null;
+        }
+        return null;
+    }
+    metalRoughChannelUrls(manifest) {
+        const fromSlices = this.sliceUrls(this.metallicSlices);
+        if (fromSlices != null)
+            return fromSlices;
+        const layers = (manifest != null) ? manifest.metalRoughLayers : null;
+        if (Array.isArray(layers)) {
+            const out = layers.filter((x) => x != null && String(x).length > 0).map((x) => this.resolveLayerUrl(String(x)));
+            return (out.length > 0) ? out : null;
+        }
+        return null;
+    }
+    emissiveChannelUrls(manifest) {
+        const fromSlices = this.sliceUrls(this.emissiveSlices);
+        if (fromSlices != null)
+            return fromSlices;
+        const layers = (manifest != null) ? manifest.emissiveLayers : null;
+        if (Array.isArray(layers)) {
+            const out = layers.filter((x) => x != null && String(x).length > 0).map((x) => this.resolveLayerUrl(String(x)));
+            return (out.length > 0) ? out : null;
+        }
+        return null;
+    }
+    sliceUrls(slices) {
+        if (slices == null || slices.length === 0)
+            return null;
+        const root = SceneManager.GetRootUrl(this.scene) || "";
+        const urls = [];
+        for (const s of slices) {
+            if (s == null)
+                continue;
+            const anyS = s;
+            let u = null;
+            if (anyS.url != null && String(anyS.url).length > 0)
+                u = String(anyS.url);
+            else if (anyS.filename != null && String(anyS.filename).length > 0)
+                u = root + String(anyS.filename);
+            if (u != null && u.length > 0)
+                urls.push(u);
+        }
+        return (urls.length > 0) ? urls : null;
+    }
+    resolveLayerUrl(filename) {
+        if (filename == null)
+            return "";
+        const f = String(filename);
+        if (/^(https?:|blob:|data:|\/)/i.test(f))
+            return f;
+        const root = SceneManager.GetRootUrl(this.scene) || "";
+        return root + f;
+    }
+    applyIndexToTargets(mesh, index) {
+        if (mesh == null)
+            return;
+        for (const t of this._targets) {
+            this.applyLayerToMaterial(t.material, t.kind, index);
+        }
+    }
+    applyLayerToMaterial(material, kind, index) {
+        if (kind === "vat") {
+            VertexAnimationController.SetAtlasCellIndex(this.abtractMesh || this.getAbstractMesh(), index);
+        }
+        else if (kind === "instanced") {
+            const mesh = this.abtractMesh || this.getAbstractMesh();
+            this.ensureSkinLayerBuffer(mesh);
+            mesh.instancedBuffers.tkSkinLayer = index;
+        }
+        else {
+            material.setSkinLayer(index);
+        }
+    }
+    isInstancedSetup(mesh) {
+        if (mesh instanceof InstancedMesh)
+            return true;
+        const src = (mesh instanceof Mesh) ? mesh : null;
+        return (src != null && src.instances != null && src.instances.length > 0);
+    }
+    ensureSkinLayerBuffer(mesh) {
+        const inst = mesh;
+        const src = (inst != null && inst.sourceMesh != null) ? inst.sourceMesh : mesh;
+        const target = (src != null) ? src : mesh;
+        if (target != null && typeof target.registerInstancedBuffer === "function") {
+            const ib = target.instancedBuffers;
+            if (ib == null || ib.tkSkinLayer === undefined) {
+                target.registerInstancedBuffer("tkSkinLayer", 1);
+                target.instancedBuffers = target.instancedBuffers || {};
+                target.instancedBuffers.tkSkinLayer = 0;
+            }
+        }
+        mesh.instancedBuffers = mesh.instancedBuffers || {};
+    }
+    getMeshSlots(mesh) {
+        const slots = [];
+        const mat = mesh.material;
+        if (mat instanceof MultiMaterial) {
+            const subs = mat.subMaterials;
+            for (let i = 0; i < subs.length; i++) {
+                if (subs[i] != null)
+                    slots.push({ material: subs[i], mm: mat, index: i });
+            }
+        }
+        else if (mat != null) {
+            slots.push({ material: mat, mm: null, index: -1 });
+        }
+        return slots;
+    }
+    matchSlot(slots, targetMat, part) {
+        if (targetMat != null) {
+            for (const s of slots)
+                if (s.material === targetMat)
+                    return s;
+        }
+        const name = this.partName(part) || (targetMat != null ? targetMat.name : null);
+        if (name != null && name.length > 0) {
+            for (const s of slots)
+                if (s.material.name === name)
+                    return s;
+            for (const s of slots)
+                if (s.material.name.indexOf(name) !== -1)
+                    return s;
+        }
+        if (slots.length === 1)
+            return slots[0];
+        return null;
+    }
+    resolvePartMaterial(part) {
+        if (part == null)
+            return null;
+        if (part instanceof Material)
+            return part;
+        if (part.skinPart != null)
+            return this.resolvePartMaterial(part.skinPart);
+        const name = this.partName(part);
+        if (name == null)
+            return null;
+        let mat = this.scene.getMaterialByName(name);
+        if (mat == null && SceneManager.GetMaterialWithName != null)
+            mat = SceneManager.GetMaterialWithName(this.scene, name);
+        return mat;
+    }
+    partName(part) {
+        if (part == null)
+            return null;
+        if (typeof part === "string")
+            return part;
+        if (part instanceof Material)
+            return part.name;
+        if (part.skinPart != null)
+            return this.partName(part.skinPart);
+        if (part.name != null)
+            return part.name;
+        if (part.material != null)
+            return this.partName(part.material);
+        return null;
+    }
+    cloneForRegular(mesh, slot, material) {
+        const tag = "_skin_" + (this.transform != null ? this.transform.name : "skin");
+        const cloned = material.clone(material.name + tag);
+        if (!(cloned instanceof CustomShaderMaterial)) {
+            console.warn("TextureAtlasSkin: clone did not preserve CustomShaderMaterial — using original (skin may be shared)", cloned);
+            return material;
+        }
+        if (slot.mm != null) {
+            if (this._clonedMultiMaterial == null) {
+                this._clonedMultiMaterial = slot.mm.clone(slot.mm.name + tag);
+                mesh.material = this._clonedMultiMaterial;
+            }
+            this._clonedMultiMaterial.subMaterials[slot.index] = cloned;
+        }
+        else {
+            mesh.material = cloned;
+        }
+        return cloned;
+    }
+    parseManifest() {
+        let data = this.textureData;
+        if (data == null)
+            return null;
+        if (typeof data === "string") {
+            try {
+                data = JSON.parse(data);
+            }
+            catch (e) {
+                console.warn("TextureAtlasSkin: bad textureData JSON", e);
+                return null;
+            }
+        }
+        return (data != null && data.skins != null) ? data : null;
+    }
+    toInt(v, def) {
+        const n = (typeof v === "number") ? v : parseInt(v, 10);
+        return isNaN(n) ? def : Math.floor(n);
+    }
+    isConfigured(material) {
+        return !!(material && material.metadata && material.metadata.atlasSkinConfigured === true);
+    }
+    markConfigured(material) {
+        material.metadata = material.metadata || {};
+        material.metadata.atlasSkinConfigured = true;
+    }
+    describeKind(kind) {
+        if (kind === "vat")
+            return "VAT Mesh (packed cell index)";
+        if (kind === "instanced")
+            return "Instanced Mesh (per-instance UV buffer)";
+        return "Babylon Mesh (cloned material uniform)";
+    }
+}
 export class UserInterface extends ScriptComponent {
     constructor(transform, scene, properties = {}, alias = "UserInterface") {
         super(transform, scene, properties, alias);
@@ -30775,6 +31731,7 @@ SceneManager.RegisterClass("CustomShaderMaterial", CustomShaderMaterial);
 SceneManager.RegisterClass("UniversalShaderMaterial", UniversalShaderMaterial);
 SceneManager.RegisterClass("UnityStyleLightingPlugin", UnityStyleLightingPlugin);
 SceneManager.RegisterClass("CustomShaderMaterialPlugin", CustomShaderMaterialPlugin);
+SceneManager.RegisterClass("SkinArraySwitchingPlugin", SkinArraySwitchingPlugin);
 SceneManager.RegisterClass("StandardShaderMaterial", StandardShaderMaterial);
 SceneManager.RegisterClass("StandardShaderMaterialPlugin", StandardShaderMaterialPlugin);
 SceneManager.RegisterClass("UniversalTerrainMaterial", UniversalTerrainMaterial);
@@ -41407,7 +42364,9 @@ SceneManager.RegisterClass("NavigationAgent", NavigationAgent);
 SceneManager.RegisterClass("PostProcessor", PostProcessor);
 SceneManager.RegisterClass("RigidbodyPhysics", RigidbodyPhysics);
 SceneManager.RegisterClass("ShurikenParticles", ShurikenParticles);
+SceneManager.RegisterClass("SkinTextureArray", SkinTextureArray);
 SceneManager.RegisterClass("TerrainBuilder", TerrainBuilder);
+SceneManager.RegisterClass("TextureAtlasSkin", TextureAtlasSkin);
 SceneManager.RegisterClass("UnitySlider", UnitySlider);
 SceneManager.RegisterClass("UnityScrollBar", UnityScrollBar);
 SceneManager.RegisterClass("UnityDropdownMenu", UnityDropdownMenu);