@rings-webgpu/core 1.0.2 → 1.0.3

package/dist/src/core/bound/BoundingBox.js

@@ -1,155 +0,0 @@
-import { Vector3 } from "../../math/Vector3";
-export class BoundingBox {
-    static { this.maxVector3 = new Vector3(1, 1, 1).multiplyScalar(Number.MAX_VALUE * 0.1); }
-    static { this.minVector3 = new Vector3(1, 1, 1).multiplyScalar(-Number.MAX_VALUE * 0.1); }
-    constructor(center, size) {
-        center ||= Vector3.ZERO.clone();
-        size ||= Vector3.ZERO.clone();
-        this.setFromCenterAndSize(center, size);
-    }
-    makeEmpty() {
-        this.setFromMinMax(BoundingBox.maxVector3, BoundingBox.minVector3);
-        return this;
-    }
-    setFromMinMax(min, max) {
-        this.init();
-        max.subtract(min, this.size);
-        min.add(max, this.center).multiplyScalar(0.5);
-        this.extents.copyFrom(this.size).multiplyScalar(0.5);
-        this.min.copyFrom(min);
-        this.max.copyFrom(max);
-        return this;
-    }
-    init() {
-        this.min ||= new Vector3();
-        this.max ||= new Vector3();
-        this.size ||= new Vector3();
-        this.center ||= new Vector3();
-        this.extents ||= new Vector3();
-        return this;
-    }
-    setFromCenterAndSize(center, size) {
-        this.size = size;
-        this.center = center;
-        this.init();
-        this.extents.copy(size).multiplyScalar(0.5);
-        this.center.subtract(this.extents, this.min);
-        this.center.add(this.extents, this.max);
-        return this;
-    }
-    inFrustum(obj, frustum) {
-        return frustum.containsBox(obj.bound);
-    }
-    merge(bound) {
-        if (bound.min.x < this.min.x)
-            this.min.x = bound.min.x;
-        if (bound.min.y < this.min.y)
-            this.min.y = bound.min.y;
-        if (bound.min.z < this.min.z)
-            this.min.z = bound.min.z;
-        if (bound.max.x > this.max.x)
-            this.max.x = bound.max.x;
-        if (bound.max.y > this.max.y)
-            this.max.y = bound.max.y;
-        if (bound.max.z > this.max.z)
-            this.max.z = bound.max.z;
-        this.size.x = bound.max.x - bound.min.x;
-        this.size.y = bound.max.y - bound.min.y;
-        this.size.z = bound.max.z - bound.min.z;
-        this.extents.x = this.size.x * 0.5;
-        this.extents.y = this.size.y * 0.5;
-        this.extents.z = this.size.z * 0.5;
-        this.center.x = this.extents.x + bound.min.x;
-        this.center.y = this.extents.y + bound.min.y;
-        this.center.z = this.extents.z + bound.min.z;
-    }
-    intersects(bounds) {
-        return (this.min.x <= bounds.max.x &&
-            this.max.x >= bounds.min.x &&
-            this.min.y <= bounds.max.y &&
-            this.max.y >= bounds.min.y &&
-            this.min.z <= bounds.max.z &&
-            this.max.z >= bounds.min.z);
-    }
-    intersectsSphere(sphere) {
-        return (this.min.x <= sphere.max.x &&
-            this.max.x >= sphere.min.x &&
-            this.min.y <= sphere.max.y &&
-            this.max.y >= sphere.min.y &&
-            this.min.z <= sphere.max.z &&
-            this.max.z >= sphere.min.z);
-    }
-    intersectsBox(box) {
-        return (this.min.x <= box.max.x &&
-            this.max.x >= box.min.x &&
-            this.min.y <= box.max.y &&
-            this.max.y >= box.min.y &&
-            this.min.z <= box.max.z &&
-            this.max.z >= box.min.z);
-    }
-    equals(bounds) {
-        return (this.center.equals(bounds.center) && this.extents.equals(bounds.extents));
-    }
-    expandByPoint(point) {
-        if (point.x < this.min.x) {
-            this.min.x = point.x;
-        }
-        if (point.x > this.max.x) {
-            this.max.x = point.x;
-        }
-        if (point.y < this.min.y) {
-            this.min.y = point.y;
-        }
-        if (point.y > this.max.y) {
-            this.max.y = point.y;
-        }
-        if (point.z < this.min.z) {
-            this.min.z = point.z;
-        }
-        if (point.z > this.max.z) {
-            this.max.z = point.z;
-        }
-    }
-    static fromPoints(points) {
-        var bounds = new BoundingBox(new Vector3(), new Vector3());
-        for (var i = 0; i < points.length; i++) {
-            bounds.expandByPoint(points[i]);
-        }
-        return bounds;
-    }
-    calculateTransform(obj) { }
-    clone() {
-        var bound = new BoundingBox(this.center.clone(), this.size.clone());
-        return bound;
-    }
-    intersectsRay(ray, point) {
-        throw new Error("Method not implemented.");
-    }
-    containsPoint(point) {
-        return (this.min.x <= point.x &&
-            this.max.x >= point.x &&
-            this.min.y <= point.y &&
-            this.max.y >= point.y &&
-            this.min.z <= point.z &&
-            this.max.z >= point.z);
-    }
-    containsBox(box) {
-        let min = this.min;
-        let max = this.max;
-        let isContain = min.x <= box.min.x &&
-            min.y <= box.min.y &&
-            min.z <= box.min.z &&
-            max.x >= box.max.x &&
-            max.y >= box.max.y &&
-            max.z >= box.max.z;
-        return isContain;
-    }
-    updateBound() { }
-    destroy(force) {
-        this.center = null;
-        this.extents = null;
-        this.min = null;
-        this.max = null;
-        this.size = null;
-    }
-}

package/dist/src/core/bound/BoundingSphere.d.ts

@@ -1,34 +0,0 @@
-import { Frustum } from "./Frustum";
-import { IBound } from "./IBound";
-import { Object3D } from "../entities/Object3D";
-import { Ray } from "../../math/Ray";
-import { Vector3 } from "../../math/Vector3";
-export declare class BoundingSphere implements IBound {
-    center: Vector3;
-    extents: Vector3;
-    max: Vector3;
-    min: Vector3;
-    size: Vector3;
-    tmpVecA: Vector3;
-    tmpVecB: Vector3;
-    tmpVecC: Vector3;
-    tmpVecD: Vector3;
-    radius: number;
-    diffBetweenPoints: Vector3;
-    owner: any;
-    forward: Vector3;
-    worldCenter: Vector3;
-    worldSize: Vector3;
-    private _center;
-    constructor(center?: Vector3, radius?: number);
-    updateBound(): void;
-    containsPoint(point: Vector3): boolean;
-    intersectsRay(ray: Ray, point: Vector3): boolean;
-    intersectsBoundingSphere(sphere: BoundingSphere): boolean;
-    calculateTransform(obj: Object3D): void;
-    inFrustum(obj: Object3D, frustum: Frustum): 1 | 0 | 2;
-    clone(): IBound;
-    update(obj: Object3D): void;
-    merge(bound: IBound): void;
-    setFromCenterAndSize(center: Vector3, size: number): void;
-}

package/dist/src/core/bound/BoundingSphere.js

@@ -1,71 +0,0 @@
-import { Vector3 } from "../../math/Vector3";
-export class BoundingSphere {
-    constructor(center, radius) {
-        this.center = new Vector3();
-        this.tmpVecA = new Vector3();
-        this.tmpVecB = new Vector3();
-        this.tmpVecC = new Vector3();
-        this.tmpVecD = new Vector3();
-        this.radius = 0;
-        this.diffBetweenPoints = new Vector3();
-        this.forward = new Vector3(0, 0, 1);
-        this._center = new Vector3();
-        this.center = center || new Vector3(0, 0, 0);
-        this.radius = radius === undefined ? 0.5 : radius;
-    }
-    updateBound() {
-        throw new Error("Method not implemented.");
-    }
-    containsPoint(point) {
-        var lenSq = this.tmpVecA.subtract(point, this.center).lengthSquared;
-        var r = this.radius;
-        return lenSq < r * r;
-    }
-    intersectsRay(ray, point) {
-        var m = this.tmpVecA.copyFrom(ray.origin).subtract(this.center);
-        var b = m.dotProduct(this.tmpVecB.copyFrom(ray.direction).normalize());
-        var c = m.dotProduct(m) - this.radius * this.radius;
-        // exit if ray's origin outside of sphere (c > 0) and ray pointing away from s (b > 0)
-        if (c > 0 && b > 0)
-            return null;
-        var discr = b * b - c;
-        // a negative discriminant corresponds to ray missing sphere
-        if (discr < 0)
-            return false;
-        // ray intersects sphere, compute smallest t value of intersection
-        var t = Math.abs(-b - Math.sqrt(discr));
-        // if t is negative, ray started inside sphere so clamp t to zero
-        if (point)
-            point.copyFrom(ray.direction).scaleBy(t).add(ray.origin);
-        return true;
-    }
-    intersectsBoundingSphere(sphere) {
-        this.tmpVecA.subtract(sphere.center, this.center);
-        var totalRadius = sphere.radius + this.radius;
-        if (this.tmpVecA.lengthSquared <= totalRadius * totalRadius) {
-            return true;
-        }
-        return false;
-    }
-    calculateTransform(obj) {
-        this.update(obj);
-    }
-    inFrustum(obj, frustum) {
-        return frustum.containsSphere(obj);
-    }
-    clone() {
-        return new BoundingSphere(this.center.clone(), this.radius);
-    }
-    update(obj) {
-        this.owner = obj;
-        this._center.add(obj.transform.worldMatrix.position, this.center);
-        this.forward = obj.transform.forward;
-    }
-    merge(bound) {
-        throw new Error("BoundingSphere merge is not ready!");
-    }
-    setFromCenterAndSize(center, size) {
-        this.center.copy(center);
-        this.radius = size;
-    }
-}

package/dist/src/core/bound/Frustum.d.ts

@@ -1,17 +0,0 @@
-import { Matrix4 } from "../../math/Matrix4";
-import { Object3D } from "../entities/Object3D";
-import { Vector3 } from "../../math/Vector3";
-import { BoundingBox } from "./BoundingBox";
-export declare class Frustum {
-    planes: Vector3[];
-    corners: Vector3[];
-    boundingBox: BoundingBox;
-    constructor();
-    updateBoundBox(pvInv: Matrix4): this;
-    setFrustumCorners(pvInv: Matrix4): void;
-    update(vpMatrix: Matrix4): void;
-    containsPoint(point: Vector3): boolean;
-    containsSphere(object3D: Object3D): 1 | 0 | 2;
-    containsBox(box: any): number;
-    containsBox2(box: any): number;
-}

package/dist/src/core/bound/Frustum.js

@@ -1,184 +0,0 @@
-import { Vector3 } from "../../math/Vector3";
-import { BoundingBox } from "./BoundingBox";
-export class Frustum {
-    constructor() {
-        this.boundingBox = new BoundingBox();
-        this.planes = [];
-        this.corners = [];
-        for (var i = 0; i < 6; i++)
-            this.planes[i] = new Vector3();
-        for (var i = 0; i < 2 * 2 * 2; i++)
-            this.corners[i] = new Vector3();
-    }
-    updateBoundBox(pvInv) {
-        this.boundingBox.makeEmpty();
-        let min = this.boundingBox.min;
-        let max = this.boundingBox.max;
-        let i = 0;
-        for (let x = 0; x < 2; ++x) {
-            for (let y = 0; y < 2; ++y) {
-                for (let z = 0; z < 2; ++z) {
-                    let pt = this.corners[i];
-                    i++;
-                    pt.set(2.0 * x - 1.0, 2.0 * y - 1.0, z, 1.0);
-                    pvInv.transformVector4(pt, pt);
-                    pt.div(pt.w, pt);
-                    min.x = Math.min(pt.x, min.x);
-                    min.y = Math.min(pt.y, min.y);
-                    min.z = Math.min(pt.z, min.z);
-                    max.x = Math.max(pt.x, max.x);
-                    max.y = Math.max(pt.y, max.y);
-                    max.z = Math.max(pt.z, max.z);
-                }
-            }
-        }
-        this.boundingBox.setFromMinMax(min, max);
-        return this;
-    }
-    setFrustumCorners(pvInv) {
-        let i = 0;
-        for (let x = 0; x < 2; ++x) {
-            for (let y = 0; y < 2; ++y) {
-                for (let z = 0; z < 2; ++z) {
-                    let pt = this.corners[i];
-                    pt.set(2.0 * x - 1.0, 2.0 * y - 1.0, z, 1.0);
-                    pvInv.transformVector4(pt, pt);
-                    pt.div(pt.w, pt);
-                    i++;
-                }
-            }
-        }
-    }
-    update(vpMatrix) {
-        var vpm = vpMatrix.rawData;
-        this.planes[0].x = vpm[3] - vpm[0];
-        this.planes[0].y = vpm[7] - vpm[4];
-        this.planes[0].z = vpm[11] - vpm[8];
-        this.planes[0].w = vpm[15] - vpm[12];
-        var t = Math.sqrt(this.planes[0].x * this.planes[0].x +
-            this.planes[0].y * this.planes[0].y +
-            this.planes[0].z * this.planes[0].z);
-        this.planes[0].x /= t;
-        this.planes[0].y /= t;
-        this.planes[0].z /= t;
-        this.planes[0].w /= t;
-        this.planes[1].x = vpm[3] + vpm[0];
-        this.planes[1].y = vpm[7] + vpm[4];
-        this.planes[1].z = vpm[11] + vpm[8];
-        this.planes[1].w = vpm[15] + vpm[12];
-        t = Math.sqrt(this.planes[1].x * this.planes[1].x +
-            this.planes[1].y * this.planes[1].y +
-            this.planes[1].z * this.planes[1].z);
-        this.planes[1].x /= t;
-        this.planes[1].y /= t;
-        this.planes[1].z /= t;
-        this.planes[1].w /= t;
-        this.planes[2].x = vpm[3] + vpm[1];
-        this.planes[2].y = vpm[7] + vpm[5];
-        this.planes[2].z = vpm[11] + vpm[9];
-        this.planes[2].w = vpm[15] + vpm[13];
-        t = Math.sqrt(this.planes[2].x * this.planes[2].x +
-            this.planes[2].y * this.planes[2].y +
-            this.planes[2].z * this.planes[2].z);
-        this.planes[2].x /= t;
-        this.planes[2].y /= t;
-        this.planes[2].z /= t;
-        this.planes[2].w /= t;
-        this.planes[3].x = vpm[3] - vpm[1];
-        this.planes[3].y = vpm[7] - vpm[5];
-        this.planes[3].z = vpm[11] - vpm[9];
-        this.planes[3].w = vpm[15] - vpm[13];
-        t = Math.sqrt(this.planes[3].x * this.planes[3].x +
-            this.planes[3].y * this.planes[3].y +
-            this.planes[3].z * this.planes[3].z);
-        this.planes[3].x /= t;
-        this.planes[3].y /= t;
-        this.planes[3].z /= t;
-        this.planes[3].w /= t;
-        this.planes[4].x = vpm[3] - vpm[2];
-        this.planes[4].y = vpm[7] - vpm[6];
-        this.planes[4].z = vpm[11] - vpm[10];
-        this.planes[4].w = vpm[15] - vpm[14];
-        t = Math.sqrt(this.planes[4].x * this.planes[4].x +
-            this.planes[4].y * this.planes[4].y +
-            this.planes[4].z * this.planes[4].z);
-        this.planes[4].x /= t;
-        this.planes[4].y /= t;
-        this.planes[4].z /= t;
-        this.planes[4].w /= t;
-        this.planes[5].x = vpm[3] + vpm[2];
-        this.planes[5].y = vpm[7] + vpm[6];
-        this.planes[5].z = vpm[11] + vpm[10];
-        this.planes[5].w = vpm[15] + vpm[14];
-        t = Math.sqrt(this.planes[5].x * this.planes[5].x +
-            this.planes[5].y * this.planes[5].y +
-            this.planes[5].z * this.planes[5].z);
-        this.planes[5].x /= t;
-        this.planes[5].y /= t;
-        this.planes[5].z /= t;
-        this.planes[5].w /= t;
-    }
-    containsPoint(point) {
-        for (var p = 0; p < 6; p++) {
-            if (this.planes[p].x * point.x +
-                this.planes[p].y * point.y +
-                this.planes[p].z * point.z +
-                this.planes[p].w <=
-                0)
-                return false;
-        }
-        return true;
-    }
-    containsSphere(object3D) {
-        let sphere = object3D.bound;
-        let c = 0;
-        let d;
-        let worldPos = object3D.transform.worldPosition;
-        let sr = sphere.radius;
-        let scx = sphere.center.x + worldPos.x;
-        let scy = sphere.center.y + worldPos.y;
-        let scz = sphere.center.z + worldPos.z;
-        for (let plane of this.planes) {
-            d = plane.x * scx + plane.y * scy + plane.z * scz + plane.w;
-            if (d <= -sr)
-                return 0;
-            if (d > sr)
-                c++;
-        }
-        return c === 6 ? 2 : 1;
-    }
-    containsBox(box) {
-        let c = 0;
-        let d;
-        let r = Math.max(box.size.x, box.size.y, box.size.z);
-        let sr = r * 2;
-        let scx = box.center.x;
-        let scy = box.center.y;
-        let scz = box.center.z;
-        for (let plane of this.planes) {
-            d = plane.x * scx + plane.y * scy + plane.z * scz + plane.w;
-            if (d <= -sr)
-                return 0;
-            if (d > sr)
-                c++;
-        }
-        return c === 6 ? 2 : 1;
-    }
-    containsBox2(box) {
-        let c = 0;
-        let d;
-        let r = 1.74 * Math.max(box.extents.x, box.extents.y, box.extents.z);
-        for (let plane of this.planes) {
-            d =
-                plane.x * box.center.x +
-                    plane.y * box.center.y +
-                    plane.z * box.center.z +
-                    plane.w;
-            if (d <= -r)
-                return 0;
-            if (d > r)
-                c++;
-        }
-        return c === 6 ? 2 : 1;
-    }
-}

package/dist/src/core/bound/IBound.d.ts

@@ -1,19 +0,0 @@
-import { Frustum } from "./Frustum";
-import { Object3D } from "../entities/Object3D";
-import { Ray } from "../../math/Ray";
-import { Vector3 } from "../../math/Vector3";
-export interface IBound {
-    center: Vector3;
-    extents: Vector3;
-    max: Vector3;
-    min: Vector3;
-    size: Vector3;
-    calculateTransform(obj: Object3D): void;
-    clone(): IBound;
-    merge(bound: IBound): any;
-    intersectsRay(ray: Ray, point: Vector3): boolean;
-    containsPoint(point: Vector3): boolean;
-    setFromCenterAndSize(center: Vector3, size: Vector3 | number): any;
-    inFrustum(object3D: Object3D, frustum: Frustum): any;
-    updateBound(): any;
-}

package/dist/src/core/bound/IBound.js

@@ -1 +0,0 @@
-export {};

package/dist/src/core/csm/CSM.d.ts

@@ -1,3 +0,0 @@
-export declare class CSM {
-    static readonly Cascades = 4;
-}

package/dist/src/core/csm/CSM.js

@@ -1,3 +0,0 @@
-export class CSM {
-    static { this.Cascades = 4; }
-}

package/dist/src/core/csm/FrustumCSM.d.ts

@@ -1,32 +0,0 @@
-import { Color } from "../../math/Color";
-import { Matrix4 } from "../../math/Matrix4";
-import { Vector3 } from "../../math/Vector3";
-import { ShadowSetting } from "../../setting/ShadowSetting";
-import { Camera3D } from "../Camera3D";
-import { BoundingBox } from "../bound/BoundingBox";
-declare class FrustumSection {
-    corners: Vector3[];
-    index: number;
-    constructor(index: number);
-}
-declare class FrustumChild {
-    bound: BoundingBox;
-    twoSections: FrustumSection[];
-    name: string;
-    color: Color;
-    shadowCamera: Camera3D;
-    readonly index: number;
-    constructor(near: FrustumSection, far: FrustumSection, index: number);
-    updateBound(): this;
-}
-export declare class FrustumCSM {
-    sections: FrustumSection[];
-    children: FrustumChild[];
-    name: string;
-    constructor(blockCount: number);
-    update(p: Matrix4, pvInv: Matrix4, near: number, far: number, shadowSetting: ShadowSetting): this;
-    private squareSplit;
-    private uniformSplit;
-    private logSplit;
-}
-export {};

package/dist/src/core/csm/FrustumCSM.js

@@ -1,106 +0,0 @@
-import { Color } from "../../math/Color";
-import { Vector3 } from "../../math/Vector3";
-import { CameraUtil } from "../../util/CameraUtil";
-import { BoundingBox } from "../bound/BoundingBox";
-class FrustumSection {
-    constructor(index) {
-        this.index = index;
-        this.corners = [];
-        for (let i = 0; i < 4; i++) {
-            this.corners.push(new Vector3());
-        }
-    }
-}
-class FrustumChild {
-    constructor(near, far, index) {
-        this.bound = new BoundingBox();
-        this.shadowCamera = CameraUtil.createCamera3DObject(null, "csmShadowCamera_" + index);
-        this.shadowCamera.isShadowCamera = true;
-        this.shadowCamera.orthoOffCenter(100, -100, 100, -100, 1, 10000);
-        this.twoSections = [near, far];
-        this.index = index;
-        if (index == 0) {
-            this.color = new Color(1, 0, 0, 1);
-        }
-        else if (index == 1) {
-            this.color = new Color(0, 1, 0, 1);
-        }
-        else if (index == 2) {
-            this.color = new Color(0, 0, 1, 1);
-        }
-        else if (index == 3) {
-            this.color = new Color(0, 1, 1, 1);
-        }
-        this.name = "child_" + index;
-    }
-    updateBound() {
-        this.bound.makeEmpty();
-        let min = this.bound.min;
-        let max = this.bound.max;
-        for (let section of this.twoSections) {
-            for (let pt of section.corners) {
-                min.x = Math.min(pt.x, min.x);
-                min.y = Math.min(pt.y, min.y);
-                min.z = Math.min(pt.z, min.z);
-                max.x = Math.max(pt.x, max.x);
-                max.y = Math.max(pt.y, max.y);
-                max.z = Math.max(pt.z, max.z);
-            }
-        }
-        this.bound.setFromMinMax(min, max);
-        return this;
-    }
-}
-export class FrustumCSM {
-    constructor(blockCount) {
-        this.sections = [];
-        let sectionCount = blockCount + 1;
-        for (let i = 0; i < sectionCount; i++) {
-            this.sections.push(new FrustumSection(i));
-        }
-        this.children = [];
-        for (let i = 0; i < blockCount; i++) {
-            this.children.push(new FrustumChild(this.sections[i], this.sections[i + 1], i));
-        }
-    }
-    update(p, pvInv, near, far, shadowSetting) {
-        let blockCount = this.sections.length - 1;
-        for (let z = 0; z <= blockCount; ++z) {
-            let section = this.sections[z];
-            let cornerIndex = 0;
-            let worldZ = this.logSplit(near, far, z, this.sections.length);
-            {
-                let scale = (worldZ - near) / far;
-                scale = scale ** shadowSetting.csmScatteringExp;
-                worldZ = (far - near) * scale + near;
-            }
-            worldZ *= shadowSetting.csmAreaScale;
-            let depth = (p.rawData[10] * worldZ + p.rawData[14]) / worldZ;
-            for (let x = 0; x < 2; ++x) {
-                for (let y = 0; y < 2; ++y) {
-                    let pt = section.corners[cornerIndex];
-                    cornerIndex++;
-                    pt.set(2.0 * x - 1.0, 2.0 * y - 1.0, depth, 1.0);
-                    pvInv.transformVector4(pt, pt);
-                    pt.div(pt.w, pt);
-                }
-            }
-        }
-        for (let miniFrustum of this.children) {
-            miniFrustum.updateBound();
-        }
-        return this;
-    }
-    squareSplit(near, far, index, max) {
-        let ratio = index / (max - 1);
-        return ratio ** 4 * (far - near) + near;
-    }
-    uniformSplit(near, far, index, max) {
-        let ratio = index / (max - 1);
-        return ratio * (far - near) + near;
-    }
-    logSplit(near, far, index, max) {
-        let ratio = near * (far / near) ** (index / (max - 1));
-        return ratio;
-    }
-}

package/dist/src/core/entities/Entity.d.ts

@@ -1,43 +0,0 @@
-import { IComponent } from "../../components/IComponent";
-import { RenderNode } from "../../components/renderer/RenderNode";
-import { Transform } from "../../components/Transform";
-import { CEventDispatcher } from "../../event/CEventDispatcher";
-import { IBound } from "../bound/IBound";
-import { Object3D } from "./Object3D";
-export declare class Entity extends CEventDispatcher {
-    name: string;
-    protected readonly _instanceID: string;
-    private _numChildren;
-    get instanceID(): string;
-    transform: Transform;
-    renderNode: RenderNode;
-    entityChildren: Entity[];
-    components: Map<any, IComponent>;
-    protected waitDisposeComponents: IComponent[];
-    protected _bound: IBound;
-    protected _boundWorld: IBound;
-    protected _isBoundChange: boolean;
-    private _dispose;
-    get dispose(): boolean;
-    getObjectByName(name: string): Entity;
-    constructor();
-    get numChildren(): number;
-    addChild(child: Entity): Entity;
-    removeChild(child: Entity): void;
-    removeAllChild(): void;
-    removeSelf(): this;
-    removeChildByIndex(index: number): void;
-    hasChild(child: Entity): boolean;
-    removeFromParent(): this;
-    getChildByIndex(index: number): Entity;
-    getChildByName(name: string, loopChild?: boolean): any;
-    update(): void;
-    instantiate(): Object3D | null;
-    protected onTransformLocalChange(e: any): void;
-    get bound(): IBound;
-    set bound(value: IBound);
-    private updateBound;
-    waitUpdate(): void;
-    noticeComponents(key: keyof IComponent, data: any): void;
-    destroy(force?: boolean): void;
-}