zakeke-configurator-react 0.1.370 → 0.1.372

package/dist/declarations/3D/src/Components/InfoPointsManager/InfoPointsManager.d.ts

@@ -1,122 +1,122 @@
-import { IDisposable } from "../../Interfaces/IDisposable";
-import { Nullable } from "../../types";
-export type InfoPointsStyle = {
-    borderColor?: string;
-    innerPointColor?: string;
-    color?: string;
-    highlightColor?: string;
-};
-export type ImagePanelStyle = {
-    backgroundColor?: string;
-    loadingTextColor?: string;
-    buttonsBorderColor?: string;
-    buttonsColor?: string;
-    buttonsBorderHighlightColor?: string;
-    buttonsHighlightColor?: string;
-    buttonsIconColor?: string;
-};
-export type InfoPointsManagerStyle = {
-    infoPointsStyle?: InfoPointsStyle;
-    imagePanelStyle?: ImagePanelStyle;
-};
-export type InfoPointPickedEventArgs = {
-    meshID: string;
-    materialID: string | null;
-    materialPhotoUrl: string[];
-};
-export type InfoPointPickedEventListener = (evt: InfoPointPickedEventArgs) => void;
-export type InfoPointContentShownListener = () => void;
-export type InfoPointContentHiddenListener = () => void;
-export declare class InfoPointsManager implements IDisposable {
-    private _zkScene;
-    private _scene;
-    private _sceneHelper;
-    private _style;
-    private _rootContainer;
-    private _meshesInfoPoints;
-    private _infoPoints;
-    private _imageUrls;
-    private _currentIdx;
-    private _imagePanel;
-    private _loadingText;
-    private _image;
-    private _closeImageButton;
-    private _moveNextImageButton;
-    private _movePrevImageButton;
-    private _isOnMoveNextButton;
-    private _isOnMovePrevButton;
-    private _lastCameraPosition;
-    onBeforeShowImages: Nullable<() => void>;
-    onAfterShowImages: Nullable<() => void>;
-    private _infoPointsShown;
-    get infoPointsShown(): boolean;
-    private _canShowInfoPointsContent;
-    get canShowInfoPointsContent(): boolean;
-    set canShowInfoPointsContent(value: boolean);
-    private _infoPointPickedListeners;
-    private _infoPointContentShownListeners;
-    private _infoPointContentHiddenListeners;
-    private _renderingNeededListeners;
-    private CLOSE_SVG;
-    private CHEVRON_LEFT_SVG;
-    private CHEVRON_RIGHT_SVG;
-    constructor(zkScene: Zakeke.Scene, scene: BABYLON.Scene, style?: InfoPointsManagerStyle);
-    dispose(): void;
-    private setDefaultStyle;
-    private setStyle;
-    applyStyle(style: Nullable<InfoPointsManagerStyle>): void;
-    showInfoPoints(): void;
-    hideInfoPoints(): void;
-    refresh(): void;
-    private getAllInfoPoints;
-    private refreshInfoPoints;
-    private removeMeshInfoPoints;
-    private getOrCreateMeshInfoPoint;
-    private updateInfoPointUrls;
-    private createMeshInfoPoint;
-    private getMaterialInfoPoint;
-    private getMaterialPhotoUrls;
-    private getOrCreateImagePanel;
-    private createImagePanel;
-    private addCloseButton;
-    private addMoveNextImageButton;
-    private addMovePrevImageButton;
-    private updateMoveNextImageButton;
-    private updateMovePrevImageButton;
-    private showImages;
-    private moveNextImage;
-    private movePrevImage;
-    private showCurrentImage;
-    private canMoveNextImage;
-    private canMovePrevImage;
-    private hideImages;
-    private showImage;
-    /**
-     * Update info points visibility and return true if at least one info point has been updated.
-     *
-     * @return {boolean} Return true if any info point has been updated.
-     */
-    updateInfoPointsVisibility(): boolean;
-    drawRay(origin: BABYLON.Vector3, forward: BABYLON.Vector3): void;
-    private updateMeshInfoPointVisibility;
-    private getCloseSvg;
-    private getChevronLeftSvg;
-    private getChevronRightSvg;
-    private getSvg;
-    private fireInfoPointPickedEvent;
-    addInfoPointPickedListener(listenerFunction: InfoPointPickedEventListener): void;
-    addInfoPointPickedListenerRange(listenerFunctions: InfoPointPickedEventListener[]): void;
-    private fireInfoPointContentShownEvent;
-    addInfoPointContentShownListener(listenerFunction: InfoPointContentShownListener): void;
-    addInfoPointContentShownListenerRange(listenerFunctions: InfoPointContentShownListener[]): void;
-    private fireInfoPointContentHiddenEvent;
-    addInfoPointContentHiddenListener(listenerFunction: InfoPointContentHiddenListener): void;
-    addInfoPointContentHiddenListenerRange(listenerFunctions: InfoPointContentHiddenListener[]): void;
-    private fireRenderingNeededEvent;
-    addRenderingNeededListener(listenerFunction: () => void): void;
-    showLoadingText(): void;
-    hideLoadingText(): void;
-    private updateGuiElementsStyle;
-    private updateMeshInfoPointsStyle;
-    private updateImagePanelStyle;
-}
+import { IDisposable } from "../../Interfaces/IDisposable";
+import { Nullable } from "../../types";
+export type InfoPointsStyle = {
+    borderColor?: string;
+    innerPointColor?: string;
+    color?: string;
+    highlightColor?: string;
+};
+export type ImagePanelStyle = {
+    backgroundColor?: string;
+    loadingTextColor?: string;
+    buttonsBorderColor?: string;
+    buttonsColor?: string;
+    buttonsBorderHighlightColor?: string;
+    buttonsHighlightColor?: string;
+    buttonsIconColor?: string;
+};
+export type InfoPointsManagerStyle = {
+    infoPointsStyle?: InfoPointsStyle;
+    imagePanelStyle?: ImagePanelStyle;
+};
+export type InfoPointPickedEventArgs = {
+    meshID: string;
+    materialID: string | null;
+    materialPhotoUrl: string[];
+};
+export type InfoPointPickedEventListener = (evt: InfoPointPickedEventArgs) => void;
+export type InfoPointContentShownListener = () => void;
+export type InfoPointContentHiddenListener = () => void;
+export declare class InfoPointsManager implements IDisposable {
+    private _zkScene;
+    private _scene;
+    private _sceneHelper;
+    private _style;
+    private _rootContainer;
+    private _meshesInfoPoints;
+    private _infoPoints;
+    private _imageUrls;
+    private _currentIdx;
+    private _imagePanel;
+    private _loadingText;
+    private _image;
+    private _closeImageButton;
+    private _moveNextImageButton;
+    private _movePrevImageButton;
+    private _isOnMoveNextButton;
+    private _isOnMovePrevButton;
+    private _lastCameraPosition;
+    onBeforeShowImages: Nullable<() => void>;
+    onAfterShowImages: Nullable<() => void>;
+    private _infoPointsShown;
+    get infoPointsShown(): boolean;
+    private _canShowInfoPointsContent;
+    get canShowInfoPointsContent(): boolean;
+    set canShowInfoPointsContent(value: boolean);
+    private _infoPointPickedListeners;
+    private _infoPointContentShownListeners;
+    private _infoPointContentHiddenListeners;
+    private _renderingNeededListeners;
+    private CLOSE_SVG;
+    private CHEVRON_LEFT_SVG;
+    private CHEVRON_RIGHT_SVG;
+    constructor(zkScene: Zakeke.Scene, scene: BABYLON.Scene, style?: InfoPointsManagerStyle);
+    dispose(): void;
+    private setDefaultStyle;
+    private setStyle;
+    applyStyle(style: Nullable<InfoPointsManagerStyle>): void;
+    showInfoPoints(): void;
+    hideInfoPoints(): void;
+    refresh(): void;
+    private getAllInfoPoints;
+    private refreshInfoPoints;
+    private removeMeshInfoPoints;
+    private getOrCreateMeshInfoPoint;
+    private updateInfoPointUrls;
+    private createMeshInfoPoint;
+    private getMaterialInfoPoint;
+    private getMaterialPhotoUrls;
+    private getOrCreateImagePanel;
+    private createImagePanel;
+    private addCloseButton;
+    private addMoveNextImageButton;
+    private addMovePrevImageButton;
+    private updateMoveNextImageButton;
+    private updateMovePrevImageButton;
+    private showImages;
+    private moveNextImage;
+    private movePrevImage;
+    private showCurrentImage;
+    private canMoveNextImage;
+    private canMovePrevImage;
+    private hideImages;
+    private showImage;
+    /**
+     * Update info points visibility and return true if at least one info point has been updated.
+     *
+     * @return {boolean} Return true if any info point has been updated.
+     */
+    updateInfoPointsVisibility(): boolean;
+    drawRay(origin: BABYLON.Vector3, forward: BABYLON.Vector3): void;
+    private updateMeshInfoPointVisibility;
+    private getCloseSvg;
+    private getChevronLeftSvg;
+    private getChevronRightSvg;
+    private getSvg;
+    private fireInfoPointPickedEvent;
+    addInfoPointPickedListener(listenerFunction: InfoPointPickedEventListener): void;
+    addInfoPointPickedListenerRange(listenerFunctions: InfoPointPickedEventListener[]): void;
+    private fireInfoPointContentShownEvent;
+    addInfoPointContentShownListener(listenerFunction: InfoPointContentShownListener): void;
+    addInfoPointContentShownListenerRange(listenerFunctions: InfoPointContentShownListener[]): void;
+    private fireInfoPointContentHiddenEvent;
+    addInfoPointContentHiddenListener(listenerFunction: InfoPointContentHiddenListener): void;
+    addInfoPointContentHiddenListenerRange(listenerFunctions: InfoPointContentHiddenListener[]): void;
+    private fireRenderingNeededEvent;
+    addRenderingNeededListener(listenerFunction: () => void): void;
+    showLoadingText(): void;
+    hideLoadingText(): void;
+    private updateGuiElementsStyle;
+    private updateMeshInfoPointsStyle;
+    private updateImagePanelStyle;
+}

package/dist/declarations/3D/src/Components/MaterialsPreview/MaterialsPreview.d.ts

@@ -1,16 +1,16 @@
-export interface IMaterialPreviewOptions {
-    width?: number;
-    height?: number;
-    crop?: boolean;
-}
-export declare class MaterialPreviewData {
-    previewFiles: {
-        [fileName: string]: Blob | string;
-    };
-    constructor();
-    downloadFiles(): void;
-}
-export declare class MaterialsPreview {
-    static getPreviewsAsync(scene: BABYLON.Scene, rootUrl: string, materialIDs: string[], options?: IMaterialPreviewOptions, createBlobs?: boolean): Promise<MaterialPreviewData>;
-    static downloadPreviewsAsync(scene: BABYLON.Scene, rootUrl: string, materialsIDs: string[], options?: IMaterialPreviewOptions): Promise<void>;
-}
+export interface IMaterialPreviewOptions {
+    width?: number;
+    height?: number;
+    crop?: boolean;
+}
+export declare class MaterialPreviewData {
+    previewFiles: {
+        [fileName: string]: Blob | string;
+    };
+    constructor();
+    downloadFiles(): void;
+}
+export declare class MaterialsPreview {
+    static getPreviewsAsync(scene: BABYLON.Scene, rootUrl: string, materialIDs: string[], options?: IMaterialPreviewOptions, createBlobs?: boolean): Promise<MaterialPreviewData>;
+    static downloadPreviewsAsync(scene: BABYLON.Scene, rootUrl: string, materialsIDs: string[], options?: IMaterialPreviewOptions): Promise<void>;
+}

package/dist/declarations/3D/src/Components/MeshExpander/MeshExpander.d.ts

@@ -1,24 +1,24 @@
-import { IDisposable } from "../../Interfaces/IDisposable";
-export declare class MeshExpander implements IDisposable {
-    private _mesh;
-    private _scene;
-    private _facesOfVertices;
-    private _meshVerticesPositions;
-    private _meshVerticesNormals;
-    private _meshIndices;
-    private _meshPositions;
-    private _meshFacesNormals;
-    private _sharedFacesOfVertices;
-    constructor();
-    dispose(): void;
-    private resetDataModel;
-    private prepareDataModel;
-    private _getFaceVerticesIndex;
-    private _computeFaceNormal;
-    private _getPositionKey;
-    private _getFacesOfVertices;
-    expandMesh(mesh: BABYLON.AbstractMesh, delta?: number): void;
-    _reComputeNormals(): void;
-    private _getVertexComputedNormal;
-    private _computeNormal;
-}
+import { IDisposable } from "../../Interfaces/IDisposable";
+export declare class MeshExpander implements IDisposable {
+    private _mesh;
+    private _scene;
+    private _facesOfVertices;
+    private _meshVerticesPositions;
+    private _meshVerticesNormals;
+    private _meshIndices;
+    private _meshPositions;
+    private _meshFacesNormals;
+    private _sharedFacesOfVertices;
+    constructor();
+    dispose(): void;
+    private resetDataModel;
+    private prepareDataModel;
+    private _getFaceVerticesIndex;
+    private _computeFaceNormal;
+    private _getPositionKey;
+    private _getFacesOfVertices;
+    expandMesh(mesh: BABYLON.AbstractMesh, delta?: number): void;
+    _reComputeNormals(): void;
+    private _getVertexComputedNormal;
+    private _computeNormal;
+}

package/dist/declarations/3D/src/Components/NormalMap/ProceduralNormalMap.d.ts

@@ -1,30 +1,30 @@
-import { IDisposable } from '../../Interfaces/IDisposable';
-export declare class ProceduralNormalMap implements IDisposable {
-    private _size;
-    private _scene;
-    private _baseTexture;
-    private _bias;
-    private _invertR;
-    private _invertG;
-    private _preBlurEnabled;
-    private _preBlur;
-    private _postBlurEnabled;
-    private _postBlur;
-    private _bevel;
-    private _intensity;
-    private _activeTextures;
-    private _preBlurXTexture;
-    private _preBlurYTexture;
-    private _normalMapTexture;
-    private _postBlurXTexture;
-    private _postBlurYTexture;
-    constructor(baseTexture: BABYLON.Texture, size: number, config: MPlaza.NormalmapConfig, scene: BABYLON.Scene);
-    private init;
-    private updateTextures;
-    private updatePreBlurTexture;
-    private updateNormalmapTexture;
-    private updatePostBlurTexture;
-    dispose(): void;
-    getNormalMapTextureAsync(baseTexture: BABYLON.Texture, config: MPlaza.NormalmapConfig): Promise<BABYLON.ProceduralTexture | null>;
-    updateAsync(baseTexture: BABYLON.Texture, config: MPlaza.NormalmapConfig): Promise<void>;
-}
+import { IDisposable } from '../../Interfaces/IDisposable';
+export declare class ProceduralNormalMap implements IDisposable {
+    private _size;
+    private _scene;
+    private _baseTexture;
+    private _bias;
+    private _invertR;
+    private _invertG;
+    private _preBlurEnabled;
+    private _preBlur;
+    private _postBlurEnabled;
+    private _postBlur;
+    private _bevel;
+    private _intensity;
+    private _activeTextures;
+    private _preBlurXTexture;
+    private _preBlurYTexture;
+    private _normalMapTexture;
+    private _postBlurXTexture;
+    private _postBlurYTexture;
+    constructor(baseTexture: BABYLON.Texture, size: number, config: MPlaza.NormalmapConfig, scene: BABYLON.Scene);
+    private init;
+    private updateTextures;
+    private updatePreBlurTexture;
+    private updateNormalmapTexture;
+    private updatePostBlurTexture;
+    dispose(): void;
+    getNormalMapTextureAsync(baseTexture: BABYLON.Texture, config: MPlaza.NormalmapConfig): Promise<BABYLON.ProceduralTexture | null>;
+    updateAsync(baseTexture: BABYLON.Texture, config: MPlaza.NormalmapConfig): Promise<void>;
+}

package/dist/declarations/3D/src/Components/Preview3D/Preview3DConfigurationManager.d.ts

@@ -1,51 +1,51 @@
-import { Nullable } from "../../types";
-type VariableMaterialSelection = {
-    id: string;
-    name: string;
-    selected: boolean;
-};
-type SelectedAttributeOption = {
-    attributeID: Nullable<number>;
-    attributeGuid: Nullable<string>;
-    optionID: Nullable<number>;
-    optionGuid: Nullable<string>;
-};
-export declare class Preview3DConfigurationManager {
-    private _zkModel;
-    private _zkScene;
-    private _scene;
-    private _sceneHelper;
-    constructor(zkModel: MPlaza.Model, zkScene: Zakeke.Scene, scene: BABYLON.Scene);
-    getPossibleVariableMaterials(): BABYLON.Material[];
-    getVariableMaterials(): BABYLON.Material[];
-    getVariableMaterialsSelection(): VariableMaterialSelection[];
-    getVariantMaterialsWithOriginal(modelColor: any): {
-        material: BABYLON.Material;
-        variableMaterial: BABYLON.Material;
-    }[];
-    updateVariableMaterials(): void;
-    unsetVariableMaterialID(materialID: string): void;
-    setVariableMaterialID(materialID: string): void;
-    private checkVariantOption;
-    private createVariantOption;
-    private removeVariantOption;
-    private getOrCreateVariantAttribute;
-    private getOrCreateVariantAttributeOption;
-    private getVariantID;
-    private checkVariantOptionMaterial;
-    private setupSceneMaterialForVariant;
-    private getSceneMaterialForVariant;
-    private isSceneMaterialForVariant;
-    private canDeleteSceneMaterialForVariant;
-    private getSceneMaterialMetadata;
-    private getOrCreateSceneMaterialMetadata;
-    private removeSceneMaterialMetadata;
-    private cloneSceneMaterial;
-    private deleteSceneMaterial;
-    private checkVariantOptionActions;
-    getVariantMaterials(modelColor: MPlaza.Color): BABYLON.Material[];
-    getSelectedAttributeOption(selectedModelColor: MPlaza.Color): SelectedAttributeOption;
-    resetOriginaMaterialsOnMeshes(): void;
-    getMeshesUsingMaterial(materialID: string): BABYLON.AbstractMesh[];
-}
-export {};
+import { Nullable } from "../../types";
+type VariableMaterialSelection = {
+    id: string;
+    name: string;
+    selected: boolean;
+};
+type SelectedAttributeOption = {
+    attributeID: Nullable<number>;
+    attributeGuid: Nullable<string>;
+    optionID: Nullable<number>;
+    optionGuid: Nullable<string>;
+};
+export declare class Preview3DConfigurationManager {
+    private _zkModel;
+    private _zkScene;
+    private _scene;
+    private _sceneHelper;
+    constructor(zkModel: MPlaza.Model, zkScene: Zakeke.Scene, scene: BABYLON.Scene);
+    getPossibleVariableMaterials(): BABYLON.Material[];
+    getVariableMaterials(): BABYLON.Material[];
+    getVariableMaterialsSelection(): VariableMaterialSelection[];
+    getVariantMaterialsWithOriginal(modelColor: any): {
+        material: BABYLON.Material;
+        variableMaterial: BABYLON.Material;
+    }[];
+    updateVariableMaterials(): void;
+    unsetVariableMaterialID(materialID: string): void;
+    setVariableMaterialID(materialID: string): void;
+    private checkVariantOption;
+    private createVariantOption;
+    private removeVariantOption;
+    private getOrCreateVariantAttribute;
+    private getOrCreateVariantAttributeOption;
+    private getVariantID;
+    private checkVariantOptionMaterial;
+    private setupSceneMaterialForVariant;
+    private getSceneMaterialForVariant;
+    private isSceneMaterialForVariant;
+    private canDeleteSceneMaterialForVariant;
+    private getSceneMaterialMetadata;
+    private getOrCreateSceneMaterialMetadata;
+    private removeSceneMaterialMetadata;
+    private cloneSceneMaterial;
+    private deleteSceneMaterial;
+    private checkVariantOptionActions;
+    getVariantMaterials(modelColor: MPlaza.Color): BABYLON.Material[];
+    getSelectedAttributeOption(selectedModelColor: MPlaza.Color): SelectedAttributeOption;
+    resetOriginaMaterialsOnMeshes(): void;
+    getMeshesUsingMaterial(materialID: string): BABYLON.AbstractMesh[];
+}
+export {};

package/dist/declarations/3D/src/Components/ProceduralTextures/BaseProceduralTexture.d.ts

@@ -1,16 +1,16 @@
-import { ISupportInitialize } from "../../Interfaces/ISupportInitialize";
-import { IDisposable } from "../../Interfaces/IDisposable";
-export declare abstract class BaseProceduralTexture extends BABYLON.ProceduralTexture implements IDisposable, ISupportInitialize {
-    private _initializing;
-    private _baseTexture;
-    protected get initializing(): boolean;
-    get baseTexture(): BABYLON.Texture;
-    set baseTexture(texture: BABYLON.Texture);
-    isReadyAsync(): Promise<void>;
-    constructor(name: string, size: number, fragment: string, scene: BABYLON.Scene, baseTexture: BABYLON.Texture, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
-    dispose(): void;
-    beginInit(): void;
-    endInit(): void;
-    protected updateShaderUniforms(): void;
-    protected setBaseTextureUniform(): void;
-}
+import { ISupportInitialize } from "../../Interfaces/ISupportInitialize";
+import { IDisposable } from "../../Interfaces/IDisposable";
+export declare abstract class BaseProceduralTexture extends BABYLON.ProceduralTexture implements IDisposable, ISupportInitialize {
+    private _initializing;
+    private _baseTexture;
+    protected get initializing(): boolean;
+    get baseTexture(): BABYLON.Texture;
+    set baseTexture(texture: BABYLON.Texture);
+    isReadyAsync(): Promise<void>;
+    constructor(name: string, size: number, fragment: string, scene: BABYLON.Scene, baseTexture: BABYLON.Texture, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+    dispose(): void;
+    beginInit(): void;
+    endInit(): void;
+    protected updateShaderUniforms(): void;
+    protected setBaseTextureUniform(): void;
+}

package/dist/declarations/3D/src/Components/ProceduralTextures/BlendProceduralTexture.d.ts

@@ -1,31 +1,31 @@
-import { IDisposable } from '../../Interfaces/IDisposable';
-import { Nullable } from '../../types';
-export declare class BlendProceduralTexture extends BABYLON.ProceduralTexture implements IDisposable {
-    private _baseTexture;
-    private _blendTexture;
-    static readonly FRAGMENT_SHADER = "zakeke_BlendProceduralTexture";
-    static readonly CUSTOM_TYPE = "Zakeke.BlendProceduralTexture";
-    constructor(name: string, size: number, scene?: Nullable<BABYLON.Scene>, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
-    dispose(): void;
-    updateShaderUniforms(): void;
-    render(useCameraPostProcess?: boolean): void;
-    resize(size: number, generateMipMaps: any): void;
-    isReady(): boolean;
-    get baseTexture(): Nullable<BABYLON.Texture>;
-    set baseTexture(texture: Nullable<BABYLON.Texture>);
-    get blendTexture(): Nullable<BABYLON.Texture>;
-    set blendTexture(texture: Nullable<BABYLON.Texture>);
-    /**
-     * Serializes this normal map procedural texture
-     * @returns a serialized normal map procedural texture object
-     */
-    serialize(): any;
-    /**
-     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
-     * @param parsedTexture defines parsed texture data
-     * @param scene defines the current scene
-     * @param rootUrl defines the root URL containing normal map procedural texture information
-     * @returns a parsed Normal Map Procedural Texture
-     */
-    static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): BlendProceduralTexture;
-}
+import { IDisposable } from '../../Interfaces/IDisposable';
+import { Nullable } from '../../types';
+export declare class BlendProceduralTexture extends BABYLON.ProceduralTexture implements IDisposable {
+    private _baseTexture;
+    private _blendTexture;
+    static readonly FRAGMENT_SHADER = "zakeke_BlendProceduralTexture";
+    static readonly CUSTOM_TYPE = "Zakeke.BlendProceduralTexture";
+    constructor(name: string, size: number, scene?: Nullable<BABYLON.Scene>, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+    dispose(): void;
+    updateShaderUniforms(): void;
+    render(useCameraPostProcess?: boolean): void;
+    resize(size: number, generateMipMaps: any): void;
+    isReady(): boolean;
+    get baseTexture(): Nullable<BABYLON.Texture>;
+    set baseTexture(texture: Nullable<BABYLON.Texture>);
+    get blendTexture(): Nullable<BABYLON.Texture>;
+    set blendTexture(texture: Nullable<BABYLON.Texture>);
+    /**
+     * Serializes this normal map procedural texture
+     * @returns a serialized normal map procedural texture object
+     */
+    serialize(): any;
+    /**
+     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing normal map procedural texture information
+     * @returns a parsed Normal Map Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): BlendProceduralTexture;
+}

package/dist/declarations/3D/src/Components/ProceduralTextures/BlurXProceduralTexture.d.ts

@@ -1,23 +1,23 @@
-import { IDisposable } from '../../Interfaces/IDisposable';
-import { BaseProceduralTexture } from './BaseProceduralTexture';
-export declare class BlurXProceduralTexture extends BaseProceduralTexture implements IDisposable {
-    static readonly FRAGMENT_SHADER = "zakeke_BlurXProceduralTexture";
-    static readonly CUSTOM_TYPE = "Zakeke.BlurXProceduralTexture";
-    private _blur;
-    get blur(): number;
-    set blur(value: number);
-    constructor(name: string, size: number, scene: BABYLON.Scene, baseTexture: BABYLON.Texture, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
-    dispose(): void;
-    updateShaderUniforms(): void;
-    /**
-    * Render the texture to its associated render target.
-    * @param useCameraPostProcess Define if camera post process should be applied to the texture
-    */
-    render(useCameraPostProcess?: boolean): void;
-    /**
-      * Resize the texture to new value.
-      * @param size Define the new size the texture should have
-      * @param generateMipMaps Define whether the new texture should create mip maps
-      */
-    resize(size: number, generateMipMaps: boolean): void;
-}
+import { IDisposable } from '../../Interfaces/IDisposable';
+import { BaseProceduralTexture } from './BaseProceduralTexture';
+export declare class BlurXProceduralTexture extends BaseProceduralTexture implements IDisposable {
+    static readonly FRAGMENT_SHADER = "zakeke_BlurXProceduralTexture";
+    static readonly CUSTOM_TYPE = "Zakeke.BlurXProceduralTexture";
+    private _blur;
+    get blur(): number;
+    set blur(value: number);
+    constructor(name: string, size: number, scene: BABYLON.Scene, baseTexture: BABYLON.Texture, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+    dispose(): void;
+    updateShaderUniforms(): void;
+    /**
+    * Render the texture to its associated render target.
+    * @param useCameraPostProcess Define if camera post process should be applied to the texture
+    */
+    render(useCameraPostProcess?: boolean): void;
+    /**
+      * Resize the texture to new value.
+      * @param size Define the new size the texture should have
+      * @param generateMipMaps Define whether the new texture should create mip maps
+      */
+    resize(size: number, generateMipMaps: boolean): void;
+}