Skip to content

S
scilla-core
Commit 3b34d398 authored by rockyl's avatar rockyl
Browse files
Options

优化

parent 82bc2481
Show whitespace changes
Inline Side-by-side
Showing with 126 additions and 1657 deletions
src/core/Component.ts
View file @ 3b34d398
......@@ -3,8 +3,8 @@
*/
import HashObject from "./HashObject";
import {Node,} from "./nodes/Node";
import {EngineConfig} from "../engine-config";
import {Entity} from "./Entity";
const interactiveMap = [
'_dealGlobalTouchBegin',
......@@ -17,9 +17,9 @@ const interactiveMap = [
*/
export class Component extends HashObject {
/**
* 所依附的节点
* 所依附的实体
*/
node: Node;
entity: Entity;
protected delayCallbacks = [];
//是否有效
......@@ -37,7 +37,7 @@ export class Component extends HashObject {
set enabled(value: boolean) {
if (this._enabled !== value) {
this._enabled = value;
if (this.node && this.node.isActive) {
if (this.entity && this.entity.isActive) {
if (!EngineConfig.editorMode) {
if (this._enabled) {
this.onEnable();
......@@ -50,18 +50,18 @@ export class Component extends HashObject {
}
/**
* 装配节点
* @param node
* 装配实体
* @param entity
*/
_setup(node: Node) {
this.node = node;
_setup(entity: Entity) {
this.entity = entity;
}
/**
* 卸载节点
* 卸载实体
*/
_unSetup() {
this.node = null;
this.entity = null;
}
/**
......@@ -111,12 +111,12 @@ export class Component extends HashObject {
this.onEditorUpdate(t);
}
$onRegression() {
this.onRegression();
$afterUpdate() {
this.afterUpdate();
}
$onEditorRegression() {
this.onEditorRegression();
$afterEditorUpdate() {
this.afterEditorUpdate();
}
private invokeDelayCallback(t) {
......@@ -144,13 +144,13 @@ export class Component extends HashObject {
}
/**
* 当子节点的时钟更新结束后
* 当子实体的时钟更新结束后
*/
onRegression() {
afterUpdate() {
}
onEditorRegression() {
afterEditorUpdate() {
}
......@@ -273,7 +273,7 @@ export class Component extends HashObject {
* @param params 参数
*/
broadcast(method, level = -1, ...params) {
this.node.broadcast(method, level, ...params);
this.entity.broadcast(method, level, ...params);
}
/**
......@@ -283,6 +283,6 @@ export class Component extends HashObject {
* @param params 参数
*/
bubbling(method, ...params) {
this.node.bubbling(method, ...params);
this.entity.bubbling(method, ...params);
}
}
src/core/Entity.ts
View file @ 3b34d398
......@@ -122,6 +122,14 @@ export class Entity extends EventDispatcher {
//----- tree
/**
* 清空所有子实体和所有组件
*/
clean(){
this.removeChildren();
this.removeAllComponents();
}
/**
* 获取父实体
*/
......
src/core/ScillaEngine.ts
View file @ 3b34d398
......@@ -4,7 +4,6 @@
* 引擎
*/
import {Node, RootNode} from "./nodes/Node";
import {injectProp} from "../tools/utils";
import InteractContext from "./context/InteractContext";
import RenderContext, {ScaleMode} from "./context/RenderContext";
......@@ -12,6 +11,7 @@ import './requestAnimationFrame';
import {AssetsManager} from "../assets-manager";
import {traverse, traversePostorder} from "./utils";
import DataCenter from "../support/DataCenter";
import {Entity, RootEntity} from "./Entity";
/**
* 引擎类
......@@ -36,7 +36,7 @@ export class ScillaEngine {
*/
readonly dataCenterConfig: any = {};
private _root: RootNode;
private _root: RootEntity;
private _canvasElement: HTMLCanvasElement;
private _flush = 0;
......@@ -139,7 +139,7 @@ export class ScillaEngine {
onUpdateScale: this.onUpdateScale.bind(this),
});
this._root = new RootNode(this);
this._root = new RootEntity(this);
this._root._restrict();
}
......@@ -163,19 +163,19 @@ export class ScillaEngine {
}
/**
* 获取根Node
* 获取根Entity
*/
get root(): Node {
get root(): Entity {
return this._root;
}
/**
* 获取节点路径
* @param node
* 获取实体路径
* @param entity
*/
getNodePath(node?: Node): string {
getEntityPath(entity?: Entity): string {
let path = '';
let current = node || this._root;
let current = entity || 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
*/
getNodeByPath(path?: string): Node {
getEntityByPath(path?: string): Entity {
let target = this._root;
if (path.length > 0) {
......@@ -308,7 +308,7 @@ export class ScillaEngine {
return true;
}
}, -1, true, function (current) {
current.onRegression();
current.$afterUpdate();
});
for (let i = 0, li = this.nextTicks.length; i < li; i++) {
......@@ -356,7 +356,7 @@ export class ScillaEngine {
}
/**
* 射线测试获取节点
* 射线测试获取实体
* 注：暂时只用在编辑器内
*/
getEntitiesByRayTest(x, y, ignoreMask = true) {
......
src/core/Texture.ts
View file @ 3b34d398
......@@ -104,8 +104,6 @@ export default class Texture extends HashObject {
drawToCanvas(context: CanvasRenderingContext2D, dx = 0, dy = 0, sx?, sy?, dw?, dh?) {
const {x, y, width, height, offX, offY} = this;
console.log(x, y, width, height);
console.log(sx || x, sy || y, width, height, dx + offX, dy + offY, dw || width, dh || height);
context.drawImage(this.img, sx || x, sy || y, width, height, dx + offX, dy + offY, dw || width, dh || height);
}
......
src/core/index.ts
View file @ 3b34d398
......@@ -3,8 +3,8 @@
*/
export {Component} from "./Component";
export {Node, RootNode} from './nodes/Node'
export {ScillaEvent} from './ScillaEvent'
export {Entity, RootEntity} from './Entity'
export {createCanvas, ScaleMode} from './context/RenderContext';
export {default as engine, ScillaEngine} from './ScillaEngine'
......@@ -13,4 +13,3 @@ export * from './Sheet'
export * from './FrameAnimation'
export * from './interpreter'
export * from './nodes'
src/core/interpreter.ts
View file @ 3b34d398
......@@ -4,13 +4,13 @@
* 配置文件解释器
*/
import {Node} from "./nodes/Node";
import {Entity} from "./Entity";
import {ScillaEvent} from "../core/ScillaEvent";
import {EngineConfig} from "../engine-config";
import engine from "./ScillaEngine";
import {traverse} from "./utils";
let nodeMap = {};
let entityMap = {};
let prefabID: number = 0;
let _getResProxy: Function;
......@@ -24,7 +24,7 @@ export function setGetResProxy(func: Function) {
* @param root
* @param getResProxy
*/
export function setupScene(config: any, root: Node, getResProxy: Function) {
export function setupScene(config: any, root: Entity, getResProxy: Function) {
setGetResProxy(getResProxy);
instantiateConfig(config, root);
......@@ -34,75 +34,70 @@ export function setupScene(config: any, root: Node, getResProxy: Function) {
* 装配预制体
* @param config
*/
export function instantiate(config: any): Node {
export function instantiate(config: any): Entity {
let pid = ++prefabID;
const node = instantiateConfig(config, null, pid);
const entity = instantiateConfig(config, null, pid);
return node.children[0];
return entity.children[0];
}
/**
* 装配树节点
* 装配树实体
* @param config
* @param root
* @param pid
*/
function instantiateConfig(config, root?: Node, pid?: number): Node {
function instantiateConfig(config, root?: Entity, pid?: number): Entity {
let rootConfig = config.root;
const node = setupNode(rootConfig, root, pid);
setupComponent(rootConfig, node, true);
injectComponent(rootConfig, node, true, pid);
const entity = setupEntity(rootConfig, root, pid);
setupComponent(rootConfig, entity, true);
injectComponent(rootConfig, entity, true, pid);
traverse(node, child => {
traverse(entity, child => {
child.active();
return false;
});
nodeMap = {};
entityMap = {};
return node;
return entity;
}
/**
* 装配节点
* 装配实体
* @param config
* @param root
* @param pid
*/
function setupNode(config, root?: Node, pid?: number): Node {
let node: Node = null;
function setupEntity(config, root?: Entity, pid?: number): Entity {
let entity: Entity = null;
if (config) {
let {name, uuid, children, base} = config;
let {name, uuid, children} = config;
if (pid !== undefined && uuid !== undefined) {
uuid = pid + '_' + uuid;
}
if (root) {
node = root;
} else {
let temp = engine.getDefByName(base);
node = new temp(name, uuid);
}
entity = root || new Entity(name, uuid);
nodeMap[uuid] = node;
entityMap[uuid] = entity;
if (children) {
for (let i = 0, li = children.length; i < li; i++) {
let child = children[i];
const childNode = setupNode(child, null, pid);
node.addChild(childNode);
const childEntity = setupEntity(child, null, pid);
entity.addChild(childEntity);
}
}
if (!root) {
node.enabled = !config.disabled;
entity.enabled = !config.disabled;
}
}
return node;
return entity;
}
/**
......@@ -111,18 +106,18 @@ function setupNode(config, root?: Node, pid?: number): Node {
* @param root
* @param includeSelf
*/
function setupComponent(config, root: Node, includeSelf: boolean = false) {
function setupComponent(config, root: Entity, 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 node = root.children[i];
const entity = root.children[i];
instantiateComponents(node, child);
instantiateComponents(entity, child);
setupComponent(child, node);
setupComponent(child, entity);
}
}
}
......@@ -134,46 +129,44 @@ function setupComponent(config, root: Node, includeSelf: boolean = false) {
* @param includeSelf
* @param pid
*/
function injectComponent(config, root: Node, includeSelf = false, pid?: number) {
function injectComponent(config, root: Entity, 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 node = root.children[i];
const entity = root.children[i];
injectComponents(node, child, pid);
injectComponents(entity, child, pid);
injectComponent(child, node, false, pid);
injectComponent(child, entity, false, pid);
}
}
}
/**
* 实例化组件列表
* @param node
* @param entity
* @param config
*/
function instantiateComponents(node: Node, config: any) {
function instantiateComponents(entity: Entity, config: any) {
if (config.components) {
for (const component of config.components) {
instantiateComponent(node, component);
instantiateComponent(entity, component);
}
}
}
/**
* 注入组件列表参数
* @param node
* @param entity
* @param config
* @param pid
*/
function injectComponents(node: Node, config: any, pid?: number) {
injectComponentProperties(node, config, pid);
function injectComponents(entity: Entity, config: any, pid?: number) {
if (config.components) {
const components = node.components;
const components = entity.components;
for (let i = 0, li = config.components.length; i < li; i++) {
const component = config.components[i];
......@@ -198,10 +191,10 @@ export function injectComponentProperties(component, config, pid?: number) {
/**
* 实例化组件
* @param node
* @param entity
* @param config
*/
export function instantiateComponent(node: Node, config: any) {
export function instantiateComponent(entity: Entity, config: any) {
const {script,} = config;
let def = engine.getDefByName(script);
......@@ -212,7 +205,7 @@ export function instantiateComponent(node: Node, config: any) {
const instance: any = new def();
instance.enabled = !config.disabled;
node.addComponent(instance);
entity.addComponent(instance);
return instance;
}
......@@ -221,13 +214,13 @@ const skipKeys = ['_type_', '_constructor_'];
/**
* 属性注入
* @param node
* @param entity
* @param propertiesConfig
* @param pid
*/
function injectProperties(node, propertiesConfig, pid?: number) {
if (!node) {
console.warn('node is null.');
function injectProperties(entity, propertiesConfig, pid?: number) {
if (!entity) {
console.warn('entity is null.');
return;
}
for (const key in propertiesConfig) {
......@@ -235,22 +228,22 @@ function injectProperties(node, propertiesConfig, pid?: number) {
continue;
}
const propertyOfConfig: any = propertiesConfig[key];
let propertyOfInstance = node[key];
let propertyOfInstance = entity[key];
if (typeof propertyOfConfig === 'object') {
if (propertyOfInstance instanceof ScillaEvent) {
if (!EngineConfig.editorMode) {
injectEvent(propertyOfInstance, propertyOfConfig, pid);
}
} else if (propertyOfConfig._type_ === 'raw') {
node[key] = propertyOfInstance = propertyOfConfig.data;
entity[key] = propertyOfInstance = propertyOfConfig.data;
} else {
if (Array.isArray(propertyOfConfig) && !propertyOfInstance) {
node[key] = propertyOfInstance = []
entity[key] = propertyOfInstance = []
}
node[key] = injectObject(propertyOfInstance, propertyOfConfig, pid);
entity[key] = injectObject(propertyOfInstance, propertyOfConfig, pid);
}
} else {
injectBaseType(node, key, propertyOfConfig, pid);
injectBaseType(entity, key, propertyOfConfig, pid);
}
}
}
......@@ -275,7 +268,7 @@ function injectObject(propertyOfInstance, propertyOfConfig, pid?: number) {
return propertyOfInstance;
}
function injectBaseType(node, key, propertyOfConfig, pid?: number) {
function injectBaseType(entity, key, propertyOfConfig, pid?: number) {
let propertyValue;
if (typeof propertyOfConfig === 'string') {
propertyValue = getLink(propertyOfConfig, pid);
......@@ -289,23 +282,23 @@ function injectBaseType(node, key, propertyOfConfig, pid?: number) {
}
if (typeof propertyValue === 'function') {
Object.defineProperty(node, keyAvatar, {
Object.defineProperty(entity, keyAvatar, {
get() {
return this[`func_${keyAvatar}`](node, engine.dataCenter)
return this[`func_${keyAvatar}`](entity, engine.dataCenter)
},
set(v) {
this[`func_${keyAvatar}`] = v;
}
})
}
node[keyAvatar] = propertyValue;
entity[keyAvatar] = propertyValue;
}
function injectEvent(event: ScillaEvent, config, pid?) {
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];
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];
const method = component[methodName];
if (method) {
if (param == undefined) {
......@@ -323,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('node|') == 0) { //node uuid
} else if (str.indexOf('entity|') == 0) { //entity uuid
const uuid = transPrefabUUID(str.substr(7), pid);
result = nodeMap[uuid];
result = entityMap[uuid];
} else if (str.indexOf('dynamic|') == 0) { //dynamic
const [_, type, expression] = str.split('|');
result = () => {
......
src/core/nodes/Circle.ts deleted 100644 → 0
View file @ 82bc2481
/**
* 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(context) {
const {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){
context.arc(pos, pos, radius, 0, 2 * Math.PI);
}else{
if(backToCenter){
context.moveTo(pos, pos);
}
context.arc(pos, pos, radius, startAngle * Math.PI / 180, endAngle * Math.PI / 180);
if(backToCenter){
context.lineTo(pos, pos);
}
}
super.draw(context);
}
}
src/core/nodes/GraphicNode.ts deleted 100644 → 0
View file @ 82bc2481
/**
* 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;
measureBounds() {
super.measureBounds();
this._margin = this.borderWidth;
}
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/Image.ts deleted 100644 → 0
View file @ 82bc2481
/**
* Created by rockyl on 2019-07-11.
*
* 图片显示类
*/
import {Node,} from "./Node";
import Texture from "../Texture";
import {deepDirtyFieldDetector, dirtyFieldDetector} from "../../tools/decorators";
import {Vector2D} from "../../support";
import Bounds from "../../support/Bounds";
import {Sheet} from "../Sheet";
export class Image extends Node {
/**
* 纹理资源
*/
@dirtyFieldDetector
texture: Texture;
/**
* 填充模式
*/
@dirtyFieldDetector
fillMode: FillMode = FillMode.NORMAL;
/**
* tiled模式的偏移
*/
@deepDirtyFieldDetector
tiledOffset: Vector2D = new Vector2D();
/**
* 切片边界配置
*/
@deepDirtyFieldDetector
slicedBounds: Bounds = new Bounds();
protected _pattern;
protected _sheetForSliced: Sheet = new Sheet();
/**
* 异步资源
* @param promise
*/
private set async_texture(promise: Promise<Texture>) {
if (!promise) {
return;
}
promise.then(
(texture) => {
this.texture = texture;
}
)
}
/**
* 重写缓存模式
*/
protected getUseCacheMode() {
return this._useCacheMode || this.fillMode === FillMode.TILED || this.fillMode === FillMode.SLICED;
}
/**
* 准备切片用的图集
*/
protected prepareSheetForSliced() {
if (this.dirty && !this.slicedBounds.isEmpty) {
const sheet = this._sheetForSliced;
sheet.cleanAllTexture();
const {sourceW, sourceH} = this.texture;
const {x, y, width, height, right, bottom} = this.slicedBounds;
const xs = [0, x, right];
const ys = [0, y, bottom];
const ws = [x, width, sourceW - right];
const hs = [y, height, sourceH - bottom];
const frames = {};
for(let i = 0; i < 9 ; i++){
let gx = i % 3;
let gy = Math.floor(i / 3);
frames[i] = {x: xs[gx], y: ys[gy], width: ws[gx], height: hs[gy],}
}
sheet.init(this.texture, frames);
sheet.generateAll();
}
}
protected draw(context) {
super.draw(context);
this.drawImage(context);
}
/**
* 根据模式绘制图片
*/
drawImage(context) {
if (!this.texture) {
return;
}
const {texture, fillMode, width, height} = this;
const {x, y, sourceW, sourceH} = texture;
let drawWidth = width, drawHeight = height;
switch (fillMode) {
case FillMode.NORMAL:
texture.drawToCanvas(context, 0, 0, undefined, undefined, width, height);
break;
case FillMode.SLICED:
this.prepareSheetForSliced();
const {x: sx, y: sy, right, bottom} = this.slicedBounds;
const rightWidth = sourceW - right;
const bottomHeight = sourceH - bottom;
const xs = [0, sx, drawWidth - rightWidth];
const ys = [0, sy, drawHeight - bottomHeight];
const ws = [sx, drawWidth - sx - rightWidth, rightWidth];
const hs = [sy, drawHeight - sy - bottomHeight, bottomHeight];
for (let i = 0; i < 9; i++) {
const slicedTexture = this._sheetForSliced.getTexture(i);
let gx = i % 3;
let gy = Math.floor(i / 3);
console.log(xs[gx], ys[gy]);
slicedTexture.drawToCanvas(context, xs[gx], ys[gy], undefined, undefined, ws[gx], hs[gy]);
}
break;
case FillMode.TILED:
if (!this._pattern || texture['isDirty']) {
const textureCanvas = texture.getCacheCanvas();
this._pattern = context.createPattern(textureCanvas, 'repeat');
}
if (!this.tiledOffset.isZero) {
const {x: offX, y: offY} = this.tiledOffset;
let x = offX % sourceW;
x = x > 0 ? x - sourceW : x;
let y = offY % sourceH;
y = y > 0 ? y - sourceH : y;
drawWidth -= x;
drawHeight -= y;
context.transform(1, 0, 0, 1, x, y);
}
context.beginPath();
context.rect(0, 0, drawWidth, drawHeight);
context.closePath();
context.fillStyle = this._pattern;
context.fill();
if (!this.tiledOffset.isZero) {
//ctx.restore();
}
break;
}
}
protected measureRenderSize() {
if (this.texture) {
const {sourceW, sourceH} = this.texture;
return {
width: sourceW,
height: sourceH,
}
}
}
}
export enum FillMode {
/**
* 正常
*/
NORMAL,
/**
* 九宫裁切
*/
SLICED,
/**
* 瓦片
*/
TILED,
}
src/core/nodes/Node.ts deleted 100644 → 0
View file @ 82bc2481
/**
* Created by rockyl on 2019-07-04.
*
* 节点类
*/
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';
/**
* 坐标
*/
@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;
/**
* 唯一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 _renderVisible: boolean;
/**
* 真实渲染透明度
*/
protected _renderAlpha: number;
/**
* 本地坐标缓存
*/
protected _localPos: Vector2D = new Vector2D();
/**
* 全局坐标缓存
*/
protected _globalPosition: Vector2D = new Vector2D();
/**
* 锚点实际偏移
*/
protected _anchorOffset: Vector2D = new Vector2D();
/**
* 渲染边界
*/
protected _bounds = new Bounds();
/**
* 尺寸
* 对于不同的子类渲染都有不同的效果
*/
protected _width: number = NaN;
protected _height: number = NaN;
/**
* 扩展尺寸
*/
protected _margin: number = 0;
/**
* 是否使用渲染模式
*/
protected _useCacheMode = false;
constructor(name?: string, uuid?: string) {
super();
if (name) {
this.name = name;
}
if (uuid) {
this._uuid = uuid;
}
}
/**
* 当属性更新时
* @param value
* @param key
* @param oldValue
*/
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;
}
/**
* 是否有效状态
*/
get enabled(): boolean {
return this._enabled;
}
set enabled(value: boolean) {
if (this._enabled !== value) {
this.setEnabled(value);
}
}
protected setEnabled(value) {
this._enabled = value;
let that = this;
traverse(this, function (child: Node) {
if (child !== that && !child._enabled) {
return true;
}
child._invokeEnabledState(value);
return false;
}, -1, true)
}
_invokeEnabledState(enabled: boolean) {
if (this._enabled) {
if (enabled) {
this.onEnable();
} else {
this.onDisable();
}
}
}
get isParentActive(): boolean {
return this._parent && this._parent.enabled && !this._parent.isFree;
}
get isActive(): boolean {
return this.isParentActive && this._enabled;
}
/**
* 是否游离状态
*/
get isFree(): boolean {
return this._isFree;
}
/**
* 使游离
*/
_free() {
this._isFree = true;
traverse(this, function (child: Node) {
if (child.isParentActive) {
child._invokeEnabledState(false);
}
child._free();
return false;
}, 1)
}
/**
* 使约束
*/
_restrict() {
this._isFree = false;
traverse(this, function (child: Node) {
if (child.isParentActive) {
child._invokeEnabledState(true);
}
child._restrict();
return false;
}, 1)
}
/**
* 添加子节点时
* @param child
* @private
*/
protected _onChildAdded(child: Node) {
child._parent = this;
if (!this._isFree && child._isFree) {
if (child.isParentActive) {
child._invokeEnabledState(true);
}
child._restrict();
}
}
/**
* 子节点被移除时
* @param child
* @private
*/
_onChildRemoved(child: Node) {
child._parent = null;
if (!this._isFree && !child._isFree) {
if (child.isActive) {
child._invokeEnabledState(false);
}
child._free();
}
}
/**
* 添加子节点，重复添加则会加到最后
* @param child
*/
addChild(child: Node) {
this.addChildAt(child, this._children.length);
}
/**
* 添加子节点到指定索引，重复添加可作为顺序交换
* @param child
* @param index
*/
addChildAt(child: Node, index) {
if (child.parent && child.parent !== this) {
child.parent.removeChild(child);
}
const currentIndex = this.getChildIndex(child);
if (index < 0 || currentIndex == index) { //如果索引小于0或没变化
return;
}
index = Math.min(this._children.length, index);
if (currentIndex >= 0 || index < this._children.length) {
if (currentIndex >= 0) {
this._children.splice(currentIndex, 1);
}
this._children.splice(index, 0, child);
} else {
this._children.push(child);
}
this._onChildAdded(child);
}
/**
* 移除节点
* @param child
*/
removeChild(child: Node) {
const index = this.getChildIndex(child);
if (index >= 0) {
return this.removeChildAt(index);
}
}
/**
* 移除指定索引的节点
* @param index
*/
removeChildAt(index: number) {
const child = this._children[index];
if (child) {
this._onChildRemoved(child);
this._children.splice(index, 1);
return child;
}
}
/**
* 根据节点获取索引
* @param child
*/
getChildIndex(child: Node): number {
return this._children.indexOf(child)
}
/**
* 获取指定索引的节点
* @param index
*/
getChildAt(index): Node {
return this._children[index];
}
/**
* 获取指定名字的节点
* @param name
*/
getChildrenByName(name): Node[] {
let children = [];
for (let child of this._children) {
if (child.name === name) {
children.push(child);
}
}
return children;
}
/**
* 移除所有子节点
*/
removeChildren() {
while (this._children.length > 0) {
this.removeChildAt(0);
}
}
/**
* 获取所有子节点
*/
get children(): Node[] {
return this._children;
}
/**
* 获取唯一ID
*/
get uuid(): string {
return this._uuid;
}
/**
* 移除所有组件和子节点
*/
clean() {
this.removeAllComponents();
this.removeChildren();
}
//----- component
/**
* 增加组件
* @param component
*/
addComponent(component: Component) {
this.onAddComponent(component);
this._components.push(component);
}
/**
* 在指定索引增加组件，重复添加可作为顺序交换
* @param component
* @param index
*/
addComponentAt(component: Component, index: number) {
const currentIndex = this._components.indexOf(component);
if (currentIndex == index) {
return;
}
if (currentIndex >= 0) {
this._components.splice(currentIndex, 1);
}
this._components.splice(index, 0, component);
this.onAddComponent(component);
}
/**
* 移除组件
* @param component
*/
removeComponent(component: Component) {
this.onRemoveComponent(component);
const index = this._components.indexOf(component);
if (index >= 0) {
this._components.splice(index, 1);
}
}
/**
* 移除所有组件
*/
removeAllComponents() {
while (this._components.length > 0) {
this.removeComponent(this._components[0]);
}
}
/**
* 根据组件名称获取指定类的组件列表
* @param name
*/
getComponentsByName<T extends Component>(name: string): T[] {
return <T[]>this._components.filter((value: Component) => {
return value.constructor['__class__'] === name;
});
}
/**
* 获取指定类的组件列表
* @param clazz
*/
getComponents<T extends Component>(clazz: new() => T): T[] {
return <T[]>this._components.filter((component: Component) => {
return component instanceof clazz;
});
}
/**
* 获取指定类的组件
* @param name
*/
getComponentByName<T extends Component>(name: string): T {
return this.getComponentsByName<T>(name)[0];
}
/**
* 获取指定类的组件
* @param clazz
*/
getComponent<T extends Component>(clazz: new() => T): T {
return this.getComponents<T>(clazz)[0];
}
/**
* 获取所有组件
*/
get components(): Component[] {
return this._components;
}
//----- lifecycle
/**
* 遍历所有组件
* @param func
*/
forEachComponent(func: (component) => boolean) {
for (let component of this._components) {
if (func(component)) {
break;
}
}
}
active() {
this.forEachComponent(comp => {
if (comp.enabled) {
return comp.onCreate();
}
});
}
/**
* 当组件生效时
*/
onEnable() {
this.forEachComponent(comp => {
if (comp.enabled) {
return comp.$onAwake();
}
});
}
/**
* 当组件失效时
*/
onDisable() {
this.forEachComponent(comp => {
if (comp.enabled) {
return comp.$onSleep();
}
});
}
/**
* 当时钟更新时
* @param t
*/
$onUpdate(t) {
if (!this.enabled) {
return;
}
this.preUpdate(t);
this.updateComponents(t);
this.onUpdate(t);
this.windUpUpdate(t);
}
/**
* 当子节点遍历回归
*/
onRegression() {
this.forEachComponent(comp => {
if (comp.enabled) {
if (EngineConfig.editorMode) {
return comp.$onEditorRegression();
} else {
return comp.$onRegression();
}
}
});
}
/**
* 当交互时
* @param type
* @param event
*/
onInteract(type, event) {
if (!this.isFree && this.enabled) {
let interrupt = false;
this.forEachComponent(comp => {
if (comp.enabled && comp.interactable) {
const r = comp.onInteract(type, event);
if (r) {
interrupt = true;
}
return false;
}
});
return interrupt;
} else {
return false;
}
}
/**
* 当添加组件时
* @param component
*/
onAddComponent(component: Component) {
component._setup(this);
if (EngineConfig.awakeComponentWhenAdded) {
this.awakeComponent(component);
}
}
/**
* 唤醒组件
* @param component
*/
awakeComponent(component) {
if (!this._isFree && this._enabled) {
component.$onAwake();
}
}
/**
* 当移除组件时
* @param component
*/
onRemoveComponent(component: Component) {
if (EngineConfig.sleepComponentWhenRemoved) {
this.sleepComponent(component);
}
component._unSetup();
}
/**
* 睡眠组件
* @param component
*/
sleepComponent(component: Component) {
if (!this._isFree && this._enabled) {
component.$onSleep();
}
}
/**
* 向下广播
* 如果某组件调用后返回true，将结束整条链
* @param method 方法名
* @param level 深度，默认全部遍历
* @param params 参数
*/
broadcast(method: string, level = -1, ...params) {
traverse(this, this.invokeOnNode, level, true, null, method, ...params)
}
/**
* 向上冒泡
* 如果某组件调用后返回true，将结束整条链
* @param method 方法名
* @param params 参数
*/
bubbling(method: string, ...params) {
bubbling(this, this.invokeOnNode, false, method, ...params);
}
/**
* 调用节点上的组件的方法
* @param hitNode 遇到的节点
* @param method 方法名
* @param params 参数
*/
private invokeOnNode = (hitNode: Node, method: string, ...params): boolean => {
let hitBreak = false;
hitNode.forEachComponent(comp => {
const m = comp[method];
if (m) {
const result = m.apply(comp, params);
if (result) {
hitBreak = true;
}
}
return false;
});
if (hitBreak) {
return true;
}
};
//-----Update
/**
* 预更新
* @param t
*/
protected preUpdate(t) {
}
/**
* 组件更新
* @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) {
if (this.dirty) {
this.updateLocalMatrix();
}
this.updateGlobalMatrix();
if (this.dirty) {
if (this.useCacheMode) {
this.readyCacheCanvas();
}
this.measureBounds();
if (this.useCacheMode) {
this.updateCacheCanvas();
}
}
this.transformToLocal();
if (this._renderVisible) {
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, anchor: {x, y}} = this;
let renderSize: any = this.measureRenderSize();
bounds.width = isNaN(explicitWidth) ? renderSize ? renderSize.width : 0 : explicitWidth;
bounds.height = isNaN(explicitHeight) ? renderSize ? renderSize.height : 0 : explicitHeight;
const anchorOffsetX = this._anchorOffset.x = bounds.width * x;
const anchorOffsetY = this._anchorOffset.y = bounds.height * y;
bounds.x = -anchorOffsetX;
bounds.y = -anchorOffsetY;
}
/**
* 测量渲染尺寸
*/
protected measureRenderSize() {
return;
}
/**
* 渲染过程
*/
protected render() {
this.applyAlpha();
this.beforeDraw();
this.drawClip();
if (this.dirty) {
if (this.useCacheMode) {
this.draw(this.currentCanvasContext);
}
}
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 renderVisible(): boolean {
return this._renderVisible;
}
/**
* 渲染边界
*/
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;
this._renderVisible = parent.renderVisible && this.visible;
_globalMatrix.concat(parent.getMatrix(false));
} else {
this._renderAlpha = this.alpha;
this._renderVisible = this.visible;
}
}
/**
* 执行矩阵转换
*/
protected transformToLocal() {
const {_anchorOffset: {x: ax, y: ay}} = this;
const {a, b, c, d, tx, ty} = this.getMatrix(false, true);
const offX = ax * a + ay * c;
const offY = ax * b + ay * d;
this.context.setTransform(a, b, c, d, tx - offX, ty - offY);
}
/**
* 获取渲染上下文
* 如果缓存上下文存在，则返回缓存上下文
*/
protected get currentCanvasContext() {
return this._cacheContext || this.context;
}
}
/**
* 根节点类
*/
export class RootNode extends Node {
protected _engine: ScillaEngine;
constructor(engine: ScillaEngine) {
super();
this.name = 'root';
this._engine = engine;
}
/**
* 获取引擎，只有活动的root节点才有这个属性
*/
get engine() {
return this._engine;
}
}
src/core/nodes/Rect.ts deleted 100644 → 0
View file @ 82bc2481
/**
* 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 deleted 100644 → 0
View file @ 82bc2481
/**
* Created by rockyl on 2019-07-05.
*/
export * from './Node'
export * from './GraphicNode'
export * from './Rect'
export * from './Circle'
export * from './Image'
src/core/utils.ts
View file @ 3b34d398
/**
* Created by rockyl on 2019-04-22.
*
* 节点相关工具
* 实体相关工具
*/
import {Node} from "./nodes/Node";
import {Entity} from "./Entity";
/**
* 节点遍历(先序遍历)
* @param target 目标节点
* @param hitChild 遇到子节点回调
* 实体遍历(先序遍历)
* @param target 目标实体
* @param hitChild 遇到子实体回调
* @param level 深度，默认全部遍历
* @param includeSelf 是否包括自身
* @param fullCallback 子节点遍历完后回调
* @param fullCallback 子实体遍历完后回调
* @param params 其他参数
*/
export function traverse(target: Node, hitChild: (child: Node, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Node) => void, ...params) {
export function traverse(target: Entity, hitChild: (child: Entity, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Entity) => void, ...params) {
let interrupt;
if (includeSelf) {
hitChild(target, ...params);
......@@ -37,15 +37,15 @@ export function traverse(target: Node, hitChild: (child: Node, ...params) => boo
}
/**
* 节点遍历(后序遍历且倒序)
* @param target 目标节点
* @param hitChild 遇到子节点回调
* 实体遍历(后序遍历且倒序)
* @param target 目标实体
* @param hitChild 遇到子实体回调
* @param level 深度，默认全部遍历
* @param includeSelf 是否包括自身
* @param fullCallback 子节点遍历完后回调
* @param fullCallback 子实体遍历完后回调
* @param params 其他参数
*/
export function traversePostorder(target: Node, hitChild: (child: Node, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Node) => void, ...params) {
export function traversePostorder(target: Entity, hitChild: (child: Entity, ...params) => boolean, level = -1, includeSelf = false, fullCallback?: (current: Entity) => void, ...params) {
if (level !== 0) {
for (let i = target.children.length - 1; i >= 0; i--) {
const child = target.children[i];
......@@ -70,19 +70,19 @@ export function traversePostorder(target: Node, hitChild: (child: Node, ...param
}
/**
* 节点冒泡
* @param target 目标节点
* @param hitParent 遇到父节点回调
* 实体冒泡
* @param target 目标实体
* @param hitParent 遇到父实体回调
* @param includeSelf 是否包括自身
* @param params 其他参数
*/
export function bubbling(target: Node, hitParent: (parent: Node, ...params) => boolean, includeSelf = false, ...params) {
export function bubbling(target: Entity, hitParent: (parent: Entity, ...params) => boolean, includeSelf = false, ...params) {
if (includeSelf) {
hitParent(target, ...params);
}
let node = target;
while (node = node.parent) {
if (hitParent(node, ...params)) {
let entity = target;
while (entity = entity.parent) {
if (hitParent(entity, ...params)) {
break;
}
}
......
src/engine-config.ts
View file @ 3b34d398
......@@ -15,19 +15,19 @@ export const EngineConfig = {
*/
lineHeightRatio: 1.2,
/**
* 节点实例化时enabled的初始值
* 实体实例化时enabled的初始值
*/
nodeEnabled: true,
entityEnabled: true,
/**
* 组件实例化时enabled的初始值
*/
componentEnabled: true,
/**
* 组件被添加到节点树上时是否执行onAwake方法
* 组件被添加到实体树上时是否执行onAwake方法
*/
awakeComponentWhenAdded: true,
/**
* 组件从节点树上被移除时是否执行onSleep方法
* 组件从实体树上被移除时是否执行onSleep方法
*/
sleepComponentWhenRemoved: true,
/**
......
src/support/DataCenter.ts
View file @ 3b34d398
......@@ -68,11 +68,11 @@ export default class DataCenter extends EventEmitter {
* @param expression
*/
public parse(type: string, expression: string) {
let node = this.store[type];
let entity = this.store[type];
let result = null;
try {
result = utils.dotEval(expression, node);
result = utils.dotEval(expression, entity);
} catch (e) {
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment