@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/assets/Res.js

@@ -0,0 +1,299 @@
+import { FileLoader } from "../loader/FileLoader";
+import { GLBParser } from "../loader/parser/gltf/GLBParser";
+import { GLTFParser } from "../loader/parser/gltf/GLTFParser";
+import { OBJParser } from "../loader/parser/OBJParser";
+import { BitmapTexture2D } from "../textures/BitmapTexture2D";
+import { BitmapTextureCube } from "../textures/BitmapTextureCube";
+import { HDRTextureCube } from "../textures/HDRTextureCube";
+import { B3DMParser } from "../loader/parser/B3DMParser";
+import { I3DMParser } from "../loader/parser/I3DMParser";
+import { HDRTexture } from "../textures/HDRTexture";
+import { LDRTextureCube } from "../textures/LDRTextureCube";
+import { BRDFLUTGenerate } from "../gfx/generate/BrdfLUTGenerate";
+import { Uint8ArrayTexture } from "../textures/Uint8ArrayTexture";
+import { GUISprite } from "../components/gui/core/GUISprite";
+import { GUITexture } from "../components/gui/core/GUITexture";
+import { FontParser } from "../loader/parser/FontParser";
+import { fonts } from "./Fonts";
+import { AtlasParser } from "../loader/parser/AtlasParser";
+import { Reference } from "../util/Reference";
+import { LitMaterial } from "../materials/LitMaterial";
+export class Res {
+    constructor() {
+        this._texturePool = new Map();
+        this._materialPool = new Map();
+        this._prefabPool = new Map();
+        this._geometryPool = new Map();
+        this._gltfPool = new Map();
+        this._atlasList = new Map();
+        this._obj = new Map();
+    }
+    getGltf(url) {
+        return this._gltfPool.get(url);
+    }
+    addObj(url, obj) {
+        this._obj.set(url, obj);
+    }
+    getObj(url) {
+        return this._obj.get(url);
+    }
+    addTexture(url, texture) {
+        this._texturePool.set(url, texture);
+    }
+    getTexture(url) {
+        return this._texturePool.get(url);
+    }
+    addGeometry(url, geo) {
+        this._geometryPool.set(url, geo);
+    }
+    getGeometry(url) {
+        return this._geometryPool.get(url);
+    }
+    addMat(name, mat) {
+        return this._materialPool.set(name, mat);
+    }
+    getMat(name) {
+        return this._materialPool.get(name);
+    }
+    addPrefab(name, rootScene) {
+        this._prefabPool.set(name, rootScene);
+    }
+    getPrefab(name) {
+        return this._prefabPool.get(name).instantiate();
+    }
+    addAtlas(name, atlas) {
+        atlas.name = name;
+        this._atlasList.set(name, atlas);
+    }
+    getAtlas(name) {
+        return this._atlasList.get(name);
+    }
+    getGUISprite(id) {
+        for (let item of this._atlasList.values()) {
+            let sprite = item.getSprite(id);
+            if (sprite)
+                return sprite;
+        }
+        return null;
+    }
+    async load(url, c, loaderFunctions) {
+        let loader = new FileLoader();
+        let parser = await loader.load(url, c, loaderFunctions);
+        let ret = parser.data;
+        return ret;
+    }
+    async loadGltf(url, loaderFunctions) {
+        if (this._prefabPool.has(url)) {
+            return this._prefabPool.get(url);
+        }
+        let parser;
+        let ext = url.substring(url.lastIndexOf(".")).toLowerCase();
+        let loader = new FileLoader();
+        if (ext == ".gltf") {
+            parser = await loader.load(url, GLTFParser, loaderFunctions);
+        }
+        else {
+            parser = await loader.load(url, GLBParser, loaderFunctions);
+        }
+        let obj = parser.data;
+        this._prefabPool.set(url, obj);
+        this._gltfPool.set(url, parser.gltf);
+        return obj;
+    }
+    async loadObj(url, loaderFunctions) {
+        if (this._prefabPool.has(url)) {
+            return this._prefabPool.get(url);
+        }
+        let parser;
+        let ext = url.substring(url.lastIndexOf(".")).toLowerCase();
+        let loader = new FileLoader();
+        if (ext == ".obj") {
+            parser = await loader.load(url, OBJParser, loaderFunctions);
+        }
+        let obj = parser.data;
+        this._prefabPool.set(url, obj);
+        return obj;
+    }
+    async loadB3DM(url, loaderFunctions, userData) {
+        if (this._prefabPool.has(url)) {
+            return this._prefabPool.get(url);
+        }
+        let loader = new FileLoader();
+        let parser = await loader.load(url, B3DMParser, loaderFunctions, userData);
+        let obj = parser.data;
+        this._prefabPool.set(url, obj);
+        return obj;
+    }
+    async loadI3DM(url, loaderFunctions, userData) {
+        if (this._prefabPool.has(url)) {
+            return this._prefabPool.get(url);
+        }
+        let loader = new FileLoader();
+        let parser = await loader.load(url, I3DMParser, loaderFunctions, userData);
+        let obj = parser.data;
+        this._prefabPool.set(url, obj);
+        return obj;
+    }
+    async loadTexture(url, loaderFunctions, flipY) {
+        if (this._texturePool.has(url)) {
+            return this._texturePool.get(url);
+        }
+        let texture = new BitmapTexture2D();
+        texture.flipY = flipY;
+        await texture.load(url, loaderFunctions);
+        this._texturePool.set(url, texture);
+        return texture;
+    }
+    async loadTextureCount(urls, count, loaderFunctions, flipY) {
+        return new Promise(async (suc, fail) => {
+            let total = 0;
+            let loadTexture = [];
+            if (count == 0) {
+                suc(loadTexture);
+            }
+            for (let j = 0; j < count; j++) {
+                const url = urls.shift();
+                this.loadTexture(url, loaderFunctions, flipY).then((t) => {
+                    loadTexture.push(t);
+                    total++;
+                    if (total == count) {
+                        suc(loadTexture);
+                    }
+                });
+            }
+        });
+    }
+    async loadBitmapTextures(urls, count = 5, loaderFunctions, flipY) {
+        let loadTexture = [];
+        let loadCount = Math.floor(urls.length / count) + 1;
+        let last = Math.floor(urls.length % count);
+        for (let i = 0; i < loadCount; i++) {
+            let list = await this.loadTextureCount(urls, i == loadCount - 1 ? last : count, loaderFunctions, flipY);
+            loadTexture.push(...list);
+        }
+        return loadTexture;
+    }
+    async loadHDRTexture(url, loaderFunctions) {
+        if (this._texturePool.has(url)) {
+            return this._texturePool.get(url);
+        }
+        let hdrTexture = new HDRTexture();
+        hdrTexture = await hdrTexture.load(url, loaderFunctions);
+        this._texturePool.set(url, hdrTexture);
+        return hdrTexture;
+    }
+    async loadHDRTextureCube(url, loaderFunctions) {
+        if (this._texturePool.has(url)) {
+            return this._texturePool.get(url);
+        }
+        let hdrTexture = new HDRTextureCube();
+        hdrTexture = await hdrTexture.load(url, loaderFunctions);
+        this._texturePool.set(url, hdrTexture);
+        return hdrTexture;
+    }
+    async loadLDRTextureCube(url, loaderFunctions) {
+        if (this._texturePool.has(url)) {
+            return this._texturePool.get(url);
+        }
+        let ldrTextureCube = new LDRTextureCube();
+        ldrTextureCube = await ldrTextureCube.load(url, loaderFunctions);
+        this._texturePool.set(url, ldrTextureCube);
+        return ldrTextureCube;
+    }
+    async loadTextureCubeMaps(urls) {
+        let url = urls[0];
+        if (this._texturePool.has(url)) {
+            return this._texturePool.get(url);
+        }
+        let textureCube = new BitmapTextureCube();
+        await textureCube.load(urls);
+        this._texturePool.set(urls[0], textureCube);
+        return textureCube;
+    }
+    async loadTextureCubeStd(url, loaderFunctions) {
+        if (this._texturePool.has(url)) {
+            return this._texturePool.get(url);
+        }
+        let cubeMap = new BitmapTextureCube();
+        await cubeMap.loadStd(url);
+        return cubeMap;
+    }
+    async loadJSON(url, loaderFunctions) {
+        return await new FileLoader()
+            .loadJson(url, loaderFunctions)
+            .then(async (ret) => {
+            return ret;
+        })
+            .catch((e) => {
+            console.log(e);
+        });
+    }
+    async loadFont(url, loaderFunctions, userData) {
+        let loader = new FileLoader();
+        let parser = await loader.load(url, FontParser, loaderFunctions, userData);
+        let data = parser.data;
+        fonts.addFontData(data.face, data.size, data);
+        return parser.data;
+    }
+    async loadAtlas(url, loaderFunctions) {
+        let loader = new FileLoader();
+        let parser = await loader.load(url, AtlasParser, loaderFunctions, url);
+        return parser.data;
+    }
+    createTexture(width, height, r, g, b, a, name) {
+        let w = 32;
+        let h = 32;
+        let textureData = new Uint8Array(w * h * 4);
+        this.fillColor(textureData, width, height, r, g, b, a);
+        let texture = new Uint8ArrayTexture();
+        texture.name = name;
+        texture.create(16, 16, textureData, true);
+        if (name) {
+            this.addTexture(name, texture);
+        }
+        return texture;
+    }
+    fillColor(array, w, h, r, g, b, a) {
+        for (let i = 0; i < w; i++) {
+            for (let j = 0; j < h; j++) {
+                let pixelIndex = j * w + i;
+                array[pixelIndex * 4 + 0] = r;
+                array[pixelIndex * 4 + 1] = g;
+                array[pixelIndex * 4 + 2] = b;
+                array[pixelIndex * 4 + 3] = a;
+            }
+        }
+    }
+    initDefault() {
+        this.normalTexture = this.createTexture(32, 32, 255 * 0.5, 255 * 0.5, 255.0, 255.0, "default-normalTexture");
+        this.maskTexture = this.createTexture(32, 32, 255, 255 * 0.5, 255.0, 255.0, "default-maskTexture");
+        this.whiteTexture = this.createTexture(32, 32, 255, 255, 255, 255, "default-whiteTexture");
+        this.blackTexture = this.createTexture(32, 32, 0, 0, 0, 255.0, "default-blackTexture");
+        this.redTexture = this.createTexture(32, 32, 255, 0, 0, 255.0, "default-redTexture");
+        this.blueTexture = this.createTexture(32, 32, 0, 0, 255, 255.0, "default-blueTexture");
+        this.greenTexture = this.createTexture(32, 32, 0, 255, 0, 255, "default-greenTexture");
+        this.yellowTexture = this.createTexture(32, 32, 0, 255, 255, 255.0, "default-yellowTexture");
+        this.grayTexture = this.createTexture(32, 32, 128, 128, 128, 255.0, "default-grayTexture");
+        let brdf = new BRDFLUTGenerate();
+        let brdf_texture = brdf.generateBRDFLUTTexture();
+        let BRDFLUT = (brdf_texture.name = "BRDFLUT");
+        this.addTexture(BRDFLUT, brdf_texture);
+        this.defaultSky = new HDRTextureCube();
+        this.defaultSky.createFromTexture(128, this.blackTexture);
+        Reference.getInstance().attached(this.defaultSky, this);
+        Reference.getInstance().attached(brdf_texture, this);
+        Reference.getInstance().attached(this.normalTexture, this);
+        Reference.getInstance().attached(this.maskTexture, this);
+        Reference.getInstance().attached(this.whiteTexture, this);
+        Reference.getInstance().attached(this.blackTexture, this);
+        Reference.getInstance().attached(this.redTexture, this);
+        Reference.getInstance().attached(this.blueTexture, this);
+        Reference.getInstance().attached(this.greenTexture, this);
+        Reference.getInstance().attached(this.yellowTexture, this);
+        Reference.getInstance().attached(this.grayTexture, this);
+        this.defaultGUITexture = new GUITexture(this.whiteTexture);
+        this.defaultGUISprite = new GUISprite(this.defaultGUITexture);
+        this.defaultGUISprite.trimSize.set(4, 4);
+        this.defaultMaterial = new LitMaterial();
+    }
+}

package/dist/src/assets/shader/ShaderLib.d.ts

@@ -0,0 +1,5 @@
+export declare class ShaderLib {
+    static init(): void;
+    static register(keyName: string, code: string): void;
+    static getShader(keyName: string): string;
+}

package/dist/src/assets/shader/ShaderLib.js

@@ -0,0 +1,128 @@
+import { ClusterDebug_frag } from "./materials/program/ClusterDebug_frag";
+import { CubeSky_Shader } from "./sky/CubeSky_Shader";
+import { LightingFunction_frag } from "./lighting/LightingFunction_frag";
+import { MathShader } from "./math/MathShader";
+import { PhysicMaterialUniform_frag } from "./materials/uniforms/PhysicMaterialUniform_frag";
+import { UnLitMaterialUniform_frag } from "./materials/uniforms/UnLitMaterialUniform_frag";
+import { UnLit_frag } from "./lighting/UnLit_frag";
+import { VertexAttributes_vert } from "./core/struct/VertexAttributes";
+import { VideoUniform_frag } from "./materials/uniforms/VideoUniform_frag";
+import { IrradianceVolumeData_frag } from "./lighting/IrradianceVolumeData_frag";
+import { Inline_vert } from "./core/inline/Inline_vert";
+import { Common_frag } from "./core/base/Common_frag";
+import { Common_vert } from "./core/base/Common_vert";
+import { BrdfLut_frag } from "./core/common/BrdfLut_frag";
+import { EnvMap_frag } from "./core/common/EnvMap_frag";
+import { GlobalUniform } from "./core/common/GlobalUniform";
+import { InstanceUniform } from "./core/common/InstanceUniform";
+import { WorldMatrixUniform } from "./core/common/WorldMatrixUniform";
+import { FastMathShader } from "./math/FastMathShader";
+import { NormalMap_frag } from "./materials/program/NormalMap_frag";
+import { FragmentVarying } from "./core/struct/FragmentVarying";
+import { FragmentOutput } from "./core/struct/FragmentOutput";
+import { ShadingInput } from "./core/struct/ShadingInput";
+import { IESProfiles_frag } from "./lighting/IESProfiles_frag";
+import { ShadowMapping_frag } from "./materials/program/ShadowMapping_frag";
+import { Irradiance_frag } from "./lighting/Irradiance_frag";
+import { BRDF_frag } from "./lighting/BRDF_frag"; // 反射 消耗低
+import { BxDF_frag } from "./lighting/BxDF_frag"; // 散射 消耗中
+import { BsDF_frag } from "./lighting/BsDF_frag"; // 体积+散射 消耗高
+import { Clearcoat_frag } from "./materials/program/Clearcoat_frag";
+import { Lit_shader } from "./materials/Lit_shader";
+import { PBRLItShader } from "./materials/PBRLItShader";
+import { BxdfDebug_frag } from "./materials/program/BxdfDebug_frag";
+import { Quad_depth2d_frag_wgsl, Quad_depthCube_frag_wgsl, Quad_frag_wgsl, Quad_vert_wgsl, } from "./quad/Quad_shader";
+import { ColorUtil } from "./utils/ColorUtil";
+import { GenerayRandomDir } from "./utils/GenerayRandomDir";
+import { MatrixShader } from "./math/MatrixShader";
+import { ClusterLight } from "./core/struct/ClusterLight";
+import { Hair_frag } from "./lighting/Hair_frag";
+import { UnLit } from "./materials/UnLit";
+import { Lambert_shader } from "./materials/Lambert_shader";
+import { QuadGlsl_fs, QuadGlsl_vs } from "./glsl/Quad_glsl";
+import { SkyGBuffer_pass } from "./core/pass/SkyGBuffer_pass";
+import { GBuffer_pass } from "./core/pass/GBuffer_pass";
+import { castPointShadowMap_vert, directionShadowCastMap_frag, shadowCastMap_frag, shadowCastMap_vert, } from "./core/pass/CastShadow_pass";
+import { ZPassShader_vs } from "./core/pass/ZPassShader_vs";
+import { ZPassShader_fs } from "./core/pass/ZPassShader_fs";
+import { BitUtil } from "./utils/BitUtil";
+import { GBufferStand } from "./core/common/GBufferStand";
+import { ReflectionShader_shader } from "./materials/ReflectionShader_shader";
+import { ReflectionCG } from "./env/ReflectionCG";
+import { SHCommon_frag } from "./core/common/SHCommon_frag";
+export class ShaderLib {
+    static init() {
+        ShaderLib.register("MathShader", MathShader);
+        ShaderLib.register("FastMathShader", FastMathShader);
+        ShaderLib.register("BitUtil", BitUtil);
+        ShaderLib.register("GBufferStand", GBufferStand);
+        ShaderLib.register("SHCommon_frag", SHCommon_frag);
+        ShaderLib.register("MatrixShader", MatrixShader);
+        ShaderLib.register("GlobalUniform", GlobalUniform);
+        ShaderLib.register("WorldMatrixUniform", WorldMatrixUniform);
+        ShaderLib.register("NormalMap_frag", NormalMap_frag);
+        ShaderLib.register("LightingFunction_frag", LightingFunction_frag);
+        ShaderLib.register("PhysicMaterialUniform_frag", PhysicMaterialUniform_frag);
+        ShaderLib.register("UnLitMaterialUniform_frag", UnLitMaterialUniform_frag);
+        ShaderLib.register("VideoUniform_frag", VideoUniform_frag);
+        ShaderLib.register("InstanceUniform", InstanceUniform);
+        ShaderLib.register("Inline_vert", Inline_vert);
+        ShaderLib.register("VertexAttributes_vert", VertexAttributes_vert);
+        ShaderLib.register("Common_vert", Common_vert);
+        ShaderLib.register("Common_frag", Common_frag);
+        ShaderLib.register("FragmentVarying", FragmentVarying);
+        ShaderLib.register("FragmentOutput", FragmentOutput);
+        ShaderLib.register("ClusterLight", ClusterLight);
+        ShaderLib.register("ShadingInput", ShadingInput);
+        ShaderLib.register("IESProfiles_frag", IESProfiles_frag);
+        ShaderLib.register("ShadowMapping_frag", ShadowMapping_frag);
+        ShaderLib.register("Irradiance_frag", Irradiance_frag);
+        ShaderLib.register("IrradianceVolumeData_frag", IrradianceVolumeData_frag);
+        ShaderLib.register("BrdfLut_frag", BrdfLut_frag);
+        ShaderLib.register("EnvMap_frag", EnvMap_frag);
+        ShaderLib.register("ColorUtil_frag", ColorUtil);
+        ShaderLib.register("BRDF_frag", BRDF_frag);
+        ShaderLib.register("Hair_frag", Hair_frag);
+        ShaderLib.register("BxDF_frag", BxDF_frag);
+        ShaderLib.register("BsDF_frag", BsDF_frag);
+        ShaderLib.register("UnLit_frag", UnLit_frag);
+        ShaderLib.register("UnLit", UnLit);
+        ShaderLib.register("ReflectionCG", ReflectionCG);
+        ShaderLib.register("ReflectionShader_shader", ReflectionShader_shader);
+        ShaderLib.register("Clearcoat_frag", Clearcoat_frag);
+        ShaderLib.register("LitShader", Lit_shader);
+        ShaderLib.register("PBRLItShader", PBRLItShader);
+        ShaderLib.register("ClusterDebug_frag", ClusterDebug_frag);
+        ShaderLib.register("BxdfDebug_frag", BxdfDebug_frag);
+        ShaderLib.register("GenerayRandomDir", GenerayRandomDir);
+        ShaderLib.register("Quad_vert_wgsl", Quad_vert_wgsl);
+        ShaderLib.register("Quad_frag_wgsl", Quad_frag_wgsl);
+        ShaderLib.register("Quad_depth2d_frag_wgsl", Quad_depth2d_frag_wgsl);
+        ShaderLib.register("Quad_depthCube_frag_wgsl", Quad_depthCube_frag_wgsl);
+        ShaderLib.register("sky_vs_frag_wgsl", CubeSky_Shader.sky_vs_frag_wgsl);
+        ShaderLib.register("sky_fs_frag_wgsl", CubeSky_Shader.sky_fs_frag_wgsl);
+        ShaderLib.register("LambertShader", Lambert_shader);
+        ShaderLib.register("QuadGlsl_vs", QuadGlsl_vs);
+        ShaderLib.register("QuadGlsl_fs", QuadGlsl_fs);
+        ShaderLib.register("SkyGBuffer_fs", SkyGBuffer_pass);
+        ShaderLib.register("gbuffer_vs", GBuffer_pass);
+        ShaderLib.register("gbuffer_fs", GBuffer_pass);
+        ShaderLib.register("castPointShadowMap_vert", castPointShadowMap_vert);
+        ShaderLib.register("shadowCastMap_frag", shadowCastMap_frag);
+        ShaderLib.register("shadowCastMap_vert", shadowCastMap_vert);
+        ShaderLib.register("directionShadowCastMap_frag", directionShadowCastMap_frag);
+        ShaderLib.register("ZPass_shader_vs", ZPassShader_vs);
+        ShaderLib.register("ZPass_shader_fs", ZPassShader_fs);
+    }
+    static register(keyName, code) {
+        if (!ShaderLib[keyName.toLowerCase()]) {
+            ShaderLib[keyName.toLowerCase()] = code;
+        }
+    }
+    static getShader(keyName) {
+        if (ShaderLib[keyName.toLowerCase()]) {
+            return ShaderLib[keyName.toLowerCase()];
+        }
+        return ShaderLib[keyName.toLowerCase()];
+    }
+}

package/dist/src/assets/shader/anim/SkeletonAnimation_shader.d.ts

@@ -0,0 +1,3 @@
+export declare class SkeletonAnimation_shader {
+    static groupBindingAndFunctions(beginGroup: number, beginBinding: number): string;
+}

package/dist/src/assets/shader/anim/SkeletonAnimation_shader.js

@@ -0,0 +1,51 @@
+export class SkeletonAnimation_shader {
+    static groupBindingAndFunctions(beginGroup, beginBinding) {
+        return `
+            struct JointsMatrix {
+                matrix: array<mat4x4<f32>>
+            };
+
+            @group(${beginGroup}) @binding(${beginBinding})
+            var<storage, read> jointsMatrixIndexTable: array<f32>;
+
+            @group(${beginGroup}) @binding(${beginBinding + 1})
+            var<storage, read> jointsInverseMatrix: JointsMatrix;
+
+            @group(${beginGroup}) @binding(${beginBinding + 2})
+            var<storage, read> jointsIndexMapingTable: array<f32>;
+
+            const MAX_JOINT_NUM = 8;
+            fn getSkeletonWorldMatrix(joints: array<f32, MAX_JOINT_NUM>, weight: array<f32, MAX_JOINT_NUM>, num: u32) -> mat4x4<f32> {
+                var result: mat4x4<f32>;
+                for(var i: u32 = 0; i < num; i=i+1){
+                    let jointId = i32(joint[i]);
+                    let jointIndex = u32(jointsIndexMapingTable[jointId]);
+                    let jointMatrixIndex = u32(jointsMatrixIndexTable[jointIndex]);
+                    let joint = models.matrix[jointMatrixIndex] * jointsInverseMatrix.matrix[jointId] * weights[i];
+                    result += joint;
+                }
+                return result;
+            }
+
+            fn getSkeletonWorldMatrix_4(joints: vec4<f32>, weights: vec4<f32>) -> mat4x4<f32> {
+                return getSkeletonWorldMatrix(array<f32, MAX_JOINT_NUM>(
+                    joints.x, joints.y, joints.z, joints.w,
+                    0, 0, 0, 0,
+                ), array<f32, MAX_JOINT_NUM>(
+                    weights.x, weights.y, weights.z, weights.w,
+                    0, 0, 0, 0,
+                ), 4);
+            }
+
+            fn getSkeletonWorldMatrix_8(joints0: vec4<f32>, weights0: vec4<f32>, joints1: vec4<f32>, weights1: vec4<f32>) -> mat4x4<f32> {
+                return getSkeletonWorldMatrix(array<f32, MAX_JOINT_NUM>(
+                    joints0.x, joints0.y, joints0.z, joints0.w,
+                    joints1.x, joints1.y, joints1.z, joints1.w,
+                ), array<f32, MAX_JOINT_NUM>(
+                    weights0.x, weights0.y, weights0.z, weights0.w,
+                    weights1.x, weights1.y, weights1.z, weights1.w,
+                ), 8);
+            }
+        `;
+    }
+}

package/dist/src/assets/shader/cluster/ClusterBoundsSource_cs.d.ts

@@ -0,0 +1 @@
+export declare let ClusterBoundsSource_cs: string;

package/dist/src/assets/shader/cluster/ClusterBoundsSource_cs.js

@@ -0,0 +1,88 @@
+import { ClusterConfig } from "../../../gfx/renderJob/passRenderer/cluster/ClusterConfig";
+export let ClusterBoundsSource_cs = `
+    #include "GlobalUniform"
+
+    struct ClusterBox{
+        minPoint:vec4<f32>,
+        maxPoint:vec4<f32>
+    }
+
+    struct ClustersUniform{
+        clusterTileX:f32,
+        clusterTileY:f32,
+        clusterTileZ:f32,
+        numLights:f32,
+        maxNumLightsPerCluster:f32,
+        near:f32,
+        far:f32,
+        screenWidth:f32,
+        screenHeight:f32,
+        clusterPix:f32
+    }
+
+    @group(0) @binding(1) var<uniform> clustersUniform: ClustersUniform;
+    @group(0) @binding(2) var<storage,read_write> clusterBuffer: array<ClusterBox>;
+
+    var<private> clusterTileX: f32;
+    var<private> clusterTileY: f32;
+    var<private> clusterTileZ: f32;
+    fn convertNDCToView(v4:vec4<f32>) -> vec4<f32> {
+        var v = globalUniform.pvMatrixInv * v4;
+        v = v / v.w;
+        return v;
+    }
+
+    fn ScreenToView(screen: vec4<f32>) -> vec4<f32> {
+        let texCoord = screen.xy / vec2<f32>(clustersUniform.screenWidth, clustersUniform.screenHeight);
+        let clip = vec4<f32>(vec2<f32>(texCoord.x, 1.0 - texCoord.y) * 2.0 - vec2<f32>(1.0, 1.0), screen.z, screen.w);
+        return convertNDCToView(clip);
+    }
+
+    fn gridToIndex(i:vec3<u32>) -> u32{
+        return i.z * u32(clusterTileX) * u32(clusterTileY) + i.y * u32(clusterTileX) + i.x;
+    }
+
+    fn LineIntersectionToZPlane(eye:vec3<f32>, ndcPoint :vec3<f32>, z:f32) -> vec3<f32>
+    {
+        var normal = vec3<f32>(0.0, 0.0, 1.0);
+        var dir = ndcPoint - eye;
+        var t = (z - dot(normal, eye)) / dot(normal, dir);
+        var result = eye + t * dir;
+        return result;
+    }
+
+    @compute @workgroup_size(${ClusterConfig.clusterTileX},${ClusterConfig.clusterTileY},1)
+    fn CsMain(@builtin(workgroup_id) workgroup_id: vec3<u32>, @builtin(local_invocation_id) local_invocation_id: vec3<u32>){
+        let i = local_invocation_id.x;
+        let j = local_invocation_id.y;
+        let k = workgroup_id.x;
+        clusterTileX = clustersUniform.clusterTileX;
+        clusterTileY = clustersUniform.clusterTileY;
+        clusterTileZ = clustersUniform.clusterTileZ;
+        let clusterGrid = vec3<u32>(i,j,k);
+        let tileIndex = gridToIndex(clusterGrid);
+        let eyePos = vec3<f32>(0.0, 0.0, 0.0);
+        let tx = clusterTileX;
+        let ty = clusterTileY;
+        let tz = clusterTileZ;
+        let near = clustersUniform.near;
+        let far = clustersUniform.far;
+        let titleSize = vec2<f32>( globalUniform.windowWidth / tx , globalUniform.windowHeight / ty ) ;
+        var maxPointSs = vec4<f32>(vec2<f32>(f32(i) + 1.0, f32(j) + 1.0) * titleSize, 0.0, 1.0);
+        var minPointSs = vec4<f32>(vec2<f32>(f32(i) , f32(j)) * titleSize, 0.0, 1.0);
+        var maxPointVs = ScreenToView(maxPointSs).xyz;
+        var minPointVs = ScreenToView(minPointSs).xyz;
+        var tileNear = clustersUniform.near * pow(clustersUniform.far / clustersUniform.near, f32(k) / clustersUniform.clusterTileZ);
+        var tileFar = clustersUniform.near * pow(clustersUniform.far / clustersUniform.near, (f32(k) + 1.0) / clustersUniform.clusterTileZ);
+        var minPointNear = LineIntersectionToZPlane(eyePos, minPointVs, tileNear);
+        var minPointFar = LineIntersectionToZPlane(eyePos, minPointVs, tileFar);
+        var maxPointNear = LineIntersectionToZPlane(eyePos, maxPointVs, tileNear);
+        var maxPointFar = LineIntersectionToZPlane(eyePos, maxPointVs, tileFar);
+        var minPointAABB = min(min(minPointNear, minPointFar), min(maxPointNear, maxPointFar));
+        var maxPointAABB = max(max(minPointNear, minPointFar), max(maxPointNear, maxPointFar));
+        var clusterBox : ClusterBox ;
+        clusterBox.minPoint = vec4<f32>(minPointAABB,f32(tileIndex)) ;
+        clusterBox.maxPoint = vec4<f32>(maxPointAABB,f32(tileIndex)) ;
+        clusterBuffer[tileIndex] = clusterBox;
+    }
+`;

package/dist/src/assets/shader/cluster/ClusterLighting_cs.d.ts

@@ -0,0 +1 @@
+export declare let ClusterLighting_cs: string;