You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
599 lines
18 KiB
JavaScript
599 lines
18 KiB
JavaScript
import BoundingRectangle from "../Core/BoundingRectangle.js";
|
|
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 PassThrough from "../Shaders/PostProcessStages/PassThrough.js";
|
|
import PassThroughDepth from "../Shaders/PostProcessStages/PassThroughDepth.js";
|
|
import BlendingState from "./BlendingState.js";
|
|
import StencilConstants from "./StencilConstants.js";
|
|
import StencilFunction from "./StencilFunction.js";
|
|
import StencilOperation from "./StencilOperation.js";
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
function GlobeDepth() {
|
|
this._globeColorTexture = undefined;
|
|
this._primitiveColorTexture = undefined;
|
|
this._depthStencilTexture = undefined;
|
|
this._globeDepthTexture = undefined;
|
|
this._tempGlobeDepthTexture = undefined;
|
|
this._tempCopyDepthTexture = undefined;
|
|
|
|
this._globeColorFramebuffer = undefined;
|
|
this._primitiveColorFramebuffer = undefined;
|
|
this._copyDepthFramebuffer = undefined;
|
|
this._tempCopyDepthFramebuffer = undefined;
|
|
this._updateDepthFramebuffer = undefined;
|
|
|
|
this._clearGlobeColorCommand = undefined;
|
|
this._clearPrimitiveColorCommand = undefined;
|
|
this._copyColorCommand = undefined;
|
|
this._copyDepthCommand = undefined;
|
|
this._tempCopyDepthCommand = undefined;
|
|
this._updateDepthCommand = undefined;
|
|
this._mergeColorCommand = undefined;
|
|
|
|
this._viewport = new BoundingRectangle();
|
|
this._rs = undefined;
|
|
this._rsBlend = undefined;
|
|
this._rsUpdate = undefined;
|
|
|
|
this._useScissorTest = false;
|
|
this._scissorRectangle = undefined;
|
|
|
|
this._useLogDepth = undefined;
|
|
this._useHdr = undefined;
|
|
this._clearGlobeDepth = undefined;
|
|
|
|
this._debugGlobeDepthViewportCommand = undefined;
|
|
}
|
|
|
|
Object.defineProperties(GlobeDepth.prototype, {
|
|
framebuffer: {
|
|
get: function () {
|
|
return this._globeColorFramebuffer;
|
|
},
|
|
},
|
|
primitiveFramebuffer: {
|
|
get: function () {
|
|
return this._primitiveColorFramebuffer;
|
|
},
|
|
},
|
|
});
|
|
|
|
function executeDebugGlobeDepth(globeDepth, context, passState, useLogDepth) {
|
|
if (
|
|
!defined(globeDepth._debugGlobeDepthViewportCommand) ||
|
|
useLogDepth !== globeDepth._useLogDepth
|
|
) {
|
|
var fsSource =
|
|
"uniform highp sampler2D u_depthTexture;\n" +
|
|
"varying vec2 v_textureCoordinates;\n" +
|
|
"void main()\n" +
|
|
"{\n" +
|
|
" float z_window = czm_unpackDepth(texture2D(u_depthTexture, v_textureCoordinates));\n" +
|
|
" z_window = czm_reverseLogDepth(z_window); \n" +
|
|
" float n_range = czm_depthRange.near;\n" +
|
|
" float f_range = czm_depthRange.far;\n" +
|
|
" float z_ndc = (2.0 * z_window - n_range - f_range) / (f_range - n_range);\n" +
|
|
" float scale = pow(z_ndc * 0.5 + 0.5, 8.0);\n" +
|
|
" gl_FragColor = vec4(mix(vec3(0.0), vec3(1.0), scale), 1.0);\n" +
|
|
"}\n";
|
|
var fs = new ShaderSource({
|
|
defines: [useLogDepth ? "LOG_DEPTH" : ""],
|
|
sources: [fsSource],
|
|
});
|
|
|
|
globeDepth._debugGlobeDepthViewportCommand = context.createViewportQuadCommand(
|
|
fs,
|
|
{
|
|
uniformMap: {
|
|
u_depthTexture: function () {
|
|
return globeDepth._globeDepthTexture;
|
|
},
|
|
},
|
|
owner: globeDepth,
|
|
}
|
|
);
|
|
|
|
globeDepth._useLogDepth = useLogDepth;
|
|
}
|
|
|
|
globeDepth._debugGlobeDepthViewportCommand.execute(context, passState);
|
|
}
|
|
|
|
function destroyTextures(globeDepth) {
|
|
globeDepth._globeColorTexture =
|
|
globeDepth._globeColorTexture &&
|
|
!globeDepth._globeColorTexture.isDestroyed() &&
|
|
globeDepth._globeColorTexture.destroy();
|
|
globeDepth._depthStencilTexture =
|
|
globeDepth._depthStencilTexture &&
|
|
!globeDepth._depthStencilTexture.isDestroyed() &&
|
|
globeDepth._depthStencilTexture.destroy();
|
|
globeDepth._globeDepthTexture =
|
|
globeDepth._globeDepthTexture &&
|
|
!globeDepth._globeDepthTexture.isDestroyed() &&
|
|
globeDepth._globeDepthTexture.destroy();
|
|
}
|
|
|
|
function destroyFramebuffers(globeDepth) {
|
|
globeDepth._globeColorFramebuffer =
|
|
globeDepth._globeColorFramebuffer &&
|
|
!globeDepth._globeColorFramebuffer.isDestroyed() &&
|
|
globeDepth._globeColorFramebuffer.destroy();
|
|
globeDepth._copyDepthFramebuffer =
|
|
globeDepth._copyDepthFramebuffer &&
|
|
!globeDepth._copyDepthFramebuffer.isDestroyed() &&
|
|
globeDepth._copyDepthFramebuffer.destroy();
|
|
}
|
|
|
|
function destroyUpdateDepthResources(globeDepth) {
|
|
globeDepth._tempCopyDepthFramebuffer =
|
|
globeDepth._tempCopyDepthFramebuffer &&
|
|
!globeDepth._tempCopyDepthFramebuffer.isDestroyed() &&
|
|
globeDepth._tempCopyDepthFramebuffer.destroy();
|
|
globeDepth._updateDepthFramebuffer =
|
|
globeDepth._updateDepthFramebuffer &&
|
|
!globeDepth._updateDepthFramebuffer.isDestroyed() &&
|
|
globeDepth._updateDepthFramebuffer.destroy();
|
|
globeDepth._tempGlobeDepthTexture =
|
|
globeDepth._tempGlobeDepthTexture &&
|
|
!globeDepth._tempGlobeDepthTexture.isDestroyed() &&
|
|
globeDepth._tempGlobeDepthTexture.destroy();
|
|
}
|
|
|
|
function createUpdateDepthResources(
|
|
globeDepth,
|
|
context,
|
|
width,
|
|
height,
|
|
passState
|
|
) {
|
|
globeDepth._tempGlobeDepthTexture = new Texture({
|
|
context: context,
|
|
width: width,
|
|
height: height,
|
|
pixelFormat: PixelFormat.RGBA,
|
|
pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
|
|
sampler: Sampler.NEAREST,
|
|
});
|
|
globeDepth._tempCopyDepthFramebuffer = new Framebuffer({
|
|
context: context,
|
|
colorTextures: [globeDepth._tempGlobeDepthTexture],
|
|
destroyAttachments: false,
|
|
});
|
|
globeDepth._updateDepthFramebuffer = new Framebuffer({
|
|
context: context,
|
|
colorTextures: [globeDepth._globeDepthTexture],
|
|
depthStencilTexture: passState.framebuffer.depthStencilTexture,
|
|
destroyAttachments: false,
|
|
});
|
|
}
|
|
|
|
function createTextures(globeDepth, context, width, height, hdr) {
|
|
var pixelDatatype = hdr
|
|
? context.halfFloatingPointTexture
|
|
? PixelDatatype.HALF_FLOAT
|
|
: PixelDatatype.FLOAT
|
|
: PixelDatatype.UNSIGNED_BYTE;
|
|
globeDepth._globeColorTexture = new Texture({
|
|
context: context,
|
|
width: width,
|
|
height: height,
|
|
pixelFormat: PixelFormat.RGBA,
|
|
pixelDatatype: pixelDatatype,
|
|
sampler: Sampler.NEAREST,
|
|
});
|
|
|
|
globeDepth._depthStencilTexture = new Texture({
|
|
context: context,
|
|
width: width,
|
|
height: height,
|
|
pixelFormat: PixelFormat.DEPTH_STENCIL,
|
|
pixelDatatype: PixelDatatype.UNSIGNED_INT_24_8,
|
|
});
|
|
|
|
globeDepth._globeDepthTexture = new Texture({
|
|
context: context,
|
|
width: width,
|
|
height: height,
|
|
pixelFormat: PixelFormat.RGBA,
|
|
pixelDatatype: PixelDatatype.UNSIGNED_BYTE,
|
|
sampler: Sampler.NEAREST,
|
|
});
|
|
}
|
|
|
|
function createFramebuffers(globeDepth, context) {
|
|
globeDepth._globeColorFramebuffer = new Framebuffer({
|
|
context: context,
|
|
colorTextures: [globeDepth._globeColorTexture],
|
|
depthStencilTexture: globeDepth._depthStencilTexture,
|
|
destroyAttachments: false,
|
|
});
|
|
|
|
globeDepth._copyDepthFramebuffer = new Framebuffer({
|
|
context: context,
|
|
colorTextures: [globeDepth._globeDepthTexture],
|
|
destroyAttachments: false,
|
|
});
|
|
}
|
|
|
|
function createPrimitiveFramebuffer(globeDepth, context, width, height, hdr) {
|
|
var pixelDatatype = hdr
|
|
? context.halfFloatingPointTexture
|
|
? PixelDatatype.HALF_FLOAT
|
|
: PixelDatatype.FLOAT
|
|
: PixelDatatype.UNSIGNED_BYTE;
|
|
globeDepth._primitiveColorTexture = new Texture({
|
|
context: context,
|
|
width: width,
|
|
height: height,
|
|
pixelFormat: PixelFormat.RGBA,
|
|
pixelDatatype: pixelDatatype,
|
|
sampler: Sampler.NEAREST,
|
|
});
|
|
|
|
globeDepth._primitiveColorFramebuffer = new Framebuffer({
|
|
context: context,
|
|
colorTextures: [globeDepth._primitiveColorTexture],
|
|
depthStencilTexture: globeDepth._depthStencilTexture,
|
|
destroyAttachments: false,
|
|
});
|
|
}
|
|
|
|
function destroyPrimitiveFramebuffer(globeDepth) {
|
|
globeDepth._primitiveColorTexture =
|
|
globeDepth._primitiveColorTexture &&
|
|
!globeDepth._primitiveColorTexture.isDestroyed() &&
|
|
globeDepth._primitiveColorTexture.destroy();
|
|
globeDepth._primitiveColorFramebuffer =
|
|
globeDepth._primitiveColorFramebuffer &&
|
|
!globeDepth._primitiveColorFramebuffer.isDestroyed() &&
|
|
globeDepth._primitiveColorFramebuffer.destroy();
|
|
}
|
|
|
|
function updateFramebuffers(
|
|
globeDepth,
|
|
context,
|
|
width,
|
|
height,
|
|
hdr,
|
|
clearGlobeDepth
|
|
) {
|
|
var colorTexture = globeDepth._globeColorTexture;
|
|
var textureChanged =
|
|
!defined(colorTexture) ||
|
|
colorTexture.width !== width ||
|
|
colorTexture.height !== height ||
|
|
hdr !== globeDepth._useHdr;
|
|
if (textureChanged) {
|
|
destroyTextures(globeDepth);
|
|
destroyFramebuffers(globeDepth);
|
|
createTextures(globeDepth, context, width, height, hdr, clearGlobeDepth);
|
|
createFramebuffers(globeDepth, context, clearGlobeDepth);
|
|
}
|
|
|
|
if (textureChanged || clearGlobeDepth !== globeDepth._clearGlobeDepth) {
|
|
destroyPrimitiveFramebuffer(globeDepth);
|
|
if (clearGlobeDepth) {
|
|
createPrimitiveFramebuffer(globeDepth, context, width, height, hdr);
|
|
}
|
|
}
|
|
}
|
|
|
|
function updateCopyCommands(globeDepth, context, width, height, passState) {
|
|
globeDepth._viewport.width = width;
|
|
globeDepth._viewport.height = height;
|
|
|
|
var useScissorTest = !BoundingRectangle.equals(
|
|
globeDepth._viewport,
|
|
passState.viewport
|
|
);
|
|
var updateScissor = useScissorTest !== globeDepth._useScissorTest;
|
|
globeDepth._useScissorTest = useScissorTest;
|
|
|
|
if (
|
|
!BoundingRectangle.equals(globeDepth._scissorRectangle, passState.viewport)
|
|
) {
|
|
globeDepth._scissorRectangle = BoundingRectangle.clone(
|
|
passState.viewport,
|
|
globeDepth._scissorRectangle
|
|
);
|
|
updateScissor = true;
|
|
}
|
|
|
|
if (
|
|
!defined(globeDepth._rs) ||
|
|
!BoundingRectangle.equals(globeDepth._viewport, globeDepth._rs.viewport) ||
|
|
updateScissor
|
|
) {
|
|
globeDepth._rs = RenderState.fromCache({
|
|
viewport: globeDepth._viewport,
|
|
scissorTest: {
|
|
enabled: globeDepth._useScissorTest,
|
|
rectangle: globeDepth._scissorRectangle,
|
|
},
|
|
});
|
|
globeDepth._rsBlend = RenderState.fromCache({
|
|
viewport: globeDepth._viewport,
|
|
scissorTest: {
|
|
enabled: globeDepth._useScissorTest,
|
|
rectangle: globeDepth._scissorRectangle,
|
|
},
|
|
blending: BlendingState.ALPHA_BLEND,
|
|
});
|
|
|
|
// Copy packed depth only if the 3D Tiles bit is set
|
|
globeDepth._rsUpdate = RenderState.fromCache({
|
|
viewport: globeDepth._viewport,
|
|
scissorTest: {
|
|
enabled: globeDepth._useScissorTest,
|
|
rectangle: globeDepth._scissorRectangle,
|
|
},
|
|
stencilTest: {
|
|
enabled: true,
|
|
frontFunction: StencilFunction.EQUAL,
|
|
frontOperation: {
|
|
fail: StencilOperation.KEEP,
|
|
zFail: StencilOperation.KEEP,
|
|
zPass: StencilOperation.KEEP,
|
|
},
|
|
backFunction: StencilFunction.NEVER,
|
|
reference: StencilConstants.CESIUM_3D_TILE_MASK,
|
|
mask: StencilConstants.CESIUM_3D_TILE_MASK,
|
|
},
|
|
});
|
|
}
|
|
|
|
if (!defined(globeDepth._copyDepthCommand)) {
|
|
globeDepth._copyDepthCommand = context.createViewportQuadCommand(
|
|
PassThroughDepth,
|
|
{
|
|
uniformMap: {
|
|
u_depthTexture: function () {
|
|
return globeDepth._depthStencilTexture;
|
|
},
|
|
},
|
|
owner: globeDepth,
|
|
}
|
|
);
|
|
}
|
|
|
|
globeDepth._copyDepthCommand.framebuffer = globeDepth._copyDepthFramebuffer;
|
|
globeDepth._copyDepthCommand.renderState = globeDepth._rs;
|
|
|
|
if (!defined(globeDepth._copyColorCommand)) {
|
|
globeDepth._copyColorCommand = context.createViewportQuadCommand(
|
|
PassThrough,
|
|
{
|
|
uniformMap: {
|
|
colorTexture: function () {
|
|
return globeDepth._globeColorTexture;
|
|
},
|
|
},
|
|
owner: globeDepth,
|
|
}
|
|
);
|
|
}
|
|
|
|
globeDepth._copyColorCommand.renderState = globeDepth._rs;
|
|
|
|
if (!defined(globeDepth._tempCopyDepthCommand)) {
|
|
globeDepth._tempCopyDepthCommand = context.createViewportQuadCommand(
|
|
PassThroughDepth,
|
|
{
|
|
uniformMap: {
|
|
u_depthTexture: function () {
|
|
return globeDepth._tempCopyDepthTexture;
|
|
},
|
|
},
|
|
owner: globeDepth,
|
|
}
|
|
);
|
|
}
|
|
|
|
globeDepth._tempCopyDepthCommand.framebuffer =
|
|
globeDepth._tempCopyDepthFramebuffer;
|
|
globeDepth._tempCopyDepthCommand.renderState = globeDepth._rs;
|
|
|
|
if (!defined(globeDepth._updateDepthCommand)) {
|
|
globeDepth._updateDepthCommand = context.createViewportQuadCommand(
|
|
PassThrough,
|
|
{
|
|
uniformMap: {
|
|
colorTexture: function () {
|
|
return globeDepth._tempGlobeDepthTexture;
|
|
},
|
|
},
|
|
owner: globeDepth,
|
|
}
|
|
);
|
|
}
|
|
|
|
globeDepth._updateDepthCommand.framebuffer =
|
|
globeDepth._updateDepthFramebuffer;
|
|
globeDepth._updateDepthCommand.renderState = globeDepth._rsUpdate;
|
|
|
|
if (!defined(globeDepth._clearGlobeColorCommand)) {
|
|
globeDepth._clearGlobeColorCommand = new ClearCommand({
|
|
color: new Color(0.0, 0.0, 0.0, 0.0),
|
|
stencil: 0.0,
|
|
owner: globeDepth,
|
|
});
|
|
}
|
|
|
|
globeDepth._clearGlobeColorCommand.framebuffer =
|
|
globeDepth._globeColorFramebuffer;
|
|
|
|
if (!defined(globeDepth._clearPrimitiveColorCommand)) {
|
|
globeDepth._clearPrimitiveColorCommand = new ClearCommand({
|
|
color: new Color(0.0, 0.0, 0.0, 0.0),
|
|
stencil: 0.0,
|
|
owner: globeDepth,
|
|
});
|
|
}
|
|
|
|
globeDepth._clearPrimitiveColorCommand.framebuffer =
|
|
globeDepth._primitiveColorFramebuffer;
|
|
|
|
if (!defined(globeDepth._mergeColorCommand)) {
|
|
globeDepth._mergeColorCommand = context.createViewportQuadCommand(
|
|
PassThrough,
|
|
{
|
|
uniformMap: {
|
|
colorTexture: function () {
|
|
return globeDepth._primitiveColorTexture;
|
|
},
|
|
},
|
|
owner: globeDepth,
|
|
}
|
|
);
|
|
}
|
|
|
|
globeDepth._mergeColorCommand.framebuffer = globeDepth._globeColorFramebuffer;
|
|
globeDepth._mergeColorCommand.renderState = globeDepth._rsBlend;
|
|
}
|
|
|
|
GlobeDepth.prototype.executeDebugGlobeDepth = function (
|
|
context,
|
|
passState,
|
|
useLogDepth
|
|
) {
|
|
executeDebugGlobeDepth(this, context, passState, useLogDepth);
|
|
};
|
|
|
|
GlobeDepth.prototype.update = function (
|
|
context,
|
|
passState,
|
|
viewport,
|
|
hdr,
|
|
clearGlobeDepth
|
|
) {
|
|
var width = viewport.width;
|
|
var height = viewport.height;
|
|
|
|
updateFramebuffers(this, context, width, height, hdr, clearGlobeDepth);
|
|
updateCopyCommands(this, context, width, height, passState);
|
|
context.uniformState.globeDepthTexture = undefined;
|
|
|
|
this._useHdr = hdr;
|
|
this._clearGlobeDepth = clearGlobeDepth;
|
|
};
|
|
|
|
GlobeDepth.prototype.executeCopyDepth = function (context, passState) {
|
|
if (defined(this._copyDepthCommand)) {
|
|
this._copyDepthCommand.execute(context, passState);
|
|
context.uniformState.globeDepthTexture = this._globeDepthTexture;
|
|
}
|
|
};
|
|
|
|
GlobeDepth.prototype.executeUpdateDepth = function (
|
|
context,
|
|
passState,
|
|
clearGlobeDepth
|
|
) {
|
|
var depthTextureToCopy = passState.framebuffer.depthStencilTexture;
|
|
if (clearGlobeDepth || depthTextureToCopy !== this._depthStencilTexture) {
|
|
// First copy the depth to a temporary globe depth texture, then update the
|
|
// main globe depth texture where the stencil bit for 3D Tiles is set.
|
|
// This preserves the original globe depth except where 3D Tiles is rendered.
|
|
// The additional texture and framebuffer resources are created on demand.
|
|
if (defined(this._updateDepthCommand)) {
|
|
if (
|
|
!defined(this._updateDepthFramebuffer) ||
|
|
this._updateDepthFramebuffer.depthStencilTexture !==
|
|
depthTextureToCopy ||
|
|
this._updateDepthFramebuffer.getColorTexture(0) !==
|
|
this._globeDepthTexture
|
|
) {
|
|
var width = this._globeDepthTexture.width;
|
|
var height = this._globeDepthTexture.height;
|
|
destroyUpdateDepthResources(this);
|
|
createUpdateDepthResources(this, context, width, height, passState);
|
|
updateCopyCommands(this, context, width, height, passState);
|
|
}
|
|
this._tempCopyDepthTexture = depthTextureToCopy;
|
|
this._tempCopyDepthCommand.execute(context, passState);
|
|
this._updateDepthCommand.execute(context, passState);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Fast path - the depth texture can be copied normally.
|
|
if (defined(this._copyDepthCommand)) {
|
|
this._copyDepthCommand.execute(context, passState);
|
|
}
|
|
};
|
|
|
|
GlobeDepth.prototype.executeCopyColor = function (context, passState) {
|
|
if (defined(this._copyColorCommand)) {
|
|
this._copyColorCommand.execute(context, passState);
|
|
}
|
|
};
|
|
|
|
GlobeDepth.prototype.executeMergeColor = function (context, passState) {
|
|
if (defined(this._mergeColorCommand)) {
|
|
this._mergeColorCommand.execute(context, passState);
|
|
}
|
|
};
|
|
|
|
GlobeDepth.prototype.clear = function (context, passState, clearColor) {
|
|
var clear = this._clearGlobeColorCommand;
|
|
if (defined(clear)) {
|
|
Color.clone(clearColor, clear.color);
|
|
clear.execute(context, passState);
|
|
}
|
|
clear = this._clearPrimitiveColorCommand;
|
|
if (defined(clear) && defined(this._primitiveColorFramebuffer)) {
|
|
clear.execute(context, passState);
|
|
}
|
|
};
|
|
|
|
GlobeDepth.prototype.isDestroyed = function () {
|
|
return false;
|
|
};
|
|
|
|
GlobeDepth.prototype.destroy = function () {
|
|
destroyTextures(this);
|
|
destroyFramebuffers(this);
|
|
destroyPrimitiveFramebuffer(this);
|
|
destroyUpdateDepthResources(this);
|
|
|
|
if (defined(this._copyColorCommand)) {
|
|
this._copyColorCommand.shaderProgram = this._copyColorCommand.shaderProgram.destroy();
|
|
}
|
|
|
|
if (defined(this._copyDepthCommand)) {
|
|
this._copyDepthCommand.shaderProgram = this._copyDepthCommand.shaderProgram.destroy();
|
|
}
|
|
|
|
if (defined(this._tempCopyDepthCommand)) {
|
|
this._tempCopyDepthCommand.shaderProgram = this._tempCopyDepthCommand.shaderProgram.destroy();
|
|
}
|
|
|
|
if (defined(this._updateDepthCommand)) {
|
|
this._updateDepthCommand.shaderProgram = this._updateDepthCommand.shaderProgram.destroy();
|
|
}
|
|
|
|
if (defined(this._mergeColorCommand)) {
|
|
this._mergeColorCommand.shaderProgram = this._mergeColorCommand.shaderProgram.destroy();
|
|
}
|
|
|
|
if (defined(this._debugGlobeDepthViewportCommand)) {
|
|
this._debugGlobeDepthViewportCommand.shaderProgram = this._debugGlobeDepthViewportCommand.shaderProgram.destroy();
|
|
}
|
|
|
|
return destroyObject(this);
|
|
};
|
|
export default GlobeDepth;
|