Reuse webgpu resources

cocos/gfx/webgpu/webgpu-command-buffer.ts

@@ -39,6 +39,7 @@ import {
     Filter,
     TextureBlit,
     ShaderStageFlagBit,
+    DescriptorSetInfo,
 } from '../base/define';
 import { Framebuffer } from '../base/framebuffer';
 import { InputAssembler } from '../base/input-assembler';
@@ -75,6 +76,7 @@ import { WebGPUSwapchain } from './webgpu-swapchain';
 import { WebGPUPipelineLayout } from './webgpu-pipeline-layout';
 import { WebGPUDescriptorSetLayout } from './webgpu-descriptor-set-layout';
 import { error, errorID } from '../../core';
+import { SetIndex } from '../../rendering/define';
 
 export interface IWebGPUDepthBias {
     constantFactor: number;
@@ -101,6 +103,7 @@ export interface IWebGPUStencilCompareMask {
 interface CommandEncoder { commandEncoder: GPUCommandEncoder, renderPassEncoder: GPURenderPassEncoder }
 let currPipelineState: WebGPUPipelineState | null = null;
 const descriptorSets: WebGPUDescriptorSet[] = [];
+const groupSets: SetIndex[] = [SetIndex.GLOBAL, SetIndex.MATERIAL, SetIndex.LOCAL];
 const renderAreas: Rect[] = [];
 export class WebGPUCommandBuffer extends CommandBuffer {
     public pipelineBarrier (
@@ -626,34 +629,50 @@ export class WebGPUCommandBuffer extends CommandBuffer {
         }
         const gpuPipelineLayout = this._curGPUPipelineState.gpuPipelineLayout as IWebGPUGPUPipelineLayout;
         const wgpuPipLayout = (currPipelineState?.pipelineLayout as WebGPUPipelineLayout);
-        let needFetchPipLayout = false;
-        const descSize = descriptorSets.length;
-        for (let i = 0; i < descSize; i++) {
-            descriptorSets[i].prepare(
-                i ? DescUpdateFrequency.NORMAL : DescUpdateFrequency.LOW,
-                bindingMaps.get(i)!,
-                vertBinds[i] || [],
-                fragBinds[i] || [],
-            );
-            const layout = descriptorSets[i].layout as WebGPUDescriptorSetLayout;
-            const currGrpLayout = layout.gpuDescriptorSetLayout!.bindGroupLayout;
-            const notEqualLayout = gpuPipelineLayout.gpuBindGroupLayouts[i] !== currGrpLayout;
-            if (layout.hasChanged || notEqualLayout) {
-                if (notEqualLayout) {
-                    wgpuPipLayout.changeSetLayout(i, layout);
-                }
-                layout.resetChanged();
-                needFetchPipLayout = true;
+        // const needFetchPipLayout = false;
+        // const descSize = descriptorSets.length;
+        for (let i = 0; i < groupSets.length; i++) {
+            const currSetIdx = groupSets[i];
+            const currDesc = descriptorSets[currSetIdx];
+            if (currDesc) {
+                currDesc.prepare();
+            } else {
+                const currLayout = wgpuPipLayout.setLayouts[currSetIdx];
+                const currLayoutInfo = new DescriptorSetInfo(currLayout);
+                const newDescSet = WebGPUDeviceManager.instance.createDescriptorSet(currLayoutInfo) as WebGPUDescriptorSet;
+                descriptorSets[currSetIdx] = newDescSet;
+                newDescSet.prepare(true);
+                // this._curGPUDescriptorSets[currSetIdx] = newDescSet.gpuDescriptorSet;
             }
-        }
-
-        if (needFetchPipLayout || !wgpuPipLayout.gpuPipelineLayout!.nativePipelineLayout
-            || this._curGPUPipelineState.pipelineState!.layout !== gpuPipelineLayout.nativePipelineLayout) {
-            wgpuPipLayout.fetchPipelineLayout(false);
-            this._curWebGPUPipelineState?.updatePipelineLayout();
-            needFetchPipLayout = true;
-        }
-        this._curWebGPUPipelineState!.prepare(this._curGPUInputAssembler!, needFetchPipLayout);
+            // const layout = descriptorSets[i].layout as WebGPUDescriptorSetLayout;
+            // const currGrpLayout = layout.gpuDescriptorSetLayout!.bindGroupLayout;
+            // const notEqualLayout = gpuPipelineLayout.gpuBindGroupLayouts[i] !== currGrpLayout;
+            // if (layout.hasChanged || notEqualLayout) {
+            //     if (notEqualLayout) {
+            //         wgpuPipLayout.changeSetLayout(i, layout);
+            //     }
+            //     layout.resetChanged();
+            //     needFetchPipLayout = true;
+            // }
+        }
+
+        // wgpuPipLayout.setLayouts.forEach((layout) => {
+
+        // });
+
+        // groupSets.forEach((val) => {
+        // if (!descriptorSets[val]) {
+        //     descriptorSets[val];
+        // }
+        // });
+
+        // if (needFetchPipLayout || !wgpuPipLayout.gpuPipelineLayout!.nativePipelineLayout
+        //     || this._curGPUPipelineState.pipelineState!.layout !== gpuPipelineLayout.nativePipelineLayout) {
+        //     wgpuPipLayout.fetchPipelineLayout(false);
+        //     this._curWebGPUPipelineState?.updatePipelineLayout();
+        //     needFetchPipLayout = true;
+        // }
+        this._curWebGPUPipelineState!.prepare(this._curGPUInputAssembler!);
         const { dynamicOffsetIndices } = gpuPipelineLayout;
         // ----------------------------wgpu pipline state-----------------------------
         const wgpuPipeline = this._curGPUPipelineState.nativePipeline as GPURenderPipeline;
@@ -668,20 +687,21 @@ export class WebGPUCommandBuffer extends CommandBuffer {
             };
             this._renderPassFuncQueue.push(stencilRefFunc);
         }
-        const currGPUDescSize = this._curGPUDescriptorSets.length;
+        const currGPUDescSize = groupSets.length;
         const wgpuBindGroups = new Array<GPUBindGroup>(currGPUDescSize);
         const wgpuDynOffsets = new Array<number[]>(currGPUDescSize);
         for (let i = 0; i < currGPUDescSize; i++) {
-            const curGpuDesc = this._curGPUDescriptorSets[i];
-            wgpuBindGroups[i] = curGpuDesc.bindGroup;
-            wgpuDynOffsets[i] = [...this._curDynamicOffsets[i]];
-            if (!descriptorSets[i].dynamicOffsetCount) {
-                wgpuDynOffsets[i] = [];
-            } else if (descriptorSets[i]  && descriptorSets[i].dynamicOffsetCount !== wgpuDynOffsets[i].length) {
-                wgpuDynOffsets[i].length = descriptorSets[i].dynamicOffsetCount;
-                for (let j = 0; j < descriptorSets[i].dynamicOffsetCount; j++) {
-                    if (!wgpuDynOffsets[i][j]) {
-                        wgpuDynOffsets[i][j] = 0;
+            const currSetIdx = groupSets[i];
+            const curGpuDesc = descriptorSets[currSetIdx].gpuDescriptorSet;
+            wgpuBindGroups[currSetIdx] = curGpuDesc.bindGroup;
+            wgpuDynOffsets[currSetIdx] = [...this._curDynamicOffsets[currSetIdx]];
+            if (!descriptorSets[currSetIdx].dynamicOffsetCount) {
+                wgpuDynOffsets[currSetIdx] = [];
+            } else if (descriptorSets[currSetIdx] && descriptorSets[currSetIdx].dynamicOffsetCount !== wgpuDynOffsets[currSetIdx].length) {
+                wgpuDynOffsets[currSetIdx].length = descriptorSets[currSetIdx].dynamicOffsetCount;
+                for (let j = 0; j < descriptorSets[currSetIdx].dynamicOffsetCount; j++) {
+                    if (!wgpuDynOffsets[currSetIdx][j]) {
+                        wgpuDynOffsets[currSetIdx][j] = 0;
                     }
                 }
             }

cocos/gfx/webgpu/webgpu-commands.ts

@@ -42,6 +42,7 @@ import {
     formatAlignment,
     alignTo,
     TextureFlagBit,
+    DescriptorSetLayoutBinding,
 } from '../base/define';
 
 import { WebGPUCommandAllocator } from './webgpu-command-allocator';
@@ -1371,6 +1372,123 @@ export function WebGPUCmdFuncCopyTexImagesToTexture (
     }
 }
 
+const GFXSampleTypeToGPUTextureSampleType: GPUTextureSampleType[] = [
+    'float',
+    'unfilterable-float',
+    'sint',
+    'uint',
+];
+
+const GFXViewDimensionToGPUViewDimension: GPUTextureViewDimension[] = [
+    '2d',
+    '2d',
+    '1d',
+    '1d',
+    '2d',
+    '2d-array',
+    '2d',
+    '2d-array',
+    '3d',
+    'cube',
+    'cube-array',
+    '2d',
+];
+
+const GFXMemoryAccessToGPUStorageTextureAccess: (GPUStorageTextureAccess | undefined)[] = [
+    'read-only',
+    'read-only',
+    'write-only',
+    'read-write',
+];
+
+export function CreateBindGroupLayoutEntry (currBind: DescriptorSetLayoutBinding): GPUBindGroupLayoutEntry[] {
+    const binding = currBind.binding;
+    // Define the mapping from ShaderStageFlagBit to GPUShaderStage
+    const gpuVisibility = GFXStageToWebGPUStage(currBind.stageFlags);
+    const entrys: GPUBindGroupLayoutEntry[] = [];
+    const entry: GPUBindGroupLayoutEntry = {
+        binding,
+        visibility: gpuVisibility,
+    };
+    entrys.push(entry);
+    let entrySampler: GPUBindGroupLayoutEntry | null = null;
+    const samplerType = GFXSampleTypeToGPUTextureSampleType[currBind.sampleType];
+    const isTexUnFilter = samplerType === 'unfilterable-float';
+    const viewDimension = GFXViewDimensionToGPUViewDimension[currBind.viewDimension];
+    const type = currBind.descriptorType;
+    const multisampled = currBind.viewDimension > 5 && currBind.viewDimension < 8;
+    switch (type) {
+    case DescriptorType.UNIFORM_BUFFER:
+    case DescriptorType.DYNAMIC_UNIFORM_BUFFER:
+        entry.buffer = {
+            type: 'uniform',
+            hasDynamicOffset: type === DescriptorType.DYNAMIC_UNIFORM_BUFFER,
+            minBindingSize: undefined,
+        };
+        break;
+
+    case DescriptorType.STORAGE_BUFFER:
+    case DescriptorType.DYNAMIC_STORAGE_BUFFER:
+        entry.buffer = {
+            type: 'storage',
+            hasDynamicOffset: type === DescriptorType.DYNAMIC_STORAGE_BUFFER,
+            minBindingSize: undefined,
+        };
+        break;
+
+    case DescriptorType.SAMPLER_TEXTURE:
+        // Assuming this is a combined image sampler
+        entry.texture = {
+            sampleType: samplerType, // or 'unfilterable-float', 'depth', 'sint', 'uint'
+            viewDimension, // or 'cube', '3d', '1d'
+            multisampled,
+        };
+        entrySampler = {
+            binding: binding + SEPARATE_SAMPLER_BINDING_OFFSET,
+            visibility: gpuVisibility,
+        };
+        entrySampler.sampler = {
+            type: isTexUnFilter ? 'non-filtering' : 'filtering', // or 'non-filtering', 'comparison'
+        };
+        entrys.push(entrySampler);
+        break;
+
+    case DescriptorType.SAMPLER:
+        entry.sampler = {
+            type: isTexUnFilter ? 'non-filtering' : 'filtering', // or 'non-filtering', 'comparison'
+        };
+        break;
+
+    case DescriptorType.TEXTURE:
+        entry.texture = {
+            sampleType: samplerType, // or 'unfilterable-float', 'depth', 'sint', 'uint'
+            viewDimension, // or 'cube', '3d', '1d'
+            multisampled,
+        };
+        break;
+
+    case DescriptorType.STORAGE_IMAGE:
+        entry.storageTexture = {
+            access: GFXMemoryAccessToGPUStorageTextureAccess[currBind.access], // or 'read-only', 'read-write'
+            format: GFXFormatToWGPUFormat(currBind.format), // Choose the appropriate texture format
+            viewDimension, // or 'cube', '3d', '1d'
+        };
+        break;
+
+    case DescriptorType.INPUT_ATTACHMENT:
+        entry.texture = {
+            sampleType: samplerType, // or 'unfilterable-float', 'depth', 'sint', 'uint'
+            viewDimension, // or 'cube', '3d', '1d'
+            multisampled,
+        };
+        break;
+
+    default:
+        throw new Error(`Unsupported descriptor type: ${type}`);
+    }
+    return entrys;
+}
+
 export function TextureSampleTypeTrait (format: Format): GPUTextureSampleType {
     // See https://gpuweb.github.io/gpuweb/#texture-format-caps
     switch (format) {
@@ -1420,6 +1538,13 @@ export function TextureSampleTypeTrait (format: Format): GPUTextureSampleType {
     }
 }
 
+export function FormatToWGPUFormatType (format: Format): GPUTextureSampleType {
+    if (format === Format.DEPTH_STENCIL) {
+        return 'unfilterable-float';
+    }
+    return TextureSampleTypeTrait(format);
+}
+
 interface MipmapPassData {
     vertShader: GPUShaderModule;
     fragShader: GPUShaderModule;

cocos/gfx/webgpu/webgpu-define.ts

@@ -27,7 +27,7 @@
 */
 
 import { WEBGPU } from 'internal:constants';
-import { gfx, webgpuAdapter, glslangWasmModule, promiseForWebGPUInstantiation, spirvOptModule, twgslModule } from '../../webgpu/instantiated';
+import { gfx, webgpuAdapter, glslangWasmModule, promiseForWebGPUInstantiation, twgslModule } from '../../webgpu/instantiated';
 import {
     Texture, CommandBuffer, DescriptorSet, Device, InputAssembler, Buffer, Shader
 } from './override';