import Color from "../Core/Color.js";
|
import defined from "../Core/defined.js";
|
import destroyObject from "../Core/destroyObject.js";
|
import PixelFormat from "../Core/PixelFormat.js";
|
import ClearCommand from "../Renderer/ClearCommand.js";
|
import Framebuffer from "../Renderer/Framebuffer.js";
|
import PixelDatatype from "../Renderer/PixelDatatype.js";
|
import RenderState from "../Renderer/RenderState.js";
|
import Sampler from "../Renderer/Sampler.js";
|
import ShaderSource from "../Renderer/ShaderSource.js";
|
import Texture from "../Renderer/Texture.js";
|
import TextureMagnificationFilter from "../Renderer/TextureMagnificationFilter.js";
|
import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
|
import TextureWrap from "../Renderer/TextureWrap.js";
|
import PassThrough from "../Shaders/PostProcessStages/PassThrough.js";
|
import BlendingState from "./BlendingState.js";
|
import StencilConstants from "./StencilConstants.js";
|
import StencilFunction from "./StencilFunction.js";
|
import StencilOperation from "./StencilOperation.js";
|
|
/**
|
* @private
|
*/
|
function InvertClassification() {
|
this.previousFramebuffer = undefined;
|
this._previousFramebuffer = undefined;
|
|
this._texture = undefined;
|
this._classifiedTexture = undefined;
|
this._depthStencilTexture = undefined;
|
this._fbo = undefined;
|
this._fboClassified = undefined;
|
|
this._rsUnclassified = undefined;
|
this._rsClassified = undefined;
|
|
this._unclassifiedCommand = undefined;
|
this._classifiedCommand = undefined;
|
this._translucentCommand = undefined;
|
|
this._clearColorCommand = new ClearCommand({
|
color: new Color(0.0, 0.0, 0.0, 0.0),
|
owner: this,
|
});
|
this._clearCommand = new ClearCommand({
|
color: new Color(0.0, 0.0, 0.0, 0.0),
|
depth: 1.0,
|
stencil: 0,
|
});
|
|
var that = this;
|
this._uniformMap = {
|
colorTexture: function () {
|
return that._texture;
|
},
|
depthTexture: function () {
|
return that._depthStencilTexture;
|
},
|
classifiedTexture: function () {
|
return that._classifiedTexture;
|
},
|
};
|
}
|
|
Object.defineProperties(InvertClassification.prototype, {
|
unclassifiedCommand: {
|
get: function () {
|
return this._unclassifiedCommand;
|
},
|
},
|
});
|
|
InvertClassification.isTranslucencySupported = function (context) {
|
return context.depthTexture && context.fragmentDepth;
|
};
|
|
var rsUnclassified = {
|
depthMask: false,
|
stencilTest: {
|
enabled: true,
|
frontFunction: StencilFunction.EQUAL,
|
frontOperation: {
|
fail: StencilOperation.KEEP,
|
zFail: StencilOperation.KEEP,
|
zPass: StencilOperation.KEEP,
|
},
|
backFunction: StencilFunction.NEVER,
|
reference: 0,
|
mask: StencilConstants.CLASSIFICATION_MASK,
|
},
|
blending: BlendingState.ALPHA_BLEND,
|
};
|
|
var rsClassified = {
|
depthMask: false,
|
stencilTest: {
|
enabled: true,
|
frontFunction: StencilFunction.NOT_EQUAL,
|
frontOperation: {
|
fail: StencilOperation.KEEP,
|
zFail: StencilOperation.KEEP,
|
zPass: StencilOperation.KEEP,
|
},
|
backFunction: StencilFunction.NEVER,
|
reference: 0,
|
mask: StencilConstants.CLASSIFICATION_MASK,
|
},
|
blending: BlendingState.ALPHA_BLEND,
|
};
|
|
// Set the 3D Tiles bit when rendering back into the scene's framebuffer. This is only needed if
|
// invert classification does not use the scene's depth-stencil texture, which is the case if the invert
|
// classification color is translucent.
|
var rsDefault = {
|
depthMask: true,
|
depthTest: {
|
enabled: true,
|
},
|
stencilTest: StencilConstants.setCesium3DTileBit(),
|
stencilMask: StencilConstants.CESIUM_3D_TILE_MASK,
|
blending: BlendingState.ALPHA_BLEND,
|
};
|
|
var translucentFS =
|
"#extension GL_EXT_frag_depth : enable\n" +
|
"uniform sampler2D colorTexture;\n" +
|
"uniform sampler2D depthTexture;\n" +
|
"uniform sampler2D classifiedTexture;\n" +
|
"varying vec2 v_textureCoordinates;\n" +
|
"void main()\n" +
|
"{\n" +
|
" vec4 color = texture2D(colorTexture, v_textureCoordinates);\n" +
|
" if (color.a == 0.0)\n" +
|
" {\n" +
|
" discard;\n" +
|
" }\n" +
|
" bool isClassified = all(equal(texture2D(classifiedTexture, v_textureCoordinates), vec4(0.0)));\n" +
|
"#ifdef UNCLASSIFIED\n" +
|
" vec4 highlightColor = czm_invertClassificationColor;\n" +
|
" if (isClassified)\n" +
|
" {\n" +
|
" discard;\n" +
|
" }\n" +
|
"#else\n" +
|
" vec4 highlightColor = vec4(1.0);\n" +
|
" if (!isClassified)\n" +
|
" {\n" +
|
" discard;\n" +
|
" }\n" +
|
"#endif\n" +
|
" gl_FragColor = color * highlightColor;\n" +
|
" gl_FragDepthEXT = texture2D(depthTexture, v_textureCoordinates).r;\n" +
|
"}\n";
|
|
var opaqueFS =
|
"uniform sampler2D colorTexture;\n" +
|
"varying vec2 v_textureCoordinates;\n" +
|
"void main()\n" +
|
"{\n" +
|
" vec4 color = texture2D(colorTexture, v_textureCoordinates);\n" +
|
" if (color.a == 0.0)\n" +
|
" {\n" +
|
" discard;\n" +
|
" }\n" +
|
"#ifdef UNCLASSIFIED\n" +
|
" gl_FragColor = color * czm_invertClassificationColor;\n" +
|
"#else\n" +
|
" gl_FragColor = color;\n" +
|
"#endif\n" +
|
"}\n";
|
|
InvertClassification.prototype.update = function (context) {
|
var texture = this._texture;
|
var previousFramebufferChanged =
|
!defined(texture) || this.previousFramebuffer !== this._previousFramebuffer;
|
this._previousFramebuffer = this.previousFramebuffer;
|
|
var width = context.drawingBufferWidth;
|
var height = context.drawingBufferHeight;
|
|
var textureChanged =
|
!defined(texture) || texture.width !== width || texture.height !== height;
|
if (textureChanged || previousFramebufferChanged) {
|
this._texture = this._texture && this._texture.destroy();
|
this._classifiedTexture =
|
this._classifiedTexture && this._classifiedTexture.destroy();
|
this._depthStencilTexture =
|
this._depthStencilTexture && this._depthStencilTexture.destroy();
|
|
this._texture = new Texture({
|
context: context,
|
width: width,
|
height: height,
|
pixelFormat: PixelFormat.RGBA,
|
pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
|
sampler: new Sampler({
|
wrapS: TextureWrap.CLAMP_TO_EDGE,
|
wrapT: TextureWrap.CLAMP_TO_EDGE,
|
minificationFilter: TextureMinificationFilter.LINEAR,
|
magnificationFilter: TextureMagnificationFilter.LINEAR,
|
}),
|
});
|
|
if (!defined(this._previousFramebuffer)) {
|
this._classifiedTexture = new Texture({
|
context: context,
|
width: width,
|
height: height,
|
pixelFormat: PixelFormat.RGBA,
|
pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
|
sampler: new Sampler({
|
wrapS: TextureWrap.CLAMP_TO_EDGE,
|
wrapT: TextureWrap.CLAMP_TO_EDGE,
|
minificationFilter: TextureMinificationFilter.LINEAR,
|
magnificationFilter: TextureMagnificationFilter.LINEAR,
|
}),
|
});
|
this._depthStencilTexture = new Texture({
|
context: context,
|
width: width,
|
height: height,
|
pixelFormat: PixelFormat.DEPTH_STENCIL,
|
pixelDatatype: PixelDatatype.UNSIGNED_INT_24_8,
|
});
|
}
|
}
|
|
if (!defined(this._fbo) || textureChanged || previousFramebufferChanged) {
|
this._fbo = this._fbo && this._fbo.destroy();
|
this._fboClassified = this._fboClassified && this._fboClassified.destroy();
|
|
var depthStencilTexture;
|
var depthStencilRenderbuffer;
|
if (defined(this._previousFramebuffer)) {
|
depthStencilTexture = this._previousFramebuffer.depthStencilTexture;
|
depthStencilRenderbuffer = this._previousFramebuffer
|
.depthStencilRenderbuffer;
|
} else {
|
depthStencilTexture = this._depthStencilTexture;
|
}
|
|
this._fbo = new Framebuffer({
|
context: context,
|
colorTextures: [this._texture],
|
depthStencilTexture: depthStencilTexture,
|
depthStencilRenderbuffer: depthStencilRenderbuffer,
|
destroyAttachments: false,
|
});
|
|
if (!defined(this._previousFramebuffer)) {
|
this._fboClassified = new Framebuffer({
|
context: context,
|
colorTextures: [this._classifiedTexture],
|
depthStencilTexture: depthStencilTexture,
|
destroyAttachments: false,
|
});
|
}
|
}
|
|
if (!defined(this._rsUnclassified)) {
|
this._rsUnclassified = RenderState.fromCache(rsUnclassified);
|
this._rsClassified = RenderState.fromCache(rsClassified);
|
this._rsDefault = RenderState.fromCache(rsDefault);
|
}
|
|
if (!defined(this._unclassifiedCommand) || previousFramebufferChanged) {
|
if (defined(this._unclassifiedCommand)) {
|
this._unclassifiedCommand.shaderProgram =
|
this._unclassifiedCommand.shaderProgram &&
|
this._unclassifiedCommand.shaderProgram.destroy();
|
this._classifiedCommand.shaderProgram =
|
this._classifiedCommand.shaderProgram &&
|
this._classifiedCommand.shaderProgram.destroy();
|
}
|
|
var fs = defined(this._previousFramebuffer) ? opaqueFS : translucentFS;
|
var unclassifiedFSSource = new ShaderSource({
|
defines: ["UNCLASSIFIED"],
|
sources: [fs],
|
});
|
var classifiedFSSource = new ShaderSource({
|
sources: [fs],
|
});
|
this._unclassifiedCommand = context.createViewportQuadCommand(
|
unclassifiedFSSource,
|
{
|
renderState: defined(this._previousFramebuffer)
|
? this._rsUnclassified
|
: this._rsDefault,
|
uniformMap: this._uniformMap,
|
owner: this,
|
}
|
);
|
this._classifiedCommand = context.createViewportQuadCommand(
|
classifiedFSSource,
|
{
|
renderState: defined(this._previousFramebuffer)
|
? this._rsClassified
|
: this._rsDefault,
|
uniformMap: this._uniformMap,
|
owner: this,
|
}
|
);
|
|
if (defined(this._translucentCommand)) {
|
this._translucentCommand.shaderProgram =
|
this._translucentCommand.shaderProgram &&
|
this._translucentCommand.shaderProgram.destroy();
|
}
|
if (!defined(this._previousFramebuffer)) {
|
this._translucentCommand = context.createViewportQuadCommand(
|
PassThrough,
|
{
|
renderState: this._rsUnclassified,
|
uniformMap: this._uniformMap,
|
owner: this,
|
}
|
);
|
}
|
}
|
};
|
|
InvertClassification.prototype.clear = function (context, passState) {
|
var framebuffer = passState.framebuffer;
|
|
if (defined(this._previousFramebuffer)) {
|
passState.framebuffer = this._fbo;
|
this._clearColorCommand.execute(context, passState);
|
} else {
|
passState.framebuffer = this._fbo;
|
this._clearCommand.execute(context, passState);
|
passState.framebuffer = this._fboClassified;
|
this._clearCommand.execute(context, passState);
|
}
|
|
passState.framebuffer = framebuffer;
|
};
|
|
InvertClassification.prototype.executeClassified = function (
|
context,
|
passState
|
) {
|
if (!defined(this._previousFramebuffer)) {
|
var framebuffer = passState.framebuffer;
|
|
passState.framebuffer = this._fboClassified;
|
this._translucentCommand.execute(context, passState);
|
|
passState.framebuffer = framebuffer;
|
}
|
this._classifiedCommand.execute(context, passState);
|
};
|
|
InvertClassification.prototype.executeUnclassified = function (
|
context,
|
passState
|
) {
|
this._unclassifiedCommand.execute(context, passState);
|
};
|
|
InvertClassification.prototype.isDestroyed = function () {
|
return false;
|
};
|
|
InvertClassification.prototype.destroy = function () {
|
this._fbo = this._fbo && this._fbo.destroy();
|
this._texture = this._texture && this._texture.destroy();
|
this._depthStencilTexture =
|
this._depthStencilTexture && this._depthStencilTexture.destroy();
|
|
if (defined(this._unclassifiedCommand)) {
|
this._unclassifiedCommand.shaderProgram =
|
this._unclassifiedCommand.shaderProgram &&
|
this._unclassifiedCommand.shaderProgram.destroy();
|
this._classifiedCommand.shaderProgram =
|
this._classifiedCommand.shaderProgram &&
|
this._classifiedCommand.shaderProgram.destroy();
|
}
|
|
return destroyObject(this);
|
};
|
export default InvertClassification;
|
