rm-webgpu-compute-tasks 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rm-webgpu-compute-tasks",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/index.d.ts

@@ -9,6 +9,11 @@ import { Vector4 } from 'three';
 export declare class AtomicUint32Array extends Uint32Array {
 }
 
+export declare function autoWorkgroup(maxSize?: [number, number?, number?]): {
+    workgroupSize: Vec3;
+    workgroupCount: Vec3;
+};
+
 export declare class BaseMaterial extends ShaderMaterial {
     constructor(opt?: IOption);
 }
@@ -34,6 +39,30 @@ declare type BufferGroup = {
     group: GPUBindGroup;
 };
 
+export declare class ComputeMaterial extends ShaderMaterial<GPUComputePipeline> {
+    workgroupCount: [number, number?, number?];
+    workgroupSize: [number, number, number];
+    constructor(opt: ComputeMaterialOptions);
+    setWorkgroupCount(workgroupCount: [number, number?, number?]): void;
+    needsPipelineUpdate: boolean;
+    createPipeline(): GPUComputePipeline | undefined;
+    update(): void;
+}
+
+export declare interface ComputeMaterialOptions {
+    beforeCcde?: string;
+    mainCode: string;
+    uniforms?: Record<string, {
+        value: UniformValue;
+        write?: boolean;
+        atomic?: boolean;
+    }>;
+    define?: Record<string, boolean>;
+    workgroupCount?: [number, number?, number?];
+    workgroupSize?: [number, number, number];
+    maxSize?: [number, number?, number?];
+}
+
 /** 创建buffer
  * @param device
  * @param options
@@ -107,16 +136,17 @@ export declare class CubeTexture extends Texture {
     private buildFaceViews;
 }
 
-export declare class DepthMaterial extends ShaderMaterial {
-    constructor(opt?: IBaseMaterialOption);
-}
-
 export declare function destroyWebgpu(): Promise<void>;
 
 export declare const getAdapter: () => GPUAdapter;
 
 export declare const getDevice: () => GPUDevice;
 
+export declare function getNullBG(): {
+    bindGroup: GPUBindGroup;
+    bindGroupLayout: GPUBindGroupLayout | null;
+};
+
 export declare function getSampler(desc: GPUSamplerDescriptor): GPUSampler;
 
 export declare type GPUAttribute = {
@@ -224,13 +254,6 @@ declare type GpuComputedOption = {
     code?: string;
 };
 
-declare interface IBaseMaterialOption {
-    color?: number;
-    side?: GPUCullMode;
-    topology?: GPUPrimitiveTopology;
-    map?: Texture;
-}
-
 export declare interface ICreateObstacleDetection {
     base: string;
     size?: number;
@@ -239,6 +262,7 @@ export declare interface ICreateObstacleDetection {
     canvasWidth?: number;
     canvasHeight?: number;
     fov?: number;
+    linesJson?: any;
 }
 
 export declare interface ICubeTextureOption {
@@ -293,13 +317,6 @@ declare interface IOption {
     opacity?: number;
 }
 
-declare interface IOption_2 {
-    side?: GPUCullMode;
-    topology?: GPUPrimitiveTopology;
-    cubeTexture: Texture;
-    results?: Uint32Array;
-}
-
 declare type IStruct = IStructBaseType[];
 
 declare interface IStructArray {
@@ -333,12 +350,13 @@ export declare interface IVertexInputDes {
 /**
  * @param base
  */
-export declare function loadData(base: string): Promise<IData & {
+export declare function loadData(base: string, linesJson_?: any): Promise<IData & {
     map: Map<number, [number, number, number, number]>;
     linesJson: any[];
 }>;
 
 export declare class Object3D extends THREE.Object3D {
+    static get GROU_INDEX(): number;
     static get bindGroupLayout(): GPUBindGroupLayout;
     private buffer;
     bindGroup: GPUBindGroup;
@@ -355,7 +373,7 @@ export declare class Object3D extends THREE.Object3D {
 }
 
 export declare const obstacleDetection: typeof obstacleDetection_ & {
-    getResult(base: string): Promise<number[]>;
+    getResult(base: string, linesJson?: any): Promise<number[]>;
 };
 
 declare function obstacleDetection_(opt: ICreateObstacleDetection): Promise<{
@@ -375,11 +393,13 @@ declare function obstacleDetection_(opt: ICreateObstacleDetection): Promise<{
     result: number[];
 }>;
 
-export declare class OcclusionMaterial extends ShaderMaterial {
-    constructor(opt: IOption_2);
-    static packUint(v: number): Vector4;
-    static unpackUint(r: number, g: number, b: number, a: number): number;
-    static unpackUintByUint8(buff: Uint8Array, i: number): number | null;
+declare interface Option_2 {
+    base: string;
+    urls: string[];
+    erodeMaskSize?: number;
+    kernelSize?: number;
+    gridSize?: number;
+    gridAmount?: number;
 }
 
 export declare class PerspectiveCamera extends THREE.PerspectiveCamera {
@@ -450,35 +470,52 @@ export declare class Renderer {
     format: GPUTextureFormat;
     renderTarget: GPUTextureView | null;
     depthTarget: GPUTextureView | null;
+    /**
+     * @param width
+     * @param height
+     * @param format
+     */
     constructor(width?: number, height?: number, format?: GPUTextureFormat);
+    /** 渲染
+     * @param meshList
+     * @param camera
+     * @param depthClearValue
+     * @returns
+     */
     render(meshList: Object3D[], camera: PerspectiveCamera, depthClearValue?: number): void;
+    compute(materials: ComputeMaterial[] | ComputeMaterial): void;
 }
 
+export declare const segmentObjectPointClouds: typeof sopc_ & {
+    getResult(opt: Option_2): Promise<number[][][]>;
+};
+
 export declare const shaderLocationMap: Map<string, number>;
 
-export declare class ShaderMaterial {
+export declare class ShaderMaterial<T = GPURenderPipeline> {
+    static get GROU_INDEX(): number;
     vertex: string;
     fragment: string;
-    pipeline?: GPURenderPipeline;
+    pipeline?: T;
     bindGroup: GPUBindGroup;
     buffer: GPUBuffer;
     uniforms: Record<string, {
         value: UniformValue;
     }>;
-    private uniformArray;
-    private _bufferUniforms;
-    private _textureUniforms;
-    private _storageUniforms;
-    private topology?;
-    private side?;
-    private blend?;
-    private writeMask?;
-    private depthStencil?;
-    private env?;
-    private _needsUniformUpdate;
+    protected uniformArray: Float32Array<ArrayBuffer>;
+    protected _bufferUniforms: Record<string, UniformMeta>;
+    protected _textureUniforms: Record<string, UniformMeta>;
+    protected _storageUniforms: Record<string, UniformMeta>;
+    protected topology?: GPUPrimitiveTopology;
+    protected side?: GPUCullMode;
+    protected blend?: GPUBlendState;
+    protected writeMask?: number | undefined;
+    protected depthStencil?: Omit<GPUDepthStencilState, "format">;
+    protected define?: Record<string, boolean>;
+    protected _needsUniformUpdate: boolean;
     get needsUniformUpdate(): boolean;
     set needsUniformUpdate(v: boolean);
-    private _needsBindGroupUpdate;
+    protected _needsBindGroupUpdate: boolean;
     get needsBindGroupUpdate(): boolean;
     set needsBindGroupUpdate(v: boolean);
     constructor(options: ShaderMaterialOptions);
@@ -486,47 +523,52 @@ export declare class ShaderMaterial {
      * 初始化uniform
      * @param uniforms
      */
-    private _initUniform;
+    protected _initUniform(uniforms: any): void;
     /**
      * 获取绑定组布局
      * @returns
      */
-    private _getBindGroupLayout;
+    protected _getBindGroupLayout(): GPUBindGroupLayout;
     /**
      * 创建绑定组
      */
-    private _createBindGroup;
+    protected _createBindGroup(): void;
     /** 生成uniform 代码
-     * @param type
+     * @param mtype
      * @returns
      */
-    private _generateUniformWGSL;
+    protected _generateUniformWGSL(mtype: "vertex" | "fragment" | "compute"): string;
     /** 生成 顶点着色器入参类型代码
      * @param attrMap
      * @returns
      */
-    private _generateVertexInputWGSL;
+    protected _generateVertexInputWGSL(attrMap: Map<string, GPUAttribute>): string;
     /**
      * 生成 Storage 类型代码
      */
-    private _generateStorageWGSL;
+    protected _generateStorageWGSL(type: "vertex" | "fragment" | "compute"): string;
     /** 创建渲染管线
      * @param attrMap
      * @param colorFormat
      * @param depthFormat
      * @returns
      */
-    createPipeline(attrMap: Map<string, GPUAttribute>, colorFormat?: GPUTextureFormat, depthFormat?: GPUTextureFormat): GPURenderPipeline;
+    createPipeline(attrMap: Map<string, GPUAttribute>, colorFormat?: GPUTextureFormat, depthFormat?: GPUTextureFormat): GPURenderPipeline | T | undefined;
     /**
      * 更新uniform 数据
      */
-    private _updateUniform;
+    protected _updateUniform(): void;
     update(): void;
     /** 获取buffer
      * @param name
      * @returns
      */
     getStorageBuffer(name: string): GPUBuffer | undefined;
+    /** 主动设置GPUBuffer, 可共享其他材质已经创建的 GPUBuffer
+     * @param name
+     * @param buff
+     */
+    setStorageBuffer(name: string, buff: GPUBuffer): void;
 }
 
 export declare interface ShaderMaterialOptions {
@@ -542,9 +584,16 @@ export declare interface ShaderMaterialOptions {
     blend?: GPUBlendState;
     writeMask?: number | undefined;
     depthStencil?: Omit<GPUDepthStencilState, "format">;
-    env?: Record<string, boolean>;
+    define?: Record<string, boolean>;
 }
 
+declare function sopc_(opt: Option_2): Promise<{
+    renderer: Renderer;
+    camera: PerspectiveCamera;
+    results: number[][][];
+    pointsArray: Float32Array<ArrayBufferLike>;
+}>;
+
 export declare class Texture {
     depthTexture: GPUTexture;
     depthView: GPUTextureView;
@@ -567,7 +616,18 @@ export declare class Texture {
 
 export declare const transparentOption: Omit<GPUColorTargetState, "format">;
 
-declare type UniformValue = Color | Matrix4 | Matrix3 | Texture | CubeTexture | number | Vector2 | Vector3 | Vector4 | number[] | Float32Array | Uint32Array | Uint8Array;
+export declare interface UniformMeta {
+    type: string;
+    value: UniformValue;
+    binding?: number;
+    buffer?: GPUBuffer;
+    write?: boolean;
+    atomic?: boolean;
+}
+
+export declare type UniformValue = Color | Matrix4 | Matrix3 | Texture | CubeTexture | number | Vector2 | Vector3 | Vector4 | number[] | Float32Array | Uint32Array | Uint8Array;
+
+declare type Vec3 = [number, number, number];
 
 declare type WGSl_TYPE = "f32" | "u32" | "vec2" | "vec3" | "vec4" | "mat3x3" | "mat4x4";