@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/gfx/renderJob/post/GlobalFog.d.ts

@@ -0,0 +1,69 @@
+import { Color } from "../../../math/Color";
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+export declare class GlobalFog extends PostBase {
+    /**
+     * @internal
+     */
+    private fogSetting;
+    fogOpTexture: VirtualTexture;
+    private fogCompute;
+    private fogUniform;
+    private rendererPassState;
+    constructor();
+    private createCompute;
+    private uploadSetting;
+    rtFrame: RTFrame;
+    private createResource;
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */
+    onDetach(view: View3D): void;
+    set fogType(v: number);
+    get fogType(): number;
+    set fogHeightScale(v: number);
+    get fogHeightScale(): number;
+    set start(v: number);
+    get start(): number;
+    set end(v: number);
+    get end(): number;
+    set ins(v: number);
+    get ins(): number;
+    set density(v: number);
+    get density(): number;
+    set skyRoughness(v: number);
+    get skyRoughness(): number;
+    set skyFactor(v: number);
+    get skyFactor(): number;
+    set overrideSkyFactor(v: number);
+    get overrideSkyFactor(): number;
+    /**
+     * @internal
+     */
+    get fogColor(): Color;
+    /**
+     * @internal
+     */
+    set fogColor(value: Color);
+    set falloff(v: number);
+    get falloff(): number;
+    set rayLength(v: number);
+    get rayLength(): number;
+    set scatteringExponent(v: number);
+    get scatteringExponent(): number;
+    set dirHeightLine(v: number);
+    get dirHeightLine(): number;
+    private _lastSkyTexture;
+    private getSkyTexture;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+    onResize(): void;
+}

package/dist/src/gfx/renderJob/post/GlobalFog.js

@@ -0,0 +1,208 @@
+import { GlobalFog_shader } from "../../../assets/shader/post/GlobalFog_shader";
+import { ShaderLib } from "../../../assets/shader/ShaderLib";
+import { Engine3D } from "../../../Engine3D";
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { GPUTextureFormat } from "../../graphics/webGpu/WebGPUConst";
+import { webGPUContext } from "../../graphics/webGpu/Context3D";
+import { PostBase } from "./PostBase";
+import { GBufferFrame } from "../frame/GBufferFrame";
+import { SkyRenderer } from "../../../components/renderer/SkyRenderer";
+import { EntityCollect } from "../collect/EntityCollect";
+import { RTDescriptor } from "../../graphics/webGpu/descriptor/RTDescriptor";
+import { RTFrame } from "../frame/RTFrame";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { UniformGPUBuffer } from "../../graphics/webGpu/core/buffer/UniformGPUBuffer";
+import { GPUContext } from "../GPUContext";
+import { WebGPUDescriptorCreator } from "../../graphics/webGpu/descriptor/WebGPUDescriptorCreator";
+import { GlobalBindGroup } from "../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
+export class GlobalFog extends PostBase {
+    constructor() {
+        super();
+        this.fogSetting = Engine3D.setting.render.postProcessing.globalFog;
+    }
+    createCompute(view) {
+        ShaderLib.register("GlobalFog_shader", GlobalFog_shader);
+        this.fogCompute = new ComputeShader(GlobalFog_shader);
+        this.fogUniform = new UniformGPUBuffer(4 * 5); //vector4 * 5
+        this.fogCompute.setUniformBuffer("fogUniform", this.fogUniform);
+        let rtFrame = GBufferFrame.getGBufferFrame(GBufferFrame.colorPass_GBuffer);
+        this.fogCompute.setSamplerTexture("gBufferTexture", rtFrame.getCompressGBufferTexture());
+        this.fogCompute.setSamplerTexture("inTex", rtFrame.getColorTexture());
+        this._lastSkyTexture = this.getSkyTexture();
+        this.fogCompute.setSamplerTexture(`prefilterMap`, this._lastSkyTexture);
+        this.fogCompute.setStorageTexture(`outTex`, this.fogOpTexture);
+        this.rendererPassState = WebGPUDescriptorCreator.createRendererPassState(this.rtFrame, null);
+        this.rendererPassState.label = "FOG";
+        let lightUniformEntries = GlobalBindGroup.getLightEntries(view.scene);
+        this.fogCompute.setStorageBuffer(`lightBuffer`, lightUniformEntries.storageGPUBuffer);
+    }
+    uploadSetting() {
+        let fogUniform = this.fogUniform;
+        let globalFog = this.fogSetting;
+        fogUniform.setColor("fogColor", globalFog.fogColor);
+        fogUniform.setFloat("fogType", globalFog.fogType);
+        fogUniform.setFloat("fogHeightScale", globalFog.fogHeightScale);
+        fogUniform.setFloat("start", globalFog.start);
+        fogUniform.setFloat("end", globalFog.end);
+        fogUniform.setFloat("density", globalFog.density);
+        fogUniform.setFloat("ins", globalFog.ins);
+        fogUniform.setFloat("falloff", globalFog.falloff);
+        fogUniform.setFloat("rayLength", globalFog.rayLength);
+        fogUniform.setFloat("scatteringExponent", globalFog.scatteringExponent);
+        fogUniform.setFloat("dirHeightLine", globalFog.dirHeightLine);
+        fogUniform.setFloat("skyFactor", globalFog.skyFactor);
+        fogUniform.setFloat("skyRoughness", globalFog.skyRoughness);
+        fogUniform.setFloat("overrideSkyFactor", globalFog.overrideSkyFactor);
+        fogUniform.setFloat("isSkyHDR", 0);
+        fogUniform.apply();
+        this.fogCompute.setUniformBuffer("fogUniform", this.fogUniform);
+    }
+    createResource() {
+        let [w, h] = webGPUContext.presentationSize;
+        this.fogOpTexture = new VirtualTexture(w, h, GPUTextureFormat.rgba16float, false, GPUTextureUsage.STORAGE_BINDING |
+            GPUTextureUsage.COPY_DST |
+            GPUTextureUsage.COPY_SRC |
+            GPUTextureUsage.TEXTURE_BINDING);
+        this.fogOpTexture.name = "fogTex";
+        let fogDesc = new RTDescriptor();
+        fogDesc.loadOp = `load`;
+        this.rtFrame = new RTFrame([this.fogOpTexture], [fogDesc]);
+    }
+    /**
+     * @internal
+     */
+    onAttach(view) {
+        Engine3D.setting.render.postProcessing.globalFog.enable = true;
+    }
+    /**
+     * @internal
+     */
+    onDetach(view) {
+        Engine3D.setting.render.postProcessing.globalFog.enable = false;
+    }
+    set fogType(v) {
+        this.fogSetting.fogType = v;
+    }
+    get fogType() {
+        return this.fogSetting.fogType;
+    }
+    set fogHeightScale(v) {
+        this.fogSetting.fogHeightScale = v;
+    }
+    get fogHeightScale() {
+        return this.fogSetting.fogHeightScale;
+    }
+    set start(v) {
+        this.fogSetting.start = v;
+    }
+    get start() {
+        return this.fogSetting.start;
+    }
+    set end(v) {
+        this.fogSetting.end = v;
+    }
+    get end() {
+        return this.fogSetting.end;
+    }
+    set ins(v) {
+        this.fogSetting.ins = v;
+    }
+    get ins() {
+        return this.fogSetting.ins;
+    }
+    set density(v) {
+        this.fogSetting.density = v;
+    }
+    get density() {
+        return this.fogSetting.density;
+    }
+    set skyRoughness(v) {
+        this.fogSetting.skyRoughness = v;
+    }
+    get skyRoughness() {
+        return this.fogSetting.skyRoughness;
+    }
+    set skyFactor(v) {
+        this.fogSetting.skyFactor = v;
+    }
+    get skyFactor() {
+        return this.fogSetting.skyFactor;
+    }
+    set overrideSkyFactor(v) {
+        this.fogSetting.overrideSkyFactor = v;
+    }
+    get overrideSkyFactor() {
+        return this.fogSetting.overrideSkyFactor;
+    }
+    /**
+     * @internal
+     */
+    get fogColor() {
+        return this.fogSetting.fogColor;
+    }
+    /**
+     * @internal
+     */
+    set fogColor(value) {
+        this.fogSetting.fogColor.copyFrom(value);
+    }
+    set falloff(v) {
+        this.fogSetting.falloff = v;
+    }
+    get falloff() {
+        return this.fogSetting.falloff;
+    }
+    set rayLength(v) {
+        this.fogSetting.rayLength = v;
+    }
+    get rayLength() {
+        return this.fogSetting.rayLength;
+    }
+    set scatteringExponent(v) {
+        this.fogSetting.scatteringExponent = v;
+    }
+    get scatteringExponent() {
+        return this.fogSetting.scatteringExponent;
+    }
+    set dirHeightLine(v) {
+        this.fogSetting.dirHeightLine = v;
+    }
+    get dirHeightLine() {
+        return this.fogSetting.dirHeightLine;
+    }
+    getSkyTexture() {
+        let texture = Engine3D.res.defaultSky;
+        if (EntityCollect.instance.sky instanceof SkyRenderer) {
+            texture = EntityCollect.instance.sky.map;
+        }
+        return texture;
+    }
+    /**
+     * @internal
+     */
+    render(view, command) {
+        if (!this.fogCompute) {
+            this.createResource();
+            this.createCompute(view);
+            this.onResize();
+            let globalUniform = GlobalBindGroup.getCameraGroup(view.camera);
+            this.fogCompute.setUniformBuffer("globalUniform", globalUniform.uniformGPUBuffer);
+        }
+        let skyTexture = this.getSkyTexture();
+        if (skyTexture != this._lastSkyTexture) {
+            this._lastSkyTexture = skyTexture;
+            this.fogCompute.setSamplerTexture(`prefilterMap`, this._lastSkyTexture);
+        }
+        this.fogCompute.setUniformFloat("isSkyHDR", skyTexture.isHDRTexture ? 1 : 0);
+        this.uploadSetting();
+        GPUContext.computeCommand(command, [this.fogCompute]);
+        GPUContext.lastRenderPassState = this.rendererPassState;
+    }
+    onResize() {
+        let [w, h] = webGPUContext.presentationSize;
+        this.fogOpTexture.resize(w, h);
+        this.fogCompute.workerSizeX = Math.ceil(this.fogOpTexture.width / 8);
+        this.fogCompute.workerSizeY = Math.ceil(this.fogOpTexture.height / 8);
+        this.fogCompute.workerSizeZ = 1;
+    }
+}

package/dist/src/gfx/renderJob/post/GodRayPost.d.ts

@@ -0,0 +1,56 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { StorageGPUBuffer } from "../../graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { RendererPassState } from "../passRenderer/state/RendererPassState";
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+import { RTFrame } from "../frame/RTFrame";
+export declare class GodRayPost extends PostBase {
+    /**
+     * @internal
+     */
+    godRayTexture: VirtualTexture;
+    /**
+     * @internal
+     */
+    rendererPassState: RendererPassState;
+    /**
+     * @internal
+     */
+    godRayCompute: ComputeShader;
+    /**
+     * @internal
+     */
+    historyGodRayData: StorageGPUBuffer;
+    /**
+     * @internal
+     */
+    godRaySetting: StorageGPUBuffer;
+    rtFrame: RTFrame;
+    constructor();
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */ Render: any;
+    onDetach(view: View3D): void;
+    get blendColor(): boolean;
+    set blendColor(value: boolean);
+    get rayMarchCount(): number;
+    set rayMarchCount(value: number);
+    get scatteringExponent(): number;
+    set scatteringExponent(value: number);
+    get intensity(): number;
+    set intensity(value: number);
+    private createGUI;
+    private removeGUI;
+    private createCompute;
+    private createResource;
+    onResize(): void;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+}

package/dist/src/gfx/renderJob/post/GodRayPost.js

@@ -0,0 +1,126 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { GlobalBindGroup } from "../../graphics/webGpu/core/bindGroups/GlobalBindGroup";
+import { StorageGPUBuffer } from "../../graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { UniformGPUBuffer } from "../../graphics/webGpu/core/buffer/UniformGPUBuffer";
+import { WebGPUDescriptorCreator } from "../../graphics/webGpu/descriptor/WebGPUDescriptorCreator";
+import { ComputeShader } from "../../graphics/webGpu/shader/ComputeShader";
+import { GPUTextureFormat } from "../../graphics/webGpu/WebGPUConst";
+import { webGPUContext } from "../../graphics/webGpu/Context3D";
+import { GPUContext } from "../GPUContext";
+import { PostBase } from "./PostBase";
+import { Engine3D } from "../../../Engine3D";
+import { RTDescriptor } from "../../graphics/webGpu/descriptor/RTDescriptor";
+import { GBufferFrame } from "../frame/GBufferFrame";
+import { RTFrame } from "../frame/RTFrame";
+import { GodRay_cs } from "../../../assets/shader/compute/GodRay_cs";
+import { clamp } from "../../../math/MathUtil";
+export class GodRayPost extends PostBase {
+    constructor() {
+        super();
+    }
+    /**
+     * @internal
+     */
+    onAttach(view) {
+        Engine3D.setting.render.postProcessing.godRay.enable = true;
+        this.createGUI();
+    }
+    onDetach(view) {
+        Engine3D.setting.render.postProcessing.godRay.enable = false;
+        this.removeGUI();
+    }
+    get blendColor() {
+        return Engine3D.setting.render.postProcessing.godRay.blendColor;
+    }
+    set blendColor(value) {
+        Engine3D.setting.render.postProcessing.godRay.blendColor = value;
+    }
+    get rayMarchCount() {
+        return Engine3D.setting.render.postProcessing.godRay.rayMarchCount;
+    }
+    set rayMarchCount(value) {
+        value = clamp(value, 8, 20);
+        Engine3D.setting.render.postProcessing.godRay.rayMarchCount = value;
+    }
+    get scatteringExponent() {
+        return Engine3D.setting.render.postProcessing.godRay.scatteringExponent;
+    }
+    set scatteringExponent(value) {
+        value = clamp(value, 1, 40);
+        Engine3D.setting.render.postProcessing.godRay.scatteringExponent = value;
+    }
+    get intensity() {
+        return Engine3D.setting.render.postProcessing.godRay.intensity;
+    }
+    set intensity(value) {
+        value = clamp(value, 0.01, 5);
+        Engine3D.setting.render.postProcessing.godRay.intensity = value;
+    }
+    createGUI() { }
+    removeGUI() { }
+    createCompute(view) {
+        this.godRayCompute = new ComputeShader(GodRay_cs);
+        let godRaySetting = new UniformGPUBuffer(4 * 3); //vector4 * 2
+        this.godRayCompute.setUniformBuffer("godRayUniform", godRaySetting);
+        this.historyGodRayData = new StorageGPUBuffer(4 * this.godRayTexture.width * this.godRayTexture.height);
+        this.godRayCompute.setStorageBuffer("historyGodRayData", this.historyGodRayData);
+        let rtFrame = GBufferFrame.getGBufferFrame(GBufferFrame.colorPass_GBuffer);
+        this.godRayCompute.setSamplerTexture(`gBufferTexture`, rtFrame.getCompressGBufferTexture());
+        this.autoSetColorTexture("inTex", this.godRayCompute);
+        this.godRayCompute.setStorageTexture(`outTex`, this.godRayTexture);
+        let shadowRenderer = Engine3D.getRenderJob(view).shadowMapPassRenderer;
+        this.godRayCompute.setSamplerTexture(`shadowMap`, shadowRenderer.depth2DArrayTexture);
+        this.godRaySetting = godRaySetting;
+        this.onResize();
+    }
+    createResource() {
+        let presentationSize = webGPUContext.presentationSize;
+        let [w, h] = presentationSize;
+        this.godRayTexture = new VirtualTexture(w, h, GPUTextureFormat.rgba16float, false, GPUTextureUsage.STORAGE_BINDING |
+            GPUTextureUsage.COPY_DST |
+            GPUTextureUsage.COPY_SRC |
+            GPUTextureUsage.TEXTURE_BINDING);
+        this.godRayTexture.name = "godRayTexture";
+        let gtaoDec = new RTDescriptor();
+        gtaoDec.loadOp = `load`;
+        this.rtFrame = new RTFrame([this.godRayTexture], [gtaoDec]);
+    }
+    onResize() {
+        let presentationSize = webGPUContext.presentationSize;
+        let [w, h] = presentationSize;
+        this.godRayTexture.resize(w, h);
+        this.historyGodRayData.resizeBuffer(4 * this.godRayTexture.width * this.godRayTexture.height);
+        this.godRayCompute.setStorageBuffer("historyGodRayData", this.historyGodRayData);
+        this.godRayCompute.workerSizeX = Math.ceil(this.godRayTexture.width / 8);
+        this.godRayCompute.workerSizeY = Math.ceil(this.godRayTexture.height / 8);
+        this.godRayCompute.workerSizeZ = 1;
+    }
+    /**
+     * @internal
+     */
+    render(view, command) {
+        if (!this.godRayCompute) {
+            this.createResource();
+            this.createCompute(view);
+            let lightUniformEntries = GlobalBindGroup.getLightEntries(view.scene);
+            this.godRayCompute.setStorageBuffer("lightBuffer", lightUniformEntries.storageGPUBuffer);
+            this.godRayCompute.setStorageBuffer("models", GlobalBindGroup.modelMatrixBindGroup.matrixBufferDst);
+            this.rendererPassState = WebGPUDescriptorCreator.createRendererPassState(this.rtFrame, null);
+            this.rendererPassState.label = "GodRay";
+            let globalUniform = GlobalBindGroup.getCameraGroup(view.camera);
+            this.godRayCompute.setUniformBuffer("globalUniform", globalUniform.uniformGPUBuffer);
+        }
+        let setting = Engine3D.setting.render.postProcessing.godRay;
+        this.godRaySetting.setFloat("intensity", setting.intensity);
+        this.godRaySetting.setFloat("rayMarchCount", setting.rayMarchCount);
+        let presentationSize = webGPUContext.presentationSize;
+        let [w, h] = presentationSize;
+        this.godRaySetting.setFloat("viewPortWidth", w);
+        this.godRaySetting.setFloat("viewPortHeight", h);
+        this.godRaySetting.setFloat("blendColor", setting.blendColor ? 1 : 0);
+        this.godRaySetting.setFloat("scatteringExponent", setting.scatteringExponent);
+        this.godRaySetting.apply();
+        GPUContext.computeCommand(command, [this.godRayCompute]);
+        GPUContext.lastRenderPassState = this.rendererPassState;
+    }
+}

package/dist/src/gfx/renderJob/post/OutlinePost.d.ts

@@ -0,0 +1,93 @@
+import { PostBase } from "./PostBase";
+import { View3D } from "../../../core/View3D";
+export declare class OutlinePost extends PostBase {
+    /**
+     * @internal
+     */
+    private outlineTex;
+    /**
+     * @internal
+     */
+    private lowTex;
+    /**
+     * @internal
+     */
+    private rendererPassState;
+    /**
+     * @internal
+     */
+    private calcWeightCompute;
+    /**
+     * @internal
+     */
+    private outlineCompute;
+    /**
+     * @internal
+     */
+    private blendCompute;
+    /**
+     * @internal
+     */
+    private outlineSetting;
+    /**
+     * @internal
+     */
+    private slotsBuffer;
+    /**
+     * @internal
+     */
+    private slotsArray;
+    /**
+     * @internal
+     */
+    private entitiesArray;
+    /**
+     * @internal
+     */
+    private entitiesBuffer;
+    /**
+     * @internal
+     */
+    private weightBuffer;
+    /**
+     * @internal
+     */
+    private lowTexSize;
+    /**
+     * @internal
+     */
+    private oldOutlineColor;
+    /**
+     * @internal
+     */
+    private rtFrame;
+    private view;
+    constructor();
+    /**
+     * @internal
+     */
+    onAttach(view: View3D): void;
+    /**
+     * @internal
+     */
+    onDetach(view: View3D): void;
+    set outlinePixel(value: number);
+    get outlinePixel(): number;
+    set fadeOutlinePixel(value: number);
+    get fadeOutlinePixel(): number;
+    set strength(value: number);
+    get strength(): number;
+    set useAddMode(value: boolean);
+    get useAddMode(): boolean;
+    private createGUI;
+    private createCompute;
+    private createResource;
+    private fetchData;
+    private fetchOutlineData;
+    private computeList;
+    /**
+     * @internal
+     */
+    render(view: View3D, command: GPUCommandEncoder): void;
+    onResize(): void;
+}