CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新增sceneTransition 用于场景过渡

Browse Source
This commit is contained in:
YHH
2020-06-21 10:27:15 +08:00
parent 60646edd6b
commit 3d9730d956
22 changed files with 2292 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/src/ECS/Components/SpriteRenderer.ts
View File

@@ -76,10 +76,10 @@ class SpriteRenderer extends RenderableComponent {
this._bitmap.x = this.entity.transform.position.x - camera.transform.position.x + camera.origin.x;
this._bitmap.y = this.entity.transform.position.y - camera.transform.position.y + camera.origin.y;
this._bitmap.rotation = this.entity.transform.rotation;
this._bitmap.rotation = this.entity.transform.rotation + camera.transform.rotation;
this._bitmap.anchorOffsetX = this._origin.x;
this._bitmap.anchorOffsetY = this._origin.y;
this._bitmap.scaleX = this.entity.transform.scale.x;
this._bitmap.scaleY = this.entity.transform.scale.y;
this._bitmap.scaleX = this.entity.transform.scale.x * camera.transform.scale.x;
this._bitmap.scaleY = this.entity.transform.scale.y * camera.transform.scale.y;
}
}

69
source/src/ECS/Scene.ts
View File

@@ -3,11 +3,13 @@ class Scene extends egret.DisplayObjectContainer {
public camera: Camera;
public readonly entities: EntityList;
public readonly renderableComponents: RenderableComponentList;
public readonly content: ContentManager;
private _projectionMatrix: Matrix2D;
private _transformMatrix: Matrix2D;
private _matrixTransformMatrix: Matrix2D;
private _renderers: Renderer[] = [];
private _didSceneBegin;
public readonly entityProcessors: EntityProcessorList;
@@ -18,10 +20,10 @@ class Scene extends egret.DisplayObjectContainer {
this.entityProcessors = new EntityProcessorList();
this.renderableComponents = new RenderableComponentList();
this.entities = new EntityList(this);
this.content = new ContentManager();
this.addEventListener(egret.Event.ACTIVATE, this.onActive, this);
this.addEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
this.addEventListener(egret.Event.ENTER_FRAME, this.update, this);
}
public createEntity(name: string) {
@@ -68,12 +70,6 @@ class Scene extends egret.DisplayObjectContainer {
return this.entityProcessors.getProcessor<T>();
}
public setActive(): Scene {
SceneManager.setActiveScene(this);
return this;
}
public addRenderer<T extends Renderer>(renderer: T) {
this._renderers.push(renderer);
this._renderers.sort();
@@ -96,8 +92,7 @@ class Scene extends egret.DisplayObjectContainer {
this._renderers.remove(renderer);
}
/** 初始化场景 */
public initialize() {
public begin(){
if (this._renderers.length == 0) {
this.addRenderer(new DefaultRenderer());
console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染");
@@ -106,32 +101,49 @@ class Scene extends egret.DisplayObjectContainer {
this.camera = this.createEntity("camera").getOrCreateComponent(new Camera());
Physics.reset();
Input.initialize();
if (this.entityProcessors)
this.entityProcessors.begin();
this.camera.onSceneSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
this._didSceneBegin = true;
this.onStart();
}
public end(){
this._didSceneBegin = false;
this.removeEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
this.entities.removeAllEntities();
Physics.clear();
this.camera.destory();
this.camera = null;
this.content.dispose();
if (this.entityProcessors)
this.entityProcessors.end();
}
protected onStart(){
}
/** 场景激活 */
public onActive() {
protected onActive() {
}
/** 场景失去焦点 */
public onDeactive() {
protected onDeactive() {
}
public update() {
Time.update(egret.getTimer());
for (let i = GlobalManager.globalManagers.length - 1; i >= 0; i--) {
if (GlobalManager.globalManagers[i].enabled)
GlobalManager.globalManagers[i].update();
}
this.entities.updateLists();
if (this.entityProcessors)
@@ -143,7 +155,6 @@ class Scene extends egret.DisplayObjectContainer {
this.entityProcessors.lateUpdate();
this.renderableComponents.updateList();
this.render();
}
public render(){
@@ -154,22 +165,4 @@ class Scene extends egret.DisplayObjectContainer {
this._renderers[i].render(this);
}
}
public prepRenderState() {
this._projectionMatrix.m11 = 2 / this.stage.stageWidth;
this._projectionMatrix.m22 = -2 / this.stage.stageHeight;
this._transformMatrix = this.camera.transformMatrix;
this._matrixTransformMatrix = Matrix2D.multiply(this._transformMatrix, this._projectionMatrix);
}
public destory() {
this.removeEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
this.camera.destory();
this.camera = null;
this.entities.removeAllEntities();
}
}

110
source/src/ECS/SceneManager.ts
View File

@@ -1,40 +1,94 @@
/** 运行时的场景管理。 */
class SceneManager {
private static _loadedScenes: Map<string, Scene> = new Map();
/** 上一个场景 */
private static _lastScene: Scene;
/** 当前激活的场景 */
private static _activeScene: Scene;
private static _scene: Scene;
private static _nextScene: Scene;
public static sceneTransition: SceneTransition;
/**
* 使用给定的名称在运行时创建一个空的新场景。
* 新场景将与当前打开的任何现有场景一起被添加到层次结构中。
* 这个函数用于在运行时创建场景。
* @param name
* @param scene
*/
public static createScene(name: string, scene: Scene){
scene.name = name;
this._loadedScenes.set(name, scene);
return scene;
constructor(stage: egret.Stage) {
stage.addEventListener(egret.Event.ENTER_FRAME, SceneManager.update, this);
SceneManager.initialize(stage);
}
public static setActiveScene(scene: Scene){
if (this._activeScene){
// 如果场景相同则不进行切换
if (this._activeScene == scene)
return;
public static get scene() {
return this._scene;
}
public static set scene(value: Scene) {
if (!value)
throw new Error("场景不能为空");
this._lastScene = this._activeScene;
this._activeScene.destory();
if (this._scene == null) {
this._scene = value;
this._scene.begin();
} else {
this._nextScene = value;
}
}
public static initialize(stage: egret.Stage) {
Input.initialize(stage);
}
public static update() {
Time.update(egret.getTimer());
if (SceneManager._scene) {
for (let i = GlobalManager.globalManagers.length - 1; i >= 0; i--) {
if (GlobalManager.globalManagers[i].enabled)
GlobalManager.globalManagers[i].update();
}
if (!SceneManager.sceneTransition ||
(SceneManager.sceneTransition && (!SceneManager.sceneTransition.loadsNewScene || SceneManager.sceneTransition.isNewSceneLoaded))) {
SceneManager._scene.update();
}
if (SceneManager._nextScene) {
SceneManager._scene.end();
for (let i = 0; i < SceneManager._scene.entities.buffer.length; i++) {
let entity = SceneManager._scene.entities.buffer[i];
entity.destory();
}
SceneManager._scene = SceneManager._nextScene;
SceneManager._nextScene = null;
SceneManager._scene.begin();
}
}
this._activeScene = scene;
this._activeScene.initialize();
return scene;
SceneManager.render();
}
public static getActiveScene(){
return this._activeScene;
public static render() {
if (this.sceneTransition)
this.sceneTransition.preRender();
if (this.sceneTransition) {
if (this._scene && this.sceneTransition.wantsPreviousSceneRender && !this.sceneTransition.hasPreviousSceneRender) {
this._scene.render();
this.sceneTransition.onBeginTransition();
} else if (this._scene && this.sceneTransition.isNewSceneLoaded) {
this._scene.render();
}
this.sceneTransition.render();
} else if (this.scene) {
this.scene.render();
}
}
/**
* 临时运行SceneTransition，允许一个场景过渡到另一个平滑的自定义效果。
* @param sceneTransition
*/
public static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T {
if (!this.sceneTransition) {
throw new Error("在前一个场景完成之前，不能开始一个新的场景转换。");
}
this.sceneTransition = sceneTransition;
return sceneTransition;
}
}

2
source/src/Graphics/Renderers/Renderer.ts
View File

@@ -18,7 +18,7 @@ abstract class Renderer {
protected beginRender(cam: Camera){
cam.transform.updateTransform();
let entities = SceneManager.getActiveScene().entities;
let entities = SceneManager.scene.entities;
for (let i = 0; i < entities.buffer.length; i ++){
entities.buffer[i].transform.updateTransform();
}

33
source/src/Graphics/Transitions/FadeTransition.ts Normal file
View File

@@ -0,0 +1,33 @@
///<reference path="./SceneTransition.ts"/>
class FadeTransition extends SceneTransition {
public fadeToColor: number = 0x000000;
public fadeOutDuration = 0.4;
private _color: number = 0xFFFFFF;
private _toColor: number = 0xFFFFFF;
private _destinationRect: Rectangle;
private _overlayTexture: egret.RenderTexture;
constructor(sceneLoadAction: Function){
super(sceneLoadAction, true);
this._destinationRect = new Rectangle(0, 0, this.previousSceneRender.textureWidth, this.previousSceneRender.textureHeight);
}
// public onBeginTransition(){
// this._overlayTexture = new egret.RenderTexture();
// let shape = new egret.Shape();
// shape.graphics.beginFill(0xFFFFFF, 1);
// shape.graphics.drawRect(0, 0, 1, 1);
// shape.graphics.endFill();
// this._overlayTexture.drawToTexture(shape);
// let elapsed = 0;
// let _toColor;
// while (elapsed < this.fadeOutDuration){
// elapsed += Time.deltaTime;
// // egret.Tween.get(this).to({_color: this._toColor, })
// }
// }
}

86
source/src/Graphics/Transitions/SceneTransition.ts Normal file
View File

@@ -0,0 +1,86 @@
/**
* SceneTransition用于从一个场景过渡到另一个场景或在一个有效果的场景中过渡
*/
abstract class SceneTransition {
/** 是否加载新场景的标志 */
public loadsNewScene: boolean;
/**
* 将此用于两个部分的转换。例如，淡出会先淡出到黑色，然后当isNewSceneLoaded为true，它会淡出。
* 对于场景过渡，isNewSceneLoaded应该在中点设置为true，这就标识一个新的场景被加载了。
*/
public isNewSceneLoaded: boolean;
/**
* 如果为true
* 会将之前的场景渲染到previousSceneRender中，这样你就可以在转换时使用它
*/
public wantsPreviousSceneRender: boolean;
/** 返回新加载场景的函数 */
protected sceneLoadAction: Function;
/** 包含上一个场景的最后渲染。可以用来在加载新场景时模糊屏幕。 */
public previousSceneRender: egret.RenderTexture;
/** 在loadNextScene执行时调用。这在进行场景间过渡时很有用，这样你就知道什么时候可以更多地使用相机或者重置任何实体 */
public onScreenObscured: Function;
/** 当转换完成执行时调用，以便可以调用其他工作，比如启动另一个转换。 */
public onTransitionCompleted: Function;
public progress: number = 0;
constructor(sceneLoadAction: Function, wantsPreviousSceneRender: boolean = true) {
this.sceneLoadAction = sceneLoadAction;
this.wantsPreviousSceneRender = wantsPreviousSceneRender;
this.loadsNewScene = sceneLoadAction != null;
if (wantsPreviousSceneRender)
this.previousSceneRender = new egret.RenderTexture();
}
private _hasPreviousSceneRender;
public get hasPreviousSceneRender() {
if (!this._hasPreviousSceneRender) {
this._hasPreviousSceneRender = true;
return false;
}
return true;
}
public preRender() { }
public render(){
}
public onBeginTransition(): Promise<any> {
return new Promise((resolve) => {
resolve(this.loadScene());
this.transitionComplete();
});
}
protected transitionComplete() {
SceneManager.sceneTransition = null;
if (this.previousSceneRender){
this.previousSceneRender.dispose();
this.previousSceneRender = null;
}
if (this.onTransitionCompleted){
this.onTransitionCompleted();
}
}
protected loadScene(): Promise<any> {
return new Promise(async (resolve) => {
if (this.onScreenObscured)
this.onScreenObscured();
if (!this.loadsNewScene) {
this.isNewSceneLoaded = true;
resolve();
}
SceneManager.scene = await this.sceneLoadAction();
this.isNewSceneLoaded = true;
});
}
}

1092
source/src/Math/long.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

4
source/src/Physics/Physics.ts
View File

@@ -9,6 +9,10 @@ class Physics {
this._spatialHash = new SpatialHash(this.spatialHashCellSize);
}
public static clear(){
this._spatialHash.clear();
}
public static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask = -1){
return this._spatialHash.overlapCircle(center, randius, results, layerMask);
}

4
source/src/Physics/Shapes/Polygon.ts
View File

@@ -53,10 +53,8 @@ class Polygon extends Shape {
public collidesWithShape(other: Shape){
let result = new CollisionResult();
if (other instanceof Polygon){
result = ShapeCollisions.polygonToPolygon(this, other);
return result;
return ShapeCollisions.polygonToPolygon(this, other);
}
if (other instanceof Circle){
result = ShapeCollisions.circleToPolygon(other, this);

4
source/src/Physics/Verlet/SpatialHash.ts
View File

@@ -52,6 +52,10 @@ class SpatialHash {
}
}
public clear(){
this._cellDict.clear();
}
public overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask) {
let bounds = new Rectangle(circleCenter.x - radius, circleCenter.y - radius, radius * 2, radius * 2);

41
source/src/Utils/ContentManager.ts Normal file
View File

@@ -0,0 +1,41 @@
class ContentManager {
protected loadedAssets: Map<string, any> = new Map<string, any>();
/** 异步加载资源 */
public load(name: string, local: boolean = true): Promise<any> {
return new Promise((resolve, reject) => {
let res = this.loadedAssets.get(name);
if (res) {
resolve(res);
return;
}
if (local) {
RES.getResAsync(name).then((data) => {
this.loadedAssets.set(name, data);
resolve(data);
}).catch((err) => {
console.error("资源加载错误:", name, err);
reject(err);
});
} else {
RES.getResByUrl(name).then((data) => {
this.loadedAssets.set(name, data);
resolve(data);
}).catch((err) => {
console.error("资源加载错误:", name, err);
reject(err);
});
}
})
}
public dispose(){
this.loadedAssets.forEach(value => {
let assetsToRemove = value;
assetsToRemove.dispose();
});
this.loadedAssets.clear();
}
}

8
source/src/Utils/Input.ts
View File

@@ -6,7 +6,7 @@ class TouchState {
public get position(){
return new Vector2(this.x, this.y);
}
public reset(){
this.x = 0;
this.y = 0;
@@ -26,6 +26,8 @@ class Input {
private static _totalTouchCount: number = 0;
/** 返回第一个触摸点的坐标 */
public static get touchPosition(){
if (!this._gameTouchs[0])
return Vector2.zero;
return this._gameTouchs[0].position;
}
/** 获取最大触摸数 */
@@ -65,12 +67,12 @@ class Input {
return delta;
}
public static initialize(){
public static initialize(stage: egret.Stage){
if (this._init)
return;
this._init = true;
this._stage = SceneManager.getActiveScene().stage;
this._stage = stage;
this._stage.addEventListener(egret.TouchEvent.TOUCH_BEGIN, this.touchBegin, this);
this._stage.addEventListener(egret.TouchEvent.TOUCH_MOVE, this.touchMove, this);
this._stage.addEventListener(egret.TouchEvent.TOUCH_END, this.touchEnd, this);