@turbox3d/design-engine
Version:
Large-scale design application engine library
888 lines • 31.9 kB
JavaScript
import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
import _createClass from "@babel/runtime/helpers/esm/createClass";
import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
import _inherits from "@babel/runtime/helpers/esm/inherits";
import _typeof from "@babel/runtime/helpers/esm/typeof";
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
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 === "undefined" ? "undefined" : _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;
};
/* eslint-disable no-else-return */
import { computed, Domain, mutation, reactive, reactor } from '@turbox3d/reactivity';
import { generateUUID } from '@turbox3d/shared';
import { Box2, Box3, Euler, MathUtils, Matrix3, Matrix4, Quaternion, Vector2, Vector3 } from '@turbox3d/math';
/** 视角类型 */
export var EPerspectiveType;
(function (EPerspectiveType) {
/** 正视 */
EPerspectiveType["FRONT"] = "front";
/** 顶视 */
EPerspectiveType["TOP"] = "top";
/** 左视 */
EPerspectiveType["LEFT"] = "left";
})(EPerspectiveType || (EPerspectiveType = {}));
/**
* | y
* |
* |
* | x
* /— — — — — —
* /
* /
* /z
* 右手坐标系
*/
var EntityObject = /*#__PURE__*/function (_Domain) {
function EntityObject() {
var _this;
var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : generateUUID();
_classCallCheck(this, EntityObject);
_this = _callSuper(this, EntityObject);
/** 模型名称 */
_this.name = '';
/** 模型位置 */
_this.position = new Vector3(0, 0, 0);
/** 模型旋转角度（注意不是弧度） */
_this.rotation = new Vector3(0, 0, 0);
/** 模型缩放 */
_this.scale = new Vector3(1, 1, 1);
/** 模型尺寸 */
_this.size = new Vector3(0, 0, 0);
/** 模型子节点 */
_this.children = new Set();
/** 是否隐藏 */
_this.hidden = false;
/** 是否锁定 */
_this.locked = false;
/** 是否可被点击 */
_this.isClickable = true;
/** 是否可被 hover */
_this.isHoverable = true;
/** 是否可被拖拽 */
_this.isDraggable = true;
/** 是否可被捏合（移动端） */
_this.isPinchable = true;
/** 是否可被旋转（移动端） */
_this.isRotatable = true;
/** 是否可被按压（移动端） */
_this.isPressable = true;
/** 渲染顺序 */
_this.renderOrder = 0;
/** 对应的模型网格 */
_this.meshes = [];
/** 响应式的任务管线 */
_this.reactivePipeLine = [];
_this.reactions = [];
_this.id = id;
EntityObject.entityMap.set(_this.id, _this);
return _this;
}
_inherits(EntityObject, _Domain);
return _createClass(EntityObject, [{
key: "initDomainContext",
value: function initDomainContext() {
return {
isNeedRecord: true
};
}
/** 启动响应式任务管线 */
}, {
key: "runReactivePipeLine",
value: function runReactivePipeLine() {
var _this2 = this;
this.reactions = this.reactivePipeLine.map(function (pipe) {
return reactive(function () {
return pipe.func.call(_this2);
}, pipe.options);
});
}
/** 销毁所有响应式任务管线 */
}, {
key: "disposeReactivePipeLine",
value: function disposeReactivePipeLine() {
this.reactions.forEach(function (reaction) {
return reaction.dispose();
});
}
/** back
* 0---------3
* | |
* |left |right
* | |
* 1---------2
* front
* 顶视的紧贴包围盒点集合，忽略 x、z 轴旋转
*/
}, {
key: "box2Top",
get: function get() {
return this.getBox2From3d(EPerspectiveType.TOP);
}
/** 基于世界坐标系的顶视的紧贴包围盒点集合，忽略 x、z 轴旋转 */
}, {
key: "box2TopWCS",
get: function get() {
return this.getBox2From3d(EPerspectiveType.TOP, true);
}
/**
* 基于世界坐标系的顶视的 AABB 包围盒点集合，忽略 x、z 轴旋转
*/
}, {
key: "box2TopAABBWCS",
get: function get() {
return this.getBox2AABBFrom3d(EPerspectiveType.TOP, true);
}
/** top
* 3---------2
* | |
* |left |right
* | |
* 0---------1
* bottom
* 正视/立面的紧贴包围盒点集合，忽略 x、y 轴旋转
*/
}, {
key: "box2Front",
get: function get() {
return this.getBox2From3d(EPerspectiveType.FRONT);
}
/** 基于世界坐标系的正视/立面的紧贴包围盒点集合，忽略 x、y 轴旋转 */
}, {
key: "box2FrontWCS",
get: function get() {
return this.getBox2From3d(EPerspectiveType.FRONT, true);
}
/**
* 基于世界坐标系的正视/立面的 AABB 包围盒点集合，忽略 x、y 轴旋转
*/
}, {
key: "box2FrontAABBWCS",
get: function get() {
return this.getBox2AABBFrom3d(EPerspectiveType.FRONT, true);
}
/** top
* 3---------2
* | |
* |left |right
* | |
* 0---------1
* bottom
* 左视的紧贴包围盒点集合，忽略 y、z 轴旋转
*/
}, {
key: "box2Left",
get: function get() {
return this.getBox2From3d(EPerspectiveType.LEFT);
}
/** 基于世界坐标系的左视的紧贴包围盒点集合，忽略 y、z 轴旋转 */
}, {
key: "box2LeftWCS",
get: function get() {
return this.getBox2From3d(EPerspectiveType.LEFT, true);
}
/**
* 基于世界坐标系的左视的 AABB 包围盒点集合，忽略 y、z 轴旋转
*/
}, {
key: "box2LeftAABBWCS",
get: function get() {
return this.getBox2AABBFrom3d(EPerspectiveType.LEFT, true);
}
/**
* 7-----------6
* / . / |
* / . / |
* 4-----------5 |
* | . | |
* | . | |
* | 0.......|...3
* | . | /
* | . | /
* 1-----------2
* 三维的紧贴包围盒点集合
*/
}, {
key: "box3",
get: function get() {
return this.getBox3();
}
/** 基于世界坐标系的三维的紧贴包围盒点集合 */
}, {
key: "box3WCS",
get: function get() {
return this.getBox3(undefined, true);
}
/**
* 三维的 AABB 包围盒点集合
*/
}, {
key: "box3AABB",
get: function get() {
return this.getBox3AABB();
}
/**
* 基于世界坐标系的三维的 AABB 包围盒点集合
*/
}, {
key: "box3AABBWCS",
get: function get() {
return this.getBox3AABB(undefined, true);
}
/** 缩放过的尺寸 */
}, {
key: "scaledSize",
get: function get() {
return this.getScaledSize();
}
/** 3x3 entity 顶视矩阵 */
}, {
key: "matrix3Top",
get: function get() {
return this.getMatrix3From3d(EPerspectiveType.TOP);
}
/** 3x3 entity 正视/立面矩阵 */
}, {
key: "matrix3Front",
get: function get() {
return this.getMatrix3From3d(EPerspectiveType.FRONT);
}
/** 3x3 entity 左视矩阵 */
}, {
key: "matrix3Left",
get: function get() {
return this.getMatrix3From3d(EPerspectiveType.LEFT);
}
/** 4x4 entity 矩阵 */
}, {
key: "matrix4",
get: function get() {
return this.getMatrix4();
}
}, {
key: "setClickable",
value: function setClickable(clickable) {
this.isClickable = clickable;
return this;
}
}, {
key: "setHoverable",
value: function setHoverable(hoverable) {
this.isHoverable = hoverable;
return this;
}
}, {
key: "setDraggable",
value: function setDraggable(draggable) {
this.isDraggable = draggable;
return this;
}
}, {
key: "setPinchable",
value: function setPinchable(pinchable) {
this.isPinchable = pinchable;
return this;
}
}, {
key: "setRotatable",
value: function setRotatable(rotatable) {
this.isRotatable = rotatable;
return this;
}
}, {
key: "setPressable",
value: function setPressable(pressable) {
this.isPressable = pressable;
return this;
}
/** 设置是否可交互 */
}, {
key: "setInteractive",
value: function setInteractive(interactive) {
this.setClickable(interactive);
this.setHoverable(interactive);
this.setDraggable(interactive);
this.setPinchable(interactive);
this.setRotatable(interactive);
this.setPressable(interactive);
return this;
}
}, {
key: "setRenderOrder",
value: function setRenderOrder(renderOrder) {
this.renderOrder = renderOrder;
return this;
}
/** 锁定 */
}, {
key: "lock",
value: function lock() {
this.locked = true;
return this;
}
/** 解锁 */
}, {
key: "unlock",
value: function unlock() {
this.locked = false;
return this;
}
/** 隐藏模型 */
}, {
key: "hide",
value: function hide() {
this.hidden = true;
return this;
}
/** 显示模型 */
}, {
key: "show",
value: function show() {
this.hidden = false;
return this;
}
/** 设置名称 */
}, {
key: "setName",
value: function setName(name) {
this.name = name;
return this;
}
/** 设置一个 4x4 矩阵 */
}, {
key: "setMatrix4",
value: function setMatrix4(value) {
var position = new Vector3();
var quaternion = new Quaternion();
var scale = new Vector3();
value.decompose(position, quaternion, scale);
var rotation = new Euler().setFromQuaternion(quaternion).toVector3();
this.setPosition(position);
this.setRotation({
x: rotation.x * MathUtils.RAD2DEG,
y: rotation.y * MathUtils.RAD2DEG,
z: rotation.z * MathUtils.RAD2DEG
});
this.setScale(scale);
return this;
}
/** 相对于世界坐标系的矩阵 */
}, {
key: "concatenatedMatrix",
get: function get() {
return this.getConcatenatedMatrix();
}
/** 是否是顶层模型 */
}, {
key: "isRoot",
value: function isRoot() {
return !this.parent;
}
/**
* 获取该模型的顶层模型
* @param stopCondition 停止查找的条件函数，返回 true 就停下查找
*/
}, {
key: "getRoot",
value: function getRoot(stopCondition) {
// eslint-disable-next-line @typescript-eslint/no-this-alias
var root = this;
while (root.parent && (!stopCondition || !stopCondition(root))) {
root = root.parent;
}
return root;
}
/**
* 遍历
* @param callback 遍历的处理逻辑函数，返回值是布尔值，如果是 true，则会停止当前遍历到的节点继续往下遍历
*/
}, {
key: "traverse",
value: function traverse(callback) {
var isStop = callback(this);
if (isStop) {
return this;
}
this.children.forEach(function (child) {
child.traverse(callback);
});
return this;
}
/** 添加子模型 */
}, {
key: "addChild",
value: function addChild(child) {
this.children.add(child);
child.parent = this;
return this;
}
/** 批量添加子模型 */
}, {
key: "addChildren",
value: function addChildren(children) {
var _this3 = this;
children.forEach(function (child) {
return _this3.addChild(child);
});
return this;
}
/** 删除子模型 */
}, {
key: "removeChild",
value: function removeChild(child) {
child.parent = undefined;
this.children["delete"](child);
return this;
}
/** 批量移除指定的子模型，不传参则移除所有子模型 */
}, {
key: "removeChildren",
value: function removeChildren(children) {
var _this4 = this;
if (!children) {
this.children.forEach(function (child) {
child.parent = undefined;
});
this.children.clear();
return this;
}
children.forEach(function (child) {
return _this4.removeChild(child);
});
return this;
}
/** 获取该模型与其祖先节点的路径链（从祖先节点到当前模型的顺序） */
}, {
key: "getParentPathChain",
value: function getParentPathChain() {
var path = [this];
// eslint-disable-next-line @typescript-eslint/no-this-alias
var t = this;
while (t.parent) {
t = t.parent;
path.unshift(t);
}
return path;
}
/** 获取模型节点深度 */
}, {
key: "getDepth",
value: function getDepth() {
// eslint-disable-next-line @typescript-eslint/no-this-alias
var t = this;
var result = 1;
while (t.parent) {
t = t.parent;
result += 1;
}
return result;
}
}, {
key: "getScaledSize",
value: function getScaledSize() {
var _this$size = this.size,
x = _this$size.x,
y = _this$size.y,
z = _this$size.z;
var _this$scale = this.scale,
x1 = _this$scale.x,
y1 = _this$scale.y,
z1 = _this$scale.z;
return new Vector3(x * x1, y * y1, z * z1);
}
}, {
key: "setPosition",
value: function setPosition(position) {
var x = position.x,
y = position.y,
z = position.z;
x !== undefined && (this.position.x = x);
y !== undefined && (this.position.y = y);
z !== undefined && (this.position.z = z);
return this;
}
}, {
key: "setRotation",
value: function setRotation(rotation) {
var x = rotation.x,
y = rotation.y,
z = rotation.z;
x !== undefined && (this.rotation.x = x);
y !== undefined && (this.rotation.y = y);
z !== undefined && (this.rotation.z = z);
return this;
}
}, {
key: "setScale",
value: function setScale(scale) {
var x = scale.x,
y = scale.y,
z = scale.z;
x !== undefined && (this.scale.x = x);
y !== undefined && (this.scale.y = y);
z !== undefined && (this.scale.z = z);
return this;
}
}, {
key: "setSize",
value: function setSize(size) {
var x = size.x,
y = size.y,
z = size.z;
x !== undefined && (this.size.x = x);
y !== undefined && (this.size.y = y);
z !== undefined && (this.size.z = z);
return this;
}
}, {
key: "setMeshes",
value: function setMeshes(value) {
this.meshes = value;
return this;
}
}, {
key: "getMatrix4",
value: function getMatrix4() {
var order = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'ZYX';
var quaternion = new Quaternion().setFromEuler(new Euler(this.rotation.x * MathUtils.DEG2RAD, this.rotation.y * MathUtils.DEG2RAD, this.rotation.z * MathUtils.DEG2RAD, order));
var position = new Vector3(this.position.x, this.position.y, this.position.z);
var scale = new Vector3(this.scale.x, this.scale.y, this.scale.z);
return new Matrix4().compose(position, quaternion, scale);
}
}, {
key: "getMatrix3From3d",
value: function getMatrix3From3d() {
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : EPerspectiveType.FRONT;
var matrix3 = new Matrix3();
if (type === EPerspectiveType.FRONT) {
matrix3.compose(new Vector2(this.position.x, this.position.y), this.rotation.z * MathUtils.DEG2RAD, new Vector2(this.scale.x, this.scale.y));
} else if (type === EPerspectiveType.TOP) {
matrix3.compose(new Vector2(this.position.x, this.position.z), this.rotation.y * MathUtils.DEG2RAD, new Vector2(this.scale.x, this.scale.z));
} else if (type === EPerspectiveType.LEFT) {
matrix3.compose(new Vector2(this.position.z, this.position.y), this.rotation.x * MathUtils.DEG2RAD, new Vector2(this.scale.z, this.scale.y));
}
return matrix3;
}
}, {
key: "getConcatenatedMatrix",
value: function getConcatenatedMatrix() {
var result = this.getMatrix4().clone();
// eslint-disable-next-line @typescript-eslint/no-this-alias
var root = this;
while (root.parent) {
root = root.parent;
result.premultiply(root.getMatrix4());
}
return result;
}
/**
* 初始建模包围盒，默认建模原点为几何中心，如需修改请重写该方法
* @BreakingChange 之前建模原点默认为左后下，现在默认为几何中心（更便于做计算）
*/
}, {
key: "getRawBox3",
value: function getRawBox3() {
var size = new Vector3(this.size.x, this.size.y, this.size.z);
// const original = new Vector3(0.5, 0.5, 0.5);
var original = new Vector3(0, 0, 0);
var center = size.clone().multiply(original);
return new Box3().setFromCenterAndSize(center, size);
}
}, {
key: "getRawBox3Points",
value: function getRawBox3Points() {
var box3 = this.getRawBox3();
var points = [new Vector3(box3.min.x, box3.min.y, box3.min.z), new Vector3(box3.min.x, box3.min.y, box3.max.z), new Vector3(box3.max.x, box3.min.y, box3.max.z), new Vector3(box3.max.x, box3.min.y, box3.min.z), new Vector3(box3.min.x, box3.max.y, box3.max.z), new Vector3(box3.max.x, box3.max.y, box3.max.z), new Vector3(box3.max.x, box3.max.y, box3.min.z), new Vector3(box3.min.x, box3.max.y, box3.min.z)];
return points;
}
/** 获取 AABB 包围盒 */
}, {
key: "getBox3AABB",
value: function getBox3AABB(matrix4) {
var useWCS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var points = this.getBox3(matrix4, useWCS);
var box3 = new Box3().setFromPoints(points);
return [new Vector3(box3.min.x, box3.min.y, box3.min.z), new Vector3(box3.min.x, box3.min.y, box3.max.z), new Vector3(box3.max.x, box3.min.y, box3.max.z), new Vector3(box3.max.x, box3.min.y, box3.min.z), new Vector3(box3.min.x, box3.max.y, box3.max.z), new Vector3(box3.max.x, box3.max.y, box3.max.z), new Vector3(box3.max.x, box3.max.y, box3.min.z), new Vector3(box3.min.x, box3.max.y, box3.min.z)];
}
/** 获取紧贴包围盒 */
}, {
key: "getBox3",
value: function getBox3(matrix4) {
var useWCS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var matrix = matrix4 || (useWCS ? this.getConcatenatedMatrix() : this.getMatrix4());
var points = this.getRawBox3Points();
return points.map(function (point) {
return point.clone().applyMatrix4(matrix);
});
}
}, {
key: "getRawBox2PointsFrom3d",
value: function getRawBox2PointsFrom3d() {
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : EPerspectiveType.FRONT;
var box3 = this.getRawBox3();
if (type === EPerspectiveType.TOP) {
return [new Vector2(box3.min.x, box3.min.z), new Vector2(box3.min.x, box3.max.z), new Vector2(box3.max.x, box3.max.z), new Vector2(box3.max.x, box3.min.z)];
} else if (type === EPerspectiveType.FRONT) {
return [new Vector2(box3.min.x, box3.min.y), new Vector2(box3.max.x, box3.min.y), new Vector2(box3.max.x, box3.max.y), new Vector2(box3.min.x, box3.max.y)];
} else if (type === EPerspectiveType.LEFT) {
return [new Vector2(box3.min.z, box3.min.y), new Vector2(box3.max.z, box3.min.y), new Vector2(box3.max.z, box3.max.y), new Vector2(box3.min.z, box3.max.y)];
}
return [];
}
/** 从 3d 下不同视角获取 2d AABB 包围盒 */
}, {
key: "getBox2AABBFrom3d",
value: function getBox2AABBFrom3d() {
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : EPerspectiveType.FRONT;
var useWCS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var points = this.getBox2From3d(type, useWCS);
var box2 = new Box2().setFromPoints(points);
return [new Vector2(box2.min.x, box2.min.y), new Vector2(box2.max.x, box2.min.y), new Vector2(box2.max.x, box2.max.y), new Vector2(box2.min.x, box2.max.y)];
}
/** 从 3d 下不同视角获取 2d 紧贴包围盒 */
}, {
key: "getBox2From3d",
value: function getBox2From3d() {
var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : EPerspectiveType.FRONT;
var useWCS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var matrix = useWCS ? this.getConcatenatedMatrix() : this.getMatrix4();
var points = this.getBox3(matrix, useWCS);
var len = points.length / 2;
var position = new Vector3();
var rotation = new Quaternion();
var scale = new Vector3();
matrix.decompose(position, rotation, scale);
var euler = new Euler().setFromQuaternion(rotation);
var _euler$toArray$slice$ = euler.toArray().slice(0, 3).map(function (rad) {
return rad % (Math.PI / 2) === 0;
}),
_euler$toArray$slice$2 = _slicedToArray(_euler$toArray$slice$, 3),
x = _euler$toArray$slice$2[0],
y = _euler$toArray$slice$2[1],
z = _euler$toArray$slice$2[2];
if (type === EPerspectiveType.TOP) {
// 顶视图情况下，x 轴、z 轴只要有非 90 度倍数旋转，就得取投影包围盒，否则取真实紧贴包围盒
if (!x || !z) {
var box3 = new Box3().setFromPoints(points);
return [new Vector2(box3.min.x, box3.min.z), new Vector2(box3.min.x, box3.max.z), new Vector2(box3.max.x, box3.max.z), new Vector2(box3.max.x, box3.min.z)];
}
var newPoints = points.sort(function (a, b) {
return b.y - a.y;
}).slice(0, len).map(function (p) {
return new Vector2(p.x, p.z);
});
return MathUtils.clockwisePoints(newPoints);
} else if (type === EPerspectiveType.FRONT) {
// 正视图情况下，x 轴、y 轴只要有非 90 度倍数旋转，就得取投影包围盒，否则取真实紧贴包围盒
if (!x || !y) {
var _box = new Box3().setFromPoints(points);
return [new Vector2(_box.min.x, _box.min.y), new Vector2(_box.max.x, _box.min.y), new Vector2(_box.max.x, _box.max.y), new Vector2(_box.min.x, _box.max.y)];
}
var _newPoints = points.sort(function (a, b) {
return b.z - a.z;
}).slice(0, len).map(function (p) {
return new Vector2(p.x, p.y);
});
return MathUtils.clockwisePoints(_newPoints);
} else if (type === EPerspectiveType.LEFT) {
// 左视图情况下，z 轴、y 轴只要有非 90 度倍数旋转，就得取投影包围盒，否则取真实紧贴包围盒
if (!z || !y) {
var _box2 = new Box3().setFromPoints(points);
return [new Vector2(_box2.min.z, _box2.min.y), new Vector2(_box2.max.z, _box2.min.y), new Vector2(_box2.max.z, _box2.max.y), new Vector2(_box2.min.z, _box2.max.y)];
}
var _newPoints2 = points.sort(function (a, b) {
return a.x - b.x;
}).slice(0, len).map(function (p) {
return new Vector2(p.z, p.y);
});
return MathUtils.clockwisePoints(_newPoints2);
}
return [];
}
/**
* ------------------------------------------------ 以下是纯 2d 坐标系下的方法 ------------------------------------------------
* x
* |— — — — — —
* |
* |
* |
* y |
* 2d 坐标系
*/
}, {
key: "getRawBox2",
value: function getRawBox2() {
var size = new Vector2(this.size.x, this.size.y);
// const original = new Vector2(0.5, 0.5);
var original = new Vector2(0, 0);
var center = size.clone().multiply(original);
return new Box2().setFromCenterAndSize(center, size);
}
/** top
* 3---------2
* | |
* |left |right
* | |
* 0---------1
* bottom
* 获取原始包围盒的 4 个点
*/
}, {
key: "getRawBox2Points",
value: function getRawBox2Points() {
var box2 = this.getRawBox2();
return [new Vector2(box2.min.x, box2.max.y), new Vector2(box2.max.x, box2.max.y), new Vector2(box2.max.x, box2.min.y), new Vector2(box2.min.x, box2.min.y)];
}
}, {
key: "getMatrix3",
value: function getMatrix3() {
var matrix3 = new Matrix3();
return matrix3.compose(new Vector2(this.position.x, this.position.y), this.rotation.z * MathUtils.DEG2RAD, new Vector2(this.scale.x, this.scale.y));
}
}, {
key: "getConcatenatedMatrix3",
value: function getConcatenatedMatrix3() {
var result = this.getMatrix3().clone();
// eslint-disable-next-line @typescript-eslint/no-this-alias
var root = this;
while (root.parent) {
root = root.parent;
result.premultiply(root.getMatrix3());
}
return result;
}
/** 获取 AABB 包围盒 */
}, {
key: "getBox2AABB",
value: function getBox2AABB(matrix3) {
var useWCS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var points = this.getBox2(matrix3, useWCS);
var box2 = new Box2().setFromPoints(points);
return [new Vector2(box2.min.x, box2.max.y), new Vector2(box2.max.x, box2.max.y), new Vector2(box2.max.x, box2.min.y), new Vector2(box2.min.x, box2.min.y)];
}
/** 获取紧贴包围盒 */
}, {
key: "getBox2",
value: function getBox2(matrix3) {
var useWCS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var matrix = matrix3 || (useWCS ? this.getConcatenatedMatrix3() : this.getMatrix3());
var points = this.getRawBox2Points();
return points.map(function (point) {
return point.clone().applyMatrix3(matrix);
});
}
}], [{
key: "getEntityById",
value: function getEntityById(id) {
return EntityObject.entityMap.get(id);
}
}]);
}(Domain);
EntityObject.EPerspectiveType = EPerspectiveType;
EntityObject.entityMap = new Map();
export default EntityObject;
__decorate([reactor()], EntityObject.prototype, "id", void 0);
__decorate([reactor()], EntityObject.prototype, "name", void 0);
__decorate([reactor()], EntityObject.prototype, "position", void 0);
__decorate([reactor()], EntityObject.prototype, "rotation", void 0);
__decorate([reactor()], EntityObject.prototype, "scale", void 0);
__decorate([reactor()], EntityObject.prototype, "size", void 0);
__decorate([reactor()], EntityObject.prototype, "parent", void 0);
__decorate([reactor()], EntityObject.prototype, "children", void 0);
__decorate([reactor()], EntityObject.prototype, "hidden", void 0);
__decorate([reactor()], EntityObject.prototype, "locked", void 0);
__decorate([reactor()], EntityObject.prototype, "isClickable", void 0);
__decorate([reactor()], EntityObject.prototype, "isHoverable", void 0);
__decorate([reactor()], EntityObject.prototype, "isDraggable", void 0);
__decorate([reactor()], EntityObject.prototype, "isPinchable", void 0);
__decorate([reactor()], EntityObject.prototype, "isRotatable", void 0);
__decorate([reactor()], EntityObject.prototype, "isPressable", void 0);
__decorate([reactor()], EntityObject.prototype, "renderOrder", void 0);
__decorate([reactor()], EntityObject.prototype, "meshes", void 0);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2Top", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2TopWCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2TopAABBWCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2Front", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2FrontWCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2FrontAABBWCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2Left", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2LeftWCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box2LeftAABBWCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box3", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box3WCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box3AABB", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "box3AABBWCS", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "scaledSize", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "matrix3Top", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "matrix3Front", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "matrix3Left", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "matrix4", null);
__decorate([mutation], EntityObject.prototype, "setClickable", null);
__decorate([mutation], EntityObject.prototype, "setHoverable", null);
__decorate([mutation], EntityObject.prototype, "setDraggable", null);
__decorate([mutation], EntityObject.prototype, "setPinchable", null);
__decorate([mutation], EntityObject.prototype, "setRotatable", null);
__decorate([mutation], EntityObject.prototype, "setPressable", null);
__decorate([mutation], EntityObject.prototype, "setInteractive", null);
__decorate([mutation], EntityObject.prototype, "setRenderOrder", null);
__decorate([mutation], EntityObject.prototype, "lock", null);
__decorate([mutation], EntityObject.prototype, "unlock", null);
__decorate([mutation], EntityObject.prototype, "hide", null);
__decorate([mutation], EntityObject.prototype, "show", null);
__decorate([mutation], EntityObject.prototype, "setName", null);
__decorate([mutation], EntityObject.prototype, "setMatrix4", null);
__decorate([computed({
lazy: false
})], EntityObject.prototype, "concatenatedMatrix", null);
__decorate([mutation], EntityObject.prototype, "traverse", null);
__decorate([mutation], EntityObject.prototype, "addChild", null);
__decorate([mutation], EntityObject.prototype, "addChildren", null);
__decorate([mutation], EntityObject.prototype, "removeChild", null);
__decorate([mutation], EntityObject.prototype, "removeChildren", null);
__decorate([mutation], EntityObject.prototype, "setPosition", null);
__decorate([mutation], EntityObject.prototype, "setRotation", null);
__decorate([mutation], EntityObject.prototype, "setScale", null);
__decorate([mutation], EntityObject.prototype, "setSize", null);
__decorate([mutation], EntityObject.prototype, "setMeshes", null);