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

移除Graphics相关

Browse Source
This commit is contained in:
yhh
2020-11-30 18:23:03 +08:00
parent 0137309d3a
commit 0d8878abef
10 changed files with 20 additions and 1042 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
source/src/ECS/Core.ts
View File

@@ -25,7 +25,6 @@ module es {
public static entitySystemsEnabled: boolean;
public _nextScene: Scene;
public _sceneTransition: SceneTransition;
/**
* 用于凝聚GraphicsDeviceReset事件
*/
@@ -94,20 +93,6 @@ module es {
}
}
/**
* 临时运行SceneTransition，允许一个场景过渡到另一个平滑的自定义效果。
* @param sceneTransition
*/
public static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T {
if (this._instance._sceneTransition) {
console.warn("在前一个场景完成之前，不能开始一个新的场景转换。");
return;
}
this._instance._sceneTransition = sceneTransition;
return sceneTransition;
}
/**
* 添加一个全局管理器对象，它的更新方法将调用场景前的每一帧。
* @param manager
@@ -153,34 +138,6 @@ module es {
Core.emitter.emit(CoreEvents.OrientationChanged);
}
public async draw() {
this.startDebugDraw();
if (this._sceneTransition != null) {
this._sceneTransition.preRender();
// 如果有的话，我们会对SceneTransition进行特殊处理。
// 我们要么渲染SceneTransition，要么渲染Scene的
if (this._sceneTransition != null){
if (this._scene != null && !this._sceneTransition.hasPreviousSceneRender) {
this._scene.render();
this._scene.postRender();
await this._sceneTransition.onBeginTransition();
} else if (this._scene != null && this._sceneTransition.isNewSceneLoaded) {
this._scene.render();
this._scene.postRender();
}
this._sceneTransition.render();
}
} else if (this._scene) {
this._scene.render();
// 如如果我们没有一个活动的SceneTransition，就像往常一样渲染
this._scene.postRender();
}
}
public startDebugDraw() {
this._frameCounter ++;
this._frameCounterElapsedTime += Time.deltaTime;
@@ -230,15 +187,7 @@ module es {
this._globalManagers.buffer[i].update();
}
// 仔细阅读:
// 当场景转换发生时，我们不更新场景
// - 除非是不改变场景的SceneTransition(没有理由不更新)
// - 或者是一个已经切换到新场景的SceneTransition（新场景需要做它的事情）
if (this._sceneTransition == null ||
(this._sceneTransition != null &&
(!this._sceneTransition.loadsNewScene || this._sceneTransition.isNewSceneLoaded))) {
this._scene.update();
}
this._scene.update();
if (this._nextScene != null) {
this._scene.end();
@@ -251,7 +200,7 @@ module es {
}
}
await this.draw();
this.startDebugDraw();
}
}
}

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

@@ -5,22 +5,16 @@ module es {
* 这个场景中的实体列表
*/
public readonly entities: EntityList;
/**
* 管理当前在场景实体上的所有可呈现组件的列表
*/
public readonly renderableComponents: RenderableComponentList;
/**
* 管理所有实体处理器
*/
public readonly entityProcessors: EntityProcessorList;
public readonly _sceneComponents: FastList<SceneComponent> = new FastList<SceneComponent>();
public _renderers: Renderer[] = [];
public _didSceneBegin;
constructor() {
this.entities = new EntityList(this);
this.renderableComponents = new RenderableComponentList();
if (Core.entitySystemsEnabled)
this.entityProcessors = new EntityProcessorList();
@@ -66,10 +60,6 @@ module es {
public end() {
this._didSceneBegin = false;
for (let i = 0; i < this._renderers.length; i++) {
this._renderers[i].unload();
}
Core.emitter.removeObserver(CoreEvents.GraphicsDeviceReset, this.updateResolutionScaler);
Core.emitter.removeObserver(CoreEvents.OrientationChanged, this.updateResolutionScaler);
@@ -110,23 +100,6 @@ module es {
if (this.entityProcessors != null)
this.entityProcessors.lateUpdate();
// 我们在entity.update之后更新我们的renderables，以防止任何新的Renderables被添加
this.renderableComponents.updateList();
}
public render() {
for (let i = 0; i < this._renderers.length; i++) {
this._renderers[i].render(this);
}
}
/**
* 现在的任何后处理器都要完成它的处理
* 只有在SceneTransition请求渲染时，它才会有一个值。
*/
public postRender() {
}
/**
@@ -181,44 +154,6 @@ module es {
component.onRemovedFromScene();
}
/**
* 为场景添加一个渲染器
* @param renderer
*/
public addRenderer<T extends Renderer>(renderer: T) {
this._renderers.push(renderer);
this._renderers.sort();
renderer.onAddedToScene(this);
return renderer;
}
/**
* 获取类型为T的第一个渲染器
* @param type
*/
public getRenderer<T extends Renderer>(type): T {
for (let i = 0; i < this._renderers.length; i++) {
if (this._renderers[i] instanceof type)
return this._renderers[i] as T;
}
return null;
}
/**
* 从场景中移除渲染器
* @param renderer
*/
public removeRenderer(renderer: Renderer) {
let rendererList = new linq.List(this._renderers);
if (!rendererList.contains(renderer))
return;
rendererList.remove(renderer);
renderer.unload();
}
/**
* 将实体添加到此场景，并返回它
* @param name

110
source/src/ECS/Utils/RenderableComponentList.ts
View File

@@ -1,110 +0,0 @@
///<reference path="../../Graphics/Renderers/IRenderable.ts" />
module es {
export class RenderableComponentList {
/**
* IRenderable列表的全局updatePrder排序
*/
public static compareUpdatableOrder = new RenderableComparer();
/**
* 添加到实体的组件列表
*/
public _components: IRenderable[] = [];
/**
* 通过渲染层跟踪组件，便于检索
*/
public _componentsByRenderLayer: Map<number, IRenderable[]> = new Map<number, IRenderable[]>();
public _unsortedRenderLayers: number[] = [];
private _componentsNeedSort: boolean = true;
public get componentsNeedSort(): boolean {
return this._componentsNeedSort;
}
public set componentsNeedSort(value: boolean) {
this._componentsNeedSort = value;
}
public get count() {
return this._components.length;
}
public get buffer() {
return this._components;
}
public add(component: IRenderable) {
this._components.push(component);
this.addToRenderLayerList(component, component.renderLayer);
}
public remove(component: IRenderable) {
new linq.List(this._components).remove(component);
new linq.List(this._componentsByRenderLayer.get(component.renderLayer)).remove(component);
}
public updateRenderableRenderLayer(component: IRenderable, oldRenderLayer: number, newRenderLayer: number) {
// 需要注意的是，如果渲染层在组件update之前发生了改变
let oldRenderLayers = new linq.List(this._componentsByRenderLayer.get(oldRenderLayer));
if (this._componentsByRenderLayer.has(oldRenderLayer) && oldRenderLayers.contains(component)) {
oldRenderLayers.remove(component);
this.addToRenderLayerList(component, newRenderLayer);
}
}
/**
* 将渲染层排序标志弄脏，让所有组件重新排序
* @param renderLayer
*/
public setRenderLayerNeedsComponentSort(renderLayer: number) {
let unsortedRenderLayers = new linq.List(this._unsortedRenderLayers);
if (!unsortedRenderLayers.contains(renderLayer))
unsortedRenderLayers.add(renderLayer);
this.componentsNeedSort = true;
}
public setNeedsComponentSort() {
this.componentsNeedSort = true;
}
public addToRenderLayerList(component: IRenderable, renderLayer: number) {
let list = new linq.List(this.componentsWithRenderLayer(renderLayer));
if (list.contains(component)) {
console.warn("组件呈现层列表已经包含此组件");
return;
}
list.add(component);
let unsortedRenderLayers = new linq.List(this._unsortedRenderLayers);
if (!unsortedRenderLayers.contains(renderLayer))
unsortedRenderLayers.add(renderLayer);
this.componentsNeedSort = true;
}
/**
* 使用给定的渲染层获取所有组件。组件列表是预先排序的
* @param renderLayer
*/
public componentsWithRenderLayer(renderLayer: number): IRenderable[] {
if (!this._componentsByRenderLayer.get(renderLayer)) {
this._componentsByRenderLayer.set(renderLayer, []);
}
return this._componentsByRenderLayer.get(renderLayer);
}
public updateList() {
if (this.componentsNeedSort) {
this._components.sort(RenderableComponentList.compareUpdatableOrder.compare);
this.componentsNeedSort = false;
}
if (this._unsortedRenderLayers.length > 0) {
for (let i = 0, count = this._unsortedRenderLayers.length; i < count; i++) {
let renderLayerComponents = this._componentsByRenderLayer.get(this._unsortedRenderLayers[i]);
if (renderLayerComponents) {
renderLayerComponents.sort(RenderableComponentList.compareUpdatableOrder.compare);
}
}
this._unsortedRenderLayers.length = 0;
}
}
}
}