CocosPlugin/cocos-animator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix:编辑器文件导入. add:example,runtime

Browse Source
This commit is contained in:
YipLee
2021-01-24 19:29:37 +08:00
parent c232a91a41
commit 91f4d8011b
214 changed files with 41328 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
README.md
View File

@@ -2,21 +2,92 @@
一个用于Cocos Creator的可视化动画状态机编辑器。<br/>
编辑器地址：https://leeyip.github.io/cocos-animator/
## 目录
- [前言](#preface)
- [项目结构](#project)
- [状态机编辑器](#editor)
- [总览](#editor1)
- [状态机视图](#editor2)
- [Parameters](#editor3)
- [Inspector](#editor4)
- [数据导入与导出](#editor5)
- [导出的数据格式](#json)
- [Runtime](#runtime)
- [Example](#example)
- [注意点](#warning)
- [参考资料](#reference)
## 前言
## 使用
## <a id="preface"></a>前言
当动画数量较多且转换规则复杂的时候，手动编写代码去处理转换逻辑会非常痛苦。用过Unity的话，都知道Unity的Animator Controller能可视化地编辑状态机，在一定程度上减轻了手写逻辑的痛苦，但是Cocos Creator目前没有提供这种便利的工具，于是便有了这个项目。<br/>
动手之前，在网上看到已经有人做了一个这种工具<sup>[[1]](#reference1)</sup>，但离我想要的效果差了一点，以及runtime的实现也有一些问题，同时我也希望能随时根据需求自由更改功能，于是便用Cocos Creator另写了一个状态机编辑器，runtime的实现也在他的基础上进行了修改。
## 注意点
- 参数名、子状态机名、状态名都不可重名
- trigger与Unity中trigger逻辑相同；autoTrigger与trigger类似，但每次状态机内部逻辑更新之后都会自动reset
- 状态机组件update会优先执行，添加了@executionOrder(-1000)
- 当transition未勾选hasExitTime以及没有添加任何condition时，transition会被忽略
- Parameters和Inspector两个界面如果内容超出，使用鼠标滚轮滚动，因为为了防止与拖拽行为产生冲突，触摸事件已被屏蔽
## 数据格式
### 1. 编辑器工程数据格式
## <a id="project"></a>项目结构
- animator-editor：状态机编辑器项目源码，使用CocosCreator2.2.2实现
- animator-runtime：解析状态机的runtime源码，里面两个目录分别用于CocosCreator2.x的项目与3.0项目
- examples：用CocosCreator2.2.2与3.0rc写的简单例子
## <a id="editor"></a>状态机编辑器
操作基本和Unity Animator类似</br>
#### <a id="editor1"></a>**总览**</br>
编辑器界面分为三个部分
![image](./images/editor1.png)</br>
- 左侧用于编辑状态机参数，参数分为number、boolean、trigger、auto trigger四种类型。
- 中间用于编辑状态、子状态机以及状态之间的连线关系，上侧的导航栏用于表示当视图状态机的层级关系，BaseLayer为根状态机。
- 右侧用于编辑状态与状态转换连线的数据。
#### <a id="editor2"></a>**状态机视图**</br>
![image](./images/operate1.gif)
![image](./images/operate2.gif)
![image](./images/operate3.gif)</br>
- 操作方式：
- 鼠标滚轮可缩放以及拖动视图
- 鼠标右键空白处可选择生成状态或子状态机节点
- 鼠标右键状态可选择生成状态转换连线、设置默认状态、删除
- 鼠标左键按住状态拖动到状态机上出现加号，即可将状态丢入状态机内
- 鼠标右键子状态机可选择删除
- 鼠标双击子状态机可进入子状态机视图
- 鼠标左键选中状态、子状态机、连线时均可用delete键删除
- 鼠标左键可以拉伸调节Parameters和Inspector两个界面宽度
- 有上下双向箭头的地方是可拖拽排序的列表
- 状态：用矩形表示，橙色为默认状态，是整个状态机运行的入口。AnyState是一种殊的状态，用于指代任意状态，仅能由AnyState将连线指向其余状态，无法将连线指向AnyState。
- 子状态机：用六边形表示，内部包含默认状态则显示为橙色，名字中带有(up)的状态机为当前视图的父状态机。
#### <a id="editor3"></a>**Parameters**</br>
用于编辑状态机参数，可填写初始值表示状态机开始运行时的参数状态
- **number** 数字输入框
- **boolean** 方形勾选框
- **trigger** 圆形勾选框，与Unity中trigger表现一致，内部是一个boolean，在满足包含trigger条件的状态转换时会自动resetTrigger
- **auto trigger** 菱形勾选框，在满足状态转换时以及每帧状态机逻辑更新时都会自动reset为false
#### <a id="editor4"></a>**Inspector**</br>
用于编辑状态以及连线数据</br>
- **Name**--状态/状态机名</br>
- **Motion**--状态对应的动画名</br>
- **Speed**--动画播放速度</br>
- **Multiplier**--动画播放速度混合的number类型参数</br>
- **Loop**--动画是否循环播放</br>
- **Transitions**（连线数据）：
- 记录状态间的转换关系（当前状态->目标状态）
- **优先级**：同一个状态有多个transition的情况下，优先满足哪一个就先转向对应的目标状态，若同时满足多个transition，则以列表中从上往下的排序决定优先级（选中状态时才可以拖拽排序）
- **Has Exit Time**打勾则表示会等待动画播放结束才能转向下一状态
- **Conditions**（转换条件）：所有条件都是逻辑与的关系，必须同时满足所选择的逻辑关系（若勾选了Has Exit Time，还需等待动画播放完毕）才能转向下一状态
#### <a id="editor5"></a>**数据导入与导出**
- 导出数据
- **ctrl+s**--导出状态机编辑器工程文件（此文件记录了编辑器与runtime所需的所有数据，此文件必须保存好）
- **ctrl+e**--仅导出runtime所需的数据文件
- 导入数据
- 将ctrl+s所保存文件拖入状态机编辑器内将还原整个状态机视图
- cocos creator的animation文件、spine的json文件、dragonbones的json文件均可拖入状态机编辑器内自动生成对应的状态节点
![image](./images/operate4.gif)
#### <a id="json"></a>导出的数据格式
- 状态机编辑器工程数据格式
```
{
/** 编辑器版本号 */
@@ -120,7 +191,7 @@
}
```
### 2. runtime解析所需的数据格式
- runtime解析所需的数据格式
```
{
parameters: [
@@ -170,3 +241,105 @@
];
}
```
## <a id="runtime"></a>Runtime
只要将对应版本的runtime整个文件夹丢入项目中即可使用。</br>
core中是runtime的核心实现，而AnimatorAnimation、AnimatorSpine、AnimatorDragonBones、AnimatorCustomization是用于与节点绑定的cc.Component脚本，分别用于不同类型的动画。</br>
- **Animator脚本组件 API**
- **onInit** 手动初始化状态机
- **manualUpdate** 手动调用更新
- **setBool** 设置boolean类型参数的值
- **getBool** 获取boolean类型参数的值
- **setNumber** 设置number类型参数的值
- **getNumber** 获取number类型参数的值
- **setTrigger** 设置trigger类型参数的值
- **resetTrigger** 重置trigger类型参数的值
- **autoTrigger** 设置autoTrigger类型参数的值
- **play** 无视条件直接跳转状态
- **curStateName** 当前状态名
- **curStateMotion** 当前动画名
## <a id="example"></a>Example
![image](./images/runtime1.png)</br>
- **AssetRawUrl** 拖入状态机编辑器导出的文件（两种文件均可，但ctrl+e导出的文件更小）
- **PlayOnStart** 如果勾选则自动初始化状态机，否则需要主动调用onInit去初始化
- **AutoUpdate** 如果勾选则自动每帧更新状态机逻辑，否则需要主动调用manualUpdate去更新
#### 绑定脚本后只需要在对应的点设置参数值，就可以靠参数去驱动状态机进行状态转换了
```
this.Animator.setNumber('speed', this.speed);
this.Animator.setTrigger('hit');
```
#### 执行以下操作时必须取消勾选PlayOnStart，主动调用onInit去初始化，onInit可传入0-3个不同类型的参数，传参不需要区分先后顺序
1. 如果需要每个状态都有单独的逻辑回调（onEntry、onUpdate、onExit）
```
// 单个状态的逻辑控制类
export default class SheepIdle extends AnimatorStateLogic {
public onEntry() {
cc.log('idle entry');
}
public onUpdate() {
cc.log('idle update');
}
public onExit() {
cc.log('idle exit');
}
}
```
```
let map: Map<string, AnimatorStateLogic> = new Map();
map.set('sheep_idle', new SheepIdle());
map.set('sheep_run', new SheepRun());
map.set('sheep_hit', new SheepHit(this));
this.Animator.onInit(map);
```
2. 如果需要监听状态切换
```
this.Animator.onInit((fromState: string, toState: string) => {
cc.log(`state change: ${fromState} -> ${toState}`);
});
```
3. 如果使用自定义的方式播放动画（AnimatorCustomization）
```
/**
* 自定义控制动画播放的接口
*/
export interface AnimationPlayer {
/** 设置动画播放结束的回调 */
setFinishedCallback(callback: () => void, target: any): void;
/** 播放动画 */
playAnimation(animName: string, loop: boolean): void;
/** 缩放动画播放速率 */
scaleTime(scale: number): void;
}
```
```
this.Animator.onInit(AnimationPlayer);
```
#### 如果需要使用spine在不同的trackindex播放动画，可以用AnimatorSpine和AnimatorSpineSecondary挂在同一个spine节点上实现并行状态机
![image](./images/runtime2.png)</br>
AnimatorSpine为主状态机，trackindex为0，负责播放walk、run、jump三个动画</br>
AnimatorSpineSecondary为次状态机，trackindex为1，负责播放shoot动画</br>
编辑好两个不同的状态机，运行时便可将实现播放别的动画的同时开枪</br>
![image](./images/example1.gif)</br>
**ps：但实际项目中如果需要使用并行状态机往往比这会复杂很多，很可能需要你自行修改runtime的实现**
## <a id="warning"></a>注意点
#### 首先，虽然名为动画状态机，但实际上把动画剥离开，仅仅用作一个纯粹的逻辑上的状态机也是没有问题的，只需要编辑状态机时不填入动画名（Motion），然后调用onInit传入逻辑控制参数即可。
- 参数名、子状态机名、状态名都不可重名
- 目前不支持状态转向自身
- Parameters和Inspector两个界面如果内容超出，请使用鼠标滚轮滚动，因为为了防止与拖拽行为产生冲突，触摸事件已被屏蔽
- 当未勾选Has Exit Time以及没有添加任何condition时，此transition会被忽略
- 状态机组件添加了@executionOrder(-1000)
- spine的动画播放速度完全由主状态机控制
- 由于cocos中spine的setCompleteListener内部实现问题，每次调用会直接覆盖之前的回调，所以如果需要监听动画播完，请使用AnimatorSpine中addCompleteListener等api
- 目前不支持动画混合，例如调用spine的setMix会影响动画结束（Has Exit Time）的判定，所以如果需要做spine、dragonbones、cocos animation这些动画混合都需要自行处理
## <a id="reference"></a>参考资料
1. <a id="reference1"></a>https://blog.csdn.net/vikingsc2007_1/article/details/81070029
2. https://docs.unity3d.com/2018.4/Documentation/Manual/AnimatorControllers.html

34
animator-editor/assets/script/editor/fsm/FsmCtr.ts
View File

@@ -553,14 +553,32 @@ export default class FsmCtr extends cc.Component {
* 导入cocos animation文件
*/
public importAnim(animData: any) {
let x = Tool.randFloat(-this.MachineLayer.node.x - 100, -this.MachineLayer.node.x + 100);
let y = Tool.randFloat(-this.MachineLayer.node.y - 100, -this.MachineLayer.node.y + 100);
let unitState = this.MachineLayer.createState(cc.v2(x, y));
let state: State = unitState.state;
state.name = animData._name;
state.motion = animData._name;
state.speed = animData.speed;
state.loop = animData.wrapMode === cc.WrapMode.Loop;
if (animData instanceof Array) {
// 3.0 anim文件
animData.forEach((data) => {
if (!data.hasOwnProperty('_name')) {
return;
}
let x = Tool.randFloat(-this.MachineLayer.node.x - 100, -this.MachineLayer.node.x + 100);
let y = Tool.randFloat(-this.MachineLayer.node.y - 100, -this.MachineLayer.node.y + 100);
let unitState = this.MachineLayer.createState(cc.v2(x, y));
let state: State = unitState.state;
state.name = data._name;
state.motion = data._name;
state.speed = data.speed;
state.loop = data.wrapMode === cc.WrapMode.Loop;
});
} else {
// 2.x anim文件
let x = Tool.randFloat(-this.MachineLayer.node.x - 100, -this.MachineLayer.node.x + 100);
let y = Tool.randFloat(-this.MachineLayer.node.y - 100, -this.MachineLayer.node.y + 100);
let unitState = this.MachineLayer.createState(cc.v2(x, y));
let state: State = unitState.state;
state.name = animData._name;
state.motion = animData._name;
state.speed = animData.speed;
state.loop = animData.wrapMode === cc.WrapMode.Loop;
}
}
/**

2
animator-editor/assets/script/scene/Main.ts
View File

@@ -94,7 +94,7 @@ export default class Main extends cc.Component {
this.resetEditor();
this._editor.Parameters.import(data.parameters);
this._editor.Fsm.importProject(data);
} else if (data.skeleton && data.animations) {
} else if (data.animations) {
// 读取spine文件
this._editor.Fsm.improtSpine(data);
} else if (data.armature) {

29
animator-runtime/AnimatorDragonBones.ts
View File

@@ -1,29 +0,0 @@
// import AnimatorBase from "./lib/AnimatorBase";
// const { ccclass, property, requireComponent } = cc._decorator;
// /** DragonBones状态机组件 */
// @ccclass
// @requireComponent(dragonBones.ArmatureDisplay)
// export default class AnimatorDragonBones extends AnimatorBase {
// /** DragonBones组件 */
// private _dragonBones: dragonBones.ArmatureDisplay = null;
// protected start() {
// this._dragonBones = this.getComponent(dragonBones.ArmatureDisplay);
// if (this.AssetRawUrl !== null) {
// this.initJson(this.AssetRawUrl.json);
// }
// this._dragonBones.addEventListener(dragonBones.EventObject.COMPLETE, this.onAnimFinished, this);
// }
// public playAnimation(animName: string, loop: boolean) {
// this._dragonBones.playAnimation(animName, loop ? 0 : -1);
// }
// public scaleTime(scale: number) {
// if (scale > 0)
// this._dragonBones.timeScale = scale;
// }
// }

45
animator-runtime/AnimatorSpine.ts
View File

@@ -1,45 +0,0 @@
// import AnimatorBase from "./lib/AnimatorBase";
// const { ccclass, property, requireComponent } = cc._decorator;
// /** Spine状态机组件 */
// @ccclass
// @requireComponent(sp.Skeleton)
// export default class AnimatorSpine extends AnimatorBase {
// spine: sp.Skeleton = null;
// listeners: Array<Function>;
// protected start(): void {
// this.listeners = new Array<Function>();
// this.spine = this.getComponent(sp.Skeleton);
// if (this.AssetRawUrl !== null) {
// this.initJson(this.AssetRawUrl.json);
// }
// this.spine.setCompleteListener(this.spineAniStateEvent.bind(this));
// this.spine.setEventListener(this.spineAniEvent.bind(this));
// }
// private spineAniStateEvent(obj, trackIndex, type, event, loopCount): void {
// this._animatorController.onAnimationComplete();
// }
// private spineAniEvent(track, event): void {
// for (let i = 0; i < this.listeners.length; i++) {
// this.listeners[i](track, event);
// }
// }
// public addEventListener(cb: Function): void {
// this.listeners.push(cb);
// }
// public playAnimation(aniName: string, loop: boolean): void {
// this.spine.setAnimation(0, aniName, loop);
// }
// public scaleTime(scale: number): void {
// if (scale > 0)
// this.spine.timeScale = scale;
// }
// }

38
animator-runtime/AnimatorAnimation.ts → animator-runtime/animator2.x/AnimatorAnimation.ts
View File

@@ -1,26 +1,31 @@
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent } = cc._decorator;
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/** Animation状态机组件 */
/**
* Cocos Animation状态机组件
*/
@ccclass
@disallowMultiple
@requireComponent(cc.Animation)
export default class AnimatorAnimation extends AnimatorBase {
/** Animation组件 */
private _animation: cc.Animation = null;
/** 当前的动画实例 */
private _animState: cc.AnimationState = null;
/** 记录初始的wrapmode */
private _wrapModeMap: Map<cc.AnimationState, cc.WrapMode> = new Map();
protected onLoad() {
if (!this.PlayOnLoad || this._hasInit) {
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._animation = this.getComponent(cc.Animation);
this._animation.on("finished", this.onAnimFinished, this);
this._animation.on("lastframe", this.onAnimFinished, this);
this._animation.on(cc.Animation.EventType.FINISHED, this.onAnimFinished, this);
this._animation.on(cc.Animation.EventType.LASTFRAME, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
@@ -35,7 +40,7 @@ export default class AnimatorAnimation extends AnimatorBase {
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnLoad || this._hasInit) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
@@ -43,8 +48,8 @@ export default class AnimatorAnimation extends AnimatorBase {
this.initArgs(...args);
this._animation = this.getComponent(cc.Animation);
this._animation.on("finished", this.onAnimFinished, this);
this._animation.on("lastframe", this.onAnimFinished, this);
this._animation.on(cc.Animation.EventType.FINISHED, this.onAnimFinished, this);
this._animation.on(cc.Animation.EventType.LASTFRAME, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
@@ -58,8 +63,18 @@ export default class AnimatorAnimation extends AnimatorBase {
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (!animName) {
return;
}
this._animState = this._animation.play(animName);
this._animState.wrapMode = loop ? cc.WrapMode.Loop : cc.WrapMode.Default;
if (!this._animState) {
return;
}
if (!this._wrapModeMap.has(this._animState)) {
this._wrapModeMap.set(this._animState, this._animState.wrapMode);
}
this._animState.wrapMode = loop ? cc.WrapMode.Loop : this._wrapModeMap.get(this._animState);
}
/**
@@ -68,7 +83,8 @@ export default class AnimatorAnimation extends AnimatorBase {
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
if (scale > 0 && this._animState)
if (this._animState) {
this._animState.speed = scale;
}
}
}

15
animator-runtime/AnimatorAvatar.ts → animator-runtime/animator2.x/AnimatorCustomization.ts
View File

@@ -1,11 +1,18 @@
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent } = cc._decorator;
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/** 纸娃娃系统状态机组件 */
/**
* 自定义动画控制的状态机组件
*/
@ccclass
export default class AnimatorAvatar extends AnimatorBase {
@disallowMultiple
export default class AnimatorCustomization extends AnimatorBase {
/** 此组件必须主动调用onInit初始化 */
@property({ override: true, visible: false })
protected PlayOnStart: boolean = false;
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
@@ -33,7 +40,7 @@ export default class AnimatorAvatar extends AnimatorBase {
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (this._animationPlayer) {
if (this._animationPlayer && animName) {
this._animationPlayer.playAnimation(animName, loop);
}
}

71
animator-runtime/animator2.x/AnimatorDragonBones.ts Normal file
View File

@@ -0,0 +1,71 @@
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/**
* DragonBones状态机组件
*/
@ccclass
@disallowMultiple
@requireComponent(dragonBones.ArmatureDisplay)
export default class AnimatorDragonBones extends AnimatorBase {
/** DragonBones组件 */
private _dragonBones: dragonBones.ArmatureDisplay = null;
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._dragonBones = this.getComponent(dragonBones.ArmatureDisplay);
this._dragonBones.addEventListener(dragonBones.EventObject.COMPLETE, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._dragonBones = this.getComponent(dragonBones.ArmatureDisplay);
this._dragonBones.addEventListener(dragonBones.EventObject.COMPLETE, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
animName && this._dragonBones.playAnimation(animName, loop ? 0 : -1);
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
this._dragonBones.timeScale = scale;
}
}

120
animator-runtime/animator2.x/AnimatorSpine.ts Normal file
View File

@@ -0,0 +1,120 @@
import AnimatorSpineSecondary from "./AnimatorSpineSecondary";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/**
* Spine状态机组件（主状态机），trackIndex为0
*/
@ccclass
@disallowMultiple
@requireComponent(sp.Skeleton)
export default class AnimatorSpine extends AnimatorBase {
/** spine组件 */
private _spine: sp.Skeleton = null;
/** 动画完成的回调 */
private _completeListenerMap: Map<(entry?: any) => void, any> = new Map();
/** 次状态机注册的回调 */
private _secondaryListenerMap: Map<(entry?: any) => void, AnimatorSpineSecondary> = new Map();
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._spine = this.getComponent(sp.Skeleton);
this._spine.setCompleteListener(this.onSpineComplete.bind(this));
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._spine = this.getComponent(sp.Skeleton);
this._spine.setCompleteListener(this.onSpineComplete.bind(this));
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
private onSpineComplete(entry: any) {
entry.trackIndex === 0 && this.onAnimFinished();
this._completeListenerMap.forEach((target, cb) => { target ? cb.call(target, entry) : cb(entry); });
this._secondaryListenerMap.forEach((target, cb) => { entry.trackIndex === target.TrackIndex && cb.call(target, entry); });
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (animName) {
this._spine.setAnimation(0, animName, loop);
} else {
this._spine.clearTrack(0);
}
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
this._spine.timeScale = scale;
}
/**
* 注册次状态机动画结束的回调（状态机内部方法，不能由外部直接调用）
*/
public addSecondaryListener(cb: (entry?: any) => void, target: AnimatorSpineSecondary) {
this._secondaryListenerMap.set(cb, target);
}
/**
* 注册动画完成时的监听
* @param cb 回调
* @param target 调用回调的this对象
*/
public addCompleteListener(cb: (entry?: any) => void, target: any = null) {
if (this._completeListenerMap.has(cb)) {
return;
}
this._completeListenerMap.set(cb, target);
}
/**
* 注销动画完成的监听
* @param cb 回调
*/
public removeCompleteListener(cb: (entry?: any) => void) {
this._completeListenerMap.delete(cb);
}
/**
* 清空动画完成的监听
*/
public clearCompleteListener() {
this._completeListenerMap.clear;
}
}

72
animator-runtime/animator2.x/AnimatorSpineSecondary.ts Normal file
View File

@@ -0,0 +1,72 @@
import AnimatorSpine from "./AnimatorSpine";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent } = cc._decorator;
/**
* Spine状态机组件（次状态机），同一节点可添加多个，用于在不同track中播放动画，trackIndex必须大于0
*/
@ccclass
@requireComponent(sp.Skeleton)
export default class AnimatorSpineSecondary extends AnimatorBase {
@property({ tooltip: CC_DEV && '动画播放的trackIndex，必须大于0' }) TrackIndex: number = 1;
/** 主状态机 */
private _main: AnimatorSpine = null;
/** spine组件 */
private _spine: sp.Skeleton = null;
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._spine = this.getComponent(sp.Skeleton);
this._main = this.getComponent(AnimatorSpine);
this._main.addSecondaryListener(this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._spine = this.getComponent(sp.Skeleton);
this._main = this.getComponent(AnimatorSpine);
this._main.addSecondaryListener(this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (animName) {
this._spine.setAnimation(this.TrackIndex, animName, loop);
} else {
this._spine.clearTrack(this.TrackIndex);
}
}
}

13
animator-runtime/core/AnimatorBase.ts → animator-runtime/animator2.x/core/AnimatorBase.ts
View File

@@ -9,7 +9,7 @@ const { ccclass, property, executionOrder } = cc._decorator;
*/
export interface AnimationPlayer {
/** 设置动画播放结束的回调 */
setFinishedCallback(callback: (event: cc.Event.EventCustom) => void, target?: any): void;
setFinishedCallback(callback: () => void, target: any): void;
/** 播放动画 */
playAnimation(animName: string, loop: boolean): void;
/** 缩放动画播放速率 */
@@ -25,8 +25,8 @@ export default class AnimatorBase extends cc.Component {
@property({ type: cc.JsonAsset, tooltip: CC_DEV && '状态机json文件' })
protected AssetRawUrl: cc.JsonAsset = null;
@property({ tooltip: CC_DEV && '是否在onLoad中自动启动状态机' })
protected PlayOnLoad: boolean = true;
@property({ tooltip: CC_DEV && '是否在start中自动启动状态机' })
protected PlayOnStart: boolean = true;
@property({ tooltip: CC_DEV && '是否在update中自动触发状态机逻辑更新' })
protected AutoUpdate: boolean = true;
@@ -43,10 +43,11 @@ export default class AnimatorBase extends cc.Component {
/** 自定义的动画播放控制器 */
protected _animationPlayer: AnimationPlayer = null;
/** 当前状态名 */
public get curStateName(): string {
return this._ac.curState.name;
}
/** 当前动画名 */
public get curStateMotion(): string {
return this._ac.curState.motion;
}
@@ -150,9 +151,7 @@ export default class AnimatorBase extends cc.Component {
* 状态切换时的逻辑（状态机内部方法，不能由外部直接调用）
*/
public onStateChange(fromState: AnimatorState, toState: AnimatorState) {
if (toState.motion && toState.motion !== "") {
this.playAnimation(toState.motion, toState.loop);
}
this.playAnimation(toState.motion, toState.loop);
let fromStateName = fromState ? fromState.name : '';

0
animator-runtime/core/AnimatorCondition.ts → animator-runtime/animator2.x/core/AnimatorCondition.ts
View File

1
animator-runtime/core/AnimatorController.ts → animator-runtime/animator2.x/core/AnimatorController.ts
View File

@@ -77,6 +77,7 @@ export default class AnimatorController {
public onAnimationComplete() {
this.animComplete = true;
this.animCompleteState = this._curState;
// cc.log(`animation complete: ${this._curState.name}`);
}
/**

0
animator-runtime/core/AnimatorParams.ts → animator-runtime/animator2.x/core/AnimatorParams.ts
View File

2
animator-runtime/core/AnimatorState.ts → animator-runtime/animator2.x/core/AnimatorState.ts
View File

@@ -36,7 +36,7 @@ export default class AnimatorState {
for (let i = 0; i < data.transitions.length; i++) {
let transition: AnimatorTransition = new AnimatorTransition(data.transitions[i], ac);
transition.isValid && this._transitions.push(transition);
transition.isValid() && this._transitions.push(transition);
}
}

3
animator-runtime/core/AnimatorStateLogic.ts → animator-runtime/animator2.x/core/AnimatorStateLogic.ts
View File

@@ -2,9 +2,6 @@
* 状态逻辑基类
*/
export default class AnimatorStateLogic {
constructor() {
}
/**
* 进入状态时调用
* @virtual

0
animator-runtime/core/AnimatorTransition.ts → animator-runtime/animator2.x/core/AnimatorTransition.ts
View File

92
animator-runtime/animator3.x/AnimatorAnimation.ts Normal file
View File

@@ -0,0 +1,92 @@
import { Animation, AnimationState, _decorator, __private } from "cc";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = _decorator;
/**
* Cocos Animation状态机组件
*/
@ccclass
@disallowMultiple
@requireComponent(Animation)
export default class AnimatorAnimation extends AnimatorBase {
/** Animation组件 */
private _animation: Animation = null!;
/** 当前的动画实例 */
private _animState: AnimationState = null!;
/** 记录初始的wrapmode */
private _wrapModeMap: Map<AnimationState, number> = new Map();
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._animation = this.getComponent(Animation)!;
this._animation.on(Animation.EventType.FINISHED, this.onAnimFinished, this);
this._animation.on(Animation.EventType.LASTFRAME, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._animation = this.getComponent(Animation)!;
this._animation.on(Animation.EventType.FINISHED, this.onAnimFinished, this);
this._animation.on(Animation.EventType.LASTFRAME, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (!animName) {
return;
}
this._animation.play(animName);
this._animState = this._animation.getState(animName);
if (!this._animState) {
return;
}
if (!this._wrapModeMap.has(this._animState)) {
this._wrapModeMap.set(this._animState, this._animState.wrapMode);
}
this._animState.wrapMode = loop ? 2 : this._wrapModeMap.get(this._animState)!;
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
if (this._animState) {
this._animState.speed = scale;
}
}
}

59
animator-runtime/animator3.x/AnimatorCustomization.ts Normal file
View File

@@ -0,0 +1,59 @@
import { _decorator } from "cc";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = _decorator;
/**
* 自定义动画控制的状态机组件
*/
@ccclass
@disallowMultiple
export default class AnimatorCustomization extends AnimatorBase {
/** 此组件必须主动调用onInit初始化 */
@property({ override: true, visible: false })
protected PlayOnStart: boolean = false;
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (this._animationPlayer && animName) {
this._animationPlayer.playAnimation(animName, loop);
}
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
if (this._animationPlayer) {
this._animationPlayer.scaleTime(scale);
}
}
}

74
animator-runtime/animator3.x/AnimatorDragonBones.ts Normal file
View File

@@ -0,0 +1,74 @@
import { dragonBones, _decorator } from "cc";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = _decorator;
/**
* DragonBones状态机组件
*/
@ccclass
@disallowMultiple
@requireComponent(dragonBones.ArmatureDisplay)
export default class AnimatorDragonBones extends AnimatorBase {
/** DragonBones组件 */
private _dragonBones: dragonBones.ArmatureDisplay = null!;
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._dragonBones = this.getComponent(dragonBones.ArmatureDisplay)!;
this._dragonBones.addEventListener('complete', this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._dragonBones = this.getComponent(dragonBones.ArmatureDisplay)!;
this._dragonBones.addEventListener('complete', this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (animName)
this._dragonBones.playAnimation(animName, loop ? 0 : -1);
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
if (scale > 0)
this._dragonBones.timeScale = scale;
}
}

122
animator-runtime/animator3.x/AnimatorSpine.ts Normal file
View File

@@ -0,0 +1,122 @@
import { sp, _decorator } from "cc";
import AnimatorSpineSecondary from "./AnimatorSpineSecondary";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = _decorator;
/**
* Spine状态机组件（主状态机），trackIndex为0
*/
@ccclass
@disallowMultiple
@requireComponent(sp.Skeleton)
export default class AnimatorSpine extends AnimatorBase {
/** spine组件 */
private _spine: sp.Skeleton = null!;
/** 动画完成的回调 */
private _completeListenerMap: Map<(entry?: any) => void, any> = new Map();
/** 次状态机注册的回调 */
private _secondaryListenerMap: Map<(entry?: any) => void, AnimatorSpineSecondary> = new Map();
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._spine = this.getComponent(sp.Skeleton)!;
this._spine.setCompleteListener(this.onSpineComplete.bind(this));
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._spine = this.getComponent(sp.Skeleton)!;
this._spine.setCompleteListener(this.onSpineComplete.bind(this));
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
private onSpineComplete(entry: any) {
entry.trackIndex === 0 && this.onAnimFinished();
this._completeListenerMap.forEach((target, cb) => { target ? cb.call(target, entry) : cb(entry); });
this._secondaryListenerMap.forEach((target, cb) => { entry.trackIndex === target.TrackIndex && cb.call(target, entry); });
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (animName) {
this._spine.setAnimation(0, animName, loop);
} else {
this._spine.clearTrack(0);
}
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
if (scale > 0)
this._spine.timeScale = scale;
}
/**
* 注册次状态机动画结束的回调（状态机内部方法，不能由外部直接调用）
*/
public addSecondaryListener(cb: (entry?: any) => void, target: AnimatorSpineSecondary) {
this._secondaryListenerMap.set(cb, target);
}
/**
* 注册动画完成时的监听
* @param cb 回调
* @param target 调用回调的this对象
*/
public addCompleteListener(cb: (entry?: any) => void, target: any = null) {
if (this._completeListenerMap.has(cb)) {
return;
}
this._completeListenerMap.set(cb, target);
}
/**
* 注销动画完成的监听
* @param cb 回调
*/
public removeCompleteListener(cb: (entry?: any) => void) {
this._completeListenerMap.delete(cb);
}
/**
* 清空动画完成的监听
*/
public clearCompleteListener() {
this._completeListenerMap.clear;
}
}

73
animator-runtime/animator3.x/AnimatorSpineSecondary.ts Normal file
View File

@@ -0,0 +1,73 @@
import { sp, _decorator } from "cc";
import AnimatorSpine from "./AnimatorSpine";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent } = _decorator;
/**
* Spine状态机组件（次状态机），同一节点可添加多个，用于在不同track中播放动画，trackIndex必须大于0
*/
@ccclass
@requireComponent(sp.Skeleton)
export default class AnimatorSpineSecondary extends AnimatorBase {
@property({ tooltip: '动画播放的trackIndex，必须大于0' }) TrackIndex: number = 1;
/** 主状态机 */
private _main: AnimatorSpine = null!;
/** spine组件 */
private _spine: sp.Skeleton = null!;
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._spine = this.getComponent(sp.Skeleton)!;
this._main = this.getComponent(AnimatorSpine)!;
this._main.addSecondaryListener(this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._spine = this.getComponent(sp.Skeleton)!;
this._main = this.getComponent(AnimatorSpine)!;
this._main.addSecondaryListener(this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (animName) {
this._spine.setAnimation(this.TrackIndex, animName, loop);
} else {
this._spine.clearTrack(this.TrackIndex);
}
}
}

228
animator-runtime/animator3.x/core/AnimatorBase.ts Normal file
View File

@@ -0,0 +1,228 @@
import { Component, JsonAsset, _decorator } from 'cc';
import AnimatorController from "./AnimatorController";
import AnimatorState from "./AnimatorState";
import AnimatorStateLogic from "./AnimatorStateLogic";
const { ccclass, property, executionOrder } = _decorator;
/**
* 自定义控制动画播放的接口
*/
export interface AnimationPlayer {
/** 设置动画播放结束的回调 */
setFinishedCallback(callback: () => void, target: any): void;
/** 播放动画 */
playAnimation(animName: string, loop: boolean): void;
/** 缩放动画播放速率 */
scaleTime(scale: number): void;
}
/**
* 状态机组件基类 优先执行生命周期
*/
@ccclass
@executionOrder(-1000)
export default class AnimatorBase extends Component {
@property({ type: JsonAsset, tooltip: '状态机json文件' })
protected AssetRawUrl: JsonAsset = null!;
@property({ tooltip: '是否在start中自动启动状态机' })
protected PlayOnStart: boolean = true;
@property({ tooltip: '是否在update中自动触发状态机逻辑更新' })
protected AutoUpdate: boolean = true;
/** 是否初始化 */
protected _hasInit: boolean = false;
/** 状态机控制 */
protected _ac: AnimatorController = null!;
/** 各个状态逻辑控制，key为状态名 */
protected _stateLogicMap: Map<string, AnimatorStateLogic> = null!;
/** 状态切换时的回调 */
protected _onStateChangeCall: (fromState: string, toState: string) => void = null!;
/** 自定义的动画播放控制器 */
protected _animationPlayer: AnimationPlayer = null!;
/** 当前状态名 */
public get curStateName(): string {
return this._ac.curState.name;
}
/** 当前动画名 */
public get curStateMotion(): string {
return this._ac.curState.motion;
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @virtual
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
}
/**
* 处理初始化参数
*/
protected initArgs(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
args.forEach((arg) => {
if (!arg) {
return;
}
if (typeof arg === 'function') {
this._onStateChangeCall = arg;
} else if (typeof arg === 'object') {
if (arg instanceof Map) {
this._stateLogicMap = arg;
} else {
this._animationPlayer = arg;
this._animationPlayer.setFinishedCallback(this.onAnimFinished, this);
}
}
});
}
private updateAnimator() {
// 混合当前动画播放速度
let playSpeed = this._ac.curState.speed;
if (this._ac.curState.multi) {
playSpeed *= this._ac.params.getNumber(this._ac.curState.multi) || 1;
}
this.scaleTime(playSpeed);
// 更新AnimatorStateLogic
if (this._stateLogicMap) {
let curLogic = this._stateLogicMap.get(this._ac.curState.name);
curLogic && curLogic.onUpdate();
}
// 更新状态机逻辑
this._ac.updateAnimator();
}
protected update() {
if (this._hasInit && this.AutoUpdate) {
this.updateAnimator();
}
}
/**
* 手动调用更新
*/
public manualUpdate() {
if (this._hasInit && !this.AutoUpdate) {
this.updateAnimator();
}
}
/**
* 解析状态机json文件
*/
protected initJson(json: any) {
this._ac = new AnimatorController(this, json);
}
/**
* 动画结束的回调
*/
protected onAnimFinished() {
this._ac.onAnimationComplete();
}
/**
* 播放动画
* @virtual
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
}
/**
* 缩放动画播放速率
* @virtual
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
}
/**
* 状态切换时的逻辑（状态机内部方法，不能由外部直接调用）
*/
public onStateChange(fromState: AnimatorState, toState: AnimatorState) {
this.playAnimation(toState.motion, toState.loop);
let fromStateName = fromState ? fromState.name : '';
if (this._stateLogicMap) {
let fromLogic = this._stateLogicMap.get(fromStateName);
fromLogic && fromLogic.onExit();
let toLogic = this._stateLogicMap.get(toState.name);
toLogic && toLogic.onEntry();
}
this._onStateChangeCall && this._onStateChangeCall(fromStateName, toState.name);
}
/**
* 设置boolean类型参数的值
*/
public setBool(key: string, value: boolean) {
this._ac.params.setBool(key, value);
}
/**
* 获取boolean类型参数的值
*/
public getBool(key: string): boolean {
return this._ac.params.getBool(key) !== 0;
}
/**
* 设置number类型参数的值
*/
public setNumber(key: string, value: number) {
this._ac.params.setNumber(key, value);
}
/**
* 获取number类型参数的值
*/
public getNumber(key: string): number {
return this._ac.params.getNumber(key);
}
/**
* 设置trigger类型参数的值
*/
public setTrigger(key: string) {
this._ac.params.setTrigger(key);
}
/**
* 重置trigger类型参数的值
*/
public resetTrigger(key: string) {
this._ac.params.resetTrigger(key);
}
/**
* 设置autoTrigger类型参数的值（autoTrigger类型参数不需要主动reset，每次状态机更新结束后会自动reset）
*/
public autoTrigger(key: string) {
this._ac.params.autoTrigger(key);
}
/**
* 无视条件直接跳转状态
* @param 状态名
*/
public play(stateName: string) {
if (!this._hasInit) {
return;
}
this._ac.play(stateName);
}
}

82
animator-runtime/animator3.x/core/AnimatorCondition.ts Normal file
View File

@@ -0,0 +1,82 @@
import { error } from "cc";
import AnimatorController from "./AnimatorController";
/** 参数类型 */
export enum ParamType {
COMPLETE = 0,
BOOLEAN = 1,
NUMBER = 2,
TRIGGER = 3,
AUTO_TRIGGER = 4
}
/** 逻辑类型 */
export enum LogicType {
EQUAL = 0,
NOTEQUAL = 1,
GREATER = 2,
LESS = 3,
GREATER_EQUAL = 4,
LESS_EQUAL = 5
}
/**
* 单项条件
*/
export default class AnimatorCondition {
private _ac: AnimatorController;
/** 此条件对应的参数名 */
private _param: string = "";
/** 此条件对应的值 */
private _value: number = 0;
/** 此条件与值比较的逻辑 */
private _logic: LogicType = LogicType.EQUAL;
constructor(data: any, ac: AnimatorController) {
this._ac = ac;
this._param = data.param;
this._value = data.value;
this._logic = data.logic;
}
public getParamName() {
return this._param;
}
public getParamType(): ParamType {
return this._ac.params.getParamType(this._param);
}
/** 判断此条件是否满足 */
public check(): boolean {
let type: ParamType = this.getParamType();
if (type === ParamType.BOOLEAN) {
return this._ac.params.getBool(this._param) === this._value;
} else if (type === ParamType.NUMBER) {
let value: number = this._ac.params.getNumber(this._param);
switch (this._logic) {
case LogicType.EQUAL:
return value === this._value;
case LogicType.NOTEQUAL:
return value !== this._value;
case LogicType.GREATER:
return value > this._value;
case LogicType.LESS:
return value < this._value;
case LogicType.GREATER_EQUAL:
return value >= this._value;
case LogicType.LESS_EQUAL:
return value <= this._value;
default:
return false;
}
} else if (type === ParamType.AUTO_TRIGGER) {
return this._ac.params.getAutoTrigger(this._param) !== 0;
} else if (type === ParamType.TRIGGER) {
return this._ac.params.getTrigger(this._param) !== 0;
} else {
error(`[AnimatorCondition.check] 错误的type: ${type}`);
return false;
}
}
}

119
animator-runtime/animator3.x/core/AnimatorController.ts Normal file
View File

@@ -0,0 +1,119 @@
import { error } from "cc";
import AnimatorBase from "./AnimatorBase";
import AnimatorParams from "./AnimatorParams";
import AnimatorState from "./AnimatorState";
/**
* 状态机控制类
*/
export default class AnimatorController {
private _jsonData: any = null;
private _animator: AnimatorBase = null!;
private _params: AnimatorParams = null!;
private _states: Map<string, AnimatorState> = null!;
private _anyState: AnimatorState = null!;
private _curState: AnimatorState = null!;
/** 状态切换次数 */
private _changeCount: number = 0;
/** 对应animComplete的状态 */
public animCompleteState: AnimatorState = null!;
/** 动画播放完毕的标记 */
public animComplete: boolean = false;
/** 当前运行的状态 */
public get curState(): AnimatorState { return this._curState; }
public get params(): AnimatorParams { return this._params; }
constructor(player: AnimatorBase, json: any) {
this._animator = player;
this._jsonData = json;
this._states = new Map<string, AnimatorState>();
this._params = new AnimatorParams(json.parameters);
this.init(json);
}
/**
* 初始化状态机所有动画状态
*/
private init(json: any) {
if (json.states.length <= 0) {
error(`[AnimatorController.init] 状态机json错误`);
return;
}
let defaultState: string = json.defaultState;
this._anyState = new AnimatorState(json.anyState, this);
for (let i = 0; i < json.states.length; i++) {
let state: AnimatorState = new AnimatorState(json.states[i], this);
this._states.set(state.name, state);
}
this.changeState(defaultState);
}
private updateState() {
this._curState.checkAndTrans();
if (this._curState !== this._anyState && this._anyState !== null) {
this._anyState.checkAndTrans();
}
}
/**
* 更新状态机逻辑
*/
public updateAnimator() {
// 重置计数
this._changeCount = 0;
this.updateState();
// 重置动画完成标记
if (this.animComplete && this.animCompleteState.loop) {
this.animComplete = false;
}
// 重置autoTrigger
this.params.resetAllAutoTrigger();
}
public onAnimationComplete() {
this.animComplete = true;
this.animCompleteState = this._curState;
// cc.log(`animation complete: ${this._curState.name}`);
}
/**
* 无视条件直接跳转状态
* @param 状态名
*/
public play(stateName: string) {
if (!this._states.has(stateName) || this._curState.name === stateName) {
return;
}
// 重置动画完成标记
this.animComplete = false;
this.changeState(stateName);
}
/**
* 切换动画状态
*/
public changeState(stateName: string) {
this._changeCount++;
if (this._changeCount > 1000) {
error('[AnimatorController.changeState] error: 状态切换递归调用超过1000次，transition设置可能出错!');
return;
}
if (this._states.has(stateName) && (this._curState === null || this._curState.name !== stateName)) {
let oldState = this._curState;
this._curState = this._states.get(stateName)!;
this._animator.onStateChange(oldState, this._curState);
this.updateState();
} else {
error(`[AnimatorController.changeState] error state: ${stateName}`);
}
}
}

121
animator-runtime/animator3.x/core/AnimatorParams.ts Normal file
View File

@@ -0,0 +1,121 @@
import { ParamType } from "./AnimatorCondition";
/**
* 参数结构
*/
interface Param {
type: ParamType;
value: number;
}
/**
* 状态机参数
*/
export default class AnimatorParams {
private _paramMap: Map<string, Param> = new Map();
constructor(dataArr: any[]) {
dataArr.forEach((data: any) => {
let param: Param = {
type: data.type,
value: data.init
};
this._paramMap.set(data.param, param);
});
}
public getParamType(key: string): ParamType {
let param: Param = this._paramMap.get(key)!;
if (param) {
return param.type;
} else {
return null!;
}
}
public setNumber(key: string, value: number) {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.NUMBER) {
param.value = value;
}
}
public setBool(key: string, value: boolean) {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.BOOLEAN) {
param.value = value ? 1 : 0;
}
}
public setTrigger(key: string) {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.TRIGGER) {
param.value = 1;
}
}
public resetTrigger(key: string) {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.TRIGGER) {
param.value = 0;
}
}
public autoTrigger(key: string) {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.AUTO_TRIGGER) {
param.value = 1;
}
}
public resetAutoTrigger(key: string) {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.AUTO_TRIGGER) {
param.value = 0;
}
}
public resetAllAutoTrigger() {
this._paramMap.forEach((param: Param, key: string) => {
if (param.type === ParamType.AUTO_TRIGGER) {
param.value = 0;
}
});
}
public getNumber(key: string): number {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.NUMBER) {
return param.value;
} else {
return 0;
}
}
public getBool(key: string): number {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.BOOLEAN) {
return param.value;
} else {
return 0;
}
}
public getTrigger(key: string): number {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.TRIGGER) {
return param.value;
} else {
return 0;
}
}
public getAutoTrigger(key: string): number {
let param: Param = this._paramMap.get(key)!;
if (param && param.type === ParamType.AUTO_TRIGGER) {
return param.value;
} else {
return 0;
}
}
}

55
animator-runtime/animator3.x/core/AnimatorState.ts Normal file
View File

@@ -0,0 +1,55 @@
import AnimatorController from "./AnimatorController";
import AnimatorTransition from "./AnimatorTransition";
/**
* 状态管理类
*/
export default class AnimatorState {
private _name: string = "";
private _motion: string = "";
private _loop: boolean = false;
private _speed: number = 1;
private _multi: string = "";
private _transitions: AnimatorTransition[] = [];
private _ac: AnimatorController = null!;
/** 状态名 */
public get name() { return this._name; }
/** 动画名 */
public get motion() { return this._motion; }
/** 动画是否循环播放 */
public get loop() { return this._loop; }
/** 动画播放速度 */
public get speed() { return this._speed; }
/** 动画播放速度的混合参数 */
public get multi() { return this._multi; }
constructor(data: any, ac: AnimatorController) {
this._name = data.state;
this._motion = data.motion || '';
this._loop = data.loop || false;
this._speed = data.speed || 1;
this._multi = data.multiplier || '';
this._ac = ac;
for (let i = 0; i < data.transitions.length; i++) {
let transition: AnimatorTransition = new AnimatorTransition(data.transitions[i], ac);
transition.isValid() && this._transitions.push(transition);
}
}
/**
* 判断各个分支是否满足条件，满足则转换状态
*/
public checkAndTrans() {
for (let i = 0; i < this._transitions.length; i++) {
let transition: AnimatorTransition = this._transitions[i];
if (transition && transition.check()) {
transition.doTrans();
return;
}
}
}
}

25
animator-runtime/animator3.x/core/AnimatorStateLogic.ts Normal file
View File

@@ -0,0 +1,25 @@
/**
* 状态逻辑基类
*/
export default class AnimatorStateLogic {
/**
* 进入状态时调用
* @virtual
*/
public onEntry() {
}
/**
* 每次状态机逻辑更新时调用
* @virtual
*/
public onUpdate() {
}
/**
* 离开状态时调用
* @virtual
*/
public onExit() {
}
}

71
animator-runtime/animator3.x/core/AnimatorTransition.ts Normal file
View File

@@ -0,0 +1,71 @@
import AnimatorCondition, { ParamType } from "./AnimatorCondition";
import AnimatorController from "./AnimatorController";
/**
* 状态过渡类
*/
export default class AnimatorTransition {
private _toStateName: string = '';
private _hasExitTime: boolean = false;
private _conditions: AnimatorCondition[] = [];
private _ac: AnimatorController = null!;
constructor(data: any, ac: AnimatorController) {
this._toStateName = data.toState;
this._hasExitTime = data.hasExitTime;
this._ac = ac;
for (let i = 0; i < data.conditions.length; i++) {
let condition: AnimatorCondition = new AnimatorCondition(data.conditions[i], ac);
this._conditions.push(condition);
}
}
/**
* 返回该transition是否有效，当未勾选hasExitTime以及没有添加任何condition时此transition无效并忽略
*/
public isValid(): boolean {
return this._hasExitTime || this._conditions.length > 0;
}
/**
* 判断是否满足所有转换条件
*/
public check(): boolean {
if (this._toStateName === this._ac.curState.name) {
return false;
}
if (this._hasExitTime && (this._ac.curState !== this._ac.animCompleteState || !this._ac.animComplete)) {
return false;
}
for (let i = 0; i < this._conditions.length; i++) {
if (!this._conditions[i].check()) {
return false;
}
}
return true;
}
/**
* 转换状态
*/
public doTrans() {
// 满足条件时重置动画播完标记
if (this._hasExitTime) {
this._ac.animComplete = false;
}
// 满足状态转换条件时重置trigger和autoTrigger
for (let i = 0; i < this._conditions.length; i++) {
let type = this._conditions[i].getParamType();
let name = this._conditions[i].getParamName();
if (type === ParamType.TRIGGER) {
this._ac.params.resetTrigger(name);
} else if (type === ParamType.AUTO_TRIGGER) {
this._ac.params.resetAutoTrigger(name);
}
}
this._ac.changeState(this._toStateName);
}
}

53
examples/example2-2-2/.gitignore vendored Normal file
View File

@@ -0,0 +1,53 @@
#/////////////////////////////////////////////////////////////////////////////
# Fireball Projects
#/////////////////////////////////////////////////////////////////////////////
/library/
/temp/
/local/
/build/
#/////////////////////////////////////////////////////////////////////////////
# npm files
#/////////////////////////////////////////////////////////////////////////////
npm-debug.log
node_modules/
#/////////////////////////////////////////////////////////////////////////////
# Logs and databases
#/////////////////////////////////////////////////////////////////////////////
*.log
*.sql
*.sqlite
#/////////////////////////////////////////////////////////////////////////////
# files for debugger
#/////////////////////////////////////////////////////////////////////////////
*.sln
*.csproj
*.pidb
*.unityproj
*.suo
#/////////////////////////////////////////////////////////////////////////////
# OS generated files
#/////////////////////////////////////////////////////////////////////////////
.DS_Store
ehthumbs.db
Thumbs.db
#/////////////////////////////////////////////////////////////////////////////
# WebStorm files
#/////////////////////////////////////////////////////////////////////////////
.idea/
#//////////////////////////
# VS Code files
#//////////////////////////
.vscode/

7
examples/example2-2-2/assets/res.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "6f7a4dfa-6f65-4255-aed8-4a2902f84601",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

7
examples/example2-2-2/assets/res/animation.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "a835cdc7-50a5-416b-8090-4f35d54dfc78",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/animation/animation-animator.json Normal file
View File

@@ -0,0 +1 @@
{"animator":"1.0.0","mainStateMachine":{"layerPos":[-68.23754226233478,-21.050174637417967],"layerScale":1.2000000000000002,"anyStatePos":[-300,300],"subStates":["sheep_hit","sheep_idle","sheep_run"],"subStateMachines":[]},"subStateMachines":[],"defaultState":"sheep_idle","anyState":{"transitions":[{"toState":"sheep_hit","hasExitTime":false,"conditions":[{"param":"hit","value":0,"logic":0}]}]},"states":[{"position":[210,60],"upStateMachine":"BaseLayer","state":"sheep_hit","motion":"sheep_hit","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"sheep_idle","hasExitTime":true,"conditions":[]}]},{"position":[-240,60],"upStateMachine":"BaseLayer","state":"sheep_idle","motion":"sheep_idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"sheep_run","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":2}]}]},{"position":[-240,-120],"upStateMachine":"BaseLayer","state":"sheep_run","motion":"sheep_run","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"sheep_idle","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":0}]}]}],"parameters":[{"param":"speed","type":2,"init":0},{"param":"hit","type":3,"init":0}]}

5
examples/example2-2-2/assets/res/animation/animation-animator.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "43806a1f-7be5-4bf1-9477-95e699fea019",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/animation/animation-runtimeData.json Normal file
View File

@@ -0,0 +1 @@
{"defaultState":"sheep_idle","anyState":{"transitions":[{"toState":"sheep_hit","hasExitTime":false,"conditions":[{"param":"hit","value":0,"logic":0}]}]},"states":[{"state":"sheep_hit","motion":"sheep_hit","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"sheep_idle","hasExitTime":true,"conditions":[]}]},{"state":"sheep_idle","motion":"sheep_idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"sheep_run","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":2}]}]},{"state":"sheep_run","motion":"sheep_run","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"sheep_idle","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":0}]}]}],"parameters":[{"param":"speed","type":2,"init":0},{"param":"hit","type":3,"init":0}]}

5
examples/example2-2-2/assets/res/animation/animation-runtimeData.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "eafb4a36-50c1-4417-b90a-234e6a57e0ba",
"subMetas": {}
}

191
examples/example2-2-2/assets/res/animation/sheep.plist Normal file
View File

@@ -0,0 +1,191 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>frames</key>
<dict>
<key>sheep_down_0.png</key>
<dict>
<key>frame</key>
<string>{{2,2},{224,87}}</string>
<key>offset</key>
<string>{0,-25}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{2,61},{224,87}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_down_1.png</key>
<dict>
<key>frame</key>
<string>{{326,367},{152,103}}</string>
<key>offset</key>
<string>{-6,-8}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{32,36},{152,103}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_down_2.png</key>
<dict>
<key>frame</key>
<string>{{2,335},{166,105}}</string>
<key>offset</key>
<string>{-7,-3}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{24,30},{166,105}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_jump_0.png</key>
<dict>
<key>frame</key>
<string>{{326,472},{144,151}}</string>
<key>offset</key>
<string>{-10,0}</string>
<key>rotated</key>
<true/>
<key>sourceColorRect</key>
<string>{{32,4},{144,151}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_jump_1.png</key>
<dict>
<key>frame</key>
<string>{{170,351},{154,131}}</string>
<key>offset</key>
<string>{-13,2}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{24,12},{154,131}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_jump_2.png</key>
<dict>
<key>frame</key>
<string>{{348,260},{160,105}}</string>
<key>offset</key>
<string>{-10,4}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{24,23},{160,105}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_jump_3.png</key>
<dict>
<key>frame</key>
<string>{{2,442},{152,115}}</string>
<key>offset</key>
<string>{-12,-2}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{26,24},{152,115}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_jump_4.png</key>
<dict>
<key>frame</key>
<string>{{360,119},{148,139}}</string>
<key>offset</key>
<string>{-12,-2}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{28,12},{148,139}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_run_0.png</key>
<dict>
<key>frame</key>
<string>{{178,236},{168,113}}</string>
<key>offset</key>
<string>{-4,0}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{26,23},{168,113}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_run_1.png</key>
<dict>
<key>frame</key>
<string>{{182,119},{176,115}}</string>
<key>offset</key>
<string>{1,2}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{27,20},{176,115}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_run_2.png</key>
<dict>
<key>frame</key>
<string>{{228,2},{178,115}}</string>
<key>offset</key>
<string>{1,11}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{26,11},{178,115}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_run_3.png</key>
<dict>
<key>frame</key>
<string>{{2,91},{178,113}}</string>
<key>offset</key>
<string>{2,1}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{27,22},{178,113}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
<key>sheep_touch_0.png</key>
<dict>
<key>frame</key>
<string>{{2,206},{174,127}}</string>
<key>offset</key>
<string>{-5,16}</string>
<key>rotated</key>
<false/>
<key>sourceColorRect</key>
<string>{{22,0},{174,127}}</string>
<key>sourceSize</key>
<string>{228,159}</string>
</dict>
</dict>
<key>metadata</key>
<dict>
<key>format</key>
<integer>2</integer>
<key>realTextureFileName</key>
<string>sheep.png</string>
<key>size</key>
<string>{512,1024}</string>
<key>smartupdate</key>
<string>$TexturePacker:SmartUpdate:a7b82875050232ffbd24deccd7e379b7:847cb78fe45f863139518baf3831526a:13084b924613a7ef2ca9c6df3339651b$</string>
<key>textureFileName</key>
<string>sheep.png</string>
</dict>
</dict>
</plist>

298
examples/example2-2-2/assets/res/animation/sheep.plist.meta Normal file
View File

@@ -0,0 +1,298 @@
{
"ver": "1.2.4",
"uuid": "679478cf-f911-402f-9ad6-75649317cc25",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"size": {
"width": 512,
"height": 1024
},
"type": "Texture Packer",
"subMetas": {
"sheep_down_0.png": {
"ver": "1.0.4",
"uuid": "19964863-36eb-437c-92e1-edff001c640b",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": 0,
"offsetY": -25,
"trimX": 2,
"trimY": 2,
"width": 224,
"height": 87,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_down_1.png": {
"ver": "1.0.4",
"uuid": "d3dc5491-96af-489a-bd07-94fb66a4d390",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -6,
"offsetY": -8,
"trimX": 326,
"trimY": 367,
"width": 152,
"height": 103,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_down_2.png": {
"ver": "1.0.4",
"uuid": "36311098-60f7-4dbd-823f-d4b65bba51ac",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -7,
"offsetY": -3,
"trimX": 2,
"trimY": 335,
"width": 166,
"height": 105,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_jump_0.png": {
"ver": "1.0.4",
"uuid": "f99dcc0a-21fe-4a8b-83d4-ae2c6086f2bb",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": true,
"offsetX": -10,
"offsetY": 0,
"trimX": 326,
"trimY": 472,
"width": 144,
"height": 151,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_jump_1.png": {
"ver": "1.0.4",
"uuid": "b0f22f00-acd5-4281-8237-5a5537be01eb",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -13,
"offsetY": 2,
"trimX": 170,
"trimY": 351,
"width": 154,
"height": 131,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_jump_2.png": {
"ver": "1.0.4",
"uuid": "bea82e28-c68e-469e-8a2e-f960bfd6fd83",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -10,
"offsetY": 4,
"trimX": 348,
"trimY": 260,
"width": 160,
"height": 105,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_jump_3.png": {
"ver": "1.0.4",
"uuid": "13d1ac9b-9adb-4bc2-94ea-6d5cc86c4576",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -12,
"offsetY": -2,
"trimX": 2,
"trimY": 442,
"width": 152,
"height": 115,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_jump_4.png": {
"ver": "1.0.4",
"uuid": "4a35b378-ad2b-46cd-ae2a-52e34773b1e9",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -12,
"offsetY": -2,
"trimX": 360,
"trimY": 119,
"width": 148,
"height": 139,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_run_0.png": {
"ver": "1.0.4",
"uuid": "b483caae-e5fd-4067-ac76-bd2b7227af39",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -4,
"offsetY": 0,
"trimX": 178,
"trimY": 236,
"width": 168,
"height": 113,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_run_1.png": {
"ver": "1.0.4",
"uuid": "641ca71a-5ade-4f52-a845-9105b17e0d85",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": 1,
"offsetY": 2,
"trimX": 182,
"trimY": 119,
"width": 176,
"height": 115,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_run_2.png": {
"ver": "1.0.4",
"uuid": "d98cc8d8-8bc1-48e1-a8c1-941df564e02c",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": 1,
"offsetY": 11,
"trimX": 228,
"trimY": 2,
"width": 178,
"height": 115,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_run_3.png": {
"ver": "1.0.4",
"uuid": "237ec4a7-7729-43d5-90d2-1e5b629aad69",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": 2,
"offsetY": 1,
"trimX": 2,
"trimY": 91,
"width": 178,
"height": 113,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
},
"sheep_touch_0.png": {
"ver": "1.0.4",
"uuid": "5d309671-90b5-42bd-b193-4aee80a602d1",
"rawTextureUuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -5,
"offsetY": 16,
"trimX": 2,
"trimY": 206,
"width": 174,
"height": 127,
"rawWidth": 228,
"rawHeight": 159,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"spriteType": "normal",
"subMetas": {}
}
}
}

BIN
examples/example2-2-2/assets/res/animation/sheep.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 250 KiB

12
examples/example2-2-2/assets/res/animation/sheep.png.meta Normal file
View File

@@ -0,0 +1,12 @@
{
"ver": "2.3.3",
"uuid": "a82bf3f7-5244-411c-b8dc-7b800b3bab3c",
"type": "raw",
"wrapMode": "clamp",
"filterMode": "bilinear",
"premultiplyAlpha": false,
"genMipmaps": false,
"packable": true,
"platformSettings": {},
"subMetas": {}
}

43
examples/example2-2-2/assets/res/animation/sheep_hit.anim Normal file
View File

@@ -0,0 +1,43 @@
{
"__type__": "cc.AnimationClip",
"_name": "sheep_hit",
"_objFlags": 0,
"_native": "",
"_duration": 0.5166666666666667,
"sample": 60,
"speed": 1,
"wrapMode": 1,
"curveData": {
"comps": {
"cc.Sprite": {
"spriteFrame": [
{
"frame": 0,
"value": {
"__uuid__": "5d309671-90b5-42bd-b193-4aee80a602d1"
}
},
{
"frame": 0.16666666666666666,
"value": {
"__uuid__": "19964863-36eb-437c-92e1-edff001c640b"
}
},
{
"frame": 0.3333333333333333,
"value": {
"__uuid__": "d3dc5491-96af-489a-bd07-94fb66a4d390"
}
},
{
"frame": 0.5,
"value": {
"__uuid__": "36311098-60f7-4dbd-823f-d4b65bba51ac"
}
}
]
}
}
},
"events": []
}

5
examples/example2-2-2/assets/res/animation/sheep_hit.anim.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "2.1.0",
"uuid": "24d1963d-df84-4647-9b79-6d34ae17a827",
"subMetas": {}
}

25
examples/example2-2-2/assets/res/animation/sheep_idle.anim Normal file
View File

@@ -0,0 +1,25 @@
{
"__type__": "cc.AnimationClip",
"_name": "sheep_idle",
"_objFlags": 0,
"_native": "",
"_duration": 0.016666666666666666,
"sample": 60,
"speed": 1,
"wrapMode": 2,
"curveData": {
"comps": {
"cc.Sprite": {
"spriteFrame": [
{
"frame": 0,
"value": {
"__uuid__": "36311098-60f7-4dbd-823f-d4b65bba51ac"
}
}
]
}
}
},
"events": []
}

5
examples/example2-2-2/assets/res/animation/sheep_idle.anim.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "2.1.0",
"uuid": "1a1afca2-6657-476f-a923-411df0b0333d",
"subMetas": {}
}

44
examples/example2-2-2/assets/res/animation/sheep_run.anim Normal file
View File

@@ -0,0 +1,44 @@
{
"__type__": "cc.AnimationClip",
"_name": "sheep_run",
"_objFlags": 0,
"_native": "",
"_duration": 0.4,
"sample": 10,
"speed": 1,
"wrapMode": 2,
"curveData": {
"comps": {
"cc.Sprite": {
"spriteFrame": [
{
"frame": 0,
"value": {
"__uuid__": "b483caae-e5fd-4067-ac76-bd2b7227af39"
}
},
{
"frame": 0.1,
"value": {
"__uuid__": "641ca71a-5ade-4f52-a845-9105b17e0d85"
}
},
{
"frame": 0.2,
"value": {
"__uuid__": "d98cc8d8-8bc1-48e1-a8c1-941df564e02c"
}
},
{
"frame": 0.3,
"value": {
"__uuid__": "237ec4a7-7729-43d5-90d2-1e5b629aad69"
}
}
]
}
},
"props": {}
},
"events": []
}

5
examples/example2-2-2/assets/res/animation/sheep_run.anim.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "2.1.0",
"uuid": "365c3f76-afc4-4db0-ad85-ddb95fa6d4b9",
"subMetas": {}
}

7
examples/example2-2-2/assets/res/customization.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "ffc0c320-212e-4b05-bd56-ca4301c2b20f",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/customization/customization-animator.json Normal file
View File

@@ -0,0 +1 @@
{"animator":"1.0.0","mainStateMachine":{"layerPos":[0,0],"layerScale":1,"anyStatePos":[-300,300],"subStates":["idle","move1","move2"],"subStateMachines":[]},"subStateMachines":[],"defaultState":"idle","anyState":{"transitions":[]},"states":[{"position":[-270,0],"upStateMachine":"BaseLayer","state":"idle","motion":"idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"move1","hasExitTime":true,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"position":[210,0],"upStateMachine":"BaseLayer","state":"move1","motion":"move1","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"move2","hasExitTime":true,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"position":[-270,-270],"upStateMachine":"BaseLayer","state":"move2","motion":"move2","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"idle","hasExitTime":true,"conditions":[{"param":"next","value":0,"logic":0}]}]}],"parameters":[{"param":"next","type":3,"init":0}]}

5
examples/example2-2-2/assets/res/customization/customization-animator.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "95d0a313-ebec-4f2b-8e99-38ae9ecc31ac",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/customization/customization-runtimeData.json Normal file
View File

@@ -0,0 +1 @@
{"defaultState":"idle","anyState":{"transitions":[]},"states":[{"state":"idle","motion":"idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"move1","hasExitTime":true,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"state":"move1","motion":"move1","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"move2","hasExitTime":true,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"state":"move2","motion":"move2","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"idle","hasExitTime":true,"conditions":[{"param":"next","value":0,"logic":0}]}]}],"parameters":[{"param":"next","type":3,"init":0}]}

5
examples/example2-2-2/assets/res/customization/customization-runtimeData.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "3b43599a-fb1d-45ae-a605-d120f985812e",
"subMetas": {}
}

7
examples/example2-2-2/assets/res/dragonBones.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "4cfae3f8-1706-46d3-826d-203c1b0735b7",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/dragonBones/dragonbones-animator.json Normal file
View File

@@ -0,0 +1 @@
{"animator":"1.0.0","mainStateMachine":{"layerPos":[0,0],"layerScale":1,"anyStatePos":[-300,300],"subStates":["idle","walk","aim","hit"],"subStateMachines":[]},"subStateMachines":[],"defaultState":"idle","anyState":{"transitions":[]},"states":[{"position":[-300,60],"upStateMachine":"BaseLayer","state":"idle","motion":"idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"walk","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"position":[120,60],"upStateMachine":"BaseLayer","state":"walk","motion":"walk","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"hit","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"position":[-300,-210],"upStateMachine":"BaseLayer","state":"aim","motion":"aim","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"idle","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"position":[120,-210],"upStateMachine":"BaseLayer","state":"hit","motion":"hit","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"aim","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]}],"parameters":[{"param":"next","type":3,"init":0}]}

5
examples/example2-2-2/assets/res/dragonBones/dragonbones-animator.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "701555ab-955e-4125-883e-48e627b3745f",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/dragonBones/dragonbones-runtimeData.json Normal file
View File

@@ -0,0 +1 @@
{"defaultState":"idle","anyState":{"transitions":[]},"states":[{"state":"idle","motion":"idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"walk","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"state":"walk","motion":"walk","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"hit","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"state":"aim","motion":"aim","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"idle","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]},{"state":"hit","motion":"hit","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"aim","hasExitTime":false,"conditions":[{"param":"next","value":0,"logic":0}]}]}],"parameters":[{"param":"next","type":3,"init":0}]}

5
examples/example2-2-2/assets/res/dragonBones/dragonbones-runtimeData.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "91924927-4ae8-4f46-b31f-53f35fd76b42",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/dragonBones/mecha_1502b_ske.json Normal file
View File

File diff suppressed because one or more lines are too long

6
examples/example2-2-2/assets/res/dragonBones/mecha_1502b_ske.json.meta Normal file
View File

File diff suppressed because one or more lines are too long

1
examples/example2-2-2/assets/res/dragonBones/mecha_1502b_tex.json Normal file
View File

@@ -0,0 +1 @@
{"imagePath":"mecha_1502b_tex.png","width":512,"SubTexture":[{"width":74,"y":93,"height":20,"name":"bullet_01_f/bullet_01","x":307},{"width":48,"y":1,"height":38,"name":"fire_effect_01_f/fireEffect","x":212},{"width":180,"y":430,"height":52,"name":"flame_01_f/ba_bu_flame1","x":1},{"frameX":-2,"frameHeight":234,"y":1,"frameY":0,"frameWidth":86,"width":81,"height":233,"name":"flame_01_f/bbb","x":1},{"width":44,"y":1,"height":39,"name":"mecha_1502b_folder/shouder_l_0","x":319},{"width":29,"y":77,"height":106,"name":"mecha_1502b_folder/foot_l_0","x":434},{"width":50,"y":185,"height":32,"name":"mecha_1502b_folder/thigh_1_l_0","x":434},{"width":122,"y":177,"height":46,"name":"mecha_1502b_folder/calf_l","x":84},{"width":101,"y":118,"height":57,"name":"mecha_1502b_folder/thigh_l","x":84},{"width":41,"y":77,"height":65,"name":"mecha_1502b_folder/pelvis","x":465},{"width":89,"y":236,"height":192,"name":"mecha_1502b_folder/chest","x":1},{"width":29,"y":77,"height":109,"name":"mecha_1502b_folder/foot_r","x":403},{"width":55,"y":1,"height":32,"name":"mecha_1502b_folder/thigh_1_r_1","x":262},{"width":126,"y":1,"height":52,"name":"mecha_1502b_folder/calf_r","x":84},{"width":103,"y":55,"height":61,"name":"mecha_1502b_folder/thigh_r","x":84},{"width":43,"y":144,"height":39,"name":"mecha_1502b_folder/shouder_r_1","x":465},{"width":116,"y":55,"height":44,"name":"weapon_1502b_folder/back_l","x":189},{"frameX":0,"frameHeight":36,"y":39,"frameY":0,"frameWidth":94,"width":93,"height":36,"name":"weapon_1502b_folder/image/paoguan_0002","x":403},{"width":94,"y":1,"height":36,"name":"weapon_1502b_folder/image/paoguan_0001","x":403},{"width":94,"y":55,"height":36,"name":"weapon_1502b_folder/image/paoguan_0003","x":307},{"width":121,"y":118,"height":45,"name":"weapon_1502b_folder/back_r","x":187}],"height":512,"name":"mecha_1502b"}

7
examples/example2-2-2/assets/res/dragonBones/mecha_1502b_tex.json.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.0",
"uuid": "2793a939-cf7f-4a69-bc16-d2ed790b67d5",
"atlasJson": "{\"imagePath\":\"mecha_1502b_tex.png\",\"width\":512,\"SubTexture\":[{\"width\":74,\"y\":93,\"height\":20,\"name\":\"bullet_01_f/bullet_01\",\"x\":307},{\"width\":48,\"y\":1,\"height\":38,\"name\":\"fire_effect_01_f/fireEffect\",\"x\":212},{\"width\":180,\"y\":430,\"height\":52,\"name\":\"flame_01_f/ba_bu_flame1\",\"x\":1},{\"frameX\":-2,\"frameHeight\":234,\"y\":1,\"frameY\":0,\"frameWidth\":86,\"width\":81,\"height\":233,\"name\":\"flame_01_f/bbb\",\"x\":1},{\"width\":44,\"y\":1,\"height\":39,\"name\":\"mecha_1502b_folder/shouder_l_0\",\"x\":319},{\"width\":29,\"y\":77,\"height\":106,\"name\":\"mecha_1502b_folder/foot_l_0\",\"x\":434},{\"width\":50,\"y\":185,\"height\":32,\"name\":\"mecha_1502b_folder/thigh_1_l_0\",\"x\":434},{\"width\":122,\"y\":177,\"height\":46,\"name\":\"mecha_1502b_folder/calf_l\",\"x\":84},{\"width\":101,\"y\":118,\"height\":57,\"name\":\"mecha_1502b_folder/thigh_l\",\"x\":84},{\"width\":41,\"y\":77,\"height\":65,\"name\":\"mecha_1502b_folder/pelvis\",\"x\":465},{\"width\":89,\"y\":236,\"height\":192,\"name\":\"mecha_1502b_folder/chest\",\"x\":1},{\"width\":29,\"y\":77,\"height\":109,\"name\":\"mecha_1502b_folder/foot_r\",\"x\":403},{\"width\":55,\"y\":1,\"height\":32,\"name\":\"mecha_1502b_folder/thigh_1_r_1\",\"x\":262},{\"width\":126,\"y\":1,\"height\":52,\"name\":\"mecha_1502b_folder/calf_r\",\"x\":84},{\"width\":103,\"y\":55,\"height\":61,\"name\":\"mecha_1502b_folder/thigh_r\",\"x\":84},{\"width\":43,\"y\":144,\"height\":39,\"name\":\"mecha_1502b_folder/shouder_r_1\",\"x\":465},{\"width\":116,\"y\":55,\"height\":44,\"name\":\"weapon_1502b_folder/back_l\",\"x\":189},{\"frameX\":0,\"frameHeight\":36,\"y\":39,\"frameY\":0,\"frameWidth\":94,\"width\":93,\"height\":36,\"name\":\"weapon_1502b_folder/image/paoguan_0002\",\"x\":403},{\"width\":94,\"y\":1,\"height\":36,\"name\":\"weapon_1502b_folder/image/paoguan_0001\",\"x\":403},{\"width\":94,\"y\":55,\"height\":36,\"name\":\"weapon_1502b_folder/image/paoguan_0003\",\"x\":307},{\"width\":121,\"y\":118,\"height\":45,\"name\":\"weapon_1502b_folder/back_r\",\"x\":187}],\"height\":512,\"name\":\"mecha_1502b\"}",
"texture": "f9d4e201-c14a-4876-bd8b-e1233a3f5fd8",
"subMetas": {}
}

BIN
examples/example2-2-2/assets/res/dragonBones/mecha_1502b_tex.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 186 KiB

34
examples/example2-2-2/assets/res/dragonBones/mecha_1502b_tex.png.meta Normal file
View File

@@ -0,0 +1,34 @@
{
"ver": "2.3.3",
"uuid": "f9d4e201-c14a-4876-bd8b-e1233a3f5fd8",
"type": "sprite",
"wrapMode": "clamp",
"filterMode": "bilinear",
"premultiplyAlpha": false,
"genMipmaps": false,
"packable": true,
"platformSettings": {},
"subMetas": {
"mecha_1502b_tex": {
"ver": "1.0.4",
"uuid": "3e01bc7c-f1ec-4149-ab81-644d53e7e85b",
"rawTextureUuid": "f9d4e201-c14a-4876-bd8b-e1233a3f5fd8",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -1.5,
"offsetY": 14.5,
"trimX": 1,
"trimY": 1,
"width": 507,
"height": 481,
"rawWidth": 512,
"rawHeight": 512,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"subMetas": {}
}
}
}

7
examples/example2-2-2/assets/res/spine.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "b4fb9513-fb6d-4bb2-8b12-be957a6ad7cd",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/spine/spine-animator0.json Normal file
View File

@@ -0,0 +1 @@
{"animator":"1.0.0","mainStateMachine":{"layerPos":[-39.57449196272348,57.1601385080676],"layerScale":1.4000000000000004,"anyStatePos":[-300,300],"subStates":["idle","walk","run","jump"],"subStateMachines":[]},"subStateMachines":[],"defaultState":"idle","anyState":{"transitions":[]},"states":[{"position":[-270,60],"upStateMachine":"BaseLayer","state":"idle","motion":"idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"walk","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":2},{"param":"speed","value":2,"logic":3}]},{"toState":"run","hasExitTime":false,"conditions":[{"param":"speed","value":2,"logic":4}]},{"toState":"jump","hasExitTime":false,"conditions":[{"param":"jump","value":0,"logic":0}]}]},{"position":[210,60],"upStateMachine":"BaseLayer","state":"walk","motion":"walk","speed":1,"multiplier":"speed","loop":true,"transitions":[{"toState":"idle","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":0}]},{"toState":"run","hasExitTime":false,"conditions":[{"param":"speed","value":2,"logic":4}]},{"toState":"jump","hasExitTime":false,"conditions":[{"param":"jump","value":0,"logic":0}]}]},{"position":[-270,-150],"upStateMachine":"BaseLayer","state":"run","motion":"run","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"idle","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":0}]},{"toState":"walk","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":2},{"param":"speed","value":2,"logic":3}]},{"toState":"jump","hasExitTime":false,"conditions":[{"param":"jump","value":0,"logic":0}]}]},{"position":[210,-270],"upStateMachine":"BaseLayer","state":"jump","motion":"jump","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"idle","hasExitTime":true,"conditions":[]}]}],"parameters":[{"param":"speed","type":2,"init":0},{"param":"jump","type":4,"init":0}]}

5
examples/example2-2-2/assets/res/spine/spine-animator0.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "acf936e0-be76-4a88-8fa5-98391c31cbc1",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/spine/spine-animator1.json Normal file
View File

@@ -0,0 +1 @@
{"animator":"1.0.0","mainStateMachine":{"layerPos":[0,0],"layerScale":1,"anyStatePos":[-300,300],"subStates":["empty","shoot"],"subStateMachines":[]},"subStateMachines":[],"defaultState":"empty","anyState":{"transitions":[]},"states":[{"position":[-300,-60],"upStateMachine":"BaseLayer","state":"empty","motion":"","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"shoot","hasExitTime":false,"conditions":[{"param":"shoot","value":0,"logic":0}]}]},{"position":[150,-60],"upStateMachine":"BaseLayer","state":"shoot","motion":"shoot","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"empty","hasExitTime":true,"conditions":[]}]}],"parameters":[{"param":"shoot","type":4,"init":0}]}

5
examples/example2-2-2/assets/res/spine/spine-animator1.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "b9fbc4bb-a022-4927-8824-edf4bd30b556",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/spine/spine-runtimeData0.json Normal file
View File

@@ -0,0 +1 @@
{"defaultState":"idle","anyState":{"transitions":[]},"states":[{"state":"idle","motion":"idle","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"walk","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":2},{"param":"speed","value":2,"logic":3}]},{"toState":"run","hasExitTime":false,"conditions":[{"param":"speed","value":2,"logic":4}]},{"toState":"jump","hasExitTime":false,"conditions":[{"param":"jump","value":0,"logic":0}]}]},{"state":"walk","motion":"walk","speed":1,"multiplier":"speed","loop":true,"transitions":[{"toState":"idle","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":0}]},{"toState":"run","hasExitTime":false,"conditions":[{"param":"speed","value":2,"logic":4}]},{"toState":"jump","hasExitTime":false,"conditions":[{"param":"jump","value":0,"logic":0}]}]},{"state":"run","motion":"run","speed":1,"multiplier":"","loop":true,"transitions":[{"toState":"idle","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":0}]},{"toState":"walk","hasExitTime":false,"conditions":[{"param":"speed","value":0,"logic":2},{"param":"speed","value":2,"logic":3}]},{"toState":"jump","hasExitTime":false,"conditions":[{"param":"jump","value":0,"logic":0}]}]},{"state":"jump","motion":"jump","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"idle","hasExitTime":true,"conditions":[]}]}],"parameters":[{"param":"speed","type":2,"init":0},{"param":"jump","type":4,"init":0}]}

5
examples/example2-2-2/assets/res/spine/spine-runtimeData0.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "a4c4a817-2577-4c9b-94dc-bc6fe12a8ce8",
"subMetas": {}
}

1
examples/example2-2-2/assets/res/spine/spine-runtimeData1.json Normal file
View File

@@ -0,0 +1 @@
{"defaultState":"empty","anyState":{"transitions":[]},"states":[{"state":"empty","motion":"","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"shoot","hasExitTime":false,"conditions":[{"param":"shoot","value":0,"logic":0}]}]},{"state":"shoot","motion":"shoot","speed":1,"multiplier":"","loop":false,"transitions":[{"toState":"empty","hasExitTime":true,"conditions":[]}]}],"parameters":[{"param":"shoot","type":4,"init":0}]}

5
examples/example2-2-2/assets/res/spine/spine-runtimeData1.json.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "1.0.0",
"uuid": "b58f7a9d-68b5-440f-896f-ef2d0359382d",
"subMetas": {}
}

2412
examples/example2-2-2/assets/res/spine/spineboy.json Normal file
View File

File diff suppressed because it is too large Load Diff

9
examples/example2-2-2/assets/res/spine/spineboy.json.meta Normal file
View File

@@ -0,0 +1,9 @@
{
"ver": "1.2.2",
"uuid": "a5e3714e-7870-4b3a-acf6-1e78ec8b90df",
"textures": [
"1fca40dd-d252-4f6e-9a11-904e370eab6b"
],
"scale": 1,
"subMetas": {}
}

BIN
examples/example2-2-2/assets/res/spine/spineboy.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 215 KiB

34
examples/example2-2-2/assets/res/spine/spineboy.png.meta Normal file
View File

@@ -0,0 +1,34 @@
{
"ver": "2.3.3",
"uuid": "1fca40dd-d252-4f6e-9a11-904e370eab6b",
"type": "sprite",
"wrapMode": "clamp",
"filterMode": "bilinear",
"premultiplyAlpha": false,
"genMipmaps": false,
"packable": true,
"platformSettings": {},
"subMetas": {
"spineboy": {
"ver": "1.0.4",
"uuid": "0a9b7c82-adbe-47bb-b9ea-9ef63db25f91",
"rawTextureUuid": "1fca40dd-d252-4f6e-9a11-904e370eab6b",
"trimType": "auto",
"trimThreshold": 1,
"rotated": false,
"offsetX": -11,
"offsetY": 6,
"trimX": 2,
"trimY": 2,
"width": 998,
"height": 240,
"rawWidth": 1024,
"rawHeight": 256,
"borderTop": 0,
"borderBottom": 0,
"borderLeft": 0,
"borderRight": 0,
"subMetas": {}
}
}
}

195
examples/example2-2-2/assets/res/spine/spineboy.txt Normal file
View File

@@ -0,0 +1,195 @@
spineboy.png
size:1024,256
format: RGBA8888
filter: Linear,Linear
repeat: none
eye_indifferent
rotate: true
xy: 389, 5
size: 56, 53
orig: 56, 53
offset: 0, 0
index: -1
eye_surprised
rotate: false
xy: 580, 34
size: 56, 53
orig: 56, 53
offset: 0, 0
index: -1
front_bracer
rotate: false
xy: 732, 85
size: 35, 48
orig: 35, 48
offset: 0, 0
index: -1
front_fist_closed
rotate: false
xy: 556, 91
size: 45, 49
orig: 45, 49
offset: 0, 0
index: -1
front_fist_open
rotate: false
xy: 668, 32
size: 52, 52
orig: 52, 52
offset: 0, 0
index: -1
front_foot
rotate: false
xy: 924, 201
size: 76, 41
orig: 76, 41
offset: 0, 0
index: -1
front_foot_bend1
rotate: false
xy: 845, 200
size: 77, 42
orig: 77, 42
offset: 0, 0
index: -1
front_foot_bend2
rotate: false
xy: 778, 186
size: 65, 56
orig: 65, 56
offset: 0, 0
index: -1
front_shin
rotate: true
xy: 444, 91
size: 49, 110
orig: 49, 110
offset: 0, 0
index: -1
front_thigh
rotate: true
xy: 603, 89
size: 29, 67
orig: 29, 67
offset: 0, 0
index: -1
front_upper_arm
rotate: true
xy: 672, 86
size: 32, 58
orig: 32, 58
offset: 0, 0
index: -1
goggles
rotate: false
xy: 444, 142
size: 157, 100
orig: 157, 100
offset: 0, 0
index: -1
gun
rotate: false
xy: 603, 120
size: 126, 122
orig: 126, 122
offset: 0, 0
index: -1
head
rotate: false
xy: 279, 63
size: 163, 179
orig: 163, 179
offset: 0, 0
index: -1
mouth_grind
rotate: false
xy: 845, 163
size: 56, 35
orig: 56, 35
offset: 0, 0
index: -1
mouth_oooo
rotate: false
xy: 842, 126
size: 56, 35
orig: 56, 35
offset: 0, 0
index: -1
mouth_smile
rotate: false
xy: 769, 97
size: 56, 35
orig: 56, 35
offset: 0, 0
index: -1
muzzle
rotate: false
xy: 2, 2
size: 275, 240
orig: 277, 240
offset: 0, 0
index: -1
neck
rotate: false
xy: 903, 173
size: 22, 25
orig: 22, 25
offset: 0, 0
index: -1
rear_bracer
rotate: false
xy: 722, 40
size: 34, 43
orig: 34, 43
offset: 0, 0
index: -1
rear_foot
rotate: false
xy: 444, 11
size: 68, 36
orig: 68, 36
offset: 0, 0
index: -1
rear_foot_bend1
rotate: false
xy: 444, 49
size: 70, 40
orig: 70, 40
offset: 0, 0
index: -1
rear_foot_bend2
rotate: false
xy: 778, 134
size: 62, 50
orig: 62, 50
offset: 0, 0
index: -1
rear_shin
rotate: false
xy: 731, 135
size: 45, 107
orig: 45, 107
offset: 0, 0
index: -1
rear_thigh
rotate: true
xy: 516, 50
size: 39, 62
orig: 39, 62
offset: 0, 0
index: -1
rear_upper_arm
rotate: false
xy: 638, 35
size: 28, 52
orig: 28, 52
offset: 0, 0
index: -1
torso
rotate: true
xy: 279, 2
size: 59, 108
orig: 59, 108
offset: 0, 0
index: -1

5
examples/example2-2-2/assets/res/spine/spineboy.txt.meta Normal file
View File

@@ -0,0 +1,5 @@
{
"ver": "2.0.0",
"uuid": "24a83a5f-48eb-40c4-ad22-95385682e0e3",
"subMetas": {}
}

7
examples/example2-2-2/assets/scene.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "8316e976-8f63-47fd-a5b5-dc10fc684312",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

595
examples/example2-2-2/assets/scene/Animation.fire Normal file
View File

@@ -0,0 +1,595 @@
[
{
"__type__": "cc.SceneAsset",
"_name": "",
"_objFlags": 0,
"_native": "",
"scene": {
"__id__": 1
}
},
{
"__type__": "cc.Scene",
"_objFlags": 0,
"_parent": null,
"_children": [
{
"__id__": 2
}
],
"_active": true,
"_components": [],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0,
"y": 0
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_is3DNode": true,
"_groupIndex": 0,
"groupIndex": 0,
"autoReleaseAssets": false,
"_id": "43925b6c-075e-4466-a3fe-582378320bbe"
},
{
"__type__": "cc.Node",
"_name": "Canvas",
"_objFlags": 0,
"_parent": {
"__id__": 1
},
"_children": [
{
"__id__": 3
},
{
"__id__": 5
},
{
"__id__": 7
},
{
"__id__": 9
}
],
"_active": true,
"_components": [
{
"__id__": 13
},
{
"__id__": 14
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
960,
540,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "2fnzhYDDhH+o7heymIpQap"
},
{
"__type__": "cc.Node",
"_name": "Main Camera",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 4
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
337.9122923544306,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "43gdsY9DVP862c3LIKCc7W"
},
{
"__type__": "cc.Camera",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 3
},
"_enabled": true,
"_cullingMask": 4294967295,
"_clearFlags": 7,
"_backgroundColor": {
"__type__": "cc.Color",
"r": 0,
"g": 0,
"b": 0,
"a": 255
},
"_depth": -1,
"_zoomRatio": 1,
"_targetTexture": null,
"_fov": 60,
"_orthoSize": 10,
"_nearClip": 1,
"_farClip": 4096,
"_ortho": true,
"_rect": {
"__type__": "cc.Rect",
"x": 0,
"y": 0,
"width": 1,
"height": 1
},
"_renderStages": 1,
"_alignWithScreen": true,
"_id": "e6yEYF90pEMLeXgxk4Hbv7"
},
{
"__type__": "cc.Node",
"_name": "info",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 6
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 803.59,
"height": 144.64
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
-420.862,
361.941,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "3eZbpCz5pET7+Ec/nts+Ya"
},
{
"__type__": "cc.Label",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 5
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_useOriginalSize": false,
"_string": "按左右键移动\n按k键播放hit动画并打断移动",
"_N$string": "按左右键移动\n按k键播放hit动画并打断移动",
"_fontSize": 64,
"_lineHeight": 64,
"_enableWrapText": true,
"_N$file": null,
"_isSystemFontUsed": true,
"_spacingX": 0,
"_batchAsBitmap": false,
"_N$horizontalAlign": 0,
"_N$verticalAlign": 1,
"_N$fontFamily": "Arial",
"_N$overflow": 0,
"_N$cacheMode": 0,
"_id": "35W5Duu3dAdauEtS3SXEYi"
},
{
"__type__": "cc.Node",
"_name": "ground",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 8
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 46,
"g": 82,
"b": 66,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 2000,
"height": 100
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 1
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
-54,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "d87kkEe1lKWbWHA8Dfo51E"
},
{
"__type__": "cc.Sprite",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 7
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_srcBlendFactor": 770,
"_dstBlendFactor": 771,
"_spriteFrame": {
"__uuid__": "a23235d1-15db-4b95-8439-a2e005bfff91"
},
"_type": 0,
"_sizeMode": 0,
"_fillType": 0,
"_fillCenter": {
"__type__": "cc.Vec2",
"x": 0,
"y": 0
},
"_fillStart": 0,
"_fillRange": 0,
"_isTrimmedMode": true,
"_atlas": null,
"_id": "78u7U+C3dGX4ApD1E5oUnD"
},
{
"__type__": "cc.Node",
"_name": "Sheep",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 10
},
{
"__id__": 11
},
{
"__id__": 12
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 166,
"height": 105
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "3dMop0lcpB5ap16Dr3NLeE"
},
{
"__type__": "cc.Sprite",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 9
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_srcBlendFactor": 770,
"_dstBlendFactor": 771,
"_spriteFrame": {
"__uuid__": "36311098-60f7-4dbd-823f-d4b65bba51ac"
},
"_type": 0,
"_sizeMode": 1,
"_fillType": 0,
"_fillCenter": {
"__type__": "cc.Vec2",
"x": 0,
"y": 0
},
"_fillStart": 0,
"_fillRange": 0,
"_isTrimmedMode": true,
"_atlas": {
"__uuid__": "679478cf-f911-402f-9ad6-75649317cc25"
},
"_id": "52DYKxWtBARbHB0VzsEalX"
},
{
"__type__": "cc.Animation",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 9
},
"_enabled": true,
"_defaultClip": null,
"_clips": [
{
"__uuid__": "24d1963d-df84-4647-9b79-6d34ae17a827"
},
{
"__uuid__": "1a1afca2-6657-476f-a923-411df0b0333d"
},
{
"__uuid__": "365c3f76-afc4-4db0-ad85-ddb95fa6d4b9"
}
],
"playOnLoad": false,
"_id": "bcKYZj9ulE2ZcRFn31cVCb"
},
{
"__type__": "c0eccTRS2tFf5D/vabVUToc",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 9
},
"_enabled": true,
"AssetRawUrl": {
"__uuid__": "eafb4a36-50c1-4417-b90a-234e6a57e0ba"
},
"PlayOnStart": false,
"AutoUpdate": false,
"_id": "90GlQw+UVPg6vmrtIrndbK"
},
{
"__type__": "cc.Canvas",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"_designResolution": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_fitWidth": false,
"_fitHeight": true,
"_id": "b0j7FPe5BMD7397xVWjcMb"
},
{
"__type__": "14db7VUlFRDOKSHFQUjRZrK",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"Animator": {
"__id__": 12
},
"_id": "96DtkQX15IyIGmoidkuOSP"
}
]

7
examples/example2-2-2/assets/scene/Animation.fire.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.2.5",
"uuid": "43925b6c-075e-4466-a3fe-582378320bbe",
"asyncLoadAssets": false,
"autoReleaseAssets": false,
"subMetas": {}
}

470
examples/example2-2-2/assets/scene/Customization.fire Normal file
View File

@@ -0,0 +1,470 @@
[
{
"__type__": "cc.SceneAsset",
"_name": "",
"_objFlags": 0,
"_native": "",
"scene": {
"__id__": 1
}
},
{
"__type__": "cc.Scene",
"_objFlags": 0,
"_parent": null,
"_children": [
{
"__id__": 2
}
],
"_active": true,
"_components": [],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0,
"y": 0
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_is3DNode": true,
"_groupIndex": 0,
"groupIndex": 0,
"autoReleaseAssets": false,
"_id": "a01bf096-4001-4a1b-b287-3be7f71862ad"
},
{
"__type__": "cc.Node",
"_name": "Canvas",
"_objFlags": 0,
"_parent": {
"__id__": 1
},
"_children": [
{
"__id__": 3
},
{
"__id__": 5
},
{
"__id__": 8
}
],
"_active": true,
"_components": [
{
"__id__": 10
},
{
"__id__": 11
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
960,
540,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "d0tqW3ByxFQblWu45a5GMA"
},
{
"__type__": "cc.Node",
"_name": "Main Camera",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 4
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
337.9122923544306,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "f6PBTeImtJBrZZicL5UNin"
},
{
"__type__": "cc.Camera",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 3
},
"_enabled": true,
"_cullingMask": 4294967295,
"_clearFlags": 7,
"_backgroundColor": {
"__type__": "cc.Color",
"r": 0,
"g": 0,
"b": 0,
"a": 255
},
"_depth": -1,
"_zoomRatio": 1,
"_targetTexture": null,
"_fov": 60,
"_orthoSize": 10,
"_nearClip": 1,
"_farClip": 4096,
"_ortho": true,
"_rect": {
"__type__": "cc.Rect",
"x": 0,
"y": 0,
"width": 1,
"height": 1
},
"_renderStages": 1,
"_alignWithScreen": true,
"_id": "784UbtpBhE8YVW8qhcwfo0"
},
{
"__type__": "cc.Node",
"_name": "Cube",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 6
},
{
"__id__": 7
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 70,
"g": 76,
"b": 211,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 100,
"height": 100
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "5cOhQEACpJgLkRzD51Zo6f"
},
{
"__type__": "cc.Sprite",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 5
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_srcBlendFactor": 770,
"_dstBlendFactor": 771,
"_spriteFrame": {
"__uuid__": "a23235d1-15db-4b95-8439-a2e005bfff91"
},
"_type": 0,
"_sizeMode": 0,
"_fillType": 0,
"_fillCenter": {
"__type__": "cc.Vec2",
"x": 0,
"y": 0
},
"_fillStart": 0,
"_fillRange": 0,
"_isTrimmedMode": true,
"_atlas": null,
"_id": "eespuLqxNGRpNueW2q1ld2"
},
{
"__type__": "0e26fCq18dIn7sZ8VOtyCEI",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 5
},
"_enabled": true,
"AssetRawUrl": {
"__uuid__": "3b43599a-fb1d-45ae-a605-d120f985812e"
},
"PlayOnStart": false,
"AutoUpdate": true,
"_id": "830b6JiVVO1a5RD1IPhTi/"
},
{
"__type__": "cc.Node",
"_name": "info",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 9
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 704,
"height": 80.64
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
370,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "a2NKS5XO1NLY25vI/h3MUm"
},
{
"__type__": "cc.Label",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 8
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_useOriginalSize": false,
"_string": "点击屏幕切换下一个动画",
"_N$string": "点击屏幕切换下一个动画",
"_fontSize": 64,
"_lineHeight": 64,
"_enableWrapText": true,
"_N$file": null,
"_isSystemFontUsed": true,
"_spacingX": 0,
"_batchAsBitmap": false,
"_N$horizontalAlign": 0,
"_N$verticalAlign": 1,
"_N$fontFamily": "Arial",
"_N$overflow": 0,
"_N$cacheMode": 0,
"_id": "33HOdXuw5GCZEeeYon3hwb"
},
{
"__type__": "cc.Canvas",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"_designResolution": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_fitWidth": false,
"_fitHeight": true,
"_id": "7eneme19dEhLmAPLWqwLPL"
},
{
"__type__": "4ecb8kn8zpIM5/7jjjBGTaH",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"Cube": {
"__id__": 5
},
"_id": "b6SV1vk9xEn7LSuSSI2+OU"
}
]

7
examples/example2-2-2/assets/scene/Customization.fire.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.2.5",
"uuid": "a01bf096-4001-4a1b-b287-3be7f71862ad",
"asyncLoadAssets": false,
"autoReleaseAssets": false,
"subMetas": {}
}

478
examples/example2-2-2/assets/scene/DragonBones.fire Normal file
View File

@@ -0,0 +1,478 @@
[
{
"__type__": "cc.SceneAsset",
"_name": "",
"_objFlags": 0,
"_native": "",
"scene": {
"__id__": 1
}
},
{
"__type__": "cc.Scene",
"_objFlags": 0,
"_parent": null,
"_children": [
{
"__id__": 2
}
],
"_active": true,
"_components": [],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0,
"y": 0
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_is3DNode": true,
"_groupIndex": 0,
"groupIndex": 0,
"autoReleaseAssets": false,
"_id": "cbce07d4-8ebb-45af-ba6a-92f10c90e44f"
},
{
"__type__": "cc.Node",
"_name": "Canvas",
"_objFlags": 0,
"_parent": {
"__id__": 1
},
"_children": [
{
"__id__": 3
},
{
"__id__": 5
},
{
"__id__": 8
}
],
"_active": true,
"_components": [
{
"__id__": 10
},
{
"__id__": 11
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
960,
540,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "5c+lnLk7hCQZukqeDKipf+"
},
{
"__type__": "cc.Node",
"_name": "Main Camera",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 4
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
337.7446708008789,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "d7b9QRh1BKx5jCW9RrYHW0"
},
{
"__type__": "cc.Camera",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 3
},
"_enabled": true,
"_cullingMask": 4294967295,
"_clearFlags": 7,
"_backgroundColor": {
"__type__": "cc.Color",
"r": 0,
"g": 0,
"b": 0,
"a": 255
},
"_depth": -1,
"_zoomRatio": 1,
"_targetTexture": null,
"_fov": 60,
"_orthoSize": 10,
"_nearClip": 1,
"_farClip": 4096,
"_ortho": true,
"_rect": {
"__type__": "cc.Rect",
"x": 0,
"y": 0,
"width": 1,
"height": 1
},
"_renderStages": 1,
"_alignWithScreen": true,
"_id": "37RyO+zC5GTZLa2IsKhgNL"
},
{
"__type__": "cc.Node",
"_name": "mecha_1502b_ske",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 6
},
{
"__id__": 7
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "eeAw6eZqlNwZTeXKWdTh+P"
},
{
"__type__": "dragonBones.ArmatureDisplay",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 5
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_armatureName": "mecha_1502b",
"_animationName": "aim",
"_preCacheMode": 0,
"_cacheMode": 0,
"playTimes": -1,
"premultipliedAlpha": false,
"_armatureKey": "26b72df2-3334-455b-964e-db6847774e64#2793a939-cf7f-4a69-bc16-d2ed790b67d5",
"_accTime": 0,
"_playCount": 0,
"_frameCache": null,
"_curFrame": null,
"_playing": false,
"_armatureCache": null,
"_N$dragonAsset": {
"__uuid__": "26b72df2-3334-455b-964e-db6847774e64"
},
"_N$dragonAtlasAsset": {
"__uuid__": "2793a939-cf7f-4a69-bc16-d2ed790b67d5"
},
"_N$_defaultArmatureIndex": 3,
"_N$_animationIndex": 15,
"_N$_defaultCacheMode": 0,
"_N$timeScale": 1,
"_N$debugBones": false,
"_N$enableBatch": false,
"_id": "8cFD32P/NCD5mKdL318w+z"
},
{
"__type__": "fa0001DMAlCzZ/hkmySCXhc",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 5
},
"_enabled": true,
"AssetRawUrl": {
"__uuid__": "91924927-4ae8-4f46-b31f-53f35fd76b42"
},
"PlayOnLoad": true,
"AutoUpdate": true,
"_id": "f5wzpMVrdIf4wgL6YT0+2k"
},
{
"__type__": "cc.Node",
"_name": "info",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 9
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 512,
"height": 80.64
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
300,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "5bZkQ6BzBCHo9L9EDDs74A"
},
{
"__type__": "cc.Label",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 8
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_useOriginalSize": false,
"_string": "点击屏幕切换动画",
"_N$string": "点击屏幕切换动画",
"_fontSize": 64,
"_lineHeight": 64,
"_enableWrapText": true,
"_N$file": null,
"_isSystemFontUsed": true,
"_spacingX": 0,
"_batchAsBitmap": false,
"_N$horizontalAlign": 0,
"_N$verticalAlign": 1,
"_N$fontFamily": "Arial",
"_N$overflow": 0,
"_N$cacheMode": 0,
"_id": "c1stylrVVKr5f5NPTO84fM"
},
{
"__type__": "cc.Canvas",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"_designResolution": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_fitWidth": false,
"_fitHeight": true,
"_id": "06kiZkyIJLQartAZWv1j7+"
},
{
"__type__": "46c5f3rR99BdL/g8jPFTaRb",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"Animator": {
"__id__": 7
},
"_id": "dfU81p/IlBBo2G+QzZ1cZX"
}
]

7
examples/example2-2-2/assets/scene/DragonBones.fire.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.2.5",
"uuid": "cbce07d4-8ebb-45af-ba6a-92f10c90e44f",
"asyncLoadAssets": false,
"autoReleaseAssets": false,
"subMetas": {}
}

499
examples/example2-2-2/assets/scene/Spine.fire Normal file
View File

@@ -0,0 +1,499 @@
[
{
"__type__": "cc.SceneAsset",
"_name": "",
"_objFlags": 0,
"_native": "",
"scene": {
"__id__": 1
}
},
{
"__type__": "cc.Scene",
"_objFlags": 0,
"_parent": null,
"_children": [
{
"__id__": 2
}
],
"_active": true,
"_components": [],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0,
"y": 0
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_is3DNode": true,
"_groupIndex": 0,
"groupIndex": 0,
"autoReleaseAssets": false,
"_id": "e2a4478a-d1d7-4049-b006-7be03ae32f62"
},
{
"__type__": "cc.Node",
"_name": "Canvas",
"_objFlags": 0,
"_parent": {
"__id__": 1
},
"_children": [
{
"__id__": 3
},
{
"__id__": 5
},
{
"__id__": 7
}
],
"_active": true,
"_components": [
{
"__id__": 11
},
{
"__id__": 12
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
960,
540,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "d5PbdupI9MzIYanN2n/w4y"
},
{
"__type__": "cc.Node",
"_name": "Main Camera",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 4
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
0,
337.7446577905061,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "65BAnD7nZMmJKEjmCkaJQs"
},
{
"__type__": "cc.Camera",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 3
},
"_enabled": true,
"_cullingMask": 4294967295,
"_clearFlags": 7,
"_backgroundColor": {
"__type__": "cc.Color",
"r": 0,
"g": 0,
"b": 0,
"a": 255
},
"_depth": -1,
"_zoomRatio": 1,
"_targetTexture": null,
"_fov": 60,
"_orthoSize": 10,
"_nearClip": 1,
"_farClip": 4096,
"_ortho": true,
"_rect": {
"__type__": "cc.Rect",
"x": 0,
"y": 0,
"width": 1,
"height": 1
},
"_renderStages": 1,
"_alignWithScreen": true,
"_id": "09SCmtIJRIzZZ0xtzRd0bY"
},
{
"__type__": "cc.Node",
"_name": "info",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 6
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 1287.16,
"height": 272.64
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
-253.473,
359.87,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "cbTvNdZQVNJZX19d6T2q5U"
},
{
"__type__": "cc.Label",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 5
},
"_enabled": true,
"_materials": [
{
"__uuid__": "eca5d2f2-8ef6-41c2-bbe6-f9c79d09c432"
}
],
"_useOriginalSize": false,
"_string": "按以下按键播放动画\n左右方向键(按住加速，松开减速)：walk、run\n空格键：jump\nk：shoot",
"_N$string": "按以下按键播放动画\n左右方向键(按住加速，松开减速)：walk、run\n空格键：jump\nk：shoot",
"_fontSize": 64,
"_lineHeight": 64,
"_enableWrapText": true,
"_N$file": null,
"_isSystemFontUsed": true,
"_spacingX": 0,
"_batchAsBitmap": false,
"_N$horizontalAlign": 0,
"_N$verticalAlign": 1,
"_N$fontFamily": "Arial",
"_N$overflow": 0,
"_N$cacheMode": 0,
"_id": "82cLjGOzJIEa8lq21IafRj"
},
{
"__type__": "cc.Node",
"_name": "spineboy",
"_objFlags": 0,
"_parent": {
"__id__": 2
},
"_children": [],
"_active": true,
"_components": [
{
"__id__": 8
},
{
"__id__": 9
},
{
"__id__": 10
}
],
"_prefab": null,
"_opacity": 255,
"_color": {
"__type__": "cc.Color",
"r": 255,
"g": 255,
"b": 255,
"a": 255
},
"_contentSize": {
"__type__": "cc.Size",
"width": 0,
"height": 0
},
"_anchorPoint": {
"__type__": "cc.Vec2",
"x": 0.5,
"y": 0.5
},
"_trs": {
"__type__": "TypedArray",
"ctor": "Float64Array",
"array": [
0,
-360,
0,
0,
0,
0,
1,
1,
1,
1
]
},
"_eulerAngles": {
"__type__": "cc.Vec3",
"x": 0,
"y": 0,
"z": 0
},
"_skewX": 0,
"_skewY": 0,
"_is3DNode": false,
"_groupIndex": 0,
"groupIndex": 0,
"_id": "e8lexkq8dMNab6Z9MEI/ky"
},
{
"__type__": "sp.Skeleton",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 7
},
"_enabled": true,
"_materials": [
{
"__uuid__": "7afd064b-113f-480e-b793-8817d19f63c3"
}
],
"paused": false,
"defaultSkin": "",
"defaultAnimation": "",
"_preCacheMode": 0,
"_cacheMode": 0,
"loop": true,
"premultipliedAlpha": true,
"timeScale": 1,
"_accTime": 0,
"_playCount": 0,
"_frameCache": null,
"_curFrame": null,
"_skeletonCache": null,
"_animationName": "",
"_animationQueue": [],
"_headAniInfo": null,
"_playTimes": 0,
"_isAniComplete": true,
"_N$skeletonData": {
"__uuid__": "a5e3714e-7870-4b3a-acf6-1e78ec8b90df"
},
"_N$_defaultCacheMode": 0,
"_N$debugSlots": false,
"_N$debugBones": false,
"_N$debugMesh": false,
"_N$useTint": false,
"_N$enableBatch": false,
"_id": "c1Za9Hx3BKeo0Xf6wRH0tz"
},
{
"__type__": "81397AkbwFD5Izg7F0yY1/D",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 7
},
"_enabled": true,
"AssetRawUrl": {
"__uuid__": "a4c4a817-2577-4c9b-94dc-bc6fe12a8ce8"
},
"PlayOnStart": false,
"AutoUpdate": true,
"_id": "b60UaHdkdFbZ6yfl+H0Phm"
},
{
"__type__": "32504xevahNAblXzax6Zdkv",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 7
},
"_enabled": true,
"AssetRawUrl": {
"__uuid__": "b58f7a9d-68b5-440f-896f-ef2d0359382d"
},
"PlayOnStart": true,
"AutoUpdate": true,
"TrackIndex": 1,
"_id": "47ianh+1pHcbo7nNb/aYiV"
},
{
"__type__": "cc.Canvas",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"_designResolution": {
"__type__": "cc.Size",
"width": 1920,
"height": 1080
},
"_fitWidth": false,
"_fitHeight": true,
"_id": "d3fJPGqCZNr5EcI+Cccf+/"
},
{
"__type__": "1810cN/HlpB7LK654rJsVXg",
"_name": "",
"_objFlags": 0,
"node": {
"__id__": 2
},
"_enabled": true,
"SpineBoy": {
"__id__": 8
},
"_id": "c6mUGXnhFO9LwZvNL2dzK9"
}
]

7
examples/example2-2-2/assets/scene/Spine.fire.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.2.5",
"uuid": "e2a4478a-d1d7-4049-b006-7be03ae32f62",
"asyncLoadAssets": false,
"autoReleaseAssets": false,
"subMetas": {}
}

7
examples/example2-2-2/assets/script.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "fa7b3b8d-41ad-455f-b2c0-c542fc3b9d6c",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

7
examples/example2-2-2/assets/script/animator.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "1d876d7a-3ee1-4416-a86b-478e7a2291bc",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

90
examples/example2-2-2/assets/script/animator/AnimatorAnimation.ts Normal file
View File

@@ -0,0 +1,90 @@
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/**
* Cocos Animation状态机组件
*/
@ccclass
@disallowMultiple
@requireComponent(cc.Animation)
export default class AnimatorAnimation extends AnimatorBase {
/** Animation组件 */
private _animation: cc.Animation = null;
/** 当前的动画实例 */
private _animState: cc.AnimationState = null;
/** 记录初始的wrapmode */
private _wrapModeMap: Map<cc.AnimationState, cc.WrapMode> = new Map();
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._animation = this.getComponent(cc.Animation);
this._animation.on(cc.Animation.EventType.FINISHED, this.onAnimFinished, this);
this._animation.on(cc.Animation.EventType.LASTFRAME, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._animation = this.getComponent(cc.Animation);
this._animation.on(cc.Animation.EventType.FINISHED, this.onAnimFinished, this);
this._animation.on(cc.Animation.EventType.LASTFRAME, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (!animName) {
return;
}
this._animState = this._animation.play(animName);
if (!this._animState) {
return;
}
if (!this._wrapModeMap.has(this._animState)) {
this._wrapModeMap.set(this._animState, this._animState.wrapMode);
}
this._animState.wrapMode = loop ? cc.WrapMode.Loop : this._wrapModeMap.get(this._animState);
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
if (this._animState) {
this._animState.speed = scale;
}
}
}

9
examples/example2-2-2/assets/script/animator/AnimatorAnimation.ts.meta Normal file
View File

@@ -0,0 +1,9 @@
{
"ver": "1.0.5",
"uuid": "c0ecc4d1-4b6b-457f-90ff-bda6d5513a1c",
"isPlugin": false,
"loadPluginInWeb": true,
"loadPluginInNative": true,
"loadPluginInEditor": false,
"subMetas": {}
}

58
examples/example2-2-2/assets/script/animator/AnimatorCustomization.ts Normal file
View File

@@ -0,0 +1,58 @@
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/**
* 自定义动画控制的状态机组件
*/
@ccclass
@disallowMultiple
export default class AnimatorCustomization extends AnimatorBase {
/** 此组件必须主动调用onInit初始化 */
@property({ override: true, visible: false })
protected PlayOnStart: boolean = false;
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (this._animationPlayer && animName) {
this._animationPlayer.playAnimation(animName, loop);
}
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
if (this._animationPlayer) {
this._animationPlayer.scaleTime(scale);
}
}
}

9
examples/example2-2-2/assets/script/animator/AnimatorCustomization.ts.meta Normal file
View File

@@ -0,0 +1,9 @@
{
"ver": "1.0.5",
"uuid": "0e26f0aa-d7c7-489f-bb19-f153adc82108",
"isPlugin": false,
"loadPluginInWeb": true,
"loadPluginInNative": true,
"loadPluginInEditor": false,
"subMetas": {}
}

71
examples/example2-2-2/assets/script/animator/AnimatorDragonBones.ts Normal file
View File

@@ -0,0 +1,71 @@
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/**
* DragonBones状态机组件
*/
@ccclass
@disallowMultiple
@requireComponent(dragonBones.ArmatureDisplay)
export default class AnimatorDragonBones extends AnimatorBase {
/** DragonBones组件 */
private _dragonBones: dragonBones.ArmatureDisplay = null;
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._dragonBones = this.getComponent(dragonBones.ArmatureDisplay);
this._dragonBones.addEventListener(dragonBones.EventObject.COMPLETE, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._dragonBones = this.getComponent(dragonBones.ArmatureDisplay);
this._dragonBones.addEventListener(dragonBones.EventObject.COMPLETE, this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
animName && this._dragonBones.playAnimation(animName, loop ? 0 : -1);
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
this._dragonBones.timeScale = scale;
}
}

9
examples/example2-2-2/assets/script/animator/AnimatorDragonBones.ts.meta Normal file
View File

@@ -0,0 +1,9 @@
{
"ver": "1.0.5",
"uuid": "fa000d43-3009-42cd-9fe1-926c9209785c",
"isPlugin": false,
"loadPluginInWeb": true,
"loadPluginInNative": true,
"loadPluginInEditor": false,
"subMetas": {}
}

120
examples/example2-2-2/assets/script/animator/AnimatorSpine.ts Normal file
View File

@@ -0,0 +1,120 @@
import AnimatorSpineSecondary from "./AnimatorSpineSecondary";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent, disallowMultiple } = cc._decorator;
/**
* Spine状态机组件（主状态机），trackIndex为0
*/
@ccclass
@disallowMultiple
@requireComponent(sp.Skeleton)
export default class AnimatorSpine extends AnimatorBase {
/** spine组件 */
private _spine: sp.Skeleton = null;
/** 动画完成的回调 */
private _completeListenerMap: Map<(entry?: any) => void, any> = new Map();
/** 次状态机注册的回调 */
private _secondaryListenerMap: Map<(entry?: any) => void, AnimatorSpineSecondary> = new Map();
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._spine = this.getComponent(sp.Skeleton);
this._spine.setCompleteListener(this.onSpineComplete.bind(this));
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._spine = this.getComponent(sp.Skeleton);
this._spine.setCompleteListener(this.onSpineComplete.bind(this));
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
private onSpineComplete(entry: any) {
entry.trackIndex === 0 && this.onAnimFinished();
this._completeListenerMap.forEach((target, cb) => { target ? cb.call(target, entry) : cb(entry); });
this._secondaryListenerMap.forEach((target, cb) => { entry.trackIndex === target.TrackIndex && cb.call(target, entry); });
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (animName) {
this._spine.setAnimation(0, animName, loop);
} else {
this._spine.clearTrack(0);
}
}
/**
* 缩放动画播放速率
* @override
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
this._spine.timeScale = scale;
}
/**
* 注册次状态机动画结束的回调（状态机内部方法，不能由外部直接调用）
*/
public addSecondaryListener(cb: (entry?: any) => void, target: AnimatorSpineSecondary) {
this._secondaryListenerMap.set(cb, target);
}
/**
* 注册动画完成时的监听
* @param cb 回调
* @param target 调用回调的this对象
*/
public addCompleteListener(cb: (entry?: any) => void, target: any = null) {
if (this._completeListenerMap.has(cb)) {
return;
}
this._completeListenerMap.set(cb, target);
}
/**
* 注销动画完成的监听
* @param cb 回调
*/
public removeCompleteListener(cb: (entry?: any) => void) {
this._completeListenerMap.delete(cb);
}
/**
* 清空动画完成的监听
*/
public clearCompleteListener() {
this._completeListenerMap.clear;
}
}

9
examples/example2-2-2/assets/script/animator/AnimatorSpine.ts.meta Normal file
View File

@@ -0,0 +1,9 @@
{
"ver": "1.0.5",
"uuid": "81397024-6f01-43e4-8ce0-ec5d32635fc3",
"isPlugin": false,
"loadPluginInWeb": true,
"loadPluginInNative": true,
"loadPluginInEditor": false,
"subMetas": {}
}

72
examples/example2-2-2/assets/script/animator/AnimatorSpineSecondary.ts Normal file
View File

@@ -0,0 +1,72 @@
import AnimatorSpine from "./AnimatorSpine";
import AnimatorBase, { AnimationPlayer } from "./core/AnimatorBase";
import AnimatorStateLogic from "./core/AnimatorStateLogic";
const { ccclass, property, requireComponent } = cc._decorator;
/**
* Spine状态机组件（次状态机），同一节点可添加多个，用于在不同track中播放动画，trackIndex必须大于0
*/
@ccclass
@requireComponent(sp.Skeleton)
export default class AnimatorSpineSecondary extends AnimatorBase {
@property({ tooltip: CC_DEV && '动画播放的trackIndex，必须大于0' }) TrackIndex: number = 1;
/** 主状态机 */
private _main: AnimatorSpine = null;
/** spine组件 */
private _spine: sp.Skeleton = null;
protected start() {
if (!this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this._spine = this.getComponent(sp.Skeleton);
this._main = this.getComponent(AnimatorSpine);
this._main.addSecondaryListener(this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @override
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
if (this.PlayOnStart || this._hasInit) {
return;
}
this._hasInit = true;
this.initArgs(...args);
this._spine = this.getComponent(sp.Skeleton);
this._main = this.getComponent(AnimatorSpine);
this._main.addSecondaryListener(this.onAnimFinished, this);
if (this.AssetRawUrl !== null) {
this.initJson(this.AssetRawUrl.json);
}
}
/**
* 播放动画
* @override
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
if (animName) {
this._spine.setAnimation(this.TrackIndex, animName, loop);
} else {
this._spine.clearTrack(this.TrackIndex);
}
}
}

9
examples/example2-2-2/assets/script/animator/AnimatorSpineSecondary.ts.meta Normal file
View File

@@ -0,0 +1,9 @@
{
"ver": "1.0.5",
"uuid": "32504c5e-bda8-4d01-b957-cdac7a65d92f",
"isPlugin": false,
"loadPluginInWeb": true,
"loadPluginInNative": true,
"loadPluginInEditor": false,
"subMetas": {}
}

7
examples/example2-2-2/assets/script/animator/core.meta Normal file
View File

@@ -0,0 +1,7 @@
{
"ver": "1.0.1",
"uuid": "686e46ec-3c93-40c8-a343-98d92f38c904",
"isSubpackage": false,
"subpackageName": "",
"subMetas": {}
}

227
examples/example2-2-2/assets/script/animator/core/AnimatorBase.ts Normal file
View File

@@ -0,0 +1,227 @@
import AnimatorController from "./AnimatorController";
import AnimatorState from "./AnimatorState";
import AnimatorStateLogic from "./AnimatorStateLogic";
const { ccclass, property, executionOrder } = cc._decorator;
/**
* 自定义控制动画播放的接口
*/
export interface AnimationPlayer {
/** 设置动画播放结束的回调 */
setFinishedCallback(callback: () => void, target: any): void;
/** 播放动画 */
playAnimation(animName: string, loop: boolean): void;
/** 缩放动画播放速率 */
scaleTime(scale: number): void;
}
/**
* 状态机组件基类 优先执行生命周期
*/
@ccclass
@executionOrder(-1000)
export default class AnimatorBase extends cc.Component {
@property({ type: cc.JsonAsset, tooltip: CC_DEV && '状态机json文件' })
protected AssetRawUrl: cc.JsonAsset = null;
@property({ tooltip: CC_DEV && '是否在start中自动启动状态机' })
protected PlayOnStart: boolean = true;
@property({ tooltip: CC_DEV && '是否在update中自动触发状态机逻辑更新' })
protected AutoUpdate: boolean = true;
/** 是否初始化 */
protected _hasInit: boolean = false;
/** 状态机控制 */
protected _ac: AnimatorController = null;
/** 各个状态逻辑控制，key为状态名 */
protected _stateLogicMap: Map<string, AnimatorStateLogic> = null;
/** 状态切换时的回调 */
protected _onStateChangeCall: (fromState: string, toState: string) => void = null;
/** 自定义的动画播放控制器 */
protected _animationPlayer: AnimationPlayer = null;
/** 当前状态名 */
public get curStateName(): string {
return this._ac.curState.name;
}
/** 当前动画名 */
public get curStateMotion(): string {
return this._ac.curState.motion;
}
/**
* 手动初始化状态机，可传入0-3个参数，类型如下
* - onStateChangeCall 状态切换时的回调
* - stateLogicMap 各个状态逻辑控制
* - animationPlayer 自定义动画控制
* @virtual
*/
public onInit(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
}
/**
* 处理初始化参数
*/
protected initArgs(...args: Array<Map<string, AnimatorStateLogic> | ((fromState: string, toState: string) => void) | AnimationPlayer>) {
args.forEach((arg) => {
if (!arg) {
return;
}
if (typeof arg === 'function') {
this._onStateChangeCall = arg;
} else if (typeof arg === 'object') {
if (arg instanceof Map) {
this._stateLogicMap = arg;
} else {
this._animationPlayer = arg;
this._animationPlayer.setFinishedCallback(this.onAnimFinished, this);
}
}
});
}
private updateAnimator() {
// 混合当前动画播放速度
let playSpeed = this._ac.curState.speed;
if (this._ac.curState.multi) {
playSpeed *= this._ac.params.getNumber(this._ac.curState.multi) || 1;
}
this.scaleTime(playSpeed);
// 更新AnimatorStateLogic
if (this._stateLogicMap) {
let curLogic = this._stateLogicMap.get(this._ac.curState.name);
curLogic && curLogic.onUpdate();
}
// 更新状态机逻辑
this._ac.updateAnimator();
}
protected update() {
if (this._hasInit && this.AutoUpdate) {
this.updateAnimator();
}
}
/**
* 手动调用更新
*/
public manualUpdate() {
if (this._hasInit && !this.AutoUpdate) {
this.updateAnimator();
}
}
/**
* 解析状态机json文件
*/
protected initJson(json: any) {
this._ac = new AnimatorController(this, json);
}
/**
* 动画结束的回调
*/
protected onAnimFinished() {
this._ac.onAnimationComplete();
}
/**
* 播放动画
* @virtual
* @param animName 动画名
* @param loop 是否循环播放
*/
protected playAnimation(animName: string, loop: boolean) {
}
/**
* 缩放动画播放速率
* @virtual
* @param scale 缩放倍率
*/
protected scaleTime(scale: number) {
}
/**
* 状态切换时的逻辑（状态机内部方法，不能由外部直接调用）
*/
public onStateChange(fromState: AnimatorState, toState: AnimatorState) {
this.playAnimation(toState.motion, toState.loop);
let fromStateName = fromState ? fromState.name : '';
if (this._stateLogicMap) {
let fromLogic = this._stateLogicMap.get(fromStateName);
fromLogic && fromLogic.onExit();
let toLogic = this._stateLogicMap.get(toState.name);
toLogic && toLogic.onEntry();
}
this._onStateChangeCall && this._onStateChangeCall(fromStateName, toState.name);
}
/**
* 设置boolean类型参数的值
*/
public setBool(key: string, value: boolean) {
this._ac.params.setBool(key, value);
}
/**
* 获取boolean类型参数的值
*/
public getBool(key: string): boolean {
return this._ac.params.getBool(key) !== 0;
}
/**
* 设置number类型参数的值
*/
public setNumber(key: string, value: number) {
this._ac.params.setNumber(key, value);
}
/**
* 获取number类型参数的值
*/
public getNumber(key: string): number {
return this._ac.params.getNumber(key);
}
/**
* 设置trigger类型参数的值
*/
public setTrigger(key: string) {
this._ac.params.setTrigger(key);
}
/**
* 重置trigger类型参数的值
*/
public resetTrigger(key: string) {
this._ac.params.resetTrigger(key);
}
/**
* 设置autoTrigger类型参数的值（autoTrigger类型参数不需要主动reset，每次状态机更新结束后会自动reset）
*/
public autoTrigger(key: string) {
this._ac.params.autoTrigger(key);
}
/**
* 无视条件直接跳转状态
* @param 状态名
*/
public play(stateName: string) {
if (!this._hasInit) {
return;
}
this._ac.play(stateName);
}
}

Some files were not shown because too many files have changed in this diff Show More