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

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