import BoundingRectangle from "../Core/BoundingRectangle.js";
|
import Cartesian2 from "../Core/Cartesian2.js";
|
import Cartesian4 from "../Core/Cartesian4.js";
|
import defined from "../Core/defined.js";
|
import destroyObject from "../Core/destroyObject.js";
|
import CesiumMath from "../Core/Math.js";
|
import Matrix4 from "../Core/Matrix4.js";
|
import Transforms from "../Core/Transforms.js";
|
import AdditiveBlend from "../Shaders/PostProcessStages/AdditiveBlend.js";
|
import BrightPass from "../Shaders/PostProcessStages/BrightPass.js";
|
import GaussianBlur1D from "../Shaders/PostProcessStages/GaussianBlur1D.js";
|
import PassThrough from "../Shaders/PostProcessStages/PassThrough.js";
|
import PostProcessStage from "./PostProcessStage.js";
|
import PostProcessStageComposite from "./PostProcessStageComposite.js";
|
import PostProcessStageSampleMode from "./PostProcessStageSampleMode.js";
|
import PostProcessStageTextureCache from "./PostProcessStageTextureCache.js";
|
import SceneFramebuffer from "./SceneFramebuffer.js";
|
|
function SunPostProcess() {
|
this._sceneFramebuffer = new SceneFramebuffer();
|
|
var scale = 0.125;
|
var stages = new Array(6);
|
|
stages[0] = new PostProcessStage({
|
fragmentShader: PassThrough,
|
textureScale: scale,
|
forcePowerOfTwo: true,
|
sampleMode: PostProcessStageSampleMode.LINEAR,
|
});
|
|
var brightPass = (stages[1] = new PostProcessStage({
|
fragmentShader: BrightPass,
|
uniforms: {
|
avgLuminance: 0.5, // A guess at the average luminance across the entire scene
|
threshold: 0.25,
|
offset: 0.1,
|
},
|
textureScale: scale,
|
forcePowerOfTwo: true,
|
}));
|
|
var that = this;
|
this._delta = 1.0;
|
this._sigma = 2.0;
|
this._blurStep = new Cartesian2();
|
|
stages[2] = new PostProcessStage({
|
fragmentShader: GaussianBlur1D,
|
uniforms: {
|
step: function () {
|
that._blurStep.x = that._blurStep.y =
|
1.0 / brightPass.outputTexture.width;
|
return that._blurStep;
|
},
|
delta: function () {
|
return that._delta;
|
},
|
sigma: function () {
|
return that._sigma;
|
},
|
direction: 0.0,
|
},
|
textureScale: scale,
|
forcePowerOfTwo: true,
|
});
|
|
stages[3] = new PostProcessStage({
|
fragmentShader: GaussianBlur1D,
|
uniforms: {
|
step: function () {
|
that._blurStep.x = that._blurStep.y =
|
1.0 / brightPass.outputTexture.width;
|
return that._blurStep;
|
},
|
delta: function () {
|
return that._delta;
|
},
|
sigma: function () {
|
return that._sigma;
|
},
|
direction: 1.0,
|
},
|
textureScale: scale,
|
forcePowerOfTwo: true,
|
});
|
|
stages[4] = new PostProcessStage({
|
fragmentShader: PassThrough,
|
sampleMode: PostProcessStageSampleMode.LINEAR,
|
});
|
|
this._uCenter = new Cartesian2();
|
this._uRadius = undefined;
|
|
stages[5] = new PostProcessStage({
|
fragmentShader: AdditiveBlend,
|
uniforms: {
|
center: function () {
|
return that._uCenter;
|
},
|
radius: function () {
|
return that._uRadius;
|
},
|
colorTexture2: function () {
|
return that._sceneFramebuffer.getFramebuffer().getColorTexture(0);
|
},
|
},
|
});
|
|
this._stages = new PostProcessStageComposite({
|
stages: stages,
|
});
|
|
var textureCache = new PostProcessStageTextureCache(this);
|
var length = stages.length;
|
for (var i = 0; i < length; ++i) {
|
stages[i]._textureCache = textureCache;
|
}
|
|
this._textureCache = textureCache;
|
this.length = stages.length;
|
}
|
|
SunPostProcess.prototype.get = function (index) {
|
return this._stages.get(index);
|
};
|
|
SunPostProcess.prototype.getStageByName = function (name) {
|
var length = this._stages.length;
|
for (var i = 0; i < length; ++i) {
|
var stage = this._stages.get(i);
|
if (stage.name === name) {
|
return stage;
|
}
|
}
|
return undefined;
|
};
|
|
var sunPositionECScratch = new Cartesian4();
|
var sunPositionWCScratch = new Cartesian2();
|
var sizeScratch = new Cartesian2();
|
var postProcessMatrix4Scratch = new Matrix4();
|
|
function updateSunPosition(postProcess, context, viewport) {
|
var us = context.uniformState;
|
var sunPosition = us.sunPositionWC;
|
var viewMatrix = us.view;
|
var viewProjectionMatrix = us.viewProjection;
|
var projectionMatrix = us.projection;
|
|
// create up sampled render state
|
var viewportTransformation = Matrix4.computeViewportTransformation(
|
viewport,
|
0.0,
|
1.0,
|
postProcessMatrix4Scratch
|
);
|
var sunPositionEC = Matrix4.multiplyByPoint(
|
viewMatrix,
|
sunPosition,
|
sunPositionECScratch
|
);
|
var sunPositionWC = Transforms.pointToGLWindowCoordinates(
|
viewProjectionMatrix,
|
viewportTransformation,
|
sunPosition,
|
sunPositionWCScratch
|
);
|
|
sunPositionEC.x += CesiumMath.SOLAR_RADIUS;
|
var limbWC = Transforms.pointToGLWindowCoordinates(
|
projectionMatrix,
|
viewportTransformation,
|
sunPositionEC,
|
sunPositionEC
|
);
|
var sunSize =
|
Cartesian2.magnitude(Cartesian2.subtract(limbWC, sunPositionWC, limbWC)) *
|
30.0 *
|
2.0;
|
|
var size = sizeScratch;
|
size.x = sunSize;
|
size.y = sunSize;
|
|
postProcess._uCenter = Cartesian2.clone(sunPositionWC, postProcess._uCenter);
|
postProcess._uRadius = Math.max(size.x, size.y) * 0.15;
|
|
var width = context.drawingBufferWidth;
|
var height = context.drawingBufferHeight;
|
|
var stages = postProcess._stages;
|
var firstStage = stages.get(0);
|
|
var downSampleWidth = firstStage.outputTexture.width;
|
var downSampleHeight = firstStage.outputTexture.height;
|
|
var downSampleViewport = new BoundingRectangle();
|
downSampleViewport.width = downSampleWidth;
|
downSampleViewport.height = downSampleHeight;
|
|
// create down sampled render state
|
viewportTransformation = Matrix4.computeViewportTransformation(
|
downSampleViewport,
|
0.0,
|
1.0,
|
postProcessMatrix4Scratch
|
);
|
sunPositionWC = Transforms.pointToGLWindowCoordinates(
|
viewProjectionMatrix,
|
viewportTransformation,
|
sunPosition,
|
sunPositionWCScratch
|
);
|
|
size.x *= downSampleWidth / width;
|
size.y *= downSampleHeight / height;
|
|
var scissorRectangle = firstStage.scissorRectangle;
|
scissorRectangle.x = Math.max(sunPositionWC.x - size.x * 0.5, 0.0);
|
scissorRectangle.y = Math.max(sunPositionWC.y - size.y * 0.5, 0.0);
|
scissorRectangle.width = Math.min(size.x, width);
|
scissorRectangle.height = Math.min(size.y, height);
|
|
for (var i = 1; i < 4; ++i) {
|
BoundingRectangle.clone(scissorRectangle, stages.get(i).scissorRectangle);
|
}
|
}
|
|
SunPostProcess.prototype.clear = function (context, passState, clearColor) {
|
this._sceneFramebuffer.clear(context, passState, clearColor);
|
this._textureCache.clear(context);
|
};
|
|
SunPostProcess.prototype.update = function (passState) {
|
var context = passState.context;
|
var viewport = passState.viewport;
|
|
var sceneFramebuffer = this._sceneFramebuffer;
|
sceneFramebuffer.update(context, viewport);
|
var framebuffer = sceneFramebuffer.getFramebuffer();
|
|
this._textureCache.update(context);
|
this._stages.update(context, false);
|
|
updateSunPosition(this, context, viewport);
|
|
return framebuffer;
|
};
|
|
SunPostProcess.prototype.execute = function (context) {
|
var colorTexture = this._sceneFramebuffer.getFramebuffer().getColorTexture(0);
|
var stages = this._stages;
|
var length = stages.length;
|
stages.get(0).execute(context, colorTexture);
|
for (var i = 1; i < length; ++i) {
|
stages.get(i).execute(context, stages.get(i - 1).outputTexture);
|
}
|
};
|
|
SunPostProcess.prototype.copy = function (context, framebuffer) {
|
if (!defined(this._copyColorCommand)) {
|
var that = this;
|
this._copyColorCommand = context.createViewportQuadCommand(PassThrough, {
|
uniformMap: {
|
colorTexture: function () {
|
return that._stages.get(that._stages.length - 1).outputTexture;
|
},
|
},
|
owner: this,
|
});
|
}
|
|
this._copyColorCommand.framebuffer = framebuffer;
|
this._copyColorCommand.execute(context);
|
};
|
|
SunPostProcess.prototype.isDestroyed = function () {
|
return false;
|
};
|
|
SunPostProcess.prototype.destroy = function () {
|
this._textureCache.destroy();
|
this._stages.destroy();
|
return destroyObject(this);
|
};
|
export default SunPostProcess;
|
