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

主版本（支持渲染版本移动分支至support_engine）

Browse Source
This commit is contained in:
yhh
2021-01-13 13:09:04 +08:00
parent 6699c32f73
commit eca9ba7b82
23 changed files with 607 additions and 2300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
source/src/Core.ts Normal file
View File

@@ -0,0 +1,197 @@
module es {
/**
* 全局核心类
*/
export class Core {
/**
* 核心发射器。只发出核心级别的事件
*/
public static emitter: Emitter<CoreEvents>;
/**
* 启用/禁用焦点丢失时的暂停。如果为真，则不调用更新或渲染方法
*/
public static pauseOnFocusLost = true;
/**
* 是否启用调试渲染
*/
public static debugRenderEndabled = false;
/**
* 简化对内部类的全局内容实例的访问
*/
public static _instance: Core;
/**
* 用于确定是否应该使用EntitySystems
*/
public static entitySystemsEnabled: boolean;
public _nextScene: Scene;
/**
* 用于凝聚GraphicsDeviceReset事件
*/
public _graphicsDeviceChangeTimer: ITimer;
/**
* 全局访问系统
*/
public _globalManagers: GlobalManager[] = [];
public _coroutineManager: CoroutineManager = new CoroutineManager();
public _timerManager: TimerManager = new TimerManager();
public width: number;
public height: number;
constructor(width: number, height: number, enableEntitySystems: boolean = true) {
this.width = width;
this.height = height;
Core._instance = this;
Core.emitter = new Emitter<CoreEvents>();
Core.emitter.addObserver(CoreEvents.frameUpdated, this.update, this);
Core.registerGlobalManager(this._coroutineManager);
Core.registerGlobalManager(this._timerManager);
Core.entitySystemsEnabled = enableEntitySystems;
this.initialize();
}
/**
* 提供对单例/游戏实例的访问
* @constructor
*/
public static get Instance() {
return this._instance;
}
public _frameCounterElapsedTime: number = 0;
public _frameCounter: number = 0;
public _totalMemory: number = 0;
public _titleMemory: (totalMemory: number, frameCounter: number) => void;
public _scene: Scene;
/**
* 当前活动的场景。注意，如果设置了该设置，在更新结束之前场景实际上不会改变
*/
public static get scene() {
if (!this._instance)
return null;
return this._instance._scene;
}
/**
* 当前活动的场景。注意，如果设置了该设置，在更新结束之前场景实际上不会改变
* @param value
*/
public static set scene(value: Scene) {
if (!value) {
console.error("场景不能为空");
return;
}
if (this._instance._scene == null) {
this._instance._scene = value;
this._instance.onSceneChanged();
this._instance._scene.begin();
} else {
this._instance._nextScene = value;
}
}
/**
* 添加一个全局管理器对象，它的更新方法将调用场景前的每一帧。
* @param manager
*/
public static registerGlobalManager(manager: es.GlobalManager) {
this._instance._globalManagers.push(manager);
manager.enabled = true;
}
/**
* 删除全局管理器对象
* @param manager
*/
public static unregisterGlobalManager(manager: es.GlobalManager) {
new linq.List(this._instance._globalManagers).remove(manager);
manager.enabled = false;
}
/**
* 获取类型为T的全局管理器
* @param type
*/
public static getGlobalManager<T extends es.GlobalManager>(type): T {
for (let i = 0; i < this._instance._globalManagers.length; i++) {
if (this._instance._globalManagers[i] instanceof type)
return this._instance._globalManagers[i] as T;
}
return null;
}
/**
* 启动一个coroutine。Coroutine可以将number延时几秒或延时到其他startCoroutine.Yielding
* null将使coroutine在下一帧被执行。
* @param enumerator
*/
public static startCoroutine(enumerator): ICoroutine {
return this._instance._coroutineManager.startCoroutine(enumerator);
}
/**
* 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
* @param timeInSeconds
* @param repeats
* @param context
* @param onTime
*/
public static schedule(timeInSeconds: number, repeats: boolean = false, context: any = null, onTime: (timer: ITimer) => void) {
return this._instance._timerManager.schedule(timeInSeconds, repeats, context, onTime);
}
public startDebugDraw() {
this._frameCounter++;
this._frameCounterElapsedTime += Time.deltaTime;
if (this._frameCounterElapsedTime >= 1) {
let memoryInfo = window.performance["memory"];
if (memoryInfo != null) {
this._totalMemory = Number((memoryInfo.totalJSHeapSize / 1048576).toFixed(2));
}
if (this._titleMemory) this._titleMemory(this._totalMemory, this._frameCounter);
this._frameCounter = 0;
this._frameCounterElapsedTime -= 1;
}
}
/**
* 在一个场景结束后，下一个场景开始之前调用
*/
public onSceneChanged() {
Time.sceneChanged();
}
protected initialize() {
}
protected async update(currentTime?: number) {
if (currentTime != null) Time.update(currentTime);
if (this._scene != null) {
for (let i = this._globalManagers.length - 1; i >= 0; i--) {
if (this._globalManagers[i].enabled)
this._globalManagers[i].update();
}
this._scene.update();
if (this._nextScene != null) {
this._scene.end();
this._scene = this._nextScene;
this._nextScene = null;
this.onSceneChanged();
this._scene.begin();
}
}
this.startDebugDraw();
}
}
}

3
source/src/ECS/Component.ts
View File

@@ -78,9 +78,6 @@ module es {
public onEntityTransformChanged(comp: transform.Component) {
}
public debugRender(batcher: IBatcher) {
}
/**
*当父实体或此组件启用时调用
*/

8
source/src/ECS/Components/Physics/Colliders/BoxCollider.ts
View File

@@ -84,14 +84,6 @@ module es {
}
}
public debugRender(batcher: IBatcher) {
let poly = this.shape as Polygon;
batcher.drawHollowRect(this.bounds, Debug.colliderBounds, 1);
batcher.drawPolygon(this.shape.position, poly.points, Debug.colliderEdge, true, 1);
batcher.drawPixel(this.entity.transform.position, Debug.colliderPosition, 4);
batcher.drawPixel(Vector2.add(this.entity.transform.position, this.shape.center), Debug.colliderCenter, 2);
}
public toString() {
return `[BoxCollider: bounds: ${this.bounds}]`;
}

7
source/src/ECS/Components/Physics/Colliders/CircleCollider.ts
View File

@@ -40,13 +40,6 @@ module es {
return this;
}
public debugRender(batcher: IBatcher) {
batcher.drawHollowRect(this.bounds, Debug.colliderBounds, 1);
batcher.drawCircle(this.shape.position, (this.shape as Circle).radius, Debug.colliderEdge, 1);
batcher.drawPixel(this.entity.transform.position, Debug.colliderPosition, 4);
batcher.drawPixel(this.shape.position, Debug.colliderCenter, 2);
}
public toString() {
return `[CircleCollider: bounds: ${this.bounds}, radius: ${(this.shape as Circle).radius}]`
}

26
source/src/ECS/Components/Physics/Colliders/Collider.ts
View File

@@ -114,32 +114,6 @@ module es {
}
public onAddedToEntity() {
if (this._colliderRequiresAutoSizing) {
Insist.isTrue(this instanceof BoxCollider || this instanceof CircleCollider, "只有框和圆的碰撞器可以自动创建");
let renderable = this.entity.getComponent<RenderableComponent>(RenderableComponent);
if (renderable == null)
console.warn("Collider没有形状，也没有RenderableComponent。不知道如何确定它的大小。");
if (renderable != null) {
let renderableBounds = renderable.bounds.clone();
// 我们在这里需要大小*反比例，因为当我们自动调整Collider的大小时，它需要没有一个缩放的Renderable
let width = renderableBounds.width / this.entity.transform.scale.x;
let height = renderableBounds.height / this.entity.transform.scale.y;
if (this instanceof CircleCollider) {
this.radius = Math.max(width, height) * 0.5;
// 获取Renderable的中心，将其转移到本地坐标，并将其作为我们碰撞器的localOffset
this.localOffset = Vector2.subtract(renderableBounds.center, this.entity.transform.position);
} else if (this instanceof BoxCollider) {
this.width = width;
this.height = height;
this.localOffset = Vector2.subtract(renderableBounds.center, this.entity.transform.position);
}
}
}
this._isParentEntityAddedToScene = true;
this.registerColliderWithPhysicsSystem();
}

8
source/src/ECS/Components/Physics/Colliders/PolygonCollider.ts
View File

@@ -23,13 +23,5 @@ module es {
Polygon.recenterPolygonVerts(points);
this.shape = new Polygon(points);
}
public debugRender(batcher: IBatcher) {
let poly = this.shape as Polygon;
batcher.drawHollowRect(this.bounds, Debug.colliderBounds, 1);
batcher.drawPolygon(this.shape.position, poly.points, Debug.colliderEdge, true, 1);
batcher.drawPixel(this.entity.transform.position, Debug.colliderPosition, 4);
batcher.drawPixel(this.shape.position, Debug.colliderCenter, 2);
}
}
}

80
source/src/ECS/Components/Renderables/IRenderable.ts
View File

@@ -1,80 +0,0 @@
module es {
/**
* 接口，当应用于一个Component时，它将被注册到场景渲染器中。
* 请仔细实现这个功能 改变像layerDepth/renderLayer/material这样的东西需要更新Scene RenderableComponentList
*/
export interface IRenderable {
/** 包裹此对象的AABB。用来进行相机筛选 */
bounds: Rectangle;
/** 这个IRenderable是否应该被渲染 */
enabled: boolean;
/**
* 标准的Batcher图层深度，0为前面，1为后面。
* 改变这个值会触发场景中可渲染组件列表的排序
*/
layerDepth: number;
/**
* 较低的renderLayers在前面，较高的在後面，就像layerDepth一样，但不是限制在0-1。
* 请注意，这意味着较高的renderLayers首先被发送到Batcher。在使用模板缓冲区时，这是一个重要的事实
*/
renderLayer: number;
/**
* 由渲染器使用，用于指定该精灵应如何渲染。
* 如果非空，当组件从实体中移除时，它会被自动处理。
*/
material;
/**
* 这个Renderable的可见性。
* 状态的改变最终会调用onBecameVisible/onBecameInvisible方法
*/
isVisible: boolean;
/**
* 用于检索一个已经铸造的Material子类的帮助程序
*/
getMaterial<T extends IMaterial>(): T;
/**
* 如果Renderables的边界与Camera.bounds相交，则返回true。
* 处理isVisible标志的状态切换。
* 在你的渲染方法中使用这个方法来决定你是否应该渲染
* @param camera
*/
isVisibleFromCamera(camera: ICamera): boolean;
/**
* 被渲染器调用。摄像机可以用来进行裁剪，并使用Batcher实例进行绘制
* @param batcher
* @param camera
*/
render(batcher: IBatcher, camera: ICamera);
/**
* 只有在没有对撞机的情况下才会渲染边界。
* 始终在原点上渲染一个正方形
* @param batcher
*/
debugRender(batcher: IBatcher);
}
/**
* 对IRenderables进行排序的比较器。
* 首先按 RenderLayer 排序，然后按 LayerDepth 排序。
* 如果出现平局，则使用材料作为平局的断定器，以避免渲染状态的改变
*/
export class RenderableComparer implements IComparer<IRenderable> {
public compare(self: IRenderable, other: IRenderable): number {
let res = other.renderLayer - self.renderLayer;
if (res == 0) {
res = other.layerDepth - self.layerDepth;
if (res == 0) {
if (self.material == other.material)
return 0;
if (other.material == null)
return -1;
return 1;
}
}
return res;
}
}
}

230
source/src/ECS/Components/Renderables/RenderableComponent.ts
View File

@@ -1,230 +0,0 @@
module es {
/**
* IRenderable的具体实现。包含方便的方法。
* 非常重要！子类必须覆盖width/height或bounds! 子类必须覆盖width/height或bounds!
*/
export abstract class RenderableComponent extends Component implements IRenderable, IComparer<RenderableComponent> {
public static renderIdGenerator: number = 0;
/**
* 不重写bounds属性的子类必须实现这个！RenderableComponent的宽度。
*/
public abstract get width();
/**
* 不重写bounds属性的子类必须实现这个!
*/
public abstract get height();
/**
* 包裹此对象的AABB。用来进行相机筛选。
*/
public abstract get bounds();
/**
* 标准的Batcher图层深度，0为前面，1为后面。
* 改变这个值会触发场景中可渲染组件列表的排序。
*/
public get layerDepth() {
return this._layerDepth;
}
public set layerDepth(value: number) {
this.setLayerDepth(value);
}
/**
* 较低的renderLayers在前面，较高的在后面，就像layerDepth一樣，但不是限制在0-1。
* 请注意，这意味着更高的renderLayers首先被发送到Batcher。
*/
public get renderLayer() {
return this._renderLayer;
}
public set renderLayer(value: number) {
this.setRenderLayer(value);
}
/**
* 渲染时传递给批处理程序的颜色
*/
public color: number = 0xffffff;
/**
* 由渲染器使用，用于指定该精灵的渲染方式
*/
public material: IMaterial;
/**
* 偏移。用于将多个Renderables添加到需要特定定位的实体
*/
public get localOffset(): Vector2 {
return this._localOffset;
}
public set localOffset(value: Vector2) {
this.setLocalOffset(value);
}
/**
* 这个Renderable的可见性。
* 状态的改变最终会调用onBecameVisible/onBecameInvisible方法
*/
public get isVisible() {
return this._isVisble;
}
public set isVisible(value: boolean) {
if (this._isVisble != value) {
this._isVisble = value;
if (this._isVisble)
this.onBecameVisible();
else
this.onBecameInvisible();
}
}
constructor() {
super();
}
public debugRenderEnabled: boolean = true;
protected _localOffset: Vector2 = Vector2.zero;
protected _layerDepth: number;
protected _renderLayer: number;
protected _bounds: Rectangle = Rectangle.empty;
protected _isVisble: boolean;
protected _areBoundsDirty: boolean = true;
public onEntityTransformChanged(comp: transform.Component) {
this._areBoundsDirty = true;
}
/**
* 被渲染器调用。摄像机可以用来进行裁剪，并使用Batcher实例进行绘制
* @param batcher
* @param camera
*/
public abstract render(batcher: IBatcher, camera: ICamera);
/**
* 只有在没有对撞机的情况下才会渲染边界。始终在原点上渲染一个正方形
* @param batcher
*/
public debugRender(batcher: IBatcher) {
if (!this.debugRenderEnabled)
return;
// 如果我们没有对撞机，我们就画出我们的范围
if (this.entity.getComponent<Collider>(Collider) == null)
batcher.drawHollowRect(this.bounds, 0xFFFF00);
batcher.drawPixel(this.entity.transform.position.add(this._localOffset), 0xcc3299, 4);
}
/**
* 当Renderable进入相机帧时被调用。
* 请注意，如果您的Renderer没有使用isVisibleFromCamera来进行裁剪检查，这些方法将不会被调用。
* 所有默认的Renderer都会这样做
*/
protected onBecameVisible() {
}
/**
* 当渲染器退出相机帧时，将调用这些方法。
* 请注意，如果你的Renderer没有使用isVisibleFromCamera来进行Culling检查，这些方法将不会被调用。
* 所有默认的Renderer都会这样做
*/
protected onBecameInvisible() {
}
public onRemovedFromEntity() {
}
/**
* 如果Renderables的边界与Camera.bounds相交，则返回true。
* 处理isVisible标志的状态切换。在你的渲染方法中使用这个方法来决定你是否应该渲染
* @param camera
*/
public isVisibleFromCamera(camera: ICamera) {
this.isVisible = camera.bounds.intersects(this.bounds);
return this.isVisible;
}
public setMaterial(material: IMaterial) {
this.material = material;
if (this.entity != null && this.entity.scene != null)
this.entity.scene.renderableComponents.setRenderLayerNeedsComponentSort(this.renderLayer);
return this;
}
/**
* 标准的Batcher图层深度，0为前面，1为后面。
* 改变这个值会触发一种类似于renderableComponents的方法
* @param layerDepth
*/
public setLayerDepth(layerDepth: number): RenderableComponent {
this._layerDepth = MathHelper.clamp01(layerDepth);
if (this.entity != null && this.entity.scene != null)
this.entity.scene.renderableComponents.setRenderLayerNeedsComponentSort(this.renderLayer);
return this;
}
/**
* 较低的渲染层在前面，较高的在后面
* @param renderLayer
*/
public setRenderLayer(renderLayer: number): RenderableComponent {
if (renderLayer != this._renderLayer) {
let oldRenderLayer = this._renderLayer;
this._renderLayer = renderLayer;
// 如果该组件拥有一个实体，那么是由ComponentList管理，需要通知它改变了渲染层
if (this.entity && this.entity.scene)
this.entity.scene.renderableComponents.updateRenderableRenderLayer(this, oldRenderLayer, this._renderLayer);
}
return this;
}
/**
* 偏移。用于将多个Renderables添加到需要特定定位的实体
* @param offset
*/
public setLocalOffset(offset: Vector2): RenderableComponent {
if (!this._localOffset.equals(offset)) {
this._localOffset = offset;
this._areBoundsDirty = true;
}
return this;
}
/**
* 用于检索一个已经铸造的Material子类的帮助程序
*/
public getMaterial<T extends IMaterial>(): T {
return this.material as T;
}
/**
* 先按renderLayer排序，再按layerDepth排序，最后按材质排序
* @param other
*/
public compare(other: RenderableComponent) {
let res = other.renderLayer - this.renderLayer;
if (res == 0) {
res = other.layerDepth - this.layerDepth;
if (res == 0) {
if (this.material == other.material)
return 0;
if (other.material == null)
return -1;
return 1;
}
}
}
}
}

21
source/src/ECS/CoreEvents.ts
View File

@@ -1,29 +1,12 @@
module es {
export enum CoreEvents {
/**
* 在图形设备重置时触发。当这种情况发生时，任何渲染目标或其他内容的VRAM将被擦除，需要重新生成
*/
graphicsDeviceReset,
/**
* 当场景发生变化时触发
*/
sceneChanged,
/**
* 当设备方向改变时触发
* 每帧更新事件
*/
orientationChanged,
/**
* 当Core.useCustomUpdate为true时则派发该事件
*/
sceneUpdated,
addDefaultRender,
setRenderTarget,
clearGraphics,
disposeRenderTarget,
resolutionScale,
resolutionOffset,
createRenderTarget,
createCamera,
rendererSizeChanged,
frameUpdated,
}
}

8
source/src/ECS/Entity.ts
View File

@@ -380,14 +380,6 @@ module es {
this.components.update();
}
/**
* 自定义渲染器可以选择是否调用它
* @param batcher
*/
public debugRender(batcher: IBatcher) {
this.components.debugRender(batcher);
}
/**
* 将组件添加到组件列表中。返回组件。
* @param component

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

@@ -13,105 +13,23 @@ module es {
/** 场景 */
export class Scene {
/**
* 默认场景 摄像机
*/
public camera: ICamera;
/**
* 这个场景中的实体列表
*/
public readonly entities: EntityList;
/** 管理当前在场景中的所有RenderableComponents的列表 Entitys */
public readonly renderableComponents: RenderableComponentList;
/**
* 如果ResolutionPolicy是完美的像素，这将被设置为为它计算的比例
*/
public pixelPerfectScale: number = 1;
/**
* 如果设置了，最终渲染到屏幕上的时间可以推迟到这个委托。
* 这实际上只在最终渲染可能需要全屏大小效果的情况下有用，即使使用了一个小的后置缓冲区
*/
public set finalRenderDelegate(value: IFinalRenderDelegate) {
if (this._finalRenderDelegate != null)
this._finalRenderDelegate.unload();
this._finalRenderDelegate = value;
if (this._finalRenderDelegate != null)
this._finalRenderDelegate.onAddedToScene(this);
}
public get finalRenderDelegate() {
return this._finalRenderDelegate;
}
private _finalRenderDelegate: IFinalRenderDelegate;
/**
* 管理所有实体处理器
*/
public readonly entityProcessors: EntityProcessorList;
/**
* 所有场景的默认分辨率大小
*/
private static _defaultDesignResolutionSize: Vector2 = Vector2.zero;
private static _defaultDesignBleedSize: Vector2 = Vector2.zero;
/**
* 用于所有场景的默认分辨率策略
*/
private static _defaultSceneResolutionPolicy: SceneResolutionPolicy = SceneResolutionPolicy.none;
/**
* 场景的解析策略
*/
private _resolutionPolicy: SceneResolutionPolicy;
/**
* 场景使用的设计分辨率大小
*/
private _designResolutionSize: Vector2 = Vector2.zero;
private _designBleedSize: Vector2 = Vector2.zero;
/**
* 这将根据分辨率策略进行设置，并用于RenderTarget的最终输出
*/
private _finalRenderDestinationRect: Rectangle = Rectangle.empty;
private _sceneRenderTarget: Ref<any> = new Ref(null);
private _destinationRenderTarget: Ref<any> = new Ref(null);
private _screenshotRequestCallback: (texture) => void;
public readonly _sceneComponents: SceneComponent[] = [];
public _renderers: IRenderer[] = [];
public readonly _afterPostProcessorRenderers: IRenderer[] = [];
private _didSceneBegin: boolean;
private currentRenderId: Ref<number> = new Ref(null);
/**
* 设置新场景将使用的默认设计尺寸和分辨率策略，水平/垂直Bleed仅与BestFit相关
* @param width
* @param height
* @param sceneResolutionPolicy
* @param horizontalBleed
* @param vertialcalBleed
*/
public static setDefaultDesignResolution(width: number, height: number,
sceneResolutionPolicy: SceneResolutionPolicy,
horizontalBleed: number = 0, vertialcalBleed: number = 0) {
this._defaultDesignBleedSize = new Vector2(width, height);
this._defaultSceneResolutionPolicy = sceneResolutionPolicy;
if (this._defaultSceneResolutionPolicy == SceneResolutionPolicy.bestFit)
this._defaultDesignBleedSize = new Vector2(horizontalBleed, vertialcalBleed);
}
constructor() {
this.entities = new EntityList(this);
this.renderableComponents = new RenderableComponentList();
this.entityProcessors = new EntityProcessorList();
Framework.emitter.emit(CoreEvents.createCamera, this);
this._resolutionPolicy = Scene._defaultSceneResolutionPolicy;
this._designResolutionSize = Scene._defaultDesignResolutionSize;
this._designBleedSize = Scene._defaultDesignBleedSize;
this.initialize();
}
@@ -136,16 +54,7 @@ module es {
}
public begin() {
if (this._renderers.length == 0) {
Framework.emitter.emit(CoreEvents.addDefaultRender);
console.warn("场景开始时没有渲染器");
}
Physics.reset();
this.updateResolutionScaler();
Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
Framework.emitter.addObserver(CoreEvents.graphicsDeviceReset, this.updateResolutionScaler, this);
Framework.emitter.addObserver(CoreEvents.orientationChanged, this.updateResolutionScaler, this);
if (this.entityProcessors != null)
this.entityProcessors.begin();
@@ -158,10 +67,6 @@ module es {
public end() {
this._didSceneBegin = false;
for (let i = 0; i < this._renderers.length; i++)
this._renderers[i].unload();
Framework.emitter.removeObserver(CoreEvents.graphicsDeviceReset, this.updateResolutionScaler);
this.entities.removeAllEntities();
for (let i = 0; i < this._sceneComponents.length; i++) {
@@ -169,9 +74,6 @@ module es {
}
this._sceneComponents.length = 0;
this.camera = null;
Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._sceneRenderTarget);
Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._destinationRenderTarget);
Physics.clear();
if (this.entityProcessors)
@@ -180,107 +82,7 @@ module es {
this.unload();
}
public updateResolutionScaler() {
let designSize = this._designResolutionSize;
let screenSize = new Vector2(Screen.width, Screen.height);
let screenAspectRatio = screenSize.x / screenSize.y;
let renderTargetWidth = screenSize.x;
let renderTargetHeight = screenSize.y;
let resolutionScaleX = screenSize.x / designSize.x;
let resolutionScaleY = screenSize.y / designSize.y;
let rectCalculated = false;
// 计算PixelPerfect变体所使用的比例
this.pixelPerfectScale = 1;
if (this._resolutionPolicy != SceneResolutionPolicy.none) {
if (designSize.x / designSize.y > screenAspectRatio)
this.pixelPerfectScale = screenSize.x / designSize.x;
else
this.pixelPerfectScale = screenSize.y / designSize.y;
if (this.pixelPerfectScale == 0)
this.pixelPerfectScale = 1;
}
switch (this._resolutionPolicy) {
case SceneResolutionPolicy.none:
this._finalRenderDestinationRect.x = this._finalRenderDestinationRect.y = 0;
this._finalRenderDestinationRect.width = screenSize.x;
this._finalRenderDestinationRect.height = screenSize.y;
rectCalculated = true;
break;
case SceneResolutionPolicy.bestFit:
let safeScaleX = screenSize.x / (designSize.x - this._designBleedSize.x);
let safeScaleY = screenSize.y / (designSize.y - this._designBleedSize.y);
let resolutionScale = Math.max(resolutionScaleX, resolutionScaleY);
let safeScale = Math.min(safeScaleX, safeScaleY);
resolutionScaleX = resolutionScaleY = Math.min(resolutionScale, safeScale);
renderTargetWidth = designSize.x;
renderTargetHeight = designSize.y;
break;
}
// 如果我们还没有计算出一个矩形
if (!rectCalculated) {
// 计算RenderTarget的显示矩形
let renderWidth = designSize.x * resolutionScaleX;
let renderHeight = designSize.y * resolutionScaleY;
this._finalRenderDestinationRect = new Rectangle((screenSize.x - renderWidth) / 2,
(screenSize.y - renderHeight) / 2, renderWidth, renderHeight);
}
// 在Input类中设置一些值，将鼠标位置转换为我们的缩放分辨率
let scaleX = renderTargetWidth / this._finalRenderDestinationRect.width;
let scaleY = renderTargetHeight / this._finalRenderDestinationRect.height;
Framework.emitter.emit(CoreEvents.resolutionScale, new Vector2(scaleX, scaleY));
Framework.emitter.emit(CoreEvents.resolutionOffset, this._finalRenderDestinationRect.location);
// 调整我们的RenderTargets大小
if (this._sceneRenderTarget != null)
Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._sceneRenderTarget);
Framework.emitter.emit(CoreEvents.createRenderTarget, this._sceneRenderTarget, renderTargetWidth, renderTargetHeight);
// 只有在已经存在的情况下才会创建 destinationRenderTarget
if (this._destinationRenderTarget != null) {
Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._destinationRenderTarget);
Framework.emitter.emit(CoreEvents.createRenderTarget, this._destinationRenderTarget, renderTargetWidth, renderTargetHeight);
}
// 通知渲染器、后处理器和FinalRenderDelegate渲染纹理尺寸的变化
for (let i = 0; i < this._renderers.length; i++)
this._renderers[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
for (let i = 0; i < this._afterPostProcessorRenderers.length; i++)
this._afterPostProcessorRenderers[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
if (this._finalRenderDelegate != null)
this._finalRenderDelegate.onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
this.camera.onSceneRenderTargetSizeChanged(renderTargetWidth, renderTargetHeight);
}
/**
* 下一次绘制完成后，这将克隆回缓冲区，并调用回调与clone。
* 注意，当使用完Texture后，你必须处理掉它
* @param callback
*/
public requestScreenshot(callback: (texture) => void) {
this._screenshotRequestCallback = callback;
}
public update() {
// 我们在这里设置RenderTarget，这样Viewport就会与RenderTarget正确匹配
Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
// 更新我们的列表，以防它们有任何变化
this.entities.updateLists();
@@ -296,92 +98,10 @@ module es {
// 更新我们的实体组
this.entities.update();
// 我们在entity.update之后更新我们的renderables，以防止任何新的Renderables被添加
this.renderableComponents.updateList();
if (this.entityProcessors != null)
this.entityProcessors.lateUpdate();
}
public render() {
if (this._renderers.length == 0) {
console.error("场景中没有渲染器!");
return;
}
// 渲染器应该总是先有那些需要RenderTarget的。
// 他们在渲染的时候会自己清空并设置自己为当前的RenderTarget。
// 如果第一个Renderer想要sceneRenderTarget，我们现在就设置并清除它
if (this._renderers[0].wantsToRenderToSceneRenderTarget) {
Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
Framework.emitter.emit(CoreEvents.clearGraphics);
}
let lastRendererHadRenderTarget = false;
for (let i = 0; i < this._renderers.length; i++) {
if (lastRendererHadRenderTarget && this._renderers[i].wantsToRenderToSceneRenderTarget) {
Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
Framework.emitter.emit(CoreEvents.clearGraphics);
// 强制更新相机矩阵，以考虑到新的视口尺寸
if (this._renderers[i].camera != null)
this._renderers[i].camera.forceMatrixUpdate();
this.camera && this.camera.forceMatrixUpdate();
}
this._renderers[i].render(this);
lastRendererHadRenderTarget = this._renderers[i].renderTexture != null;
}
}
/**
* 任何存在的PostProcessors都可以进行处理，然后我们对RenderTarget进行最后的渲染。
* 几乎在所有情况下，finalRenderTarget都是空的。
* 只有在场景转换的第一帧中，如果转换请求渲染，它才会有一个值。
* @param finalRenderTarget
*/
public postRender(finalRenderTarget = null) {
let enabledCounter = 0;
for (let i = 0; i < this._afterPostProcessorRenderers.length; i++) {
if (i == 0) {
// 我们需要在这里设置正确的RenderTarget
let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
Framework.emitter.emit(CoreEvents.setRenderTarget, currentRenderTarget);
}
if (this._afterPostProcessorRenderers[i].camera != null)
this._afterPostProcessorRenderers[i].camera.forceMatrixUpdate();
this._afterPostProcessorRenderers[i].render(this);
}
// 如果我们有一个截图请求，在最终渲染到回缓冲区之前处理它
if (this._screenshotRequestCallback != null) {
let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
this._screenshotRequestCallback(currentRenderTarget.value);
this._screenshotRequestCallback = null;
}
// 将我们的最终结果渲染到后置缓冲区，或者让我们的委托来做
if (this._finalRenderDelegate != null) {
let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
this._finalRenderDelegate.handleFinalRender(finalRenderTarget, currentRenderTarget, this._finalRenderDestinationRect);
} else {
let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
Framework.emitter.emit(CoreEvents.setRenderTarget, finalRenderTarget);
Framework.emitter.emit(CoreEvents.clearGraphics);
Framework.batcher.begin(this.currentRenderId, null);
Framework.batcher.draw(currentRenderTarget.value,
new Vector2(this._finalRenderDestinationRect.x, this._finalRenderDestinationRect.y),
0xffffff,
0,
Vector2.zero,
new Vector2(this._finalRenderDestinationRect.width, this._finalRenderDestinationRect.height));
Framework.batcher.end();
}
}
/**
* 向组件列表添加并返回SceneComponent
* @param component
@@ -434,67 +154,6 @@ module es {
component.onRemovedFromScene();
}
/**
* 添加一个渲染器到场景中
* @param renderer
*/
public addRenderer<T extends IRenderer>(renderer: T): T {
if (renderer.wantsToRenderAfterPostProcessors) {
this._afterPostProcessorRenderers.push(renderer);
this._afterPostProcessorRenderers.sort((a, b) => {
return a.compare(b);
});
} else {
this._renderers.push(renderer);
this._renderers.sort((a, b) => {
return a.compare(b);
});
}
renderer.onAddedToScene(this);
if (this._didSceneBegin)
Framework.emitter.emit(CoreEvents.rendererSizeChanged, this._sceneRenderTarget.value);
return renderer;
}
/**
* 得到第一个T型的渲染器
* @param type
*/
public getRenderer<T extends IRenderer>(type): T {
for (let i = 0; i < this._renderers.length; i++) {
if (this._renderers[i] instanceof type)
return this._renderers[i] as T;
}
for (let i = 0; i < this._afterPostProcessorRenderers.length; i++) {
if (this._afterPostProcessorRenderers[i] instanceof type)
return this._afterPostProcessorRenderers[i] as T;
}
return null;
}
/**
* 从场景中移除渲染器
* @param renderer
*/
public removeRenderer(renderer: IRenderer) {
let afterProcessLinqList = new linq.List(this._afterPostProcessorRenderers);
let rendererLinqList = new linq.List(this._renderers);
Insist.isTrue(rendererLinqList.contains(renderer) ||
afterProcessLinqList.contains(renderer));
if (renderer.wantsToRenderAfterPostProcessors)
afterProcessLinqList.remove(renderer);
else
rendererLinqList.remove(renderer);
renderer.unload();
}
/**
* 将实体添加到此场景，并返回它
* @param name

19
source/src/ECS/Utils/ComponentList.ts
View File

@@ -82,9 +82,6 @@ module es {
for (let component of this._components) {
if (!component) continue;
if (component instanceof RenderableComponent)
new linq.List(this._entity.scene.renderableComponents.buffer).remove(component);
// 处理IUpdatable
if (isIUpdatable(component))
new linq.List(this._updatableComponents).remove(component);
@@ -96,9 +93,6 @@ module es {
public registerAllComponents() {
for (let component of this._components) {
if (component instanceof RenderableComponent)
this._entity.scene.renderableComponents.buffer.push(component);
if (isIUpdatable(component))
this._updatableComponents.push(component);
@@ -124,9 +118,6 @@ module es {
for (let i = 0, count = this._componentsToAdd.length; i < count; i++) {
let component = this._componentsToAdd[i];
if (component instanceof RenderableComponent)
this._entity.scene.renderableComponents.buffer.push(component);
if (isIUpdatable(component))
this._updatableComponents.push(component);
@@ -162,9 +153,6 @@ module es {
}
public handleRemove(component: Component) {
if (component instanceof RenderableComponent)
new linq.List(this._entity.scene.renderableComponents.buffer).remove(component);
if (isIUpdatable(component))
new linq.List(this._updatableComponents).remove(component);
@@ -254,12 +242,5 @@ module es {
for (let i = 0; i < this._components.length; i++)
this._components[i].onDisabled();
}
public debugRender(batcher: IBatcher) {
for (let i = 0; i < this._components.length; i++) {
if (this._components[i].enabled)
this._components[i].debugRender(batcher);
}
}
}
}

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

@@ -1,94 +0,0 @@
module es {
export class RenderableComponentList {
// IRenderable列表的全局updateOrder排序
public static compareUpdatableOrder: IComparer<IRenderable> = new RenderableComparer();
/**
* 添加到实体的组件列表
*/
private _components: IRenderable[] = [];
/**
* 通过renderLayer跟踪组件，便于检索
*/
private _componentsByRenderLayer: Map<number, IRenderable[]> = new Map();
private _unsortedRenderLayers: number[] = [];
private _componentsNeedSort: boolean = true;
public get count() {
return this._components.length;
}
public get buffer(){
return this._components;
}
public get(index: number): IRenderable {
return this._components[index];
}
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) {
// 需要注意的是，在组件 "上线 "之前，renderLayer可能会发生变化
if (this._componentsByRenderLayer.has(oldRenderLayer) &&
new linq.List(this._componentsByRenderLayer.get(oldRenderLayer)).contains(component)) {
new linq.List(this._componentsByRenderLayer.get(oldRenderLayer)).remove(component);
this.addToRenderLayerList(component, newRenderLayer);
}
}
/**
* 弄脏RenderLayers排序标志，导致所有组件的重新排序
* @param renderLayer
*/
public setRenderLayerNeedsComponentSort(renderLayer: number) {
if (!new linq.List(this._unsortedRenderLayers).contains(renderLayer))
this._unsortedRenderLayers.push(renderLayer);
this._componentsNeedSort = true;
}
private addToRenderLayerList(component: IRenderable, renderLayer: number) {
let list = this.componentsWithRenderLayer(renderLayer);
Insist.isFalse(new linq.List(list).contains(component), "组件renderLayer列表已经包含这个组件");
}
/**
* 获取所有给定renderLayer的组件。组件列表是预先排序的。
* @param renderLayer
*/
public componentsWithRenderLayer(renderLayer: number) {
if (!this._componentsByRenderLayer.has(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;
}
}
}
}

14
source/src/Framework.ts
View File

@@ -1,14 +0,0 @@
///<reference path="./Utils/Emitter.ts" />
module es {
/**
* 这里作为框架的核心件
* 全局函数移动到这
*/
export class Framework {
/**
* 核心发射器。只发出核心级别的事件
*/
public static emitter: Emitter<CoreEvents> = new Emitter<CoreEvents>();
public static batcher: IBatcher;
}
}

27
source/src/Graphics/IBatcher.ts
View File

@@ -1,27 +0,0 @@
module es {
export interface IBatcher {
/**
* 创建投影矩阵时要使用的矩阵
*/
transformMatrix: Matrix;
/**
* 如果为true，则将在绘制目标位置之前将其四舍五入
*/
shouldRoundDestinations: boolean;
disposed();
begin(id: Ref<number>, effect, transformationMatrix?: Matrix, disableBatching?: boolean);
end();
prepRenderState();
/**
* 设置是否应忽略位置舍入。在为调试绘制基元时很有用
*/
setIgnoreRoundingDestinations(shouldIgnore: boolean);
drawHollowRect(rect: Rectangle, color: number, thickness?: number);
drawHollowBounds(x: number, y: number, width: number, height: number, color: number, thickness: number);
drawLine(start: Vector2, end: Vector2, color: number, thickness);
draw(texture, position: Vector2, color?: number, rotation?: number, origin?: Vector2, scale?: Vector2, effects?);
drawPixel(position: Vector2, color: number, size?: number);
drawPolygon(position: Vector2, points: Vector2[], color: number, closePoly?: boolean, thickness?: number);
drawCircle(position: Vector2, radius: number, color: number, thickness?: number, resolution?: number);
}
}

29
source/src/Graphics/ICamera.ts
View File

@@ -1,29 +0,0 @@
module es {
export interface ICamera extends Component {
position: Vector2;
rotation: number;
rawZoom: number;
zoom: number;
minimumZoom: number;
maximumZoom: number;
bounds: Rectangle;
transformMatrix: Matrix2D;
inverseTransformMatrix: Matrix2D;
projectionMatrix: Matrix;
viewprojectionMatrix: Matrix;
origin: Vector2;
setInset(left: number, right: number, top: number, bottom: number): ICamera;
setPosition(position: Vector2): ICamera;
setRotation(rotation: number): ICamera;
setZoom(zoom: number): ICamera;
setMinimumZoom(minZoom: number): ICamera;
setMaximumZoom(maxZoom: number): ICamera;
forceMatrixUpdate();
onEntityTransformChanged(comp: transform.Component);
zoomIn(deltaZoom: number);
zoomOut(deltaZoom: number);
worldToScreenPoint(worldPosition: Vector2): Vector2;
screenToWorldPoint(screenPosition: Vector2): Vector2;
onSceneRenderTargetSizeChanged(newWidth: number, newHeight: number);
}
}

32
source/src/Graphics/IFinalRenderDelegate.ts
View File

@@ -1,32 +0,0 @@
module es {
/**
* 可选接口，可以添加到任何对象中，用于特殊情况下需要覆盖最终渲染到屏幕。
* 请注意，如果有IFinalRenderDelegate存在，Scene.screenshotRequestCallback将不会像预期的那样工作。
*/
export interface IFinalRenderDelegate {
/**
* 在添加到场景中时调用
* @param scene
*/
onAddedToScene(scene: Scene);
/**
* 当后置缓冲区大小改变时调用
* @param newWidth
* @param newHeight
*/
onSceneBackBufferSizeChanged(newWidth: number, newHeight: number);
/**
* 这个被场景调用，这样就可以处理最终的渲染。渲染应该在finalRenderTarget中完成。
* 在大多数情况下，finalRenderTarget将是空的，所以渲染将只是到回缓冲区。
* finalRenderTarget只有在场景转换的第一帧时才会被设置，其中转换已经请求了上一个场景的渲染
* @param finalRenderTarget
* @param source
* @param finalRenderDestinationRect
*/
handleFinalRender(finalRenderTarget, source, finalRenderDestinationRect: Rectangle);
/**
* 场景结束时调用。在这里释放任何资源
*/
unload();
}
}

15
source/src/Graphics/IMaterial.ts
View File

@@ -1,15 +0,0 @@
module es {
/**
* 便利的子类，有一个单一的属性，可以投递Effect，使配置更简单
*/
export interface IMaterial {
/**
* Batcher为当前RenderableComponent使用的效果
*/
effect;
dispose();
onPreRender(camera: ICamera);
compareTo(other: IMaterial): number;
clone(): IMaterial;
}
}

57
source/src/Graphics/IRenderer.ts
View File

@@ -1,57 +0,0 @@
module es {
export interface IRenderer {
/**
* Batcher使用的材料。任何RenderableComponent都可以覆盖它
*/
material: IMaterial;
/**
* 渲染器用于渲染的Camera(实际上是它的transformMatrix和culling的边界)。
* 这是一个方便的字段，不是必需的。
* 渲染器子类可以在调用beginRender时选择使用的摄像机
*/
camera: ICamera;
/**
* 指定场景调用渲染器的顺序
*/
renderOrder: number;
/**
* 如果renderTarget不是空的，这个渲染器将渲染到RenderTarget中，而不是渲染到屏幕上
*/
renderTexture;
/**
* 标志，决定是否要调试渲染。
* 渲染方法接收一个bool(debugRenderEnabled)让渲染器知道全局调试渲染是否开启/关闭。
* 然后渲染器使用本地的bool来决定是否应该调试渲染
*/
shouldDebugRender: boolean;
/**
* 如果为true，场景将使用场景RenderTarget调用SetRenderTarget。
* 如果Renderer有一个renderTexture，默认的实现会返回true
*/
wantsToRenderToSceneRenderTarget: boolean;
/**
* 如果为true，场景将在所有后处理器完成后调用渲染方法。
* 这必须在调用Scene.addRenderer生效之前设置为true，并且Renderer不应该有renderTexture。
* 使用这种类型的渲染器的主要原因是为了让你可以在不进行后期处理的情况下，在Scene的其余部分上渲染你的UI。
* ScreenSpaceRenderer是一个将此设置为真的Renderer例子
*/
wantsToRenderAfterPostProcessors: boolean;
/**
* 当Renderer被添加到场景中时被调用
* @param scene
*/
onAddedToScene(scene: Scene);
/**
* 当场景结束或该渲染器从场景中移除时，调用该函数，用于清理
*/
unload();
render(scene: Scene);
/**
* 当默认的场景RenderTarget被调整大小时，以及在场景已经开始的情况下添加一个Renderer时，会被调用。
* @param newWidth
* @param newHeight
*/
onSceneBackBufferSizeChanged(newWidth: number, newHeight: number);
compare(other: IRenderer): number;
}
}