@rings-webgpu/core 1.0.0 → 1.0.2

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

@@ -0,0 +1,85 @@
+import { View3D } from "../../core/View3D";
+import { GeometryBase } from "../../core/geometry/GeometryBase";
+import { ShaderReflection } from "../../gfx/graphics/webGpu/shader/value/ShaderReflectionInfo";
+import { RenderContext } from "../../gfx/renderJob/passRenderer/RenderContext";
+import { ClusterLightingBuffer } from "../../gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer";
+import { RendererMask } from "../../gfx/renderJob/passRenderer/state/RendererMask";
+import { RendererPassState } from "../../gfx/renderJob/passRenderer/state/RendererPassState";
+import { ComponentBase } from "../ComponentBase";
+import { Octree } from "../../core/tree/octree/Octree";
+import { OctreeEntity } from "../../core/tree/octree/OctreeEntity";
+import { Material } from "../../materials/Material";
+import { RenderLayer } from "../../gfx/renderJob/config/RenderLayer";
+import { RenderShaderCompute } from "../../gfx/graphics/webGpu/compute/RenderShaderCompute";
+import { PassType } from "../../gfx/renderJob/passRenderer/state/PassType";
+export declare class RenderNode extends ComponentBase {
+    instanceCount: number;
+    lodLevel: number;
+    alwaysRender: boolean;
+    instanceID: string;
+    drawType: number;
+    protected _geometry: GeometryBase;
+    protected _materials: Material[];
+    protected _castShadow: boolean;
+    protected _castReflection: boolean;
+    protected _castGI: boolean;
+    protected _rendererMask: number;
+    protected _inRenderer: boolean;
+    protected _readyPipeline: boolean;
+    protected _combineShaderRefection: ShaderReflection;
+    protected _ignoreEnvMap?: boolean;
+    protected _ignorePrefilterMap?: boolean;
+    protected __renderOrder: number;
+    protected _renderOrder: number;
+    protected _passInit: Map<PassType, boolean>;
+    isRenderOrderChange?: boolean;
+    needSortOnCameraZ?: boolean;
+    isRecievePostEffectUI?: boolean;
+    protected _octreeBinder: {
+        octree: Octree;
+        entity: OctreeEntity;
+    };
+    protected _renderLayer: RenderLayer;
+    protected _computes: RenderShaderCompute[];
+    init(param?: any): void;
+    attachSceneOctree(octree: Octree): void;
+    detachSceneOctree(): void;
+    protected updateOctreeEntity(e?: any): void;
+    copyComponent(from: this): this;
+    get renderLayer(): RenderLayer;
+    set renderLayer(value: RenderLayer);
+    get geometry(): GeometryBase;
+    set geometry(value: GeometryBase);
+    addMask(mask: RendererMask): void;
+    removeMask(mask: RendererMask): void;
+    hasMask(mask: RendererMask): boolean;
+    get rendererMask(): number;
+    set rendererMask(value: number);
+    get renderOrder(): number;
+    set renderOrder(value: number);
+    get materials(): Material[];
+    set materials(value: Material[]);
+    private addComputes;
+    private removeComputes;
+    addRendererMask(tag: RendererMask): void;
+    removeRendererMask(tag: RendererMask): void;
+    onEnable(): void;
+    onDisable(): void;
+    selfCloneMaterials(key: string): this;
+    protected initPipeline(): void;
+    protected castNeedPass(): void;
+    get castShadow(): boolean;
+    set castShadow(value: boolean);
+    get castGI(): boolean;
+    set castGI(value: boolean);
+    get castReflection(): boolean;
+    set castReflection(value: boolean);
+    renderPass(view: View3D, passType: PassType, renderContext: RenderContext): void;
+    renderPass2(view: View3D, passType: PassType, rendererPassState: RendererPassState, clusterLightingBuffer: ClusterLightingBuffer, encoder: GPURenderPassEncoder, useBundle?: boolean): void;
+    recordRenderPass2(view: View3D, passType: PassType, rendererPassState: RendererPassState, clusterLightingBuffer: ClusterLightingBuffer, encoder: GPURenderPassEncoder, useBundle?: boolean): void;
+    private noticeShaderChange;
+    preInit(_rendererType: PassType): boolean;
+    nodeUpdate(view: View3D, passType: PassType, renderPassState: RendererPassState, clusterLightingBuffer?: ClusterLightingBuffer): void;
+    beforeDestroy(force?: boolean): void;
+    destroy(force?: boolean): void;
+}

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

@@ -0,0 +1,518 @@
+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 { EditorInspector } from "../../util/SerializeDecoration";
+import { Engine3D } from "../../Engine3D";
+import { PassGenerate } from "../../gfx/generate/PassGenerate";
+import { GlobalBindGroup } from "../../gfx/graphics/webGpu/core/bindGroups/GlobalBindGroup";
+import { GPUContext } from "../../gfx/renderJob/GPUContext";
+import { EntityCollect } from "../../gfx/renderJob/collect/EntityCollect";
+import { RTResourceMap } from "../../gfx/renderJob/frame/RTResourceMap";
+import { RendererMask, RendererMaskUtil, } from "../../gfx/renderJob/passRenderer/state/RendererMask";
+import { GetCountInstanceID } from "../../util/Global";
+import { Reference } from "../../util/Reference";
+import { ComponentBase } from "../ComponentBase";
+import { IESProfiles } from "../lights/IESProfiles";
+import { OctreeEntity } from "../../core/tree/octree/OctreeEntity";
+import { Transform } from "../Transform";
+import { RenderLayer } from "../../gfx/renderJob/config/RenderLayer";
+import { PassType } from "../../gfx/renderJob/passRenderer/state/PassType";
+import { ProfilerUtil } from "../../util/ProfilerUtil";
+export class RenderNode extends ComponentBase {
+    constructor() {
+        super(...arguments);
+        this.instanceCount = 0;
+        this.lodLevel = 0;
+        this.alwaysRender = false;
+        this.drawType = 0;
+        this._materials = [];
+        this._castShadow = true;
+        this._castReflection = true;
+        this._castGI = false;
+        this._rendererMask = RendererMask.Default;
+        this._inRenderer = false;
+        this._readyPipeline = false;
+        this.__renderOrder = 0; //cameraDepth + _renderOrder
+        this._renderOrder = 0;
+        this._passInit = new Map();
+        this._renderLayer = RenderLayer.None;
+    }
+    init(param) {
+        this.renderOrder = 0;
+        this.rendererMask = RendererMask.Default;
+        this.instanceID = GetCountInstanceID().toString();
+        this._computes = [];
+    }
+    attachSceneOctree(octree) {
+        this._octreeBinder = { octree, entity: new OctreeEntity(this) };
+        this.transform.eventDispatcher.addEventListener(Transform.LOCAL_ONCHANGE, this.updateOctreeEntity, this);
+    }
+    detachSceneOctree() {
+        if (this._octreeBinder) {
+            this._octreeBinder.entity?.leaveNode();
+            this.transform.eventDispatcher.removeEventListener(Transform.LOCAL_ONCHANGE, this.updateOctreeEntity, this);
+            this._octreeBinder = null;
+        }
+    }
+    updateOctreeEntity(e) {
+        this._octreeBinder?.entity?.update(this._octreeBinder.octree);
+    }
+    copyComponent(from) {
+        super.copyComponent(from);
+        this.geometry = from._geometry;
+        this.materials = from._materials.slice();
+        this.drawType = from.drawType;
+        this.alwaysRender = from.alwaysRender;
+        this.needSortOnCameraZ = from.needSortOnCameraZ;
+        this.isRenderOrderChange = from.isRenderOrderChange;
+        this.castShadow = from.castShadow;
+        this.castGI = from.castGI;
+        this.rendererMask = from.rendererMask;
+        this.isRecievePostEffectUI = from.isRecievePostEffectUI;
+        return this;
+    }
+    get renderLayer() {
+        return this._renderLayer;
+    }
+    set renderLayer(value) {
+        this._renderLayer = value;
+    }
+    get geometry() {
+        return this._geometry;
+    }
+    set geometry(value) {
+        if (this._geometry != value) {
+            this._readyPipeline = false;
+            if (this._geometry) {
+                Reference.getInstance().detached(this._geometry, this);
+            }
+            if (value) {
+                Reference.getInstance().attached(value, this);
+            }
+        }
+        this._geometry = value;
+    }
+    addMask(mask) {
+        this._rendererMask = RendererMaskUtil.addMask(this.rendererMask, mask);
+    }
+    removeMask(mask) {
+        this._rendererMask = RendererMaskUtil.removeMask(this.rendererMask, mask);
+    }
+    hasMask(mask) {
+        return RendererMaskUtil.hasMask(this.rendererMask, mask);
+    }
+    get rendererMask() {
+        return this._rendererMask;
+    }
+    set rendererMask(value) {
+        this._rendererMask = value;
+    }
+    get renderOrder() {
+        return this._renderOrder;
+    }
+    set renderOrder(value) {
+        if (value != this._renderOrder) {
+            this.isRenderOrderChange = true;
+            this.__renderOrder = value;
+        }
+        this._renderOrder = value;
+    }
+    get materials() {
+        return this._materials;
+    }
+    set materials(value) {
+        this._readyPipeline = false;
+        for (let i = 0; i < this._materials.length; i++) {
+            let mat = this._materials[i];
+            Reference.getInstance().detached(mat, this);
+            if (mat.shader && mat.shader.computes)
+                this.removeComputes(mat.shader.computes);
+        }
+        for (let i = 0; i < value.length; i++) {
+            let mat = value[i];
+            Reference.getInstance().attached(mat, this);
+            if (mat.shader && mat.shader.computes)
+                this.addComputes(mat.shader.computes);
+        }
+        this._materials = value;
+        let transparent = false;
+        let sort = 0;
+        for (let i = 0; i < value.length; i++) {
+            const element = value[i];
+            const passArray = element.getPass(PassType.COLOR);
+            const pass = passArray[0];
+            if (pass.shaderState.transparent) {
+                transparent = true;
+                sort = sort > pass.renderOrder ? sort : pass.renderOrder;
+            }
+        }
+        this.renderOrder = sort;
+        if (!this._readyPipeline) {
+            this.initPipeline();
+        }
+    }
+    addComputes(computes) {
+        this._computes.push(...computes);
+    }
+    removeComputes(computes) {
+        for (const com of computes) {
+            let index = this._computes.indexOf(com);
+            if (index != -1) {
+                this._computes.splice(index, 1);
+            }
+        }
+    }
+    addRendererMask(tag) {
+        this._rendererMask = RendererMaskUtil.addMask(this._rendererMask, tag);
+    }
+    removeRendererMask(tag) {
+        this._rendererMask = RendererMaskUtil.removeMask(this._rendererMask, tag);
+    }
+    onEnable() {
+        if (!this._readyPipeline) {
+            this.initPipeline();
+        }
+        EntityCollect.instance.addRenderNode(this.transform.scene3D, this);
+        this.updateOctreeEntity();
+    }
+    onDisable() {
+        this._enable = false;
+        EntityCollect.instance.removeRenderNode(this.transform.scene3D, this);
+        super.onDisable?.();
+    }
+    selfCloneMaterials(key) {
+        let newMaterials = [];
+        for (let i = 0, c = this.materials.length; i < c; i++) {
+            const material = this.materials[i].clone();
+            newMaterials.push(material);
+        }
+        this.materials = newMaterials;
+        this._readyPipeline = false;
+        this.initPipeline();
+        return this;
+    }
+    initPipeline() {
+        if (this._geometry && this._materials.length > 0) {
+            for (let j = 0; j < this._materials.length; j++) {
+                const material = this._materials[j];
+                let passList = material.getPass(PassType.COLOR);
+                for (let i = 0; i < passList.length; i++) {
+                    const pass = passList[i];
+                    // let shader = RenderShader.getShader(pass.instanceID);
+                    if (!pass.shaderReflection) {
+                        pass.preCompile(this._geometry);
+                    }
+                    this._geometry.generate(pass.shaderReflection);
+                }
+                this.object3D.bound = this._geometry.bounds.clone();
+            }
+            this._readyPipeline = true;
+            let sort = 0;
+            for (let i = 0; i < this.materials.length; i++) {
+                const element = this.materials[i];
+                const passArray = element.getPass(PassType.COLOR);
+                const pass = passArray[0];
+                if (pass.renderOrder >= 3000) {
+                    sort = sort > pass.renderOrder ? sort : pass.renderOrder;
+                }
+                else {
+                    sort = Math.max(sort - 3000, 0);
+                }
+                this.castNeedPass();
+            }
+            this.renderOrder = sort;
+            if (this.enable && this.transform && this.transform.scene3D) {
+                EntityCollect.instance.addRenderNode(this.transform.scene3D, this);
+            }
+        }
+    }
+    castNeedPass() {
+        if (this.castGI) {
+            for (let i = 0; i < this.materials.length; i++) {
+                const mat = this.materials[i];
+                PassGenerate.createGIPass(this, mat.shader);
+            }
+        }
+        for (let i = 0; i < this.materials.length; i++) {
+            const mat = this.materials[i];
+            if (mat.castShadow) {
+                PassGenerate.createShadowPass(this, mat.shader);
+            }
+        }
+        if (this.castReflection) {
+            for (let i = 0; i < this.materials.length; i++) {
+                const mat = this.materials[i];
+                if (mat.castReflection) {
+                    PassGenerate.createReflectionPass(this, mat.shader);
+                }
+            }
+        }
+        // add if alpha == 1
+        let ignoreDepthPass = RendererMaskUtil.hasMask(this.rendererMask, RendererMask.IgnoreDepthPass);
+        if (!ignoreDepthPass && Engine3D.setting.render.zPrePass) {
+            for (let i = 0; i < this.materials.length; i++) {
+                const mat = this.materials[i];
+                PassGenerate.createDepthPass(this, mat.shader);
+            }
+        }
+        else {
+            for (let i = 0; i < this.materials.length; i++) {
+                const mat = this.materials[i];
+                mat.shader.removeShaderByIndex(PassType.DEPTH, 0);
+            }
+        }
+    }
+    get castShadow() {
+        return this._castShadow;
+    }
+    set castShadow(value) {
+        this._castShadow = value;
+    }
+    get castGI() {
+        return this._castGI;
+    }
+    set castGI(value) {
+        this._castGI = value;
+    }
+    get castReflection() {
+        return this._castReflection;
+    }
+    set castReflection(value) {
+        this._castReflection = value;
+    }
+    renderPass(view, passType, renderContext) {
+        if (!this._geometry)
+            return;
+        let renderNode = this;
+        let worldMatrix = renderNode.transform._worldMatrix;
+        const nCount = Math.max(renderNode.materials.length, renderNode._geometry.subGeometries.length);
+        for (let i = 0; i < nCount; i++) {
+            const material = i >= renderNode.materials.length
+                ? renderNode.materials[0]
+                : renderNode.materials[i];
+            if (!material || !material.enable)
+                continue;
+            let passes = material.getPass(passType);
+            if (!passes || passes.length == 0)
+                continue;
+            GPUContext.bindGeometryBuffer(renderContext.encoder, renderNode._geometry);
+            ProfilerUtil.viewCount_vertex(view, PassType[passType], renderNode._geometry.vertexCount);
+            for (let j = 0; j < passes.length; j++) {
+                if (!passes || passes.length == 0)
+                    continue;
+                let matPass = passes[j];
+                const renderShader = matPass;
+                if (renderShader.pipeline) {
+                    if (renderShader.shaderState.splitTexture) {
+                        renderContext.endRenderPass();
+                        RTResourceMap.WriteSplitColorTexture(renderNode.instanceID);
+                        renderContext.beginOpaqueRenderPass();
+                        GPUContext.bindCamera(renderContext.encoder, view.camera);
+                        GPUContext.bindGeometryBuffer(renderContext.encoder, renderNode._geometry);
+                    }
+                    let noneShare = GPUContext.bindPipeline(renderContext.encoder, renderShader);
+                    if (noneShare) {
+                        ProfilerUtil.viewCount_pipeline(view, PassType[passType]);
+                    }
+                    let subGeometry = i >= renderNode._geometry.subGeometries.length
+                        ? renderNode._geometry.subGeometries[0]
+                        : renderNode._geometry.subGeometries[i];
+                    let lodInfos = subGeometry.lodLevels;
+                    let lodInfo = lodInfos[renderNode.lodLevel];
+                    if (renderNode.instanceCount > 0) {
+                        ProfilerUtil.viewCount_instance(view, PassType[passType], renderNode.instanceCount);
+                        ProfilerUtil.viewCount_indices(view, PassType[passType], lodInfo.indexCount);
+                        ProfilerUtil.viewCount_tri(view, PassType[passType], (lodInfo.indexCount / 3) * renderNode.instanceCount);
+                        GPUContext.drawIndexed(renderContext.encoder, lodInfo.indexCount, renderNode.instanceCount, lodInfo.indexStart, 0, 0);
+                    }
+                    else {
+                        ProfilerUtil.viewCount_indices(view, PassType[passType], lodInfo.indexCount);
+                        ProfilerUtil.viewCount_tri(view, PassType[passType], lodInfo.indexCount / 3);
+                        GPUContext.drawIndexed(renderContext.encoder, lodInfo.indexCount, 1, lodInfo.indexStart, 0, worldMatrix.index);
+                    }
+                    ProfilerUtil.viewCount_draw(view, PassType[passType]);
+                }
+            }
+        }
+    }
+    renderPass2(view, passType, rendererPassState, clusterLightingBuffer, encoder, useBundle = false) {
+        if (!this.enable)
+            return;
+        if (!this._geometry)
+            return;
+        let node = this;
+        let worldMatrix = node.object3D.transform._worldMatrix;
+        for (let i = 0; i < this.materials.length; i++) {
+            const material = this.materials[i];
+            if (!material.castShadow && passType == PassType.SHADOW)
+                continue;
+            let passes = material.getPass(passType);
+            if (!passes || passes.length == 0)
+                return;
+            if (this.drawType == 2) {
+                for (let matPass of passes) {
+                    if (matPass.pipeline) {
+                        GPUContext.bindPipeline(encoder, matPass);
+                        GPUContext.draw(encoder, 6, 1, 0, worldMatrix.index);
+                    }
+                }
+            }
+            else {
+                GPUContext.bindGeometryBuffer(encoder, node._geometry);
+                for (let matPass of passes) {
+                    if (matPass.pipeline) {
+                        GPUContext.bindPipeline(encoder, matPass);
+                        let subGeometries = node._geometry.subGeometries;
+                        const subGeometry = subGeometries[i];
+                        let lodInfos = subGeometry.lodLevels;
+                        let lodInfo = lodInfos[node.lodLevel];
+                        GPUContext.drawIndexed(encoder, lodInfo.indexCount, 1, lodInfo.indexStart, 0, worldMatrix.index);
+                    }
+                }
+            }
+        }
+    }
+    recordRenderPass2(view, passType, rendererPassState, clusterLightingBuffer, encoder, useBundle = false) {
+        if (!this.enable)
+            return;
+        let node = this;
+        for (let i = 0; i < this.materials.length; i++) {
+            let material = this.materials[i];
+            let passes = material.getPass(passType);
+            if (!passes || passes.length == 0)
+                return;
+            let worldMatrix = node.object3D.transform._worldMatrix;
+            for (let j = 0; j < passes.length; j++) {
+                const renderShader = passes[j];
+                GPUContext.bindPipeline(encoder, renderShader);
+                let subGeometries = node._geometry.subGeometries;
+                const subGeometry = subGeometries[i];
+                let lodInfos = subGeometry.lodLevels;
+                let lodInfo = lodInfos[node.lodLevel];
+                GPUContext.drawIndexed(encoder, lodInfo.indexCount, 1, lodInfo.indexStart, 0, worldMatrix.index);
+            }
+        }
+    }
+    noticeShaderChange() {
+        if (this.enable) {
+            this.onEnable();
+            this._passInit.forEach((v, k) => {
+                this._passInit.set(k, false);
+            });
+        }
+    }
+    preInit(_rendererType) {
+        return this._passInit.get(_rendererType);
+    }
+    nodeUpdate(view, passType, renderPassState, clusterLightingBuffer) {
+        let node = this;
+        let envMap = view.scene.envMap;
+        for (let j = 0; j < node.materials.length; j++) {
+            let material = node.materials[j];
+            let passes = material.getPass(passType);
+            if (passes) {
+                for (let i = 0; i < passes.length; i++) {
+                    const pass = passes[i];
+                    const renderShader = pass;
+                    if (renderShader.shaderState.splitTexture) {
+                        let splitTexture = RTResourceMap.CreateSplitTexture(node.instanceID);
+                        renderShader.setTexture("splitTexture_Map", splitTexture);
+                    }
+                    if (!node._ignoreEnvMap && renderShader.envMap != envMap) {
+                        renderShader.setTexture(`envMap`, envMap);
+                    }
+                    if (!renderShader.prefilterMap) {
+                        renderShader.setTexture(`prefilterMap`, envMap);
+                    }
+                    let reflectionEntries = GlobalBindGroup.getReflectionEntries(view.scene);
+                    if (!renderShader.reflectionMap &&
+                        reflectionEntries &&
+                        reflectionEntries.reflectionMap) {
+                        renderShader.setTexture(`reflectionMap`, reflectionEntries.reflectionMap);
+                        renderShader.setStorageBuffer(`reflectionBuffer`, reflectionEntries.storageGPUBuffer);
+                    }
+                    if (renderShader.pipeline) {
+                        renderShader.apply(node._geometry, renderPassState, () => node.noticeShaderChange());
+                        continue;
+                    }
+                    let bdrflutTex = Engine3D.res.getTexture(`BRDFLUT`);
+                    renderShader.setTexture(`brdflutMap`, bdrflutTex);
+                    let shadowRenderer = Engine3D.getRenderJob(view).shadowMapPassRenderer;
+                    if (shadowRenderer && shadowRenderer.depth2DArrayTexture) {
+                        renderShader.setTexture(`shadowMap`, Engine3D.getRenderJob(view).shadowMapPassRenderer
+                            .depth2DArrayTexture);
+                    }
+                    let pointShadowRenderer = Engine3D.getRenderJob(view).pointLightShadowRenderer;
+                    if (pointShadowRenderer && pointShadowRenderer.cubeArrayTexture) {
+                        renderShader.setTexture(`pointShadowMap`, pointShadowRenderer.cubeArrayTexture);
+                    }
+                    let iesTexture = IESProfiles.iesTexture;
+                    if (iesTexture) {
+                        renderShader.setTexture(`iesTextureArrayMap`, iesTexture);
+                    }
+                    if (renderPassState.irradianceBuffer &&
+                        renderPassState.irradianceBuffer.length > 0) {
+                        renderShader.setTexture(`irradianceMap`, renderPassState.irradianceBuffer[0]);
+                        renderShader.setTexture(`irradianceDepthMap`, renderPassState.irradianceBuffer[1]);
+                    }
+                    let lightUniformEntries = GlobalBindGroup.getLightEntries(view.scene);
+                    if (lightUniformEntries) {
+                        renderShader.setStorageBuffer(`lightBuffer`, lightUniformEntries.storageGPUBuffer);
+                        if (lightUniformEntries.irradianceVolume) {
+                            renderShader.setUniformBuffer(`irradianceData`, lightUniformEntries.irradianceVolume.irradianceVolumeBuffer);
+                        }
+                    }
+                    if (clusterLightingBuffer) {
+                        renderShader.setStorageBuffer(`clustersUniform`, clusterLightingBuffer.clustersUniformBuffer);
+                        renderShader.setStorageBuffer(`lightAssignBuffer`, clusterLightingBuffer.lightAssignBuffer);
+                        renderShader.setStorageBuffer(`assignTable`, clusterLightingBuffer.assignTableBuffer);
+                        renderShader.setStorageBuffer(`clusterBuffer`, clusterLightingBuffer.clusterBuffer);
+                    }
+                    renderShader.apply(node._geometry, renderPassState);
+                    this._passInit.set(passType, true);
+                }
+            }
+        }
+    }
+    beforeDestroy(force) {
+        Reference.getInstance().detached(this._geometry, this);
+        if (!Reference.getInstance().hasReference(this._geometry)) {
+            this._geometry.destroy(force);
+        }
+        for (let i = 0; i < this._materials.length; i++) {
+            const mat = this._materials[i];
+            Reference.getInstance().detached(mat, this);
+            if (!Reference.getInstance().hasReference(mat)) {
+                mat.destroy(force);
+            }
+        }
+        super.beforeDestroy(force);
+    }
+    destroy(force) {
+        super.destroy(force);
+        this._geometry = undefined;
+        this._materials.length = 0;
+        this._combineShaderRefection = undefined;
+    }
+}
+__decorate([
+    EditorInspector,
+    __metadata("design:type", Array),
+    __metadata("design:paramtypes", [Array])
+], RenderNode.prototype, "materials", null);
+__decorate([
+    EditorInspector,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], RenderNode.prototype, "castShadow", null);
+__decorate([
+    EditorInspector,
+    __metadata("design:type", Boolean),
+    __metadata("design:paramtypes", [Boolean])
+], RenderNode.prototype, "castGI", null);

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

@@ -0,0 +1,26 @@
+import { View3D } from "../../core/View3D";
+import { Object3D } from "../../core/entities/Object3D";
+import { MeshRenderer } from "./MeshRenderer";
+import { StorageGPUBuffer } from "../../gfx/graphics/webGpu/core/buffer/StorageGPUBuffer";
+import { PassType } from "../../gfx/renderJob/passRenderer/state/PassType";
+import { RendererPassState } from "../../gfx/renderJob/passRenderer/state/RendererPassState";
+import { SkeletonAnimationComponent } from "../SkeletonAnimationComponent";
+import { ClusterLightingBuffer } from "../../gfx/renderJob/passRenderer/cluster/ClusterLightingBuffer";
+export declare class SkinnedMeshRenderer extends MeshRenderer {
+    skinJointsName: Array<string>;
+    protected mInverseBindMatrixData: Array<Float32Array>;
+    protected mInverseBindMatrixBuffer: StorageGPUBuffer;
+    protected mSkeletonAnimation: SkeletonAnimationComponent;
+    protected mJointIndexTableBuffer: StorageGPUBuffer;
+    constructor();
+    start(): void;
+    onEnable(): void;
+    get skeletonAnimation(): SkeletonAnimationComponent;
+    set skeletonAnimation(value: SkeletonAnimationComponent);
+    get skinInverseBindMatrices(): Array<Float32Array>;
+    set skinInverseBindMatrices(inverseBindMatrices: Array<Float32Array>);
+    get inverseBindMatrixBuffer(): StorageGPUBuffer;
+    get jointIndexTableBuffer(): GPUBuffer;
+    cloneTo(obj: Object3D): void;
+    nodeUpdate(view: View3D, passType: PassType, renderPassState: RendererPassState, clusterLightingBuffer: ClusterLightingBuffer): void;
+}