@onerjs/core 8.56.4 → 9.0.1

package/scene.pure.js

@@ -68,6 +68,23 @@ export class Scene {
     static CollisionCoordinatorFactory() {
         throw _WarnImport("DefaultCollisionCoordinator");
     }
+    /**
+     * Executes a synchronous action without allowing it to weaken an existing entity-collection block.
+     * @param blockEntityCollection whether the action requires entity collection to be blocked
+     * @param action the action to execute
+     * @returns the action result
+     * @internal
+     */
+    _executeWithBlockedEntityCollection(blockEntityCollection, action) {
+        const previousBlockEntityCollection = this._blockEntityCollection;
+        this._blockEntityCollection = previousBlockEntityCollection || blockEntityCollection;
+        try {
+            return action();
+        }
+        finally {
+            this._blockEntityCollection = previousBlockEntityCollection;
+        }
+    }
     /**
      * Defines the color used to clear the render buffer (Default is (0.2, 0.2, 0.3, 1.0))
      */
@@ -486,6 +503,31 @@ export class Scene {
     get prePass() {
         return !!this.prePassRenderer && this.prePassRenderer.defaultRT.enabled;
     }
+    /**
+     * Flag indicating if we need to store previous matrices when rendering.
+     * Setting it directly controls the manual requirement; renderers can independently request previous matrices.
+     */
+    get needsPreviousWorldMatrices() {
+        return this._needsPreviousWorldMatrices;
+    }
+    set needsPreviousWorldMatrices(value) {
+        this._manualPreviousWorldMatrices = value;
+        this._needsPreviousWorldMatrices = value || this._previousWorldMatricesOwners.size > 0;
+    }
+    /**
+     * @internal
+     * @param owner The renderer or frame graph requesting previous world matrices
+     * @param required Whether that owner still needs previous world matrices
+     */
+    _setPreviousWorldMatricesRequired(owner, required) {
+        if (required) {
+            this._previousWorldMatricesOwners.add(owner);
+        }
+        else {
+            this._previousWorldMatricesOwners.delete(owner);
+        }
+        this._needsPreviousWorldMatrices = this._manualPreviousWorldMatrices || this._previousWorldMatricesOwners.size > 0;
+    }
     /**
      * Gets or sets a boolean indicating if shadows are enabled on this scene
      */
@@ -1208,10 +1250,9 @@ export class Scene {
          * (Default is 1000)
          */
         this.fogEnd = 1000.0;
-        /**
-         * Flag indicating if we need to store previous matrices when rendering
-         */
-        this.needsPreviousWorldMatrices = false;
+        this._needsPreviousWorldMatrices = false;
+        this._manualPreviousWorldMatrices = false;
+        this._previousWorldMatricesOwners = new Set();
         // Lights
         this._shadowsEnabled = true;
         this._lightsEnabled = true;
@@ -1345,6 +1386,20 @@ export class Scene {
         this._softwareSkinnedMeshes = new SmartArrayNoDuplicate(32);
         /** @internal */
         this._activeAnimatables = new Array();
+        /**
+         * @internal
+         * The writes of the runtime animations since the last animation step's bindings were processed - between steps
+         * and in the current or last step - in the order they were made: the first _animationWriteCount entries, the rest
+         * being reused. What the animations wrote, kept whatever became of them since, for as long as the bindings they
+         * registered are pending or just processed.
+         */
+        this._animationWrites = new Array();
+        /** @internal How many of _animationWrites are in use. */
+        this._animationWriteCount = 0;
+        /** @internal How many of them, at the front, the last animation step's bindings processed; the next step lets them go. */
+        this._animationStepWriteCount = 0;
+        /** @internal Whether the current or last animation step evaluated the active animatables, which none does while animations are disabled. */
+        this._animationStepEvaluated = false;
         this._transformMatrix = Matrix.Zero();
         /**
          * Gets or sets a boolean indicating if lights must be sorted by priority (off by default)
@@ -4612,6 +4667,7 @@ export class Scene {
                 this._processSubCameras(this.activeCamera, !!this.activeCamera.outputRenderTarget);
             }
         }
+        this._inputManager._updateMeshUnderPointer();
         // Intersection checks
         this._checkIntersections();
         // Executes the after render stage actions.
@@ -4722,6 +4778,9 @@ export class Scene {
         this._renderTargets.dispose();
         this._materialsRenderTargets.dispose();
         this._registeredForLateAnimationBindings.dispose();
+        this._animationWrites.length = 0;
+        this._animationWriteCount = 0;
+        this._animationStepWriteCount = 0;
         this._meshesForIntersections.dispose();
         this._toBeDisposed.length = 0;
         // Abort active requests