@onerjs/core 8.53.5 → 8.53.6

package/Engines/thinNativeEngine.d.ts

@@ -1,3 +1,2 @@
 export * from "./thinNativeEngine.pure.js";
 export * from "./thinNativeEngine.types.js";
-import "../Buffers/buffer.align.js";

package/Engines/thinNativeEngine.js

@@ -1,4 +1,3 @@
 export * from "./thinNativeEngine.pure.js";
 export * from "./thinNativeEngine.types.js";
-import "../Buffers/buffer.align.js";
 //# sourceMappingURL=thinNativeEngine.js.map

package/Engines/thinNativeEngine.js.map

@@ -1 +1 @@
-{"version":3,"file":"thinNativeEngine.js","sourceRoot":"","sources":["../../../../dev/core/src/Engines/thinNativeEngine.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AAEzC,OAAO,yBAAyB,CAAC","sourcesContent":["export * from \"./thinNativeEngine.pure\";\nexport * from \"./thinNativeEngine.types\";\n\nimport \"../Buffers/buffer.align\";\n"]}
+{"version":3,"file":"thinNativeEngine.js","sourceRoot":"","sources":["../../../../dev/core/src/Engines/thinNativeEngine.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC","sourcesContent":["export * from \"./thinNativeEngine.pure\";\nexport * from \"./thinNativeEngine.types\";\n"]}

package/Engines/thinNativeEngine.pure.d.ts

@@ -7,6 +7,7 @@ import { type Effect } from "../Materials/effect.pure.js";
 import { DataBuffer } from "../Buffers/dataBuffer.js";
 import { type RenderTargetCreationOptions, type TextureSize, type DepthTextureCreationOptions, type InternalTextureCreationOptions } from "../Materials/Textures/textureCreationOptions.js";
 import { type IPipelineContext } from "./IPipelineContext.js";
+import { type IMultiRenderTargetOptions } from "../Materials/Textures/multiRenderTarget.pure.js";
 import { type IColor3Like, type IColor4Like, type IViewportLike } from "../Maths/math.like.js";
 import { type ISceneLike } from "./abstractEngine.pure.js";
 import { ThinEngine } from "./thinEngine.pure.js";
@@ -17,6 +18,7 @@ import { type IStencilState } from "../States/IStencilState.js";
 import { type RenderTargetWrapper } from "./renderTargetWrapper.js";
 import { type NativeData, NativeDataStream } from "./Native/nativeDataStream.js";
 import { type INative, type INativeEngine, type NativeFramebuffer, type NativeTexture } from "./Native/nativeInterfaces.js";
+import { NativeRenderTargetWrapper } from "./Native/nativeRenderTargetWrapper.js";
 import { type IHardwareTextureWrapper } from "../Materials/Textures/hardwareTextureWrapper.js";
 import { type _IShaderProcessingContext } from "./Processors/shaderProcessingOptions.js";
 import { type ShaderLanguage } from "../Materials/shaderLanguage.js";
@@ -65,6 +67,7 @@ export declare class ThinNativeEngine extends ThinEngine {
     private _frameStats;
     private _boundBuffersVertexArray;
     private _currentDepthTest;
+    private _depthTestEnabled;
     private _stencilTest;
     private _stencilMask;
     private _stencilFunc;
@@ -215,6 +218,9 @@ export declare class ThinNativeEngine extends ThinEngine {
      * @param enable defines the state to set
      */
     setDepthBuffer(enable: boolean): void;
+    private _encodeDepthTest;
+    private _flushDepthTestState;
+    applyStates(): void;
     /**
      * Gets a boolean indicating if depth writing is enabled
      * @returns the current depth writing state
@@ -466,6 +472,27 @@ export declare class ThinNativeEngine extends ThinEngine {
         height: number;
         depth: number;
     }, options: boolean | RenderTargetCreationOptions): RenderTargetWrapper;
+    createRenderTargetCubeTexture(size: number, options?: RenderTargetCreationOptions): RenderTargetWrapper;
+    createMultipleRenderTarget(size: TextureSize, options: IMultiRenderTargetOptions, _initializeBuffers?: boolean): RenderTargetWrapper;
+    /**
+     * Creates (or recreates) the native framebuffer of a multi render target from the color attachment
+     * textures currently held by the wrapper. bgfx binds a fixed attachment set when a framebuffer is
+     * created and cannot re-point an individual attachment the way GL's framebufferTexture2D can, so the
+     * whole framebuffer has to be recreated whenever an attachment is swapped after creation (e.g. the OIT
+     * depth-peeling renderer replaces every attachment via MultiRenderTarget.setInternalTexture).
+     * @param rtWrapper The multi render target wrapper to build the framebuffer for.
+     * @internal
+     */
+    _createMultiRenderTargetFramebuffer(rtWrapper: NativeRenderTargetWrapper): void;
+    generateMipMapsForCubemap(_texture: InternalTexture, _unbind?: boolean): void;
+    bindAttachments(_attachments: number[]): void;
+    buildTextureLayout(textureStatus: boolean[], _backBufferLayout?: boolean): number[];
+    restoreSingleAttachment(): void;
+    restoreSingleAttachmentForRenderTarget(): void;
+    generateMipMapsMultiFramebuffer(_texture: RenderTargetWrapper): void;
+    resolveMultiFramebuffer(_texture: RenderTargetWrapper): void;
+    unBindMultiColorAttachmentFramebuffer(_rtWrapper: RenderTargetWrapper, _disableGenerateMipMaps?: boolean, onBeforeUnbind?: () => void): void;
+    updateMultipleRenderTargetTextureSampleCount(rtWrapper: Nullable<RenderTargetWrapper>, samples: number, _initializeBuffers?: boolean): number;
     updateRenderTargetTextureSampleCount(rtWrapper: RenderTargetWrapper, samples: number): number;
     updateTextureSamplingMode(samplingMode: number, texture: InternalTexture): void;
     bindFramebuffer(texture: RenderTargetWrapper, faceIndex?: number, requiredWidth?: number, requiredHeight?: number, forceFullscreenViewport?: boolean): void;

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;
@@ -175,6 +183,10 @@ export class ThinNativeEngine extends ThinEngine {
         this._webGLVersion = 2;
         this.disableUniformBuffers = true;
         this._shaderPlatformName = "NATIVE";
+        // Babylon Native is not WebGL and has no _gl context. Report a distinct engine name (like
+        // WebGPU reports "WebGPU") so application/feature code that branches on engine.name === "WebGL"
+        // to touch the WebGL-only _gl context skips the native engine instead of dereferencing null.
+        this._name = "Native";
         // TODO: Initialize this more correctly based on the hardware capabilities.
         // Init caps
         this._caps = {
@@ -212,7 +224,7 @@ export class ThinNativeEngine extends ThinEngine {
             textureHalfFloatRender: true,
             textureLOD: true,
             texelFetch: false,
-            drawBuffersExtension: false,
+            drawBuffersExtension: true,
             depthTextureExtension: false,
             vertexArrayObject: true,
             instancedArrays: true,
@@ -411,8 +423,16 @@ export class ThinNativeEngine extends ThinEngine {
         return null;
     }
     clear(color, backBuffer, depth, stencil = false, stencilClearValue = 0) {
-        if (this.useReverseDepthBuffer) {
-            throw new Error("reverse depth buffer is not currently implemented");
+        if (depth && this.useReverseDepthBuffer) {
+            // Reverse-Z: the scene is rendered with a flipped projection (near maps to 1, far to 0), so the
+            // depth buffer is cleared to 0 and the comparison must accept greater values. The WebGL engine
+            // sets depthCullingState.depthFunc = GEQUAL here and relies on applyStates() running the depth
+            // comparison to the GL context before each draw. The native draw path does not call applyStates()
+            // (only depth-test enable/disable is reconciled in _flushDepthTestState()), so setting the shared
+            // state alone would never reach the backend. Route the comparison through the native command path
+            // as well -- mirroring the WebGPU engine's clear path, which calls setDepthFunctionToGreaterOrEqual().
+            this._depthCullingState.depthFunc = 518;
+            this.setDepthFunction(518);
         }
         this._commandBufferEncoder.startEncodingCommand(_native.Engine.COMMAND_CLEAR);
         this._commandBufferEncoder.encodeCommandArgAsUInt32(backBuffer && color ? 1 : 0);
@@ -421,7 +441,7 @@ export class ThinNativeEngine extends ThinEngine {
         this._commandBufferEncoder.encodeCommandArgAsFloat32(color ? color.b : 0);
         this._commandBufferEncoder.encodeCommandArgAsFloat32(color ? color.a : 1);
         this._commandBufferEncoder.encodeCommandArgAsUInt32(depth ? 1 : 0);
-        this._commandBufferEncoder.encodeCommandArgAsFloat32(1);
+        this._commandBufferEncoder.encodeCommandArgAsFloat32(depth && this.useReverseDepthBuffer ? 0 : 1);
         this._commandBufferEncoder.encodeCommandArgAsUInt32(stencil ? 1 : 0);
         this._commandBufferEncoder.encodeCommandArgAsUInt32(stencilClearValue);
         this._commandBufferEncoder.finishEncodingCommand();
@@ -538,6 +558,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 +587,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 +838,41 @@ 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);
+        }
+    }
+    applyStates() {
+        // The base ThinEngine.applyStates() drives the WebGL context (this._gl) directly, which is null on
+        // Native. Flush the depth-culling state through the native command path instead, so callers that
+        // mutate engine.depthCullingState directly and then call applyStates() (e.g. the depth-peeling / OIT
+        // renderer) take effect. Alpha and stencil state are applied on Native via their dedicated setters
+        // (setAlphaMode / setStencil*), which encode their commands when called.
+        const depthCullingState = this._depthCullingState;
+        if (depthCullingState.depthFunc !== null && depthCullingState.depthFunc !== undefined) {
+            this.setDepthFunction(depthCullingState.depthFunc);
+        }
+        this.setDepthBuffer(depthCullingState.depthTest);
+        this.setDepthWrite(depthCullingState.depthMask);
+    }
     /**
      * Gets a boolean indicating if depth writing is enabled
      * @returns the current depth writing state
@@ -877,9 +930,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 +1612,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 +1653,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.
@@ -1808,6 +1879,273 @@ export class ThinNativeEngine extends ThinEngine {
         rtWrapper.setTextures(texture);
         return rtWrapper;
     }
+    createRenderTargetCubeTexture(size, options) {
+        const rtWrapper = this._createHardwareRenderTargetWrapper(false, true, size);
+        let generateDepthBuffer = true;
+        let generateStencilBuffer = false;
+        let generateMipMaps = false;
+        let type = 0;
+        let samplingMode = 3;
+        let format = 5;
+        let samples = 1;
+        let label;
+        if (options !== undefined && typeof options === "object") {
+            generateDepthBuffer = options.generateDepthBuffer ?? true;
+            generateStencilBuffer = !!options.generateStencilBuffer;
+            generateMipMaps = !!options.generateMipMaps;
+            type = options.type ?? 0;
+            samplingMode = options.samplingMode ?? 3;
+            format = options.format ?? 5;
+            samples = options.samples ?? 1;
+            label = options.label;
+        }
+        // Match _createInternalTexture: float/half-float RTTs that the platform can't linearly filter fall
+        // back to NEAREST so the cube RTT never carries an unsupported sampling mode.
+        if (type === 1 && !this._caps.textureFloatLinearFiltering) {
+            samplingMode = 1;
+        }
+        else if (type === 2 && !this._caps.textureHalfFloatLinearFiltering) {
+            samplingMode = 1;
+        }
+        if (type === 1 && !this._caps.textureFloat) {
+            type = 0;
+            Logger.Warn("Float textures are not supported. Type forced to TEXTURETYPE_UNSIGNED_BYTE");
+        }
+        const texture = new InternalTexture(this, 5 /* InternalTextureSource.RenderTarget */);
+        texture.isCube = true;
+        texture.baseWidth = size;
+        texture.baseHeight = size;
+        texture.width = size;
+        texture.height = size;
+        texture.isReady = true;
+        texture.samples = samples;
+        texture.generateMipMaps = generateMipMaps;
+        texture.samplingMode = samplingMode;
+        texture.type = type;
+        texture.format = format;
+        texture.label = label;
+        const nativeTexture = texture._hardwareTexture.underlyingResource;
+        const nativeTextureFormat = getNativeTextureFormat(format, type);
+        // See the createRenderTargetTexture MSAA/mips note: avoid the mips + samples combo on bgfx.
+        const hasMips = samples > 1 ? false : generateMipMaps;
+        this._engine.initializeTexture(nativeTexture, size, size, hasMips, nativeTextureFormat, /*renderTarget*/ true, /*srgb*/ false, samples, /*isCube*/ true);
+        this._setTextureSampling(nativeTexture, getNativeSamplingMode(samplingMode));
+        // The native engine cannot render to all six faces through one framebuffer, so create one
+        // framebuffer per face (the C++ side binds the matching cube layer); bindFramebuffer(faceIndex)
+        // then selects the right one.
+        const framebuffers = [];
+        for (let face = 0; face < 6; face++) {
+            framebuffers.push(this._engine.createFrameBuffer(nativeTexture, size, size, generateStencilBuffer, generateDepthBuffer, samples, face));
+        }
+        rtWrapper._framebuffers = framebuffers;
+        rtWrapper._generateDepthBuffer = generateDepthBuffer;
+        rtWrapper._generateStencilBuffer = generateStencilBuffer;
+        rtWrapper._samples = samples;
+        rtWrapper.setTextures(texture);
+        // Track the hand-built cube RTT texture the same way _createInternalTexture tracks 2D textures so it
+        // participates in engine-wide lifecycle management (dispose iteration, context rebuild, stats).
+        this._internalTexturesCache.push(texture);
+        return rtWrapper;
+    }
+    createMultipleRenderTarget(size, options, _initializeBuffers = true) {
+        const rtWrapper = this._createHardwareRenderTargetWrapper(true, false, size);
+        let generateMipMaps = false;
+        let generateDepthBuffer = true;
+        let generateStencilBuffer = false;
+        let generateDepthTexture = false;
+        let textureCount = 1;
+        let samples = 1;
+        let types = [];
+        let samplingModes = [];
+        let formats = [];
+        let targets = [];
+        let faceIndex = [];
+        let layerIndex = [];
+        let labels = [];
+        let dontCreateTextures = false;
+        if (options !== undefined) {
+            generateMipMaps = options.generateMipMaps ?? false;
+            generateDepthBuffer = options.generateDepthBuffer ?? true;
+            generateStencilBuffer = options.generateStencilBuffer ?? false;
+            generateDepthTexture = options.generateDepthTexture ?? false;
+            textureCount = options.textureCount ?? 1;
+            samples = options.samples ?? 1;
+            types = options.types || types;
+            samplingModes = options.samplingModes || samplingModes;
+            formats = options.formats || formats;
+            targets = options.targetTypes || targets;
+            faceIndex = options.faceIndex || faceIndex;
+            layerIndex = options.layerIndex || layerIndex;
+            labels = options.labels || labels;
+            dontCreateTextures = options.dontCreateTextures ?? false;
+        }
+        rtWrapper.label = options?.label ?? "MultiRenderTargetWrapper";
+        const width = size.width ?? size;
+        const height = size.height ?? size;
+        const textures = [];
+        const attachments = [];
+        for (let i = 0; i < textureCount; i++) {
+            const samplingMode = samplingModes[i] || 3;
+            let type = types[i] || 0;
+            const format = formats[i] || 5;
+            const target = targets[i] || 3553;
+            attachments.push(i);
+            // target === -1 marks an attachment with no engine-created texture; dontCreateTextures defers them.
+            if (target === -1 || dontCreateTextures) {
+                continue;
+            }
+            if (type === 1 && !this._caps.textureFloat) {
+                type = 0;
+                Logger.Warn("Float textures are not supported. Multi render target attachment forced to TEXTURETYPE_UNSIGNED_BYTE type");
+            }
+            const texture = new InternalTexture(this, 6 /* InternalTextureSource.MultiRenderTarget */);
+            const nativeTexture = texture._hardwareTexture.underlyingResource;
+            if (target !== 3553) {
+                // Native multi render targets currently only attach 2D color textures; cube / 2D-array
+                // attachments are created as 2D so the attachment still exists and mrt.textures[i] is populated.
+                Logger.Warn("Multi render target attachment target " + target + " is not supported on Native; using a 2D texture.");
+            }
+            // bgfx auto-generates the mip chain on resolve; avoid the mips + MSAA combo (see createRenderTargetTexture).
+            const hasMips = samples > 1 ? false : generateMipMaps;
+            this._engine.initializeTexture(nativeTexture, width, height, hasMips, getNativeTextureFormat(format, type), /*renderTarget*/ true, /*srgb*/ false, samples);
+            this._setTextureSampling(nativeTexture, getNativeSamplingMode(samplingMode));
+            texture.baseWidth = width;
+            texture.baseHeight = height;
+            texture.width = width;
+            texture.height = height;
+            texture.isReady = true;
+            texture.samples = samples;
+            texture.generateMipMaps = generateMipMaps;
+            texture.samplingMode = samplingMode;
+            texture.type = type;
+            texture.format = format;
+            texture.label = labels[i] ?? rtWrapper.label + "-Texture" + i;
+            textures[i] = texture;
+            this._internalTexturesCache.push(texture);
+        }
+        rtWrapper._generateDepthBuffer = generateDepthBuffer || generateDepthTexture;
+        rtWrapper._generateStencilBuffer = generateStencilBuffer;
+        rtWrapper._samples = samples;
+        rtWrapper._attachments = attachments;
+        rtWrapper.setTextures(textures);
+        rtWrapper.setLayerAndFaceIndices(layerIndex, faceIndex);
+        // The native engine creates one framebuffer with all the color attachments (bgfx writes to every
+        // attachment of the bound framebuffer, so there is no drawBuffers equivalent to issue per draw).
+        this._createMultiRenderTargetFramebuffer(rtWrapper);
+        return rtWrapper;
+    }
+    /**
+     * Creates (or recreates) the native framebuffer of a multi render target from the color attachment
+     * textures currently held by the wrapper. bgfx binds a fixed attachment set when a framebuffer is
+     * created and cannot re-point an individual attachment the way GL's framebufferTexture2D can, so the
+     * whole framebuffer has to be recreated whenever an attachment is swapped after creation (e.g. the OIT
+     * depth-peeling renderer replaces every attachment via MultiRenderTarget.setInternalTexture).
+     * @param rtWrapper The multi render target wrapper to build the framebuffer for.
+     * @internal
+     */
+    _createMultiRenderTargetFramebuffer(rtWrapper) {
+        const textures = rtWrapper.textures;
+        if (!textures) {
+            return;
+        }
+        const colorHandles = [];
+        for (const texture of textures) {
+            const handle = texture?._hardwareTexture?.underlyingResource;
+            if (handle) {
+                colorHandles.push(handle);
+            }
+        }
+        // bgfx framebuffers use a dense, ordered attachment list, so only (re)build once every expected color
+        // attachment is present. Building from a partial set (e.g. attachments deferred via dontCreateTextures /
+        // targetTypes[i] === -1, or filled out of order) would compress the attachment indices -- attachment 2
+        // would become attachment 1, etc. -- and produce a framebuffer that does not match the MRT layout. The
+        // count match guarantees the collected handles are contiguous and in attachment order.
+        const expectedCount = rtWrapper._attachments ? rtWrapper._attachments.length : colorHandles.length;
+        if (colorHandles.length === 0 || colorHandles.length !== expectedCount) {
+            return;
+        }
+        const width = rtWrapper.width;
+        const height = rtWrapper.height;
+        if (this._engine.createMultiFrameBuffer) {
+            rtWrapper._framebuffer = this._engine.createMultiFrameBuffer(colorHandles, width, height, rtWrapper._generateStencilBuffer, rtWrapper._generateDepthBuffer, rtWrapper._samples);
+        }
+        else {
+            // Older Babylon Native binaries (predating multi render target support) do not expose createMultiFrameBuffer.
+            // Fall back to a single-attachment framebuffer bound to the first color target so the scene keeps rendering.
+            // Warn once (limit 1): the framebuffer can be rebuilt many times during attachment setup/swaps.
+            Logger.Warn("createMultiFrameBuffer is not supported by this version of Babylon Native; multi render targets are unavailable. Falling back to a single-attachment framebuffer bound to the first color target.", 1);
+            rtWrapper._framebuffer = this._engine.createFrameBuffer(colorHandles[0], width, height, rtWrapper._generateStencilBuffer, rtWrapper._generateDepthBuffer, rtWrapper._samples);
+        }
+    }
+    generateMipMapsForCubemap(_texture, _unbind = true) {
+        // The WebGL path rebinds gl.TEXTURE_CUBE_MAP and calls gl.generateMipmap; both deref _gl, which is
+        // null on Native. bgfx auto-generates the mip chain when a render target texture created with mips is
+        // resolved (the same way 2D RTTs get their mips here -- unBindFramebuffer issues no explicit mipgen),
+        // so this is a no-op on Native.
+    }
+    bindAttachments(_attachments) {
+        // No-op on Native: bgfx renders to every color attachment of the bound framebuffer, so there is
+        // no gl.drawBuffers equivalent to select a subset.
+    }
+    buildTextureLayout(textureStatus, _backBufferLayout = false) {
+        // Native has no gl draw-buffer enums; return a per-attachment index list (consumers only use the
+        // length/order, and bindAttachments is a no-op).
+        const result = [];
+        for (let i = 0; i < textureStatus.length; i++) {
+            result.push(textureStatus[i] ? i : -1);
+        }
+        return result;
+    }
+    restoreSingleAttachment() {
+        // No-op on Native (see bindAttachments).
+    }
+    restoreSingleAttachmentForRenderTarget() {
+        // No-op on Native (see bindAttachments).
+    }
+    generateMipMapsMultiFramebuffer(_texture) {
+        // No-op on Native: bgfx auto-generates mips on render-target resolve (as for 2D/cube RTTs).
+    }
+    resolveMultiFramebuffer(_texture) {
+        // No-op on Native: bgfx resolves MSAA render targets automatically.
+    }
+    unBindMultiColorAttachmentFramebuffer(_rtWrapper, _disableGenerateMipMaps = false, onBeforeUnbind) {
+        this._currentRenderTarget = null;
+        if (onBeforeUnbind) {
+            onBeforeUnbind();
+        }
+        this._bindUnboundFramebuffer(null);
+    }
+    updateMultipleRenderTargetTextureSampleCount(rtWrapper, samples, _initializeBuffers = true) {
+        if (!rtWrapper || rtWrapper.samples === samples) {
+            return samples;
+        }
+        const textures = rtWrapper.textures;
+        if (!textures) {
+            return rtWrapper.samples;
+        }
+        const nativeRTWrapper = rtWrapper;
+        // bgfx couples MSAA to the texture creation flags (see updateRenderTargetTextureSampleCount), so
+        // changing the sample count after the fact requires reissuing every color attachment's underlying
+        // bgfx handle with the new MSAA flag. initializeTexture disposes the old handle and allocates a fresh
+        // one while preserving the InternalTexture / Graphics::Texture identity; only the internal bgfx handle
+        // rotates. Afterwards the framebuffer is recreated so its attachment list refers to the new handles.
+        for (const texture of textures) {
+            // Wrapped (External-source) textures own an opaque external handle (format=-1); reinitializing
+            // would destroy it and getNativeTextureFormat would throw, so leave those attachments untouched.
+            if (!texture?._hardwareTexture || texture.source === 15 /* InternalTextureSource.External */) {
+                continue;
+            }
+            const nativeTexture = texture._hardwareTexture.underlyingResource;
+            // See the bgfx-msaa-mips workaround in updateRenderTargetTextureSampleCount (BabylonNative#1714).
+            const hasMips = samples > 1 ? false : texture.generateMipMaps;
+            this._engine.initializeTexture(nativeTexture, texture.baseWidth, texture.baseHeight, hasMips, getNativeTextureFormat(texture.format, texture.type), 
+            /*renderTarget*/ true, texture._useSRGBBuffer, samples);
+            texture.samples = samples;
+        }
+        nativeRTWrapper._samples = samples;
+        this._createMultiRenderTargetFramebuffer(nativeRTWrapper);
+        return samples;
+    }
     updateRenderTargetTextureSampleCount(rtWrapper, samples) {
         if (rtWrapper.samples === samples) {
             return samples;
@@ -1847,10 +2185,24 @@ export class ThinNativeEngine extends ThinEngine {
         // underlying bgfx resource has 1 mip level. Remove this guard once a fixed bgfx is in stable BN npm.
         const hasMips = samples > 1 ? false : texture.generateMipMaps;
         const nativeTextureFormat = getNativeTextureFormat(texture.format, texture.type);
-        this._engine.initializeTexture(nativeTexture, texture.baseWidth, texture.baseHeight, hasMips, nativeTextureFormat, /*renderTarget*/ true, texture._useSRGBBuffer, samples);
-        // NativeRenderTargetWrapper._framebuffer setter releases the old framebuffer before assigning,
-        // so no manual _releaseFramebufferObjects call is needed (and would double-delete the handle).
-        nativeRTWrapper._framebuffer = this._engine.createFrameBuffer(nativeTexture, texture.baseWidth, texture.baseHeight, rtWrapper._generateStencilBuffer, rtWrapper._generateDepthBuffer, samples);
+        const isCube = texture.isCube;
+        this._engine.initializeTexture(nativeTexture, texture.baseWidth, texture.baseHeight, hasMips, nativeTextureFormat, 
+        /*renderTarget*/ true, texture._useSRGBBuffer, samples, isCube);
+        if (isCube) {
+            // Cube RTTs render through one framebuffer per face (see createRenderTargetCubeTexture). The
+            // underlying bgfx handle was just rotated, so recreate all six attachments; the _framebuffers
+            // setter releases the stale ones and keeps _framebuffer aliased to face 0 for single-target paths.
+            const framebuffers = [];
+            for (let face = 0; face < 6; face++) {
+                framebuffers.push(this._engine.createFrameBuffer(nativeTexture, texture.baseWidth, texture.baseHeight, rtWrapper._generateStencilBuffer, rtWrapper._generateDepthBuffer, samples, face));
+            }
+            nativeRTWrapper._framebuffers = framebuffers;
+        }
+        else {
+            // NativeRenderTargetWrapper._framebuffer setter releases the old framebuffer before assigning,
+            // so no manual _releaseFramebufferObjects call is needed (and would double-delete the handle).
+            nativeRTWrapper._framebuffer = this._engine.createFrameBuffer(nativeTexture, texture.baseWidth, texture.baseHeight, rtWrapper._generateStencilBuffer, rtWrapper._generateDepthBuffer, samples);
+        }
         rtWrapper._samples = samples;
         texture.samples = samples;
         return samples;
@@ -1868,13 +2220,17 @@ export class ThinNativeEngine extends ThinEngine {
             this.unBindFramebuffer(this._currentRenderTarget);
         }
         this._currentRenderTarget = texture;
-        if (faceIndex) {
-            throw new Error("Cuboid frame buffers are not yet supported in NativeEngine.");
-        }
         if (requiredWidth || requiredHeight) {
             throw new Error("Required width/height for frame buffers not yet supported in NativeEngine.");
         }
-        if (nativeRTWrapper._framebufferDepthStencil) {
+        if (nativeRTWrapper._framebuffers) {
+            // Cube render target: bind the framebuffer for the requested face.
+            this._bindUnboundFramebuffer(nativeRTWrapper._framebuffers[faceIndex ?? 0]);
+        }
+        else if (faceIndex) {
+            throw new Error("Cuboid frame buffers are not yet supported in NativeEngine.");
+        }
+        else if (nativeRTWrapper._framebufferDepthStencil) {
             this._bindUnboundFramebuffer(nativeRTWrapper._framebufferDepthStencil);
         }
         else {
@@ -2091,7 +2447,17 @@ export class ThinNativeEngine extends ThinEngine {
      * @param generateMipMaps defines whether to generate mipmaps or not
      */
     updateTextureData(texture, imageData, xOffset, yOffset, width, height, faceIndex = 0, lod = 0, generateMipMaps = false) {
-        throw new Error("updateTextureData not implemented.");
+        if (!texture._hardwareTexture) {
+            return;
+        }
+        if (!this._engine.updateTextureData) {
+            throw new Error("updateTextureData not implemented.");
+        }
+        // bgfx updates the requested sub-rectangle of the existing texture (faceIndex selects the cube
+        // face / array layer, lod selects the mip level). invertY is forwarded so the native side can match
+        // the vertical orientation the base texture upload uses. Mip regeneration after a partial update is
+        // not supported on Native, so generateMipMaps is ignored (consistent with the other raw-texture paths).
+        this._engine.updateTextureData(texture._hardwareTexture.underlyingResource, imageData, xOffset, yOffset, width, height, faceIndex, lod, texture.invertY);
     }
     /**
      * @internal