@rings-webgpu/core 1.0.2 → 1.0.3

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

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

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

@@ -1,26 +0,0 @@
-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;
-}