rm-webgpu-compute-tasks 0.0.1

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "rm-webgpu-compute-tasks",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./src/index.d.ts",
+        "default": "./src/index.js",
+        "style": "./src/index.css"
+      },
+      "require": {
+        "types": "./src/index.d.ts",
+        "default": "./src/index.js"
+      }
+    }
+  },
+  "dependencies": {
+    "three": ">=0.181.0",
+    "webgpu": "^0.4.0"
+  },
+  "author": "夏过初秋",
+  "license": "UNLICENSED"
+}

package/src/index.d.ts

@@ -0,0 +1,574 @@
+import { Color } from 'three';
+import { Matrix3 } from 'three';
+import { Matrix4 } from 'three';
+import * as THREE from 'three';
+import { Vector2 } from 'three';
+import { Vector3 } from 'three';
+import { Vector4 } from 'three';
+
+export declare class AtomicUint32Array extends Uint32Array {
+}
+
+export declare class BaseMaterial extends ShaderMaterial {
+    constructor(opt?: IOption);
+}
+
+declare type BufferDataType = Record<string, (number[]) | ArrayBufferView | IStruct | IStructArray>;
+
+export declare class BufferGeometry extends THREE.BufferGeometry {
+    gpuAttributes: Map<string, GPUAttribute>;
+    indexBuffer?: GPUBuffer;
+    indexFormat?: GPUIndexFormat;
+    needsUpdate: boolean;
+    count: number;
+    update(): void;
+    setAttribute<K extends string>(name: K, attribute: THREE.BufferAttribute | THREE.InterleavedBufferAttribute): this;
+    private getVertexFormat;
+}
+
+declare type BufferGroup = {
+    buffers: {
+        name: string;
+        buffer: GPUBuffer;
+    }[];
+    group: GPUBindGroup;
+};
+
+/** 创建buffer
+ * @param device
+ * @param options
+ * @returns
+ */
+export declare function createBuffer(device: GPUDevice, options: {
+    data?: ArrayBuffer | ArrayBufferView;
+    size?: number;
+    usage: GPUBufferUsageFlags;
+    mappedAtCreation?: boolean;
+    label?: string;
+}): GPUBuffer;
+
+/** 创建计算管线
+ * @param device
+ * @param options
+ * @returns
+ */
+export declare function createComputePipeline(device: GPUDevice, options: {
+    layout?: GPUPipelineLayout;
+    compute: GPUProgrammableStage;
+    label?: string;
+}): GPUComputePipeline;
+
+/** 创建渲染管线
+ * @param device
+ * @param options
+ * @returns
+ */
+export declare function createRenderPipeline(device: GPUDevice, options: {
+    layout?: GPUPipelineLayout;
+    vertex: GPUVertexState;
+    primitive?: GPUPrimitiveState;
+    depthStencil?: GPUDepthStencilState;
+    multisample?: GPUMultisampleState;
+    fragment?: GPUFragmentState;
+    label?: string;
+}): GPURenderPipeline;
+
+/** 创建纹理
+ * @param device
+ * @param options
+ * @returns
+ */
+export declare function createTexture(device: GPUDevice, options: {
+    size: GPUExtent3D;
+    format: GPUTextureFormat;
+    usage: GPUTextureUsageFlags;
+    dimension?: GPUTextureDimension;
+    mipLevelCount?: number;
+    sampleCount?: number;
+    data?: ArrayBufferView;
+    bytesPerRow?: number;
+    label?: string;
+}): GPUTexture;
+
+export declare class CubeCamera {
+    cameras: PerspectiveCamera[];
+    depthClearValue: number;
+    constructor(near?: number, far?: number, depthClearValue?: number);
+    setPosition(x: number, y: number, z: number): void;
+    updateDirections(): void;
+    render(meshList: Object3D[], renderer: Renderer, cubeTexture: CubeTexture): void;
+}
+
+export declare class CubeTexture extends Texture {
+    get cubeView(): GPUTextureView;
+    faceViews: GPUTextureView[];
+    constructor(width: number, height?: number, des?: ICubeTextureOption);
+    getFaceView(face: number): GPUTextureView;
+    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 getSampler(desc: GPUSamplerDescriptor): GPUSampler;
+
+export declare type GPUAttribute = {
+    buffer: GPUBuffer;
+    stride: number;
+    format: GPUVertexFormat;
+    shaderLocation: number;
+};
+
+export declare class GpuComputed {
+    template?: BufferDataType;
+    option?: GpuComputedOption;
+    pipeline?: GPUComputePipeline;
+    device?: GPUDevice;
+    groupLayout?: any;
+    code?: string;
+    constructor(template: BufferDataType, option?: GpuComputedOption);
+    /** 完善模版数据
+     * @param template
+     */
+    private improveTemplateOption;
+    /** 获取Gpu设备
+     * @returns
+     */
+    getDevice(): Promise<{
+        adapter: GPUAdapter;
+        device: GPUDevice;
+    }>;
+    /**
+     * 初始化计算管线
+     */
+    initPipeline(): Promise<void>;
+    /**
+     * 根据数据创建buffer组
+     * @param data 数据
+     * @param bindGroup 已创建的bindGroup, 会在没有传入对应数据时使用，用于Buffer重复利用，不需要重新构建，按名字判断，所以请确保名称和类型一致性
+     * @returns
+     */
+    createBindGroup(data: Record<string, any>, bindGroup?: {
+        group: GPUBindGroup;
+        buffers: {
+            name: string;
+            buffer: GPUBuffer;
+        }[];
+    }): {
+        group: GPUBindGroup;
+        buffers: {
+            name: string;
+            buffer: GPUBuffer;
+        }[];
+    };
+    /** 数据映射回模版数据
+     * @param array
+     * @param key
+     */
+    dataMap(array: Float32Array | Uint32Array | Int32Array, key: string): Float32Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Record<string, number | number[]> | Record<string, number | number[]>[];
+    /** 开始计算
+     * @param group 数据组
+     * @param workgroupCount 工作组大小
+     * @param synchronize 需要同步的数据字段
+     * @returns
+     */
+    computed(group: BufferGroup, workgroupCount: [number, number?, number?], synchronize?: string[]): Promise<(Float32Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>)[]>;
+    /** 初始化gpu设备
+     * @returns
+     */
+    static init(opt?: InitOption): Promise<void>;
+    static set(adapter_: GPUAdapter, device_: GPUDevice): void;
+    /** 注销gpu设备
+     */
+    static destroy(): void;
+    /**
+     * @param data
+     */
+    static buildBufferTypeByData(data: Record<string, any>): Record<string, IStructArray | IStruct | ArrayBufferView<ArrayBufferLike>>;
+    /** 通过数据创建
+     * @param opt
+     * @returns
+     */
+    static fromByData(opt: {
+        data: Record<string, any>;
+    } & GpuComputedOption): Promise<GpuComputed>;
+    /** 快捷计算方法
+     * @param opt
+     * @returns
+     */
+    static computed(opt: {
+        data: Record<string, any>;
+        workgroupCount: [number, number?, number?];
+        synchronize?: string[];
+        map?: boolean;
+        onSuccess?: (opt: {
+            gpuComputed: GpuComputed;
+            group: BufferGroup;
+            results: (Float32Array | Uint32Array | Int32Array)[];
+        }) => void;
+    } & GpuComputedOption): Promise<(Float32Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike> | Record<string, number | number[]> | Record<string, number | number[]>[])[]>;
+}
+
+declare type GpuComputedOption = {
+    workgroupSize?: [number, number, number];
+    globalInvocationIdName?: string;
+    workgroupIndexName?: string;
+    beforeCodes?: string[];
+    code?: string;
+};
+
+declare interface IBaseMaterialOption {
+    color?: number;
+    side?: GPUCullMode;
+    topology?: GPUPrimitiveTopology;
+    map?: Texture;
+}
+
+export declare interface ICreateObstacleDetection {
+    base: string;
+    size?: number;
+    near?: number;
+    far?: number;
+    canvasWidth?: number;
+    canvasHeight?: number;
+    fov?: number;
+}
+
+export declare interface ICubeTextureOption {
+    sampler?: GPUSamplerDescriptor;
+    format?: GPUTextureFormat;
+    needDepthTexture?: boolean;
+}
+
+declare interface IData {
+    indexArray: number[];
+    pointClouds: Float32Array[];
+    pointCloudArray: number[];
+    rectArray: number[];
+    trajectoryList: {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+}
+
+declare type InitOption = {
+    featureLevel?: string;
+    powerPreference?: GPUPowerPreference;
+    forceFallbackAdapter?: boolean;
+    xrCompatible?: boolean;
+    requiredFeatures?: Iterable<GPUFeatureName>;
+    requiredLimits?: Record<string, GPUSize64 | undefined>;
+    defaultQueue?: GPUQueueDescriptor;
+};
+
+declare type InitOption_2 = {
+    featureLevel?: string;
+    powerPreference?: GPUPowerPreference;
+    forceFallbackAdapter?: boolean;
+    xrCompatible?: boolean;
+    requiredFeatures?: Iterable<GPUFeatureName>;
+    requiredLimits?: Record<string, GPUSize64 | undefined>;
+    defaultQueue?: GPUQueueDescriptor;
+};
+
+export declare function initWebgpu(opt?: InitOption_2): Promise<{
+    device: GPUDevice;
+    adapter: GPUAdapter;
+} | undefined>;
+
+declare interface IOption {
+    color?: number;
+    side?: GPUCullMode;
+    topology?: GPUPrimitiveTopology;
+    map?: Texture;
+    transparent?: boolean;
+    opacity?: number;
+}
+
+declare interface IOption_2 {
+    side?: GPUCullMode;
+    topology?: GPUPrimitiveTopology;
+    cubeTexture: Texture;
+    results?: Uint32Array;
+}
+
+declare type IStruct = IStructBaseType[];
+
+declare interface IStructArray {
+    buffer?: number[];
+    stride?: number;
+    layout: IStruct;
+}
+
+declare interface IStructBaseType {
+    name: string;
+    type: WGSl_TYPE;
+    offset?: number;
+    size?: number;
+}
+
+export declare interface ITextureOption {
+    sampler?: GPUSamplerDescriptor;
+    format?: GPUTextureFormat;
+    depthOrArrayLayers?: number;
+    dimension?: GPUTextureDimension;
+    viewDimension?: GPUTextureViewDimension;
+    init?: boolean;
+    needDepthTexture?: boolean;
+}
+
+export declare interface IVertexInputDes {
+    name: string;
+    type: string;
+}
+
+/**
+ * @param base
+ */
+export declare function loadData(base: string): Promise<IData & {
+    map: Map<number, [number, number, number, number]>;
+    linesJson: any[];
+}>;
+
+export declare class Object3D extends THREE.Object3D {
+    static get bindGroupLayout(): GPUBindGroupLayout;
+    private buffer;
+    bindGroup: GPUBindGroup;
+    needsUpdate: boolean;
+    material: ShaderMaterial;
+    geometry: BufferGeometry;
+    private uniformArray;
+    constructor(geometry: BufferGeometry, material: ShaderMaterial);
+    updateMatrixWorld(force?: boolean): void;
+    private _updateBuffer;
+    pipeline: GPURenderPipeline | null;
+    private createPipeline;
+    update(format: GPUTextureFormat): void;
+}
+
+export declare const obstacleDetection: typeof obstacleDetection_ & {
+    getResult(base: string): Promise<number[]>;
+};
+
+declare function obstacleDetection_(opt: ICreateObstacleDetection): Promise<{
+    renderer: Renderer;
+    camera: PerspectiveCamera;
+    data: IData & {
+        map: Map<number, [number, number, number, number]>;
+        linesJson: any[];
+    };
+    depthCubeTexture: CubeTexture;
+    resultCubeTexture: CubeTexture;
+    cubeCamera: CubeCamera;
+    quadObject3D: Object3D;
+    pointsObject3D: Object3D;
+    indexCount: number;
+    resultTextureBuff: Uint32Array<ArrayBuffer>;
+    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;
+}
+
+export declare class PerspectiveCamera extends THREE.PerspectiveCamera {
+    static get bindGroupLayout(): GPUBindGroupLayout;
+    private buffer;
+    bindGroup: GPUBindGroup;
+    private _needsUpdate;
+    get needsUpdate(): boolean;
+    set needsUpdate(v: boolean);
+    private uniformArray;
+    constructor(fov: number, aspect: number, near: number, far: number);
+    private _updateBuffer;
+    updateMatrix(): void;
+    updateMatrixWorld(): void;
+    updateProjectionMatrix(): void;
+    update(): void;
+}
+
+/** 自动推导读取 cubemap face */
+export declare function readCubeTexture(texture: GPUTexture, face?: number, mipLevel?: number, device?: GPUDevice): Promise<{
+    data: Uint8Array<ArrayBuffer>;
+    width: number;
+    height: number;
+    format: "depth32float-stencil8" | "r8unorm" | "r8snorm" | "r8uint" | "r8sint" | "r16unorm" | "r16snorm" | "r16uint" | "r16sint" | "r16float" | "rg8unorm" | "rg8snorm" | "rg8uint" | "rg8sint" | "r32uint" | "r32sint" | "r32float" | "rg16unorm" | "rg16snorm" | "rg16uint" | "rg16sint" | "rg16float" | "rgba8unorm" | "rgba8unorm-srgb" | "rgba8snorm" | "rgba8uint" | "rgba8sint" | "bgra8unorm" | "bgra8unorm-srgb" | "rgb9e5ufloat" | "rgb10a2uint" | "rgb10a2unorm" | "rg11b10ufloat" | "rg32uint" | "rg32sint" | "rg32float" | "rgba16unorm" | "rgba16snorm" | "rgba16uint" | "rgba16sint" | "rgba16float" | "rgba32uint" | "rgba32sint" | "rgba32float" | "stencil8" | "depth16unorm" | "depth24plus" | "depth24plus-stencil8" | "depth32float" | "bc1-rgba-unorm" | "bc1-rgba-unorm-srgb" | "bc2-rgba-unorm" | "bc2-rgba-unorm-srgb" | "bc3-rgba-unorm" | "bc3-rgba-unorm-srgb" | "bc4-r-unorm" | "bc4-r-snorm" | "bc5-rg-unorm" | "bc5-rg-snorm" | "bc6h-rgb-ufloat" | "bc6h-rgb-float" | "bc7-rgba-unorm" | "bc7-rgba-unorm-srgb" | "etc2-rgb8unorm" | "etc2-rgb8unorm-srgb" | "etc2-rgb8a1unorm" | "etc2-rgb8a1unorm-srgb" | "etc2-rgba8unorm" | "etc2-rgba8unorm-srgb" | "eac-r11unorm" | "eac-r11snorm" | "eac-rg11unorm" | "eac-rg11snorm" | "astc-4x4-unorm" | "astc-4x4-unorm-srgb" | "astc-5x4-unorm" | "astc-5x4-unorm-srgb" | "astc-5x5-unorm" | "astc-5x5-unorm-srgb" | "astc-6x5-unorm" | "astc-6x5-unorm-srgb" | "astc-6x6-unorm" | "astc-6x6-unorm-srgb" | "astc-8x5-unorm" | "astc-8x5-unorm-srgb" | "astc-8x6-unorm" | "astc-8x6-unorm-srgb" | "astc-8x8-unorm" | "astc-8x8-unorm-srgb" | "astc-10x5-unorm" | "astc-10x5-unorm-srgb" | "astc-10x6-unorm" | "astc-10x6-unorm-srgb" | "astc-10x8-unorm" | "astc-10x8-unorm-srgb" | "astc-10x10-unorm" | "astc-10x10-unorm-srgb" | "astc-12x10-unorm" | "astc-12x10-unorm-srgb" | "astc-12x12-unorm" | "astc-12x12-unorm-srgb";
+    bytesPerPixel: number;
+}>;
+
+/** 读取buffer
+ * @param buffer
+ * @param size 字节数
+ * @param Type
+ * @returns
+ */
+export declare function readGPUBuffer<T extends ArrayBufferView = Uint8Array>(buffer: GPUBuffer, size: number, Type?: {
+    new (buffer: ArrayBuffer): T;
+}, device?: GPUDevice): Promise<T>;
+
+/**
+ * @param texture
+ * @param options
+ * @param device
+ * @returns
+ */
+export declare function readTextureBuffer(texture: GPUTexture & {
+    width?: number;
+    height?: number;
+    format?: GPUTextureFormat;
+    depthOrArrayLayers?: number;
+}, options?: ReadTextureOptions, device?: GPUDevice): Promise<{
+    data: Uint8Array<ArrayBuffer>;
+    width: number;
+    height: number;
+    bytesPerPixel: number;
+    format: "depth32float-stencil8" | "r8unorm" | "r8snorm" | "r8uint" | "r8sint" | "r16unorm" | "r16snorm" | "r16uint" | "r16sint" | "r16float" | "rg8unorm" | "rg8snorm" | "rg8uint" | "rg8sint" | "r32uint" | "r32sint" | "r32float" | "rg16unorm" | "rg16snorm" | "rg16uint" | "rg16sint" | "rg16float" | "rgba8unorm" | "rgba8unorm-srgb" | "rgba8snorm" | "rgba8uint" | "rgba8sint" | "bgra8unorm" | "bgra8unorm-srgb" | "rgb9e5ufloat" | "rgb10a2uint" | "rgb10a2unorm" | "rg11b10ufloat" | "rg32uint" | "rg32sint" | "rg32float" | "rgba16unorm" | "rgba16snorm" | "rgba16uint" | "rgba16sint" | "rgba16float" | "rgba32uint" | "rgba32sint" | "rgba32float" | "stencil8" | "depth16unorm" | "depth24plus" | "depth24plus-stencil8" | "depth32float" | "bc1-rgba-unorm" | "bc1-rgba-unorm-srgb" | "bc2-rgba-unorm" | "bc2-rgba-unorm-srgb" | "bc3-rgba-unorm" | "bc3-rgba-unorm-srgb" | "bc4-r-unorm" | "bc4-r-snorm" | "bc5-rg-unorm" | "bc5-rg-snorm" | "bc6h-rgb-ufloat" | "bc6h-rgb-float" | "bc7-rgba-unorm" | "bc7-rgba-unorm-srgb" | "etc2-rgb8unorm" | "etc2-rgb8unorm-srgb" | "etc2-rgb8a1unorm" | "etc2-rgb8a1unorm-srgb" | "etc2-rgba8unorm" | "etc2-rgba8unorm-srgb" | "eac-r11unorm" | "eac-r11snorm" | "eac-rg11unorm" | "eac-rg11snorm" | "astc-4x4-unorm" | "astc-4x4-unorm-srgb" | "astc-5x4-unorm" | "astc-5x4-unorm-srgb" | "astc-5x5-unorm" | "astc-5x5-unorm-srgb" | "astc-6x5-unorm" | "astc-6x5-unorm-srgb" | "astc-6x6-unorm" | "astc-6x6-unorm-srgb" | "astc-8x5-unorm" | "astc-8x5-unorm-srgb" | "astc-8x6-unorm" | "astc-8x6-unorm-srgb" | "astc-8x8-unorm" | "astc-8x8-unorm-srgb" | "astc-10x5-unorm" | "astc-10x5-unorm-srgb" | "astc-10x6-unorm" | "astc-10x6-unorm-srgb" | "astc-10x8-unorm" | "astc-10x8-unorm-srgb" | "astc-10x10-unorm" | "astc-10x10-unorm-srgb" | "astc-12x10-unorm" | "astc-12x10-unorm-srgb" | "astc-12x12-unorm" | "astc-12x12-unorm-srgb";
+}>;
+
+declare interface ReadTextureOptions {
+    face?: number;
+    layer?: number;
+    mipLevel?: number;
+}
+
+export declare class Renderer {
+    canvas?: HTMLCanvasElement;
+    context?: GPUCanvasContext;
+    depthTexture: GPUTexture;
+    depthTextureView: GPUTextureView;
+    format: GPUTextureFormat;
+    renderTarget: GPUTextureView | null;
+    depthTarget: GPUTextureView | null;
+    constructor(width?: number, height?: number, format?: GPUTextureFormat);
+    render(meshList: Object3D[], camera: PerspectiveCamera, depthClearValue?: number): void;
+}
+
+export declare const shaderLocationMap: Map<string, number>;
+
+export declare class ShaderMaterial {
+    vertex: string;
+    fragment: string;
+    pipeline?: GPURenderPipeline;
+    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;
+    get needsUniformUpdate(): boolean;
+    set needsUniformUpdate(v: boolean);
+    private _needsBindGroupUpdate;
+    get needsBindGroupUpdate(): boolean;
+    set needsBindGroupUpdate(v: boolean);
+    constructor(options: ShaderMaterialOptions);
+    /**
+     * 初始化uniform
+     * @param uniforms
+     */
+    private _initUniform;
+    /**
+     * 获取绑定组布局
+     * @returns
+     */
+    private _getBindGroupLayout;
+    /**
+     * 创建绑定组
+     */
+    private _createBindGroup;
+    /** 生成uniform 代码
+     * @param type
+     * @returns
+     */
+    private _generateUniformWGSL;
+    /** 生成 顶点着色器入参类型代码
+     * @param attrMap
+     * @returns
+     */
+    private _generateVertexInputWGSL;
+    /**
+     * 生成 Storage 类型代码
+     */
+    private _generateStorageWGSL;
+    /** 创建渲染管线
+     * @param attrMap
+     * @param colorFormat
+     * @param depthFormat
+     * @returns
+     */
+    createPipeline(attrMap: Map<string, GPUAttribute>, colorFormat?: GPUTextureFormat, depthFormat?: GPUTextureFormat): GPURenderPipeline;
+    /**
+     * 更新uniform 数据
+     */
+    private _updateUniform;
+    update(): void;
+    /** 获取buffer
+     * @param name
+     * @returns
+     */
+    getStorageBuffer(name: string): GPUBuffer | undefined;
+}
+
+export declare interface ShaderMaterialOptions {
+    vertex: string;
+    fragment: string;
+    uniforms?: Record<string, {
+        value: UniformValue;
+        write?: boolean;
+        atomic?: boolean;
+    }>;
+    topology?: GPUPrimitiveTopology;
+    side?: GPUCullMode;
+    blend?: GPUBlendState;
+    writeMask?: number | undefined;
+    depthStencil?: Omit<GPUDepthStencilState, "format">;
+    env?: Record<string, boolean>;
+}
+
+export declare class Texture {
+    depthTexture: GPUTexture;
+    depthView: GPUTextureView;
+    texture: GPUTexture;
+    view: GPUTextureView;
+    width: number;
+    height: number;
+    format: GPUTextureFormat;
+    sampler: GPUSampler;
+    private needDepthTexture;
+    private depthOrArrayLayers;
+    private dimension;
+    private viewDimension;
+    constructor(width: number, height?: number, des?: ITextureOption);
+    protected init(width: number, height?: number): void;
+    destroy(): void;
+    static fromByImage(bitmap: ImageBitmap): Promise<Texture>;
+    static fromURL(url: string): Promise<Texture>;
+}
+
+export declare const transparentOption: Omit<GPUColorTargetState, "format">;
+
+declare type UniformValue = Color | Matrix4 | Matrix3 | Texture | CubeTexture | number | Vector2 | Vector3 | Vector4 | number[] | Float32Array | Uint32Array | Uint8Array;
+
+declare type WGSl_TYPE = "f32" | "u32" | "vec2" | "vec3" | "vec4" | "mat3x3" | "mat4x4";
+
+export { }