@onerjs/core 8.23.12 → 8.25.0

package/Rendering/objectRenderer.d.ts

@@ -1,6 +1,7 @@
-import type { SmartArray, Nullable, Immutable, Camera, Scene, AbstractMesh, SubMesh, Material, IParticleSystem } from "../index.js";
+import type { Nullable, Immutable, Camera, Scene, AbstractMesh, SubMesh, Material, IParticleSystem, BoundingBox, UniformBuffer } from "../index.js";
 import { Observable } from "../Misc/observable.js";
 import { RenderingManager } from "../Rendering/renderingManager.js";
+import { SmartArray } from "../Misc/smartArray.js";
 /**
  * Defines the options of the object renderer
  */
@@ -112,18 +113,30 @@ export declare class ObjectRenderer {
      * An event triggered after the rendering group is processed
      */
     readonly onAfterRenderingManagerRenderObservable: Observable<number>;
+    /**
+     * An event triggered when initRender is called
+     */
+    readonly onInitRenderingObservable: Observable<ObjectRenderer>;
+    /**
+     * An event triggered when finishRender is called
+     */
+    readonly onFinishRenderingObservable: Observable<ObjectRenderer>;
     /**
      * An event triggered when fast path rendering is used
      */
     readonly onFastPathRenderObservable: Observable<number>;
     protected _scene: Scene;
-    /** @internal */
-    _renderingManager: RenderingManager;
+    protected _renderingManager: RenderingManager;
     /** @internal */
     _waitingRenderList?: string[];
     protected _currentRefreshId: number;
     protected _refreshRate: number;
     protected _currentApplyByPostProcessSetting: boolean;
+    protected _activeMeshes: SmartArray<AbstractMesh>;
+    protected _activeBoundingBoxes: SmartArray<BoundingBox>;
+    protected _useUBO: boolean;
+    protected _sceneUBO: UniformBuffer;
+    protected _currentSceneUBO: UniformBuffer;
     /**
      * The options used by the object renderer
      */
@@ -147,12 +160,25 @@ export declare class ObjectRenderer {
      * Gets the current value of the refreshId counter
      */
     get currentRefreshId(): number;
+    /**
+     * Gets the array of active meshes
+     * @returns an array of AbstractMesh
+     */
+    getActiveMeshes(): SmartArray<AbstractMesh>;
     /**
      * Sets a specific material to be used to render a mesh/a list of meshes with this object renderer
      * @param mesh mesh or array of meshes
      * @param material material or array of materials to use for this render pass. If undefined is passed, no specific material will be used but the regular material instead (mesh.material). It's possible to provide an array of materials to use a different material for each rendering pass.
      */
     setMaterialForRendering(mesh: AbstractMesh | AbstractMesh[], material?: Material | Material[]): void;
+    /** @internal */
+    _isFrozen: boolean;
+    /** @internal */
+    _freezeActiveMeshesCancel: Nullable<() => void>;
+    /** @internal */
+    _freezeActiveMeshes(freezeMeshes: boolean): void;
+    /** @internal */
+    _unfreezeActiveMeshes(): void;
     /**
      * Instantiates an object renderer.
      * @param name The friendly name of the object renderer
@@ -212,6 +238,10 @@ export declare class ObjectRenderer {
     /** @internal */
     _checkReadiness(): boolean;
     private _prepareRenderingManager;
+    /**
+     * Gets the rendering manager
+     */
+    get renderingManager(): RenderingManager;
     /**
      * 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.

package/Rendering/objectRenderer.js

@@ -2,6 +2,9 @@ import { Observable } from "../Misc/observable.js";
 import { RenderingManager } from "../Rendering/renderingManager.js";
 
 import { _ObserveArray } from "../Misc/arrayTools.js";
+import { _RetryWithInterval } from "../Misc/timingTools.js";
+import { Logger } from "../Misc/logger.js";
+import { SmartArray } from "../Misc/smartArray.js";
 /**
  * A class that renders objects to the currently bound render target.
  * This class only renders objects, and is not concerned with the output texture or post-processing.
@@ -51,6 +54,9 @@ export class ObjectRenderer {
             return;
         }
         this._name = value;
+        if (this._sceneUBO) {
+            this._sceneUBO.name = `Scene ubo for ${this.name}`;
+        }
         if (!this._scene) {
             return;
         }
@@ -72,6 +78,13 @@ export class ObjectRenderer {
     get currentRefreshId() {
         return this._currentRefreshId;
     }
+    /**
+     * Gets the array of active meshes
+     * @returns an array of AbstractMesh
+     */
+    getActiveMeshes() {
+        return this._activeMeshes;
+    }
     /**
      * Sets a specific material to be used to render a mesh/a list of meshes with this object renderer
      * @param mesh mesh or array of meshes
@@ -95,6 +108,47 @@ export class ObjectRenderer {
             }
         }
     }
+    /** @internal */
+    _freezeActiveMeshes(freezeMeshes) {
+        this._freezeActiveMeshesCancel = _RetryWithInterval(() => {
+            return this._checkReadiness();
+        }, () => {
+            this._freezeActiveMeshesCancel = null;
+            if (freezeMeshes) {
+                for (let index = 0; index < this._activeMeshes.length; index++) {
+                    this._activeMeshes.data[index]._freeze();
+                }
+            }
+            this._prepareRenderingManager(0, true);
+            this._isFrozen = true;
+        }, (err, isTimeout) => {
+            this._freezeActiveMeshesCancel = null;
+            if (!isTimeout) {
+                Logger.Error("ObjectRenderer: An unexpected error occurred while waiting for the renderer to be ready.");
+                if (err) {
+                    Logger.Error(err);
+                    if (err.stack) {
+                        Logger.Error(err.stack);
+                    }
+                }
+            }
+            else {
+                Logger.Error(`ObjectRenderer: Timeout while waiting for the renderer to be ready.`);
+                if (err) {
+                    Logger.Error(err);
+                }
+            }
+        });
+    }
+    /** @internal */
+    _unfreezeActiveMeshes() {
+        this._freezeActiveMeshesCancel?.();
+        this._freezeActiveMeshesCancel = null;
+        for (let index = 0; index < this._activeMeshes.length; index++) {
+            this._activeMeshes.data[index]._unFreeze();
+        }
+        this._isFrozen = false;
+    }
     /**
      * Instantiates an object renderer.
      * @param name The friendly name of the object renderer
@@ -159,6 +213,14 @@ export class ObjectRenderer {
          * An event triggered after the rendering group is processed
          */
         this.onAfterRenderingManagerRenderObservable = new Observable();
+        /**
+         * An event triggered when initRender is called
+         */
+        this.onInitRenderingObservable = new Observable();
+        /**
+         * An event triggered when finishRender is called
+         */
+        this.onFinishRenderingObservable = new Observable();
         /**
          * An event triggered when fast path rendering is used
          */
@@ -166,9 +228,19 @@ export class ObjectRenderer {
         this._currentRefreshId = -1;
         this._refreshRate = 1;
         this._currentApplyByPostProcessSetting = false;
+        this._activeMeshes = new SmartArray(256);
+        this._activeBoundingBoxes = new SmartArray(32);
+        /** @internal */
+        this._isFrozen = false;
+        /** @internal */
+        this._freezeActiveMeshesCancel = null;
         this._currentSceneCamera = null;
         this.name = name;
         this._scene = scene;
+        this._useUBO = this._scene.getEngine().supportsUniformBuffers;
+        if (this._useUBO) {
+            this._sceneUBO = this._scene.createSceneUniformBuffer(`Scene ubo for ${this.name}`, false);
+        }
         this.renderList = [];
         this._renderPassIds = [];
         this.options = {
@@ -181,6 +253,7 @@ export class ObjectRenderer {
         // Rendering groups
         this._renderingManager = new RenderingManager(scene);
         this._renderingManager._useSceneAutoClearSetup = true;
+        this._scene.addObjectRenderer(this);
     }
     _releaseRenderPassId() {
         const engine = this._scene.getEngine();
@@ -294,14 +367,21 @@ export class ObjectRenderer {
     initRender(viewportWidth, viewportHeight) {
         const engine = this._scene.getEngine();
         const camera = this.activeCamera ?? this._scene.activeCamera;
+        this.onInitRenderingObservable.notifyObservers(this);
         this._currentSceneCamera = this._scene.activeCamera;
+        if (this._useUBO) {
+            this._currentSceneUBO = this._scene.getSceneUniformBuffer();
+            this._currentSceneUBO.unbindEffect();
+            this._scene.setSceneUniformBuffer(this._sceneUBO);
+        }
         if (camera) {
-            if (camera !== this._scene.activeCamera) {
-                this._scene.setTransformMatrix(camera.getViewMatrix(), camera.getProjectionMatrix(true));
-                this._scene.activeCamera = camera;
-            }
+            this._scene.setTransformMatrix(camera.getViewMatrix(), camera.getProjectionMatrix(true));
+            this._scene.activeCamera = camera;
             engine.setViewport(camera.rigParent ? camera.rigParent.viewport : camera.viewport, viewportWidth, viewportHeight);
         }
+        if (this._useUBO) {
+            this._scene.finalizeSceneUbo();
+        }
         this._defaultRenderListPrepared = false;
     }
     /**
@@ -309,6 +389,9 @@ export class ObjectRenderer {
      */
     finishRender() {
         const scene = this._scene;
+        if (this._useUBO) {
+            this._scene.setSceneUniformBuffer(this._currentSceneUBO);
+        }
         if (this._disableImageProcessing) {
             scene.imageProcessingConfiguration._applyByPostProcess = this._currentApplyByPostProcessSetting;
         }
@@ -320,6 +403,7 @@ export class ObjectRenderer {
             scene.getEngine().setViewport(this._currentSceneCamera.viewport);
         }
         scene.resetCachedMaterial();
+        this.onFinishRenderingObservable.notifyObservers(this);
     }
     /**
      * Renders all the objects (meshes, particles systems, sprites) to the currently bound render target texture.
@@ -334,26 +418,7 @@ export class ObjectRenderer {
         this.onBeforeRenderObservable.notifyObservers(passIndex);
         const fastPath = engine.snapshotRendering && engine.snapshotRenderingMode === 1;
         if (!fastPath) {
-            // Get the list of meshes to render
-            let currentRenderList = null;
-            const defaultRenderList = this.renderList ? this.renderList : scene.getActiveMeshes().data;
-            const defaultRenderListLength = this.renderList ? this.renderList.length : scene.getActiveMeshes().length;
-            if (this.getCustomRenderList) {
-                currentRenderList = this.getCustomRenderList(passIndex, defaultRenderList, defaultRenderListLength);
-            }
-            if (!currentRenderList) {
-                // No custom render list provided, we prepare the rendering for the default list, but check
-                // first if we did not already performed the preparation before so as to avoid re-doing it several times
-                if (!this._defaultRenderListPrepared) {
-                    this._prepareRenderingManager(defaultRenderList, defaultRenderListLength, !this.renderList || this.forceLayerMaskCheck);
-                    this._defaultRenderListPrepared = true;
-                }
-                currentRenderList = defaultRenderList;
-            }
-            else {
-                // Prepare the rendering for the custom render list provided
-                this._prepareRenderingManager(currentRenderList, currentRenderList.length, this.forceLayerMaskCheck);
-            }
+            const currentRenderList = this._prepareRenderingManager(passIndex);
             this.onBeforeRenderingManagerRenderObservable.notifyObservers(passIndex);
             this._renderingManager.render(this.customRenderFunction, currentRenderList, this.renderParticles, this.renderSprites);
             this.onAfterRenderingManagerRenderObservable.notifyObservers(passIndex);
@@ -379,8 +444,8 @@ export class ObjectRenderer {
         const numPasses = this.options.numPasses;
         for (let passIndex = 0; passIndex < numPasses && returnValue; passIndex++) {
             let currentRenderList = null;
-            const defaultRenderList = this.renderList ? this.renderList : scene.getActiveMeshes().data;
-            const defaultRenderListLength = this.renderList ? this.renderList.length : scene.getActiveMeshes().length;
+            const defaultRenderList = this.renderList ? this.renderList : scene.frameGraph ? scene.meshes : scene.getActiveMeshes().data;
+            const defaultRenderListLength = this.renderList ? this.renderList.length : scene.frameGraph ? scene.meshes.length : scene.getActiveMeshes().length;
             engine.currentRenderPassId = this._renderPassIds[passIndex];
             this.onBeforeRenderObservable.notifyObservers(passIndex);
             if (this.getCustomRenderList) {
@@ -423,13 +488,52 @@ export class ObjectRenderer {
         engine.currentRenderPassId = currentRenderPassId;
         return returnValue;
     }
-    _prepareRenderingManager(currentRenderList, currentRenderListLength, checkLayerMask) {
+    _prepareRenderingManager(passIndex = 0, winterIsComing = false) {
         const scene = this._scene;
+        // Get the list of meshes to dispatch to the rendering manager
+        let currentRenderList = null;
+        let currentRenderListLength = 0;
+        let checkLayerMask = false;
+        const defaultRenderList = this.renderList ? this.renderList : scene.frameGraph ? scene.meshes : scene.getActiveMeshes().data;
+        const defaultRenderListLength = this.renderList ? this.renderList.length : scene.frameGraph ? scene.meshes.length : scene.getActiveMeshes().length;
+        if (this.getCustomRenderList) {
+            currentRenderList = this.getCustomRenderList(passIndex, defaultRenderList, defaultRenderListLength);
+        }
+        if (!currentRenderList) {
+            // No custom render list provided, we prepare the rendering for the default list, but check
+            // first if we did not already performed the preparation (in this frame) before so as to avoid re-doing it several times
+            if (this._defaultRenderListPrepared && !winterIsComing) {
+                return defaultRenderList;
+            }
+            this._defaultRenderListPrepared = true;
+            currentRenderList = defaultRenderList;
+            currentRenderListLength = defaultRenderListLength;
+            checkLayerMask = !this.renderList || this.forceLayerMaskCheck;
+        }
+        else {
+            // Prepare the rendering for the custom render list provided
+            currentRenderListLength = currentRenderList.length;
+            checkLayerMask = this.forceLayerMaskCheck;
+        }
         const camera = scene.activeCamera; // note that at this point, scene.activeCamera == this.activeCamera if defined, because initRender() has been called before
         const cameraForLOD = this.cameraForLOD ?? camera;
+        // The cast to "any" is to avoid an error in ES6 in case you don't import boundingBoxRenderer
+        const boundingBoxRenderer = scene.getBoundingBoxRenderer?.();
+        if (scene._activeMeshesFrozen && this._isFrozen) {
+            this._renderingManager.resetSprites();
+            if (this.enableBoundingBoxRendering && boundingBoxRenderer) {
+                boundingBoxRenderer.reset();
+                for (let i = 0; i < this._activeBoundingBoxes.length; i++) {
+                    const boundingBox = this._activeBoundingBoxes.data[i];
+                    boundingBoxRenderer.renderList.push(boundingBox);
+                }
+            }
+            return currentRenderList;
+        }
         this._renderingManager.reset();
-        const boundingBoxRenderer = scene.getBoundingBoxRenderer();
-        boundingBoxRenderer && boundingBoxRenderer.reset();
+        this._activeMeshes.reset();
+        this._activeBoundingBoxes.reset();
+        this.enableBoundingBoxRendering && boundingBoxRenderer && boundingBoxRenderer.reset();
         const sceneRenderId = scene.getRenderId();
         const currentFrameId = scene.getFrameId();
         for (let meshIndex = 0; meshIndex < currentRenderListLength; meshIndex++) {
@@ -480,10 +584,12 @@ export class ObjectRenderer {
                     isMasked = false;
                 }
                 if (mesh.isEnabled() && mesh.isVisible && mesh.subMeshes && !isMasked) {
+                    this._activeMeshes.push(mesh);
+                    meshToRender._internalAbstractMeshDataInfo._wasActiveLastFrame = true;
                     if (meshToRender !== mesh) {
                         meshToRender._activate(sceneRenderId, true);
                     }
-                    this.enableBoundingBoxRendering && boundingBoxRenderer && boundingBoxRenderer._preActiveMesh(meshToRender);
+                    this.enableBoundingBoxRendering && boundingBoxRenderer && boundingBoxRenderer._preActiveMesh(mesh);
                     if (mesh._activate(sceneRenderId, true) && mesh.subMeshes.length) {
                         if (!mesh.isAnInstance) {
                             meshToRender._internalAbstractMeshDataInfo._onlyForInstancesIntermediate = false;
@@ -497,7 +603,7 @@ export class ObjectRenderer {
                         scene._prepareSkeleton(meshToRender);
                         for (let subIndex = 0; subIndex < meshToRender.subMeshes.length; subIndex++) {
                             const subMesh = meshToRender.subMeshes[subIndex];
-                            this.enableBoundingBoxRendering && boundingBoxRenderer && boundingBoxRenderer._evaluateSubMesh(meshToRender, subMesh);
+                            this.enableBoundingBoxRendering && boundingBoxRenderer && boundingBoxRenderer._evaluateSubMesh(mesh, subMesh);
                             this._renderingManager.dispatch(subMesh, meshToRender);
                         }
                     }
@@ -505,15 +611,32 @@ export class ObjectRenderer {
                 }
             }
         }
-        const particleSystems = this.particleSystemList || scene.particleSystems;
-        for (let particleIndex = 0; particleIndex < particleSystems.length; particleIndex++) {
-            const particleSystem = particleSystems[particleIndex];
-            const emitter = particleSystem.emitter;
-            if (!particleSystem.isStarted() || !emitter || (emitter.position && !emitter.isEnabled())) {
-                continue;
+        if (this.enableBoundingBoxRendering && boundingBoxRenderer && winterIsComing) {
+            for (let i = 0; i < boundingBoxRenderer.renderList.length; i++) {
+                const boundingBox = boundingBoxRenderer.renderList.data[i];
+                this._activeBoundingBoxes.push(boundingBox);
+            }
+        }
+        if (this._scene.particlesEnabled) {
+            this._scene.onBeforeParticlesRenderingObservable.notifyObservers(this._scene);
+            const particleSystems = this.particleSystemList || scene.particleSystems;
+            for (let particleIndex = 0; particleIndex < particleSystems.length; particleIndex++) {
+                const particleSystem = particleSystems[particleIndex];
+                const emitter = particleSystem.emitter;
+                if (!particleSystem.isStarted() || !emitter || (emitter.position && !emitter.isEnabled())) {
+                    continue;
+                }
+                this._renderingManager.dispatchParticles(particleSystem);
             }
-            this._renderingManager.dispatchParticles(particleSystem);
+            this._scene.onAfterParticlesRenderingObservable.notifyObservers(this._scene);
         }
+        return currentRenderList;
+    }
+    /**
+     * Gets the rendering manager
+     */
+    get renderingManager() {
+        return this._renderingManager;
     }
     /**
      * Overrides the default sort function applied in the rendering group to prepare the meshes.
@@ -569,6 +692,9 @@ export class ObjectRenderer {
         this.onFastPathRenderObservable.clear();
         this._releaseRenderPassId();
         this.renderList = null;
+        this._sceneUBO?.dispose();
+        this._sceneUBO = undefined;
+        this._scene.removeObjectRenderer(this);
     }
     /** @internal */
     _rebuild() {