@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/core/Particles/baseParticleSystem.d.ts

@@ -0,0 +1,469 @@
+/**
+ * This represents the base class for particle system in Babylon.
+ * Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
+ * Particles can take different shapes while emitted like box, sphere, cone or you can write your custom function.
+ * @example https://doc.babylonjs.com/babylon101/particles
+ */
+export class BaseParticleSystem {
+    /**
+     * Instantiates a particle system.
+     * Particles are often small sprites used to simulate hard-to-reproduce phenomena like fire, smoke, water, or abstract visual effects like magic glitter and faery dust.
+     * @param name The name of the particle system
+     */
+    constructor(name: any);
+    /**
+     * List of animations used by the particle system.
+     */
+    animations: any[];
+    /**
+     * The rendering group used by the Particle system to chose when to render.
+     */
+    renderingGroupId: number;
+    /**
+     * The emitter represents the Mesh or position we are attaching the particle system to.
+     */
+    emitter: Vector3;
+    /**
+     * The maximum number of particles to emit per frame
+     */
+    emitRate: number;
+    /**
+     * If you want to launch only a few particles at once, that can be done, as well.
+     */
+    manualEmitCount: number;
+    /**
+     * The overall motion speed (0.01 is default update speed, faster updates = faster animation)
+     */
+    updateSpeed: number;
+    /**
+     * The amount of time the particle system is running (depends of the overall update speed).
+     */
+    targetStopDuration: number;
+    /**
+     * Specifies whether the particle system will be disposed once it reaches the end of the animation.
+     */
+    disposeOnStop: boolean;
+    /**
+     * Minimum power of emitting particles.
+     */
+    minEmitPower: number;
+    /**
+     * Maximum power of emitting particles.
+     */
+    maxEmitPower: number;
+    /**
+     * Minimum life time of emitting particles.
+     */
+    minLifeTime: number;
+    /**
+     * Maximum life time of emitting particles.
+     */
+    maxLifeTime: number;
+    /**
+     * Minimum Size of emitting particles.
+     */
+    minSize: number;
+    /**
+     * Maximum Size of emitting particles.
+     */
+    maxSize: number;
+    /**
+     * Minimum scale of emitting particles on X axis.
+     */
+    minScaleX: number;
+    /**
+     * Maximum scale of emitting particles on X axis.
+     */
+    maxScaleX: number;
+    /**
+     * Minimum scale of emitting particles on Y axis.
+     */
+    minScaleY: number;
+    /**
+     * Maximum scale of emitting particles on Y axis.
+     */
+    maxScaleY: number;
+    /**
+     * Gets or sets the minimal initial rotation in radians.
+     */
+    minInitialRotation: number;
+    /**
+     * Gets or sets the maximal initial rotation in radians.
+     */
+    maxInitialRotation: number;
+    /**
+     * Minimum angular speed of emitting particles (Z-axis rotation for each particle).
+     */
+    minAngularSpeed: number;
+    /**
+     * Maximum angular speed of emitting particles (Z-axis rotation for each particle).
+     */
+    maxAngularSpeed: number;
+    /**
+     * The layer mask we are rendering the particles through.
+     */
+    layerMask: number;
+    /**
+     * This can help using your own shader to render the particle system.
+     * The according effect will be created
+     */
+    customShader: any;
+    /**
+     * By default particle system starts as soon as they are created. This prevents the
+     * automatic start to happen and let you decide when to start emitting particles.
+     */
+    preventAutoStart: boolean;
+    /** @internal */
+    _wasDispatched: boolean;
+    _rootUrl: string;
+    /** Gets or sets the strength to apply to the noise value (default is (10, 10, 10)) */
+    noiseStrength: Vector3;
+    /**
+     * Callback triggered when the particle animation is ending.
+     */
+    onAnimationEnd: any;
+    /**
+     * Blend mode use to render the particle, it can be either ParticleSystem.BLENDMODE_ONEONE or ParticleSystem.BLENDMODE_STANDARD.
+     */
+    blendMode: number;
+    /**
+     * Forces the particle to write their depth information to the depth buffer. This can help preventing other draw calls
+     * to override the particles.
+     */
+    forceDepthWrite: boolean;
+    /** Gets or sets a value indicating how many cycles (or frames) must be executed before first rendering (this value has to be set before starting the system). Default is 0 */
+    preWarmCycles: number;
+    /** Gets or sets a value indicating the time step multiplier to use in pre-warm mode (default is 1) */
+    preWarmStepOffset: number;
+    /**
+     * If using a spritesheet (isAnimationSheetEnabled) defines the speed of the sprite loop (default is 1 meaning the animation will play once during the entire particle lifetime)
+     */
+    spriteCellChangeSpeed: number;
+    /**
+     * If using a spritesheet (isAnimationSheetEnabled) defines the first sprite cell to display
+     */
+    startSpriteCellID: number;
+    /**
+     * If using a spritesheet (isAnimationSheetEnabled) defines the last sprite cell to display
+     */
+    endSpriteCellID: number;
+    /**
+     * If using a spritesheet (isAnimationSheetEnabled), defines the sprite cell width to use
+     */
+    spriteCellWidth: number;
+    /**
+     * If using a spritesheet (isAnimationSheetEnabled), defines the sprite cell height to use
+     */
+    spriteCellHeight: number;
+    /**
+     * If using a spritesheet (isAnimationSheetEnabled), defines wether the sprite animation is looping
+     */
+    spriteCellLoop: boolean;
+    /**
+     * This allows the system to random pick the start cell ID between startSpriteCellID and endSpriteCellID
+     */
+    spriteRandomStartCell: boolean;
+    /** Gets or sets a Vector2 used to move the pivot (by default (0,0)) */
+    translationPivot: Vector2;
+    /**
+     * Gets or sets a boolean indicating that hosted animations (in the system.animations array) must be started when system.start() is called
+     */
+    beginAnimationOnStart: boolean;
+    /**
+     * Gets or sets the frame to start the animation from when beginAnimationOnStart is true
+     */
+    beginAnimationFrom: number;
+    /**
+     * Gets or sets the frame to end the animation on when beginAnimationOnStart is true
+     */
+    beginAnimationTo: number;
+    /**
+     * Gets or sets a boolean indicating if animations must loop when beginAnimationOnStart is true
+     */
+    beginAnimationLoop: boolean;
+    /**
+     * Gets or sets a world offset applied to all particles
+     */
+    worldOffset: Vector3;
+    _useLogarithmicDepth: boolean;
+    /**
+     * You can use gravity if you want to give an orientation to your particles.
+     */
+    gravity: Vector3;
+    _colorGradients: any;
+    _sizeGradients: any;
+    _lifeTimeGradients: any;
+    _angularSpeedGradients: any;
+    _velocityGradients: any;
+    _limitVelocityGradients: any;
+    _dragGradients: any;
+    _emitRateGradients: any;
+    _startSizeGradients: any;
+    _rampGradients: any;
+    _colorRemapGradients: any;
+    _alphaRemapGradients: any;
+    /**
+     * Defines the delay in milliseconds before starting the system (0 by default)
+     */
+    startDelay: number;
+    /** Gets or sets a value indicating the damping to apply if the limit velocity factor is reached */
+    limitVelocityDamping: number;
+    /**
+     * Random color of each particle after it has been emitted, between color1 and color2 vectors
+     */
+    color1: Color4;
+    /**
+     * Random color of each particle after it has been emitted, between color1 and color2 vectors
+     */
+    color2: Color4;
+    /**
+     * Color the particle will have at the end of its lifetime
+     */
+    colorDead: Color4;
+    /**
+     * An optional mask to filter some colors out of the texture, or filter a part of the alpha channel
+     */
+    textureMask: Color4;
+    /** @internal */
+    _isSubEmitter: boolean;
+    /** @internal */
+    _billboardMode: number;
+    /** @internal */
+    _isBillboardBased: boolean;
+    /**
+     * Local cache of defines for image processing.
+     */
+    _imageProcessingConfigurationDefines: ImageProcessingConfigurationDefines;
+    id: any;
+    name: any;
+    set noiseTexture(arg: any);
+    /**
+     * Gets or sets a texture used to add random noise to particle positions
+     */
+    get noiseTexture(): any;
+    _noiseTexture: any;
+    set isAnimationSheetEnabled(arg: any);
+    /**
+     * Gets or sets whether an animation sprite sheet is enabled or not on the particle system
+     */
+    get isAnimationSheetEnabled(): any;
+    _isAnimationSheetEnabled: any;
+    set useLogarithmicDepth(arg: boolean);
+    /**
+     * Gets or sets a boolean enabling the use of logarithmic depth buffers, which is good for wide depth buffers.
+     */
+    get useLogarithmicDepth(): boolean;
+    /**
+     * Get hosting scene
+     * @returns the scene
+     */
+    getScene(): any;
+    _hasTargetStopDurationDependantGradient(): any;
+    /**
+     * Gets the current list of drag gradients.
+     * You must use addDragGradient and removeDragGradient to update this list
+     * @returns the list of drag gradients
+     */
+    getDragGradients(): any;
+    /**
+     * Gets the current list of limit velocity gradients.
+     * You must use addLimitVelocityGradient and removeLimitVelocityGradient to update this list
+     * @returns the list of limit velocity gradients
+     */
+    getLimitVelocityGradients(): any;
+    /**
+     * Gets the current list of color gradients.
+     * You must use addColorGradient and removeColorGradient to update this list
+     * @returns the list of color gradients
+     */
+    getColorGradients(): any;
+    /**
+     * Gets the current list of size gradients.
+     * You must use addSizeGradient and removeSizeGradient to update this list
+     * @returns the list of size gradients
+     */
+    getSizeGradients(): any;
+    /**
+     * Gets the current list of color remap gradients.
+     * You must use addColorRemapGradient and removeColorRemapGradient to update this list
+     * @returns the list of color remap gradients
+     */
+    getColorRemapGradients(): any;
+    /**
+     * Gets the current list of alpha remap gradients.
+     * You must use addAlphaRemapGradient and removeAlphaRemapGradient to update this list
+     * @returns the list of alpha remap gradients
+     */
+    getAlphaRemapGradients(): any;
+    /**
+     * Gets the current list of life time gradients.
+     * You must use addLifeTimeGradient and removeLifeTimeGradient to update this list
+     * @returns the list of life time gradients
+     */
+    getLifeTimeGradients(): any;
+    /**
+     * Gets the current list of angular speed gradients.
+     * You must use addAngularSpeedGradient and removeAngularSpeedGradient to update this list
+     * @returns the list of angular speed gradients
+     */
+    getAngularSpeedGradients(): any;
+    /**
+     * Gets the current list of velocity gradients.
+     * You must use addVelocityGradient and removeVelocityGradient to update this list
+     * @returns the list of velocity gradients
+     */
+    getVelocityGradients(): any;
+    /**
+     * Gets the current list of start size gradients.
+     * You must use addStartSizeGradient and removeStartSizeGradient to update this list
+     * @returns the list of start size gradients
+     */
+    getStartSizeGradients(): any;
+    /**
+     * Gets the current list of emit rate gradients.
+     * You must use addEmitRateGradient and removeEmitRateGradient to update this list
+     * @returns the list of emit rate gradients
+     */
+    getEmitRateGradients(): any;
+    set direction1(arg: any);
+    /**
+     * Random direction of each particle after it has been emitted, between direction1 and direction2 vectors.
+     * This only works when particleEmitterTyps is a BoxParticleEmitter
+     */
+    get direction1(): any;
+    set direction2(arg: any);
+    /**
+     * Random direction of each particle after it has been emitted, between direction1 and direction2 vectors.
+     * This only works when particleEmitterTyps is a BoxParticleEmitter
+     */
+    get direction2(): any;
+    set minEmitBox(arg: any);
+    /**
+     * Minimum box point around our emitter. Our emitter is the center of particles source, but if you want your particles to emit from more than one point, then you can tell it to do so.
+     * This only works when particleEmitterTyps is a BoxParticleEmitter
+     */
+    get minEmitBox(): any;
+    set maxEmitBox(arg: any);
+    /**
+     * Maximum box point around our emitter. Our emitter is the center of particles source, but if you want your particles to emit from more than one point, then you can tell it to do so.
+     * This only works when particleEmitterTyps is a BoxParticleEmitter
+     */
+    get maxEmitBox(): any;
+    set billboardMode(arg: number);
+    /**
+     * Gets or sets the billboard mode to use when isBillboardBased = true.
+     * Value can be: ParticleSystem.BILLBOARDMODE_ALL, ParticleSystem.BILLBOARDMODE_Y, ParticleSystem.BILLBOARDMODE_STRETCHED
+     */
+    get billboardMode(): number;
+    set isBillboardBased(arg: boolean);
+    /**
+     * Gets or sets a boolean indicating if the particles must be rendered as billboard or aligned with the direction
+     */
+    get isBillboardBased(): boolean;
+    /**
+     * Sets the Default image processing configuration used either in the this material.
+     *
+     * If sets to null, the scene one is in use.
+     */
+    set imageProcessingConfiguration(arg: any);
+    /**
+     * Gets the image processing configuration used either in this material.
+     */
+    get imageProcessingConfiguration(): any;
+    /**
+     * Attaches a new image processing configuration to the Standard Material.
+     * @param configuration
+     */
+    _attachImageProcessingConfiguration(configuration: any): void;
+    _imageProcessingConfiguration: any;
+    /** @internal */
+    _reset(): void;
+    /**
+     * @internal
+     */
+    _removeGradientAndTexture(gradient: any, gradients: any, texture: any): BaseParticleSystem;
+    /**
+     * Creates a Point Emitter for the particle system (emits directly from the emitter position)
+     * @param direction1 Particles are emitted between the direction1 and direction2 from within the box
+     * @param direction2 Particles are emitted between the direction1 and direction2 from within the box
+     * @returns the emitter
+     */
+    createPointEmitter(direction1: any, direction2: any): PointParticleEmitter;
+    particleEmitterType: PointParticleEmitter | HemisphericParticleEmitter | SphereParticleEmitter | SphereDirectedParticleEmitter | CylinderParticleEmitter | CylinderDirectedParticleEmitter | ConeParticleEmitter | BoxParticleEmitter | undefined;
+    /**
+     * Creates a Hemisphere Emitter for the particle system (emits along the hemisphere radius)
+     * @param radius The radius of the hemisphere to emit from
+     * @param radiusRange The range of the hemisphere to emit from [0-1] 0 Surface Only, 1 Entire Radius
+     * @returns the emitter
+     */
+    createHemisphericEmitter(radius?: number, radiusRange?: number): HemisphericParticleEmitter;
+    /**
+     * Creates a Sphere Emitter for the particle system (emits along the sphere radius)
+     * @param radius The radius of the sphere to emit from
+     * @param radiusRange The range of the sphere to emit from [0-1] 0 Surface Only, 1 Entire Radius
+     * @returns the emitter
+     */
+    createSphereEmitter(radius?: number, radiusRange?: number): SphereParticleEmitter;
+    /**
+     * Creates a Directed Sphere Emitter for the particle system (emits between direction1 and direction2)
+     * @param radius The radius of the sphere to emit from
+     * @param direction1 Particles are emitted between the direction1 and direction2 from within the sphere
+     * @param direction2 Particles are emitted between the direction1 and direction2 from within the sphere
+     * @returns the emitter
+     */
+    createDirectedSphereEmitter(radius?: number, direction1?: Vector3, direction2?: Vector3): SphereDirectedParticleEmitter;
+    /**
+     * Creates a Cylinder Emitter for the particle system (emits from the cylinder to the particle position)
+     * @param radius The radius of the emission cylinder
+     * @param height The height of the emission cylinder
+     * @param radiusRange The range of emission [0-1] 0 Surface only, 1 Entire Radius
+     * @param directionRandomizer How much to randomize the particle direction [0-1]
+     * @returns the emitter
+     */
+    createCylinderEmitter(radius?: number, height?: number, radiusRange?: number, directionRandomizer?: number): CylinderParticleEmitter;
+    /**
+     * Creates a Directed Cylinder Emitter for the particle system (emits between direction1 and direction2)
+     * @param radius The radius of the cylinder to emit from
+     * @param height The height of the emission cylinder
+     * @param radiusRange the range of the emission cylinder [0-1] 0 Surface only, 1 Entire Radius (1 by default)
+     * @param direction1 Particles are emitted between the direction1 and direction2 from within the cylinder
+     * @param direction2 Particles are emitted between the direction1 and direction2 from within the cylinder
+     * @returns the emitter
+     */
+    createDirectedCylinderEmitter(radius?: number, height?: number, radiusRange?: number, direction1?: Vector3, direction2?: Vector3): CylinderDirectedParticleEmitter;
+    /**
+     * Creates a Cone Emitter for the particle system (emits from the cone to the particle position)
+     * @param radius The radius of the cone to emit from
+     * @param angle The base angle of the cone
+     * @returns the emitter
+     */
+    createConeEmitter(radius?: number, angle?: number): ConeParticleEmitter;
+    /**
+     * Creates a Box Emitter for the particle system. (emits between direction1 and direction2 from withing the box defined by minEmitBox and maxEmitBox)
+     * @param direction1 Particles are emitted between the direction1 and direction2 from within the box
+     * @param direction2 Particles are emitted between the direction1 and direction2 from within the box
+     * @param minEmitBox Particles are emitted from the box between minEmitBox and maxEmitBox
+     * @param maxEmitBox  Particles are emitted from the box between minEmitBox and maxEmitBox
+     * @returns the emitter
+     */
+    createBoxEmitter(direction1: any, direction2: any, minEmitBox: any, maxEmitBox: any): BoxParticleEmitter;
+}
+export namespace BaseParticleSystem {
+    const BLENDMODE_ONEONE: number;
+    const BLENDMODE_STANDARD: number;
+    const BLENDMODE_ADD: number;
+    const BLENDMODE_MULTIPLY: number;
+    const BLENDMODE_MULTIPLYADD: number;
+}
+import { Vector3 } from "../Maths/math.vector.js";
+import { Vector2 } from "../Maths/math.vector.js";
+import { Color4 } from "../Maths/math.color.js";
+import { ImageProcessingConfigurationDefines } from "../Materials/imageProcessingConfiguration.js";
+import { PointParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/pointParticleEmitter.js";
+import { HemisphericParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/hemisphericParticleEmitter.js";
+import { SphereParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/sphereParticleEmitter.js";
+import { SphereDirectedParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/sphereParticleEmitter.js";
+import { CylinderParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/cylinderParticleEmitter.js";
+import { CylinderDirectedParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/cylinderParticleEmitter.js";
+import { ConeParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/coneParticleEmitter.js";
+import { BoxParticleEmitter } from "@babylonjs/core/Particles/EmitterTypes/boxParticleEmitter.js";

package/dist/types/node_modules/@babylonjs/core/Particles/cloudPoint.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Represents one particle of a points cloud system.
+ */
+export class CloudPoint {
+    /**
+     * Creates a Point Cloud object.
+     * Don't create particles manually, use instead the PCS internal tools like _addParticle()
+     * @param particleIndex (integer) is the particle index in the PCS pool. It's also the particle identifier.
+     * @param group (PointsGroup) is the group the particle belongs to
+     * @param groupId (integer) is the group identifier in the PCS.
+     * @param idxInGroup (integer) is the index of the particle in the current point group (ex: the 10th point of addPoints(30))
+     * @param pcs defines the PCS it is associated to
+     */
+    constructor(particleIndex: any, group: any, groupId: any, idxInGroup: any, pcs: any);
+    /**
+     * particle global index
+     */
+    idx: any;
+    /**
+     * The color of the particle
+     */
+    color: Color4;
+    /**
+     * The world space position of the particle.
+     */
+    position: Vector3;
+    /**
+     * The world space rotation of the particle. (Not use if rotationQuaternion is set)
+     */
+    rotation: Vector3;
+    /**
+     * The uv of the particle.
+     */
+    uv: Vector2;
+    /**
+     * The current speed of the particle.
+     */
+    velocity: Vector3;
+    /**
+     * The pivot point in the particle local space.
+     */
+    pivot: Vector3;
+    /**
+     * Must the particle be translated from its pivot point in its local space ?
+     * In this case, the pivot point is set at the origin of the particle local space and the particle is translated.
+     * Default : false
+     */
+    translateFromPivot: boolean;
+    /**
+     * Index of this particle in the global "positions" array (Internal use)
+     * @internal
+     */
+    _pos: number;
+    /**
+     * @internal Index of this particle in the global "indices" array (Internal use)
+     */
+    _ind: number;
+    /**
+     * Group id of this particle
+     */
+    groupId: any;
+    /**
+     * Index of the particle in its group id (Internal use)
+     */
+    idxInGroup: any;
+    /**
+     * @internal Still set as invisible in order to skip useless computations (Internal use)
+     */
+    _stillInvisible: boolean;
+    /**
+     * @internal Last computed particle rotation matrix
+     */
+    _rotationMatrix: number[];
+    /**
+     * Parent particle Id, if any.
+     * Default null.
+     */
+    parentId: any;
+    /**
+     * @internal Internal global position in the PCS.
+     */
+    _globalPosition: Vector3;
+    _group: any;
+    _pcs: any;
+    /**
+     * Set point size
+     */
+    set size(arg: any);
+    /**
+     * get point size
+     */
+    get size(): any;
+    /**
+     * Legacy support, changed quaternion to rotationQuaternion
+     */
+    set quaternion(arg: any);
+    /**
+     * Legacy support, changed quaternion to rotationQuaternion
+     */
+    get quaternion(): any;
+    rotationQuaternion: any;
+    /**
+     * Returns a boolean. True if the particle intersects a mesh, else false
+     * The intersection is computed on the particle position and Axis Aligned Bounding Box (AABB) or Sphere
+     * @param target is the object (point or mesh) what the intersection is computed against
+     * @param isSphere is boolean flag when false (default) bounding box of mesh is used, when true the bounding sphere is used
+     * @returns true if it intersects
+     */
+    intersectsMesh(target: any, isSphere: any): any;
+    /**
+     * get the rotation matrix of the particle
+     * @internal
+     */
+    getRotationMatrix(m: any): void;
+}
+/**
+ * Represents a group of points in a points cloud system
+ *  * PCS internal tool, don't use it manually.
+ */
+export class PointsGroup {
+    /**
+     * Creates a points group object. This is an internal reference to produce particles for the PCS.
+     * PCS internal tool, don't use it manually.
+     * @internal
+     */
+    constructor(id: any, posFunction: any);
+    groupId: any;
+    _positionFunction: any;
+    set groupID(arg: any);
+    /**
+     * Get or set the groupId
+     * @deprecated Please use groupId instead
+     */
+    get groupID(): any;
+}
+import { Color4 } from "@babylonjs/core/Maths/math.color.js";
+import { Vector3 } from "@babylonjs/core/Maths/math.vector.js";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";

package/dist/types/node_modules/@babylonjs/core/Particles/computeShaderParticleSystem.d.ts

@@ -0,0 +1,24 @@
+/** @internal */
+export class ComputeShaderParticleSystem {
+    constructor(parent: any, engine: any);
+    _bufferComputeShader: any[];
+    _renderVertexBuffers: any[];
+    alignDataInBuffer: boolean;
+    _parent: any;
+    _engine: any;
+    isUpdateBufferCreated(): boolean;
+    isUpdateBufferReady(): boolean;
+    createUpdateBuffer(defines: any): UniformBufferEffectCommonAccessor;
+    _updateComputeShader: ComputeShader | null | undefined;
+    _simParamsComputeShader: UniformBuffer | null | undefined;
+    createVertexBuffers(updateBuffer: any, renderVertexBuffers: any): void;
+    createParticleBuffer(data: any): import("@babylonjs/core").DataBuffer;
+    bindDrawBuffers(index: any, effect: any): void;
+    preUpdateParticleBuffer(): void;
+    updateParticleBuffer(index: any, targetBuffer: any, currentActiveCount: any): void;
+    releaseBuffers(): void;
+    releaseVertexBuffers(): void;
+}
+import { UniformBufferEffectCommonAccessor } from "../Materials/uniformBufferEffectCommonAccessor.js";
+import { ComputeShader } from "../Compute/computeShader.js";
+import { UniformBuffer } from "../Materials/uniformBuffer.js";