@rings-webgpu/core 1.0.0 → 1.0.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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