@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/textures/HDRTextureCube.js

@@ -0,0 +1,50 @@
+import { ErpImage2CubeMap } from "../gfx/generate/convert/ErpImage2CubeMap";
+import { TextureCube } from "../gfx/graphics/webGpu/core/texture/TextureCube";
+import { GPUTextureFormat } from "../gfx/graphics/webGpu/WebGPUConst";
+import { webGPUContext } from "../gfx/graphics/webGpu/Context3D";
+import { VirtualTexture } from "./VirtualTexture";
+import { FileLoader } from "../loader/FileLoader";
+import { RGBEParser } from "../loader/parser/RGBEParser";
+import { TextureCubeFaceData } from "./TextureCubeFaceData";
+export class HDRTextureCube extends TextureCube {
+    constructor() {
+        super();
+        this.useMipmap = true;
+        this.format = GPUTextureFormat.rgba16float;
+        this.isHDRTexture = true;
+        this._faceData = new TextureCubeFaceData(this);
+    }
+    createFromHDRData(size, data) {
+        let texture = new VirtualTexture(data.width, data.height, GPUTextureFormat.rgba16float, false, GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING);
+        let float32Array = new Float32Array(data.array);
+        ErpImage2CubeMap.convertRGBE2RGBA(texture, float32Array);
+        this.createFromTexture(size, texture);
+        return this;
+    }
+    createFromTexture(size, texture) {
+        this.width = this.height = size;
+        this.textureBindingLayout.viewDimension = "cube";
+        let mipmapSize = this.width;
+        this.mipmapCount = 1;
+        while (mipmapSize > 16) {
+            mipmapSize /= 2;
+            this.mipmapCount++;
+        }
+        this.createTextureDescriptor(size, size, this.mipmapCount, this.format);
+        this.textureDescriptor.size = {
+            width: size,
+            height: size,
+            depthOrArrayLayers: 6,
+        };
+        this.textureDescriptor.dimension = "2d";
+        this.gpuSampler = webGPUContext.device.createSampler(this);
+        this._faceData.uploadErpTexture(texture);
+        return this;
+    }
+    async load(url, loaderFunctions) {
+        this._url = url;
+        let loader = new FileLoader();
+        let parser = await loader.load(url, RGBEParser, loaderFunctions);
+        return parser.getCubeTexture();
+    }
+}

package/dist/src/textures/LDRTextureCube.d.ts

@@ -0,0 +1,13 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { TextureCube } from "../gfx/graphics/webGpu/core/texture/TextureCube";
+import { LoaderFunctions } from "../loader/LoaderFunctions";
+import { TextureCubeFaceData } from "./TextureCubeFaceData";
+export declare class LDRTextureCube extends TextureCube {
+    protected _faceData: TextureCubeFaceData;
+    private _url;
+    get ldrImageUrl(): string;
+    constructor();
+    load(url: string, loaderFunctions?: LoaderFunctions): Promise<LDRTextureCube>;
+    private createFromLDRTexture;
+    createFromTexture(size: number, texture: Texture): this;
+}

package/dist/src/textures/LDRTextureCube.js

@@ -0,0 +1,49 @@
+import { GPUTextureFormat } from "../gfx/graphics/webGpu/WebGPUConst";
+import { webGPUContext } from "../gfx/graphics/webGpu/Context3D";
+import { TextureCube } from "../gfx/graphics/webGpu/core/texture/TextureCube";
+import { BitmapTexture2D } from "./BitmapTexture2D";
+import { TextureCubeFaceData } from "./TextureCubeFaceData";
+export class LDRTextureCube extends TextureCube {
+    get ldrImageUrl() {
+        return this._url;
+    }
+    constructor() {
+        super();
+        this.useMipmap = true;
+        this.format = GPUTextureFormat.rgba16float;
+        this._faceData = new TextureCubeFaceData(this);
+    }
+    async load(url, loaderFunctions) {
+        this._url = url;
+        let bitmapTexture = new BitmapTexture2D(false);
+        await bitmapTexture.load(url, loaderFunctions);
+        this.createFromLDRTexture(bitmapTexture);
+        return this;
+    }
+    createFromLDRTexture(srcTexture) {
+        let size = Math.log2(srcTexture.width / 4);
+        size = Math.pow(2, Math.round(size));
+        this.createFromTexture(size, srcTexture);
+        return this;
+    }
+    createFromTexture(size, texture) {
+        this.width = this.height = size;
+        this.textureBindingLayout.viewDimension = "cube";
+        let mipmapSize = this.width;
+        this.mipmapCount = 1;
+        while (mipmapSize > 16) {
+            mipmapSize /= 2;
+            this.mipmapCount++;
+        }
+        this.createTextureDescriptor(size, size, this.mipmapCount, this.format);
+        this.textureDescriptor.size = {
+            width: size,
+            height: size,
+            depthOrArrayLayers: 6,
+        };
+        this.textureDescriptor.dimension = "2d";
+        this.gpuSampler = webGPUContext.device.createSampler(this);
+        this._faceData.uploadErpTexture(texture);
+        return this;
+    }
+}

package/dist/src/textures/RenderTexture.d.ts

@@ -0,0 +1,12 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+export declare class RenderTexture extends Texture {
+    resolveTarget: GPUTextureView;
+    sampleCount: number;
+    autoResize?: boolean;
+    clear?: boolean;
+    constructor(width: number, height: number, format?: GPUTextureFormat, useMipMap?: boolean, usage?: GPUFlagsConstant, numberLayer?: number, sampleCount?: number, clear?: boolean, autoResize?: boolean);
+    resize(width: any, height: any): void;
+    create(width: number, height: number, useMiamp?: boolean): void;
+    clone(): RenderTexture;
+    readTextureToImage(): ArrayBuffer;
+}

package/dist/src/textures/RenderTexture.js

@@ -0,0 +1,140 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { GPUAddressMode, GPUTextureFormat, } from "../gfx/graphics/webGpu/WebGPUConst";
+import { webGPUContext } from "../gfx/graphics/webGpu/Context3D";
+import { GPUContext } from "../gfx/renderJob/GPUContext";
+import { UUID } from "../util/Global";
+import { CResizeEvent } from "..";
+export class RenderTexture extends Texture {
+    constructor(width, height, format = GPUTextureFormat.rgba8unorm, useMipMap = false, usage, numberLayer = 1, sampleCount = 0, clear = true, autoResize = true) {
+        super(width, height, numberLayer);
+        this.name = UUID();
+        this.autoResize = autoResize;
+        this.useMipmap = useMipMap;
+        this.sampleCount = sampleCount;
+        this.format = format;
+        this.numberLayer = numberLayer;
+        this.clear = clear;
+        if (usage != undefined) {
+            this.usage = usage;
+        }
+        else {
+            this.usage =
+                usage |
+                    GPUTextureUsage.RENDER_ATTACHMENT |
+                    GPUTextureUsage.TEXTURE_BINDING |
+                    GPUTextureUsage.COPY_SRC |
+                    GPUTextureUsage.COPY_DST;
+        }
+        this.resize(width, height);
+        if (this.autoResize) {
+            webGPUContext.addEventListener(CResizeEvent.RESIZE, (e) => {
+                let { width, height } = e.data;
+                this.resize(width, height);
+                this._textureChange = true;
+            }, this);
+        }
+    }
+    resize(width, height) {
+        let device = webGPUContext.device;
+        if (this.gpuTexture) {
+            Texture.delayDestroyTexture(this.gpuTexture);
+            this.gpuTexture = null;
+            this.view = null;
+        }
+        this.width = width;
+        this.height = height;
+        this.createTextureDescriptor(width, height, 1, this.format, this.usage, this.numberLayer, this.sampleCount);
+        this.useMipmap = false;
+        this.visibility =
+            GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT;
+        if (this.format == GPUTextureFormat.rgba32float) {
+            this.samplerBindingLayout.type = `non-filtering`;
+            this.textureBindingLayout.sampleType = `unfilterable-float`;
+            this.gpuSampler = device.createSampler({});
+        }
+        else if (this.format == GPUTextureFormat.depth32float) {
+            this.samplerBindingLayout.type = `filtering`;
+            this.sampler_comparisonBindingLayout.type = `comparison`;
+            this.textureBindingLayout.sampleType = `depth`;
+            this.gpuSampler = webGPUContext.device.createSampler({});
+            this.gpuSampler_comparison = webGPUContext.device.createSampler({
+                compare: "less",
+                label: "sampler_comparison",
+            });
+        }
+        else if (this.format == GPUTextureFormat.depth24plus) {
+            this.samplerBindingLayout = {
+                type: `filtering`,
+            };
+            this.sampler_comparisonBindingLayout = {
+                type: "comparison",
+            };
+            this.textureBindingLayout.sampleType = `depth`;
+            this.gpuSampler = webGPUContext.device.createSampler({});
+            this.gpuSampler_comparison = webGPUContext.device.createSampler({
+                compare: "less",
+                label: "sampler_comparison",
+            });
+        }
+        else {
+            this.samplerBindingLayout.type = `filtering`;
+            this.textureBindingLayout.sampleType = `float`;
+            if (this.sampleCount > 0) {
+                this.textureBindingLayout.multisampled = true;
+            }
+            this.minFilter = "linear";
+            this.magFilter = "linear";
+            this.mipmapFilter = `linear`;
+            this.addressModeU = GPUAddressMode.clamp_to_edge;
+            this.addressModeV = GPUAddressMode.clamp_to_edge;
+            this.gpuSampler = device.createSampler(this);
+        }
+        this._textureChange = true;
+    }
+    create(width, height, useMiamp = true) {
+        let device = webGPUContext.device;
+        const bytesPerRow = width * 4;
+        let td = new Float32Array(width * height * 4);
+        const textureDataBuffer = device.createBuffer({
+            size: td.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+        });
+        device.queue.writeBuffer(textureDataBuffer, 0, td);
+        const commandEncoder = GPUContext.beginCommandEncoder();
+        commandEncoder.copyBufferToTexture({
+            buffer: textureDataBuffer,
+            bytesPerRow: bytesPerRow,
+        }, {
+            texture: this.getGPUTexture(),
+        }, {
+            width: width,
+            height: height,
+            depthOrArrayLayers: 1,
+        });
+        GPUContext.endCommandEncoder(commandEncoder);
+    }
+    clone() {
+        let texture = new RenderTexture(this.width, this.height, this.format, this.useMipmap, this.usage, this.numberLayer, this.sampleCount, this.clear, this.autoResize);
+        texture.name = "clone_" + texture.name;
+        return texture;
+    }
+    readTextureToImage() {
+        let device = webGPUContext.device;
+        let w = webGPUContext.windowWidth;
+        let h = webGPUContext.windowHeight;
+        const bytesPerRow = w * 4;
+        let td = new Float32Array(w * h * 4);
+        const textureBuffer = device.createBuffer({
+            size: td.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+        });
+        const commandEncoder = GPUContext.beginCommandEncoder();
+        commandEncoder.copyTextureToBuffer({
+            texture: this.getGPUTexture(),
+        }, {
+            buffer: textureBuffer,
+        }, [w, h]);
+        let arryBuffer = textureBuffer.getMappedRange(0, td.byteLength);
+        return arryBuffer;
+    }
+}

package/dist/src/textures/SolidColorSky.d.ts

@@ -0,0 +1,11 @@
+import { Color } from "../math/Color";
+import { LDRTextureCube } from "./LDRTextureCube";
+export declare class SolidColorSky extends LDRTextureCube {
+    private _internalTexture;
+    private readonly _minSize;
+    private _skyColor;
+    constructor(color: Color);
+    private changeColor;
+    get color(): Color;
+    set color(value: Color);
+}

package/dist/src/textures/SolidColorSky.js

@@ -0,0 +1,29 @@
+import { Engine3D } from "../Engine3D";
+import { Float16ArrayTexture } from "./Float16ArrayTexture";
+import { LDRTextureCube } from "./LDRTextureCube";
+export class SolidColorSky extends LDRTextureCube {
+    constructor(color) {
+        super();
+        this._minSize = 32;
+        this._skyColor = color;
+        this._internalTexture = new Float16ArrayTexture();
+        let numbers = [];
+        Engine3D.res.fillColor(numbers, this._minSize, this._minSize, this.color.r, this.color.g, this.color.b, this.color.a);
+        this._internalTexture.create(this._minSize, this._minSize, numbers, false);
+        this.createFromTexture(this._minSize, this._internalTexture);
+        return this;
+    }
+    changeColor(color) {
+        this._skyColor = color;
+        Engine3D.res.fillColor(this._internalTexture.floatArray, this._minSize, this._minSize, this.color.r, this.color.g, this.color.b, this.color.a);
+        this._internalTexture.updateTexture(this._minSize, this._minSize, this._internalTexture.floatArray, false);
+        this._faceData.uploadTexture(0, this._internalTexture);
+        return this;
+    }
+    get color() {
+        return this._skyColor;
+    }
+    set color(value) {
+        this.changeColor(value);
+    }
+}

package/dist/src/textures/TextureCubeFaceData.d.ts

@@ -0,0 +1,19 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+export declare class TextureCubeFaceData {
+    faceTextureRef: {
+        [key: string]: {
+            t: GPUTexture;
+            v: GPUTextureView;
+        };
+    };
+    private _texture;
+    constructor(texture: Texture);
+    uploadTexture(mip: number, texture: Texture): this;
+    uploadErpTexture(texture: Texture): this;
+    getGpuSource(mip: number): {
+        t: GPUTexture;
+        v: GPUTextureView;
+    };
+    private generateMipmap;
+    private generateMipmapAtLevel;
+}

package/dist/src/textures/TextureCubeFaceData.js

@@ -0,0 +1,55 @@
+import { ErpImage2CubeMap } from "../gfx/generate/convert/ErpImage2CubeMap";
+import { IBLEnvMapCreator } from "../gfx/generate/convert/IBLEnvMapCreator";
+export class TextureCubeFaceData {
+    constructor(texture) {
+        this._texture = texture;
+        this.faceTextureRef = {};
+    }
+    uploadTexture(mip, texture) {
+        let gpuSource = this.getGpuSource(mip);
+        ErpImage2CubeMap.makeTextureCube(texture, this._texture.width, gpuSource.v);
+        return this;
+    }
+    uploadErpTexture(texture) {
+        let gpuSource = this.getGpuSource(0);
+        ErpImage2CubeMap.makeTextureCube(texture, this._texture.width, gpuSource.v);
+        this.generateMipmap(texture);
+        return this;
+    }
+    getGpuSource(mip) {
+        let source = this.faceTextureRef[mip];
+        if (!source) {
+            source = {
+                t: this._texture.getGPUTexture(),
+                v: this._texture.getGPUTexture().createView({
+                    format: this._texture.format,
+                    dimension: "2d-array",
+                    baseMipLevel: mip,
+                    mipLevelCount: 1,
+                    arrayLayerCount: 6,
+                }),
+            };
+            this.faceTextureRef[mip] = source;
+        }
+        return source;
+    }
+    generateMipmap(texture) {
+        let mipmap = 1;
+        while (mipmap < this._texture.mipmapCount) {
+            this.generateMipmapAtLevel(mipmap, texture);
+            mipmap++;
+        }
+    }
+    generateMipmapAtLevel(mipmap, erpTexture, pow = 3.0) {
+        let mipFaceSize = this._texture.width / Math.pow(2, mipmap);
+        let image = {
+            width: mipFaceSize,
+            height: mipFaceSize,
+            erpTexture: erpTexture,
+        };
+        let roughness = (mipmap + 1) / this._texture.mipmapCount;
+        roughness = Math.pow(roughness, pow);
+        let gpuSource = this.getGpuSource(mipmap);
+        IBLEnvMapCreator.importantSample(image, mipFaceSize, roughness, gpuSource.v);
+    }
+}

package/dist/src/textures/Uint8ArrayTexture.d.ts

@@ -0,0 +1,6 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+export declare class Uint8ArrayTexture extends Texture {
+    private _dataBuffer;
+    create(width: number, height: number, data: Uint8Array, useMipmap?: boolean): this;
+    updateTexture(width: number, height: number, data: Uint8Array): void;
+}

package/dist/src/textures/Uint8ArrayTexture.js

@@ -0,0 +1,63 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { TextureMipmapGenerator } from "../gfx/graphics/webGpu/core/texture/TextureMipmapGenerator";
+import { GPUTextureFormat } from "../gfx/graphics/webGpu/WebGPUConst";
+import { webGPUContext } from "../gfx/graphics/webGpu/Context3D";
+import { GPUContext } from "../gfx/renderJob/GPUContext";
+export class Uint8ArrayTexture extends Texture {
+    create(width, height, data, useMipmap = false) {
+        let device = webGPUContext.device;
+        const bytesPerRow = Math.ceil((width * 4) / 256) * 256;
+        this.format = GPUTextureFormat.rgba8unorm;
+        this.mipmapCount = Math.floor(useMipmap ? Math.log2(width) : 1);
+        this.createTextureDescriptor(width, height, this.mipmapCount, this.format);
+        const textureDataBuffer = (this._dataBuffer = device.createBuffer({
+            size: data.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+        }));
+        device.queue.writeBuffer(textureDataBuffer, 0, data);
+        const commandEncoder = GPUContext.beginCommandEncoder();
+        commandEncoder.copyBufferToTexture({
+            buffer: textureDataBuffer,
+            bytesPerRow: bytesPerRow,
+        }, {
+            texture: this.getGPUTexture(),
+        }, {
+            width: width,
+            height: height,
+            depthOrArrayLayers: 1,
+        });
+        GPUContext.endCommandEncoder(commandEncoder);
+        if (useMipmap) {
+            TextureMipmapGenerator.webGPUGenerateMipmap(this);
+        }
+        return this;
+    }
+    updateTexture(width, height, data) {
+        let device = webGPUContext.device;
+        const bytesPerRow = Math.ceil((width * 4) / 256) * 256;
+        this.mipmapCount = Math.floor(true ? Math.log2(width) : 1);
+        this._dataBuffer && this._dataBuffer.destroy();
+        this._dataBuffer = null;
+        const textureDataBuffer = (this._dataBuffer = device.createBuffer({
+            size: data.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+        }));
+        device.queue.writeBuffer(textureDataBuffer, 0, data);
+        const commandEncoder = GPUContext.beginCommandEncoder();
+        commandEncoder.copyBufferToTexture({
+            buffer: textureDataBuffer,
+            bytesPerRow: bytesPerRow,
+        }, {
+            texture: this.getGPUTexture(),
+        }, {
+            width: width,
+            height: height,
+            depthOrArrayLayers: 1,
+        });
+        GPUContext.endCommandEncoder(commandEncoder);
+        this.gpuSampler = device.createSampler(this);
+        if (this.mipmapCount > 1) {
+            TextureMipmapGenerator.webGPUGenerateMipmap(this);
+        }
+    }
+}

package/dist/src/textures/VirtualTexture.d.ts

@@ -0,0 +1,29 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+/**
+ * 虚拟纹理 类似于 Three.js 的 WebGLRenderTarget
+ */
+export declare class VirtualTexture extends Texture {
+    resolveTarget: GPUTextureView;
+    sampleCount: number;
+    clone(): VirtualTexture;
+    /**
+     * create virtual texture
+     * @param width width of texture
+     * @param height height of texture
+     * @param format GPUTextureFormat, default value is rgba8unorm
+     * @param useMipmap whether or not gen mipmap
+     * @returns
+     */
+    constructor(width: number, height: number, format?: GPUTextureFormat, useMipMap?: boolean, usage?: GPUFlagsConstant, numberLayer?: number, sampleCount?: number, mipmapCount?: number);
+    resize(width: any, height: any): void;
+    /**
+     * create rt texture
+     * @param width texture width
+     * @param height texture height
+     * @param data  texture pixel data
+     * @param useMipmap texture use mipmap switch
+     * @returns
+     */
+    create(width: number, height: number, useMiamp?: boolean): void;
+    readTextureToImage(): ArrayBuffer;
+}

package/dist/src/textures/VirtualTexture.js

@@ -0,0 +1,152 @@
+import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
+import { GPUAddressMode, GPUTextureFormat, } from "../gfx/graphics/webGpu/WebGPUConst";
+import { webGPUContext } from "../gfx/graphics/webGpu/Context3D";
+import { GPUContext } from "../gfx/renderJob/GPUContext";
+import { UUID } from "../util/Global";
+/**
+ * 虚拟纹理 类似于 Three.js 的 WebGLRenderTarget
+ */
+export class VirtualTexture extends Texture {
+    clone() {
+        let texture = new VirtualTexture(this.width, this.height, this.format, this.useMipmap, this.usage, this.numberLayer, this.sampleCount);
+        texture.name = "clone_" + texture.name;
+        return texture;
+    }
+    /**
+     * create virtual texture
+     * @param width width of texture
+     * @param height height of texture
+     * @param format GPUTextureFormat, default value is rgba8unorm
+     * @param useMipmap whether or not gen mipmap
+     * @returns
+     */
+    constructor(width, height, format = GPUTextureFormat.rgba8unorm, useMipMap = false, usage, numberLayer = 1, sampleCount = 0, mipmapCount = 1) {
+        super(width, height, numberLayer);
+        let device = webGPUContext.device;
+        this.name = UUID();
+        this.useMipmap = useMipMap;
+        this.sampleCount = sampleCount;
+        this.format = format;
+        this.numberLayer = numberLayer;
+        this.mipmapCount = mipmapCount;
+        if (usage != undefined) {
+            this.usage = usage;
+        }
+        else {
+            this.usage =
+                usage |
+                    GPUTextureUsage.RENDER_ATTACHMENT |
+                    GPUTextureUsage.TEXTURE_BINDING |
+                    GPUTextureUsage.COPY_SRC |
+                    GPUTextureUsage.COPY_DST;
+        }
+        this.resize(width, height);
+    }
+    resize(width, height) {
+        let device = webGPUContext.device;
+        if (this.gpuTexture) {
+            Texture.delayDestroyTexture(this.gpuTexture);
+            this.gpuTexture = null;
+            this.view = null;
+        }
+        this.width = width;
+        this.height = height;
+        this.createTextureDescriptor(width, height, this.mipmapCount, this.format, this.usage, this.numberLayer, this.sampleCount);
+        this.useMipmap = false;
+        this.visibility =
+            GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT;
+        if (this.format == GPUTextureFormat.rgba32float) {
+            this.samplerBindingLayout.type = `non-filtering`;
+            this.textureBindingLayout.sampleType = `unfilterable-float`;
+            this.gpuSampler = device.createSampler({});
+        }
+        else if (this.format == GPUTextureFormat.depth32float) {
+            this.samplerBindingLayout.type = `filtering`;
+            this.sampler_comparisonBindingLayout.type = `comparison`;
+            this.textureBindingLayout.sampleType = `depth`;
+            this.gpuSampler = webGPUContext.device.createSampler({});
+            this.gpuSampler_comparison = webGPUContext.device.createSampler({
+                compare: "less",
+                label: "sampler_comparison",
+            });
+        }
+        else if (this.format == GPUTextureFormat.depth24plus) {
+            this.samplerBindingLayout = {
+                type: `filtering`,
+            };
+            this.sampler_comparisonBindingLayout = {
+                type: "comparison",
+            };
+            this.textureBindingLayout.sampleType = `depth`;
+            this.gpuSampler = webGPUContext.device.createSampler({});
+            this.gpuSampler_comparison = webGPUContext.device.createSampler({
+                compare: "less",
+                label: "sampler_comparison",
+            });
+        }
+        else {
+            this.samplerBindingLayout.type = `filtering`;
+            this.textureBindingLayout.sampleType = `float`;
+            if (this.sampleCount > 0) {
+                this.textureBindingLayout.multisampled = true;
+            }
+            this.minFilter = `linear`;
+            this.magFilter = "linear";
+            this.mipmapFilter = `nearest`;
+            this.maxAnisotropy = 1;
+            this.addressModeU = GPUAddressMode.mirror_repeat;
+            this.addressModeV = GPUAddressMode.mirror_repeat;
+            this.gpuSampler = device.createSampler(this);
+        }
+        this._textureChange = true;
+    }
+    /**
+     * create rt texture
+     * @param width texture width
+     * @param height texture height
+     * @param data  texture pixel data
+     * @param useMipmap texture use mipmap switch
+     * @returns
+     */
+    create(width, height, useMiamp = true) {
+        let device = webGPUContext.device;
+        const bytesPerRow = width * 4;
+        let td = new Float32Array(width * height * 4);
+        const textureDataBuffer = device.createBuffer({
+            size: td.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+        });
+        device.queue.writeBuffer(textureDataBuffer, 0, td);
+        const commandEncoder = GPUContext.beginCommandEncoder();
+        commandEncoder.copyBufferToTexture({
+            buffer: textureDataBuffer,
+            bytesPerRow: bytesPerRow,
+        }, {
+            texture: this.getGPUTexture(),
+        }, {
+            width: width,
+            height: height,
+            depthOrArrayLayers: 1,
+        });
+        GPUContext.endCommandEncoder(commandEncoder);
+    }
+    readTextureToImage() {
+        let device = webGPUContext.device;
+        let w = webGPUContext.windowWidth;
+        let h = webGPUContext.windowHeight;
+        const bytesPerRow = w * 4;
+        let td = new Float32Array(w * h * 4);
+        const textureBuffer = device.createBuffer({
+            size: td.byteLength,
+            usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+        });
+        const commandEncoder = GPUContext.beginCommandEncoder();
+        commandEncoder.copyTextureToBuffer({
+            texture: this.getGPUTexture(),
+        }, {
+            buffer: textureBuffer,
+        }, [w, h]);
+        let arryBuffer = textureBuffer.getMappedRange(0, td.byteLength);
+        return arryBuffer;
+    }
+}

package/dist/src/util/AxisObject.d.ts

@@ -0,0 +1,11 @@
+import { Object3D } from "../core/entities/Object3D";
+/**
+ * 包含xyz坐标的OBJECT3D
+ * @group Util
+ */
+export declare class AxisObject extends Object3D {
+    length: number;
+    thickness: number;
+    constructor(length: number, thickness?: number);
+    init(): void;
+}