@babylonjs-toolkit/next 9.12.1 → 9.12.1011

package/lib/scenemanager.d.ts

@@ -47,7 +47,7 @@ import { MaterialDefines } from '@babylonjs/core/Materials/materialDefines';
 import { UniformBuffer } from '@babylonjs/core/Materials/uniformBuffer';
 import { MaterialPluginBase } from '@babylonjs/core/Materials/materialPluginBase';
 import { IAnimatable } from '@babylonjs/core/Animations';
-import { ShaderLanguage } from '@babylonjs/core/Materials';
+import { ShaderLanguage, RawTexture2DArray } from '@babylonjs/core/Materials';
 import { StaticSound, IStaticSoundOptions, AudioEngineV2, StaticSoundBuffer, StreamingSound, IWebAudioEngineOptions, AbstractSpatialAudio, IStaticSoundBufferOptions, IStreamingSoundOptions } from '@babylonjs/core/AudioV2';
 import { VertexData } from '@babylonjs/core/Meshes/mesh.vertexData';
 import { IFileRequest } from '@babylonjs/core/Misc/fileRequest';
@@ -814,6 +814,8 @@ export declare class CVTOOLS_unity_metadata implements IGLTFLoaderExtension {
     static readonly IBL_SPEC_FACTOR: number;
     static readonly IBL_PROBE_FACTOR: number;
     static SuppressReflectionProbeDiffuse(texture: BaseTexture): void;
+    static ApplyGlobalReflectionProbeDiffuse(texture: BaseTexture, scene: Scene, createPolynomialsFromFaces?: boolean): void;
+    private static _boxProjectionShaderPatched;
     enabled: boolean;
     private _webgpu;
     private _loader;
@@ -920,6 +922,12 @@ export declare class CustomShaderMaterial extends PBRMaterial {
     protected shader: string;
     protected plugin: MaterialPluginBase;
     private _unityLightingPlugin;
+    private _skinArray;
+    private _skinArrayNormal;
+    private _skinArrayMetalRough;
+    private _skinArrayEmissive;
+    private _skinLayerUniform;
+    private _skinArraySwitchingPlugin;
     getPlugin(): MaterialPluginBase;
     getClassName(): string;
     constructor(name: string, scene: Scene);
@@ -928,6 +936,21 @@ export declare class CustomShaderMaterial extends PBRMaterial {
     checkUniform(uniformName: string, type: string, value?: any): void;
     checkSampler(samplerName: string, texture?: any): void;
     splitLighting(diffuseIbl: number, specularIbl: number): void;
+    enableSkinArray(layerUniform?: boolean): CustomShaderMaterial;
+    setSkinLayer(layer: number): CustomShaderMaterial;
+    enableSkinArrayNormal(enabled?: boolean): CustomShaderMaterial;
+    enableSkinArrayMetalRough(enabled?: boolean): CustomShaderMaterial;
+    enableSkinArrayEmissive(enabled?: boolean): CustomShaderMaterial;
+    setSkinArrayLayerMode(uniform: boolean): CustomShaderMaterial;
+    addTextureArrayUniform(name: string, texture: BaseTexture): CustomShaderMaterial;
+    get skinArray(): boolean;
+    get skinArrayNormal(): boolean;
+    get skinArrayMetalRough(): boolean;
+    get skinArrayEmissive(): boolean;
+    get skinArrayActive(): boolean;
+    get skinLayerUniform(): boolean;
+    clone(name: string, cloneTexturesOnlyOnce?: boolean, rootUrl?: string): CustomShaderMaterial;
+    protected copyCustomStateTo(result: CustomShaderMaterial): void;
     addTextureUniform(name: string, texture: Texture): CustomShaderMaterial;
     setTextureValue(name: string, texture: Texture): CustomShaderMaterial;
     markTextureAsRaw(name: string): void;
@@ -979,6 +1002,31 @@ export declare class UnityStyleLightingPlugin extends CustomShaderMaterialPlugin
     prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
     bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
 }
+export declare class SkinArraySwitchingPlugin extends CustomShaderMaterialPlugin {
+    constructor(material: CustomShaderMaterial);
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    getClassName(): string;
+    getAttributes(attributes: string[], scene: Scene, mesh: AbstractMesh): void;
+    getSamplers(samplers: string[]): void;
+    prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
+    private getGLSLVertexDefinitions;
+    private getGLSLVertexMainEnd;
+    private getGLSLFragmentDefinitions;
+    private getGLSLAlbedoCode;
+    private getGLSLNormalCode;
+    private getGLSLMetalRoughSampleCode;
+    private getGLSLMetalRoughApplyCode;
+    private getGLSLEmissiveCode;
+    private getWGSLVertexDefinitions;
+    private getWGSLVertexMainEnd;
+    private getWGSLFragmentDefinitions;
+    private getWGSLAlbedoCode;
+    private getWGSLNormalCode;
+    private getWGSLMetalRoughSampleCode;
+    private getWGSLMetalRoughApplyCode;
+    private getWGSLEmissiveCode;
+}
 export type CustomUniformProperty = {
     name: string;
     size: number;
@@ -1461,26 +1509,29 @@ export declare class TreeBranchMaterialPlugin extends CustomShaderMaterialPlugin
 }
 export declare class VertexAnimationMaterial extends CustomShaderMaterial {
     controller: VertexAnimationController;
-    runtimeAlbedoSkins: BaseTexture;
-    runtimeNormalSkins: BaseTexture;
+    private _vatSkinArray;
+    private _vatSkinArrayNormal;
+    private _vatSkinArrayMetalRough;
+    private _vatSkinArrayEmissive;
     constructor(name: string, scene: Scene);
     awake(): void;
     update(): void;
     getShaderName(): string;
     getController(): VertexAnimationController;
     cloneForInstance(instanceName: string): VertexAnimationMaterial;
-    setRuntimeSkinArrays(albedoArray: BaseTexture, normalArray: BaseTexture, nullOutDefaults?: boolean): void;
-    clearRuntimeSkinArrays(): void;
-    installSkinsFromUrlsAsync(layers: {
-        albedo: string;
-        normal: string;
-    }[], width: number, height: number, options?: {
-        nullOutDefaults?: boolean;
-        rootUrl?: string;
-        generateMipMaps?: boolean;
-        samplingMode?: number;
-    }): Promise<void>;
-    private _notifyPluginOfRuntimeSkinChange;
+    enableVatSkinArray(): VertexAnimationMaterial;
+    disableVatSkinArray(): void;
+    enableVatSkinArrayNormal(): VertexAnimationMaterial;
+    disableVatSkinArrayNormal(): void;
+    enableVatSkinArrayMetalRough(): VertexAnimationMaterial;
+    disableVatSkinArrayMetalRough(): void;
+    enableVatSkinArrayEmissive(): VertexAnimationMaterial;
+    disableVatSkinArrayEmissive(): void;
+    get vatSkinArray(): boolean;
+    get vatSkinArrayNormal(): boolean;
+    get vatSkinArrayMetalRough(): boolean;
+    get vatSkinArrayEmissive(): boolean;
+    get vatSkinArrayActive(): boolean;
 }
 export interface IVertexAnimationRendererReference {
     name?: string;
@@ -1539,8 +1590,8 @@ export declare class VertexAnimationController {
     static Find(guid: string): VertexAnimationController;
     static GetOrCreate(guid: string, scene: Scene, rootUrl?: string, lazyLoadTextures?: boolean): VertexAnimationController;
     static CollectRendererTargets(settings: IVertexAnimationSettings[]): IVertexAnimationRendererReference[];
-    static SetSkinIndex(mesh: AbstractMesh, skinIndex: number): void;
-    static GetSkinIndex(mesh: AbstractMesh): number;
+    static SetAtlasCellIndex(mesh: AbstractMesh, cellIndex: number): void;
+    static GetAtlasCellIndex(mesh: AbstractMesh): number;
     static DisposeAll(scene?: Scene): void;
     readonly guid: string;
     readonly scene: Scene;
@@ -1585,17 +1636,6 @@ export declare class VertexAnimationController {
     getClip(name: string): IVertexAnimationClip | null;
     setSpeed(speed: number): void;
     setLoop(loop: boolean): void;
-    setRuntimeSkinArrays(albedoArray: BaseTexture, normalArray: BaseTexture, nullOutDefaults?: boolean): void;
-    clearRuntimeSkinArrays(): void;
-    installSkinsFromUrlsAsync(layers: {
-        albedo: string;
-        normal: string;
-    }[], width: number, height: number, options?: {
-        nullOutDefaults?: boolean;
-        rootUrl?: string;
-        generateMipMaps?: boolean;
-        samplingMode?: number;
-    }): Promise<void>;
     setCurrentTime(time: number): void;
     getCurrentTime(): number;
     addPlugin(plugin: VertexAnimationMaterialPlugin): void;
@@ -1628,8 +1668,6 @@ export declare class VertexAnimationMaterialPlugin extends CustomShaderMaterialP
     private _rendererTargets;
     private _targetRendererGuid;
     private _placeholderTexture;
-    private _placeholderAlbedoArray;
-    private _placeholderNormalArray;
     private _cc_posTex;
     private _cc_normTex;
     private _cc_prevPosTex;
@@ -1655,9 +1693,7 @@ export declare class VertexAnimationMaterialPlugin extends CustomShaderMaterialP
     getSamplers(samplers: string[]): void;
     getAttributes(attributes: string[], scene: Scene, mesh: AbstractMesh): void;
     prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
-    onRuntimeSkinArraysChanged(): void;
     bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
-    private _pushRuntimeSkinSamplers;
     setupAnimations(settings: IVertexAnimationSettings[], controllerId: string, rootUrl?: string, lazyLoadTextures?: boolean): VertexAnimationController;
     private _captureRendererTarget;
     private _resolveRendererTarget;
@@ -1676,14 +1712,20 @@ export declare class VertexAnimationMaterialPlugin extends CustomShaderMaterialP
     private getWGSLVertexDefinitions;
     private getWGSLVertexPositionCode;
     private getWGSLVertexNormalCode;
-    private getGLSLVertexMainEnd;
-    private getWGSLVertexMainEnd;
-    private getGLSLFragmentDefinitions;
-    private getGLSLFragmentAlbedoCode;
-    private getGLSLFragmentNormalCode;
-    private getWGSLFragmentDefinitions;
-    private getWGSLFragmentAlbedoCode;
-    private getWGSLFragmentNormalCode;
+    private getGLSLSkinLayerVaryingCode;
+    private getGLSLSkinFragmentDefs;
+    private getGLSLSkinAlbedoCode;
+    private getGLSLSkinNormalCode;
+    private getGLSLSkinMetalRoughSampleCode;
+    private getGLSLSkinMetalRoughApplyCode;
+    private getGLSLSkinEmissiveCode;
+    private getWGSLSkinLayerVaryingCode;
+    private getWGSLSkinFragmentDefs;
+    private getWGSLSkinAlbedoCode;
+    private getWGSLSkinNormalCode;
+    private getWGSLSkinMetalRoughSampleCode;
+    private getWGSLSkinMetalRoughApplyCode;
+    private getWGSLSkinEmissiveCode;
 }
 export interface KeymapState {
     result: boolean | number;
@@ -3913,6 +3955,20 @@ export interface IParticleSystemProperties {
     trails?: any;
     customData?: any;
 }
+export declare class SkinTextureArray {
+    private static _cache;
+    static Build(scene: Scene, urls: string[], options?: {
+        samplingMode?: number;
+        aniso?: number;
+        invertY?: boolean;
+        mipmaps?: boolean;
+    }): Promise<RawTexture2DArray>;
+    private static _uploadMipChain;
+    private static _downsampleLayers;
+    private static _maxArrayLayers;
+    private static _loadImages;
+    static Clear(): void;
+}
 export declare class MeshNormalProxy {
     blendWithPhysicsNormal: number;
     maxLookupDistance: number;
@@ -4096,6 +4152,52 @@ export declare class TerrainBuilder extends ScriptComponent {
     private static GammaToLinear;
     private static LinearToGamma;
 }
+export declare class TextureAtlasSkin extends ScriptComponent {
+    private abtractMesh;
+    private textureData;
+    private defaultIndex;
+    private skinnedParts;
+    private albedoSlices;
+    private normalSlices;
+    private metallicSlices;
+    private occlusionSlices;
+    private emissiveSlices;
+    private _applied;
+    private _manifest;
+    private _currentIndex;
+    private _targets;
+    private _clonedMultiMaterial;
+    constructor(transform: TransformNode, scene: Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected start(): void;
+    applySkins(): void;
+    setSkinIndex(index: number): number;
+    private clampIndex;
+    skinCount(): number;
+    private maxChannelSliceCount;
+    getSkinIndex(): number;
+    private configureMaterial;
+    private albedoChannelUrls;
+    private normalChannelUrls;
+    private metalRoughChannelUrls;
+    private emissiveChannelUrls;
+    private sliceUrls;
+    private resolveLayerUrl;
+    private applyIndexToTargets;
+    private applyLayerToMaterial;
+    private isInstancedSetup;
+    private ensureSkinLayerBuffer;
+    private getMeshSlots;
+    private matchSlot;
+    private resolvePartMaterial;
+    private partName;
+    private cloneForRegular;
+    private parseManifest;
+    private toInt;
+    private isConfigured;
+    private markConfigured;
+    private describeKind;
+}
 export declare class UserInterface extends ScriptComponent {
     private static readonly PHYSICAL_SIZE_SLICE_FACTOR;
     private static readonly PHYSICAL_SIZE_POINT_FACTOR;