@babylonjs/core 9.12.0 → 9.13.0

package/Engines/thinNativeEngine.pure.js

@@ -1,4 +1,5 @@
 /** This file must only contain pure code and pure imports */
+import { RegisterBufferAlign } from "../Buffers/buffer.align.pure.js";
 import { InternalTexture } from "../Materials/Textures/internalTexture.js";
 import { DataBuffer } from "../Buffers/dataBuffer.js";
 import { Observable } from "../Misc/observable.pure.js";
@@ -132,6 +133,12 @@ export class ThinNativeEngine extends ThinEngine {
      * @internal
      */
     _initializeNativeEngine(adaptToDeviceRatio) {
+        // ThinNativeEngine relies on VertexBuffer.effective{Buffer,ByteOffset,ByteStride}
+        // (defined in Buffers/buffer.align.pure) to bind vertex attributes through
+        // recordVertexBuffer. Register the side effect here so the engine is usable
+        // on its own without callers having to remember to import the wrapper module.
+        // The registration is idempotent.
+        RegisterBufferAlign();
         this._engine = new _native.Engine({
             version: AbstractEngine.Version,
             nonFloatVertexBuffers: true,
@@ -141,7 +148,8 @@ export class ThinNativeEngine extends ThinEngine {
         this._frameStats = { gpuTimeNs: Number.NaN };
         this._boundBuffersVertexArray = null;
         this._currentDepthTest = _native.Engine.DEPTH_TEST_LEQUAL;
-        this._stencilTest;
+        this._depthTestEnabled = true;
+        this._stencilTest = false;
         this._stencilMask = 255;
         this._stencilFunc = 519;
         this._stencilFuncRef = 0;
@@ -538,6 +546,7 @@ export class ThinNativeEngine extends ThinEngine {
             return;
         }
         // Apply states
+        this._flushDepthTestState();
         this._drawCalls.addCount(1, false);
         if (instancesCount) {
             this._commandBufferEncoder.startEncodingCommand(_native.Engine.COMMAND_DRAWINDEXEDINSTANCED);
@@ -566,6 +575,7 @@ export class ThinNativeEngine extends ThinEngine {
             return;
         }
         // Apply states
+        this._flushDepthTestState();
         this._drawCalls.addCount(1, false);
         if (instancesCount) {
             this._commandBufferEncoder.startEncodingCommand(_native.Engine.COMMAND_DRAWINSTANCED);
@@ -816,10 +826,28 @@ export class ThinNativeEngine extends ThinEngine {
      * @param enable defines the state to set
      */
     setDepthBuffer(enable) {
+        // Keep the shared depth-culling state in sync so that code paths which toggle
+        // depth testing through engine.depthCullingState.depthTest (for example
+        // EffectRenderer.applyEffectWrapper) are also honored on the native side. The
+        // native draw path does not go through the WebGL applyStates() flush, so the
+        // value is reconciled in _flushDepthTestState() right before each draw.
+        this._depthCullingState.depthTest = enable;
+        this._encodeDepthTest(enable);
+    }
+    _encodeDepthTest(enable) {
+        this._depthTestEnabled = enable;
         this._commandBufferEncoder.startEncodingCommand(_native.Engine.COMMAND_SETDEPTHTEST);
         this._commandBufferEncoder.encodeCommandArgAsUInt32(enable ? this._currentDepthTest : _native.Engine.DEPTH_TEST_ALWAYS);
         this._commandBufferEncoder.finishEncodingCommand();
     }
+    _flushDepthTestState() {
+        // Unlike the WebGL engine, the native engine does not call applyStates() before
+        // a draw, so depth-test toggles made directly on engine.depthCullingState are
+        // flushed here to match the cross-engine contract.
+        if (this._depthCullingState.depthTest !== this._depthTestEnabled) {
+            this._encodeDepthTest(this._depthCullingState.depthTest);
+        }
+    }
     /**
      * Gets a boolean indicating if depth writing is enabled
      * @returns the current depth writing state
@@ -877,9 +905,13 @@ export class ThinNativeEngine extends ThinEngine {
                 break;
         }
         this._currentDepthTest = nativeDepthFunc;
-        this._commandBufferEncoder.startEncodingCommand(_native.Engine.COMMAND_SETDEPTHTEST);
-        this._commandBufferEncoder.encodeCommandArgAsUInt32(this._currentDepthTest);
-        this._commandBufferEncoder.finishEncodingCommand();
+        // Route through _encodeDepthTest so the tracked _depthTestEnabled state stays in
+        // sync with the encoded command. Because COMMAND_SETDEPTHTEST conflates the
+        // compare function and the enable bit (DEPTH_TEST_ALWAYS == disabled), encoding
+        // the new function directly here would silently re-enable depth testing while
+        // depth testing is logically disabled; _encodeDepthTest honors the current
+        // depthCullingState.depthTest and only emits the new function when enabled.
+        this._encodeDepthTest(this._depthCullingState.depthTest);
     }
     /**
      * Enable or disable depth writing
@@ -1555,6 +1587,13 @@ export class ThinNativeEngine extends ThinEngine {
         internalTexture.baseHeight = this._engine.getTextureHeight(texture);
         internalTexture.width = internalTexture.baseWidth;
         internalTexture.height = internalTexture.baseHeight;
+        if (this._engine.getTextureLayerCount) {
+            const layerCount = this._engine.getTextureLayerCount(texture);
+            if (layerCount > 1) {
+                internalTexture.is2DArray = true;
+                internalTexture.baseDepth = internalTexture.depth = layerCount;
+            }
+        }
         internalTexture.isReady = true;
         internalTexture.useMipMaps = hasMipMaps;
         this.updateTextureSamplingMode(samplingMode, internalTexture);
@@ -1589,6 +1628,13 @@ export class ThinNativeEngine extends ThinEngine {
         if (newWidth !== internalTexture.baseWidth || newHeight !== internalTexture.baseHeight) {
             throw new Error(`updateWrappedNativeTexture: new handle dimensions (${newWidth}x${newHeight}) must match the wrapped texture's dimensions (${internalTexture.baseWidth}x${internalTexture.baseHeight}).`);
         }
+        if (this._engine.getTextureLayerCount) {
+            const newLayerCount = this._engine.getTextureLayerCount(texture);
+            const oldLayerCount = internalTexture.is2DArray ? internalTexture.depth : 1;
+            if (newLayerCount !== oldLayerCount) {
+                throw new Error(`updateWrappedNativeTexture: new handle layer count (${newLayerCount}) must match the wrapped texture's layer count (${oldLayerCount}).`);
+            }
+        }
         // Pre-validate before mutating any state so a thrown precondition leaves the InternalTexture untouched.
         // Note: rtWrapper.texture only returns _textures[0]; walk every attachment to catch the multi-RT case where
         // the wrapped texture is at index > 0.