@rings-webgpu/core 1.0.2 → 1.0.4

package/dist/src/Engine3D.js

@@ -1,471 +0,0 @@
-import { Color } from "./math/Color";
-import { Time } from "./util/Time";
-import { InputSystem } from "./io/InputSystem";
-import { webGPUContext } from "./gfx/graphics/webGpu/Context3D";
-import { RTResourceMap } from "./gfx/renderJob/frame/RTResourceMap";
-import { ForwardRenderJob } from "./gfx/renderJob/jobs/ForwardRenderJob";
-import { GlobalBindGroup } from "./gfx/graphics/webGpu/core/bindGroups/GlobalBindGroup";
-import { Interpolator } from "./math/TimeInterpolator";
-import { Res } from "./assets/Res";
-import { ShaderLib } from "./assets/shader/ShaderLib";
-import { ShaderUtil } from "./gfx/graphics/webGpu/shader/util/ShaderUtil";
-import { ComponentCollect } from "./gfx/renderJob/collect/ComponentCollect";
-import { ShadowLightsCollect } from "./gfx/renderJob/collect/ShadowLightsCollect";
-import { WasmMatrix } from "@rings/wasm-matrix/WasmMatrix";
-import { Matrix4 } from "./math/Matrix4";
-import { FXAAPost } from "./gfx/renderJob/post/FXAAPost";
-import { PostProcessingComponent } from "./components/post/PostProcessingComponent";
-import { GBufferFrame } from "./gfx/renderJob/frame/GBufferFrame";
-import { version } from "../package.json";
-/**
- * Engine3D是Rings WebGPU引擎的主类，负责初始化WebGPU上下文、管理渲染循环和处理输入。
- * 它提供了一系列静态方法和属性，用于控制引擎的行为和访问引擎的各个组件。
- */
-export class Engine3D {
-    /**
-     * 帧率计算值，用于限制渲染帧率
-     * @private
-     */
-    static { this._frameRateValue = 0; }
-    /**
-     * 目标帧率，默认为360（不限制）
-     * @private
-     */
-    static { this._frameRate = 360; }
-    /**
-     * 上一帧的时间戳
-     * @private
-     */
-    static { this._time = 0; }
-    /**
-     * requestAnimationFrame的ID，用于暂停和恢复渲染循环
-     * @private
-     */
-    static { this._requestAnimationFrameID = 0; }
-    /**
-     * 获取当前设置的帧率
-     * @returns 当前帧率值
-     */
-    static get frameRate() {
-        return this._frameRate;
-    }
-    /**
-     * 设置引擎的目标帧率
-     * @param value 目标帧率，设置为360或更高表示不限制帧率
-     */
-    static set frameRate(value) {
-        this._frameRate = value;
-        this._frameRateValue = 1000 / value;
-        if (value >= 360) {
-            this._frameRateValue = 0;
-        }
-    }
-    /**
-     * 获取当前渲染上下文的尺寸
-     * @returns 包含宽度和高度的数组 [width, height]
-     */
-    static get size() {
-        return webGPUContext.presentationSize;
-    }
-    /**
-     * 获取当前渲染上下文的宽高比
-     * @returns 宽高比值
-     */
-    static get aspect() {
-        return webGPUContext.aspect;
-    }
-    /**
-     * 获取当前渲染上下文的宽度
-     * @returns 宽度值（像素）
-     */
-    static get width() {
-        return webGPUContext.windowWidth;
-    }
-    /**
-     * 获取当前渲染上下文的高度
-     * @returns 高度值（像素）
-     */
-    static get height() {
-        return webGPUContext.windowHeight;
-    }
-    static { this.setting = {
-        doublePrecision: false, // 是否启用双精度浮点计算
-        occlusionQuery: {
-            enable: true, // 遮挡查询
-            debug: false,
-        },
-        pick: {
-            enable: true,
-            mode: `bound`,
-            detail: `mesh`, // 拾取细节，网格级别
-        },
-        render: {
-            debug: false,
-            renderPassState: 4,
-            renderState_left: 5, // 左右眼渲染状态
-            renderState_right: 5,
-            renderState_split: 0.5, // 分屏比例
-            quadScale: 1, // 全屏后处理效果的缩放比
-            hdrExposure: 1.5, // 曝光值
-            debugQuad: -1,
-            maxPointLight: 1000, // 最大点光源数量
-            maxDirectLight: 4, // 最多平行光数量
-            maxSportLight: 1000, // 聚光灯数量
-            drawOpMin: 0, // 绘制操作的索引范围
-            drawOpMax: Number.MAX_SAFE_INTEGER, // 绘制0-MAX_SAFE_INTEGER之间的绘制操作，其余的忽略
-            drawTrMin: 0, // 透明度阈值
-            drawTrMax: Number.MAX_SAFE_INTEGER,
-            zPrePass: false, // 深度预渲染，重叠较多，可开启
-            useLogDepth: false, // 对数深度缓冲，优化远距离渲染精度
-            useCompressGBuffer: false, // G-Buffer压缩
-            gi: false, // 全局光照
-            postProcessing: {
-                bloom: {
-                    downSampleStep: 3, // 降采样间隔
-                    downSampleBlurSize: 9, // 降采样模糊大小
-                    downSampleBlurSigma: 1.0, // 高斯模糊默认值
-                    upSampleBlurSize: 9,
-                    upSampleBlurSigma: 1.0,
-                    luminanceThreshole: 1.0, // 亮度阈值
-                    bloomIntensity: 1.0, // 泛光强度
-                    hdr: 1.0,
-                },
-                globalFog: {
-                    debug: false,
-                    enable: false,
-                    fogType: 0.0,
-                    fogHeightScale: 0.1,
-                    start: 400,
-                    end: 10,
-                    density: 0.02,
-                    ins: 0.5,
-                    skyFactor: 0.5, // 天空盒子影响因素
-                    skyRoughness: 0.4,
-                    overrideSkyFactor: 0.8, // 覆盖因素
-                    fogColor: new Color(96 / 255, 117 / 255, 133 / 255, 1),
-                    falloff: 0.7, // 衰减系数
-                    rayLength: 200.0, // 光线长度
-                    scatteringExponent: 2.7, // 散射指数
-                    dirHeightLine: 10.0, // 方向高度线
-                },
-                godRay: {
-                    blendColor: true,
-                    rayMarchCount: 16,
-                    scatteringExponent: 5,
-                    intensity: 0.5,
-                },
-                ssao: {
-                    enable: false,
-                    radius: 0.15,
-                    bias: -0.1,
-                    aoPower: 2.0,
-                    debug: true,
-                },
-                outline: {
-                    enable: false,
-                    strength: 1,
-                    groupCount: 4,
-                    outlinePixel: 2,
-                    fadeOutlinePixel: 4,
-                    textureScale: 1,
-                    useAddMode: false,
-                    debug: true,
-                },
-                taa: {
-                    enable: false,
-                    jitterSeedCount: 8,
-                    blendFactor: 0.1,
-                    sharpFactor: 0.6,
-                    sharpPreBlurFactor: 0.5,
-                    temporalJitterScale: 0.13,
-                    debug: true,
-                },
-                gtao: {
-                    enable: false,
-                    darkFactor: 1.0,
-                    maxDistance: 5.0,
-                    maxPixel: 50.0,
-                    rayMarchSegment: 6,
-                    multiBounce: false,
-                    usePosFloat32: true,
-                    blendColor: true,
-                    debug: true,
-                },
-                ssr: {
-                    enable: false,
-                    pixelRatio: 1,
-                    fadeEdgeRatio: 0.2,
-                    rayMarchRatio: 0.5,
-                    fadeDistanceMin: 600,
-                    fadeDistanceMax: 2000,
-                    roughnessThreshold: 0.5,
-                    powDotRN: 0.2,
-                    mixThreshold: 0.1,
-                    debug: true,
-                },
-                fxaa: {
-                    enable: false, // 补充静态锯齿，适合性能差的设备
-                },
-                depthOfView: {
-                    enable: false, // 景深效果
-                    iterationCount: 3,
-                    pixelOffset: 1.0,
-                    near: 150,
-                    far: 300,
-                },
-            },
-        },
-        shadow: {
-            enable: true,
-            type: "HARD",
-            pointShadowBias: 0.0005,
-            shadowSize: 2048,
-            pointShadowSize: 1024,
-            shadowSoft: 0.005,
-            shadowBound: 100,
-            shadowBias: 0.05,
-            needUpdate: true,
-            autoUpdate: true,
-            updateFrameRate: 2,
-            csmMargin: 0.1,
-            csmScatteringExp: 0.7,
-            csmAreaScale: 0.4,
-            debug: false,
-        },
-        gi: {
-            enable: false,
-            offsetX: 0,
-            offsetY: 0,
-            offsetZ: 0,
-            probeSpace: 64,
-            probeXCount: 4,
-            probeYCount: 2,
-            probeZCount: 4,
-            probeSize: 32,
-            probeSourceTextureSize: 2048,
-            octRTMaxSize: 2048,
-            octRTSideSize: 16,
-            maxDistance: 64 * 1.73,
-            normalBias: 0.25,
-            depthSharpness: 1,
-            hysteresis: 0.98,
-            lerpHysteresis: 0.01, // 值越小，反应越慢，可以防止闪烁
-            irradianceChebyshevBias: 0.01, // 减少漏光
-            rayNumber: 144,
-            irradianceDistanceBias: 32,
-            indirectIntensity: 1.0, // 控制间接光强度
-            ddgiGamma: 2.2,
-            bounceIntensity: 0.025, // 光线反弹效果
-            probeRoughness: 1,
-            realTimeGI: false, // 实时捕捉
-            debug: false,
-            autoRenderProbe: false,
-        },
-        sky: {
-            type: "HDRSKY",
-            sky: null,
-            skyExposure: 1.0,
-            defaultFar: 65536, //can't be too big
-            defaultNear: 1,
-        },
-        light: {
-            maxLight: 4096,
-        },
-        material: {
-            materialChannelDebug: false,
-            materialDebug: false,
-        },
-        loader: {
-            numConcurrent: 20, // 并发加载资源数量
-        },
-        reflectionSetting: {
-            // 反射探针
-            reflectionProbeMaxCount: 8,
-            reflectionProbeSize: 256,
-            width: 256 * 6,
-            height: 8 * 256,
-            enable: true,
-        },
-    }; }
-    static async init(descriptor = {}) {
-        console.log("Rings Version", version);
-        if (!window.isSecureContext) {
-            console.warn("WebGPU is only supported in secure contexts (HTTPS or localhost)");
-        }
-        this.setting = { ...this.setting, ...descriptor.engineSetting };
-        await WasmMatrix.init(Matrix4.allocCount, this.setting.doublePrecision);
-        await webGPUContext.init(descriptor.canvasConfig);
-        this.setting.reflectionSetting.width =
-            this.setting.reflectionSetting.reflectionProbeSize * 6;
-        this.setting.reflectionSetting.height =
-            this.setting.reflectionSetting.reflectionProbeSize *
-                this.setting.reflectionSetting.reflectionProbeMaxCount;
-        GBufferFrame.getGBufferFrame(GBufferFrame.reflections_GBuffer, this.setting.reflectionSetting.width, this.setting.reflectionSetting.height, false);
-        ShaderLib.init();
-        ShaderUtil.init();
-        GlobalBindGroup.init();
-        RTResourceMap.init();
-        ShadowLightsCollect.init();
-        this.res = new Res();
-        this.res.initDefault();
-        this._beforeRender = descriptor.beforeRender;
-        this._renderLoop = descriptor.renderLoop;
-        this._lateRender = descriptor.lateRender;
-        this.inputSystem = new InputSystem();
-        this.inputSystem.initCanvas(webGPUContext.canvas);
-        return;
-    }
-    static startRenderJob(view) {
-        let renderJob = new ForwardRenderJob(view);
-        this.renderJobs.set(view, renderJob);
-        if (this.setting.pick.mode == `pixel`) {
-            let postProcessing = view.scene.getOrAddComponent(PostProcessingComponent);
-            postProcessing.addPost(FXAAPost);
-        }
-        if (this.setting.pick.mode == `pixel` ||
-            this.setting.pick.mode == `bound`) {
-            view.enablePick = true;
-        }
-        return renderJob;
-    }
-    static startRenderView(view) {
-        this.renderJobs ||= new Map();
-        this.views = [view];
-        let renderJob = this.startRenderJob(view);
-        this.resume();
-        return renderJob;
-    }
-    static startRenderViews(views) {
-        this.renderJobs ||= new Map();
-        this.views = views;
-        for (let i = 0; i < views.length; i++) {
-            this.startRenderJob(views[i]);
-        }
-        this.resume();
-    }
-    static getRenderJob(view) {
-        return this.renderJobs.get(view);
-    }
-    static pause() {
-        if (this._requestAnimationFrameID !== 0) {
-            cancelAnimationFrame(this._requestAnimationFrameID);
-            this._requestAnimationFrameID = 0;
-        }
-    }
-    static resume() {
-        if (this._requestAnimationFrameID === 0)
-            this._requestAnimationFrameID = requestAnimationFrame((t) => this.render(t));
-    }
-    static async render(time) {
-        if (this._frameRateValue > 0) {
-            let delta = time - this._time;
-            if (delta < this._frameRateValue) {
-                let t = performance.now();
-                await new Promise((res) => {
-                    setTimeout(() => {
-                        time += performance.now() - t;
-                        res(true);
-                    }, this._frameRateValue - delta);
-                });
-            }
-            this._time = time;
-        }
-        await this.updateFrame(time);
-        this._requestAnimationFrameID = 0;
-        this.resume();
-    }
-    static async updateFrame(time) {
-        Time.delta = time - Time.time;
-        Time.time = time;
-        Time.frame += 1;
-        Interpolator.tick(Time.delta);
-        /* update all transform */
-        let views = this.views;
-        let i = 0;
-        for (i = 0; i < views.length; i++) {
-            const view = views[i];
-            view.scene.waitUpdate();
-            let [w, h] = webGPUContext.presentationSize;
-            view.camera.viewPort.setTo(0, 0, w, h);
-        }
-        if (this._beforeRender)
-            await this._beforeRender();
-        /****** auto start with component list *****/
-        // ComponentCollect.startComponents();
-        /****** auto before update with component list *****/
-        for (const iterator of ComponentCollect.componentsBeforeUpdateList) {
-            let k = iterator[0];
-            let v = iterator[1];
-            for (const iterator2 of v) {
-                let f = iterator2[0];
-                let c = iterator2[1];
-                if (f.enable) {
-                    c(k);
-                }
-            }
-        }
-        let command = webGPUContext.device.createCommandEncoder();
-        for (const iterator of ComponentCollect.componentsComputeList) {
-            let k = iterator[0];
-            let v = iterator[1];
-            for (const iterator2 of v) {
-                let f = iterator2[0];
-                let c = iterator2[1];
-                if (f.enable) {
-                    c(k, command);
-                }
-            }
-        }
-        webGPUContext.device.queue.submit([command.finish()]);
-        /****** auto update with component list *****/
-        for (const iterator of ComponentCollect.componentsUpdateList) {
-            let k = iterator[0];
-            let v = iterator[1];
-            for (const iterator2 of v) {
-                let f = iterator2[0];
-                let c = iterator2[1];
-                if (f.enable) {
-                    c(k);
-                }
-            }
-        }
-        for (const iterator of ComponentCollect.graphicComponent) {
-            let k = iterator[0];
-            let v = iterator[1];
-            for (const iterator2 of v) {
-                let f = iterator2[0];
-                let c = iterator2[1];
-                if (k && f.enable) {
-                    c(k);
-                }
-            }
-        }
-        if (this._renderLoop) {
-            await this._renderLoop();
-        }
-        WasmMatrix.updateAllContinueTransform(0, Matrix4.useCount, 16);
-        /****** auto update global matrix share buffer write to gpu *****/
-        let globalMatrixBindGroup = GlobalBindGroup.modelMatrixBindGroup;
-        globalMatrixBindGroup.writeBuffer(Matrix4.useCount * 16);
-        this.renderJobs.forEach((v, k) => {
-            if (!v.renderState) {
-                v.start();
-            }
-            v.renderFrame();
-        });
-        /****** auto late update with component list *****/
-        for (const iterator of ComponentCollect.componentsLateUpdateList) {
-            let k = iterator[0];
-            let v = iterator[1];
-            for (const iterator2 of v) {
-                let f = iterator2[0];
-                let c = iterator2[1];
-                if (f.enable) {
-                    c(k);
-                }
-            }
-        }
-        if (this._lateRender)
-            await this._lateRender();
-    }
-}

package/dist/src/assets/Fonts.d.ts

@@ -1,20 +0,0 @@
-import { GUISprite } from "../components/gui/core/GUISprite";
-import { FontInfo } from "../loader/parser/FontParser";
-declare class Fonts {
-    protected fntCache: {
-        [key: number]: {
-            [key: string]: GUISprite;
-        };
-    };
-    protected fntData: {
-        [key: number]: {
-            [key: string]: FontInfo;
-        };
-    };
-    addFontData(face: string, size: number, fontData: FontInfo): void;
-    getFontData(face: string, size: number): FontInfo;
-    addFnt(font: string, size: number, id: string, sprite: GUISprite): void;
-    getFnt(font: string, size: number, id: string): GUISprite;
-}
-export declare let fonts: Fonts;
-export {};

package/dist/src/assets/Fonts.js

@@ -1,24 +0,0 @@
-class Fonts {
-    constructor() {
-        this.fntCache = {};
-        this.fntData = {};
-    }
-    addFontData(face, size, fontData) {
-        this.fntData[`${face}${size}`] = fontData;
-    }
-    getFontData(face, size) {
-        return this.fntData[`${face}${size}`];
-    }
-    addFnt(font, size, id, sprite) {
-        let key = `${font}${size}`;
-        if (!this.fntCache[key])
-            this.fntCache[key] = {};
-        this.fntCache[key][id] = sprite;
-    }
-    getFnt(font, size, id) {
-        let key = `${font}${size}`;
-        let list = this.fntCache[key];
-        return list ? list[id] : this.fntCache[` `];
-    }
-}
-export let fonts = new Fonts();

package/dist/src/assets/Res.d.ts

@@ -1,72 +0,0 @@
-import { Object3D } from "../core/entities/Object3D";
-import { Texture } from "../gfx/graphics/webGpu/core/texture/Texture";
-import { LoaderFunctions } from "../loader/LoaderFunctions";
-import { BitmapTexture2D } from "../textures/BitmapTexture2D";
-import { HDRTextureCube } from "../textures/HDRTextureCube";
-import { GLTF_Info } from "../loader/parser/gltf/GLTFInfo";
-import { Uint8ArrayTexture } from "../textures/Uint8ArrayTexture";
-import { GUISprite } from "../components/gui/core/GUISprite";
-import { GUITexture } from "../components/gui/core/GUITexture";
-import { GUIAtlasTexture } from "../components/gui/core/GUIAtlasTexture";
-import { FontInfo } from "../loader/parser/FontParser";
-import { Material } from "../materials/Material";
-import { Parser } from "../util/Global";
-import { ParserBase } from "../loader/parser/ParserBase";
-import { GeometryBase } from "../core/geometry/GeometryBase";
-import { LitMaterial } from "../materials/LitMaterial";
-export declare class Res {
-    private _texturePool;
-    private _materialPool;
-    private _prefabPool;
-    private _gltfPool;
-    private _geometryPool;
-    private _atlasList;
-    private _obj;
-    constructor();
-    getGltf(url: string): GLTF_Info;
-    addObj(url: string, obj: any): void;
-    getObj(url: string): any;
-    addTexture(url: string, texture: Texture): void;
-    getTexture(url: string): Texture;
-    addGeometry(url: string, geo: GeometryBase): void;
-    getGeometry(url: string): GeometryBase;
-    addMat(name: string, mat: Material): Map<string, Material>;
-    getMat(name: string): Material;
-    addPrefab(name: string, rootScene: Object3D): void;
-    getPrefab(name: string): Object3D;
-    addAtlas(name: string, atlas: GUIAtlasTexture): void;
-    getAtlas(name: string): GUIAtlasTexture;
-    getGUISprite(id: string): GUISprite;
-    load<T extends ParserBase>(url: string, c: Parser<T>, loaderFunctions?: LoaderFunctions): Promise<T["data"]>;
-    loadGltf(url: string, loaderFunctions?: LoaderFunctions): Promise<Object3D>;
-    loadObj(url: string, loaderFunctions?: LoaderFunctions): Promise<Object3D>;
-    loadB3DM(url: string, loaderFunctions?: LoaderFunctions, userData?: any): Promise<Object3D>;
-    loadI3DM(url: string, loaderFunctions?: LoaderFunctions, userData?: any): Promise<Object3D>;
-    loadTexture(url: string, loaderFunctions?: LoaderFunctions, flipY?: boolean): Promise<Texture>;
-    private loadTextureCount;
-    loadBitmapTextures(urls: string[], count?: number, loaderFunctions?: LoaderFunctions, flipY?: boolean): Promise<BitmapTexture2D[]>;
-    loadHDRTexture(url: string, loaderFunctions?: LoaderFunctions): Promise<Texture>;
-    loadHDRTextureCube(url: string, loaderFunctions?: LoaderFunctions): Promise<Texture>;
-    loadLDRTextureCube(url: string, loaderFunctions?: LoaderFunctions): Promise<Texture>;
-    loadTextureCubeMaps(urls: string[]): Promise<Texture>;
-    loadTextureCubeStd(url: string, loaderFunctions?: LoaderFunctions): Promise<Texture>;
-    loadJSON(url: string, loaderFunctions?: LoaderFunctions): Promise<void | object>;
-    loadFont(url: string, loaderFunctions?: LoaderFunctions, userData?: any): Promise<FontInfo>;
-    loadAtlas(url: string, loaderFunctions?: LoaderFunctions): Promise<FontInfo>;
-    normalTexture: Uint8ArrayTexture;
-    maskTexture: Uint8ArrayTexture;
-    whiteTexture: Uint8ArrayTexture;
-    blackTexture: Uint8ArrayTexture;
-    redTexture: Uint8ArrayTexture;
-    blueTexture: Uint8ArrayTexture;
-    greenTexture: Uint8ArrayTexture;
-    yellowTexture: Uint8ArrayTexture;
-    grayTexture: Uint8ArrayTexture;
-    defaultSky: HDRTextureCube;
-    defaultGUITexture: GUITexture;
-    defaultGUISprite: GUISprite;
-    defaultMaterial: LitMaterial;
-    createTexture(width: number, height: number, r: number, g: number, b: number, a: number, name?: string): Uint8ArrayTexture;
-    fillColor(array: any, w: number, h: number, r: number, g: number, b: number, a: number): void;
-    initDefault(): void;
-}