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

修复transition层级问题

Browse Source
This commit is contained in:
yhh
2020-06-23 16:18:14 +08:00
parent 795bfab1aa
commit 7399b9f5ca
16 changed files with 723 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -36,6 +36,13 @@ abstract class Component {
return this.entity.stage;
}
public get scene(){
if (!this.entity)
return null;
return this.entity.scene;
}
public initialize(){
}

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

@@ -30,7 +30,7 @@ class SpriteRenderer extends RenderableComponent {
this._origin = sprite.origin;
this._bitmap = new egret.Bitmap(sprite.texture2D);
this.stage.addChild(this._bitmap);
this.scene.addChild(this._bitmap);
return this;
}
@@ -85,6 +85,6 @@ class SpriteRenderer extends RenderableComponent {
public onRemovedFromEntity(){
if (this._bitmap)
this.stage.removeChild(this._bitmap);
this.scene.removeChild(this._bitmap);
}
}

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

@@ -11,14 +11,12 @@ class Scene extends egret.DisplayObjectContainer {
private _matrixTransformMatrix: Matrix2D;
private _renderers: Renderer[] = [];
private _postProcessors: PostProcessor[] = [];
private _afterPostProcessorRenderer: Renderer[] = [];
private _didSceneBegin;
public readonly entityProcessors: EntityProcessorList;
constructor(displayObject: egret.DisplayObject) {
constructor() {
super();
displayObject.stage.addChild(this);
this._projectionMatrix = new Matrix2D(0, 0, 0, 0, 0, 0);
this.entityProcessors = new EntityProcessorList();
this.renderableComponents = new RenderableComponentList();
@@ -93,9 +91,11 @@ class Scene extends egret.DisplayObjectContainer {
public removeRenderer(renderer: Renderer) {
this._renderers.remove(renderer);
renderer.unload();
}
public begin() {
SceneManager.stage.addChildAt(this, 0);
if (this._renderers.length == 0) {
this.addRenderer(new DefaultRenderer());
console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染");
@@ -184,17 +184,6 @@ class Scene extends egret.DisplayObjectContainer {
}
}
}
for (let i = 0; i < this._afterPostProcessorRenderer.length; i ++){
if (i == 0){
// TODO: 设置渲染对象
}
if (this._afterPostProcessorRenderer[i].camera){
this._afterPostProcessorRenderer[i].camera.forceMatrixUpdate();
}
this._afterPostProcessorRenderer[i].render(this);
}
}
public render() {
@@ -205,4 +194,16 @@ class Scene extends egret.DisplayObjectContainer {
this._renderers[i].render(this);
}
}
public addPostProcessor<T extends PostProcessor>(postProcessor: T): T{
this._postProcessors.push(postProcessor);
this._postProcessors.sort();
postProcessor.onAddedToScene(this);
if (this._didSceneBegin){
postProcessor.onSceneBackBufferSizeChanged(this.stage.stageWidth, this.stage.stageHeight);
}
return postProcessor;
}
}

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

@@ -91,7 +91,8 @@ class SceneManager {
*/
public static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T {
if (this.sceneTransition) {
throw new Error("在前一个场景完成之前，不能开始一个新的场景转换。");
console.error("在前一个场景完成之前，不能开始一个新的场景转换。");
return;
}
this.sceneTransition = sceneTransition;

125
source/src/Graphics/Effects/GaussianBlurEffect.ts Normal file
View File

@@ -0,0 +1,125 @@
class GaussianBlurEffect extends egret.CustomFilter {
private static vertSrc = "attribute vec2 aVertexPosition;\n" +
"attribute vec2 aTextureCoord;\n" +
"uniform vec2 projectionVector;\n" +
"varying vec2 vTextureCoord;\n" +
"const vec2 center = vec2(-1.0, 1.0);\n" +
"void main(void) {\n" +
" gl_Position = vec4( (aVertexPosition / projectionVector) + center , 0.0, 1.0);\n" +
" vTextureCoord = aTextureCoord;\n" +
"}";
private static fragmentSrc = "precision lowp float;\n" +
"varying vec2 vTextureCoord;\n" +
"uniform sampler2D uSampler;\n" +
"#define SAMPLE_COUNT 15\n" +
"uniform vec2 _sampleOffsets[SAMPLE_COUNT];\n" +
"uniform float _sampleWeights[SAMPLE_COUNT];\n" +
"void main(void) {\n" +
"vec4 c = 0;\n" +
"for( int i = 0; i < SAMPLE_COUNT; i++ )\n" +
" c += texture2D( s0, texCoord + _sampleOffsets[i] ) * _sampleWeights[i];\n" +
"gl_FragColor = c;\n" +
"}";
private _sampleWeights: number[];
private _verticalSampleOffsets: Vector2[];
private _horizontalSampleOffsets: Vector2[];
private _blurAmount = 2;
private _horizontalBlurDelta = 0.01;
private _verticalBlurDelta = 0.01;
public get blurAmount(){
return this._blurAmount;
}
public set blurAmount(value: number){
if (this._blurAmount != value){
if (value == 0)
value = 0.001;
this._blurAmount = value;
this.calculateSampleWeights();
}
}
public get horizontalBlurDelta(){
return this._horizontalBlurDelta;
}
public set horizontalBlurDelta(value: number){
if (value != this._horizontalBlurDelta){
this._horizontalBlurDelta = value;
this.setBlurEffectParameters(this._horizontalBlurDelta, 0, this._horizontalSampleOffsets);
}
}
public get verticalBlurDelta(){
return this._verticalBlurDelta;
}
public set verticalBlurDelta(value: number){
if (value != this._verticalBlurDelta){
this._verticalBlurDelta = value;
this.setBlurEffectParameters(0, this._verticalBlurDelta, this._verticalSampleOffsets);
}
}
constructor(){
super(GaussianBlurEffect.vertSrc, GaussianBlurEffect.fragmentSrc);
this._sampleWeights = [];
this._verticalSampleOffsets = [];
this._horizontalSampleOffsets = [];
this._verticalSampleOffsets[0] = Vector2.zero;
this._horizontalSampleOffsets[0] = Vector2.zero;
this.calculateSampleWeights();
this.setBlurEffectParameters(this._horizontalBlurDelta, 0, this._horizontalSampleOffsets);
this.prepareForHorizontalBlur();
}
public prepareForHorizontalBlur(){
this.uniforms._sampleOffsets = this._horizontalSampleOffsets;
}
public prepareForVerticalBlur(){
this.uniforms._sampleOffsets = this._verticalSampleOffsets;
}
private calculateSampleWeights(){
this._sampleWeights[0] = this.computeGaussian(0);
let totalWeights = this._sampleWeights[0];
for (let i = 0; i < 15 / 2; i ++){
let weight = this.computeGaussian(i + 1);
this._sampleWeights[i * 2 + 1] = weight;
this._sampleWeights[i * 2 + 2] = weight;
totalWeights += weight * 2;
}
for (let i = 0; i < this._sampleWeights.length; i ++){
this._sampleWeights[i] /= totalWeights;
}
this.uniforms._sampleWeights = this._sampleWeights;
}
private setBlurEffectParameters(dx: number, dy: number, offsets: Vector2[]){
for (let i = 0; i < 15 / 2; i ++){
let sampleOffset = i * 2 + 1.5;
let delta = Vector2.subtract( new Vector2(dx, dy), new Vector2(sampleOffset));
offsets[i * 2 + 1] = delta;
offsets[i * 2 + 2] = new Vector2(-delta);
}
}
private computeGaussian(n: number){
return ((1 / Math.sqrt(2 * Math.PI * this._blurAmount)) * Math.exp(-(n * n) / (2 * this._blurAmount * this._blurAmount)));
}
}

11
source/src/Graphics/PostProcessing/PostProcessor.ts
View File

@@ -5,6 +5,7 @@ class PostProcessor {
public shape: egret.Shape;
constructor(effect: egret.CustomFilter = null){
this.enable = true;
this.effect = effect;
}
@@ -18,12 +19,10 @@ class PostProcessor {
this.drawFullscreenQuad(source, this.effect);
}
public onSceneBackBufferSizeChanged(newWidth: number, newHeight: number){}
protected drawFullscreenQuad(texture: egret.DisplayObject, effect: egret.CustomFilter = null){
this.shape.graphics.clear();
this.shape.graphics.beginFill(0x000000, 1);
this.shape.graphics.drawRect(0, 0, texture.width, texture.height);
this.shape.graphics.endFill();
this.shape.filters = [effect];
texture.filters = [effect];
}
public unload(){
@@ -31,7 +30,7 @@ class PostProcessor {
this.effect = null;
}
this.scene = null;
this.scene.removeChild(this.shape);
this.scene = null;
}
}

27
source/src/Graphics/PostProcessing/PostProcessors/BloomSettings.ts Normal file
View File

@@ -0,0 +1,27 @@
class BloomSettings {
public readonly threshold;
public readonly blurAmount;
public readonly intensity;
public readonly baseIntensity;
public readonly saturation;
public readonly baseStaturation;
constructor(bloomThreshold: number, blurAmount: number, bloomIntensity: number,baseIntensity: number,
bloomSaturation: number, baseSaturation: number){
this.threshold = bloomThreshold;
this.blurAmount = blurAmount;
this.intensity = bloomIntensity;
this.baseIntensity = baseIntensity;
this.saturation = bloomSaturation;
this.baseStaturation = baseSaturation;
}
public static presetSettings: BloomSettings[] = [
new BloomSettings(0.1, 0.6, 2, 1, 1, 0),
new BloomSettings(0, 3, 1, 1, 1, 1),
new BloomSettings(0.5, 8, 2, 1, 0, 1),
new BloomSettings(0.25, 8, 1.3, 1, 1, 0),
new BloomSettings(0, 2, 1, 0.1, 1, 1),
new BloomSettings(0.5, 2, 1, 1, 1, 1)
];
}

36
source/src/Graphics/PostProcessing/PostProcessors/GaussianBlurPostProcessor.ts Normal file
View File

@@ -0,0 +1,36 @@
class GaussianBlurPostProcessor extends PostProcessor {
private _renderTargetScale = 1;
public get renderTargetScale(){
return this._renderTargetScale;
}
public set renderTargetScale(value: number){
if (this._renderTargetScale != value){
this._renderTargetScale = value;
this.updateEffectDeltas();
}
}
public onAddedToScene(scene: Scene){
super.onAddedToScene(scene);
this.effect = new GaussianBlurEffect();
}
public onSceneBackBufferSizeChanged(newWidth: number, newHeight: number){
this.updateEffectDeltas();
}
private updateEffectDeltas(){
let effect = this.effect as GaussianBlurEffect;
effect.horizontalBlurDelta = 1 / (this.scene.stage.stageWidth * this._renderTargetScale);
effect.verticalBlurDelta = 1 / (this.scene.stage.stageHeight * this._renderTargetScale);
}
public process(source: egret.DisplayObject){
let effect = this.effect as GaussianBlurEffect;
effect.prepareForHorizontalBlur();
this.drawFullscreenQuad(source, this.effect);
effect.prepareForVerticalBlur();
this.drawFullscreenQuad(source, this.effect);
}
}