@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/components/post/PostProcessingComponent.d.ts

@@ -0,0 +1,16 @@
+import { PostBase } from "../../gfx/renderJob/post/PostBase";
+import { Ctor } from "../../util/Global";
+import { ComponentBase } from "../ComponentBase";
+export declare class PostProcessingComponent extends ComponentBase {
+    private _postList;
+    init(param?: any): void;
+    start(): void;
+    stop(): void;
+    onEnable(): void;
+    onDisable(): void;
+    private activePost;
+    private unActivePost;
+    addPost<T extends PostBase>(c: Ctor<T>): T;
+    removePost<T extends PostBase>(c: Ctor<T>): void;
+    getPost<T extends PostBase>(c: Ctor<T>): T;
+}

package/dist/src/components/post/PostProcessingComponent.js

@@ -0,0 +1,52 @@
+import { Engine3D } from "../../Engine3D";
+import { ComponentBase } from "../ComponentBase";
+export class PostProcessingComponent extends ComponentBase {
+    init(param) {
+        this._postList = new Map();
+    }
+    start() { }
+    stop() { }
+    onEnable() {
+        this.activePost();
+    }
+    onDisable() {
+        this.unActivePost();
+    }
+    activePost() {
+        let view = this.transform.view3D;
+        let job = Engine3D.getRenderJob(view);
+        this._postList.forEach((v) => {
+            job.addPost(v);
+        });
+    }
+    unActivePost() {
+        let view = this.transform.view3D;
+        let job = Engine3D.getRenderJob(view);
+        this._postList.forEach((v) => {
+            job.removePost(v);
+        });
+    }
+    addPost(c) {
+        if (this._postList.has(c))
+            return;
+        let post = new c();
+        this._postList.set(c, post);
+        if (this._enable)
+            this.activePost();
+        return post;
+    }
+    removePost(c) {
+        if (!this._postList.has(c))
+            return;
+        let post = this._postList.get(c);
+        this._postList.delete(c);
+        let view = this.transform.view3D;
+        let job = Engine3D.getRenderJob(view);
+        job.removePost(post);
+    }
+    getPost(c) {
+        if (!this._postList.has(c))
+            return null;
+        return this._postList.get(c);
+    }
+}

package/dist/src/components/renderer/GlobalIlluminationComponent.d.ts

@@ -0,0 +1,22 @@
+import { Scene3D } from "../../core/Scene3D";
+import { ComponentBase } from "../ComponentBase";
+/**
+ *
+ * 动态全局光照.
+ * 使用全局光照实现更真实的光照效果。
+ * 全局光照系统可以模拟光线在表面反射或折射到其他表面(间接光照)的方式，
+ * 而不仅限于光线直接从光源照射到某个表面。
+ * @group Components
+ */
+export declare class GlobalIlluminationComponent extends ComponentBase {
+    private _probes;
+    private _volume;
+    private _debugMr;
+    init(scene: Scene3D): void;
+    private initProbe;
+    debug(): void;
+    private debugProbeRay;
+    private changeProbesVolumeData;
+    private changeProbesPosition;
+    onUpdate(): void;
+}

package/dist/src/components/renderer/GlobalIlluminationComponent.js

@@ -0,0 +1,118 @@
+import { Engine3D } from "../../Engine3D";
+import { GlobalBindGroup } from "../../gfx/graphics/webGpu/core/bindGroups/GlobalBindGroup";
+import { EntityCollect } from "../../gfx/renderJob/collect/EntityCollect";
+import { Probe } from "../../gfx/renderJob/passRenderer/ddgi/Probe";
+import { GIProbeMaterial, GIProbeMaterialType, } from "../../materials/GIProbeMaterial";
+import { Quaternion } from "../../math/Quaternion";
+import { Vector3 } from "../../math/Vector3";
+import { SphereGeometry } from "../../shape/SphereGeometry";
+import { ComponentBase } from "../ComponentBase";
+import { MeshRenderer } from "./MeshRenderer";
+/**
+ *
+ * 动态全局光照.
+ * 使用全局光照实现更真实的光照效果。
+ * 全局光照系统可以模拟光线在表面反射或折射到其他表面(间接光照)的方式，
+ * 而不仅限于光线直接从光源照射到某个表面。
+ * @group Components
+ */
+export class GlobalIlluminationComponent extends ComponentBase {
+    constructor() {
+        super(...arguments);
+        this._debugMr = [];
+    }
+    init(scene) {
+        scene ||= Engine3D.views[0]?.scene;
+        Engine3D.setting.gi.enable = true;
+        this._volume = GlobalBindGroup.getLightEntries(scene).irradianceVolume;
+        this.initProbe(scene);
+    }
+    initProbe(scene) {
+        let xCount = this._volume.setting.probeXCount;
+        let yCount = this._volume.setting.probeYCount;
+        let zCount = this._volume.setting.probeZCount;
+        let debugGeo = new SphereGeometry(4, 16, 16);
+        let position = new Vector3();
+        this._probes = [];
+        for (let x = 0; x < xCount; x++) {
+            for (let y = 0; y < yCount; y++) {
+                for (let z = 0; z < zCount; z++) {
+                    let index = x + z * xCount + y * (xCount * zCount);
+                    let probe = new Probe();
+                    probe.index = index;
+                    probe.name = `${x}_${y}_${z}`;
+                    let mr = probe.addComponent(MeshRenderer);
+                    mr.material = new GIProbeMaterial(GIProbeMaterialType.CastGI, index);
+                    mr.geometry = debugGeo;
+                    mr.castGI = false;
+                    mr.castShadow = false;
+                    this._debugMr.push(mr);
+                    this.object3D.addChild(probe);
+                    this._volume.calcPosition(x, y, z, position);
+                    probe.x = position.x;
+                    probe.y = position.y;
+                    probe.z = position.z;
+                    this._probes[index] = probe;
+                    this._debugMr.push(mr);
+                }
+            }
+        }
+        for (let i = 0; i < this._probes.length; i++) {
+            EntityCollect.instance.addGIProbe(scene, this._probes[i]);
+        }
+        this.object3D.transform.enable = false;
+        if (this._volume.setting.debug) {
+            this.debug();
+        }
+    }
+    debug() { }
+    debugProbeRay(probeIndex, array) {
+        const rayNumber = Engine3D.setting.gi.rayNumber;
+        let quat = new Quaternion(0.0, -0.7071067811865475, 0.7071067811865475, 0.0);
+        for (let i = 0; i < rayNumber; i++) {
+            let ii = probeIndex * rayNumber + i;
+            let dir = new Vector3(-array[ii * 4 + 0], -array[ii * 4 + 1], -array[ii * 4 + 2], 0);
+            quat.transformVector(dir, dir);
+            let len = array[ii * 4 + 3];
+            let id = `showRays${probeIndex}${i}`;
+            let start = this._probes[probeIndex].transform.worldPosition.clone();
+            let end = dir.scaleBy(len);
+            end.add(start, end);
+        }
+    }
+    changeProbesVolumeData() {
+        this._volume.setVolumeDataChange();
+    }
+    changeProbesPosition() {
+        this._volume.setVolumeDataChange();
+        let xCount = this._volume.setting.probeXCount;
+        let yCount = this._volume.setting.probeYCount;
+        let zCount = this._volume.setting.probeZCount;
+        let position = new Vector3();
+        for (let x = 0; x < xCount; x++) {
+            for (let y = 0; y < yCount; y++) {
+                for (let z = 0; z < zCount; z++) {
+                    let index = x + z * xCount + y * (xCount * zCount);
+                    let probe = this._probes[index];
+                    this._volume.calcPosition(x, y, z, position);
+                    probe.x = position.x;
+                    probe.y = position.y;
+                    probe.z = position.z;
+                }
+            }
+        }
+    }
+    onUpdate() {
+        Engine3D.setting.gi.maxDistance = Engine3D.setting.gi.probeSpace * 1.5;
+        let camera = this.transform.scene3D.view.camera;
+        let scale = Vector3.distance(camera.transform.worldPosition, camera.transform.targetPos) / 300;
+        if (this._debugMr && this._debugMr.length > 0) {
+            for (let i = 0; i < this._debugMr.length; i++) {
+                const debugOBJ = this._debugMr[i].transform;
+                debugOBJ.scaleX = scale;
+                debugOBJ.scaleY = scale;
+                debugOBJ.scaleZ = scale;
+            }
+        }
+    }
+}

package/dist/src/components/renderer/InstanceDrawComponent.d.ts

@@ -0,0 +1,19 @@
+import { RenderContext } from "../../gfx/renderJob/passRenderer/RenderContext";
+import { RenderNode } from "./RenderNode";
+import { View3D } from "../../core/View3D";
+import { RendererPassState } from "../../gfx/renderJob/passRenderer/state/RendererPassState";
+import { PassType } from "../../gfx/renderJob/passRenderer/state/PassType";
+import { ClusterLightingBuffer } from "../../gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer";
+export declare class InstanceDrawComponent extends RenderNode {
+    private _keyRenderGroup;
+    private _keyBufferGroup;
+    private _keyIdsGroup;
+    constructor();
+    init(param?: any): void;
+    start(): void;
+    reset(): void;
+    nodeUpdate(view: View3D, passType: PassType, renderPassState: RendererPassState, clusterLightingBuffer?: ClusterLightingBuffer): void;
+    renderPass(view: View3D, passType: PassType, renderContext: RenderContext): void;
+    renderItem(view: View3D, passType: PassType, renderNode: RenderNode, renderContext: RenderContext): void;
+    beforeDestroy(force?: boolean): void;
+}

package/dist/src/components/renderer/InstanceDrawComponent.js

@@ -0,0 +1,120 @@
+import { GPUContext } from "../../gfx/renderJob/GPUContext";
+import { RTResourceMap } from "../../gfx/renderJob/frame/RTResourceMap";
+import { MeshRenderer } from "./MeshRenderer";
+import { RenderNode } from "./RenderNode";
+import { StorageGPUBuffer } from "../../gfx/graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { ComponentCollect } from "../../gfx/renderJob/collect/ComponentCollect";
+export class InstanceDrawComponent extends RenderNode {
+    constructor() {
+        super();
+    }
+    init(param) {
+        this._keyRenderGroup = new Map();
+        this._keyBufferGroup = new Map();
+        this._keyIdsGroup = new Map();
+    }
+    start() {
+        let meshRenders = [];
+        this.object3D.getComponents(MeshRenderer, meshRenders, true);
+        for (let i = 0; i < meshRenders.length; i++) {
+            const mr = meshRenders[i];
+            mr.transform.updateWorldMatrix(true);
+            mr.enable = false;
+            let key = mr.geometry.instanceID;
+            for (let j = 0; j < mr.materials.length; j++) {
+                const mat = mr.materials[j];
+                key += mat.instanceID;
+            }
+            if (!this._keyRenderGroup.has(key)) {
+                let matrixBuffer = new StorageGPUBuffer(meshRenders.length);
+                matrixBuffer.visibility = GPUShaderStage.VERTEX;
+                this._keyRenderGroup.set(key, [mr]);
+                this._keyBufferGroup.set(key, matrixBuffer);
+                this._keyIdsGroup.set(key, [mr.transform.worldMatrix.index]);
+            }
+            else {
+                this._keyRenderGroup.get(key).push(mr);
+                this._keyIdsGroup.get(key).push(mr.transform.worldMatrix.index);
+            }
+        }
+        this._keyBufferGroup.forEach((v, k) => {
+            let ids = this._keyIdsGroup.get(k);
+            let instanceMatrixBuffer = this._keyBufferGroup.get(k);
+            instanceMatrixBuffer.setInt32Array("matrixIDs", new Int32Array(ids));
+            instanceMatrixBuffer.apply();
+        });
+    }
+    reset() {
+        if (this._keyRenderGroup.size > 0) {
+            this._keyRenderGroup.clear();
+            this._keyBufferGroup.clear();
+            this._keyIdsGroup.clear();
+            this.start();
+        }
+    }
+    nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+        this._keyRenderGroup.forEach((v, k) => {
+            let instanceMatrixBuffer = this._keyBufferGroup.get(k);
+            let renderNode = v[0];
+            for (let i = 0; i < renderNode.materials.length; i++) {
+                let material = renderNode.materials[i];
+                let passes = material.getPass(passType);
+                if (passes) {
+                    for (let i = 0; i < passes.length; i++) {
+                        const renderShader = passes[i];
+                        renderShader.setDefine("USE_INSTANCEDRAW", true);
+                        renderShader.setStorageBuffer(`instanceDrawID`, instanceMatrixBuffer);
+                    }
+                }
+            }
+            renderNode.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
+        });
+    }
+    renderPass(view, passType, renderContext) {
+        this._keyRenderGroup.forEach((v, k) => {
+            let renderNode = v[0];
+            renderNode.instanceCount = v.length;
+            this.renderItem(view, passType, renderNode, renderContext);
+        });
+    }
+    renderItem(view, passType, renderNode, renderContext) {
+        let worldMatrix = renderNode.transform._worldMatrix;
+        for (let i = 0; i < renderNode.materials.length; i++) {
+            const material = renderNode.materials[i];
+            let passes = material.getPass(passType);
+            if (!passes || passes.length == 0)
+                continue;
+            for (let j = 0; j < passes.length; j++) {
+                let matPass = passes[j];
+                GPUContext.bindGeometryBuffer(renderContext.encoder, renderNode.geometry);
+                const renderShader = matPass;
+                if (renderShader.shaderState.splitTexture) {
+                    renderContext.endRenderPass();
+                    RTResourceMap.WriteSplitColorTexture(renderNode.instanceID);
+                    renderContext.beginOpaqueRenderPass();
+                    GPUContext.bindCamera(renderContext.encoder, view.camera);
+                    GPUContext.bindGeometryBuffer(renderContext.encoder, renderNode.geometry);
+                }
+                GPUContext.bindPipeline(renderContext.encoder, renderShader);
+                let subGeometries = renderNode.geometry.subGeometries;
+                const subGeometry = subGeometries[i];
+                let lodInfos = subGeometry.lodLevels;
+                let lodInfo = lodInfos[renderNode.lodLevel];
+                if (renderNode.instanceCount > 0) {
+                    GPUContext.drawIndexed(renderContext.encoder, lodInfo.indexCount, renderNode.instanceCount, lodInfo.indexStart, 0, 0);
+                }
+                else {
+                    GPUContext.drawIndexed(renderContext.encoder, lodInfo.indexCount, 1, lodInfo.indexStart, 0, worldMatrix.index);
+                }
+            }
+        }
+    }
+    beforeDestroy(force) {
+        this._keyRenderGroup.clear();
+        this._keyBufferGroup.clear();
+        this._keyIdsGroup.clear();
+        //@ts-ignore
+        this._keyRenderGroup = this._keyBufferGroup = this._keyIdsGroup = undefined;
+        ComponentCollect.removeWaitStart(this.object3D, this);
+    }
+}

package/dist/src/components/renderer/MeshFilter.d.ts

@@ -0,0 +1,9 @@
+import { GeometryBase, Object3D } from "../..";
+import { MeshRenderer } from "./MeshRenderer";
+export declare class MeshFilter extends MeshRenderer {
+    constructor();
+    get geometry(): GeometryBase;
+    set geometry(value: GeometryBase);
+    cloneTo(obj: Object3D): void;
+    set meshURL(value: string);
+}

package/dist/src/components/renderer/MeshFilter.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Engine3D } from "../../Engine3D";
+import { RegisterComponent } from "../../util/SerializeDecoration";
+import { MeshRenderer } from "./MeshRenderer";
+/* eslint-disable */
+let MeshFilter = class MeshFilter extends MeshRenderer {
+    constructor() {
+        super();
+    }
+    get geometry() {
+        return null;
+    }
+    set geometry(value) { }
+    cloneTo(obj) { }
+    set meshURL(value) {
+        let geometry = Engine3D.res.getGeometry(value);
+        if (geometry) {
+            this.geometry = geometry;
+        }
+        else {
+            console.error("no geometry set", value);
+        }
+    }
+};
+MeshFilter = __decorate([
+    RegisterComponent(MeshFilter, "MeshFilter"),
+    __metadata("design:paramtypes", [])
+], MeshFilter);
+export { MeshFilter };

package/dist/src/components/renderer/MeshRenderer.d.ts

@@ -0,0 +1,51 @@
+import { Object3D } from '../../core/entities/Object3D';
+import { View3D } from '../../core/View3D';
+import { ClusterLightingBuffer } from '../../gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer';
+import { GeometryBase } from '../../core/geometry/GeometryBase';
+import { RendererPassState } from '../../gfx/renderJob/passRenderer/state/RendererPassState';
+import { PassType } from '../../gfx/renderJob/passRenderer/state/PassType';
+import { MorphTargetData } from '../anim/morphAnim/MorphTargetData';
+import { RenderNode } from './RenderNode';
+import { Material } from '../../materials/Material';
+/**
+ * The mesh renderer component is a component used to render the mesh
+ * @group Components
+ */
+export declare class MeshRenderer extends RenderNode {
+    /**
+     * Enabling this option allows the grid to display any shadows cast on the grid.
+     */
+    receiveShadow: boolean;
+    morphData: MorphTargetData;
+    constructor();
+    onEnable(): void;
+    onDisable(): void;
+    cloneTo(obj: Object3D): void;
+    copyComponent(from: this): this;
+    /**
+     * The geometry of the mesh determines its shape
+     */
+    get geometry(): GeometryBase;
+    set geometry(value: GeometryBase);
+    /**
+     * material
+     */
+    get material(): Material;
+    set material(value: Material);
+    /**
+     * Set deformation animation parameters
+     */
+    setMorphInfluence(key: string, value: number): void;
+    setMorphInfluenceIndex(index: number, value: number): void;
+    onCompute(view: View3D, command: GPUCommandEncoder): void;
+    /**
+     * @internal
+     * @param passType
+     * @param renderPassState
+     * @param scene3D
+     * @param clusterLightingRender
+     * @param probes
+     */
+    nodeUpdate(view: View3D, passType: PassType, renderPassState: RendererPassState, clusterLightingBuffer: ClusterLightingBuffer): void;
+    destroy(force?: boolean): void;
+}

package/dist/src/components/renderer/MeshRenderer.js

@@ -0,0 +1,156 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var MeshRenderer_1;
+import { GeometryBase } from '../../core/geometry/GeometryBase';
+import { RendererMask } from '../../gfx/renderJob/passRenderer/state/RendererMask';
+import { MorphTargetData } from '../anim/morphAnim/MorphTargetData';
+import { RenderNode } from './RenderNode';
+import { EditorInspector, RegisterComponent } from '../../util/SerializeDecoration';
+import { mergeFunctions } from '../../util/Global';
+import { Material } from '../../materials/Material';
+/**
+ * The mesh renderer component is a component used to render the mesh
+ * @group Components
+ */
+let MeshRenderer = MeshRenderer_1 = class MeshRenderer extends RenderNode {
+    constructor() {
+        super();
+    }
+    onEnable() {
+        super.onEnable();
+    }
+    onDisable() {
+        super.onDisable();
+    }
+    cloneTo(obj) {
+        let component = obj.addComponent(MeshRenderer_1);
+        component.copyComponent(this);
+    }
+    copyComponent(from) {
+        super.copyComponent(from);
+        this.receiveShadow = from.receiveShadow;
+        return this;
+    }
+    /**
+     * The geometry of the mesh determines its shape
+     */
+    get geometry() {
+        return this._geometry;
+    }
+    set geometry(value) {
+        //this must use super geometry has reference in super
+        super.geometry = value;
+        if (value) {
+            let isMorphTarget = value.morphTargetDictionary != null;
+            if (isMorphTarget) {
+                this.morphData ||= new MorphTargetData();
+                this.morphData.morphTargetsRelative = value.morphTargetsRelative;
+                this.morphData.initMorphTarget(value);
+            }
+            this.morphData && (this.morphData.enable = isMorphTarget);
+            if (this.morphData?.enable) {
+                this.addRendererMask(RendererMask.MorphTarget);
+            }
+            else {
+                this.removeRendererMask(RendererMask.MorphTarget);
+            }
+            this.object3D.bound = this._geometry.bounds.clone();
+        }
+        else {
+            if (this.morphData) {
+                this.morphData.enable = false;
+            }
+            this.removeRendererMask(RendererMask.MorphTarget);
+        }
+        if (!this._readyPipeline) {
+            this.initPipeline();
+            if (this._computes) {
+                this.onCompute = mergeFunctions(this.onCompute, () => {
+                    for (let i = 0; i < this._computes.length; i++) {
+                        const compute = this._computes[i];
+                        compute.onUpdate();
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * material
+     */
+    get material() {
+        return this._materials[0];
+    }
+    set material(value) {
+        this.materials = [value];
+    }
+    /**
+     * Set deformation animation parameters
+     */
+    setMorphInfluence(key, value) {
+        if (this.morphData && this.morphData.enable) {
+            let index = this._geometry.morphTargetDictionary[key];
+            if (index >= 0) {
+                this.morphData.updateInfluence(index, value);
+            }
+        }
+    }
+    setMorphInfluenceIndex(index, value) {
+        if (this.morphData && this.morphData.enable) {
+            if (index >= 0) {
+                this.morphData.updateInfluence(index, value);
+            }
+        }
+    }
+    onCompute(view, command) {
+        if (this.morphData && this.morphData.enable) {
+            this.morphData.computeMorphTarget(command);
+        }
+    }
+    /**
+     * @internal
+     * @param passType
+     * @param renderPassState
+     * @param scene3D
+     * @param clusterLightingRender
+     * @param probes
+     */
+    nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+        if (this.morphData && this.morphData.enable) {
+            for (let i = 0; i < this.materials.length; i++) {
+                const material = this.materials[i];
+                let passes = material.getPass(passType);
+                if (passes) {
+                    for (let j = 0; j < passes.length; j++) {
+                        this.morphData.applyRenderShader(passes[j]);
+                    }
+                }
+            }
+        }
+        super.nodeUpdate(view, passType, renderPassState, clusterLightingBuffer);
+    }
+    destroy(force) {
+        super.destroy(force);
+    }
+};
+__decorate([
+    EditorInspector,
+    __metadata("design:type", GeometryBase),
+    __metadata("design:paramtypes", [GeometryBase])
+], MeshRenderer.prototype, "geometry", null);
+__decorate([
+    EditorInspector,
+    __metadata("design:type", Material),
+    __metadata("design:paramtypes", [Material])
+], MeshRenderer.prototype, "material", null);
+MeshRenderer = MeshRenderer_1 = __decorate([
+    RegisterComponent(MeshRenderer, 'MeshRenderer'),
+    __metadata("design:paramtypes", [])
+], MeshRenderer);
+export { MeshRenderer };

package/dist/src/components/renderer/Reflection.d.ts

@@ -0,0 +1,15 @@
+import { View3D } from "../../core/View3D";
+import { ClusterLightingBuffer } from "../../gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer";
+import { RendererPassState } from "../../gfx/renderJob/passRenderer/state/RendererPassState";
+import { PassType } from "../../gfx/renderJob/passRenderer/state/PassType";
+import { RenderNode } from "./RenderNode";
+export declare class Reflection extends RenderNode {
+    gid: number;
+    needUpdate: boolean;
+    autoUpdate: boolean;
+    radius: number;
+    init(): void;
+    onEnable(): void;
+    onDisable(): void;
+    renderPass2(view: View3D, passType: PassType, rendererPassState: RendererPassState, clusterLightingBuffer: ClusterLightingBuffer, encoder: GPURenderPassEncoder, useBundle?: boolean): void;
+}

package/dist/src/components/renderer/Reflection.js

@@ -0,0 +1,33 @@
+import { BoundingBox } from "../../core/bound/BoundingBox";
+import { EntityCollect } from "../../gfx/renderJob/collect/EntityCollect";
+import { RendererMask } from "../../gfx/renderJob/passRenderer/state/RendererMask";
+import { Vector3 } from "../../math/Vector3";
+import { RenderNode } from "./RenderNode";
+import { mergeFunctions } from "../../util/Global";
+export class Reflection extends RenderNode {
+    constructor() {
+        super(...arguments);
+        this.gid = 0;
+        this.needUpdate = true;
+        this.autoUpdate = false;
+        this.radius = 500;
+    }
+    init() {
+        super.init();
+        this.addRendererMask(RendererMask.Reflection);
+        this.alwaysRender = true;
+        this.object3D.bound = new BoundingBox(Vector3.ZERO.clone(), Vector3.MAX);
+        mergeFunctions(this.transform.onPositionChange, () => {
+            this.needUpdate = true;
+        });
+    }
+    onEnable() {
+        EntityCollect.instance.addRenderNode(this.transform.scene3D, this);
+    }
+    onDisable() {
+        EntityCollect.instance.removeRenderNode(this.transform.scene3D, this);
+    }
+    renderPass2(view, passType, rendererPassState, clusterLightingBuffer, encoder, useBundle = false) {
+        super.renderPass2(view, passType, rendererPassState, clusterLightingBuffer, encoder, useBundle);
+    }
+}