@babylonjs/core 5.32.2 → 5.33.0

package/Engines/WebGPU/webgpuTextureHelper.d.ts

@@ -3,6 +3,7 @@ import type { Nullable } from "../../types";
 import type { InternalTexture } from "../../Materials/Textures/internalTexture";
 import { WebGPUHardwareTexture } from "./webgpuHardwareTexture";
 import type { WebGPUTintWASM } from "./webgpuTintWASM";
+import type { ExternalTexture } from "../../Materials/Textures/externalTexture";
 /**
  * Map a (renderable) texture format (GPUTextureFormat) to an index for fast lookup (in caches for eg)
  */
@@ -16,14 +17,18 @@ export declare class WebGPUTextureHelper {
     private _tintWASM;
     private _bufferManager;
     private _mipmapSampler;
+    private _videoSampler;
     private _ubCopyWithOfst;
     private _pipelines;
     private _compiledShaders;
+    private _videoPipelines;
+    private _videoCompiledShaders;
     private _deferredReleaseTextures;
     private _commandEncoderForCreation;
     static ComputeNumMipmapLevels(width: number, height: number): number;
     constructor(device: GPUDevice, glslang: any, tintWASM: Nullable<WebGPUTintWASM>, bufferManager: WebGPUBufferManager);
     private _getPipeline;
+    private _getVideoPipeline;
     private static _GetTextureTypeFromFormat;
     private static _GetBlockInformationFromFormat;
     private static _IsHardwareTexture;
@@ -42,6 +47,7 @@ export declare class WebGPUTextureHelper {
     static GetNumChannelsFromWebGPUTextureFormat(format: GPUTextureFormat): number;
     static HasStencilAspect(format: GPUTextureFormat): boolean;
     static HasDepthAndStencilAspects(format: GPUTextureFormat): boolean;
+    copyVideoToTexture(video: ExternalTexture, texture: InternalTexture, format: GPUTextureFormat, invertY?: boolean, commandEncoder?: GPUCommandEncoder): void;
     invertYPreMultiplyAlpha(gpuOrHdwTexture: GPUTexture | WebGPUHardwareTexture, width: number, height: number, format: GPUTextureFormat, invertY?: boolean, premultiplyAlpha?: boolean, faceIndex?: number, mipLevel?: number, layers?: number, ofstX?: number, ofstY?: number, rectWidth?: number, rectHeight?: number, commandEncoder?: GPUCommandEncoder, allowGPUOptimization?: boolean): void;
     copyWithInvertY(srcTextureView: GPUTextureView, format: GPUTextureFormat, renderPassDescriptor: GPURenderPassDescriptor, commandEncoder?: GPUCommandEncoder): void;
     createTexture(imageBitmap: ImageBitmap | {

package/Engines/WebGPU/webgpuTextureHelper.js

@@ -141,6 +141,59 @@ const clearFragmentSource = `
         outColor = color;
     }
     `;
+const copyVideoToTextureVertexSource = `
+    struct VertexOutput {
+        @builtin(position) Position : vec4<f32>,
+        @location(0) fragUV : vec2<f32>
+    }
+  
+    @vertex
+    fn main(
+        @builtin(vertex_index) VertexIndex : u32
+    ) -> VertexOutput {
+        var pos = array<vec2<f32>, 4>(
+            vec2(-1.0,  1.0),
+            vec2( 1.0,  1.0),
+            vec2(-1.0, -1.0),
+            vec2( 1.0, -1.0)
+        );
+        var tex = array<vec2<f32>, 4>(
+            vec2(0.0, 0.0),
+            vec2(1.0, 0.0),
+            vec2(0.0, 1.0),
+            vec2(1.0, 1.0)
+        );
+
+        var output: VertexOutput;
+
+        output.Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
+        output.fragUV = tex[VertexIndex];
+
+        return output;
+    }
+    `;
+const copyVideoToTextureFragmentSource = `
+    @group(0) @binding(0) var videoSampler: sampler;
+    @group(0) @binding(1) var videoTexture: texture_external;
+
+    @fragment
+    fn main(
+        @location(0) fragUV: vec2<f32>
+    ) -> @location(0) vec4<f32> {
+        return textureSampleBaseClampToEdge(videoTexture, videoSampler, fragUV);
+    }
+    `;
+const copyVideoToTextureInvertYFragmentSource = `
+    @group(0) @binding(0) var videoSampler: sampler;
+    @group(0) @binding(1) var videoTexture: texture_external;
+
+    @fragment
+    fn main(
+        @location(0) fragUV: vec2<f32>
+    ) -> @location(0) vec4<f32> {
+        return textureSampleBaseClampToEdge(videoTexture, videoSampler, vec2<f32>(fragUV.x, 1.0 - fragUV.y));
+    }
+    `;
 var PipelineType;
 (function (PipelineType) {
     PipelineType[PipelineType["MipMap"] = 0] = "MipMap";
@@ -148,6 +201,11 @@ var PipelineType;
     PipelineType[PipelineType["Clear"] = 2] = "Clear";
     PipelineType[PipelineType["InvertYPremultiplyAlphaWithOfst"] = 3] = "InvertYPremultiplyAlphaWithOfst";
 })(PipelineType || (PipelineType = {}));
+var VideoPipelineType;
+(function (VideoPipelineType) {
+    VideoPipelineType[VideoPipelineType["DontInvertY"] = 0] = "DontInvertY";
+    VideoPipelineType[VideoPipelineType["InvertY"] = 1] = "InvertY";
+})(VideoPipelineType || (VideoPipelineType = {}));
 const shadersForPipelineType = [
     { vertex: mipmapVertexSource, fragment: mipmapFragmentSource },
     { vertex: invertYPreMultiplyAlphaVertexSource, fragment: invertYPreMultiplyAlphaFragmentSource },
@@ -206,14 +264,18 @@ export class WebGPUTextureHelper {
     constructor(device, glslang, tintWASM, bufferManager) {
         this._pipelines = {};
         this._compiledShaders = [];
+        this._videoPipelines = {};
+        this._videoCompiledShaders = [];
         this._deferredReleaseTextures = [];
         this._device = device;
         this._glslang = glslang;
         this._tintWASM = tintWASM;
         this._bufferManager = bufferManager;
         this._mipmapSampler = device.createSampler({ minFilter: WebGPUConstants.FilterMode.Linear });
+        this._videoSampler = device.createSampler({ minFilter: WebGPUConstants.FilterMode.Linear });
         this._ubCopyWithOfst = this._bufferManager.createBuffer(4 * 4, WebGPUConstants.BufferUsage.Uniform | WebGPUConstants.BufferUsage.CopyDst).underlyingResource;
         this._getPipeline(WebGPUConstants.TextureFormat.RGBA8Unorm);
+        this._getVideoPipeline(WebGPUConstants.TextureFormat.RGBA8Unorm);
     }
     static ComputeNumMipmapLevels(width, height) {
         return Scalar.ILog2(Math.max(width, height)) + 1;
@@ -282,6 +344,48 @@ export class WebGPUTextureHelper {
         }
         return pipelineAndBGL;
     }
+    _getVideoPipeline(format, type = VideoPipelineType.DontInvertY) {
+        const index = type === VideoPipelineType.InvertY ? 1 << 0 : 0;
+        if (!this._videoPipelines[format]) {
+            this._videoPipelines[format] = [];
+        }
+        let pipelineAndBGL = this._videoPipelines[format][index];
+        if (!pipelineAndBGL) {
+            let modules = this._videoCompiledShaders[index];
+            if (!modules) {
+                const vertexModule = this._device.createShaderModule({
+                    code: copyVideoToTextureVertexSource,
+                });
+                const fragmentModule = this._device.createShaderModule({
+                    code: index === 0 ? copyVideoToTextureFragmentSource : copyVideoToTextureInvertYFragmentSource,
+                });
+                modules = this._videoCompiledShaders[index] = [vertexModule, fragmentModule];
+            }
+            const pipeline = this._device.createRenderPipeline({
+                label: `CopyVideoToTexture_${format}_${index === 0 ? "DontInvertY" : "InvertY"}`,
+                layout: WebGPUConstants.AutoLayoutMode.Auto,
+                vertex: {
+                    module: modules[0],
+                    entryPoint: "main",
+                },
+                fragment: {
+                    module: modules[1],
+                    entryPoint: "main",
+                    targets: [
+                        {
+                            format,
+                        },
+                    ],
+                },
+                primitive: {
+                    topology: WebGPUConstants.PrimitiveTopology.TriangleStrip,
+                    stripIndexFormat: WebGPUConstants.IndexFormat.Uint16,
+                },
+            });
+            pipelineAndBGL = this._videoPipelines[format][index] = [pipeline, pipeline.getBindGroupLayout(0)];
+        }
+        return pipelineAndBGL;
+    }
     static _GetTextureTypeFromFormat(format) {
         switch (format) {
             // One Component = 8 bits
@@ -915,6 +1019,59 @@ export class WebGPUTextureHelper {
         }
         return false;
     }
+    copyVideoToTexture(video, texture, format, invertY = false, commandEncoder) {
+        var _a, _b, _c, _d;
+        const useOwnCommandEncoder = commandEncoder === undefined;
+        const [pipeline, bindGroupLayout] = this._getVideoPipeline(format, invertY ? VideoPipelineType.InvertY : VideoPipelineType.DontInvertY);
+        if (useOwnCommandEncoder) {
+            commandEncoder = this._device.createCommandEncoder({});
+        }
+        (_b = (_a = commandEncoder).pushDebugGroup) === null || _b === void 0 ? void 0 : _b.call(_a, `copy video to texture - invertY=${invertY}`);
+        const webgpuHardwareTexture = texture._hardwareTexture;
+        const renderPassDescriptor = {
+            colorAttachments: [
+                {
+                    view: webgpuHardwareTexture.underlyingResource.createView({
+                        format,
+                        dimension: WebGPUConstants.TextureViewDimension.E2d,
+                        mipLevelCount: 1,
+                        baseArrayLayer: 0,
+                        baseMipLevel: 0,
+                        arrayLayerCount: 1,
+                        aspect: WebGPUConstants.TextureAspect.All,
+                    }),
+                    loadOp: WebGPUConstants.LoadOp.Load,
+                    storeOp: WebGPUConstants.StoreOp.Store,
+                },
+            ],
+        };
+        const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
+        const descriptor = {
+            layout: bindGroupLayout,
+            entries: [
+                {
+                    binding: 0,
+                    resource: this._videoSampler,
+                },
+                {
+                    binding: 1,
+                    resource: this._device.importExternalTexture({
+                        source: video.underlyingResource,
+                    }),
+                },
+            ],
+        };
+        const bindGroup = this._device.createBindGroup(descriptor);
+        passEncoder.setPipeline(pipeline);
+        passEncoder.setBindGroup(0, bindGroup);
+        passEncoder.draw(4, 1, 0, 0);
+        passEncoder.end();
+        (_d = (_c = commandEncoder).popDebugGroup) === null || _d === void 0 ? void 0 : _d.call(_c);
+        if (useOwnCommandEncoder) {
+            this._device.queue.submit([commandEncoder.finish()]);
+            commandEncoder = null;
+        }
+    }
     invertYPreMultiplyAlpha(gpuOrHdwTexture, width, height, format, invertY = false, premultiplyAlpha = false, faceIndex = 0, mipLevel = 0, layers = 1, ofstX = 0, ofstY = 0, rectWidth = 0, rectHeight = 0, commandEncoder, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     allowGPUOptimization) {