@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Rendering/renderingManager.d.ts

@@ -0,0 +1,108 @@
+/**
+ * This class is used by the onRenderingGroupObservable
+ */
+export class RenderingGroupInfo {
+}
+/**
+ * This is the manager responsible of all the rendering for meshes sprites and particles.
+ * It is enable to manage the different groups as well as the different necessary sort functions.
+ * This should not be used directly aside of the few static configurations
+ */
+export class RenderingManager {
+    /**
+     * Instantiates a new rendering group for a particular scene
+     * @param scene Defines the scene the groups belongs to
+     */
+    constructor(scene: any);
+    /**
+     * @internal
+     */
+    _useSceneAutoClearSetup: boolean;
+    _renderingGroups: any[];
+    _autoClearDepthStencil: {};
+    _customOpaqueSortCompareFn: {};
+    _customAlphaTestSortCompareFn: {};
+    _customTransparentSortCompareFn: {};
+    _renderingGroupInfo: RenderingGroupInfo;
+    _maintainStateBetweenFrames: boolean;
+    _scene: any;
+    set maintainStateBetweenFrames(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating that the manager will not reset between frames.
+     * This means that if a mesh becomes invisible or transparent it will not be visible until this boolean is set to false again.
+     * By default, the rendering manager will dispatch all active meshes per frame (moving them to the transparent, opaque or alpha testing lists).
+     * By turning this property on, you will accelerate the rendering by keeping all these lists unchanged between frames.
+     */
+    get maintainStateBetweenFrames(): boolean;
+    getRenderingGroup(id: any): any;
+    _clearDepthStencilBuffer(depth?: boolean, stencil?: boolean): void;
+    _depthStencilBufferAlreadyCleaned: boolean | undefined;
+    /**
+     * Renders the entire managed groups. This is used by the scene or the different render targets.
+     * @internal
+     */
+    render(customRenderFunction: any, activeMeshes: any, renderParticles: any, renderSprites: any): void;
+    /**
+     * Resets the different information of the group to prepare a new frame
+     * @internal
+     */
+    reset(): void;
+    /**
+     * Dispose and release the group and its associated resources.
+     * @internal
+     */
+    dispose(): void;
+    /**
+     * Clear the info related to rendering groups preventing retention points during dispose.
+     */
+    freeRenderingGroups(): void;
+    _prepareRenderingGroup(renderingGroupId: any): void;
+    /**
+     * Add a sprite manager to the rendering manager in order to render it this frame.
+     * @param spriteManager Define the sprite manager to render
+     */
+    dispatchSprites(spriteManager: any): void;
+    /**
+     * Add a particle system to the rendering manager in order to render it this frame.
+     * @param particleSystem Define the particle system to render
+     */
+    dispatchParticles(particleSystem: any): void;
+    /**
+     * Add a submesh to the manager in order to render it this frame
+     * @param subMesh The submesh to dispatch
+     * @param mesh Optional reference to the submeshes's mesh. Provide if you have an exiting reference to improve performance.
+     * @param material Optional reference to the submeshes's material. Provide if you have an exiting reference to improve performance.
+     */
+    dispatch(subMesh: any, mesh: any, material: any): void;
+    /**
+     * Overrides the default sort function applied in the rendering group to prepare the meshes.
+     * This allowed control for front to back rendering or reversely depending of the special needs.
+     *
+     * @param renderingGroupId The rendering group id corresponding to its index
+     * @param opaqueSortCompareFn The opaque queue comparison function use to sort.
+     * @param alphaTestSortCompareFn The alpha test queue comparison function use to sort.
+     * @param transparentSortCompareFn The transparent queue comparison function use to sort.
+     */
+    setRenderingOrder(renderingGroupId: any, opaqueSortCompareFn?: null, alphaTestSortCompareFn?: null, transparentSortCompareFn?: null): void;
+    /**
+     * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
+     *
+     * @param renderingGroupId The rendering group id corresponding to its index
+     * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
+     * @param depth Automatically clears depth between groups if true and autoClear is true.
+     * @param stencil Automatically clears stencil between groups if true and autoClear is true.
+     */
+    setRenderingAutoClearDepthStencil(renderingGroupId: any, autoClearDepthStencil: any, depth?: boolean, stencil?: boolean): void;
+    /**
+     * Gets the current auto clear configuration for one rendering group of the rendering
+     * manager.
+     * @param index the rendering group index to get the information for
+     * @returns The auto clear setup for the requested rendering group
+     */
+    getAutoClearDepthStencilSetup(index: any): any;
+}
+export namespace RenderingManager {
+    const MAX_RENDERINGGROUPS: number;
+    const MIN_RENDERINGGROUPS: number;
+    const AUTOCLEAR: boolean;
+}

package/dist/types/node_modules/@babylonjs/core/Rendering/screenSpaceReflectionsConfiguration.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Contains all parameters needed for the prepass to perform
+ * screen space reflections
+ */
+export class ScreenSpaceReflectionsConfiguration {
+    /**
+     * Is ssr enabled
+     */
+    enabled: boolean;
+    /**
+     * Name of the configuration
+     */
+    name: string;
+    /**
+     * Textures that should be present in the MRT for this effect to work
+     */
+    texturesRequired: number[];
+}

package/dist/types/node_modules/@babylonjs/core/Rendering/ssao2Configuration.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Contains all parameters needed for the prepass to perform
+ * screen space subsurface scattering
+ */
+export class SSAO2Configuration {
+    /**
+     * Is subsurface enabled
+     */
+    enabled: boolean;
+    /**
+     * Name of the configuration
+     */
+    name: string;
+    /**
+     * Textures that should be present in the MRT for this effect to work
+     */
+    texturesRequired: number[];
+}

package/dist/types/node_modules/@babylonjs/core/Rendering/subSurfaceConfiguration.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Contains all parameters needed for the prepass to perform
+ * screen space subsurface scattering
+ */
+export class SubSurfaceConfiguration {
+    /**
+     * Builds a subsurface configuration object
+     * @param scene The scene
+     */
+    constructor(scene: any);
+    _ssDiffusionS: any[];
+    _ssFilterRadii: any[];
+    _ssDiffusionD: any[];
+    /**
+     * Is subsurface enabled
+     */
+    enabled: boolean;
+    /**
+     * Does the output of this prepass need to go through imageprocessing
+     */
+    needsImageProcessing: boolean;
+    /**
+     * Name of the configuration
+     */
+    name: string;
+    /**
+     * Diffusion profile colors for subsurface scattering
+     * You can add one diffusion color using `addDiffusionProfile` on `scene.prePassRenderer`
+     * See ...
+     * Note that you can only store up to 5 of them
+     */
+    ssDiffusionProfileColors: any[];
+    /**
+     * Defines the ratio real world => scene units.
+     * Used for subsurface scattering
+     */
+    metersPerUnit: number;
+    /**
+     * Textures that should be present in the MRT for this effect to work
+     */
+    texturesRequired: number[];
+    _scene: any;
+    /**
+     * Diffusion profile color for subsurface scattering
+     */
+    get ssDiffusionS(): any[];
+    /**
+     * Diffusion profile max color channel value for subsurface scattering
+     */
+    get ssDiffusionD(): any[];
+    /**
+     * Diffusion profile filter radius for subsurface scattering
+     */
+    get ssFilterRadii(): any[];
+    /**
+     * Adds a new diffusion profile.
+     * Useful for more realistic subsurface scattering on diverse materials.
+     * @param color The color of the diffusion profile. Should be the average color of the material.
+     * @returns The index of the diffusion profile for the material subsurface configuration
+     */
+    addDiffusionProfile(color: any): number;
+    /**
+     * Creates the sss post process
+     * @returns The created post process
+     */
+    createPostProcess(): SubSurfaceScatteringPostProcess;
+    postProcess: SubSurfaceScatteringPostProcess | undefined;
+    /**
+     * Deletes all diffusion profiles.
+     * Note that in order to render subsurface scattering, you should have at least 1 diffusion profile.
+     */
+    clearAllDiffusionProfiles(): void;
+    /**
+     * Disposes this object
+     */
+    dispose(): void;
+    /**
+     * @internal
+     * https://zero-radiance.github.io/post/sampling-diffusion/
+     *
+     * Importance sample the normalized diffuse reflectance profile for the computed value of 's'.
+     * ------------------------------------------------------------------------------------
+     * R[r, phi, s]   = s * (Exp[-r * s] + Exp[-r * s / 3]) / (8 * Pi * r)
+     * PDF[r, phi, s] = r * R[r, phi, s]
+     * CDF[r, s]      = 1 - 1/4 * Exp[-r * s] - 3/4 * Exp[-r * s / 3]
+     * ------------------------------------------------------------------------------------
+     * We importance sample the color channel with the widest scattering distance.
+     */
+    getDiffusionProfileParameters(color: any): number;
+    /**
+     * Performs sampling of a Normalized Burley diffusion profile in polar coordinates.
+     * 'u' is the random number (the value of the CDF): [0, 1).
+     * rcp(s) = 1 / ShapeParam = ScatteringDistance.
+     * Returns the sampled radial distance, s.t. (u = 0 -> r = 0) and (u = 1 -> r = Inf).
+     * @param u
+     * @param rcpS
+     */
+    _sampleBurleyDiffusionProfile(u: any, rcpS: any): number;
+}
+export namespace SubSurfaceConfiguration {
+    /**
+     * @internal
+     */
+    function _SceneComponentInitialization(_: any): never;
+}
+import { SubSurfaceScatteringPostProcess } from "../PostProcesses/subSurfaceScatteringPostProcess.js";

package/dist/types/node_modules/@babylonjs/core/Rendering/subSurfaceSceneComponent.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Defines the Geometry Buffer scene component responsible to manage a G-Buffer useful
+ * in several rendering techniques.
+ */
+export class SubSurfaceSceneComponent {
+    /**
+     * Creates a new instance of the component for the given scene
+     * @param scene Defines the scene to register the component in
+     */
+    constructor(scene: any);
+    /**
+     * The component name helpful to identify the component in the list of scene components.
+     */
+    name: string;
+    scene: any;
+    /**
+     * Registers the component in a given scene
+     */
+    register(): void;
+    /**
+     * Serializes the component data to the specified json object
+     * @param serializationObject The object to serialize to
+     */
+    serialize(serializationObject: any): void;
+    /**
+     * Adds all the elements from the container to the scene
+     */
+    addFromContainer(): void;
+    /**
+     * Removes all the elements in the container from the scene
+     */
+    removeFromContainer(): void;
+    /**
+     * Rebuilds the elements related to this component in case of
+     * context lost for instance.
+     */
+    rebuild(): void;
+    /**
+     * Disposes the component and the associated resources
+     */
+    dispose(): void;
+}

package/dist/types/node_modules/@babylonjs/core/Rendering/utilityLayerRenderer.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Renders a layer on top of an existing scene
+ */
+export class UtilityLayerRenderer {
+    /**
+     * A shared utility layer that can be used to overlay objects into a scene (Depth map of the previous scene is cleared before drawing on top of it)
+     */
+    static get DefaultUtilityLayer(): any;
+    /**
+     * Creates an utility layer, and set it as a default utility layer
+     * @param scene associated scene
+     * @internal
+     */
+    static _CreateDefaultUtilityLayerFromScene(scene: any): any;
+    /**
+     * A shared utility layer that can be used to embed objects into a scene (Depth map of the previous scene is not cleared before drawing on top of it)
+     */
+    static get DefaultKeepDepthUtilityLayer(): any;
+    /**
+     * Instantiates a UtilityLayerRenderer
+     * @param originalScene the original scene that will be rendered on top of
+     * @param handleEvents boolean indicating if the utility layer should handle events
+     */
+    constructor(originalScene: any, handleEvents?: boolean);
+    originalScene: any;
+    _pointerCaptures: {};
+    _lastPointerEvents: {};
+    _sharedGizmoLight: HemisphericLight | null;
+    _renderCamera: any;
+    /**
+     * If the picking should be done on the utility layer prior to the actual scene (Default: true)
+     */
+    pickUtilitySceneFirst: boolean;
+    /**
+     *  If the utility layer should automatically be rendered on top of existing scene
+     */
+    shouldRender: boolean;
+    /**
+     * If set to true, only pointer down onPointerObservable events will be blocked when picking is occluded by original scene
+     */
+    onlyCheckPointerDownEvents: boolean;
+    /**
+     * If set to false, only pointerUp, pointerDown and pointerMove will be sent to the utilityLayerScene (false by default)
+     */
+    processAllEvents: boolean;
+    /**
+     * Set to false to disable picking
+     */
+    pickingEnabled: boolean;
+    /**
+     * Observable raised when the pointer moves from the utility layer scene to the main scene
+     */
+    onPointerOutObservable: Observable<any>;
+    utilityLayerScene: Scene;
+    _originalPointerObserver: any;
+    _afterRenderObserver: any;
+    _sceneDisposeObserver: any;
+    /**
+     * Gets the camera that is used to render the utility layer (when not set, this will be the last active camera)
+     * @param getRigParentIfPossible if the current active camera is a rig camera, should its parent camera be returned
+     * @returns the camera that is used when rendering the utility layer
+     */
+    getRenderCamera(getRigParentIfPossible: any): any;
+    /**
+     * Sets the camera that should be used when rendering the utility layer (If set to null the last active camera will be used)
+     * @param cam the camera that should be used when rendering the utility layer
+     */
+    setRenderCamera(cam: any): void;
+    /**
+     * @internal
+     * Light which used by gizmos to get light shading
+     */
+    _getSharedGizmoLight(): HemisphericLight;
+    _notifyObservers(prePointerInfo: any, pickInfo: any, pointerEvent: any): void;
+    /**
+     * Renders the utility layers scene on top of the original scene
+     */
+    render(): void;
+    /**
+     * Disposes of the renderer
+     */
+    dispose(): void;
+    _updateCamera(): void;
+}
+export namespace UtilityLayerRenderer {
+    const _DefaultUtilityLayer: any;
+    const _DefaultKeepDepthUtilityLayer: any;
+}
+import { HemisphericLight } from "../Lights/hemisphericLight.js";
+import { Observable } from "../Misc/observable.js";
+import { Scene } from "../scene.js";

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/backgroundFragmentDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace backgroundFragmentDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "backgroundFragmentDeclaration";
+declare const shader: "uniform vec4 vEyePosition;\nuniform vec4 vPrimaryColor;\n#ifdef USEHIGHLIGHTANDSHADOWCOLORS\nuniform vec4 vPrimaryColorShadow;\n#endif\nuniform float shadowLevel;\nuniform float alpha;\n#ifdef DIFFUSE\nuniform vec2 vDiffuseInfos;\n#endif\n#ifdef REFLECTION\nuniform vec2 vReflectionInfos;\nuniform mat4 reflectionMatrix;\nuniform vec3 vReflectionMicrosurfaceInfos;\n#endif\n#if defined(REFLECTIONFRESNEL) || defined(OPACITYFRESNEL)\nuniform vec3 vBackgroundCenter;\n#endif\n#ifdef REFLECTIONFRESNEL\nuniform vec4 vReflectionControl;\n#endif\n#if defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_PROJECTION) || defined(REFRACTION)\nuniform mat4 view;\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/backgroundUboDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace backgroundUboDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "backgroundUboDeclaration";
+declare const shader: "layout(std140,column_major) uniform;\nuniform Material\n{\nuniform vec4 vPrimaryColor;\nuniform vec4 vPrimaryColorShadow;\nuniform vec2 vDiffuseInfos;\nuniform vec2 vReflectionInfos;\nuniform mat4 diffuseMatrix;\nuniform mat4 reflectionMatrix;\nuniform vec3 vReflectionMicrosurfaceInfos;\nuniform float fFovMultiplier;\nuniform float pointSize;\nuniform float shadowLevel;\nuniform float alpha;\n#if defined(REFLECTIONFRESNEL) || defined(OPACITYFRESNEL)\nuniform vec3 vBackgroundCenter;\n#endif\n#ifdef REFLECTIONFRESNEL\nuniform vec4 vReflectionControl;\n#endif\n};\n#include<sceneUboDeclaration>\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/backgroundVertexDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace backgroundVertexDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "backgroundVertexDeclaration";
+declare const shader: "uniform mat4 view;\nuniform mat4 viewProjection;\nuniform float shadowLevel;\n#ifdef DIFFUSE\nuniform mat4 diffuseMatrix;\nuniform vec2 vDiffuseInfos;\n#endif\n#ifdef REFLECTION\nuniform vec2 vReflectionInfos;\nuniform mat4 reflectionMatrix;\nuniform vec3 vReflectionMicrosurfaceInfos;\nuniform float fFovMultiplier;\n#endif\n#ifdef POINTSIZE\nuniform float pointSize;\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bakedVertexAnimation.d.ts

@@ -0,0 +1,7 @@
+export namespace bakedVertexAnimation {
+    export { name };
+    export { shader };
+}
+declare const name: "bakedVertexAnimation";
+declare const shader: "#ifdef BAKED_VERTEX_ANIMATION_TEXTURE\n{\n#ifdef INSTANCES\n#define BVASNAME bakedVertexAnimationSettingsInstanced\n#else\n#define BVASNAME bakedVertexAnimationSettings\n#endif\nfloat VATStartFrame=BVASNAME.x;\nfloat VATEndFrame=BVASNAME.y;\nfloat VATOffsetFrame=BVASNAME.z;\nfloat VATSpeed=BVASNAME.w;\nfloat totalFrames=VATEndFrame-VATStartFrame+1.0;\nfloat time=bakedVertexAnimationTime*VATSpeed/totalFrames;\nfloat frameCorrection=time<1.0 ? 0.0 : 1.0;\nfloat numOfFrames=totalFrames-frameCorrection;\nfloat VATFrameNum=fract(time)*numOfFrames;\nVATFrameNum=mod(VATFrameNum+VATOffsetFrame,numOfFrames);\nVATFrameNum=floor(VATFrameNum);\nVATFrameNum+=VATStartFrame+frameCorrection;\nmat4 VATInfluence;\nVATInfluence=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[0],VATFrameNum)*matricesWeights[0];\n#if NUM_BONE_INFLUENCERS>1\nVATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[1],VATFrameNum)*matricesWeights[1];\n#endif\n#if NUM_BONE_INFLUENCERS>2\nVATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[2],VATFrameNum)*matricesWeights[2];\n#endif\n#if NUM_BONE_INFLUENCERS>3\nVATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndices[3],VATFrameNum)*matricesWeights[3];\n#endif\n#if NUM_BONE_INFLUENCERS>4\nVATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[0],VATFrameNum)*matricesWeightsExtra[0];\n#endif\n#if NUM_BONE_INFLUENCERS>5\nVATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[1],VATFrameNum)*matricesWeightsExtra[1];\n#endif\n#if NUM_BONE_INFLUENCERS>6\nVATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[2],VATFrameNum)*matricesWeightsExtra[2];\n#endif\n#if NUM_BONE_INFLUENCERS>7\nVATInfluence+=readMatrixFromRawSamplerVAT(bakedVertexAnimationTexture,matricesIndicesExtra[3],VATFrameNum)*matricesWeightsExtra[3];\n#endif\nfinalWorld=finalWorld*VATInfluence;\n}\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bakedVertexAnimationDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace bakedVertexAnimationDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "bakedVertexAnimationDeclaration";
+declare const shader: "#ifdef BAKED_VERTEX_ANIMATION_TEXTURE\nuniform float bakedVertexAnimationTime;\nuniform vec2 bakedVertexAnimationTextureSizeInverted;\nuniform vec4 bakedVertexAnimationSettings;\nuniform sampler2D bakedVertexAnimationTexture;\n#ifdef INSTANCES\nattribute vec4 bakedVertexAnimationSettingsInstanced;\n#endif\n#define inline\nmat4 readMatrixFromRawSamplerVAT(sampler2D smp,float index,float frame)\n{\nfloat offset=index*4.0;\nfloat frameUV=(frame+0.5)*bakedVertexAnimationTextureSizeInverted.y;\nfloat dx=bakedVertexAnimationTextureSizeInverted.x;\nvec4 m0=texture2D(smp,vec2(dx*(offset+0.5),frameUV));\nvec4 m1=texture2D(smp,vec2(dx*(offset+1.5),frameUV));\nvec4 m2=texture2D(smp,vec2(dx*(offset+2.5),frameUV));\nvec4 m3=texture2D(smp,vec2(dx*(offset+3.5),frameUV));\nreturn mat4(m0,m1,m2,m3);\n}\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bayerDitherFunctions.d.ts

@@ -0,0 +1,7 @@
+export namespace bayerDitherFunctions {
+    export { name };
+    export { shader };
+}
+declare const name: "bayerDitherFunctions";
+declare const shader: "float bayerDither2(vec2 _P) {\nreturn mod(2.0*_P.y+_P.x+1.0,4.0);\n}\nfloat bayerDither4(vec2 _P) {\nvec2 P1=mod(_P,2.0); \nvec2 P2=floor(0.5*mod(_P,4.0)); \nreturn 4.0*bayerDither2(P1)+bayerDither2(P2);\n}\nfloat bayerDither8(vec2 _P) {\nvec2 P1=mod(_P,2.0); \nvec2 P2=floor(0.5 *mod(_P,4.0)); \nvec2 P4=floor(0.25*mod(_P,8.0)); \nreturn 4.0*(4.0*bayerDither2(P1)+bayerDither2(P2))+bayerDither2(P4);\n}\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bonesDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace bonesDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "bonesDeclaration";
+declare const shader: "#if NUM_BONE_INFLUENCERS>0\nattribute vec4 matricesIndices;\nattribute vec4 matricesWeights;\n#if NUM_BONE_INFLUENCERS>4\nattribute vec4 matricesIndicesExtra;\nattribute vec4 matricesWeightsExtra;\n#endif\n#ifndef BAKED_VERTEX_ANIMATION_TEXTURE\n#ifdef BONETEXTURE\nuniform sampler2D boneSampler;\nuniform float boneTextureWidth;\n#else\nuniform mat4 mBones[BonesPerMesh];\n#ifdef BONES_VELOCITY_ENABLED\nuniform mat4 mPreviousBones[BonesPerMesh];\n#endif\n#endif\n#ifdef BONETEXTURE\n#define inline\nmat4 readMatrixFromRawSampler(sampler2D smp,float index)\n{\nfloat offset=index *4.0;\nfloat dx=1.0/boneTextureWidth;\nvec4 m0=texture2D(smp,vec2(dx*(offset+0.5),0.));\nvec4 m1=texture2D(smp,vec2(dx*(offset+1.5),0.));\nvec4 m2=texture2D(smp,vec2(dx*(offset+2.5),0.));\nvec4 m3=texture2D(smp,vec2(dx*(offset+3.5),0.));\nreturn mat4(m0,m1,m2,m3);\n}\n#endif\n#endif\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bonesVertex.d.ts

@@ -0,0 +1,7 @@
+export namespace bonesVertex {
+    export { name };
+    export { shader };
+}
+declare const name: "bonesVertex";
+declare const shader: "#ifndef BAKED_VERTEX_ANIMATION_TEXTURE\n#if NUM_BONE_INFLUENCERS>0\nmat4 influence;\n#ifdef BONETEXTURE\ninfluence=readMatrixFromRawSampler(boneSampler,matricesIndices[0])*matricesWeights[0];\n#if NUM_BONE_INFLUENCERS>1\ninfluence+=readMatrixFromRawSampler(boneSampler,matricesIndices[1])*matricesWeights[1];\n#endif\n#if NUM_BONE_INFLUENCERS>2\ninfluence+=readMatrixFromRawSampler(boneSampler,matricesIndices[2])*matricesWeights[2];\n#endif\n#if NUM_BONE_INFLUENCERS>3\ninfluence+=readMatrixFromRawSampler(boneSampler,matricesIndices[3])*matricesWeights[3];\n#endif\n#if NUM_BONE_INFLUENCERS>4\ninfluence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[0])*matricesWeightsExtra[0];\n#endif\n#if NUM_BONE_INFLUENCERS>5\ninfluence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[1])*matricesWeightsExtra[1];\n#endif\n#if NUM_BONE_INFLUENCERS>6\ninfluence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[2])*matricesWeightsExtra[2];\n#endif\n#if NUM_BONE_INFLUENCERS>7\ninfluence+=readMatrixFromRawSampler(boneSampler,matricesIndicesExtra[3])*matricesWeightsExtra[3];\n#endif\n#else\ninfluence=mBones[int(matricesIndices[0])]*matricesWeights[0];\n#if NUM_BONE_INFLUENCERS>1\ninfluence+=mBones[int(matricesIndices[1])]*matricesWeights[1];\n#endif\n#if NUM_BONE_INFLUENCERS>2\ninfluence+=mBones[int(matricesIndices[2])]*matricesWeights[2];\n#endif\n#if NUM_BONE_INFLUENCERS>3\ninfluence+=mBones[int(matricesIndices[3])]*matricesWeights[3];\n#endif\n#if NUM_BONE_INFLUENCERS>4\ninfluence+=mBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];\n#endif\n#if NUM_BONE_INFLUENCERS>5\ninfluence+=mBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];\n#endif\n#if NUM_BONE_INFLUENCERS>6\ninfluence+=mBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];\n#endif\n#if NUM_BONE_INFLUENCERS>7\ninfluence+=mBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];\n#endif\n#endif\nfinalWorld=finalWorld*influence;\n#endif\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/boundingBoxRendererFragmentDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace boundingBoxRendererFragmentDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "boundingBoxRendererFragmentDeclaration";
+declare const shader: "uniform vec4 color;\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/boundingBoxRendererUboDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace boundingBoxRendererUboDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "boundingBoxRendererUboDeclaration";
+declare const shader: "#ifdef WEBGL2\nuniform vec4 color;\nuniform mat4 world;\nuniform mat4 viewProjection;\n#ifdef MULTIVIEW\nuniform mat4 viewProjectionR;\n#endif\n#else\nlayout(std140,column_major) uniform;\nuniform BoundingBoxRenderer {\nvec4 color;\nmat4 world;\nmat4 viewProjection;\nmat4 viewProjectionR;\n};\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/boundingBoxRendererVertexDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace boundingBoxRendererVertexDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "boundingBoxRendererVertexDeclaration";
+declare const shader: "uniform mat4 world;\nuniform mat4 viewProjection;\n#ifdef MULTIVIEW\nuniform mat4 viewProjectionR;\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bumpFragment.d.ts

@@ -0,0 +1,7 @@
+export namespace bumpFragment {
+    export { name };
+    export { shader };
+}
+declare const name: "bumpFragment";
+declare const shader: "vec2 uvOffset=vec2(0.0,0.0);\n#if defined(BUMP) || defined(PARALLAX) || defined(DETAIL)\n#ifdef NORMALXYSCALE\nfloat normalScale=1.0;\n#elif defined(BUMP)\nfloat normalScale=vBumpInfos.y;\n#else\nfloat normalScale=1.0;\n#endif\n#if defined(TANGENT) && defined(NORMAL)\nmat3 TBN=vTBN;\n#elif defined(BUMP)\nvec2 TBNUV=gl_FrontFacing ? vBumpUV : -vBumpUV;\nmat3 TBN=cotangent_frame(normalW*normalScale,vPositionW,TBNUV,vTangentSpaceParams);\n#else\nvec2 TBNUV=gl_FrontFacing ? vDetailUV : -vDetailUV;\nmat3 TBN=cotangent_frame(normalW*normalScale,vPositionW,TBNUV,vec2(1.,1.));\n#endif\n#elif defined(ANISOTROPIC)\n#if defined(TANGENT) && defined(NORMAL)\nmat3 TBN=vTBN;\n#else\nvec2 TBNUV=gl_FrontFacing ? vMainUV1 : -vMainUV1;\nmat3 TBN=cotangent_frame(normalW,vPositionW,TBNUV,vec2(1.,1.));\n#endif\n#endif\n#ifdef PARALLAX\nmat3 invTBN=transposeMat3(TBN);\n#ifdef PARALLAXOCCLUSION\nuvOffset=parallaxOcclusion(invTBN*-viewDirectionW,invTBN*normalW,vBumpUV,vBumpInfos.z);\n#else\nuvOffset=parallaxOffset(invTBN*viewDirectionW,vBumpInfos.z);\n#endif\n#endif\n#ifdef DETAIL\nvec4 detailColor=texture2D(detailSampler,vDetailUV+uvOffset);\nvec2 detailNormalRG=detailColor.wy*2.0-1.0;\nfloat detailNormalB=sqrt(1.-saturate(dot(detailNormalRG,detailNormalRG)));\nvec3 detailNormal=vec3(detailNormalRG,detailNormalB);\n#endif\n#ifdef BUMP\n#ifdef OBJECTSPACE_NORMALMAP\nnormalW=normalize(texture2D(bumpSampler,vBumpUV).xyz *2.0-1.0);\nnormalW=normalize(mat3(normalMatrix)*normalW);\n#elif !defined(DETAIL)\nnormalW=perturbNormal(TBN,texture2D(bumpSampler,vBumpUV+uvOffset).xyz,vBumpInfos.y);\n#else\nvec3 bumpNormal=texture2D(bumpSampler,vBumpUV+uvOffset).xyz*2.0-1.0;\n#if DETAIL_NORMALBLENDMETHOD==0 \ndetailNormal.xy*=vDetailInfos.z;\nvec3 blendedNormal=normalize(vec3(bumpNormal.xy+detailNormal.xy,bumpNormal.z*detailNormal.z));\n#elif DETAIL_NORMALBLENDMETHOD==1 \ndetailNormal.xy*=vDetailInfos.z;\nbumpNormal+=vec3(0.0,0.0,1.0);\ndetailNormal*=vec3(-1.0,-1.0,1.0);\nvec3 blendedNormal=bumpNormal*dot(bumpNormal,detailNormal)/bumpNormal.z-detailNormal;\n#endif\nnormalW=perturbNormalBase(TBN,blendedNormal,vBumpInfos.y);\n#endif\n#elif defined(DETAIL)\ndetailNormal.xy*=vDetailInfos.z;\nnormalW=perturbNormalBase(TBN,detailNormal,vDetailInfos.z);\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bumpFragmentFunctions.d.ts

@@ -0,0 +1,7 @@
+export namespace bumpFragmentFunctions {
+    export { name };
+    export { shader };
+}
+declare const name: "bumpFragmentFunctions";
+declare const shader: "#if defined(BUMP)\n#include<samplerFragmentDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_SAMPLERNAME_,bump)\n#endif\n#if defined(DETAIL)\n#include<samplerFragmentDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_SAMPLERNAME_,detail)\n#endif\n#if defined(BUMP) && defined(PARALLAX)\nconst float minSamples=4.;\nconst float maxSamples=15.;\nconst int iMaxSamples=15;\nvec2 parallaxOcclusion(vec3 vViewDirCoT,vec3 vNormalCoT,vec2 texCoord,float parallaxScale) {\nfloat parallaxLimit=length(vViewDirCoT.xy)/vViewDirCoT.z;\nparallaxLimit*=parallaxScale;\nvec2 vOffsetDir=normalize(vViewDirCoT.xy);\nvec2 vMaxOffset=vOffsetDir*parallaxLimit;\nfloat numSamples=maxSamples+(dot(vViewDirCoT,vNormalCoT)*(minSamples-maxSamples));\nfloat stepSize=1.0/numSamples;\nfloat currRayHeight=1.0;\nvec2 vCurrOffset=vec2(0,0);\nvec2 vLastOffset=vec2(0,0);\nfloat lastSampledHeight=1.0;\nfloat currSampledHeight=1.0;\nfor (int i=0; i<iMaxSamples; i++)\n{\ncurrSampledHeight=texture2D(bumpSampler,texCoord+vCurrOffset).w;\nif (currSampledHeight>currRayHeight)\n{\nfloat delta1=currSampledHeight-currRayHeight;\nfloat delta2=(currRayHeight+stepSize)-lastSampledHeight;\nfloat ratio=delta1/(delta1+delta2);\nvCurrOffset=(ratio)* vLastOffset+(1.0-ratio)*vCurrOffset;\nbreak;\n}\nelse\n{\ncurrRayHeight-=stepSize;\nvLastOffset=vCurrOffset;\nvCurrOffset+=stepSize*vMaxOffset;\nlastSampledHeight=currSampledHeight;\n}\n}\nreturn vCurrOffset;\n}\nvec2 parallaxOffset(vec3 viewDir,float heightScale)\n{\nfloat height=texture2D(bumpSampler,vBumpUV).w;\nvec2 texCoordOffset=heightScale*viewDir.xy*height;\nreturn -texCoordOffset;\n}\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bumpFragmentMainFunctions.d.ts

@@ -0,0 +1,7 @@
+export namespace bumpFragmentMainFunctions {
+    export { name };
+    export { shader };
+}
+declare const name: "bumpFragmentMainFunctions";
+declare const shader: "#if defined(BUMP) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(DETAIL)\n#if defined(TANGENT) && defined(NORMAL) \nvarying mat3 vTBN;\n#endif\n#ifdef OBJECTSPACE_NORMALMAP\nuniform mat4 normalMatrix;\n#endif\nvec3 perturbNormalBase(mat3 cotangentFrame,vec3 normal,float scale)\n{\n#ifdef NORMALXYSCALE\nnormal=normalize(normal*vec3(scale,scale,1.0));\n#endif\nreturn normalize(cotangentFrame*normal);\n}\nvec3 perturbNormal(mat3 cotangentFrame,vec3 textureSample,float scale)\n{\nreturn perturbNormalBase(cotangentFrame,textureSample*2.0-1.0,scale);\n}\nmat3 cotangent_frame(vec3 normal,vec3 p,vec2 uv,vec2 tangentSpaceParams)\n{\nvec3 dp1=dFdx(p);\nvec3 dp2=dFdy(p);\nvec2 duv1=dFdx(uv);\nvec2 duv2=dFdy(uv);\nvec3 dp2perp=cross(dp2,normal);\nvec3 dp1perp=cross(normal,dp1);\nvec3 tangent=dp2perp*duv1.x+dp1perp*duv2.x;\nvec3 bitangent=dp2perp*duv1.y+dp1perp*duv2.y;\ntangent*=tangentSpaceParams.x;\nbitangent*=tangentSpaceParams.y;\nfloat invmax=inversesqrt(max(dot(tangent,tangent),dot(bitangent,bitangent)));\nreturn mat3(tangent*invmax,bitangent*invmax,normal);\n}\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bumpVertex.d.ts

@@ -0,0 +1,7 @@
+export namespace bumpVertex {
+    export { name };
+    export { shader };
+}
+declare const name: "bumpVertex";
+declare const shader: "#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)\n#if defined(TANGENT) && defined(NORMAL)\nvec3 tbnNormal=normalize(normalUpdated);\nvec3 tbnTangent=normalize(tangentUpdated.xyz);\nvec3 tbnBitangent=cross(tbnNormal,tbnTangent)*tangentUpdated.w;\nvTBN=mat3(finalWorld)*mat3(tbnTangent,tbnBitangent,tbnNormal);\n#endif\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/bumpVertexDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace bumpVertexDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "bumpVertexDeclaration";
+declare const shader: "#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)\n#if defined(TANGENT) && defined(NORMAL) \nvarying mat3 vTBN;\n#endif\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/clipPlaneFragment.d.ts

@@ -0,0 +1,7 @@
+export namespace clipPlaneFragment {
+    export { name };
+    export { shader };
+}
+declare const name: "clipPlaneFragment";
+declare const shader: "#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)\nif (false) {}\n#endif\n#ifdef CLIPPLANE\nelse if (fClipDistance>0.0)\n{\ndiscard;\n}\n#endif\n#ifdef CLIPPLANE2\nelse if (fClipDistance2>0.0)\n{\ndiscard;\n}\n#endif\n#ifdef CLIPPLANE3\nelse if (fClipDistance3>0.0)\n{\ndiscard;\n}\n#endif\n#ifdef CLIPPLANE4\nelse if (fClipDistance4>0.0)\n{\ndiscard;\n}\n#endif\n#ifdef CLIPPLANE5\nelse if (fClipDistance5>0.0)\n{\ndiscard;\n}\n#endif\n#ifdef CLIPPLANE6\nelse if (fClipDistance6>0.0)\n{\ndiscard;\n}\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/clipPlaneFragmentDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace clipPlaneFragmentDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "clipPlaneFragmentDeclaration";
+declare const shader: "#ifdef CLIPPLANE\nvarying float fClipDistance;\n#endif\n#ifdef CLIPPLANE2\nvarying float fClipDistance2;\n#endif\n#ifdef CLIPPLANE3\nvarying float fClipDistance3;\n#endif\n#ifdef CLIPPLANE4\nvarying float fClipDistance4;\n#endif\n#ifdef CLIPPLANE5\nvarying float fClipDistance5;\n#endif\n#ifdef CLIPPLANE6\nvarying float fClipDistance6;\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/clipPlaneFragmentDeclaration2.d.ts

@@ -0,0 +1,7 @@
+export namespace clipPlaneFragmentDeclaration2 {
+    export { name };
+    export { shader };
+}
+declare const name: "clipPlaneFragmentDeclaration2";
+declare const shader: "#ifdef CLIPPLANE\nin float fClipDistance;\n#endif\n#ifdef CLIPPLANE2\nin float fClipDistance2;\n#endif\n#ifdef CLIPPLANE3\nin float fClipDistance3;\n#endif\n#ifdef CLIPPLANE4\nin float fClipDistance4;\n#endif\n#ifdef CLIPPLANE5\nin float fClipDistance5;\n#endif\n#ifdef CLIPPLANE6\nin float fClipDistance6;\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/clipPlaneVertex.d.ts

@@ -0,0 +1,7 @@
+export namespace clipPlaneVertex {
+    export { name };
+    export { shader };
+}
+declare const name: "clipPlaneVertex";
+declare const shader: "#ifdef CLIPPLANE\nfClipDistance=dot(worldPos,vClipPlane);\n#endif\n#ifdef CLIPPLANE2\nfClipDistance2=dot(worldPos,vClipPlane2);\n#endif\n#ifdef CLIPPLANE3\nfClipDistance3=dot(worldPos,vClipPlane3);\n#endif\n#ifdef CLIPPLANE4\nfClipDistance4=dot(worldPos,vClipPlane4);\n#endif\n#ifdef CLIPPLANE5\nfClipDistance5=dot(worldPos,vClipPlane5);\n#endif\n#ifdef CLIPPLANE6\nfClipDistance6=dot(worldPos,vClipPlane6);\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/clipPlaneVertexDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace clipPlaneVertexDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "clipPlaneVertexDeclaration";
+declare const shader: "#ifdef CLIPPLANE\nuniform vec4 vClipPlane;\nvarying float fClipDistance;\n#endif\n#ifdef CLIPPLANE2\nuniform vec4 vClipPlane2;\nvarying float fClipDistance2;\n#endif\n#ifdef CLIPPLANE3\nuniform vec4 vClipPlane3;\nvarying float fClipDistance3;\n#endif\n#ifdef CLIPPLANE4\nuniform vec4 vClipPlane4;\nvarying float fClipDistance4;\n#endif\n#ifdef CLIPPLANE5\nuniform vec4 vClipPlane5;\nvarying float fClipDistance5;\n#endif\n#ifdef CLIPPLANE6\nuniform vec4 vClipPlane6;\nvarying float fClipDistance6;\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/clipPlaneVertexDeclaration2.d.ts

@@ -0,0 +1,7 @@
+export namespace clipPlaneVertexDeclaration2 {
+    export { name };
+    export { shader };
+}
+declare const name: "clipPlaneVertexDeclaration2";
+declare const shader: "#ifdef CLIPPLANE\nuniform vec4 vClipPlane;\nout float fClipDistance;\n#endif\n#ifdef CLIPPLANE2\nuniform vec4 vClipPlane2;\nout float fClipDistance2;\n#endif\n#ifdef CLIPPLANE3\nuniform vec4 vClipPlane3;\nout float fClipDistance3;\n#endif\n#ifdef CLIPPLANE4\nuniform vec4 vClipPlane4;\nout float fClipDistance4;\n#endif\n#ifdef CLIPPLANE5\nuniform vec4 vClipPlane5;\nout float fClipDistance5;\n#endif\n#ifdef CLIPPLANE6\nuniform vec4 vClipPlane6;\nout float fClipDistance6;\n#endif\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/defaultFragmentDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace defaultFragmentDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "defaultFragmentDeclaration";
+declare const shader: "uniform vec4 vEyePosition;\nuniform vec4 vDiffuseColor;\n#ifdef SPECULARTERM\nuniform vec4 vSpecularColor;\n#endif\nuniform vec3 vEmissiveColor;\nuniform vec3 vAmbientColor;\nuniform float visibility;\n#ifdef DIFFUSE\nuniform vec2 vDiffuseInfos;\n#endif\n#ifdef AMBIENT\nuniform vec2 vAmbientInfos;\n#endif\n#ifdef OPACITY \nuniform vec2 vOpacityInfos;\n#endif\n#ifdef EMISSIVE\nuniform vec2 vEmissiveInfos;\n#endif\n#ifdef LIGHTMAP\nuniform vec2 vLightmapInfos;\n#endif\n#ifdef BUMP\nuniform vec3 vBumpInfos;\nuniform vec2 vTangentSpaceParams;\n#endif\n#ifdef ALPHATEST\nuniform float alphaCutOff;\n#endif\n#if defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_PROJECTION) || defined(REFRACTION) || defined(PREPASS)\nuniform mat4 view;\n#endif\n#ifdef REFRACTION\nuniform vec4 vRefractionInfos;\n#ifndef REFRACTIONMAP_3D\nuniform mat4 refractionMatrix;\n#endif\n#ifdef REFRACTIONFRESNEL\nuniform vec4 refractionLeftColor;\nuniform vec4 refractionRightColor;\n#endif\n#if defined(USE_LOCAL_REFRACTIONMAP_CUBIC) && defined(REFRACTIONMAP_3D)\nuniform vec3 vRefractionPosition;\nuniform vec3 vRefractionSize; \n#endif\n#endif\n#if defined(SPECULAR) && defined(SPECULARTERM)\nuniform vec2 vSpecularInfos;\n#endif\n#ifdef DIFFUSEFRESNEL\nuniform vec4 diffuseLeftColor;\nuniform vec4 diffuseRightColor;\n#endif\n#ifdef OPACITYFRESNEL\nuniform vec4 opacityParts;\n#endif\n#ifdef EMISSIVEFRESNEL\nuniform vec4 emissiveLeftColor;\nuniform vec4 emissiveRightColor;\n#endif\n#ifdef REFLECTION\nuniform vec2 vReflectionInfos;\n#if defined(REFLECTIONMAP_PLANAR) || defined(REFLECTIONMAP_CUBIC) || defined(REFLECTIONMAP_PROJECTION) || defined(REFLECTIONMAP_EQUIRECTANGULAR) || defined(REFLECTIONMAP_SPHERICAL) || defined(REFLECTIONMAP_SKYBOX)\nuniform mat4 reflectionMatrix;\n#endif\n#ifndef REFLECTIONMAP_SKYBOX\n#if defined(USE_LOCAL_REFLECTIONMAP_CUBIC) && defined(REFLECTIONMAP_CUBIC)\nuniform vec3 vReflectionPosition;\nuniform vec3 vReflectionSize; \n#endif\n#endif\n#ifdef REFLECTIONFRESNEL\nuniform vec4 reflectionLeftColor;\nuniform vec4 reflectionRightColor;\n#endif\n#endif\n#ifdef DETAIL\nuniform vec4 vDetailInfos;\n#endif\n#define ADDITIONAL_FRAGMENT_DECLARATION\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/defaultUboDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace defaultUboDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "defaultUboDeclaration";
+declare const shader: "layout(std140,column_major) uniform;\nuniform Material\n{\nvec4 diffuseLeftColor;\nvec4 diffuseRightColor;\nvec4 opacityParts;\nvec4 reflectionLeftColor;\nvec4 reflectionRightColor;\nvec4 refractionLeftColor;\nvec4 refractionRightColor;\nvec4 emissiveLeftColor;\nvec4 emissiveRightColor;\nvec2 vDiffuseInfos;\nvec2 vAmbientInfos;\nvec2 vOpacityInfos;\nvec2 vReflectionInfos;\nvec3 vReflectionPosition;\nvec3 vReflectionSize;\nvec2 vEmissiveInfos;\nvec2 vLightmapInfos;\nvec2 vSpecularInfos;\nvec3 vBumpInfos;\nmat4 diffuseMatrix;\nmat4 ambientMatrix;\nmat4 opacityMatrix;\nmat4 reflectionMatrix;\nmat4 emissiveMatrix;\nmat4 lightmapMatrix;\nmat4 specularMatrix;\nmat4 bumpMatrix;\nvec2 vTangentSpaceParams;\nfloat pointSize;\nfloat alphaCutOff;\nmat4 refractionMatrix;\nvec4 vRefractionInfos;\nvec3 vRefractionPosition;\nvec3 vRefractionSize;\nvec4 vSpecularColor;\nvec3 vEmissiveColor;\nvec4 vDiffuseColor;\nvec3 vAmbientColor;\n#define ADDITIONAL_UBO_DECLARATION\n};\n#include<sceneUboDeclaration>\n#include<meshUboDeclaration>\n";
+export {};

package/dist/types/node_modules/@babylonjs/core/Shaders/ShadersInclude/defaultVertexDeclaration.d.ts

@@ -0,0 +1,7 @@
+export namespace defaultVertexDeclaration {
+    export { name };
+    export { shader };
+}
+declare const name: "defaultVertexDeclaration";
+declare const shader: "uniform mat4 viewProjection;\nuniform mat4 view;\n#ifdef DIFFUSE\nuniform mat4 diffuseMatrix;\nuniform vec2 vDiffuseInfos;\n#endif\n#ifdef AMBIENT\nuniform mat4 ambientMatrix;\nuniform vec2 vAmbientInfos;\n#endif\n#ifdef OPACITY\nuniform mat4 opacityMatrix;\nuniform vec2 vOpacityInfos;\n#endif\n#ifdef EMISSIVE\nuniform vec2 vEmissiveInfos;\nuniform mat4 emissiveMatrix;\n#endif\n#ifdef LIGHTMAP\nuniform vec2 vLightmapInfos;\nuniform mat4 lightmapMatrix;\n#endif\n#if defined(SPECULAR) && defined(SPECULARTERM)\nuniform vec2 vSpecularInfos;\nuniform mat4 specularMatrix;\n#endif\n#ifdef BUMP\nuniform vec3 vBumpInfos;\nuniform mat4 bumpMatrix;\n#endif\n#ifdef REFLECTION\nuniform mat4 reflectionMatrix;\n#endif\n#ifdef POINTSIZE\nuniform float pointSize;\n#endif\n#ifdef DETAIL\nuniform vec4 vDetailInfos;\nuniform mat4 detailMatrix;\n#endif\n#define ADDITIONAL_VERTEX_DECLARATION\n";
+export {};