@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/assets/Res.js

@@ -1,299 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

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

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

@@ -1,51 +0,0 @@
-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

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

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

@@ -1,88 +0,0 @@
-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

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