@babylonjs/inspector 8.41.1-preview → 8.41.2-preview

package/lib/index.d.ts

@@ -14491,6 +14491,84 @@ declare class ImageProcessingConfiguration {
     static get VIGNETTEMODE_OPAQUE(): number;
 }
 
+/**
+ * Effect Render Options
+ */
+interface IEffectRendererOptions {
+    /**
+     * Defines the vertices positions.
+     */
+    positions?: number[];
+    /**
+     * Defines the indices.
+     */
+    indices?: number[];
+}
+/**
+ * Helper class to render one or more effects.
+ * You can access the previous rendering in your shader by declaring a sampler named textureSampler
+ */
+declare class EffectRenderer {
+    /**
+     * The engine the effect renderer has been created for.
+     */
+    readonly engine: AbstractEngine;
+    private _vertexBuffers;
+    private _indexBuffer;
+    private _indexBufferLength;
+    private _fullscreenViewport;
+    private _onContextRestoredObserver;
+    private _savedStateDepthTest;
+    private _savedStateStencilTest;
+    /**
+     * Creates an effect renderer
+     * @param engine the engine to use for rendering
+     * @param options defines the options of the effect renderer
+     */
+    constructor(engine: AbstractEngine, options?: IEffectRendererOptions);
+    /**
+     * Sets the current viewport in normalized coordinates 0-1
+     * @param viewport Defines the viewport to set (defaults to 0 0 1 1)
+     */
+    setViewport(viewport?: Viewport): void;
+    /**
+     * Binds the embedded attributes buffer to the effect.
+     * @param effect Defines the effect to bind the attributes for
+     */
+    bindBuffers(effect: Effect): void;
+    /**
+     * Sets the current effect wrapper to use during draw.
+     * The effect needs to be ready before calling this api.
+     * This also sets the default full screen position attribute.
+     * @param effectWrapper Defines the effect to draw with
+     * @param depthTest Whether to enable depth testing (default: false)
+     * @param stencilTest Whether to enable stencil testing (default: false)
+     */
+    applyEffectWrapper(effectWrapper: EffectWrapper, depthTest?: boolean, stencilTest?: boolean): void;
+    /**
+     * Saves engine states
+     */
+    saveStates(): void;
+    /**
+     * Restores engine states
+     */
+    restoreStates(): void;
+    /**
+     * Draws a full screen quad.
+     */
+    draw(): void;
+    private _isRenderTargetTexture;
+    /**
+     * renders one or more effects to a specified texture
+     * @param effectWrapper the effect to renderer
+     * @param outputTexture texture to draw to, if null it will render to the currently bound frame buffer
+     */
+    render(effectWrapper: EffectWrapper, outputTexture?: Nullable<RenderTargetWrapper | IRenderTargetTexture>): void;
+    /**
+     * Disposes of the effect renderer
+     */
+    dispose(): void;
+}
 /**
  * Allows for custom processing of the shader code used by an effect wrapper
  */
@@ -26344,7 +26422,8 @@ declare class RenderingGroup {
     private static _ZeroVector;
     private _scene;
     private _opaqueSubMeshes;
-    private _transparentSubMeshes;
+    /** @internal */
+    _transparentSubMeshes: SmartArray<SubMesh>;
     private _alphaTestSubMeshes;
     private _depthOnlySubMeshes;
     private _particleSystems;
@@ -26354,7 +26433,8 @@ declare class RenderingGroup {
     private _transparentSortCompareFn;
     private _renderOpaque;
     private _renderAlphaTest;
-    private _renderTransparent;
+    /** @internal */
+    _renderTransparent: (subMeshes: SmartArray<SubMesh>) => void;
     /** @internal */
     _empty: boolean;
     /** @internal */
@@ -26391,8 +26471,13 @@ declare class RenderingGroup {
      * @param renderSprites
      * @param renderParticles
      * @param activeMeshes
+     * @param renderDepthOnlyMeshes
+     * @param renderOpaqueMeshes
+     * @param renderAlphaTestMeshes
+     * @param renderTransparentMeshes
+     * @param customRenderTransparentSubMeshes
      */
-    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, renderSprites: boolean, renderParticles: boolean, activeMeshes: Nullable<AbstractMesh[]>): void;
+    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, renderSprites: boolean, renderParticles: boolean, activeMeshes: Nullable<AbstractMesh[]>, renderDepthOnlyMeshes?: boolean, renderOpaqueMeshes?: boolean, renderAlphaTestMeshes?: boolean, renderTransparentMeshes?: boolean, customRenderTransparentSubMeshes?: (transparentSubMeshes: SmartArray<SubMesh>) => void): void;
     /**
      * Renders the opaque submeshes in the order from the opaqueSortCompareFn.
      * @param subMeshes The submeshes to render
@@ -26568,6 +26653,10 @@ declare class RenderingManager {
      * @param scene Defines the scene the groups belongs to
      */
     constructor(scene: Scene);
+    /**
+     * @returns the list of rendering groups managed by the manager.
+     */
+    get renderingGroups(): Immutable<RenderingGroup[]>;
     /**
      * @returns the rendering group with the specified id.
      * @param id the id of the rendering group (0 by default)
@@ -26578,7 +26667,7 @@ declare class RenderingManager {
      * Renders the entire managed groups. This is used by the scene or the different render targets.
      * @internal
      */
-    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, activeMeshes: Nullable<AbstractMesh[]>, renderParticles: boolean, renderSprites: boolean): void;
+    render(customRenderFunction: Nullable<(opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, depthOnlySubMeshes: SmartArray<SubMesh>) => void>, activeMeshes: Nullable<AbstractMesh[]>, renderParticles: boolean, renderSprites: boolean, renderDepthOnlyMeshes?: boolean, renderOpaqueMeshes?: boolean, renderAlphaTestMeshes?: boolean, renderTransparentMeshes?: boolean, customRenderTransparentSubMeshes?: (transparentSubMeshes: SmartArray<SubMesh>) => void): void;
     /**
      * Resets the different information of the group to prepare a new frame
      * @internal
@@ -26705,6 +26794,26 @@ declare class ObjectRenderer {
      * Define if meshes should be rendered (default is true).
      */
     renderMeshes: boolean;
+    /**
+     * Define if depth only meshes should be rendered (default is true). No effect if renderMeshes is false.
+     */
+    renderDepthOnlyMeshes: boolean;
+    /**
+     * Define if opaque meshes should be rendered (default is true). No effect if renderMeshes is false.
+     */
+    renderOpaqueMeshes: boolean;
+    /**
+     * Define if alpha test meshes should be rendered (default is true). No effect if renderMeshes is false.
+     */
+    renderAlphaTestMeshes: boolean;
+    /**
+     * Define if transparent meshes should be rendered (default is true). No effect if renderMeshes is false.
+     */
+    renderTransparentMeshes: boolean;
+    /**
+     * Custom render function for transparent submeshes.
+     */
+    customRenderTransparentSubMeshes?: (transparentSubMeshes: SmartArray<SubMesh>) => void;
     /**
      * Define if particles should be rendered (default is true).
      */
@@ -49060,6 +49169,8 @@ declare abstract class FrameGraphTask {
     _checkTask(): void;
     /** @internal */
     _execute(): void;
+    /** @internal */
+    _initializePasses(): void;
     private _checkSameRenderTarget;
 }
 
@@ -49111,6 +49222,7 @@ declare class FrameGraphPass<T extends FrameGraphContext> implements IFrameGraph
     protected readonly _parentTask: FrameGraphTask;
     protected readonly _context: T;
     private _executeFunc;
+    private _initFunc?;
     /**
      * Whether the pass is disabled. Disabled passes will be skipped during execution.
      */
@@ -49118,13 +49230,21 @@ declare class FrameGraphPass<T extends FrameGraphContext> implements IFrameGraph
     /** @internal */
     constructor(name: string, _parentTask: FrameGraphTask, _context: T);
     /**
-     * Executes the pass.
-     * @param func The function to execute for the pass.
+     * Initializes the pass.
+     * This function is called once after the frame graph has been built
+     * @param func The function to initialize the pass.
+     */
+    setInitializeFunc(func: (context: T) => void): void;
+    /**
+     * Sets the function to execute when the pass is executed
+     * @param func The function to execute when the pass is executed
      */
     setExecuteFunc(func: (context: T) => void): void;
     /** @internal */
     _execute(): void;
     /** @internal */
+    _initialize(): void;
+    /** @internal */
     _isValid(): Nullable<string>;
     /** @internal */
     _dispose(): void;
@@ -49137,7 +49257,7 @@ declare class FrameGraphRenderPass extends FrameGraphPass<FrameGraphRenderContex
     protected readonly _engine: AbstractEngine;
     protected _renderTarget: FrameGraphTextureHandle | FrameGraphTextureHandle[] | undefined;
     protected _renderTargetDepth: FrameGraphTextureHandle | undefined;
-    protected _frameGraphRenderTarget: FrameGraphRenderTarget | undefined;
+    protected _frameGraphRenderTarget: FrameGraphRenderTarget;
     protected _dependencies: Set<FrameGraphTextureHandle>;
     /**
      * Checks if a pass is a render pass.
@@ -49156,7 +49276,7 @@ declare class FrameGraphRenderPass extends FrameGraphPass<FrameGraphRenderContex
     /**
      * Gets the frame graph render target used by the render pass.
      */
-    get frameGraphRenderTarget(): FrameGraphRenderTarget | undefined;
+    get frameGraphRenderTarget(): FrameGraphRenderTarget;
     /**
      * If true, the depth attachment will be read-only (may allow some optimizations in WebGPU)
      */
@@ -49188,6 +49308,8 @@ declare class FrameGraphRenderPass extends FrameGraphPass<FrameGraphRenderContex
      */
     collectDependencies(dependencies: Set<FrameGraphTextureHandle>): void;
     /** @internal */
+    _initialize(): void;
+    /** @internal */
     _execute(): void;
     /** @internal */
     _isValid(): Nullable<string>;
@@ -50148,6 +50270,112 @@ declare class ThinGlowLayer extends ThinEffectLayer {
     _disposeMesh(mesh: Mesh): void;
 }
 
+/**
+ * @internal
+ */
+declare class ThinDepthPeelingRenderer {
+    protected _scene: Scene;
+    protected _engine: AbstractEngine;
+    protected _depthMrts: MultiRenderTarget[];
+    protected _thinTextures: ThinTexture[];
+    protected _colorMrts: MultiRenderTarget[];
+    protected _blendBackMrt: MultiRenderTarget;
+    protected _blendBackEffectWrapper: EffectWrapper;
+    protected _blendBackEffectWrapperPingPong: EffectWrapper;
+    protected _finalEffectWrapper: EffectWrapper;
+    protected _effectRenderer: EffectRenderer;
+    protected _currentPingPongState: number;
+    protected _layoutCacheFormat: boolean[][];
+    protected _layoutCache: number[][];
+    protected _renderPassIds: number[];
+    protected _candidateSubMeshes: SmartArray<SubMesh>;
+    protected _excludedSubMeshes: SmartArray<SubMesh>;
+    protected _excludedMeshes: number[];
+    protected static _DEPTH_CLEAR_VALUE: number;
+    protected static _MIN_DEPTH: number;
+    protected static _MAX_DEPTH: number;
+    protected _colorCache: Color4[];
+    protected _passCount: number;
+    /**
+     * Number of depth peeling passes. As we are using dual depth peeling, each pass two levels of transparency are processed.
+     */
+    get passCount(): number;
+    set passCount(count: number);
+    protected _useRenderPasses: boolean;
+    /**
+     * Instructs the renderer to use render passes. It is an optimization that makes the rendering faster for some engines (like WebGPU) but that consumes more memory, so it is disabled by default.
+     */
+    get useRenderPasses(): boolean;
+    set useRenderPasses(usePasses: boolean);
+    /**
+     * Add a mesh in the exclusion list to prevent it to be handled by the depth peeling renderer
+     * @param mesh The mesh to exclude from the depth peeling renderer
+     */
+    addExcludedMesh(mesh: AbstractMesh): void;
+    /**
+     * Remove a mesh from the exclusion list of the depth peeling renderer
+     * @param mesh The mesh to remove
+     */
+    removeExcludedMesh(mesh: AbstractMesh): void;
+    /** Shader language used by the renderer */
+    protected _shaderLanguage: ShaderLanguage;
+    /**
+     * Gets the shader language used in this renderer
+     */
+    get shaderLanguage(): ShaderLanguage;
+    private _blendOutput;
+    /**
+     * Sets the render target wrapper we will blend the transparent objects onto
+     */
+    get blendOutput(): Nullable<RenderTargetWrapper>;
+    set blendOutput(blendOutput: Nullable<RenderTargetWrapper>);
+    /**
+     * Instanciates the depth peeling renderer
+     * @param scene Scene to attach to
+     * @param passCount Number of depth layers to peel
+     * @returns The depth peeling renderer
+     */
+    constructor(scene: Scene, passCount?: number);
+    private _createRenderPassIds;
+    private _releaseRenderPassIds;
+    protected _getTextureSize(): {
+        width: number;
+        height: number;
+    };
+    protected _createTextures(): void;
+    protected _disposeTextures(): void;
+    protected _createEffects(finalEffectFragmentShaderName: string, finalEffectSamplerNames: string[]): void;
+    /**
+     * Links to the prepass renderer
+     * @param _prePassRenderer The scene PrePassRenderer
+     */
+    setPrePassRenderer(_prePassRenderer: PrePassRenderer): void;
+    /**
+     * Binds depth peeling textures on an effect
+     * @param effect The effect to bind textures on
+     */
+    bind(effect: Effect): void;
+    private _renderSubMeshes;
+    protected _finalCompose(writeId: number): void;
+    /**
+     * Checks if the depth peeling renderer is ready to render transparent meshes
+     * @returns true if the depth peeling renderer is ready to render the transparent meshes
+     */
+    isReady(): boolean;
+    protected _beforeRender(): void;
+    protected _afterRender(): void;
+    /**
+     * Renders transparent submeshes with depth peeling
+     * @param transparentSubMeshes List of transparent meshes to render
+     * @returns The array of submeshes that could not be handled by this renderer
+     */
+    render(transparentSubMeshes: SmartArray<SubMesh>): SmartArray<SubMesh>;
+    /**
+     * Disposes the depth peeling renderer and associated resources
+     */
+    dispose(): void;
+}
+
 /**
  * Task used to render objects to a texture.
  */
@@ -50206,6 +50434,41 @@ declare class FrameGraphObjectRendererTask extends FrameGraphTask {
      */
     get renderMeshes(): boolean;
     set renderMeshes(value: boolean);
+    private _renderDepthOnlyMeshes;
+    /**
+     * Defines if depth only meshes should be rendered (default is true). Always subject to the renderMeshes property, though.
+     */
+    get renderDepthOnlyMeshes(): boolean;
+    set renderDepthOnlyMeshes(value: boolean);
+    private _renderOpaqueMeshes;
+    /**
+     * Defines if opaque meshes should be rendered (default is true). Always subject to the renderMeshes property, though.
+     */
+    get renderOpaqueMeshes(): boolean;
+    set renderOpaqueMeshes(value: boolean);
+    private _renderAlphaTestMeshes;
+    /**
+     * Defines if alpha test meshes should be rendered (default is true). Always subject to the renderMeshes property, though.
+     */
+    get renderAlphaTestMeshes(): boolean;
+    set renderAlphaTestMeshes(value: boolean);
+    private _renderTransparentMeshes;
+    /**
+     * Defines if transparent meshes should be rendered (default is true). Always subject to the renderMeshes property, though.
+     */
+    get renderTransparentMeshes(): boolean;
+    set renderTransparentMeshes(value: boolean);
+    private _useOITForTransparentMeshes;
+    /**
+     * Defines if Order Independent Transparency should be used for transparent meshes (default is false).
+     */
+    get useOITForTransparentMeshes(): boolean;
+    set useOITForTransparentMeshes(value: boolean);
+    /**
+     * Defines the number of passes to use for Order Independent Transparency (default is 5).
+     */
+    get oitPassCount(): number;
+    set oitPassCount(value: number);
     private _renderParticles;
     /**
      * Defines if particles should be rendered (default is true).
@@ -50265,11 +50528,13 @@ declare class FrameGraphObjectRendererTask extends FrameGraphTask {
     protected readonly _engine: AbstractEngine;
     protected readonly _scene: Scene;
     protected readonly _renderer: ObjectRenderer;
+    protected readonly _oitRenderer: ThinDepthPeelingRenderer;
     protected _textureWidth: number;
     protected _textureHeight: number;
     protected _onBeforeRenderObservable: Nullable<Observer<number>>;
     protected _onAfterRenderObservable: Nullable<Observer<number>>;
     protected _externalObjectRenderer: boolean;
+    protected _rtForOrderIndependentTransparency: FrameGraphRenderTarget;
     /**
      * Constructs a new object renderer task.
      * @param name The name of the task.
@@ -50289,6 +50554,7 @@ declare class FrameGraphObjectRendererTask extends FrameGraphTask {
     protected _getTargetHandles(): FrameGraphTextureHandle[];
     protected _prepareRendering(context: FrameGraphRenderContext, depthEnabled: boolean): void;
     protected _setLightsForShadow(): void;
+    protected _renderTransparentMeshesWithOIT(transparentSubMeshes: SmartArray<SubMesh>): void;
 }
 
 /**
@@ -50888,12 +51154,20 @@ interface IFrameGraphPass {
      * Whether the pass is disabled.
      */
     disabled: boolean;
+    /**
+     * Initializes the pass.
+     * This function is called once before the first execution of the pass.
+     * @param func The function to initialize the pass.
+     */
+    setInitializeFunc(func: (context: FrameGraphContext) => void): void;
     /**
      * Sets the function to execute when the pass is executed
      * @param func The function to execute when the pass is executed
      */
     setExecuteFunc(func: (context: FrameGraphContext) => void): void;
     /** @internal */
+    _initialize(): void;
+    /** @internal */
     _execute(): void;
     /** @internal */
     _isValid(): Nullable<string>;
@@ -55936,115 +56210,14 @@ declare module "../scene" {
     }
 }
 
-/**
- * The depth peeling renderer that performs
- * Order independant transparency (OIT).
- * This should not be instanciated directly, as it is part of a scene component
- */
-declare class DepthPeelingRenderer {
-    private _scene;
-    private _engine;
-    private _depthMrts;
-    private _thinTextures;
-    private _colorMrts;
-    private _blendBackMrt;
-    private _outputRT;
-    private _blendBackEffectWrapper;
-    private _blendBackEffectWrapperPingPong;
-    private _finalEffectWrapper;
-    private _effectRenderer;
-    private _currentPingPongState;
-    private _prePassEffectConfiguration;
-    private _blendBackTexture;
-    private _layoutCacheFormat;
-    private _layoutCache;
-    private _renderPassIds;
-    private _candidateSubMeshes;
-    private _excludedSubMeshes;
-    private _excludedMeshes;
-    private static _DEPTH_CLEAR_VALUE;
-    private static _MIN_DEPTH;
-    private static _MAX_DEPTH;
-    private _colorCache;
-    private _passCount;
-    /**
-     * Number of depth peeling passes. As we are using dual depth peeling, each pass two levels of transparency are processed.
-     */
-    get passCount(): number;
-    set passCount(count: number);
-    private _useRenderPasses;
-    /**
-     * Instructs the renderer to use render passes. It is an optimization that makes the rendering faster for some engines (like WebGPU) but that consumes more memory, so it is disabled by default.
-     */
-    get useRenderPasses(): boolean;
-    set useRenderPasses(usePasses: boolean);
-    /**
-     * Add a mesh in the exclusion list to prevent it to be handled by the depth peeling renderer
-     * @param mesh The mesh to exclude from the depth peeling renderer
-     */
-    addExcludedMesh(mesh: AbstractMesh): void;
-    /**
-     * Remove a mesh from the exclusion list of the depth peeling renderer
-     * @param mesh The mesh to remove
-     */
-    removeExcludedMesh(mesh: AbstractMesh): void;
-    /** Shader language used by the renderer */
-    protected _shaderLanguage: ShaderLanguage;
-    /**
-     * Gets the shader language used in this renderer
-     */
-    get shaderLanguage(): ShaderLanguage;
-    /**
-     * Instanciates the depth peeling renderer
-     * @param scene Scene to attach to
-     * @param passCount Number of depth layers to peel
-     * @returns The depth peeling renderer
-     */
-    constructor(scene: Scene, passCount?: number);
-    private _createRenderPassIds;
-    private _releaseRenderPassIds;
-    private _createTextures;
-    private _disposeTextures;
-    private _updateTextures;
-    private _updateTextureReferences;
-    private _createEffects;
-    /**
-     * Links to the prepass renderer
-     * @param prePassRenderer The scene PrePassRenderer
-     */
-    setPrePassRenderer(prePassRenderer: PrePassRenderer): void;
-    /**
-     * Binds depth peeling textures on an effect
-     * @param effect The effect to bind textures on
-     */
-    bind(effect: Effect): void;
-    private _renderSubMeshes;
-    private _finalCompose;
-    /**
-     * Checks if the depth peeling renderer is ready to render transparent meshes
-     * @returns true if the depth peeling renderer is ready to render the transparent meshes
-     */
-    isReady(): boolean;
-    /**
-     * Renders transparent submeshes with depth peeling
-     * @param transparentSubMeshes List of transparent meshes to render
-     * @returns The array of submeshes that could not be handled by this renderer
-     */
-    render(transparentSubMeshes: SmartArray<SubMesh>): SmartArray<SubMesh>;
-    /**
-     * Disposes the depth peeling renderer and associated resources
-     */
-    dispose(): void;
-}
-
 declare module "../scene" {
     interface Scene {
         /**
          * The depth peeling renderer
          */
-        depthPeelingRenderer: Nullable<DepthPeelingRenderer>;
+        depthPeelingRenderer: Nullable<ThinDepthPeelingRenderer>;
         /** @internal (Backing field) */
-        _depthPeelingRenderer: Nullable<DepthPeelingRenderer>;
+        _depthPeelingRenderer: Nullable<ThinDepthPeelingRenderer>;
         /**
          * Flag to indicate if we want to use order independent transparency, despite the performance hit
          */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@babylonjs/inspector",
-    "version": "8.41.1-preview",
+    "version": "8.41.2-preview",
     "type": "module",
     "main": "lib/index.js",
     "module": "lib/index.js",