1.1版本

src/core/Component.ts

@@ -3,7 +3,7 @@
  */
 
 import HashObject from "./HashObject";
-import {Entity,} from "./Entity";
+import {Node,} from "./Node";
 import {EngineConfig} from "../engine-config";
 
 const interactiveMap = [
@@ -17,9 +17,9 @@ const interactiveMap = [
  */
 export class Component extends HashObject {
 	/**
-	 * 所依附的实体
+	 * 所依附的节点
 	 */
-	entity: Entity;
+	node: Node;
 	protected delayCallbacks = [];
 
 	//是否有效
@@ -37,7 +37,7 @@ export class Component extends HashObject {
 	set enabled(value: boolean) {
 		if (this._enabled !== value) {
 			this._enabled = value;
-			if (this.entity && this.entity.isActive) {
+			if (this.node && this.node.isActive) {
 				if (!EngineConfig.editorMode) {
 					if (this._enabled) {
 						this.onEnable();
@@ -50,18 +50,18 @@ export class Component extends HashObject {
 	}
 
 	/**
-	 * 装配实体
-	 * @param entity
+	 * 装配节点
+	 * @param node
 	 */
-	_setup(entity: Entity) {
-		this.entity = entity;
+	_setup(node: Node) {
+		this.node = node;
 	}
 
 	/**
-	 * 卸载实体
+	 * 卸载节点
 	 */
 	_unSetup() {
-		this.entity = null;
+		this.node = null;
 	}
 
 	/**
@@ -111,12 +111,12 @@ export class Component extends HashObject {
 		this.onEditorUpdate(t);
 	}
 
-	$afterUpdate() {
-		this.afterUpdate();
+	$onRegression() {
+		this.onRegression();
 	}
 
-	$afterEditorUpdate() {
-		this.afterEditorUpdate();
+	$onEditorRegression() {
+		this.onEditorRegression();
 	}
 
 	private invokeDelayCallback(t) {
@@ -144,13 +144,13 @@ export class Component extends HashObject {
 	}
 
 	/**
-	 * 当子实体的时钟更新结束后
+	 * 当子节点的时钟更新结束后
 	 */
-	afterUpdate() {
+	onRegression() {
 
 	}
 
-	afterEditorUpdate() {
+	onEditorRegression() {
 
 	}
 
@@ -273,7 +273,7 @@ export class Component extends HashObject {
 	 * @param params 参数
 	 */
 	broadcast(method, level = -1, ...params) {
-		this.entity.broadcast(method, level, ...params);
+		this.node.broadcast(method, level, ...params);
 	}
 
 	/**
@@ -283,6 +283,6 @@ export class Component extends HashObject {
 	 * @param params 参数
 	 */
 	bubbling(method, ...params) {
-		this.entity.bubbling(method, ...params);
+		this.node.bubbling(method, ...params);
 	}
 }

src/core/Entity.ts → src/core/Node.ts

 /**
- * Created by rockyl on 2019-07-03.
+ * Created by rockyl on 2019-07-04.
  *
- * 实体
+ * 节点类
  */
 
-import {Component} from "./Component";
-import {EngineConfig} from "../engine-config";
-import {ScillaEngine} from "./ScillaEngine";
+import Vector2D from "../support/Vector2D";
+import {deepDirtyFieldDetector, dirtyFieldDetector,} from "../tools/decorators";
+import Matrix from "../support/Matrix";
+import {Bounds} from "../support";
+import {Component, createCanvas, engine, ScillaEngine} from "./index";
 import {bubbling, traverse} from "./utils";
+import {EngineConfig} from "../engine-config";
 import {EventDispatcher} from "./EventDispatcher";
 
-/**
- * 实体类
+export class Node extends EventDispatcher {
+	name = 'Node';
+
+	/**
+	 * 坐标
 	 */
-export class Entity extends EventDispatcher {
-	name: string = 'Entity';
-	protected _uuid: string;
+	@deepDirtyFieldDetector
+	position: Vector2D = new Vector2D();
+	/**
+	 * 缩放
+	 */
+	@deepDirtyFieldDetector
+	scale: Vector2D = new Vector2D(1, 1);
+	/**
+	 * 旋转
+	 */
+	@dirtyFieldDetector
+	rotation = 0;
+	/**
+	 * 节点透明度
+	 */
+	@dirtyFieldDetector
+	alpha: number = 1;
+	/**
+	 * 可见性
+	 */
+	@dirtyFieldDetector
+	visible: boolean = true;
+	/**
+	 * 锚点
+	 */
+	@deepDirtyFieldDetector
+	anchor: Vector2D = new Vector2D(0, 0);
+	/**
+	 * 影响子节点
+	 */
+	@dirtyFieldDetector
+	affectChildren: boolean = true;
 
-	//是否游离状态
-	protected _isFree: boolean = true;
-	//是否有效
-	protected _enabled: boolean = EngineConfig.entityEnabled;
-	protected _parent: Entity = null;
-	protected _children: Entity[] = [];
+	/**
+	 * 唯一id
+	 */
+	protected _uuid: string;
+	/**
+	 * 组件
+	 */
 	protected _components: Component[] = [];
+	/**
+	 * 父节点
+	 */
+	protected _parent: Node = null;
+	/**
+	 * 子节点
+	 */
+	protected _children: Node[] = [];
+	/**
+	 * 是否游离状态
+	 */
+	protected _isFree: boolean = true;
+	/**
+	 * 是否有效
+	 */
+	protected _enabled: boolean = EngineConfig.nodeEnabled;
+	/**
+	 * 渲染上下文
+	 */
+	protected _context;
+	/**
+	 * 缓存画布
+	 */
+	protected _cacheCanvas = null;
+	/**
+	 * 缓存用的渲染上下文
+	 */
+	protected _cacheContext;
+	/**
+	 * 属性是否脏
+	 */
+	protected dirty = true;
+	/**
+	 * 本地矩阵
+	 */
+	protected _localMatrix: Matrix = Matrix.create();
+	/**
+	 * 全局矩阵
+	 */
+	protected _globalMatrix: Matrix = Matrix.create();
+	/**
+	 * 全局逆矩阵
+	 */
+	protected _globalInvertMatrix: Matrix = Matrix.create();
+	/**
+	 * 真实渲染透明度
+	 */
+	protected _renderAlpha: number;
+	/**
+	 * 本地坐标缓存
+	 */
+	protected _localPos: Vector2D = new Vector2D();
+	/**
+	 * 全局坐标缓存
+	 */
+	protected _globalPosition: Vector2D = new Vector2D();
+	/**
+	 * 渲染边界
+	 */
+	protected _bounds = new Bounds();
+	/**
+	 * 锚点偏移
+	 */
+	//protected _anchorOffset: Vector2D = new Vector2D();
+	/**
+	 * 尺寸
+	 * 对于不同的子类渲染都有不同的效果
+	 */
+	protected _width: number = NaN;
+	protected _height: number = NaN;
+	/**
+	 * 扩展尺寸
+	 */
+	protected _margin: number = 0;
+	/**
+	 * 是否使用渲染模式
+	 */
+	protected _useCacheMode = false;
 
 	constructor(name?: string, uuid?: string) {
 		super();
@@ -37,10 +151,45 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 获取唯一ID
+	 * 当属性更新时
+	 * @param value
+	 * @param key
+	 * @param oldValue
 	 */
-	get uuid(): string {
-		return this._uuid;
+	onModify(value, key, oldValue) {
+		this.dirty = true;
+
+	}
+
+	//----- tree
+
+	/**
+	 * 获取父节点
+	 */
+	get parent(): Node {
+		return this._parent;
+	}
+
+	/**
+	 * 获取根节点
+	 */
+	get root(): RootNode {
+		let p: any = this;
+
+		do {
+			if (p instanceof RootNode) {
+				return p;
+			}
+		}
+		while (p = p.parent)
+	}
+
+	/**
+	 * 是否含有子节点
+	 * @param child
+	 */
+	containsChild(child: Node): boolean {
+		return this.getChildIndex(child) >= 0;
 	}
 
 	/**
@@ -52,9 +201,15 @@ export class Entity extends EventDispatcher {
 
 	set enabled(value: boolean) {
 		if (this._enabled !== value) {
+			this.setEnabled(value);
+		}
+	}
+
+	protected setEnabled(value) {
 		this._enabled = value;
+
 		let that = this;
-			traverse(this, function (child: Entity) {
+		traverse(this, function (child: Node) {
 			if (child !== that && !child._enabled) {
 				return true;
 			}
@@ -63,7 +218,6 @@ export class Entity extends EventDispatcher {
 			return false;
 		}, -1, true)
 	}
-	}
 
 	_invokeEnabledState(enabled: boolean) {
 		if (this._enabled) {
@@ -96,7 +250,7 @@ export class Entity extends EventDispatcher {
 	_free() {
 		this._isFree = true;
 
-		traverse(this, function (child: Entity) {
+		traverse(this, function (child: Node) {
 			if (child.isParentActive) {
 				child._invokeEnabledState(false);
 			}
@@ -111,7 +265,7 @@ export class Entity extends EventDispatcher {
 	_restrict() {
 		this._isFree = false;
 
-		traverse(this, function (child: Entity) {
+		traverse(this, function (child: Node) {
 			if (child.isParentActive) {
 				child._invokeEnabledState(true);
 			}
@@ -120,43 +274,12 @@ export class Entity extends EventDispatcher {
 		}, 1)
 	}
 
-	//----- tree
-
-	/**
-	 * 获取父实体
-	 */
-	get parent(): Entity {
-		return this._parent;
-	}
-
-	/**
-	 * 获取根实体
-	 */
-	get root(): RootEntity {
-		let p: any = this;
-
-		do {
-			if (p instanceof RootEntity) {
-				return p;
-			}
-		}
-		while (p = p.parent)
-	}
-
-	/**
-	 * 是否含有子实体
-	 * @param child
-	 */
-	containsChild(child: Entity): boolean {
-		return this.getChildIndex(child) >= 0;
-	}
-
 	/**
-	 * 添加子实体时
+	 * 添加子节点时
 	 * @param child
 	 * @private
 	 */
-	protected _onChildAdded(child: Entity) {
+	protected _onChildAdded(child: Node) {
 		child._parent = this;
 
 		if (!this._isFree && child._isFree) {
@@ -168,11 +291,11 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 子实体被移除时
+	 * 子节点被移除时
 	 * @param child
 	 * @private
 	 */
-	_onChildRemoved(child: Entity) {
+	_onChildRemoved(child: Node) {
 		child._parent = null;
 
 		if (!this._isFree && !child._isFree) {
@@ -184,19 +307,19 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 添加子实体，重复添加则会加到最后
+	 * 添加子节点，重复添加则会加到最后
 	 * @param child
 	 */
-	addChild(child: Entity) {
+	addChild(child: Node) {
 		this.addChildAt(child, this._children.length);
 	}
 
 	/**
-	 * 添加子实体到指定索引，重复添加可作为顺序交换
+	 * 添加子节点到指定索引，重复添加可作为顺序交换
 	 * @param child
 	 * @param index
 	 */
-	addChildAt(child: Entity, index) {
+	addChildAt(child: Node, index) {
 		if (child.parent && child.parent !== this) {
 			child.parent.removeChild(child);
 		}
@@ -220,10 +343,10 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 移除实体
+	 * 移除节点
 	 * @param child
 	 */
-	removeChild(child: Entity) {
+	removeChild(child: Node) {
 		const index = this.getChildIndex(child);
 		if (index >= 0) {
 			return this.removeChildAt(index);
@@ -231,7 +354,7 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 移除指定索引的实体
+	 * 移除指定索引的节点
 	 * @param index
 	 */
 	removeChildAt(index: number) {
@@ -246,26 +369,26 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 根据实体获取索引
+	 * 根据节点获取索引
 	 * @param child
 	 */
-	getChildIndex(child: Entity): number {
+	getChildIndex(child: Node): number {
 		return this._children.indexOf(child)
 	}
 
 	/**
-	 * 获取指定索引的实体
+	 * 获取指定索引的节点
 	 * @param index
 	 */
-	getChildAt(index): Entity {
+	getChildAt(index): Node {
 		return this._children[index];
 	}
 
 	/**
-	 * 获取指定名字的实体
+	 * 获取指定名字的节点
 	 * @param name
 	 */
-	getChildrenByName(name): Entity[] {
+	getChildrenByName(name): Node[] {
 		let children = [];
 		for (let child of this._children) {
 			if (child.name === name) {
@@ -277,7 +400,7 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 移除所有子实体
+	 * 移除所有子节点
 	 */
 	removeChildren() {
 		while (this._children.length > 0) {
@@ -286,12 +409,27 @@ export class Entity extends EventDispatcher {
 	}
 
 	/**
-	 * 获取所有子实体
+	 * 获取所有子节点
 	 */
-	get children(): Entity[] {
+	get children(): Node[] {
 		return this._children;
 	}
 
+	/**
+	 * 获取唯一ID
+	 */
+	get uuid(): string {
+		return this._uuid;
+	}
+
+	/**
+	 * 移除所有组件和子节点
+	 */
+	clean() {
+		this.removeAllComponents();
+		this.removeChildren();
+	}
+
 	//----- component
 
 	/**
@@ -434,53 +572,25 @@ export class Entity extends EventDispatcher {
 	 * @param t
 	 */
 	$onUpdate(t) {
+		if (!this.enabled) {
+			return;
+		}
 		this.preUpdate(t);
 		this.updateComponents(t);
 		this.onUpdate(t);
+		this.windUpUpdate(t);
 	}
 
 	/**
-	 * 预更新
-	 * @param t
-	 */
-	preUpdate(t) {
-
-	}
-
-	/**
-	 * 组件更新
-	 * @param t
-	 */
-	updateComponents(t) {
-		this.forEachComponent(comp => {
-			if (comp.enabled) {
-				if (EngineConfig.editorMode) {
-					return comp.$onEditorUpdate(t);
-				} else {
-					return comp.$onUpdate(t);
-				}
-			}
-		});
-	}
-
-	/**
-	 * 更新
-	 * @param t
+	 * 当子节点遍历回归
 	 */
-	onUpdate(t) {
-
-	}
-
-	/**
-	 * 当子实体遍历结束后
-	 */
-	$afterUpdate() {
+	onRegression() {
 		this.forEachComponent(comp => {
 			if (comp.enabled) {
 				if (EngineConfig.editorMode) {
-					return comp.$afterEditorUpdate();
+					return comp.$onEditorRegression();
 				} else {
-					return comp.$afterUpdate();
+					return comp.$onRegression();
 				}
 			}
 		});
@@ -559,7 +669,7 @@ export class Entity extends EventDispatcher {
 	 * @param params 参数
 	 */
 	broadcast(method: string, level = -1, ...params) {
-		traverse(this, this.invokeOnEntity, level, true, null, method, ...params)
+		traverse(this, this.invokeOnNode, level, true, null, method, ...params)
 	}
 
 	/**
@@ -569,18 +679,18 @@ export class Entity extends EventDispatcher {
 	 * @param params 参数
 	 */
 	bubbling(method: string, ...params) {
-		bubbling(this, this.invokeOnEntity, false, method, ...params);
+		bubbling(this, this.invokeOnNode, false, method, ...params);
 	}
 
 	/**
-	 * 调用实体上的组件的方法
-	 * @param hitEntity 遇到的实体
+	 * 调用节点上的组件的方法
+	 * @param hitNode 遇到的节点
 	 * @param method 方法名
 	 * @param params 参数
 	 */
-	private invokeOnEntity = (hitEntity: Entity, method: string, ...params): boolean => {
+	private invokeOnNode = (hitNode: Node, method: string, ...params): boolean => {
 		let hitBreak = false;
-		hitEntity.forEachComponent(comp => {
+		hitNode.forEachComponent(comp => {
 			const m = comp[method];
 			if (m) {
 				const result = m.apply(comp, params);
@@ -594,12 +704,372 @@ export class Entity extends EventDispatcher {
 			return true;
 		}
 	};
+
+	//-----Update
+
+	/**
+	 * 预更新
+	 * @param t
+	 */
+	protected preUpdate(t) {
+		if (this.dirty) {
+			this.updateLocalMatrix();
+		}
+		this.updateGlobalMatrix();
+
+		if (this.dirty) {
+			if (this.useCacheMode) {
+				this.readyCacheCanvas();
+			}
+			this.measureBounds();
+			if (this.useCacheMode) {
+				this.updateCacheCanvas();
+			}
+		}
+	}
+
+	/**
+	 * 组件更新
+	 * @param t
+	 */
+	protected updateComponents(t) {
+		this.forEachComponent(comp => {
+			if (comp.enabled) {
+				if (EngineConfig.editorMode) {
+					return comp.$onEditorUpdate(t);
+				} else {
+					return comp.$onUpdate(t);
+				}
+			}
+		});
+	}
+
+	/**
+	 * 更新
+	 * @param t
+	 */
+	protected onUpdate(t) {
+
+	}
+
+	/**
+	 * 更新收尾
+	 * @param t
+	 */
+	protected windUpUpdate(t) {
+		this.transformToLocal();
+
+		if (this.visible) {
+			this.render();
+		}
+
+		this.dirty = false;
+	}
+
+	/**
+	 * 准备缓存渲染上下文
+	 */
+	protected readyCacheCanvas() {
+		let canvas = this._cacheCanvas;
+		if (!canvas) {
+			canvas = this._cacheCanvas = createCanvas();
+			this._cacheContext = canvas.getContext('2d');
+		}
+	}
+
+	/**
+	 * 更新缓存属性
+	 */
+	protected updateCacheCanvas() {
+		let canvas = this._cacheCanvas;
+
+		const {width, height} = this.bounds;
+		canvas.width = width + this._margin * 2;
+		canvas.height = height + this._margin * 2;
+	}
+
+	/**
+	 * 测量边界
+	 */
+	measureBounds() {
+		if (!this.dirty) {
+			return;
+		}
+
+		const {bounds, explicitWidth, explicitHeight} = this;
+
+		let renderSize: any = this.measureRenderSize();
+		bounds.width = renderSize ? renderSize.width : isNaN(explicitWidth) ? 0 : explicitWidth;
+		bounds.height = renderSize ? renderSize.height : isNaN(explicitHeight) ? 0 : explicitHeight;
+	}
+
+	/**
+	 * 测量渲染尺寸
+	 */
+	protected measureRenderSize() {
+		return;
+	}
+
+	/**
+	 * 渲染过程
+	 */
+	protected render() {
+		this.applyAlpha();
+		this.beforeDraw();
+		this.drawClip();
+
+		if (this.dirty) {
+			if (this.useCacheMode) {
+				this.draw(this.currentCanvasContext);
+			}
+			this.dirty = false;
+		}
+
+		if (this.useCacheMode) {
+			this.drawCache();
+		} else {
+			this.draw(this.currentCanvasContext);
+		}
+	}
+
+	/**
+	 * 应用透明度
+	 */
+	protected applyAlpha() {
+		this.context.globalAlpha = this.alpha * this._renderAlpha;
+	}
+
+	/**
+	 * 画之前
+	 */
+	protected beforeDraw() {
+	}
+
+	/**
+	 * 画遮罩
+	 */
+	protected drawClip() {
+
+	}
+
+	/**
+	 * 画
+	 */
+	protected draw(context) {
+
+	}
+
+	/**
+	 * 绘制缓存
+	 */
+	protected drawCache() {
+		if (this._cacheCanvas.width > 0 && this._cacheCanvas.height > 0) {
+			this.context.drawImage(this._cacheCanvas, -this._margin, -this._margin);
+		}
+	}
+
+	private get context() {
+		if (!this._context) {
+			this._context = engine.renderContext.context;
+		}
+
+		return this._context;
+	}
+
+	protected getUseCacheMode() {
+		return this._useCacheMode;
+	}
+
+	/**
+	 * 获取全局坐标
+	 */
+	get globalPosition() {
+		this._globalPosition.setXY(this._globalMatrix.tx, this._globalMatrix.ty);
+		return this._globalPosition;
+	}
+
+	/**
+	 * 宽度
+	 */
+	get width(): number {
+		return isNaN(this._width) ? this.bounds.width : this._width;
+	}
+
+	set width(value: number) {
+		if (this._width != value) {
+			let old = this._width;
+			this._width = value;
+
+			this.onModify(value, 'width', old);
+		}
+	}
+
+	/**
+	 * 设定的宽度
+	 */
+	get explicitWidth(): number {
+		return this._width;
+	}
+
+	/**
+	 * 高度
+	 */
+	get height(): number {
+		return isNaN(this._height) ? this.bounds.height : this._height;
+	}
+
+	set height(value: number) {
+		if (this._height != value) {
+			let old = this._height;
+			this._height = value;
+
+			this.onModify(value, 'height', old);
+		}
+	}
+
+	/**
+	 * 是否使用渲染模式
+	 */
+	get useCacheMode() {
+		return this.getUseCacheMode();
+	}
+
+	set useCacheMode(value) {
+		this._useCacheMode = value;
+	}
+
+	/**
+	 * 设定的高度
+	 */
+	get explicitHeight(): number {
+		return this._height;
+	}
+
+	/**
+	 * 全局坐标转本地坐标
+	 * @param position
+	 */
+	globalPositionToLocal(position?) {
+		const matrix = this.getMatrix(true, true, true);
+		matrix.transformPoint(position ? position.x : 0, position ? position.y : 0, this._localPos);
+
+		return this._localPos;
+	}
+
+	/**
+	 * 获取全局角度
+	 */
+	get globalRotation() {
+		return this._globalMatrix.rotation * 180 / Math.PI;
+	}
+
+	/**
+	 * 真实渲染透明度
+	 */
+	get renderAlpha(): number {
+		return this._renderAlpha;
+	}
+
+	/**
+	 * 渲染边界
+	 */
+	get bounds(): Bounds {
+		return this._bounds;
+	}
+
+	/**
+	 * 获取矩阵
+	 */
+	getMatrix(invert: boolean = false, affectChildren = false, invertOnlyTranslate = false): Matrix {
+		let matrix;
+		if (this.affectChildren || affectChildren) {
+			matrix = this._globalMatrix;
+			if (invert) {
+				const invertMatrix = this._globalInvertMatrix;
+				invertMatrix.copyFrom(matrix);
+				if (invertOnlyTranslate) {
+					invertMatrix.a = 1;
+					invertMatrix.d = 1;
+				}
+				invertMatrix.invert();
+
+				return invertMatrix;
+			}
+		} else {
+			matrix = this.parent.getMatrix(invert);
+		}
+
+		return matrix;
+	}
+
+	/**
+	 * 更新本地矩阵
+	 */
+	protected updateLocalMatrix() {
+		const {
+			position: {x, y},
+			scale: {x: sx, y: sy}, rotation,
+			anchor: {x: ax, y: ay},
+			width, height,
+		} = this;
+
+		const matrix = this._localMatrix;
+		matrix.identity();
+
+		matrix.translate(
+			-ax * width,
+			-ay * height,
+		);
+
+		matrix.scale(sx, sy);
+		matrix.rotate(rotation * Math.PI / 180);
+
+		matrix.translate(
+			x,
+			y,
+		);
+	}
+
+	/**
+	 * 更新全局矩阵
+	 */
+	protected updateGlobalMatrix() {
+		const {
+			_globalMatrix, _localMatrix,
+			parent,
+		} = this;
+
+		_globalMatrix.copyFrom(_localMatrix);
+
+		if (parent) {
+			this._renderAlpha = parent.renderAlpha * this.alpha;
+			_globalMatrix.concat(parent.getMatrix(false));
+		} else {
+			this._renderAlpha = this.alpha;
+		}
+	}
+
+	/**
+	 * 执行矩阵转换
+	 */
+	protected transformToLocal() {
+		const {a, b, c, d, tx, ty} = this.getMatrix(false, true);
+		this.context.setTransform(a, b, c, d, tx, ty);
+	}
+
+	/**
+	 * 获取渲染上下文
+	 * 如果缓存上下文存在，则返回缓存上下文
+	 */
+	protected get currentCanvasContext() {
+		return this._cacheContext || this.context;
+	}
 }
 
 /**
- * 根实体类
+ * 根节点类
  */
-export class RootEntity extends Entity {
+export class RootNode extends Node {
 	protected _engine: ScillaEngine;
 
 	constructor(engine: ScillaEngine) {
@@ -610,7 +1080,7 @@ export class RootEntity extends Entity {
 	}
 
 	/**
-	 * 获取引擎，只有活动的root实体才有这个属性
+	 * 获取引擎，只有活动的root节点才有这个属性
 	 */
 	get engine() {
 		return this._engine;

src/core/ScillaEngine.ts

@@ -4,7 +4,7 @@
  * 引擎
  */
 
-import {Entity, RootEntity} from "./Entity";
+import {Node, RootNode} from "./Node";
 import {injectProp} from "../tools/utils";
 import InteractContext from "./context/InteractContext";
 import RenderContext, {ScaleMode} from "./context/RenderContext";
@@ -36,7 +36,7 @@ export class ScillaEngine {
 	 */
 	readonly dataCenterConfig: any = {};
 
-	private _root: Entity;
+	private _root: RootNode;
 	private _canvasElement: HTMLCanvasElement;
 
 	private _flush = 0;
@@ -139,7 +139,7 @@ export class ScillaEngine {
 			onUpdateScale: this.onUpdateScale.bind(this),
 		});
 
-		this._root = new RootEntity(this);
+		this._root = new RootNode(this);
 		this._root._restrict();
 	}
 
@@ -163,19 +163,19 @@ export class ScillaEngine {
 	}
 
 	/**
-	 * 获取根Entity
+	 * 获取根Node
 	 */
-	get root(): Entity {
+	get root(): Node {
 		return this._root;
 	}
 
 	/**
-	 * 获取实体路径
-	 * @param entity
+	 * 获取节点路径
+	 * @param node
 	 */
-	getEntityPath(entity?: Entity): string {
+	getNodePath(node?: Node): string {
 		let path = '';
-		let current = entity || this._root;
+		let current = node || this._root;
 		while (current.parent) {
 			path = current.parent.children.indexOf(current) + (path.length > 0 ? '|' : '') + path;
 			current = current.parent;
@@ -184,10 +184,10 @@ export class ScillaEngine {
 	}
 
 	/**
-	 * 根据实体路径获取实体
+	 * 根据节点路径获取节点
 	 * @param path
 	 */
-	getEntityByPath(path?: string): Entity {
+	getNodeByPath(path?: string): Node {
 		let target = this._root;
 
 		if (path.length > 0) {
@@ -308,7 +308,7 @@ export class ScillaEngine {
 				return true;
 			}
 		}, -1, true, function (current) {
-			current.$afterUpdate();
+			current.onRegression();
 		});
 
 		for (let i = 0, li = this.nextTicks.length; i < li; i++) {
@@ -356,7 +356,7 @@ export class ScillaEngine {
 	}
 
 	/**
-	 * 射线测试获取实体
+	 * 射线测试获取节点
 	 * 注：暂时只用在编辑器内
 	 */
 	getEntitiesByRayTest(x, y, ignoreMask = true) {
@@ -365,7 +365,7 @@ export class ScillaEngine {
 		let rendererDef = this.getDefByName('components/renderer/Renderer');
 		traversePostorder(this._root, function (child) {
 			const transform = child.components[0];
-			const matrix = transform['getMatrix'](true, true, true);
+			const matrix = transform['getMatrix'](true, true);
 			matrix.transformPoint(x, y, localPos);
 
 			const renderers = child.getComponents(rendererDef);

src/core/context/RenderContext.ts

@@ -105,8 +105,6 @@ export default class RenderContext {
 		this.engine = engine;
 	}
 
-	//todo
-
 	private onModify(value, key, oldValue) {
 		if (!this.dirtyFieldTriggerLock) {
 			this.updateScaleModeSelf();

src/core/index.ts

@@ -3,7 +3,7 @@
  */
 
 export {Component} from "./Component";
-export {Entity} from './Entity'
+export {Node, RootNode} from './Node'
 export {ScillaEvent} from './ScillaEvent'
 export {createCanvas, ScaleMode} from './context/RenderContext';
 export {default as engine, ScillaEngine} from './ScillaEngine'
@@ -13,3 +13,4 @@ export * from './Sheet'
 export * from './FrameAnimation'
 
 export * from './interpreter'
+export * from './nodes'

src/core/interpreter.ts

@@ -4,13 +4,13 @@
  * 配置文件解释器
  */
 
-import {Entity} from "../core/Entity";
+import {Node} from "../core/Node";
 import {ScillaEvent} from "../core/ScillaEvent";
 import {EngineConfig} from "../engine-config";
 import engine from "./ScillaEngine";
 import {traverse} from "./utils";
 
-let entityMap = {};
+let nodeMap = {};
 let prefabID: number = 0;
 let _getResProxy: Function;
 
@@ -24,89 +24,80 @@ export function setGetResProxy(func: Function) {
  * @param root
  * @param getResProxy
  */
-export function setupScene(config: any, root: Entity, getResProxy: Function) {
+export function setupScene(config: any, root: Node, getResProxy: Function) {
 	setGetResProxy(getResProxy);
 
 	instantiateConfig(config, root);
 }
 
-/**
- * 清空实体
- * @param entity
- */
-export function cleanEntity(entity: Entity) {
-	entity.removeAllComponents();
-	entity.removeChildren();
-}
-
 /**
  * 装配预制体
  * @param config
  */
-export function instantiate(config: any): Entity {
+export function instantiate(config: any): Node {
 	let pid = ++prefabID;
 
-	const entity = instantiateConfig(config, null, pid);
+	const node = instantiateConfig(config, null, pid);
 
-	return entity.children[0];
+	return node.children[0];
 }
 
 /**
- * 装配树实体
+ * 装配树节点
  * @param config
  * @param root
  * @param pid
  */
-function instantiateConfig(config, root?: Entity, pid?: number): Entity {
+function instantiateConfig(config, root?: Node, pid?: number): Node {
 	let rootConfig = config.root;
 
-	const entity = setupEntity(rootConfig, root, pid);
-	setupComponent(rootConfig, entity, true);
-	injectComponent(rootConfig, entity, true, pid);
+	const node = setupNode(rootConfig, root, pid);
+	setupComponent(rootConfig, node, true);
+	injectComponent(rootConfig, node, true, pid);
 
-	traverse(entity, child => {
+	traverse(node, child => {
 		child.active();
 
 		return false;
 	});
 
-	entityMap = {};
+	nodeMap = {};
 
-	return entity;
+	return node;
 }
 
 /**
- * 装配实体
+ * 装配节点
  * @param config
  * @param root
  * @param pid
  */
-function setupEntity(config, root?: Entity, pid?: number): Entity {
-	let entity: Entity = null;
+function setupNode(config, root?: Node, pid?: number): Node {
+	let node: Node = null;
 	if (config) {
 		let {name, uuid, children} = config;
 		if (pid !== undefined && uuid !== undefined) {
 			uuid = pid + '_' + uuid;
 		}
-		entity = root || new Entity(name, uuid);
+		node = root || new Node(name, uuid);
 
-		entityMap[uuid] = entity;
+		nodeMap[uuid] = node;
 
 		if (children) {
 			for (let i = 0, li = children.length; i < li; i++) {
 				let child = children[i];
 
-				const childEntity = setupEntity(child, null, pid);
-				entity.addChild(childEntity);
+				const childNode = setupNode(child, null, pid);
+				node.addChild(childNode);
 			}
 		}
 
 		if (!root) {
-			entity.enabled = !config.disabled;
+			node.enabled = !config.disabled;
 		}
 	}
 
-	return entity;
+	return node;
 }
 
 /**
@@ -115,18 +106,18 @@ function setupEntity(config, root?: Entity, pid?: number): Entity {
  * @param root
  * @param includeSelf
  */
-function setupComponent(config, root: Entity, includeSelf: boolean = false) {
+function setupComponent(config, root: Node, includeSelf: boolean = false) {
 	if (includeSelf) {
 		instantiateComponents(root, config);
 	}
 	if (config && config.children) {
 		for (let i = 0, li = root.children.length; i < li; i++) {
 			const child = config.children[i];
-			const entity = root.children[i];
+			const node = root.children[i];
 
-			instantiateComponents(entity, child);
+			instantiateComponents(node, child);
 
-			setupComponent(child, entity);
+			setupComponent(child, node);
 		}
 	}
 }
@@ -138,44 +129,44 @@ function setupComponent(config, root: Entity, includeSelf: boolean = false) {
  * @param includeSelf
  * @param pid
  */
-function injectComponent(config, root: Entity, includeSelf = false, pid?: number) {
+function injectComponent(config, root: Node, includeSelf = false, pid?: number) {
 	if (includeSelf) {
 		injectComponents(root, config, pid);
 	}
 	if (config && config.children) {
 		for (let i = 0, li = root.children.length; i < li; i++) {
 			const child = config.children[i];
-			const entity = root.children[i];
+			const node = root.children[i];
 
-			injectComponents(entity, child, pid);
+			injectComponents(node, child, pid);
 
-			injectComponent(child, entity, false, pid);
+			injectComponent(child, node, false, pid);
 		}
 	}
 }
 
 /**
  * 实例化组件列表
- * @param entity
+ * @param node
  * @param config
  */
-function instantiateComponents(entity: Entity, config: any) {
+function instantiateComponents(node: Node, config: any) {
 	if (config.components) {
 		for (const component of config.components) {
-			instantiateComponent(entity, component);
+			instantiateComponent(node, component);
 		}
 	}
 }
 
 /**
  * 注入组件列表参数
- * @param entity
+ * @param node
  * @param config
  * @param pid
  */
-function injectComponents(entity: Entity, config: any, pid?: number) {
+function injectComponents(node: Node, config: any, pid?: number) {
 	if (config.components) {
-		const components = entity.components;
+		const components = node.components;
 		for (let i = 0, li = config.components.length; i < li; i++) {
 			const component = config.components[i];
 
@@ -200,10 +191,10 @@ export function injectComponentProperties(component, config, pid?: number) {
 
 /**
  * 实例化组件
- * @param entity
+ * @param node
  * @param config
  */
-export function instantiateComponent(entity: Entity, config: any) {
+export function instantiateComponent(node: Node, config: any) {
 	const {script,} = config;
 
 	let def = engine.getDefByName(script);
@@ -214,7 +205,7 @@ export function instantiateComponent(entity: Entity, config: any) {
 	const instance: any = new def();
 	instance.enabled = !config.disabled;
 
-	entity.addComponent(instance);
+	node.addComponent(instance);
 
 	return instance;
 }
@@ -223,13 +214,13 @@ const skipKeys = ['_type_', '_constructor_'];
 
 /**
  * 属性注入
- * @param entity
+ * @param node
  * @param propertiesConfig
  * @param pid
  */
-function injectProperties(entity, propertiesConfig, pid?: number) {
-	if (!entity) {
-		console.warn('entity is null.');
+function injectProperties(node, propertiesConfig, pid?: number) {
+	if (!node) {
+		console.warn('node is null.');
 		return;
 	}
 	for (const key in propertiesConfig) {
@@ -237,22 +228,22 @@ function injectProperties(entity, propertiesConfig, pid?: number) {
 			continue;
 		}
 		const propertyOfConfig: any = propertiesConfig[key];
-		let propertyOfInstance = entity[key];
+		let propertyOfInstance = node[key];
 		if (typeof propertyOfConfig === 'object') {
 			if (propertyOfInstance instanceof ScillaEvent) {
 				if (!EngineConfig.editorMode) {
 					injectEvent(propertyOfInstance, propertyOfConfig, pid);
 				}
 			} else if (propertyOfConfig._type_ === 'raw') {
-				entity[key] = propertyOfInstance = propertyOfConfig.data;
+				node[key] = propertyOfInstance = propertyOfConfig.data;
 			} else {
 				if (Array.isArray(propertyOfConfig) && !propertyOfInstance) {
-					entity[key] = propertyOfInstance = []
+					node[key] = propertyOfInstance = []
 				}
-				entity[key] = injectObject(propertyOfInstance, propertyOfConfig, pid);
+				node[key] = injectObject(propertyOfInstance, propertyOfConfig, pid);
 			}
 		} else {
-			injectBaseType(entity, key, propertyOfConfig, pid);
+			injectBaseType(node, key, propertyOfConfig, pid);
 		}
 	}
 }
@@ -277,7 +268,7 @@ function injectObject(propertyOfInstance, propertyOfConfig, pid?: number) {
 	return propertyOfInstance;
 }
 
-function injectBaseType(entity, key, propertyOfConfig, pid?: number) {
+function injectBaseType(node, key, propertyOfConfig, pid?: number) {
 	let propertyValue;
 	if (typeof propertyOfConfig === 'string') {
 		propertyValue = getLink(propertyOfConfig, pid);
@@ -291,23 +282,23 @@ function injectBaseType(entity, key, propertyOfConfig, pid?: number) {
 	}
 
 	if (typeof propertyValue === 'function') {
-		Object.defineProperty(entity, keyAvatar, {
+		Object.defineProperty(node, keyAvatar, {
 			get() {
-				return this[`func_${keyAvatar}`](entity, engine.dataCenter)
+				return this[`func_${keyAvatar}`](node, engine.dataCenter)
 			},
 			set(v) {
 				this[`func_${keyAvatar}`] = v;
 			}
 		})
 	}
-	entity[keyAvatar] = propertyValue;
+	node[keyAvatar] = propertyValue;
 }
 
 function injectEvent(event: ScillaEvent, config, pid?) {
-	for (const {entity: entityName, component: componentIndex, method: methodName, param} of config) {
-		if (entityName && componentIndex >= 0 && methodName) {
-			const entity = getLink(entityName, pid);
-			const component = entity.components[componentIndex];
+	for (const {node: nodeName, component: componentIndex, method: methodName, param} of config) {
+		if (nodeName && componentIndex >= 0 && methodName) {
+			const node = getLink(nodeName, pid);
+			const component = node.components[componentIndex];
 			const method = component[methodName];
 			if (method) {
 				if (param == undefined) {
@@ -325,9 +316,9 @@ function getLink(str: string, pid?: number) {
 	if (str.indexOf('res|') == 0) { //res uuid
 		const uuid = str.substr(4);
 		result = _getResProxy(uuid);
-	} else if (str.indexOf('entity|') == 0) {  //entity uuid
+	} else if (str.indexOf('node|') == 0) {  //node uuid
 		const uuid = transPrefabUUID(str.substr(7), pid);
-		result = entityMap[uuid];
+		result = nodeMap[uuid];
 	} else if (str.indexOf('dynamic|') == 0) { //dynamic
 		const [_, type, expression] = str.split('|');
 		result = () => {

src/core/nodes/Circle.ts

+/**
+ * Created by rockyl on 2019-07-05.
+ *
+ * (圆角)矩形
+ */
+
+import {GraphicNode} from "./GraphicNode";
+import {dirtyFieldDetector} from "../../tools/decorators";
+
+export class Circle extends GraphicNode {
+	/**
+	 * 开始角度
+	 */
+	@dirtyFieldDetector
+	startAngle: number = 0;
+
+	/**
+	 * 结束角度
+	 */
+	@dirtyFieldDetector
+	endAngle: number = 360;
+
+	/**
+	 * 是否回归到圆心
+	 */
+	@dirtyFieldDetector
+	backToCenter: boolean = true;
+
+	/**
+	 * @inheritDoc
+	 */
+	protected draw() {
+		const {currentCanvasContext, bounds: {width, height}, startAngle, endAngle, backToCenter, _margin, _useCacheMode} = this;
+		let offset = _useCacheMode ? _margin : 0;
+
+		const radius = Math.min(width, height) / 2;
+		const pos = offset + radius;
+
+		if(startAngle == 0 && endAngle == 360){
+			currentCanvasContext.arc(pos, pos, radius, 0, 2 * Math.PI);
+		}else{
+			if(backToCenter){
+				currentCanvasContext.moveTo(pos, pos);
+			}
+			currentCanvasContext.arc(pos, pos, radius, startAngle * Math.PI / 180, endAngle * Math.PI / 180);
+			if(backToCenter){
+				currentCanvasContext.lineTo(pos, pos);
+			}
+		}
+
+		super.draw();
+	}
+}

src/core/nodes/GraphicNode.ts

+/**
+ * Created by rockyl on 2019-07-05.
+ *
+ * 绘制节点
+ */
+
+import {Node} from "../Node";
+import {dirtyFieldDetector} from "../../tools/decorators";
+import {color} from "../../ReType";
+
+export class GraphicNode extends Node {
+	/**
+	 * 填充颜色
+	 */
+	@dirtyFieldDetector
+	fillColor: color = '#42bce4';
+	/**
+	 * 边框颜色
+	 */
+	@dirtyFieldDetector
+	borderColor: color = 'white';
+	/**
+	 * 边框宽度
+	 */
+	@dirtyFieldDetector
+	borderWidth = 0;
+
+	/**
+	 * 是否为mask
+	 */
+	@dirtyFieldDetector
+	isMask = false;
+	/**
+	 * 是否显示mask
+	 */
+	@dirtyFieldDetector
+	maskVisible = false;
+
+	useCacheMode = true;
+
+	protected getUseCacheMode(){
+		return this._useCacheMode && !this.isMask;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	protected beforeDraw() {
+		super.beforeDraw();
+
+		this.applyStyle();
+		this.currentCanvasContext.beginPath();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	protected draw(context) {
+		super.draw(context);
+
+		if (this.isMask) {
+			this._context.clip();
+			this.maskVisible && this.fillAndStoke()
+		} else {
+			this.fillAndStoke()
+		}
+	}
+
+	/**
+	 * 应用渲染样式
+	 */
+	protected applyStyle() {
+		const {currentCanvasContext, fillColor, borderColor, borderWidth} = this;
+
+		currentCanvasContext.fillStyle = fillColor;
+		if (borderWidth > 0) {
+			currentCanvasContext.strokeStyle = borderColor;
+			currentCanvasContext.lineWidth = borderWidth;
+		}
+	}
+
+	/**
+	 * 绘制
+	 */
+	protected fillAndStoke() {
+		const {currentCanvasContext, borderWidth} = this;
+
+		currentCanvasContext.fill();
+		if (borderWidth > 0) {
+			currentCanvasContext.stroke();
+		}
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	protected drawClip() {
+		this.isMask && this.currentCanvasContext.save();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	onRegression() {
+		this.isMask && this.currentCanvasContext.restore();
+	}
+
+	onEditorRegression(){
+		this.onRegression();
+	}
+
+}

src/core/nodes/Rect.ts

+/**
+ * Created by rockyl on 2019-07-05.
+ *
+ * (圆角)矩形
+ */
+
+import {GraphicNode} from "./GraphicNode";
+import {dirtyFieldDetector} from "../../tools/decorators";
+
+export class Rect extends GraphicNode {
+	/**
+	 * 圆角
+	 */
+	@dirtyFieldDetector
+	cornerRadius = 0;
+
+	/**
+	 * @inheritDoc
+	 */
+	protected draw(context) {
+		const {PI} = Math;
+		const {cornerRadius: r, bounds: {width, height}, _margin, _useCacheMode} = this;
+
+		let offset = _useCacheMode ? _margin : 0;
+
+		if (r) {
+			context.moveTo(offset + r, offset);
+			context.lineTo(offset + width - r, offset);
+			context.arc(offset + width - r, offset + r, r, PI * 3 / 2, PI * 2);
+			context.lineTo(offset + width, offset + height - r);
+			context.arc(offset + width - r, offset + height - r, r, 0, PI / 2);
+			context.lineTo(offset + r, offset + height);
+			context.arc(offset + r, offset + height - r, r, PI / 2, PI);
+			context.lineTo(offset, offset + r);
+			context.arc(offset + r, offset + r, r, PI, PI * 3 / 2);
+		} else {
+			context.rect(offset, offset, width, height);
+		}
+
+		super.draw(context);
+	}
+}

src/core/nodes/index.ts

+/**
+ * Created by rockyl on 2019-07-05.
+ */
+
+export * from './GraphicNode'
+export * from './Rect'
+export * from './Circle'

src/core/utils.ts

 /**
  * Created by rockyl on 2019-04-22.
  *
- * 实体相关工具
+ * 节点相关工具
  */
 
-import {Entity} from "./Entity";
-import {Component} from "./Component";
+import {Node} from "./Node";
 
 /**
- * 实体遍历(先序遍历)
- * @param target 目标实体
- * @param hitChild 遇到子实体回调
+ * 节点遍历(先序遍历)
+ * @param target 目标节点
+ * @param hitChild 遇到子节点回调
  * @param level 深度，默认全部遍历
  * @param includeSelf 是否包括自身
- * @param fullCallback 子实体遍历完后回调
+ * @param fullCallback 子节点遍历完后回调
  * @param params 其他参数
  */
-export function traverse(target: Entity, hitChild: (child: Entity, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Entity) => void, ...params) {
+export function traverse(target: Node, hitChild: (child: Node, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Node) => void, ...params) {
 	let interrupt;
 	if (includeSelf) {
 		hitChild(target, ...params);
@@ -38,15 +37,15 @@ export function traverse(target: Entity, hitChild: (child: Entity, ...params) =>
 }
 
 /**
- * 实体遍历(后序遍历且倒序)
- * @param target 目标实体
- * @param hitChild 遇到子实体回调
+ * 节点遍历(后序遍历且倒序)
+ * @param target 目标节点
+ * @param hitChild 遇到子节点回调
  * @param level 深度，默认全部遍历
  * @param includeSelf 是否包括自身
- * @param fullCallback 子实体遍历完后回调
+ * @param fullCallback 子节点遍历完后回调
  * @param params 其他参数
  */
-export function traversePostorder(target: Entity, hitChild: (child: Entity, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Entity) => void, ...params) {
+export function traversePostorder(target: Node, hitChild: (child: Node, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Node) => void, ...params) {
 	let interrupt;
 
 	if (level !== 0) {
@@ -73,19 +72,19 @@ export function traversePostorder(target: Entity, hitChild: (child: Entity, ...p
 }
 
 /**
- * 实体冒泡
- * @param target 目标实体
- * @param hitParent 遇到父实体回调
+ * 节点冒泡
+ * @param target 目标节点
+ * @param hitParent 遇到父节点回调
  * @param includeSelf 是否包括自身
  * @param params 其他参数
  */
-export function bubbling(target: Entity, hitParent: (parent: Entity, ...params) => boolean, includeSelf = false, ...params) {
+export function bubbling(target: Node, hitParent: (parent: Node, ...params) => boolean, includeSelf = false, ...params) {
 	if (includeSelf) {
 		hitParent(target, ...params);
 	}
-	let entity = target;
-	while (entity = entity.parent) {
-		if (hitParent(entity, ...params)) {
+	let node = target;
+	while (node = node.parent) {
+		if (hitParent(node, ...params)) {
 			break;
 		}
 	}

src/engine-config.ts

@@ -15,19 +15,19 @@ export const EngineConfig = {
 	 */
 	lineHeightRatio: 1.2,
 	/**
-	 * 实体实例化时enabled的初始值
+	 * 节点实例化时enabled的初始值
 	 */
-	entityEnabled: true,
+	nodeEnabled: true,
 	/**
 	 * 组件实例化时enabled的初始值
 	 */
 	componentEnabled: true,
 	/**
-	 * 组件被添加到实体树上时是否执行onAwake方法
+	 * 组件被添加到节点树上时是否执行onAwake方法
 	 */
 	awakeComponentWhenAdded: true,
 	/**
-	 * 组件从实体树上被移除时是否执行onSleep方法
+	 * 组件从节点树上被移除时是否执行onSleep方法
 	 */
 	sleepComponentWhenRemoved: true,
 	/**

src/support/Bounds.ts

@@ -18,7 +18,7 @@ export default class Bounds {
 	@dirtyFieldTrigger
 	height: number;
 
-	_onChange: Function;
+	onChange: Function;
 	
 	constructor(x: number = 0, y: number = 0, width: number = 0, height: number = 0, onChange?) {
 		this.x = x;
@@ -26,11 +26,11 @@ export default class Bounds {
 		this.width = width;
 		this.height = height;
 
-		this._onChange = onChange;
+		this.onChange = onChange;
 	}
 
 	onModify(value, key, oldValue){
-		this._onChange && this._onChange(value, key, oldValue);
+		this.onChange && this.onChange(value, key, oldValue);
 	}
 
 	get left(): number {

src/support/DataCenter.ts

@@ -68,11 +68,11 @@ export default class DataCenter extends EventEmitter {
 	 * @param expression
 	 */
 	public parse(type: string, expression: string) {
-		let entity = this.store[type];
+		let node = this.store[type];
 
 		let result = null;
 		try {
-			result = utils.dotEval(expression, entity);
+			result = utils.dotEval(expression, node);
 		} catch (e) {
 
 		}

src/support/Size.ts

@@ -8,7 +8,7 @@ import HashObject from "../core/HashObject";
 /**
  * 尺寸类
  */
-export default class Size extends HashObject{
+export default class Size extends HashObject {
 	/**
 	 * 宽度
 	 */
@@ -32,18 +32,26 @@ export default class Size extends HashObject{
 		this.height = height;
 	}
 
+	onModify(value, key, oldValue) {
+		this.onChange && this.onChange(value, key, oldValue);
+	}
+
 	/**
 	 * 置空
 	 */
-	setNaN(){
+	setNaN() {
 		this.width = NaN;
 		this.height = NaN;
 	}
 
+	isNaN() {
+		return isNaN(this.width) && isNaN(this.height);
+	}
+
 	/**
 	 * 是否空尺寸
 	 */
-	get isEmpty(){
+	get isEmpty() {
 		return this.width === 0 && this.height === 0;
 	}
 
@@ -77,8 +85,4 @@ export default class Size extends HashObject{
 		this.width = target.width;
 		this.height = target.height;
 	}
-
-	onModify(value, key, oldValue) {
-		this.onChange && this.onChange(value, key, oldValue);
-	}
 }

src/support/Vector2D.ts

@@ -5,6 +5,7 @@
 
 import {get, recycle, register} from "./ObjectPool";
 import HashObject from "../core/HashObject";
+import {dirtyFieldTrigger} from "../tools/decorators";
 
 const name = 'Vector2D';
 register(name, function () {
@@ -34,9 +35,18 @@ export function releaseVector2D(target) {
  * 2D矢量
  */
 export default class Vector2D extends HashObject {
-	private _x: number;
-	private _y: number;
-	private onChange: Function;
+	/**
+	 * x分量
+	 */
+	@dirtyFieldTrigger
+	x: number;
+	/**
+	 * y分量
+	 */
+	@dirtyFieldTrigger
+	y: number;
+
+	onChange: Function;
 
 	/**
 	 * 创建一个2D矢量
@@ -49,41 +59,11 @@ export default class Vector2D extends HashObject {
 
 		this.onChange = onChange;
 
-		this._x = 0;
-		this._y = 0;
 		this.setXY(x, y);
 	}
 
-	/**
-	 * x分量
-	 */
-	get x(): number {
-		return this._x;
-	}
-
-	set x(v: number) {
-		if (this._x !== v) {
-			const old = this._x;
-			this._x = v;
-
-			this.onChange && this.onChange(v, 'x', old);
-		}
-	}
-
-	/**
-	 * y分量
-	 */
-	get y(): number {
-		return this._y;
-	}
-
-	set y(v: number) {
-		if (this._y !== v) {
-			const old = this._y;
-			this._y = v;
-
-			this.onChange && this.onChange(v, 'y', old);
-		}
+	onModify(value, key, oldValue) {
+		this.onChange && this.onChange(value, key, oldValue);
 	}
 
 	/**

src/tools/decorators.ts

@@ -6,9 +6,9 @@
 
 /**
  * 属性修改时触发
- * @param onChange
+ * @param onModify
  */
-export function fieldChanged(onChange) {
+export function fieldChanged(onModify) {
 	return function (target: any, key: string) {
 		const privateKey = '_' + key;
 		Object.defineProperty(target, key, {
@@ -20,7 +20,7 @@ export function fieldChanged(onChange) {
 				const oldValue = this[privateKey];
 				if (oldValue !== v) {
 					this[privateKey] = v;
-					onChange.apply(this, [v, key, oldValue]);
+					onModify.apply(this, [v, key, oldValue]);
 				}
 			}
 		})
@@ -36,6 +36,21 @@ export const dirtyFieldDetector = fieldChanged(
 	}
 );
 
+/**
+ * 深度属性变脏时设置宿主的dirty属性为true
+ */
+export const deepDirtyFieldDetector = fieldChanged(
+	function (value, key, oldValue) {
+		const scope = this;
+		scope['dirty'] = true;
+		if (typeof value === 'object') {
+			value['onModify'] = function(){
+				scope['dirty'] = true;
+			};
+		}
+	}
+);
+
 /**
  * 属性变脏时触发onModify方法
  */
@@ -44,3 +59,18 @@ export const dirtyFieldTrigger = fieldChanged(
 		this['onModify'] && this['onModify'](value, key, oldValue);
 	}
 );
+
+/**
+ * 深入属性变脏时触发onModify方法
+ */
+export const deepDirtyFieldTrigger = fieldChanged(
+	function (value: any, key, oldValue) {
+		if (this['onModify']) {
+			this['onModify'](value, key, oldValue);
+
+			if (typeof value === 'object') {
+				value['onModify'] = this['onModify'];
+			}
+		}
+	}
+);