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

新增场景策略适配

Browse Source
This commit is contained in:
yhh
2020-12-31 16:38:09 +08:00
parent 6f1fc314b6
commit 01c6c306b1
11 changed files with 612 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
engine_support/egret

Submodule engine_support/egret updated: 34c5197663...05ab4bfb0d

184
source/bin/framework.d.ts vendored
View File

@@ -1,3 +1,54 @@
declare module es {
/**
* 用于包装事件的一个小类
*/
class FuncPack {
/** 函数 */
func: Function;
/** 上下文 */
context: any;
constructor(func: Function, context: any);
}
/**
* 用于事件管理
*/
class Emitter<T> {
private _messageTable;
constructor();
/**
* 开始监听项
* @param eventType 监听类型
* @param handler 监听函数
* @param context 监听上下文
*/
addObserver(eventType: T, handler: Function, context: any): void;
/**
* 移除监听项
* @param eventType 事件类型
* @param handler 事件函数
*/
removeObserver(eventType: T, handler: Function): void;
/**
* 触发该事件
* @param eventType 事件类型
* @param data 事件数据
*/
emit(eventType: T, ...data: any[]): void;
}
}
declare module es {
/**
* 这里作为框架的核心件
* 全局函数移动到这
*/
class Framework {
/**
* 核心发射器。只发出核心级别的事件
*/
static emitter: Emitter<CoreEvents>;
static batcher: IBatcher;
}
}
declare module es {
/**
* 我们在这里存储了各种系统的默认颜色，如对撞机调试渲染、Debug.drawText等。
@@ -96,31 +147,26 @@ declare module es {
/**
* 在图形设备重置时触发。当这种情况发生时，任何渲染目标或其他内容的VRAM将被擦除，需要重新生成
*/
GraphicsDeviceReset = 0,
graphicsDeviceReset = 0,
/**
* 当场景发生变化时触发
*/
SceneChanged = 1,
sceneChanged = 1,
/**
* 当设备方向改变时触发
*/
OrientationChanged = 2,
/**
* 当每帧事件触发时
*/
FrameUpdated = 3,
orientationChanged = 2,
/**
* 当Core.useCustomUpdate为true时则派发该事件
*/
SceneUpdated = 4,
/**
* 当场景需要绘制时
*/
CallDraw = 5,
/**
* 当需要GC时
*/
CallGC = 6
sceneUpdated = 3,
addDefaultRender = 4,
setRenderTarget = 5,
clearGraphics = 6,
disposeRenderTarget = 7,
resolutionScale = 8,
resolutionOffset = 9,
createRenderTarget = 10
}
}
declare module es {
@@ -309,6 +355,16 @@ declare module es {
}
}
declare module es {
enum SceneResolutionPolicy {
/**
* 默认情况下，RenderTarget与屏幕大小匹配。RenderTarget与屏幕大小相匹配
*/
none = 0,
/**
* 该应用程序采用最适合设计分辨率的宽度和高度
*/
bestFit = 1
}
/** 场景 */
class Scene {
/**
@@ -321,6 +377,10 @@ declare module es {
readonly entities: EntityList;
/** 管理当前在场景中的所有RenderableComponents的列表 Entitys */
readonly renderableComponents: RenderableComponentList;
/**
* 如果ResolutionPolicy是完美的像素，这将被设置为为它计算的比例
*/
pixelPerfectScale: number;
/**
* 如果设置了，最终渲染到屏幕上的时间可以推迟到这个委托。
* 这实际上只在最终渲染可能需要全屏大小效果的情况下有用，即使使用了一个小的后置缓冲区
@@ -331,11 +391,44 @@ declare module es {
* 管理所有实体处理器
*/
readonly entityProcessors: EntityProcessorList;
/**
* 所有场景的默认分辨率大小
*/
private static _defaultDesignResolutionSize;
private static _defaultDesignBleedSize;
/**
* 用于所有场景的默认分辨率策略
*/
private static _defaultSceneResolutionPolicy;
/**
* 场景的解析策略
*/
private _resolutionPolicy;
/**
* 场景使用的设计分辨率大小
*/
private _designResolutionSize;
private _designBleedSize;
/**
* 这将根据分辨率策略进行设置，并用于RenderTarget的最终输出
*/
private _finalRenderDestinationRect;
private _sceneRenderTarget;
private _destinationRenderTarget;
private _screenshotRequestCallback;
readonly _sceneComponents: SceneComponent[];
_renderers: IRenderer[];
readonly _afterPostProcessorRenderers: IRenderer[];
_didSceneBegin: boolean;
/**
* 设置新场景将使用的默认设计尺寸和分辨率策略，水平/垂直Bleed仅与BestFit相关
* @param width
* @param height
* @param sceneResolutionPolicy
* @param horizontalBleed
* @param vertialcalBleed
*/
static setDefaultDesignResolution(width: number, height: number, sceneResolutionPolicy: SceneResolutionPolicy, horizontalBleed?: number, vertialcalBleed?: number): void;
constructor();
/**
* 在场景子类中重写这个，然后在这里进行加载。
@@ -1232,7 +1325,7 @@ declare module es {
* 先按renderLayer排序，再按layerDepth排序，最后按材质排序
* @param other
*/
compare(other: RenderableComponent): 1 | 0 | -1;
compare(other: RenderableComponent): 1 | -1 | 0;
}
}
declare module es {
@@ -1761,7 +1854,7 @@ declare module es {
*/
shouldRoundDestinations: boolean;
disposed(): any;
begin(effect: any, transformationMatrix: Matrix, disableBatching: boolean): any;
begin(effect: any, transformationMatrix?: Matrix, disableBatching?: boolean): any;
end(): any;
prepRenderState(): any;
/**
@@ -1772,7 +1865,7 @@ declare module es {
drawHollowBounds(x: number, y: number, width: number, height: number, color: number, thickness: number): any;
drawLine(start: Vector2, end: Vector2, color: number, thickness: any): any;
drawLineAngle(start: Vector2, radians: number, length: number, color: number, thickness: number): any;
draw(texture: any, position: Vector2): any;
draw(texture: any, position: Vector2, color?: number, rotation?: number, origin?: Vector2, scale?: Vector2, effects?: any): any;
flushBatch(): any;
drawPrimitives(texture: any, baseSprite: number, batchSize: number): any;
drawPixel(position: Vector2, color: number, size?: number): any;
@@ -3349,44 +3442,6 @@ declare module es {
static boxToBoxCast(first: Box, second: Box, movement: Vector2, hit: RaycastHit): boolean;
}
}
declare module es {
/**
* 用于包装事件的一个小类
*/
class FuncPack {
/** 函数 */
func: Function;
/** 上下文 */
context: any;
constructor(func: Function, context: any);
}
/**
* 用于事件管理
*/
class Emitter<T> {
private _messageTable;
constructor();
/**
* 开始监听项
* @param eventType 监听类型
* @param handler 监听函数
* @param context 监听上下文
*/
addObserver(eventType: T, handler: Function, context: any): void;
/**
* 移除监听项
* @param eventType 事件类型
* @param handler 事件函数
*/
removeObserver(eventType: T, handler: Function): void;
/**
* 触发该事件
* @param eventType 事件类型
* @param data 事件数据
*/
emit(eventType: T, data?: any): void;
}
}
declare module es {
enum Edge {
top = 0,
@@ -3505,14 +3560,19 @@ declare module es {
}
}
declare module es {
/**
* 使得number/string/boolean类型作为对象引用来进行传递
*/
class Ref<T extends number | string | boolean> {
class Ref<T> {
value: T;
constructor(value: T);
}
}
declare module es {
class Screen {
static width: number;
static height: number;
static readonly size: Vector2;
static readonly center: Vector2;
}
}
declare module es {
/**
* 管理数值的简单助手类。它存储值，直到累计的总数大于1。一旦超过1，该值将在调用update时添加到amount中。
@@ -4706,7 +4766,7 @@ declare module es {
* @param a
* @param b
*/
compare(a: EndPoint, b: EndPoint): 1 | 0 | -1;
compare(a: EndPoint, b: EndPoint): 1 | -1 | 0;
}
}
declare module es {

339
source/bin/framework.js
View File

@@ -40,6 +40,92 @@ var __spread = (this && this.__spread) || function () {
return ar;
};
var es;
(function (es) {
/**
* 用于包装事件的一个小类
*/
var FuncPack = /** @class */ (function () {
function FuncPack(func, context) {
this.func = func;
this.context = context;
}
return FuncPack;
}());
es.FuncPack = FuncPack;
/**
* 用于事件管理
*/
var Emitter = /** @class */ (function () {
function Emitter() {
this._messageTable = new Map();
}
/**
* 开始监听项
* @param eventType 监听类型
* @param handler 监听函数
* @param context 监听上下文
*/
Emitter.prototype.addObserver = function (eventType, handler, context) {
var list = this._messageTable.get(eventType);
if (!list) {
list = [];
this._messageTable.set(eventType, list);
}
if (list.findIndex(function (funcPack) { return funcPack.func == handler; }) != -1)
console.warn("您试图添加相同的观察者两次");
list.push(new FuncPack(handler, context));
};
/**
* 移除监听项
* @param eventType 事件类型
* @param handler 事件函数
*/
Emitter.prototype.removeObserver = function (eventType, handler) {
var messageData = this._messageTable.get(eventType);
var index = messageData.findIndex(function (data) { return data.func == handler; });
if (index != -1)
new linq.List(messageData).removeAt(index);
};
/**
* 触发该事件
* @param eventType 事件类型
* @param data 事件数据
*/
Emitter.prototype.emit = function (eventType) {
var data = [];
for (var _i = 1; _i < arguments.length; _i++) {
data[_i - 1] = arguments[_i];
}
var list = this._messageTable.get(eventType);
if (list) {
for (var i = list.length - 1; i >= 0; i--)
list[i].func.call(list[i].context, data);
}
};
return Emitter;
}());
es.Emitter = Emitter;
})(es || (es = {}));
///<reference path="./Utils/Emitter.ts" />
var es;
///<reference path="./Utils/Emitter.ts" />
(function (es) {
/**
* 这里作为框架的核心件
* 全局函数移动到这
*/
var Framework = /** @class */ (function () {
function Framework() {
}
/**
* 核心发射器。只发出核心级别的事件
*/
Framework.emitter = new es.Emitter();
return Framework;
}());
es.Framework = Framework;
})(es || (es = {}));
var es;
(function (es) {
/**
* 我们在这里存储了各种系统的默认颜色，如对撞机调试渲染、Debug.drawText等。
@@ -273,31 +359,26 @@ var es;
/**
* 在图形设备重置时触发。当这种情况发生时，任何渲染目标或其他内容的VRAM将被擦除，需要重新生成
*/
CoreEvents[CoreEvents["GraphicsDeviceReset"] = 0] = "GraphicsDeviceReset";
CoreEvents[CoreEvents["graphicsDeviceReset"] = 0] = "graphicsDeviceReset";
/**
* 当场景发生变化时触发
*/
CoreEvents[CoreEvents["SceneChanged"] = 1] = "SceneChanged";
CoreEvents[CoreEvents["sceneChanged"] = 1] = "sceneChanged";
/**
* 当设备方向改变时触发
*/
CoreEvents[CoreEvents["OrientationChanged"] = 2] = "OrientationChanged";
/**
* 当每帧事件触发时
*/
CoreEvents[CoreEvents["FrameUpdated"] = 3] = "FrameUpdated";
CoreEvents[CoreEvents["orientationChanged"] = 2] = "orientationChanged";
/**
* 当Core.useCustomUpdate为true时则派发该事件
*/
CoreEvents[CoreEvents["SceneUpdated"] = 4] = "SceneUpdated";
/**
* 当场景需要绘制时
*/
CoreEvents[CoreEvents["CallDraw"] = 5] = "CallDraw";
/**
* 当需要GC时
*/
CoreEvents[CoreEvents["CallGC"] = 6] = "CallGC";
CoreEvents[CoreEvents["sceneUpdated"] = 3] = "sceneUpdated";
CoreEvents[CoreEvents["addDefaultRender"] = 4] = "addDefaultRender";
CoreEvents[CoreEvents["setRenderTarget"] = 5] = "setRenderTarget";
CoreEvents[CoreEvents["clearGraphics"] = 6] = "clearGraphics";
CoreEvents[CoreEvents["disposeRenderTarget"] = 7] = "disposeRenderTarget";
CoreEvents[CoreEvents["resolutionScale"] = 8] = "resolutionScale";
CoreEvents[CoreEvents["resolutionOffset"] = 9] = "resolutionOffset";
CoreEvents[CoreEvents["createRenderTarget"] = 10] = "createRenderTarget";
})(CoreEvents = es.CoreEvents || (es.CoreEvents = {}));
})(es || (es = {}));
var es;
@@ -759,15 +840,33 @@ var es;
})(es || (es = {}));
var es;
(function (es) {
var SceneResolutionPolicy;
(function (SceneResolutionPolicy) {
/**
* 默认情况下，RenderTarget与屏幕大小匹配。RenderTarget与屏幕大小相匹配
*/
SceneResolutionPolicy[SceneResolutionPolicy["none"] = 0] = "none";
/**
* 该应用程序采用最适合设计分辨率的宽度和高度
*/
SceneResolutionPolicy[SceneResolutionPolicy["bestFit"] = 1] = "bestFit";
})(SceneResolutionPolicy = es.SceneResolutionPolicy || (es.SceneResolutionPolicy = {}));
/** 场景 */
var Scene = /** @class */ (function () {
function Scene() {
/**
* 如果ResolutionPolicy是完美的像素，这将被设置为为它计算的比例
*/
this.pixelPerfectScale = 1;
this._sceneComponents = [];
this._renderers = [];
this._afterPostProcessorRenderers = [];
this.entities = new es.EntityList(this);
this.renderableComponents = new es.RenderableComponentList();
this.entityProcessors = new es.EntityProcessorList();
this._resolutionPolicy = Scene._defaultSceneResolutionPolicy;
this._designResolutionSize = Scene._defaultDesignResolutionSize;
this._designBleedSize = Scene._defaultDesignBleedSize;
this.initialize();
}
Object.defineProperty(Scene.prototype, "finalRenderDelegate", {
@@ -788,6 +887,22 @@ var es;
enumerable: true,
configurable: true
});
/**
* 设置新场景将使用的默认设计尺寸和分辨率策略，水平/垂直Bleed仅与BestFit相关
* @param width
* @param height
* @param sceneResolutionPolicy
* @param horizontalBleed
* @param vertialcalBleed
*/
Scene.setDefaultDesignResolution = function (width, height, sceneResolutionPolicy, horizontalBleed, vertialcalBleed) {
if (horizontalBleed === void 0) { horizontalBleed = 0; }
if (vertialcalBleed === void 0) { vertialcalBleed = 0; }
this._defaultDesignBleedSize = new es.Vector2(width, height);
this._defaultSceneResolutionPolicy = sceneResolutionPolicy;
if (this._defaultSceneResolutionPolicy == SceneResolutionPolicy.bestFit)
this._defaultDesignBleedSize = new es.Vector2(horizontalBleed, vertialcalBleed);
};
/**
* 在场景子类中重写这个，然后在这里进行加载。
* 在场景设置好之后，但在调用begin之前，从contructor中调用这个函数
@@ -807,10 +922,14 @@ var es;
};
Scene.prototype.begin = function () {
if (this._renderers.length == 0) {
es.Framework.emitter.emit(es.CoreEvents.addDefaultRender);
console.warn("场景开始时没有渲染器");
}
es.Physics.reset();
this.updateResolutionScaler();
es.Framework.emitter.emit(es.CoreEvents.setRenderTarget, this._sceneRenderTarget);
es.Framework.emitter.addObserver(es.CoreEvents.graphicsDeviceReset, this.updateResolutionScaler, this);
es.Framework.emitter.addObserver(es.CoreEvents.orientationChanged, this.updateResolutionScaler, this);
if (this.entityProcessors != null)
this.entityProcessors.begin();
this._didSceneBegin = true;
@@ -820,18 +939,85 @@ var es;
this._didSceneBegin = false;
for (var i = 0; i < this._renderers.length; i++)
this._renderers[i].unload();
es.Framework.emitter.removeObserver(es.CoreEvents.graphicsDeviceReset, this.updateResolutionScaler);
this.entities.removeAllEntities();
for (var i = 0; i < this._sceneComponents.length; i++) {
this._sceneComponents[i].onRemovedFromScene();
}
this._sceneComponents.length = 0;
this.camera = null;
es.Framework.emitter.emit(es.CoreEvents.disposeRenderTarget, this._sceneRenderTarget);
es.Framework.emitter.emit(es.CoreEvents.disposeRenderTarget, this._destinationRenderTarget);
es.Physics.clear();
if (this.entityProcessors)
this.entityProcessors.end();
this.unload();
};
Scene.prototype.updateResolutionScaler = function () {
var designSize = this._designResolutionSize;
var screenSize = new es.Vector2(es.Screen.width, es.Screen.height);
var screenAspectRatio = screenSize.x / screenSize.y;
var renderTargetWidth = screenSize.x;
var renderTargetHeight = screenSize.y;
var resolutionScaleX = screenSize.x / designSize.x;
var resolutionScaleY = screenSize.y / designSize.y;
var 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:
var safeScaleX = screenSize.x / (designSize.x - this._designBleedSize.x);
var safeScaleY = screenSize.y / (designSize.y - this._designBleedSize.y);
var resolutionScale = Math.max(resolutionScaleX, resolutionScaleY);
var safeScale = Math.min(safeScaleX, safeScaleY);
resolutionScaleX = resolutionScaleY = Math.min(resolutionScale, safeScale);
renderTargetWidth = designSize.x;
renderTargetHeight = designSize.y;
break;
}
// 如果我们还没有计算出一个矩形
if (!rectCalculated) {
// 计算RenderTarget的显示矩形
var renderWidth = designSize.x * resolutionScaleX;
var renderHeight = designSize.y * resolutionScaleY;
this._finalRenderDestinationRect = new es.Rectangle((screenSize.x - renderWidth) / 2, (screenSize.y - renderHeight) / 2, renderWidth, renderHeight);
}
// 在Input类中设置一些值，将鼠标位置转换为我们的缩放分辨率
var scaleX = renderTargetWidth / this._finalRenderDestinationRect.width;
var scaleY = renderTargetHeight / this._finalRenderDestinationRect.height;
es.Framework.emitter.emit(es.CoreEvents.resolutionScale, new es.Vector2(scaleX, scaleY));
es.Framework.emitter.emit(es.CoreEvents.resolutionOffset, this._finalRenderDestinationRect.location);
// 调整我们的RenderTargets大小
if (this._sceneRenderTarget != null)
es.Framework.emitter.emit(es.CoreEvents.disposeRenderTarget, this._sceneRenderTarget);
es.Framework.emitter.emit(es.CoreEvents.createRenderTarget, this._sceneRenderTarget, renderTargetWidth, renderTargetHeight);
// 只有在已经存在的情况下才会创建 destinationRenderTarget
if (this._destinationRenderTarget != null) {
es.Framework.emitter.emit(es.CoreEvents.disposeRenderTarget, this._destinationRenderTarget);
es.Framework.emitter.emit(es.CoreEvents.createRenderTarget, this._destinationRenderTarget, renderTargetWidth, renderTargetHeight);
}
// 通知渲染器、后处理器和FinalRenderDelegate渲染纹理尺寸的变化
for (var i = 0; i < this._renderers.length; i++)
this._renderers[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
for (var 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。
@@ -842,6 +1028,8 @@ var es;
this._screenshotRequestCallback = callback;
};
Scene.prototype.update = function () {
// 我们在这里设置RenderTarget，这样Viewport就会与RenderTarget正确匹配
es.Framework.emitter.emit(es.CoreEvents.setRenderTarget, this._sceneRenderTarget);
// 更新我们的列表，以防它们有任何变化
this.entities.updateLists();
for (var i = this._sceneComponents.length - 1; i >= 0; i--) {
@@ -863,9 +1051,18 @@ var es;
console.error("场景中没有渲染器!");
return;
}
// 渲染器应该总是先有那些需要RenderTarget的。
// 他们在渲染的时候会自己清空并设置自己为当前的RenderTarget。
// 如果第一个Renderer想要sceneRenderTarget，我们现在就设置并清除它
if (this._renderers[0].wantsToRenderToSceneRenderTarget) {
es.Framework.emitter.emit(es.CoreEvents.setRenderTarget, this._sceneRenderTarget);
es.Framework.emitter.emit(es.CoreEvents.clearGraphics);
}
var lastRendererHadRenderTarget = false;
for (var i = 0; i < this._renderers.length; i++) {
if (lastRendererHadRenderTarget && this._renderers[i].wantsToRenderToSceneRenderTarget) {
es.Framework.emitter.emit(es.CoreEvents.setRenderTarget, this._sceneRenderTarget);
es.Framework.emitter.emit(es.CoreEvents.clearGraphics);
// 强制更新相机矩阵，以考虑到新的视口尺寸
if (this._renderers[i].camera != null)
this._renderers[i].camera.forceMatrixUpdate();
@@ -883,20 +1080,35 @@ var es;
*/
Scene.prototype.postRender = function (finalRenderTarget) {
if (finalRenderTarget === void 0) { finalRenderTarget = null; }
var enabledCounter = 0;
for (var i = 0; i < this._afterPostProcessorRenderers.length; i++) {
if (i == 0) {
// 我们需要在这里设置正确的RenderTarget
var currentRenderTarget = es.MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
es.Framework.emitter.emit(es.CoreEvents.setRenderTarget, currentRenderTarget);
}
if (this._afterPostProcessorRenderers[i].camera != null)
this._afterPostProcessorRenderers[i].camera.forceMatrixUpdate();
this._afterPostProcessorRenderers[i].render(this);
}
// 如果我们有一个截图请求，在最终渲染到回缓冲区之前处理它
if (this._screenshotRequestCallback != null) {
// TODO: 实现各平台的截图方式
var currentRenderTarget = es.MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
this._screenshotRequestCallback(currentRenderTarget.value);
this._screenshotRequestCallback = null;
}
// 将我们的最终结果渲染到后置缓冲区，或者让我们的委托来做
if (this._finalRenderDelegate != null) {
var currentRenderTarget = es.MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
this._finalRenderDelegate.handleFinalRender(finalRenderTarget, currentRenderTarget, this._finalRenderDestinationRect);
}
else {
var currentRenderTarget = es.MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
es.Framework.emitter.emit(es.CoreEvents.setRenderTarget, finalRenderTarget);
es.Framework.emitter.emit(es.CoreEvents.clearGraphics);
es.Framework.batcher.begin(null);
es.Framework.batcher.draw(currentRenderTarget, new es.Vector2(this._finalRenderDestinationRect.x, this._finalRenderDestinationRect.y), 0xffffff, 0, es.Vector2.zero, new es.Vector2(this._finalRenderDestinationRect.width, this._finalRenderDestinationRect.height));
es.Framework.batcher.end();
}
};
/**
@@ -1077,6 +1289,10 @@ var es;
Scene.prototype.getEntityProcessor = function () {
return this.entityProcessors.getProcessor();
};
/**
* 用于所有场景的默认分辨率策略
*/
Scene._defaultSceneResolutionPolicy = SceneResolutionPolicy.none;
return Scene;
}());
es.Scene = Scene;
@@ -7975,69 +8191,6 @@ var es;
es.ShapeCollisions = ShapeCollisions;
})(es || (es = {}));
var es;
(function (es) {
/**
* 用于包装事件的一个小类
*/
var FuncPack = /** @class */ (function () {
function FuncPack(func, context) {
this.func = func;
this.context = context;
}
return FuncPack;
}());
es.FuncPack = FuncPack;
/**
* 用于事件管理
*/
var Emitter = /** @class */ (function () {
function Emitter() {
this._messageTable = new Map();
}
/**
* 开始监听项
* @param eventType 监听类型
* @param handler 监听函数
* @param context 监听上下文
*/
Emitter.prototype.addObserver = function (eventType, handler, context) {
var list = this._messageTable.get(eventType);
if (!list) {
list = [];
this._messageTable.set(eventType, list);
}
if (list.findIndex(function (funcPack) { return funcPack.func == handler; }) != -1)
console.warn("您试图添加相同的观察者两次");
list.push(new FuncPack(handler, context));
};
/**
* 移除监听项
* @param eventType 事件类型
* @param handler 事件函数
*/
Emitter.prototype.removeObserver = function (eventType, handler) {
var messageData = this._messageTable.get(eventType);
var index = messageData.findIndex(function (data) { return data.func == handler; });
if (index != -1)
new linq.List(messageData).removeAt(index);
};
/**
* 触发该事件
* @param eventType 事件类型
* @param data 事件数据
*/
Emitter.prototype.emit = function (eventType, data) {
var list = this._messageTable.get(eventType);
if (list) {
for (var i = list.length - 1; i >= 0; i--)
list[i].func.call(list[i].context, data);
}
};
return Emitter;
}());
es.Emitter = Emitter;
})(es || (es = {}));
var es;
(function (es) {
var Edge;
(function (Edge) {
@@ -8215,9 +8368,6 @@ var es;
})(es || (es = {}));
var es;
(function (es) {
/**
* 使得number/string/boolean类型作为对象引用来进行传递
*/
var Ref = /** @class */ (function () {
function Ref(value) {
this.value = value;
@@ -8227,6 +8377,29 @@ var es;
es.Ref = Ref;
})(es || (es = {}));
var es;
(function (es) {
var Screen = /** @class */ (function () {
function Screen() {
}
Object.defineProperty(Screen, "size", {
get: function () {
return new es.Vector2(this.width, this.height);
},
enumerable: true,
configurable: true
});
Object.defineProperty(Screen, "center", {
get: function () {
return new es.Vector2(this.width / 2, this.height / 2);
},
enumerable: true,
configurable: true
});
return Screen;
}());
es.Screen = Screen;
})(es || (es = {}));
var es;
(function (es) {
/**
* 管理数值的简单助手类。它存储值，直到累计的总数大于1。一旦超过1，该值将在调用update时添加到amount中。

2
source/bin/framework.min.js vendored
View File

File diff suppressed because one or more lines are too long

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

@@ -3,30 +3,25 @@ module es {
/**
* 在图形设备重置时触发。当这种情况发生时，任何渲染目标或其他内容的VRAM将被擦除，需要重新生成
*/
GraphicsDeviceReset,
graphicsDeviceReset,
/**
* 当场景发生变化时触发
*/
SceneChanged,
sceneChanged,
/**
* 当设备方向改变时触发
*/
OrientationChanged,
/**
* 当每帧事件触发时
*/
FrameUpdated,
orientationChanged,
/**
* 当Core.useCustomUpdate为true时则派发该事件
*/
SceneUpdated,
/**
* 当场景需要绘制时
*/
CallDraw,
/**
* 当需要GC时
*/
CallGC,
sceneUpdated,
addDefaultRender,
setRenderTarget,
clearGraphics,
disposeRenderTarget,
resolutionScale,
resolutionOffset,
createRenderTarget,
}
}

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

@@ -1,4 +1,15 @@
module es {
export enum SceneResolutionPolicy {
/**
* 默认情况下，RenderTarget与屏幕大小匹配。RenderTarget与屏幕大小相匹配
*/
none,
/**
* 该应用程序采用最适合设计分辨率的宽度和高度
*/
bestFit
}
/** 场景 */
export class Scene {
/**
@@ -11,6 +22,10 @@ module es {
public readonly entities: EntityList;
/** 管理当前在场景中的所有RenderableComponents的列表 Entitys */
public readonly renderableComponents: RenderableComponentList;
/**
* 如果ResolutionPolicy是完美的像素，这将被设置为为它计算的比例
*/
public pixelPerfectScale: number = 1;
/**
* 如果设置了，最终渲染到屏幕上的时间可以推迟到这个委托。
* 这实际上只在最终渲染可能需要全屏大小效果的情况下有用，即使使用了一个小的后置缓冲区
@@ -34,7 +49,31 @@ module es {
* 管理所有实体处理器
*/
public readonly entityProcessors: EntityProcessorList;
/**
* 所有场景的默认分辨率大小
*/
private static _defaultDesignResolutionSize: Vector2;
private static _defaultDesignBleedSize: Vector2;
/**
* 用于所有场景的默认分辨率策略
*/
private static _defaultSceneResolutionPolicy: SceneResolutionPolicy = SceneResolutionPolicy.none;
/**
* 场景的解析策略
*/
private _resolutionPolicy: SceneResolutionPolicy;
/**
* 场景使用的设计分辨率大小
*/
private _designResolutionSize: Vector2;
private _designBleedSize: Vector2;
/**
* 这将根据分辨率策略进行设置，并用于RenderTarget的最终输出
*/
private _finalRenderDestinationRect: Rectangle;
private _sceneRenderTarget: Ref<any>;
private _destinationRenderTarget: Ref<any>;
private _screenshotRequestCallback: (texture) => void;
public readonly _sceneComponents: SceneComponent[] = [];
@@ -42,11 +81,32 @@ module es {
public readonly _afterPostProcessorRenderers: IRenderer[] = [];
public _didSceneBegin: boolean;
/**
* 设置新场景将使用的默认设计尺寸和分辨率策略，水平/垂直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();
this._resolutionPolicy = Scene._defaultSceneResolutionPolicy;
this._designResolutionSize = Scene._defaultDesignResolutionSize;
this._designBleedSize = Scene._defaultDesignBleedSize;
this.initialize();
}
@@ -72,11 +132,15 @@ 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();
@@ -92,6 +156,7 @@ module es {
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++) {
@@ -100,6 +165,8 @@ 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)
@@ -109,7 +176,91 @@ module es {
}
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);
}
/**
@@ -122,6 +273,9 @@ module es {
}
public update() {
// 我们在这里设置RenderTarget，这样Viewport就会与RenderTarget正确匹配
Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
// 更新我们的列表，以防它们有任何变化
this.entities.updateLists();
@@ -150,9 +304,20 @@ module es {
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();
@@ -171,7 +336,15 @@ module es {
* @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);
@@ -179,15 +352,28 @@ module es {
// 如果我们有一个截图请求，在最终渲染到回缓冲区之前处理它
if (this._screenshotRequestCallback != null) {
// TODO: 实现各平台的截图方式
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(null);
Framework.batcher.draw(currentRenderTarget,
new Vector2(this._finalRenderDestinationRect.x, this._finalRenderDestinationRect.y),
0xffffff,
0,
Vector2.zero,
new Vector2(this._finalRenderDestinationRect.width, this._finalRenderDestinationRect.height));
Framework.batcher.end();
}
}

14
source/src/Framework.ts Normal file
View File

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

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

@@ -9,7 +9,7 @@ module es {
*/
shouldRoundDestinations: boolean;
disposed();
begin(effect, transformationMatrix: Matrix, disableBatching: boolean);
begin(effect, transformationMatrix?: Matrix, disableBatching?: boolean);
end();
prepRenderState();
/**
@@ -20,7 +20,7 @@ module es {
drawHollowBounds(x: number, y: number, width: number, height: number, color: number, thickness: number);
drawLine(start: Vector2, end: Vector2, color: number, thickness);
drawLineAngle(start: Vector2, radians: number, length: number, color: number, thickness: number);
draw(texture, position: Vector2);
draw(texture, position: Vector2, color?: number, rotation?: number, origin?: Vector2, scale?: Vector2, effects?);
flushBatch();
drawPrimitives(texture, baseSprite: number, batchSize: number);
drawPixel(position: Vector2, color: number, size?: number);

2
source/src/Utils/Emitter.ts
View File

@@ -59,7 +59,7 @@ module es {
* @param eventType 事件类型
* @param data 事件数据
*/
public emit(eventType: T, data?: any) {
public emit(eventType: T, ...data: any[]) {
let list: FuncPack[] = this._messageTable.get(eventType);
if (list) {
for (let i = list.length - 1; i >= 0; i--)

7
source/src/Utils/Ref.ts
View File

@@ -1,11 +1,8 @@
module es {
/**
* 使得number/string/boolean类型作为对象引用来进行传递
*/
export class Ref<T extends number | string | boolean> {
export class Ref<T> {
public value: T;
constructor(value: T){
constructor(value: T) {
this.value = value;
}
}

14
source/src/Utils/Screen.ts Normal file
View File

@@ -0,0 +1,14 @@
module es {
export class Screen {
public static width: number;
public static height: number;
public static get size(): Vector2 {
return new Vector2(this.width, this.height);
}
public static get center(): Vector2 {
return new Vector2(this.width / 2, this.height / 2);
}
}
}