@combeenation/3d-viewer 0.0.1-types

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

@@ -0,0 +1,178 @@
+/**
+ * This renderer is helpful to fill one of the render target with a geometry buffer.
+ */
+export class GeometryBufferRenderer {
+    /**
+     * Creates a new G Buffer for the scene
+     * @param scene The scene the buffer belongs to
+     * @param ratio How big is the buffer related to the main canvas (default: 1)
+     * @param depthFormat Format of the depth texture (default: 15)
+     */
+    constructor(scene: any, ratio?: number, depthFormat?: number);
+    /**
+     * Dictionary used to store the previous transformation matrices of each rendered mesh
+     * in order to compute objects velocities when enableVelocity is set to "true"
+     * @internal
+     */
+    _previousTransformationMatrices: {};
+    /**
+     * Dictionary used to store the previous bones transformation matrices of each rendered mesh
+     * in order to compute objects velocities when enableVelocity is set to "true"
+     * @internal
+     */
+    _previousBonesTransformationMatrices: {};
+    /**
+     * Array used to store the ignored skinned meshes while computing velocity map (typically used by the motion blur post-process).
+     * Avoids computing bones velocities and computes only mesh's velocity itself (position, rotation, scaling).
+     */
+    excludedSkinnedMeshesFromVelocity: any[];
+    /** Gets or sets a boolean indicating if transparent meshes should be rendered */
+    renderTransparentMeshes: boolean;
+    _resizeObserver: any;
+    _enablePosition: boolean;
+    _enableVelocity: boolean;
+    _enableReflectivity: boolean;
+    _positionIndex: number;
+    _velocityIndex: number;
+    _reflectivityIndex: number;
+    _depthIndex: number;
+    _normalIndex: number;
+    _linkedWithPrePass: boolean;
+    _scene: any;
+    _ratio: number;
+    _useUbo: any;
+    _depthFormat: number;
+    /**
+     * @internal
+     * Sets up internal structures to share outputs with PrePassRenderer
+     * This method should only be called by the PrePassRenderer itself
+     */
+    _linkPrePassRenderer(prePassRenderer: any): void;
+    _prePassRenderer: any;
+    /**
+     * @internal
+     * Separates internal structures from PrePassRenderer so the geometry buffer can now operate by itself.
+     * This method should only be called by the PrePassRenderer itself
+     */
+    _unlinkPrePassRenderer(): void;
+    /**
+     * @internal
+     * Resets the geometry buffer layout
+     */
+    _resetLayout(): void;
+    _attachments: any;
+    /**
+     * @internal
+     * Replaces a texture in the geometry buffer renderer
+     * Useful when linking textures of the prepass renderer
+     */
+    _forceTextureType(geometryBufferType: any, index: any): void;
+    /**
+     * @internal
+     * Sets texture attachments
+     * Useful when linking textures of the prepass renderer
+     */
+    _setAttachments(attachments: any): void;
+    /**
+     * @internal
+     * Replaces the first texture which is hard coded as a depth texture in the geometry buffer
+     * Useful when linking textures of the prepass renderer
+     */
+    _linkInternalTexture(internalTexture: any): void;
+    /**
+     * Set the render list (meshes to be rendered) used in the G buffer.
+     */
+    set renderList(arg: import("@babylonjs/core").Nullable<import("@babylonjs/core").AbstractMesh[]>);
+    /**
+     * Gets the render list (meshes to be rendered) used in the G buffer.
+     */
+    get renderList(): import("@babylonjs/core").Nullable<import("@babylonjs/core").AbstractMesh[]>;
+    /**
+     * Gets whether or not G buffer are supported by the running hardware.
+     * This requires draw buffer supports
+     */
+    get isSupported(): boolean;
+    /**
+     * Returns the index of the given texture type in the G-Buffer textures array
+     * @param textureType The texture type constant. For example GeometryBufferRenderer.POSITION_TEXTURE_INDEX
+     * @returns the index of the given texture type in the G-Buffer textures array
+     */
+    getTextureIndex(textureType: any): number;
+    /**
+     * Sets whether or not objects positions are enabled for the G buffer.
+     */
+    set enablePosition(arg: boolean);
+    /**
+     * Gets a boolean indicating if objects positions are enabled for the G buffer.
+     */
+    get enablePosition(): boolean;
+    /**
+     * Sets whether or not objects velocities are enabled for the G buffer.
+     */
+    set enableVelocity(arg: boolean);
+    /**
+     * Gets a boolean indicating if objects velocities are enabled for the G buffer.
+     */
+    get enableVelocity(): boolean;
+    /**
+     * Sets whether or not objects reflectivity are enabled for the G buffer.
+     * For Metallic-Roughness workflow with ORM texture, we assume that ORM texture is defined according to the default layout:
+     * pbr.useRoughnessFromMetallicTextureAlpha = false;
+     * pbr.useRoughnessFromMetallicTextureGreen = true;
+     * pbr.useMetallnessFromMetallicTextureBlue = true;
+     */
+    set enableReflectivity(arg: boolean);
+    /**
+     * Gets a boolean indicating if objects reflectivity are enabled in the G buffer.
+     */
+    get enableReflectivity(): boolean;
+    /**
+     * Gets the scene associated with the buffer.
+     */
+    get scene(): any;
+    /**
+     * Gets the ratio used by the buffer during its creation.
+     * How big is the buffer related to the main canvas.
+     */
+    get ratio(): number;
+    /**
+     * Checks whether everything is ready to render a submesh to the G buffer.
+     * @param subMesh the submesh to check readiness for
+     * @param useInstances is the mesh drawn using instance or not
+     * @returns true if ready otherwise false
+     */
+    isReady(subMesh: any, useInstances: any): any;
+    /**
+     * Gets the current underlying G Buffer.
+     * @returns the buffer
+     */
+    getGBuffer(): MultiRenderTarget | undefined;
+    /**
+     * Sets the number of samples used to render the buffer (anti aliasing).
+     */
+    set samples(arg: number);
+    /**
+     * Gets the number of samples used to render the buffer (anti aliasing).
+     */
+    get samples(): number;
+    /**
+     * Disposes the renderer and frees up associated resources.
+     */
+    dispose(): void;
+    _assignRenderTargetIndices(): (number | string[])[];
+    _createRenderTargets(): void;
+    _multiRenderTarget: MultiRenderTarget | undefined;
+    _copyBonesTransformationMatrices(source: any, target: any): any;
+}
+export namespace GeometryBufferRenderer {
+    const DEPTH_TEXTURE_TYPE: number;
+    const NORMAL_TEXTURE_TYPE: number;
+    const POSITION_TEXTURE_TYPE: number;
+    const VELOCITY_TEXTURE_TYPE: number;
+    const REFLECTIVITY_TEXTURE_TYPE: number;
+    /**
+     * @internal
+     */
+    function _SceneComponentInitialization(_: any): never;
+}
+import { MultiRenderTarget } from "../Materials/Textures/multiRenderTarget.js";

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

@@ -0,0 +1,30 @@
+/**
+ * Defines the Geometry Buffer scene component responsible to manage a G-Buffer useful
+ * in several rendering techniques.
+ */
+export class GeometryBufferRendererSceneComponent {
+    /**
+     * 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;
+    /**
+     * 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;
+    _gatherRenderTargets(renderTargets: any): void;
+}

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

@@ -0,0 +1,15 @@
+export * from "./boundingBoxRenderer.js";
+export * from "./depthRenderer.js";
+export * from "./depthRendererSceneComponent.js";
+export * from "./depthPeelingRenderer.js";
+export * from "./depthPeelingSceneComponent.js";
+export * from "./edgesRenderer.js";
+export * from "./geometryBufferRenderer.js";
+export * from "./geometryBufferRendererSceneComponent.js";
+export * from "./prePassRenderer.js";
+export * from "./prePassRendererSceneComponent.js";
+export * from "./subSurfaceSceneComponent.js";
+export * from "./outlineRenderer.js";
+export * from "./renderingGroup.js";
+export * from "./renderingManager.js";
+export * from "./utilityLayerRenderer.js";

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

@@ -0,0 +1,18 @@
+/**
+ * Contains all parameters needed for the prepass to perform
+ * motion blur
+ */
+export class MotionBlurConfiguration {
+    /**
+     * Is motion blur 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/outlineRenderer.d.ts

@@ -0,0 +1,62 @@
+/**
+ * This class is responsible to draw the outline/overlay of meshes.
+ * It should not be used directly but through the available method on mesh.
+ */
+export class OutlineRenderer {
+    /**
+     * Instantiates a new outline renderer. (There could be only one per scene).
+     * @param scene Defines the scene it belongs to
+     */
+    constructor(scene: any);
+    /**
+     * The name of the component. Each component must have a unique name.
+     */
+    name: string;
+    /**
+     * Defines a zOffset default Factor to prevent zFighting between the overlay and the mesh.
+     */
+    zOffset: number;
+    /**
+     * Defines a zOffset default Unit to prevent zFighting between the overlay and the mesh.
+     */
+    zOffsetUnits: number;
+    scene: any;
+    _engine: any;
+    _passIdForDrawWrapper: any[];
+    /**
+     * Register the component to one instance of a scene.
+     */
+    register(): 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;
+    /**
+     * Renders the outline in the canvas.
+     * @param subMesh Defines the sumesh to render
+     * @param batch Defines the batch of meshes in case of instances
+     * @param useOverlay Defines if the rendering is for the overlay or the outline
+     * @param renderPassId Render pass id to use to render the mesh
+     */
+    render(subMesh: any, batch: any, useOverlay: boolean | undefined, renderPassId: any): void;
+    /**
+     * Returns whether or not the outline renderer is ready for a given submesh.
+     * All the dependencies e.g. submeshes, texture, effect... mus be ready
+     * @param subMesh Defines the submesh to check readiness for
+     * @param useInstances Defines whether wee are trying to render instances or not
+     * @param renderPassId Render pass id to use to render the mesh
+     * @returns true if ready otherwise false
+     */
+    isReady(subMesh: any, useInstances: any, renderPassId: any): any;
+    _beforeRenderingMesh(mesh: any, subMesh: any, batch: any): void;
+    _savedDepthWrite: any;
+    _afterRenderingMesh(mesh: any, subMesh: any, batch: any): void;
+}
+export namespace OutlineRenderer {
+    const _StencilReference: number;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,200 @@
+/**
+ * Renders a pre pass of the scene
+ * This means every mesh in the scene will be rendered to a render target texture
+ * And then this texture will be composited to the rendering canvas with post processes
+ * It is necessary for effects like subsurface scattering or deferred shading
+ */
+export class PrePassRenderer {
+    /**
+     * Instantiates a prepass renderer
+     * @param scene The scene
+     */
+    constructor(scene: any);
+    /**
+     * To save performance, we can excluded skinned meshes from the prepass
+     */
+    excludedSkinnedMesh: any[];
+    /**
+     * Force material to be excluded from the prepass
+     * Can be useful when `useGeometryBufferFallback` is set to `true`
+     * and you don't want a material to show in the effect.
+     */
+    excludedMaterials: any[];
+    /**
+     * Number of textures in the multi render target texture where the scene is directly rendered
+     */
+    mrtCount: number;
+    _mrtFormats: any[];
+    _mrtLayout: any[];
+    _mrtNames: any[];
+    _textureIndices: any[];
+    _isDirty: boolean;
+    /**
+     * Configuration for prepass effects
+     */
+    _effectConfigurations: any[];
+    /**
+     * Prevents the PrePassRenderer from using the GeometryBufferRenderer as a fallback
+     */
+    doNotUseGeometryRendererFallback: boolean;
+    /**
+     * All the render targets generated by prepass
+     */
+    renderTargets: any[];
+    _clearColor: Color4;
+    _enabled: boolean;
+    _needsCompositionForThisPass: boolean;
+    /**
+     * Set to true to disable gamma transform in PrePass.
+     * Can be useful in case you already proceed to gamma transform on a material level
+     * and your post processes don't need to be in linear color space.
+     */
+    disableGammaTransform: boolean;
+    _scene: any;
+    _engine: any;
+    defaultRT: PrePassRenderTarget;
+    _currentTarget: PrePassRenderTarget;
+    /**
+     * Returns the index of a texture in the multi render target texture array.
+     * @param type Texture type
+     * @returns The index
+     */
+    getIndex(type: any): any;
+    set samples(arg: number);
+    /**
+     * How many samples are used for MSAA of the scene render target
+     */
+    get samples(): number;
+    /**
+     * @returns the prepass render target for the rendering pass.
+     * If we are currently rendering a render target, it returns the PrePassRenderTarget
+     * associated with that render target. Otherwise, it returns the scene default PrePassRenderTarget
+     */
+    getRenderTarget(): PrePassRenderTarget;
+    /**
+     * @internal
+     * Managed by the scene component
+     * @param prePassRenderTarget
+     */
+    _setRenderTarget(prePassRenderTarget: any): void;
+    /**
+     * Returns true if the currently rendered prePassRenderTarget is the one
+     * associated with the scene.
+     */
+    get currentRTisSceneRT(): boolean;
+    _refreshGeometryBufferRendererLink(): void;
+    _geometryBuffer: any;
+    /**
+     * Indicates if the prepass is enabled
+     */
+    get enabled(): boolean;
+    /**
+     * Creates a new PrePassRenderTarget
+     * This should be the only way to instantiate a `PrePassRenderTarget`
+     * @param name Name of the `PrePassRenderTarget`
+     * @param renderTargetTexture RenderTarget the `PrePassRenderTarget` will be attached to.
+     * Can be `null` if the created `PrePassRenderTarget` is attached to the scene (default framebuffer).
+     * @internal
+     */
+    _createRenderTarget(name: any, renderTargetTexture: any): PrePassRenderTarget;
+    /**
+     * Indicates if rendering a prepass is supported
+     */
+    get isSupported(): any;
+    /**
+     * Sets the proper output textures to draw in the engine.
+     * @param effect The effect that is drawn. It can be or not be compatible with drawing to several output textures.
+     * @param subMesh Submesh on which the effect is applied
+     */
+    bindAttachmentsForEffect(effect: any, subMesh: any): void;
+    _reinitializeAttachments(): void;
+    _multiRenderAttachments: any;
+    _clearAttachments: any;
+    _defaultAttachments: any;
+    _resetLayout(): void;
+    _updateGeometryBufferLayout(): void;
+    /**
+     * Restores attachments for single texture draw.
+     */
+    restoreAttachments(): void;
+    /**
+     * @internal
+     */
+    _beforeDraw(camera: any, faceIndex: any, layer: any): void;
+    _prepareFrame(prePassRenderTarget: any, faceIndex: any, layer: any): void;
+    /**
+     * Sets an intermediary texture between prepass and postprocesses. This texture
+     * will be used as input for post processes
+     * @param rt
+     * @returns true if there are postprocesses that will use this texture,
+     * false if there is no postprocesses - and the function has no effect
+     */
+    setCustomOutput(rt: any): boolean;
+    _renderPostProcesses(prePassRenderTarget: any, faceIndex: any): void;
+    /**
+     * @internal
+     */
+    _afterDraw(faceIndex: any, layer: any): void;
+    /**
+     * Clears the current prepass render target (in the sense of settings pixels to the scene clear color value)
+     * @internal
+     */
+    _clear(): void;
+    _bindFrameBuffer(prePassRenderTarget: any): void;
+    _setEnabled(enabled: any): void;
+    _setRenderTargetEnabled(prePassRenderTarget: any, enabled: any): void;
+    /**
+     * Adds an effect configuration to the prepass render target.
+     * If an effect has already been added, it won't add it twice and will return the configuration
+     * already present.
+     * @param cfg the effect configuration
+     * @returns the effect configuration now used by the prepass
+     */
+    addEffectConfiguration(cfg: any): any;
+    _enable(): void;
+    _disable(): void;
+    _getPostProcessesSource(prePassRenderTarget: any, camera: any): any;
+    _setupOutputForThisPass(prePassRenderTarget: any, camera: any): void;
+    _postProcessesSourceForThisPass: any;
+    _linkInternalTexture(prePassRenderTarget: any, postProcess: any): void;
+    /**
+     * @internal
+     */
+    _unlinkInternalTexture(prePassRenderTarget: any): void;
+    _needsImageProcessing(): boolean;
+    _hasImageProcessing(postProcesses: any): boolean;
+    /**
+     * Internal, gets the first post proces.
+     * @param postProcesses
+     * @returns the first post process to be run on this camera.
+     */
+    _getFirstPostProcess(postProcesses: any): any;
+    /**
+     * Marks the prepass renderer as dirty, triggering a check if the prepass is necessary for the next rendering.
+     */
+    markAsDirty(): void;
+    /**
+     * Enables a texture on the MultiRenderTarget for prepass
+     * @param types
+     */
+    _enableTextures(types: any): void;
+    _update(): void;
+    _markAllMaterialsAsPrePassDirty(): void;
+    /**
+     * Disposes the prepass renderer.
+     */
+    dispose(): void;
+}
+export namespace PrePassRenderer {
+    /**
+     * @internal
+     */
+    function _SceneComponentInitialization(_: any): never;
+    const _TextureFormats: {
+        type: number;
+        format: number;
+        name: string;
+    }[];
+}
+import { Color4 } from "../Maths/math.color.js";
+import { PrePassRenderTarget } from "../Materials/Textures/prePassRenderTarget.js";

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

@@ -0,0 +1,37 @@
+/**
+ * Defines the Geometry Buffer scene component responsible to manage a G-Buffer useful
+ * in several rendering techniques.
+ */
+export class PrePassRendererSceneComponent {
+    /**
+     * 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;
+    _beforeRenderTargetDraw(renderTarget: any, faceIndex: any, layer: any): void;
+    _afterRenderTargetDraw(renderTarget: any, faceIndex: any, layer: any): void;
+    _beforeRenderTargetClearStage(renderTarget: any): void;
+    _beforeCameraDraw(camera: any): void;
+    _afterCameraDraw(): void;
+    _beforeClearStage(): void;
+    _beforeRenderingMeshStage(mesh: any, subMesh: any, batch: any, effect: any): void;
+    _afterRenderingMeshStage(mesh: any): 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/renderingGroup.d.ts

@@ -0,0 +1,140 @@
+/**
+ * This represents the object necessary to create a rendering group.
+ * This is exclusively used and created by the rendering manager.
+ * To modify the behavior, you use the available helpers in your scene or meshes.
+ * @internal
+ */
+export class RenderingGroup {
+    /**
+     * Renders the submeshes in a specified order.
+     * @param subMeshes The submeshes to sort before render
+     * @param sortCompareFn The comparison function use to sort
+     * @param camera The camera position use to preprocess the submeshes to help sorting
+     * @param transparent Specifies to activate blending if true
+     */
+    static _RenderSorted(subMeshes: any, sortCompareFn: any, camera: any, transparent: any): void;
+    /**
+     * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+     * are rendered back to front if in the same alpha index.
+     *
+     * @param a The first submesh
+     * @param b The second submesh
+     * @returns The result of the comparison
+     */
+    static defaultTransparentSortCompare(a: any, b: any): 1 | -1 | 0;
+    /**
+     * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+     * are rendered back to front.
+     *
+     * @param a The first submesh
+     * @param b The second submesh
+     * @returns The result of the comparison
+     */
+    static backToFrontSortCompare(a: any, b: any): 1 | -1 | 0;
+    /**
+     * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+     * are rendered front to back (prevent overdraw).
+     *
+     * @param a The first submesh
+     * @param b The second submesh
+     * @returns The result of the comparison
+     */
+    static frontToBackSortCompare(a: any, b: any): 1 | -1 | 0;
+    /**
+     * Build in function which can be applied to ensure meshes of a special queue (opaque, alpha test, transparent)
+     * are grouped by material then geometry.
+     *
+     * @param a The first submesh
+     * @param b The second submesh
+     * @returns The result of the comparison
+     */
+    static PainterSortCompare(a: any, b: any): number;
+    /**
+     * Creates a new rendering group.
+     * @param index The rendering group index
+     * @param scene
+     * @param opaqueSortCompareFn The opaque sort comparison function. If null no order is applied
+     * @param alphaTestSortCompareFn The alpha test sort comparison function. If null no order is applied
+     * @param transparentSortCompareFn The transparent sort comparison function. If null back to front + alpha index sort is applied
+     */
+    constructor(index: any, scene: any, opaqueSortCompareFn?: null, alphaTestSortCompareFn?: null, transparentSortCompareFn?: null);
+    index: any;
+    _opaqueSubMeshes: SmartArray<any>;
+    _transparentSubMeshes: SmartArray<any>;
+    _alphaTestSubMeshes: SmartArray<any>;
+    _depthOnlySubMeshes: SmartArray<any>;
+    _particleSystems: SmartArray<any>;
+    _spriteManagers: SmartArray<any>;
+    /** @internal */
+    _empty: boolean;
+    /** @internal */
+    _edgesRenderers: SmartArrayNoDuplicate<any>;
+    _scene: any;
+    /**
+     * Set the opaque sort comparison function.
+     * If null the sub meshes will be render in the order they were created
+     */
+    set opaqueSortCompareFn(arg: any);
+    /**
+     * Set the alpha test sort comparison function.
+     * If null the sub meshes will be render in the order they were created
+     */
+    set alphaTestSortCompareFn(arg: any);
+    /**
+     * Set the transparent sort comparison function.
+     * If null the sub meshes will be render in the order they were created
+     */
+    set transparentSortCompareFn(arg: any);
+    _opaqueSortCompareFn: any;
+    _renderOpaque: ((subMeshes: any) => void) | undefined;
+    _alphaTestSortCompareFn: any;
+    _renderAlphaTest: ((subMeshes: any) => void) | undefined;
+    _transparentSortCompareFn: any;
+    _renderTransparent: ((subMeshes: any) => void) | undefined;
+    /**
+     * Render all the sub meshes contained in the group.
+     * @param customRenderFunction Used to override the default render behaviour of the group.
+     * @param renderSprites
+     * @param renderParticles
+     * @param activeMeshes
+     * @returns true if rendered some submeshes.
+     */
+    render(customRenderFunction: any, renderSprites: any, renderParticles: any, activeMeshes: any): void;
+    /**
+     * Renders the opaque submeshes in the order from the opaqueSortCompareFn.
+     * @param subMeshes The submeshes to render
+     */
+    _renderOpaqueSorted(subMeshes: any): void;
+    /**
+     * Renders the opaque submeshes in the order from the alphatestSortCompareFn.
+     * @param subMeshes The submeshes to render
+     */
+    _renderAlphaTestSorted(subMeshes: any): void;
+    /**
+     * Renders the opaque submeshes in the order from the transparentSortCompareFn.
+     * @param subMeshes The submeshes to render
+     */
+    _renderTransparentSorted(subMeshes: any): void;
+    /**
+     * Resets the different lists of submeshes to prepare a new frame.
+     */
+    prepare(): void;
+    dispose(): void;
+    /**
+     * Inserts the submesh in its correct queue depending on its material.
+     * @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;
+    dispatchSprites(spriteManager: any): void;
+    dispatchParticles(particleSystem: any): void;
+    _renderParticles(activeMeshes: any): void;
+    _renderSprites(): void;
+}
+export namespace RenderingGroup {
+    const _ZeroVector: Vector3;
+}
+import { SmartArray } from "../Misc/smartArray.js";
+import { SmartArrayNoDuplicate } from "../Misc/smartArray.js";
+import { Vector3 } from "../Maths/math.vector.js";