@itwin/core-frontend 3.6.0-dev.8 → 4.0.0-dev.10

package/lib/esm/render/webgl/SceneCompositor.js

@@ -8,13 +8,12 @@
 import { assert, dispose } from "@itwin/core-bentley";
 import { Transform, Vector2d, Vector3d } from "@itwin/core-geometry";
 import { RenderMode, SpatialClassifierInsideDisplay, SpatialClassifierOutsideDisplay, } from "@itwin/core-common";
-import { DepthType, RenderType } from "@itwin/webgl-compatibility";
+import { RenderType } from "@itwin/webgl-compatibility";
 import { Pixel } from "../Pixel";
 import { BranchState } from "./BranchState";
-import { AmbientOcclusionGeometry, BlurGeometry, BlurType, BoundaryType, CompositeGeometry, CopyPickBufferGeometry, ScreenPointsGeometry, SingleTexturedViewportQuadGeometry, ViewportQuadGeometry, VolumeClassifierGeometry, } from "./CachedGeometry";
+import { AmbientOcclusionGeometry, BlurGeometry, BlurType, BoundaryType, CompositeGeometry, CopyPickBufferGeometry, SingleTexturedViewportQuadGeometry, ViewportQuadGeometry, VolumeClassifierGeometry, } from "./CachedGeometry";
 import { Debug } from "./Diagnostics";
 import { extractFlashedVolumeClassifierCommands, extractHilitedVolumeClassifierCommands } from "./DrawCommand";
-import { FloatRgba } from "./FloatRGBA";
 import { FrameBuffer } from "./FrameBuffer";
 import { GL } from "./GL";
 import { IModelFrameLifecycle } from "./IModelFrameLifecycle";
@@ -26,7 +25,8 @@ import { SolarShadowMap } from "./SolarShadowMap";
 import { System } from "./System";
 import { TextureHandle } from "./Texture";
 import { RenderBufferMultiSample } from "./RenderBuffer";
-function collectTextureStatistics(texture, stats) {
+import { EDLMode, EyeDomeLighting } from "./EDL";
+export function collectTextureStatistics(texture, stats) {
     if (undefined !== texture)
         stats.addTextureAttachment(texture.bytesUsed);
 }
@@ -96,23 +96,14 @@ class Textures {
     init(width, height, numSamples) {
         assert(undefined === this.accumulation);
         let pixelDataType = GL.Texture.DataType.UnsignedByte;
-        switch (System.instance.capabilities.maxRenderType) {
+        switch (System.instance.maxRenderType) {
             case RenderType.TextureFloat: {
                 pixelDataType = GL.Texture.DataType.Float;
                 break;
             }
             case RenderType.TextureHalfFloat: {
-                if (System.instance.capabilities.isWebGL2) {
-                    pixelDataType = System.instance.context.HALF_FLOAT;
-                    break;
-                }
-                else {
-                    const ext = System.instance.capabilities.queryExtensionObject("OES_texture_half_float");
-                    if (undefined !== ext) {
-                        pixelDataType = ext.HALF_FLOAT_OES;
-                        break;
-                    }
-                }
+                pixelDataType = System.instance.context.HALF_FLOAT;
+                break;
             }
             /* falls through */
             case RenderType.TextureUnsignedByte: {
@@ -202,9 +193,25 @@ class FrameBuffers {
         this.depthAndOrder = FrameBuffer.create([textures.depthAndOrder], depth);
         this.hilite = FrameBuffer.create([textures.hilite], depth);
         this.hiliteUsingStencil = FrameBuffer.create([textures.hilite], depth);
-        return undefined !== this.depthAndOrder
-            && undefined !== this.hilite
-            && undefined !== this.hiliteUsingStencil;
+        if (!this.depthAndOrder || !this.hilite || !this.hiliteUsingStencil)
+            return false;
+        assert(undefined === this.opaqueAll);
+        if (!this.initPotentialMSMRTFbos(textures, depth, depthMS))
+            return false;
+        assert(undefined !== textures.accumulation && undefined !== textures.revealage);
+        const colors = [textures.accumulation, textures.revealage];
+        this.translucent = FrameBuffer.create(colors, depth);
+        this.clearTranslucent = FrameBuffer.create(colors);
+        // We borrow the SceneCompositor's accum and revealage textures for the surface pass.
+        // First we render edges, writing to our textures.
+        // Then we copy our textures to borrowed textures.
+        // Finally we render surfaces, writing to our textures and reading from borrowed textures.
+        assert(undefined !== textures.accumulation && undefined !== textures.revealage);
+        const pingPong = [textures.accumulation, textures.revealage];
+        this.pingPong = FrameBuffer.create(pingPong);
+        return undefined !== this.translucent
+            && undefined !== this.clearTranslucent
+            && undefined !== this.pingPong;
     }
     initPotentialMSFbos(textures, depth, depthMS) {
         const boundColor = System.instance.frameBufferStack.currentColorBuffer;
@@ -221,19 +228,69 @@ class FrameBuffers {
         return undefined !== this.opaqueColor
             && undefined !== this.opaqueAndCompositeColor;
     }
-    enableOcclusion(textures, _depth, _depthMs) {
+    initPotentialMSMRTFbos(textures, depth, depthMs) {
+        const boundColor = System.instance.frameBufferStack.currentColorBuffer;
+        assert(undefined !== boundColor && undefined !== textures.color && undefined !== textures.featureId && undefined !== textures.depthAndOrder && undefined !== textures.accumulation && undefined !== textures.revealage);
+        const colorAndPick = [boundColor, textures.featureId, textures.depthAndOrder];
+        if (undefined === depthMs) {
+            this.opaqueAll = FrameBuffer.create(colorAndPick, depth);
+            colorAndPick[0] = textures.color;
+            this.opaqueAndCompositeAll = FrameBuffer.create(colorAndPick, depth);
+        }
+        else {
+            assert(undefined !== textures.colorMsBuff && undefined !== textures.featureIdMsBuff && undefined !== textures.featureIdMsBuffHidden && undefined !== textures.depthAndOrderMsBuff && undefined !== textures.depthAndOrderMsBuffHidden);
+            const colorAndPickMsBuffs = [textures.colorMsBuff, textures.featureIdMsBuff, textures.depthAndOrderMsBuff];
+            const colorAndPickFilters = [GL.MultiSampling.Filter.Linear, GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
+            this.opaqueAll = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
+            colorAndPick[0] = textures.color;
+            this.opaqueAndCompositeAll = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
+        }
+        return undefined !== this.opaqueAll
+            && undefined !== this.opaqueAndCompositeAll;
+    }
+    enableOcclusion(textures, depth, depthMs) {
         assert(undefined !== textures.occlusion && undefined !== textures.occlusionBlur);
         this.occlusion = FrameBuffer.create([textures.occlusion]);
         this.occlusionBlur = FrameBuffer.create([textures.occlusionBlur]);
-        return undefined !== this.occlusion && undefined !== this.occlusionBlur;
+        let rVal = undefined !== this.occlusion && undefined !== this.occlusionBlur;
+        if (undefined === depthMs) {
+            // If not using multisampling then we can use the accumulation and revealage textures for the hidden pick buffers,
+            assert(undefined !== textures.color && undefined !== textures.accumulation && undefined !== textures.revealage);
+            const colorAndPick = [textures.color, textures.accumulation, textures.revealage];
+            this.opaqueAndCompositeAllHidden = FrameBuffer.create(colorAndPick, depth);
+            rVal = rVal && undefined !== this.opaqueAndCompositeAllHidden;
+        }
+        else {
+            // If multisampling then we cannot use the revealage texture for depthAndOrder for the hidden edges since it is of the wrong type for blitting,
+            // so instead use a special depthAndOrderHidden texture just for this purpose.
+            // The featureId texture is not needed for hidden edges, so the accumulation texture can be used for it if we don't blit from the multisample bufffer into it.
+            assert(undefined !== textures.color && undefined !== textures.accumulation && undefined !== textures.depthAndOrderHidden);
+            assert(undefined !== textures.colorMsBuff && undefined !== textures.featureIdMsBuffHidden && undefined !== textures.depthAndOrderMsBuffHidden);
+            const colorAndPick = [textures.color, textures.accumulation, textures.depthAndOrderHidden];
+            const colorAndPickMsBuffs = [textures.colorMsBuff, textures.featureIdMsBuffHidden, textures.depthAndOrderMsBuffHidden];
+            const colorAndPickFilters = [GL.MultiSampling.Filter.Linear, GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
+            this.opaqueAndCompositeAllHidden = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
+            // We will also need a frame buffer for copying the real pick data buffers into these hidden edge pick data buffers.
+            const pingPong = [textures.accumulation, textures.depthAndOrderHidden];
+            const pingPongMSBuffs = [textures.featureIdMsBuffHidden, textures.depthAndOrderMsBuffHidden];
+            const pingPongFilters = [GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
+            this.pingPongMS = FrameBuffer.create(pingPong, depth, pingPongMSBuffs, pingPongFilters, depthMs);
+            rVal = rVal && undefined !== this.opaqueAndCompositeAllHidden && (undefined === depthMs || undefined !== this.pingPongMS);
+        }
+        return rVal;
     }
     disableOcclusion() {
         if (undefined !== this.occlusion) {
             this.occlusion = dispose(this.occlusion);
             this.occlusionBlur = dispose(this.occlusionBlur);
         }
+        this.opaqueAndCompositeAllHidden = dispose(this.opaqueAndCompositeAllHidden);
+        this.pingPongMS = dispose(this.pingPongMS);
     }
     enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS) {
+        const boundColor = System.instance.frameBufferStack.currentColorBuffer;
+        if (undefined === boundColor)
+            return;
         if (undefined === this.stencilSet) {
             if (undefined !== depthMS) { // if multisampling use the multisampled depth everywhere
                 this.stencilSet = FrameBuffer.create([], depth, [], [], depthMS);
@@ -248,6 +305,16 @@ class FrameBuffers {
                 this.volClassCreateBlendAltZ = FrameBuffer.create([textures.volClassBlend], volClassDepth);
             }
         }
+        if (undefined !== this.opaqueAll && undefined !== this.opaqueAndCompositeAll) {
+            if (undefined !== volClassDepth) {
+                let ids = [this.opaqueAll.getColor(0), this.opaqueAll.getColor(1)];
+                this.idsAndZ = FrameBuffer.create(ids, depth);
+                this.idsAndAltZ = FrameBuffer.create(ids, volClassDepth);
+                ids = [this.opaqueAndCompositeAll.getColor(0), this.opaqueAndCompositeAll.getColor(1)];
+                this.idsAndZComposite = FrameBuffer.create(ids, depth);
+                this.idsAndAltZComposite = FrameBuffer.create(ids, volClassDepth);
+            }
+        }
     }
     disableVolumeClassifier() {
         if (undefined !== this.stencilSet) {
@@ -256,29 +323,40 @@ class FrameBuffers {
             this.volClassCreateBlend = dispose(this.volClassCreateBlend);
             this.volClassCreateBlendAltZ = dispose(this.volClassCreateBlendAltZ);
         }
+        if (undefined !== this.idsAndZ) {
+            this.idsAndZ = dispose(this.idsAndZ);
+            this.idsAndAltZ = dispose(this.idsAndAltZ);
+            this.idsAndZComposite = dispose(this.idsAndZComposite);
+            this.idsAndAltZComposite = dispose(this.idsAndAltZComposite);
+        }
     }
     enableMultiSampling(textures, depth, depthMS) {
         this.opaqueColor = dispose(this.opaqueColor);
         this.opaqueAndCompositeColor = dispose(this.opaqueAndCompositeColor);
-        return this.initPotentialMSFbos(textures, depth, depthMS);
+        let rVal = this.initPotentialMSFbos(textures, depth, depthMS);
+        this.opaqueAll = dispose(this.opaqueAll);
+        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAll);
+        rVal = this.initPotentialMSMRTFbos(textures, depth, depthMS);
+        return rVal;
     }
     disableMultiSampling(textures, depth) {
+        this.opaqueAll = dispose(this.opaqueAll);
+        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAll);
+        if (!this.initPotentialMSMRTFbos(textures, depth, undefined))
+            return false;
         this.opaqueColor = dispose(this.opaqueColor);
         this.opaqueAndCompositeColor = dispose(this.opaqueAndCompositeColor);
         return this.initPotentialMSFbos(textures, depth, undefined);
     }
     get isDisposed() {
-        return undefined === this.opaqueColor
-            && undefined === this.opaqueAndCompositeColor
-            && undefined === this.depthAndOrder
-            && undefined === this.hilite
-            && undefined === this.hiliteUsingStencil
-            && undefined === this.occlusion
-            && undefined === this.occlusionBlur
-            && undefined === this.stencilSet
-            && undefined === this.altZOnly
-            && undefined === this.volClassCreateBlend
-            && undefined === this.volClassCreateBlendAltZ;
+        return undefined === this.opaqueColor && undefined === this.opaqueAndCompositeColor && undefined === this.depthAndOrder
+            && undefined === this.hilite && undefined === this.hiliteUsingStencil && undefined === this.occlusion
+            && undefined === this.occlusionBlur && undefined === this.stencilSet && undefined === this.altZOnly
+            && undefined === this.volClassCreateBlend && undefined === this.volClassCreateBlendAltZ && undefined === this.opaqueAll
+            && undefined === this.opaqueAndCompositeAll && undefined === this.opaqueAndCompositeAllHidden && undefined === this.pingPong
+            && undefined === this.pingPongMS && undefined === this.translucent && undefined === this.clearTranslucent
+            && undefined === this.idsAndZ && undefined === this.idsAndAltZ && undefined === this.idsAndZComposite
+            && undefined === this.idsAndAltZComposite && undefined === this.edlDrawCol;
     }
     dispose() {
         this.opaqueColor = dispose(this.opaqueColor);
@@ -292,9 +370,21 @@ class FrameBuffers {
         this.altZOnly = dispose(this.altZOnly);
         this.volClassCreateBlend = dispose(this.volClassCreateBlend);
         this.volClassCreateBlendAltZ = dispose(this.volClassCreateBlendAltZ);
+        this.opaqueAll = dispose(this.opaqueAll);
+        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAll);
+        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAllHidden);
+        this.pingPong = dispose(this.pingPong);
+        this.pingPongMS = dispose(this.pingPongMS);
+        this.translucent = dispose(this.translucent);
+        this.clearTranslucent = dispose(this.clearTranslucent);
+        this.idsAndZ = dispose(this.idsAndZ);
+        this.idsAndAltZ = dispose(this.idsAndAltZ);
+        this.idsAndZComposite = dispose(this.idsAndZComposite);
+        this.idsAndAltZComposite = dispose(this.idsAndAltZComposite);
+        this.edlDrawCol = dispose(this.edlDrawCol);
     }
 }
-function collectGeometryStatistics(geom, stats) {
+export function collectGeometryStatistics(geom, stats) {
     if (undefined !== geom)
         geom.collectStatistics(stats);
 }
@@ -304,17 +394,25 @@ class Geometry {
         collectGeometryStatistics(this.composite, stats);
         collectGeometryStatistics(this.volClassColorStencil, stats);
         collectGeometryStatistics(this.volClassCopyZ, stats);
-        collectGeometryStatistics(this.volClassCopyZWithPoints, stats);
         collectGeometryStatistics(this.volClassSetBlend, stats);
         collectGeometryStatistics(this.volClassBlend, stats);
         collectGeometryStatistics(this.occlusion, stats);
         collectGeometryStatistics(this.occlusionXBlur, stats);
         collectGeometryStatistics(this.occlusionYBlur, stats);
+        collectGeometryStatistics(this.copyPickBuffers, stats);
+        collectGeometryStatistics(this.clearTranslucent, stats);
+        collectGeometryStatistics(this.clearPickAndColor, stats);
     }
     init(textures) {
         assert(undefined === this.composite);
         this.composite = CompositeGeometry.createGeometry(textures.color.getHandle(), textures.accumulation.getHandle(), textures.revealage.getHandle(), textures.hilite.getHandle());
-        return undefined !== this.composite;
+        if (undefined === this.composite)
+            return false;
+        assert(undefined === this.copyPickBuffers);
+        this.copyPickBuffers = CopyPickBufferGeometry.createGeometry(textures.featureId.getHandle(), textures.depthAndOrder.getHandle());
+        this.clearTranslucent = ViewportQuadGeometry.create(16 /* OITClearTranslucent */);
+        this.clearPickAndColor = ViewportQuadGeometry.create(21 /* ClearPickAndColor */);
+        return undefined !== this.copyPickBuffers && undefined !== this.clearTranslucent && undefined !== this.clearPickAndColor;
     }
     enableOcclusion(textures, depth) {
         var _a;
@@ -331,16 +429,13 @@ class Geometry {
         this.occlusionXBlur = dispose(this.occlusionXBlur);
         this.occlusionYBlur = dispose(this.occlusionYBlur);
     }
-    enableVolumeClassifier(textures, depth, width, height) {
+    enableVolumeClassifier(textures, depth) {
         assert(undefined === this.volClassColorStencil && undefined === this.volClassCopyZ && undefined === this.volClassSetBlend && undefined === this.volClassBlend);
         this.volClassColorStencil = ViewportQuadGeometry.create(20 /* VolClassColorUsingStencil */);
         this.volClassCopyZ = SingleTexturedViewportQuadGeometry.createGeometry(depth.getHandle(), 31 /* VolClassCopyZ */);
         this.volClassSetBlend = VolumeClassifierGeometry.createVCGeometry(depth.getHandle());
         this.volClassBlend = SingleTexturedViewportQuadGeometry.createGeometry(textures.volClassBlend.getHandle(), 33 /* VolClassBlend */);
-        if (!System.instance.capabilities.supportsFragDepth)
-            this.volClassCopyZWithPoints = ScreenPointsGeometry.createGeometry(width, height, depth.getHandle());
-        return undefined !== this.volClassColorStencil && undefined !== this.volClassCopyZ && undefined !== this.volClassSetBlend && undefined !== this.volClassBlend
-            && (System.instance.capabilities.supportsFragDepth || undefined !== this.volClassCopyZWithPoints);
+        return undefined !== this.volClassColorStencil && undefined !== this.volClassCopyZ && undefined !== this.volClassSetBlend && undefined !== this.volClassBlend;
     }
     disableVolumeClassifier() {
         if (undefined !== this.volClassColorStencil) {
@@ -348,20 +443,13 @@ class Geometry {
             this.volClassCopyZ = dispose(this.volClassCopyZ);
             this.volClassSetBlend = dispose(this.volClassSetBlend);
             this.volClassBlend = dispose(this.volClassBlend);
-            if (!System.instance.capabilities.supportsFragDepth)
-                this.volClassCopyZWithPoints = dispose(this.volClassCopyZWithPoints);
         }
     }
     get isDisposed() {
-        return undefined === this.composite
-            && undefined === this.occlusion
-            && undefined === this.occlusionXBlur
-            && undefined === this.occlusionYBlur
-            && undefined === this.volClassColorStencil
-            && undefined === this.volClassCopyZ
-            && undefined === this.volClassSetBlend
-            && undefined === this.volClassBlend
-            && undefined === this.volClassCopyZWithPoints;
+        return undefined === this.composite && undefined === this.occlusion && undefined === this.occlusionXBlur
+            && undefined === this.occlusionYBlur && undefined === this.volClassColorStencil && undefined === this.volClassCopyZ
+            && undefined === this.volClassSetBlend && undefined === this.volClassBlend && undefined === this.copyPickBuffers
+            && undefined === this.clearTranslucent && undefined === this.clearPickAndColor;
     }
     dispose() {
         this.composite = dispose(this.composite);
@@ -369,6 +457,9 @@ class Geometry {
         this.occlusionXBlur = dispose(this.occlusionXBlur);
         this.occlusionYBlur = dispose(this.occlusionYBlur);
         this.disableVolumeClassifier();
+        this.copyPickBuffers = dispose(this.copyPickBuffers);
+        this.clearTranslucent = dispose(this.clearTranslucent);
+        this.clearPickAndColor = dispose(this.clearPickAndColor);
     }
 }
 // Represents a view of data read from a region of the frame buffer.
@@ -516,11 +607,12 @@ export class SceneCompositor {
     constructor(target) {
         this.target = target;
         this.solarShadowMap = new SolarShadowMap(target);
+        this.eyeDomeLighting = new EyeDomeLighting(target);
         this._needHiddenEdges = false;
     }
     get needHiddenEdges() { return this._needHiddenEdges; }
     static create(target) {
-        return System.instance.capabilities.supportsDrawBuffers ? new MRTCompositor(target) : new MPCompositor(target);
+        return new Compositor(target);
     }
 }
 // This describes what types of primitives a compositor should draw. See the `drawPrimitive` method of Compositor.
@@ -532,7 +624,7 @@ var PrimitiveDrawState;
 })(PrimitiveDrawState || (PrimitiveDrawState = {}));
 // The actual base class. Specializations are provided based on whether or not multiple render targets are supported.
 class Compositor extends SceneCompositor {
-    constructor(target, fbos, geometry) {
+    constructor(target) {
         super(target);
         this._width = -1;
         this._height = -1;
@@ -545,14 +637,16 @@ class Compositor extends SceneCompositor {
         this._hiliteRenderState = new RenderState();
         this._noDepthMaskRenderState = new RenderState();
         this._backgroundMapRenderState = new RenderState();
+        this._pointCloudRenderState = new RenderState();
         this._debugStencil = 0; // 0 to draw stencil volumes normally, 1 to draw as opaque, 2 to draw blended
         this._haveVolumeClassifier = false;
         this._antialiasSamples = 1;
         this._viewProjectionMatrix = new Matrix4();
         this._primitiveDrawState = PrimitiveDrawState.Both; // used by drawPrimitive to decide whether a primitive needs to be drawn.
-        this._frameBuffers = fbos;
-        this._geom = geometry;
+        this._fbos = new FrameBuffers();
+        this._geom = new Geometry();
         this._opaqueRenderState.flags.depthTest = true;
+        this._pointCloudRenderState.flags.depthTest = true;
         this._translucentRenderState.flags.depthMask = false;
         this._translucentRenderState.flags.blend = this._translucentRenderState.flags.depthTest = true;
         this._translucentRenderState.blend.setBlendFuncSeparate(GL.BlendFactor.One, GL.BlendFactor.Zero, GL.BlendFactor.One, GL.BlendFactor.OneMinusSrcAlpha);
@@ -570,123 +664,400 @@ class Compositor extends SceneCompositor {
         this._layerRenderState.depthFunc = GL.DepthFunc.Always;
         this._layerRenderState.blend.setBlendFunc(GL.BlendFactor.One, GL.BlendFactor.OneMinusSrcAlpha);
     }
+    get featureIds() { return this.getSamplerTexture(this._readPickDataFromPingPong ? 0 : 1); }
+    get depthAndOrder() { return this.getSamplerTexture(this._readPickDataFromPingPong ? 1 : 2); }
+    get _samplerFbo() { return this._readPickDataFromPingPong ? this._fbos.pingPong : this._fbos.opaqueAll; }
+    getSamplerTexture(index) { return this._samplerFbo.getColor(index); }
     drawPrimitive(primitive, exec, outputsToPick) {
         if ((outputsToPick && this._primitiveDrawState !== PrimitiveDrawState.NonPickable) ||
             (!outputsToPick && this._primitiveDrawState !== PrimitiveDrawState.Pickable))
             primitive.draw(exec);
     }
-    get antialiasSamples() { return this._antialiasSamples; }
-    get useMsBuffers() { return this._antialiasSamples > 1 && !this.target.isReadPixelsInProgress; }
-    enableVolumeClassifierFbos(textures, depth, volClassDepth, depthMS, volClassDepthMS) {
-        this._frameBuffers.enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS);
-    }
-    disableVolumeClassifierFbos() { this._frameBuffers.disableVolumeClassifier(); }
-    /** This function generates a texture that contains ambient occlusion information to be applied later. */
-    renderAmbientOcclusion() {
+    clearOpaque(needComposite) {
+        const fbo = needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll;
         const system = System.instance;
-        // Render unblurred ambient occlusion based on depth buffer
-        let fbo = this._frameBuffers.occlusion;
-        this.target.beginPerfMetricRecord("Compute AO");
-        system.frameBufferStack.execute(fbo, true, false, () => {
-            System.instance.applyRenderState(RenderState.defaults);
-            const params = getDrawParams(this.target, this._geom.occlusion);
-            this.target.techniques.draw(params);
-        });
-        this.target.endPerfMetricRecord();
-        // Render the X-blurred ambient occlusion based on unblurred ambient occlusion
-        fbo = this._frameBuffers.occlusionBlur;
-        this.target.beginPerfMetricRecord("Blur AO X");
-        system.frameBufferStack.execute(fbo, true, false, () => {
-            System.instance.applyRenderState(RenderState.defaults);
-            const params = getDrawParams(this.target, this._geom.occlusionXBlur);
-            this.target.techniques.draw(params);
-        });
-        this.target.endPerfMetricRecord();
-        // Render the Y-blurred ambient occlusion based on X-blurred ambient occlusion (render into original occlusion framebuffer)
-        fbo = this._frameBuffers.occlusion;
-        this.target.beginPerfMetricRecord("Blur AO Y");
-        system.frameBufferStack.execute(fbo, true, false, () => {
-            System.instance.applyRenderState(RenderState.defaults);
-            const params = getDrawParams(this.target, this._geom.occlusionYBlur);
+        system.frameBufferStack.execute(fbo, true, this.useMsBuffers, () => {
+            // Clear pick data buffers to 0's and color buffer to background color
+            // (0,0,0,0) in elementID0 and ElementID1 buffers indicates invalid element id
+            // (0,0,0,0) in DepthAndOrder buffer indicates render order 0 and encoded depth of 0 (= far plane)
+            system.applyRenderState(this._noDepthMaskRenderState);
+            const params = getDrawParams(this.target, this._geom.clearPickAndColor);
             this.target.techniques.draw(params);
+            // Clear depth buffer
+            system.applyRenderState(RenderState.defaults); // depthMask == true.
+            system.context.clearDepth(1.0);
+            system.context.clear(GL.BufferBit.Depth);
         });
-        this.target.endPerfMetricRecord();
     }
-    collectStatistics(stats) {
-        if (undefined !== this._depth)
-            stats.addTextureAttachment(this._depth.bytesUsed);
-        if (undefined !== this._depthMS)
-            stats.addTextureAttachment(this._depthMS.bytesUsed);
-        this._textures.collectStatistics(stats);
-        this._geom.collectStatistics(stats);
+    renderLayers(commands, needComposite, pass) {
+        const fbo = (needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll);
+        const useMsBuffers = 1 /* OpaqueLayers */ === pass && fbo.isMultisampled && this.useMsBuffers;
+        this._readPickDataFromPingPong = !useMsBuffers;
+        System.instance.frameBufferStack.execute(fbo, true, useMsBuffers, () => {
+            this.drawPass(commands, pass, true);
+        });
+        this._readPickDataFromPingPong = false;
     }
-    preDraw() {
-        const rect = this.target.viewRect;
-        const width = rect.width;
-        const height = rect.height;
-        const includeOcclusion = this.target.wantAmbientOcclusion;
-        const wantVolumeClassifier = (undefined !== this.target.activeVolumeClassifierProps);
-        let wantAntialiasSamples = this.target.antialiasSamples <= 1 || !System.instance.capabilities.supportsDrawBuffers ? 1 : this.target.antialiasSamples;
-        if (wantAntialiasSamples > System.instance.capabilities.maxAntialiasSamples)
-            wantAntialiasSamples = System.instance.capabilities.maxAntialiasSamples;
-        const changeAntialiasSamples = (this._antialiasSamples > 1 && wantAntialiasSamples > 1 && this._antialiasSamples !== wantAntialiasSamples);
-        // If not yet initialized, or dimensions changed, or antialiasing changed the number of samples, initialize.
-        if (undefined === this._textures.accumulation || width !== this._width || height !== this._height || changeAntialiasSamples) {
-            this._width = width;
-            this._height = height;
-            this._antialiasSamples = wantAntialiasSamples;
-            // init() first calls dispose(), which releases all of our fbos, textures, etc, and resets the _includeOcclusion flag.
-            if (!this.init()) {
-                assert(false, "Failed to initialize scene compositor");
-                return false;
-            }
+    renderOpaque(commands, compositeFlags, renderForReadPixels) {
+        if (0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */) && !renderForReadPixels) {
+            this.renderOpaqueAO(commands);
+            return;
         }
-        else if (this._antialiasSamples !== wantAntialiasSamples) {
-            // Turn on or off multisampling.  Rather than just re-initializing, we can save the
-            // non multisampled textures & FBOs and just try to add or delete the multisampled ones.
-            this._antialiasSamples = wantAntialiasSamples;
-            if (wantVolumeClassifier && this._haveVolumeClassifier) {
-                // Multisampling and volume classification buffers are somewhat co-dependent so if volume classification is on
-                // and is staying on, just disable volume classifiers and let them get re-enabled later.
-                this.disableVolumeClassifierFbos();
-                this._geom.disableVolumeClassifier();
-                this._textures.disableVolumeClassifier();
-                if (undefined !== this._vcAltDepthStencil) {
-                    this._vcAltDepthStencil.dispose();
-                    this._vcAltDepthStencil = undefined;
-                }
-                this._haveVolumeClassifier = false;
-            }
-            if (includeOcclusion && this._includeOcclusion) {
-                // Multisampling and AO buffers are also somewhat co-dependent, so if AO is on
-                // and is staying on, just disable AO and let it get re-enabled later.
-                this._geom.disableOcclusion();
-                this._frameBuffers.disableOcclusion();
-                this._textures.disableOcclusion();
-                this._includeOcclusion = false;
-            }
-            if (this._antialiasSamples > 1) {
-                if (!this.enableMultiSampling()) {
-                    assert(false, "Failed to initialize multisampling buffers");
-                    return false;
-                }
-            }
-            else {
-                if (!this.disableMultiSampling()) {
-                    assert(false, "Failed to initialize multisampling buffers");
-                    return false;
-                }
+        const needComposite = 0 /* None */ !== compositeFlags;
+        const fbStack = System.instance.frameBufferStack;
+        // Output the first 2 passes to color and pick data buffers. (All 3 in the case of rendering for readPixels() or ambient occlusion).
+        let fbo = (needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll);
+        const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
+        this._readPickDataFromPingPong = !useMsBuffers; // if multisampling then can read pick textures directly.
+        fbStack.execute(fbo, true, useMsBuffers, () => {
+            this.drawPass(commands, 2 /* OpaqueLinear */);
+            this.drawPass(commands, 3 /* OpaquePlanar */, true);
+            if (renderForReadPixels) {
+                this.drawPass(commands, 4 /* PointClouds */, true); // don't need EDL for this
+                this.drawPass(commands, 5 /* OpaqueGeneral */, true);
+                if (useMsBuffers)
+                    fbo.blitMsBuffersToTextures(true);
             }
-        }
-        // Allocate or free ambient occlusion-related resources if necessary
-        if (includeOcclusion !== this._includeOcclusion) {
+        });
+        this._readPickDataFromPingPong = false;
+        // The general pass (and following) will not bother to write to pick buffers and so can read from the actual pick buffers.
+        if (!renderForReadPixels) {
+            fbo = (needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor);
+            fbStack.execute(fbo, true, useMsBuffers, () => {
+                this.drawPass(commands, 5 /* OpaqueGeneral */, false);
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
+            });
+            // assume we are done with MS at this point, so update the non-MS buffers
+            if (useMsBuffers)
+                fbo.blitMsBuffersToTextures(needComposite);
+        }
+    }
+    renderOpaqueAO(commands) {
+        const fbStack = System.instance.frameBufferStack;
+        const haveHiddenEdges = 0 !== commands.getCommands(9 /* HiddenEdge */).length;
+        // Output the linear, planar, and pickable surfaces to color and pick data buffers.
+        let fbo = this._fbos.opaqueAndCompositeAll;
+        const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
+        this._readPickDataFromPingPong = !useMsBuffers; // if multisampling then can read pick textures directly.
+        fbStack.execute(fbo, true, useMsBuffers, () => {
+            this.drawPass(commands, 2 /* OpaqueLinear */);
+            this.drawPass(commands, 3 /* OpaquePlanar */, true);
+            this._primitiveDrawState = PrimitiveDrawState.Pickable;
+            this.drawPass(commands, 5 /* OpaqueGeneral */, true);
+            this._primitiveDrawState = PrimitiveDrawState.Both;
+            if (useMsBuffers)
+                fbo.blitMsBuffersToTextures(true);
+        });
+        this._readPickDataFromPingPong = false;
+        // Output the non-pickable surfaces and hidden edges to just the color buffer.
+        fbo = this._fbos.opaqueAndCompositeColor;
+        fbStack.execute(fbo, true, useMsBuffers, () => {
+            this._primitiveDrawState = PrimitiveDrawState.NonPickable;
+            this.drawPass(commands, 5 /* OpaqueGeneral */, false);
+            if (haveHiddenEdges)
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
+            this._primitiveDrawState = PrimitiveDrawState.Both;
+        });
+        if (useMsBuffers)
+            fbo.blitMsBuffersToTextures(true);
+        // If there are no hidden edges, then we're done & can run the AO passes using the normal depthAndOrder texture.
+        if (haveHiddenEdges) {
+            // AO needs the pick data (orderAndDepth) for the hidden edges.  We don't want it in with the other pick data though since they are not pickable, so we will use other textures.
+            // If not multisampling we will re-use the ping-pong/transparency textures since we are done with ping-ponging at this point and transparency happens later.
+            // If multisampling then we will use the accumulation texture for featureIDs and a special texture for depthAndOrder since the revealage texture is not the right type for multisampling.
+            // First we will need to copy what's in the pick buffers so far into the hidden pick buffers.
+            System.instance.applyRenderState(this._noDepthMaskRenderState);
+            fbo = (useMsBuffers ? this._fbos.pingPongMS : this._fbos.pingPong);
+            fbStack.execute(fbo, true, useMsBuffers, () => {
+                const params = getDrawParams(this.target, this._geom.copyPickBuffers);
+                this.target.techniques.draw(params);
+            });
+            if (useMsBuffers)
+                fbo.blitMsBuffersToTextures(false, 1); // only want to blit the depth/order target
+            // Now draw the hidden edges, using an fbo which places their depth/order into the hidden pick buffers.
+            // Since we are not writing to the actual pick buffers we let this._readPickDataFromPingPong remain false.
+            fbo = this._fbos.opaqueAndCompositeAllHidden;
+            this._primitiveDrawState = PrimitiveDrawState.Pickable;
+            fbStack.execute(fbo, true, useMsBuffers, () => {
+                this.drawPass(commands, 9 /* HiddenEdge */, false);
+            });
+            this._primitiveDrawState = PrimitiveDrawState.Both;
+            if (useMsBuffers) {
+                // Only want to blit the color and depth/order targets as the featureId target is not blit-able and will generate a GL error.
+                fbo.blitMsBuffersToTextures(false, 0);
+                fbo.blitMsBuffersToTextures(false, 2);
+            }
+            this._needHiddenEdges = false;
+        }
+        this._needHiddenEdges = haveHiddenEdges; // this will cause the alternate renderAndOrder texture with the hidden edges to be read for the 2nd AO blur pass.
+        this.renderAmbientOcclusion();
+        this._needHiddenEdges = false;
+    }
+    renderPointClouds(commands, compositeFlags) {
+        var _a, _b;
+        const is3d = 2 /* Perspective */ === this.target.uniforms.frustum.type;
+        // separate individual point clouds and get their point cloud settings
+        const pointClouds = [];
+        let pcs;
+        const cmds = commands.getCommands(4 /* PointClouds */);
+        let curPC;
+        let pushDepth = 0;
+        for (const cmd of cmds) {
+            if ("pushBranch" === cmd.opcode) { // should be first command
+                ++pushDepth;
+                if (pushDepth === 1) {
+                    pcs = (_a = cmd.branch.branch.realityModelDisplaySettings) === null || _a === void 0 ? void 0 : _a.pointCloud;
+                    this.target.uniforms.realityModel.pointCloud.updateRange(cmd.branch.branch.realityModelRange, this.target, cmd.branch.localToWorldTransform, is3d);
+                    pointClouds.push(curPC = { pcs, cmds: [cmd] });
+                }
+                else {
+                    assert(undefined !== curPC);
+                    curPC.cmds.push(cmd);
+                }
+            }
+            else {
+                if ("popBranch" === cmd.opcode)
+                    --pushDepth;
+                assert(undefined !== curPC);
+                curPC.cmds.push(cmd);
+            }
+        }
+        const needComposite = 0 /* None */ !== compositeFlags;
+        const fbo = (needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor);
+        const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
+        const system = System.instance;
+        const fbStack = system.frameBufferStack;
+        this._readPickDataFromPingPong = false;
+        for (const pc of pointClouds) {
+            pcs = pc.pcs;
+            let edlOn = (pcs === null || pcs === void 0 ? void 0 : pcs.edlMode) !== "off" && is3d;
+            if (edlOn) {
+                if (undefined === this._textures.hilite)
+                    edlOn = false;
+                else {
+                    // create fbo on fly if not present, or has changed (from MS)
+                    // ###TODO consider not drawing point clouds to MS buffers, at least if EDL, it isn't worth the overhead.
+                    //         would have to blit depth before draw, use depth for draw, then run shader to copy depth back to MSAA
+                    //         at end, wherever color buf changed (test alpha, else discard)
+                    //         this would also simplify this code considerably
+                    let drawColBufs;
+                    if (undefined !== this._fbos.edlDrawCol)
+                        drawColBufs = this._fbos.edlDrawCol.getColorTargets(useMsBuffers, 0);
+                    if (undefined === this._fbos.edlDrawCol || this._textures.hilite !== (drawColBufs === null || drawColBufs === void 0 ? void 0 : drawColBufs.tex) || this._textures.hiliteMsBuff !== drawColBufs.msBuf) {
+                        this._fbos.edlDrawCol = dispose(this._fbos.edlDrawCol);
+                        const filters = [GL.MultiSampling.Filter.Linear];
+                        if (useMsBuffers)
+                            this._fbos.edlDrawCol = FrameBuffer.create([this._textures.hilite], this._depth, useMsBuffers && this._textures.hiliteMsBuff ? [this._textures.hiliteMsBuff] : undefined, filters, this._depthMS);
+                        else
+                            this._fbos.edlDrawCol = FrameBuffer.create([this._textures.hilite], this._depth);
+                    }
+                    if (undefined === this._fbos.edlDrawCol)
+                        edlOn = false;
+                    else { // can draw EDL
+                        // first draw pointcloud to borrowed hilite texture(MS) and regular depth(MS) buffers
+                        fbStack.execute(this._fbos.edlDrawCol, true, useMsBuffers, () => {
+                            system.context.clearColor(0, 0, 0, 0);
+                            system.context.clear(GL.BufferBit.Color);
+                            system.applyRenderState(this.getRenderState(4 /* PointClouds */));
+                            this.target.techniques.execute(this.target, pc.cmds, 4 /* PointClouds */);
+                        });
+                        if (useMsBuffers)
+                            this._fbos.edlDrawCol.blitMsBuffersToTextures(true, 0); // need to read the non-MS depth and hilite buffers
+                        // next process buffers to generate EDL (depth buffer is passed during init)
+                        this.target.beginPerfMetricRecord("Calc EDL"); // ### todo keep? (probably)
+                        const sts = this.eyeDomeLighting.draw({
+                            edlMode: ((_b = pc.pcs) === null || _b === void 0 ? void 0 : _b.edlMode) === "full" ? EDLMode.Full : EDLMode.On,
+                            edlFilter: !!(pcs === null || pcs === void 0 ? void 0 : pcs.edlFilter),
+                            useMsBuffers,
+                            inputTex: this._textures.hilite,
+                            curFbo: fbo,
+                        });
+                        this.target.endPerfMetricRecord();
+                        if (!sts) {
+                            edlOn = false;
+                        }
+                    }
+                }
+            }
+            if (!edlOn) {
+                // draw the regular way
+                fbStack.execute(fbo, true, useMsBuffers, () => {
+                    system.applyRenderState(this.getRenderState(4 /* PointClouds */));
+                    this.target.techniques.execute(this.target, pc.cmds, 4 /* PointClouds */);
+                });
+            }
+        }
+    }
+    renderForVolumeClassification(commands, compositeFlags, renderForReadPixels) {
+        const needComposite = 0 /* None */ !== compositeFlags;
+        const needAO = 0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */);
+        const fbStack = System.instance.frameBufferStack;
+        if (renderForReadPixels || needAO) {
+            this._readPickDataFromPingPong = true;
+            fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll, true, this.useMsBuffers, () => {
+                this.drawPass(commands, 5 /* OpaqueGeneral */, true, 20 /* VolumeClassifiedRealityData */);
+            });
+        }
+        else {
+            this._readPickDataFromPingPong = false;
+            fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor, true, this.useMsBuffers, () => {
+                this.drawPass(commands, 5 /* OpaqueGeneral */, false, 20 /* VolumeClassifiedRealityData */);
+            });
+        }
+    }
+    renderIndexedClassifierForReadPixels(cmds, state, renderForIntersectingVolumes, needComposite) {
+        this._readPickDataFromPingPong = true;
+        const fbo = (renderForIntersectingVolumes ? (needComposite ? this._fbos.idsAndZComposite : this._fbos.idsAndZ)
+            : (needComposite ? this._fbos.idsAndAltZComposite : this._fbos.idsAndAltZ));
+        System.instance.frameBufferStack.execute(fbo, true, false, () => {
+            System.instance.applyRenderState(state);
+            this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
+        });
+        this._readPickDataFromPingPong = false;
+    }
+    clearTranslucent() {
+        System.instance.applyRenderState(this._noDepthMaskRenderState);
+        System.instance.frameBufferStack.execute(this._fbos.clearTranslucent, true, false, () => {
+            const params = getDrawParams(this.target, this._geom.clearTranslucent);
+            this.target.techniques.draw(params);
+        });
+    }
+    renderTranslucent(commands) {
+        System.instance.frameBufferStack.execute(this._fbos.translucent, true, false, () => {
+            this.drawPass(commands, 8 /* Translucent */);
+        });
+    }
+    getBackgroundFbo(needComposite) {
+        return needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor;
+    }
+    pingPong() {
+        if (this._fbos.opaqueAll.isMultisampled && this.useMsBuffers) {
+            // If we are multisampling we can just blit the FeatureId and DepthAndOrder MS buffers to their textures.
+            this._fbos.opaqueAll.blitMsBuffersToTextures(false, 1);
+            this._fbos.opaqueAll.blitMsBuffersToTextures(false, 2);
+        }
+        else {
+            System.instance.applyRenderState(this._noDepthMaskRenderState);
+            System.instance.frameBufferStack.execute(this._fbos.pingPong, true, this.useMsBuffers, () => {
+                const params = getDrawParams(this.target, this._geom.copyPickBuffers);
+                this.target.techniques.draw(params);
+            });
+        }
+    }
+    get antialiasSamples() { return this._antialiasSamples; }
+    get useMsBuffers() { return this._antialiasSamples > 1 && !this.target.isReadPixelsInProgress; }
+    enableVolumeClassifierFbos(textures, depth, volClassDepth, depthMS, volClassDepthMS) {
+        this._fbos.enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS);
+    }
+    disableVolumeClassifierFbos() {
+        this._fbos.disableVolumeClassifier();
+    }
+    /** This function generates a texture that contains ambient occlusion information to be applied later. */
+    renderAmbientOcclusion() {
+        const system = System.instance;
+        // Render unblurred ambient occlusion based on depth buffer
+        let fbo = this._fbos.occlusion;
+        this.target.beginPerfMetricRecord("Compute AO");
+        system.frameBufferStack.execute(fbo, true, false, () => {
+            System.instance.applyRenderState(RenderState.defaults);
+            const params = getDrawParams(this.target, this._geom.occlusion);
+            this.target.techniques.draw(params);
+        });
+        this.target.endPerfMetricRecord();
+        // Render the X-blurred ambient occlusion based on unblurred ambient occlusion
+        fbo = this._fbos.occlusionBlur;
+        this.target.beginPerfMetricRecord("Blur AO X");
+        system.frameBufferStack.execute(fbo, true, false, () => {
+            System.instance.applyRenderState(RenderState.defaults);
+            const params = getDrawParams(this.target, this._geom.occlusionXBlur);
+            this.target.techniques.draw(params);
+        });
+        this.target.endPerfMetricRecord();
+        // Render the Y-blurred ambient occlusion based on X-blurred ambient occlusion (render into original occlusion framebuffer)
+        fbo = this._fbos.occlusion;
+        this.target.beginPerfMetricRecord("Blur AO Y");
+        system.frameBufferStack.execute(fbo, true, false, () => {
+            System.instance.applyRenderState(RenderState.defaults);
+            const params = getDrawParams(this.target, this._geom.occlusionYBlur);
+            this.target.techniques.draw(params);
+        });
+        this.target.endPerfMetricRecord();
+    }
+    collectStatistics(stats) {
+        if (undefined !== this._depth)
+            stats.addTextureAttachment(this._depth.bytesUsed);
+        if (undefined !== this._depthMS)
+            stats.addTextureAttachment(this._depthMS.bytesUsed);
+        this._textures.collectStatistics(stats);
+        this._geom.collectStatistics(stats);
+    }
+    preDraw() {
+        const rect = this.target.viewRect;
+        const width = rect.width;
+        const height = rect.height;
+        const includeOcclusion = this.target.wantAmbientOcclusion;
+        const wantVolumeClassifier = (undefined !== this.target.activeVolumeClassifierProps);
+        let wantAntialiasSamples = this.target.antialiasSamples <= 1 ? 1 : this.target.antialiasSamples;
+        if (wantAntialiasSamples > System.instance.maxAntialiasSamples)
+            wantAntialiasSamples = System.instance.maxAntialiasSamples;
+        const changeAntialiasSamples = (this._antialiasSamples > 1 && wantAntialiasSamples > 1 && this._antialiasSamples !== wantAntialiasSamples);
+        // If not yet initialized, or dimensions changed, or antialiasing changed the number of samples, initialize.
+        if (undefined === this._textures.accumulation || width !== this._width || height !== this._height || changeAntialiasSamples) {
+            this._width = width;
+            this._height = height;
+            this._antialiasSamples = wantAntialiasSamples;
+            // init() first calls dispose(), which releases all of our fbos, textures, etc, and resets the _includeOcclusion flag.
+            if (!this.init()) {
+                assert(false, "Failed to initialize scene compositor");
+                return false;
+            }
+        }
+        else if (this._antialiasSamples !== wantAntialiasSamples) {
+            // Turn on or off multisampling.  Rather than just re-initializing, we can save the
+            // non multisampled textures & FBOs and just try to add or delete the multisampled ones.
+            this._antialiasSamples = wantAntialiasSamples;
+            if (wantVolumeClassifier && this._haveVolumeClassifier) {
+                // Multisampling and volume classification buffers are somewhat co-dependent so if volume classification is on
+                // and is staying on, just disable volume classifiers and let them get re-enabled later.
+                this.disableVolumeClassifierFbos();
+                this._geom.disableVolumeClassifier();
+                this._textures.disableVolumeClassifier();
+                if (undefined !== this._vcAltDepthStencil) {
+                    this._vcAltDepthStencil.dispose();
+                    this._vcAltDepthStencil = undefined;
+                }
+                this._haveVolumeClassifier = false;
+            }
+            if (includeOcclusion && this._includeOcclusion) {
+                // Multisampling and AO buffers are also somewhat co-dependent, so if AO is on
+                // and is staying on, just disable AO and let it get re-enabled later.
+                this._geom.disableOcclusion();
+                this._fbos.disableOcclusion();
+                this._textures.disableOcclusion();
+                this._includeOcclusion = false;
+            }
+            if (this._antialiasSamples > 1) {
+                if (!this.enableMultiSampling()) {
+                    assert(false, "Failed to initialize multisampling buffers");
+                    return false;
+                }
+            }
+            else {
+                if (!this.disableMultiSampling()) {
+                    assert(false, "Failed to initialize multisampling buffers");
+                    return false;
+                }
+            }
+        }
+        // Allocate or free ambient occlusion-related resources if necessary
+        if (includeOcclusion !== this._includeOcclusion) {
             this._includeOcclusion = includeOcclusion;
             if (includeOcclusion) {
                 if (!this._textures.enableOcclusion(width, height, this._antialiasSamples)) {
                     assert(false, "Failed to initialize occlusion textures");
                     return false;
                 }
-                if (!this._frameBuffers.enableOcclusion(this._textures, this._depth, this._depthMS)) {
+                if (!this._fbos.enableOcclusion(this._textures, this._depth, this._depthMS)) {
                     assert(false, "Failed to initialize occlusion frame buffers");
                     return false;
                 }
@@ -694,28 +1065,22 @@ class Compositor extends SceneCompositor {
             }
             else {
                 this._geom.disableOcclusion();
-                this._frameBuffers.disableOcclusion();
+                this._fbos.disableOcclusion();
                 this._textures.disableOcclusion();
             }
         }
-        // Allocate or free volume classifier-related resources if necessary.  Make sure that we have depth/stencil.
+        // Allocate or free volume classifier-related resources if necessary.
         if (wantVolumeClassifier !== this._haveVolumeClassifier) {
-            if (wantVolumeClassifier && DepthType.TextureUnsignedInt24Stencil8 === System.instance.capabilities.maxDepthType) {
+            if (wantVolumeClassifier) {
                 this._vcAltDepthStencil = System.instance.createDepthBuffer(width, height);
                 if (undefined !== this._depthMS)
                     this._vcAltDepthStencilMS = System.instance.createDepthBuffer(width, height, this._antialiasSamples);
-                if (undefined === this._vcAltDepthStencil || (undefined !== this._depthMS && undefined === this._vcAltDepthStencilMS)) {
-                    assert(false, "Failed to initialize volume classifier depth buffer");
+                if (undefined === this._vcAltDepthStencil || (undefined !== this._depthMS && undefined === this._vcAltDepthStencilMS))
                     return false;
-                }
-                if (!this._textures.enableVolumeClassifier(width, height, this._antialiasSamples)) {
-                    assert(false, "Failed to initialize volume classifier textures");
+                if (!this._textures.enableVolumeClassifier(width, height, this._antialiasSamples))
                     return false;
-                }
-                if (!this._geom.enableVolumeClassifier(this._textures, this._depth, width, height)) {
-                    assert(false, "Failed to initialize volume classifier geometry");
+                if (!this._geom.enableVolumeClassifier(this._textures, this._depth))
                     return false;
-                }
                 this.enableVolumeClassifierFbos(this._textures, this._depth, this._vcAltDepthStencil, this._depthMS, this._vcAltDepthStencilMS);
                 this._haveVolumeClassifier = true;
             }
@@ -733,10 +1098,8 @@ class Compositor extends SceneCompositor {
         return true;
     }
     draw(commands) {
-        if (!this.preDraw()) {
-            assert(false);
+        if (!this.preDraw())
             return;
-        }
         const compositeFlags = commands.compositeFlags;
         const needComposite = 0 /* None */ !== compositeFlags;
         // Clear output targets
@@ -784,6 +1147,10 @@ class Compositor extends SceneCompositor {
             frameBufferStack: System.instance.frameBufferStack,
         });
         this.target.frameStatsCollector.endTime("onRenderOpaqueTime");
+        // Render point cloud geometry with possible EDL
+        this.target.beginPerfMetricRecord("Render PointClouds");
+        this.renderPointClouds(commands, compositeFlags);
+        this.target.endPerfMetricRecord();
         // Render opaque geometry
         this.target.beginPerfMetricRecord("Render Opaque");
         this.renderOpaque(commands, compositeFlags, false);
@@ -792,7 +1159,7 @@ class Compositor extends SceneCompositor {
         this.target.frameStatsCollector.beginTime("translucentTime");
         // Render translucent layers
         this.target.beginPerfMetricRecord("Render Translucent Layers");
-        this.renderLayers(commands, needComposite, 6 /* TranslucentLayers */);
+        this.renderLayers(commands, needComposite, 7 /* TranslucentLayers */);
         this.target.endPerfMetricRecord();
         if (needComposite) {
             this._geom.composite.update(compositeFlags);
@@ -813,13 +1180,13 @@ class Compositor extends SceneCompositor {
         // Render overlay Layers
         this.target.frameStatsCollector.beginTime("overlaysTime");
         this.target.beginPerfMetricRecord("Render Overlay Layers");
-        this.renderLayers(commands, false, 10 /* OverlayLayers */);
+        this.renderLayers(commands, false, 11 /* OverlayLayers */);
         this.target.endPerfMetricRecord();
         this.target.frameStatsCollector.endTime("overlaysTime");
         this.target.popViewClip();
     }
     get fullHeight() { return this.target.viewRect.height; }
-    drawForReadPixels(commands, sceneOverlays, overlayDecorations) {
+    drawForReadPixels(commands, sceneOverlays, worldOverlayDecorations, viewOverlayDecorations) {
         this.target.beginPerfMetricRecord("Render Background", true);
         if (!this.preDraw()) {
             this.target.endPerfMetricRecord(true); // End Render Background record if returning
@@ -842,28 +1209,29 @@ class Compositor extends SceneCompositor {
             // Ensure it draws before any opaque geometry (including layers), without depth.
             this.target.beginPerfMetricRecord("Render background map", true);
             this.target.drawingBackgroundForReadPixels = true;
-            this.renderLayers(commands, false, 14 /* BackgroundMap */);
+            this.renderLayers(commands, false, 15 /* BackgroundMap */);
             this.target.drawingBackgroundForReadPixels = false;
             this.target.endPerfMetricRecord(true);
             this.target.beginPerfMetricRecord("Render Opaque Layers", true);
             this.renderLayers(commands, false, 1 /* OpaqueLayers */);
             this.target.endPerfMetricRecord(true);
+            // PointClouds are rendered in Opaque pass for readPixels
             this.target.beginPerfMetricRecord("Render Opaque", true);
             this.renderOpaque(commands, 0 /* None */, true);
             this.target.endPerfMetricRecord(true);
             this.target.beginPerfMetricRecord("Render Translucent Layers", true);
-            this.renderLayers(commands, false, 6 /* TranslucentLayers */);
+            this.renderLayers(commands, false, 7 /* TranslucentLayers */);
             this.target.endPerfMetricRecord(true);
             this.target.beginPerfMetricRecord("Render Overlay Layers", true);
-            this.renderLayers(commands, false, 10 /* OverlayLayers */);
+            this.renderLayers(commands, false, 11 /* OverlayLayers */);
             this.target.endPerfMetricRecord(true);
             this.target.popViewClip();
         }
-        if (0 === sceneOverlays.length && (undefined === overlayDecorations || 0 === overlayDecorations.length))
+        if (!sceneOverlays.length && !(worldOverlayDecorations === null || worldOverlayDecorations === void 0 ? void 0 : worldOverlayDecorations.length) && !(viewOverlayDecorations === null || viewOverlayDecorations === void 0 ? void 0 : viewOverlayDecorations.length))
             return;
         // Now populate the opaque passes with any pickable world overlays
         this.target.beginPerfMetricRecord("Overlay Draws", true);
-        commands.initForPickOverlays(sceneOverlays, overlayDecorations);
+        commands.initForPickOverlays(sceneOverlays, worldOverlayDecorations, viewOverlayDecorations);
         if (commands.isEmpty) {
             this.target.endPerfMetricRecord(true); // End Overlay Draws record if returning
             return;
@@ -872,7 +1240,7 @@ class Compositor extends SceneCompositor {
         // (If *only* overlays exist, then clearOpaque() above already took care of this).
         if (haveRenderCommands) {
             const system = System.instance;
-            system.frameBufferStack.execute(this._frameBuffers.opaqueColor, true, this.useMsBuffers, () => {
+            system.frameBufferStack.execute(this._fbos.opaqueColor, true, this.useMsBuffers, () => {
                 system.applyRenderState(RenderState.defaults);
                 system.context.clearDepth(1.0);
                 system.context.clear(GL.BufferBit.Depth);
@@ -890,7 +1258,7 @@ class Compositor extends SceneCompositor {
     readPixels(rect, selector) {
         return PixelBuffer.create(rect, selector, this);
     }
-    readDepthAndOrder(rect) { return this.readFrameBuffer(rect, this._frameBuffers.depthAndOrder); }
+    readDepthAndOrder(rect) { return this.readFrameBuffer(rect, this._fbos.depthAndOrder); }
     readFeatureIds(rect) {
         const tex = this._textures.featureId;
         if (undefined === tex)
@@ -904,8 +1272,8 @@ class Compositor extends SceneCompositor {
         this.solarShadowMap.update(context);
     }
     get screenSpaceEffectFbo() {
-        assert(undefined !== this._frameBuffers.hilite);
-        return this._frameBuffers.hilite;
+        assert(undefined !== this._fbos.hilite);
+        return this._fbos.hilite;
     }
     readFrameBuffer(rect, fbo) {
         if (undefined === fbo || !Debug.isValidFrameBuffer)
@@ -930,14 +1298,16 @@ class Compositor extends SceneCompositor {
             && undefined === this._vcAltDepthStencil
             && !this._includeOcclusion
             && this._textures.isDisposed
-            && this._frameBuffers.isDisposed
+            && this._fbos.isDisposed
             && this._geom.isDisposed
             && !this._haveVolumeClassifier
-            && this.solarShadowMap.isDisposed;
+            && this.solarShadowMap.isDisposed
+            && this.eyeDomeLighting.isDisposed;
     }
     dispose() {
         this.reset();
         dispose(this.solarShadowMap);
+        dispose(this.eyeDomeLighting);
     }
     // Resets anything that depends on the dimensions of the render target.
     // Does *not* dispose the solar shadow map.
@@ -947,9 +1317,10 @@ class Compositor extends SceneCompositor {
         this._vcAltDepthStencil = dispose(this._vcAltDepthStencil);
         this._includeOcclusion = false;
         dispose(this._textures);
-        dispose(this._frameBuffers);
+        dispose(this._fbos);
         dispose(this._geom);
         this._haveVolumeClassifier = false;
+        this.eyeDomeLighting.reset();
     }
     init() {
         this.reset();
@@ -960,8 +1331,9 @@ class Compositor extends SceneCompositor {
             this._depthMS = undefined;
         if (this._depth !== undefined) {
             return this._textures.init(this._width, this._height, this._antialiasSamples)
-                && this._frameBuffers.init(this._textures, this._depth, this._depthMS)
-                && this._geom.init(this._textures);
+                && this._fbos.init(this._textures, this._depth, this._depthMS)
+                && this._geom.init(this._textures)
+                && this.eyeDomeLighting.init(this._width, this._height, this._depth);
         }
         return false;
     }
@@ -971,36 +1343,42 @@ class Compositor extends SceneCompositor {
         this._depthMS = System.instance.createDepthBuffer(this._width, this._height, this._antialiasSamples);
         if (undefined === this._depthMS)
             return false;
-        return this._textures.enableMultiSampling(this._width, this._height, this._antialiasSamples);
+        if (!this._textures.enableMultiSampling(this._width, this._height, this._antialiasSamples))
+            return false;
+        assert(undefined !== this._depth && undefined !== this._depthMS);
+        return this._fbos.enableMultiSampling(this._textures, this._depth, this._depthMS);
     }
     disableMultiSampling() {
+        assert(undefined !== this._depth);
+        if (!this._fbos.disableMultiSampling(this._textures, this._depth))
+            return false;
         // Want to disable multisampling without deleting & reallocating other stuff.
         this._depthMS = dispose(this._depthMS);
         assert(undefined !== this._depth);
         return this._textures.disableMultiSampling();
     }
     renderBackgroundMap(commands, needComposite) {
-        const cmds = commands.getCommands(14 /* BackgroundMap */);
+        const cmds = commands.getCommands(15 /* BackgroundMap */);
         if (0 === cmds.length) {
             return;
         }
         const fbStack = System.instance.frameBufferStack;
         const fbo = this.getBackgroundFbo(needComposite);
         fbStack.execute(fbo, true, this.useMsBuffers, () => {
-            System.instance.applyRenderState(this.getRenderState(14 /* BackgroundMap */));
-            this.target.techniques.execute(this.target, cmds, 14 /* BackgroundMap */);
+            System.instance.applyRenderState(this.getRenderState(15 /* BackgroundMap */));
+            this.target.techniques.execute(this.target, cmds, 15 /* BackgroundMap */);
         });
     }
     renderSkyBox(commands, needComposite) {
-        const cmds = commands.getCommands(13 /* SkyBox */);
+        const cmds = commands.getCommands(14 /* SkyBox */);
         if (0 === cmds.length) {
             return;
         }
         const fbStack = System.instance.frameBufferStack;
         const fbo = this.getBackgroundFbo(needComposite);
         fbStack.execute(fbo, true, this.useMsBuffers, () => {
-            System.instance.applyRenderState(this.getRenderState(13 /* SkyBox */));
-            this.target.techniques.execute(this.target, cmds, 13 /* SkyBox */);
+            System.instance.applyRenderState(this.getRenderState(14 /* SkyBox */));
+            this.target.techniques.execute(this.target, cmds, 14 /* SkyBox */);
         });
     }
     renderBackground(commands, needComposite) {
@@ -1119,10 +1497,10 @@ class Compositor extends SceneCompositor {
     }
     renderIndexedVolumeClassifier(cmdsByIndex, needComposite) {
         // Set the stencil for the given classifier stencil volume.
-        System.instance.frameBufferStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
+        System.instance.frameBufferStack.execute(this._fbos.stencilSet, false, this.useMsBuffers, () => {
             this.target.pushState(this._vcBranchState);
             System.instance.applyRenderState(this._vcSetStencilRenderState);
-            this.target.techniques.executeForIndexedClassifier(this.target, cmdsByIndex, 5 /* Classification */);
+            this.target.techniques.executeForIndexedClassifier(this.target, cmdsByIndex, 6 /* Classification */);
             this.target.popBranch();
         });
         // Process the stencil for the pick data.
@@ -1130,8 +1508,8 @@ class Compositor extends SceneCompositor {
     }
     renderVolumeClassification(commands, compositeFlags, renderForReadPixels) {
         // Sometimes we need to render the classifier stencil volumes one at a time, if so draw them from the cmdsByIndex list
-        const cmds = commands.getCommands(5 /* Classification */);
-        const cmdsByIndex = commands.getCommands(16 /* ClassificationByIndex */);
+        const cmds = commands.getCommands(6 /* Classification */);
+        const cmdsByIndex = commands.getCommands(17 /* ClassificationByIndex */);
         let numCmdsPerClassifier = 0;
         for (const cmd of cmdsByIndex) { // Figure out how many commands there are per index/primitive
             numCmdsPerClassifier++;
@@ -1140,7 +1518,7 @@ class Compositor extends SceneCompositor {
                 break;
             }
         }
-        const cmdsForVC = commands.getCommands(19 /* VolumeClassifiedRealityData */);
+        const cmdsForVC = commands.getCommands(20 /* VolumeClassifiedRealityData */);
         if (!this.target.activeVolumeClassifierProps || (renderForReadPixels && 0 === cmds.length) || 0 === cmdsForVC.length)
             return;
         let outsideFlags = this.target.activeVolumeClassifierProps.flags.outside;
@@ -1160,28 +1538,28 @@ class Compositor extends SceneCompositor {
         if (this._debugStencil > 0) {
             fbStack.execute(fboColorAndZ, true, this.useMsBuffers, () => {
                 if (1 === this._debugStencil) {
-                    System.instance.applyRenderState(this.getRenderState(4 /* OpaqueGeneral */));
-                    this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
+                    System.instance.applyRenderState(this.getRenderState(5 /* OpaqueGeneral */));
+                    this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
                 }
                 else {
                     this.target.pushState(this._vcBranchState);
                     System.instance.applyRenderState(this._vcDebugRenderState);
-                    this.target.techniques.execute(this.target, cmds, 5 /* Classification */);
+                    this.target.techniques.execute(this.target, cmds, 6 /* Classification */);
                     this.target.popBranch();
                 }
             });
             return;
         }
-        if (undefined === this._frameBuffers.altZOnly || undefined === this._frameBuffers.stencilSet)
+        if (undefined === this._fbos.altZOnly || undefined === this._fbos.stencilSet)
             return;
         if (renderForReadPixels && this.target.vcSupportIntersectingVolumes) {
             // Clear the stencil.
-            fbStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
+            fbStack.execute(this._fbos.stencilSet, false, this.useMsBuffers, () => {
                 System.instance.context.clearStencil(0);
                 System.instance.context.clear(GL.BufferBit.Stencil);
             });
             if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
-                this._frameBuffers.stencilSet.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
+                this._fbos.stencilSet.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
             for (let i = 0; i < cmdsByIndex.length; i += numCmdsPerClassifier)
                 this.renderIndexedVolumeClassifier(cmdsByIndex.slice(i, i + numCmdsPerClassifier), needComposite);
             return;
@@ -1191,10 +1569,10 @@ class Compositor extends SceneCompositor {
         const doColorByElement = SpatialClassifierInsideDisplay.ElementColor === insideFlags || renderForReadPixels;
         const doColorByElementForIntersectingVolumes = this.target.vcSupportIntersectingVolumes;
         const needAltZ = (doColorByElement && !doColorByElementForIntersectingVolumes) || needOutsideDraw;
-        let zOnlyFbo = this._frameBuffers.stencilSet;
-        let volClassBlendFbo = this._frameBuffers.volClassCreateBlend;
+        let zOnlyFbo = this._fbos.stencilSet;
+        let volClassBlendFbo = this._fbos.volClassCreateBlend;
         let volClassBlendReadZTexture = this._vcAltDepthStencil.getHandle();
-        let volClassBlendReadZTextureFbo = this._frameBuffers.altZOnly;
+        let volClassBlendReadZTextureFbo = this._fbos.altZOnly;
         if (!needAltZ) {
             // Initialize the blend texture and the stencil.
             assert(undefined !== volClassBlendFbo);
@@ -1207,31 +1585,28 @@ class Compositor extends SceneCompositor {
         else {
             // If we are doing color-by-element for the inside do not care about intersecting volumes or we need to color the outside
             // then we need to copy the Z buffer and set up a different zbuffer/stencil to render in.
-            zOnlyFbo = this._frameBuffers.altZOnly;
-            volClassBlendFbo = this._frameBuffers.volClassCreateBlendAltZ;
+            zOnlyFbo = this._fbos.altZOnly;
+            volClassBlendFbo = this._fbos.volClassCreateBlendAltZ;
             assert(undefined !== volClassBlendFbo);
             volClassBlendReadZTexture = this._depth.getHandle();
-            volClassBlendReadZTextureFbo = this._frameBuffers.stencilSet;
+            volClassBlendReadZTextureFbo = this._fbos.stencilSet;
             if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
                 volClassBlendReadZTextureFbo.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
             // Copy the current Z into the Alt-Z.  At the same time go ahead and clear the stencil and the blend texture.
             fbStack.execute(volClassBlendFbo, true, this.useMsBuffers, () => {
                 this.target.pushState(this.target.decorationsState);
                 System.instance.applyRenderState(this._vcCopyZRenderState);
-                if (System.instance.capabilities.supportsFragDepth)
-                    this.target.techniques.draw(getDrawParams(this.target, this._geom.volClassCopyZ)); // This method uses the EXT_frag_depth extension
-                else
-                    this.target.techniques.draw(getDrawParams(this.target, this._geom.volClassCopyZWithPoints)); // This method draws GL_POINTS (1 per pixel) to set Z in vertex shader
+                this.target.techniques.draw(getDrawParams(this.target, this._geom.volClassCopyZ)); // This method uses the EXT_frag_depth extension
                 System.instance.bindTexture2d(TextureUnit.Zero, undefined);
                 this.target.popBranch();
             });
         }
         if (renderForReadPixels) {
             // Set the stencil for all of the classifier volumes.
-            System.instance.frameBufferStack.execute(this._frameBuffers.altZOnly, false, this.useMsBuffers, () => {
+            System.instance.frameBufferStack.execute(this._fbos.altZOnly, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 System.instance.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.execute(this.target, cmds, 5 /* Classification */);
+                this.target.techniques.execute(this.target, cmds, 6 /* Classification */);
                 // After we create the stencil we need to clear the Z for the next step (so also must turn on z writing temporarily).
                 this._vcSetStencilRenderState.flags.depthMask = true;
                 System.instance.applyRenderState(this._vcSetStencilRenderState);
@@ -1250,7 +1625,7 @@ class Compositor extends SceneCompositor {
             this.setAllStencilOps(this._vcColorRenderState, GL.StencilOperation.Keep); // don't clear the stencil so that all classifiers behind reality mesh will still draw
             this.target.activeVolumeClassifierTexture = this._geom.volClassCopyZ.texture;
             if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
-                this._frameBuffers.stencilSet.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
+                this._fbos.stencilSet.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
             this.renderIndexedClassifierForReadPixels(cmds, this._vcColorRenderState, false, needComposite);
             this.target.activeVolumeClassifierTexture = undefined;
             this._vcColorRenderState.flags.depthTest = false;
@@ -1270,7 +1645,7 @@ class Compositor extends SceneCompositor {
             fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 System.instance.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.execute(this.target, cmds, 5 /* Classification */);
+                this.target.techniques.execute(this.target, cmds, 6 /* Classification */);
                 this.target.popBranch();
                 System.instance.bindTexture2d(TextureUnit.Two, undefined);
                 System.instance.bindTexture2d(TextureUnit.Five, undefined);
@@ -1326,7 +1701,7 @@ class Compositor extends SceneCompositor {
                     fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
                         this.target.pushState(this._vcBranchState);
                         System.instance.applyRenderState(this._vcSetStencilRenderState);
-                        this.target.techniques.execute(this.target, nxtCmds, 5 /* Classification */);
+                        this.target.techniques.execute(this.target, nxtCmds, 6 /* Classification */);
                         this.target.popBranch();
                     });
                     // Process the stencil. Just render the volume normally (us opaque pass), but use blending to modify the source alpha that gets written to the blend texture.
@@ -1337,7 +1712,7 @@ class Compositor extends SceneCompositor {
                         this._vcColorRenderState.flags.cull = true;
                         System.instance.applyRenderState(this._vcColorRenderState);
                         this.target.activeVolumeClassifierTexture = undefined; // make sure this texture is undefined so we do not use the planar classification shader
-                        this.target.techniques.execute(this.target, nxtCmds, 4 /* OpaqueGeneral */);
+                        this.target.techniques.execute(this.target, nxtCmds, 5 /* OpaqueGeneral */);
                         this._vcColorRenderState.flags.cull = false;
                         this.target.popBranch();
                     });
@@ -1345,7 +1720,7 @@ class Compositor extends SceneCompositor {
             }
             else {
                 if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
-                    this._frameBuffers.stencilSet.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
+                    this._fbos.stencilSet.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
                 fbStack.execute(volClassBlendFbo, false, this.useMsBuffers, () => {
                     // For coloring the inside by element color we will draw the inside using the the classifiers themselves.
                     // To do this we need to first clear our Alt-Z.  The shader will then test and write Z and will discard
@@ -1363,7 +1738,7 @@ class Compositor extends SceneCompositor {
                     System.instance.context.clearDepth(1.0);
                     System.instance.context.clear(GL.BufferBit.Depth);
                     this.target.activeVolumeClassifierTexture = this._geom.volClassCopyZ.texture;
-                    this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
+                    this.target.techniques.execute(this.target, cmds, 5 /* OpaqueGeneral */);
                     this.target.activeVolumeClassifierTexture = undefined;
                     this._vcColorRenderState.flags.depthTest = false;
                     this._vcColorRenderState.flags.depthMask = false;
@@ -1380,12 +1755,12 @@ class Compositor extends SceneCompositor {
         // and this stage can be skipped.  In order for this to work the list of commands needs to get reduced to only the ones which draw hilited volumes.
         // We cannot use the hillite shader to draw them since it doesn't handle logZ properly (it doesn't need to since it is only used elsewhere when Z write is turned off)
         // and we don't really want another whole set of hilite shaders just for this.
-        const cmdsSelected = extractHilitedVolumeClassifierCommands(this.target.hilites, commands.getCommands(15 /* HiliteClassification */));
-        commands.replaceCommands(15 /* HiliteClassification */, cmdsSelected); // replace the hilite command list for use in hilite pass as well.
+        const cmdsSelected = extractHilitedVolumeClassifierCommands(this.target.hilites, commands.getCommands(16 /* HiliteClassification */));
+        commands.replaceCommands(16 /* HiliteClassification */, cmdsSelected); // replace the hilite command list for use in hilite pass as well.
         // if (cmdsSelected.length > 0 && insideFlags !== this.target.activeVolumeClassifierProps!.flags.selected) {
         if (!doColorByElement && cmdsSelected.length > 0 && insideFlags !== SpatialClassifierInsideDisplay.Hilite) { // assume selected ones are always hilited
             // Set the stencil using just the hilited volume classifiers.
-            fbStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
+            fbStack.execute(this._fbos.stencilSet, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 System.instance.applyRenderState(this._vcSetStencilRenderState);
                 if (needAltZ) {
@@ -1393,12 +1768,12 @@ class Compositor extends SceneCompositor {
                     System.instance.context.clearStencil(0);
                     System.instance.context.clear(GL.BufferBit.Stencil);
                 }
-                this.target.techniques.execute(this.target, cmdsSelected, 5 /* Classification */);
+                this.target.techniques.execute(this.target, cmdsSelected, 6 /* Classification */);
                 this.target.popBranch();
             });
             if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
-                this._frameBuffers.altZOnly.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
-            fbStack.execute(this._frameBuffers.volClassCreateBlend, false, this.useMsBuffers, () => {
+                this._fbos.altZOnly.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
+            fbStack.execute(this._fbos.volClassCreateBlend, false, this.useMsBuffers, () => {
                 this._geom.volClassSetBlend.boundaryType = BoundaryType.Selected;
                 this._geom.volClassSetBlend.texture = this._vcAltDepthStencil.getHandle(); // need to attach the alt depth instead of the real one since it is bound to the frame buffer
                 this.target.pushState(this.target.decorationsState);
@@ -1429,10 +1804,10 @@ class Compositor extends SceneCompositor {
         const flashedClassifierCmds = extractFlashedVolumeClassifierCommands(this.target.flashedId, cmdsByIndex, numCmdsPerClassifier);
         if (undefined !== flashedClassifierCmds && !doColorByElement) {
             // Set the stencil for this one classifier.
-            fbStack.execute(this._frameBuffers.stencilSet, false, this.useMsBuffers, () => {
+            fbStack.execute(this._fbos.stencilSet, false, this.useMsBuffers, () => {
                 this.target.pushState(this._vcBranchState);
                 System.instance.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.executeForIndexedClassifier(this.target, flashedClassifierCmds, 4 /* OpaqueGeneral */);
+                this.target.techniques.executeForIndexedClassifier(this.target, flashedClassifierCmds, 5 /* OpaqueGeneral */);
                 this.target.popBranch();
             });
             // Process the stencil to flash the contents.
@@ -1449,35 +1824,35 @@ class Compositor extends SceneCompositor {
     }
     renderHilite(commands) {
         const system = System.instance;
-        system.frameBufferStack.execute(this._frameBuffers.hilite, true, false, () => {
+        system.frameBufferStack.execute(this._fbos.hilite, true, false, () => {
             // Clear the hilite buffer.
             system.context.clearColor(0, 0, 0, 0);
             system.context.clear(GL.BufferBit.Color);
             // Draw the normal hilite geometry.
-            this.drawPass(commands, 9 /* Hilite */);
+            this.drawPass(commands, 10 /* Hilite */);
         });
         // Process planar classifiers
-        const planarClassifierCmds = commands.getCommands(17 /* HilitePlanarClassification */);
+        const planarClassifierCmds = commands.getCommands(18 /* HilitePlanarClassification */);
         if (0 !== planarClassifierCmds.length) {
-            system.frameBufferStack.execute(this._frameBuffers.hiliteUsingStencil, true, false, () => {
+            system.frameBufferStack.execute(this._fbos.hiliteUsingStencil, true, false, () => {
                 system.applyRenderState(this._opaqueRenderState);
-                this.target.techniques.execute(this.target, planarClassifierCmds, 17 /* HilitePlanarClassification */);
+                this.target.techniques.execute(this.target, planarClassifierCmds, 18 /* HilitePlanarClassification */);
             });
         }
         // Process the volume classifiers.
-        const vcHiliteCmds = commands.getCommands(15 /* HiliteClassification */);
+        const vcHiliteCmds = commands.getCommands(16 /* HiliteClassification */);
         if (0 !== vcHiliteCmds.length && undefined !== this._vcBranchState) {
             // Set the stencil for the given classifier stencil volume.
-            system.frameBufferStack.execute(this._frameBuffers.stencilSet, false, false, () => {
+            system.frameBufferStack.execute(this._fbos.stencilSet, false, false, () => {
                 this.target.pushState(this._vcBranchState);
                 system.applyRenderState(this._vcSetStencilRenderState);
-                this.target.techniques.execute(this.target, vcHiliteCmds, 9 /* Hilite */);
+                this.target.techniques.execute(this.target, vcHiliteCmds, 10 /* Hilite */);
                 this.target.popBranch();
             });
             // Process the stencil for the hilite data.
-            system.frameBufferStack.execute(this._frameBuffers.hiliteUsingStencil, true, false, () => {
+            system.frameBufferStack.execute(this._fbos.hiliteUsingStencil, true, false, () => {
                 system.applyRenderState(this._vcPickDataRenderState);
-                this.target.techniques.execute(this.target, vcHiliteCmds, 9 /* Hilite */);
+                this.target.techniques.execute(this.target, vcHiliteCmds, 10 /* Hilite */);
             });
         }
     }
@@ -1489,27 +1864,29 @@ class Compositor extends SceneCompositor {
     getRenderState(pass) {
         switch (pass) {
             case 1 /* OpaqueLayers */:
-            case 6 /* TranslucentLayers */:
-            case 10 /* OverlayLayers */:
+            case 7 /* TranslucentLayers */:
+            case 11 /* OverlayLayers */:
                 // NB: During pick, we don't want blending - it will mess up our pick buffer data and we don't care about the color data.
                 // During normal draw, we don't use the pick buffers for anything, and we want color blending.
                 // (We get away with this because surfaces always draw before their edges, and we're not depth-testing, so edges always draw atop surfaces without pick buffer testing).
                 this._layerRenderState.flags.blend = !this.target.isReadPixelsInProgress;
                 // Transparent non-overlay Layers are drawn between opaque and translucent passes. Test depth, don't write it, so that they blend with opaque.
-                this._layerRenderState.flags.depthMask = 6 /* TranslucentLayers */ !== pass;
-                this._layerRenderState.depthFunc = (6 /* TranslucentLayers */ === pass) ? GL.DepthFunc.Default : GL.DepthFunc.Always;
+                this._layerRenderState.flags.depthMask = 7 /* TranslucentLayers */ !== pass;
+                this._layerRenderState.depthFunc = (7 /* TranslucentLayers */ === pass) ? GL.DepthFunc.Default : GL.DepthFunc.Always;
                 return this._layerRenderState;
             case 2 /* OpaqueLinear */:
             case 3 /* OpaquePlanar */:
-            case 4 /* OpaqueGeneral */:
-            case 17 /* HilitePlanarClassification */:
+            case 5 /* OpaqueGeneral */:
+            case 18 /* HilitePlanarClassification */:
                 return this._opaqueRenderState;
-            case 7 /* Translucent */:
+            case 8 /* Translucent */:
                 return this._translucentRenderState;
-            case 9 /* Hilite */:
+            case 10 /* Hilite */:
                 return this._hiliteRenderState;
-            case 14 /* BackgroundMap */:
+            case 15 /* BackgroundMap */:
                 return this._backgroundMapRenderState;
+            case 4 /* PointClouds */:
+                return this._pointCloudRenderState;
             default:
                 return this._noDepthMaskRenderState;
         }
@@ -1526,645 +1903,4 @@ class Compositor extends SceneCompositor {
         this.target.techniques.execute(this.target, cmds, pass);
     }
 }
-class MRTFrameBuffers extends FrameBuffers {
-    init(textures, depth, depthMs) {
-        if (!super.init(textures, depth, depthMs))
-            return false;
-        assert(undefined === this.opaqueAll);
-        if (!this.initPotentialMSMRTFbos(textures, depth, depthMs))
-            return false;
-        assert(undefined !== textures.accumulation && undefined !== textures.revealage);
-        const colors = [textures.accumulation, textures.revealage];
-        this.translucent = FrameBuffer.create(colors, depth);
-        this.clearTranslucent = FrameBuffer.create(colors);
-        // We borrow the SceneCompositor's accum and revealage textures for the surface pass.
-        // First we render edges, writing to our textures.
-        // Then we copy our textures to borrowed textures.
-        // Finally we render surfaces, writing to our textures and reading from borrowed textures.
-        assert(undefined !== textures.accumulation && undefined !== textures.revealage);
-        const pingPong = [textures.accumulation, textures.revealage];
-        this.pingPong = FrameBuffer.create(pingPong);
-        return undefined !== this.translucent
-            && undefined !== this.clearTranslucent
-            && undefined !== this.pingPong;
-    }
-    initPotentialMSMRTFbos(textures, depth, depthMs) {
-        const boundColor = System.instance.frameBufferStack.currentColorBuffer;
-        assert(undefined !== boundColor && undefined !== textures.color && undefined !== textures.featureId && undefined !== textures.depthAndOrder && undefined !== textures.accumulation && undefined !== textures.revealage);
-        const colorAndPick = [boundColor, textures.featureId, textures.depthAndOrder];
-        if (undefined === depthMs) {
-            this.opaqueAll = FrameBuffer.create(colorAndPick, depth);
-            colorAndPick[0] = textures.color;
-            this.opaqueAndCompositeAll = FrameBuffer.create(colorAndPick, depth);
-        }
-        else {
-            assert(undefined !== textures.colorMsBuff && undefined !== textures.featureIdMsBuff && undefined !== textures.featureIdMsBuffHidden && undefined !== textures.depthAndOrderMsBuff && undefined !== textures.depthAndOrderMsBuffHidden);
-            const colorAndPickMsBuffs = [textures.colorMsBuff, textures.featureIdMsBuff, textures.depthAndOrderMsBuff];
-            const colorAndPickFilters = [GL.MultiSampling.Filter.Linear, GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
-            this.opaqueAll = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
-            colorAndPick[0] = textures.color;
-            this.opaqueAndCompositeAll = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
-        }
-        return undefined !== this.opaqueAll
-            && undefined !== this.opaqueAndCompositeAll;
-    }
-    enableOcclusion(textures, depth, depthMs) {
-        let rVal = super.enableOcclusion(textures, depth, depthMs);
-        if (undefined === depthMs) {
-            // If not using multisampling then we can use the accumulation and revealage textures for the hidden pick buffers,
-            assert(undefined !== textures.color && undefined !== textures.accumulation && undefined !== textures.revealage);
-            const colorAndPick = [textures.color, textures.accumulation, textures.revealage];
-            this.opaqueAndCompositeAllHidden = FrameBuffer.create(colorAndPick, depth);
-            rVal = rVal && undefined !== this.opaqueAndCompositeAllHidden;
-        }
-        else {
-            // If multisampling then we cannot use the revealage texture for depthAndOrder for the hidden edges since it is of the wrong type for blitting,
-            // so instead use a special depthAndOrderHidden texture just for this purpose.
-            // The featureId texture is not needed for hidden edges, so the accumulation texture can be used for it if we don't blit from the multisample bufffer into it.
-            assert(undefined !== textures.color && undefined !== textures.accumulation && undefined !== textures.depthAndOrderHidden);
-            assert(undefined !== textures.colorMsBuff && undefined !== textures.featureIdMsBuffHidden && undefined !== textures.depthAndOrderMsBuffHidden);
-            const colorAndPick = [textures.color, textures.accumulation, textures.depthAndOrderHidden];
-            const colorAndPickMsBuffs = [textures.colorMsBuff, textures.featureIdMsBuffHidden, textures.depthAndOrderMsBuffHidden];
-            const colorAndPickFilters = [GL.MultiSampling.Filter.Linear, GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
-            this.opaqueAndCompositeAllHidden = FrameBuffer.create(colorAndPick, depth, colorAndPickMsBuffs, colorAndPickFilters, depthMs);
-            // We will also need a frame buffer for copying the real pick data buffers into these hidden edge pick data buffers.
-            const pingPong = [textures.accumulation, textures.depthAndOrderHidden];
-            const pingPongMSBuffs = [textures.featureIdMsBuffHidden, textures.depthAndOrderMsBuffHidden];
-            const pingPongFilters = [GL.MultiSampling.Filter.Nearest, GL.MultiSampling.Filter.Nearest];
-            this.pingPongMS = FrameBuffer.create(pingPong, depth, pingPongMSBuffs, pingPongFilters, depthMs);
-            rVal = rVal && undefined !== this.opaqueAndCompositeAllHidden && (undefined === depthMs || undefined !== this.pingPongMS);
-        }
-        return rVal;
-    }
-    disableOcclusion() {
-        super.disableOcclusion();
-        this.opaqueAndCompositeAllHidden = dispose(this.opaqueAndCompositeAllHidden);
-        this.pingPongMS = dispose(this.pingPongMS);
-    }
-    enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS) {
-        const boundColor = System.instance.frameBufferStack.currentColorBuffer;
-        if (undefined === boundColor)
-            return;
-        super.enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS);
-        if (undefined !== this.opaqueAll && undefined !== this.opaqueAndCompositeAll) {
-            if (undefined !== volClassDepth) {
-                let ids = [this.opaqueAll.getColor(0), this.opaqueAll.getColor(1)];
-                this.idsAndZ = FrameBuffer.create(ids, depth);
-                this.idsAndAltZ = FrameBuffer.create(ids, volClassDepth);
-                ids = [this.opaqueAndCompositeAll.getColor(0), this.opaqueAndCompositeAll.getColor(1)];
-                this.idsAndZComposite = FrameBuffer.create(ids, depth);
-                this.idsAndAltZComposite = FrameBuffer.create(ids, volClassDepth);
-            }
-        }
-    }
-    disableVolumeClassifier() {
-        super.disableVolumeClassifier();
-        if (undefined !== this.idsAndZ) {
-            this.idsAndZ = dispose(this.idsAndZ);
-            this.idsAndAltZ = dispose(this.idsAndAltZ);
-            this.idsAndZComposite = dispose(this.idsAndZComposite);
-            this.idsAndAltZComposite = dispose(this.idsAndAltZComposite);
-        }
-    }
-    enableMultiSampling(textures, depth, depthMS) {
-        super.enableMultiSampling(textures, depth, depthMS);
-        this.opaqueAll = dispose(this.opaqueAll);
-        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAll);
-        return this.initPotentialMSMRTFbos(textures, depth, depthMS);
-    }
-    disableMultiSampling(textures, depth) {
-        this.opaqueAll = dispose(this.opaqueAll);
-        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAll);
-        if (!this.initPotentialMSMRTFbos(textures, depth, undefined))
-            return false;
-        return super.disableMultiSampling(textures, depth);
-    }
-    get isDisposed() {
-        return super.isDisposed
-            && undefined === this.opaqueAll
-            && undefined === this.opaqueAndCompositeAll
-            && undefined === this.opaqueAndCompositeAllHidden
-            && undefined === this.pingPong
-            && undefined === this.pingPongMS
-            && undefined === this.translucent
-            && undefined === this.clearTranslucent
-            && undefined === this.idsAndZ
-            && undefined === this.idsAndAltZ
-            && undefined === this.idsAndZComposite
-            && undefined === this.idsAndAltZComposite;
-    }
-    dispose() {
-        super.dispose();
-        this.opaqueAll = dispose(this.opaqueAll);
-        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAll);
-        this.opaqueAndCompositeAll = dispose(this.opaqueAndCompositeAllHidden);
-        this.pingPong = dispose(this.pingPong);
-        this.pingPongMS = dispose(this.pingPongMS);
-        this.translucent = dispose(this.translucent);
-        this.clearTranslucent = dispose(this.clearTranslucent);
-        this.idsAndZ = dispose(this.idsAndZ);
-        this.idsAndAltZ = dispose(this.idsAndAltZ);
-        this.idsAndZComposite = dispose(this.idsAndZComposite);
-        this.idsAndAltZComposite = dispose(this.idsAndAltZComposite);
-    }
-}
-class MRTGeometry extends Geometry {
-    collectStatistics(stats) {
-        super.collectStatistics(stats);
-        collectGeometryStatistics(this.copyPickBuffers, stats);
-        collectGeometryStatistics(this.clearTranslucent, stats);
-        collectGeometryStatistics(this.clearPickAndColor, stats);
-    }
-    init(textures) {
-        if (!super.init(textures))
-            return false;
-        assert(undefined === this.copyPickBuffers);
-        this.copyPickBuffers = CopyPickBufferGeometry.createGeometry(textures.featureId.getHandle(), textures.depthAndOrder.getHandle());
-        this.clearTranslucent = ViewportQuadGeometry.create(16 /* OITClearTranslucent */);
-        this.clearPickAndColor = ViewportQuadGeometry.create(21 /* ClearPickAndColor */);
-        return undefined !== this.copyPickBuffers && undefined !== this.clearTranslucent && undefined !== this.clearPickAndColor;
-    }
-    get isDisposed() {
-        return super.isDisposed
-            && undefined === this.copyPickBuffers
-            && undefined === this.clearTranslucent
-            && undefined === this.clearPickAndColor;
-    }
-    dispose() {
-        super.dispose();
-        this.copyPickBuffers = dispose(this.copyPickBuffers);
-        this.clearTranslucent = dispose(this.clearTranslucent);
-        this.clearPickAndColor = dispose(this.clearPickAndColor);
-    }
-}
-// SceneCompositor used when multiple render targets are supported (WEBGL_draw_buffers exists and supports at least 4 color attachments).
-class MRTCompositor extends Compositor {
-    constructor(target) {
-        super(target, new MRTFrameBuffers(), new MRTGeometry());
-    }
-    get currentRenderTargetIndex() {
-        assert(false, "MRT is supported");
-        return 0;
-    }
-    set currentRenderTargetIndex(_index) {
-        assert(false, "MRT is supported");
-    }
-    get featureIds() { return this.getSamplerTexture(this._readPickDataFromPingPong ? 0 : 1); }
-    get depthAndOrder() { return this.getSamplerTexture(this._readPickDataFromPingPong ? 1 : 2); }
-    get _fbos() { return this._frameBuffers; }
-    get _geometry() { return this._geom; }
-    enableVolumeClassifierFbos(textures, depth, volClassDepth, depthMS, volClassDepthMS) {
-        this._fbos.enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS);
-    }
-    disableVolumeClassifierFbos() { this._fbos.disableVolumeClassifier(); }
-    enableMultiSampling() {
-        if (!super.enableMultiSampling())
-            return false;
-        assert(undefined !== this._depth && undefined !== this._depthMS);
-        return this._fbos.enableMultiSampling(this._textures, this._depth, this._depthMS);
-    }
-    disableMultiSampling() {
-        assert(undefined !== this._depth);
-        if (!this._fbos.disableMultiSampling(this._textures, this._depth))
-            return false;
-        return super.disableMultiSampling();
-    }
-    clearOpaque(needComposite) {
-        const fbo = needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll;
-        const system = System.instance;
-        system.frameBufferStack.execute(fbo, true, this.useMsBuffers, () => {
-            // Clear pick data buffers to 0's and color buffer to background color
-            // (0,0,0,0) in elementID0 and ElementID1 buffers indicates invalid element id
-            // (0,0,0,0) in DepthAndOrder buffer indicates render order 0 and encoded depth of 0 (= far plane)
-            system.applyRenderState(this._noDepthMaskRenderState);
-            const params = getDrawParams(this.target, this._geometry.clearPickAndColor);
-            this.target.techniques.draw(params);
-            // Clear depth buffer
-            system.applyRenderState(RenderState.defaults); // depthMask == true.
-            system.context.clearDepth(1.0);
-            system.context.clear(GL.BufferBit.Depth);
-        });
-    }
-    renderOpaque(commands, compositeFlags, renderForReadPixels) {
-        if (0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */) && !renderForReadPixels) {
-            this.renderOpaqueAO(commands);
-            return;
-        }
-        const needComposite = 0 /* None */ !== compositeFlags;
-        const fbStack = System.instance.frameBufferStack;
-        // Output the first 2 passes to color and pick data buffers. (All 3 in the case of rendering for readPixels() or ambient occlusion).
-        let fbo = (needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll);
-        const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
-        this._readPickDataFromPingPong = !useMsBuffers; // if multisampling then can read pick textures directly.
-        fbStack.execute(fbo, true, useMsBuffers, () => {
-            this.drawPass(commands, 2 /* OpaqueLinear */);
-            this.drawPass(commands, 3 /* OpaquePlanar */, true);
-            if (renderForReadPixels) {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, true);
-                if (useMsBuffers)
-                    fbo.blitMsBuffersToTextures(true);
-            }
-        });
-        this._readPickDataFromPingPong = false;
-        // The general pass (and following) will not bother to write to pick buffers and so can read from the actual pick buffers.
-        if (!renderForReadPixels) {
-            fbo = (needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor);
-            fbStack.execute(fbo, true, useMsBuffers, () => {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false);
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
-            });
-            if (useMsBuffers)
-                fbo.blitMsBuffersToTextures(needComposite);
-        }
-    }
-    renderOpaqueAO(commands) {
-        const fbStack = System.instance.frameBufferStack;
-        const haveHiddenEdges = 0 !== commands.getCommands(8 /* HiddenEdge */).length;
-        // Output the linear, planar, and pickable surfaces to color and pick data buffers.
-        let fbo = this._fbos.opaqueAndCompositeAll;
-        const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
-        this._readPickDataFromPingPong = !useMsBuffers; // if multisampling then can read pick textures directly.
-        fbStack.execute(fbo, true, useMsBuffers, () => {
-            this.drawPass(commands, 2 /* OpaqueLinear */);
-            this.drawPass(commands, 3 /* OpaquePlanar */, true);
-            this._primitiveDrawState = PrimitiveDrawState.Pickable;
-            this.drawPass(commands, 4 /* OpaqueGeneral */, true);
-            this._primitiveDrawState = PrimitiveDrawState.Both;
-            if (useMsBuffers)
-                fbo.blitMsBuffersToTextures(true);
-        });
-        this._readPickDataFromPingPong = false;
-        // Output the non-pickable surfaces and hidden edges to just the color buffer.
-        fbo = this._fbos.opaqueAndCompositeColor;
-        fbStack.execute(fbo, true, useMsBuffers, () => {
-            this._primitiveDrawState = PrimitiveDrawState.NonPickable;
-            this.drawPass(commands, 4 /* OpaqueGeneral */, false);
-            if (haveHiddenEdges)
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
-            this._primitiveDrawState = PrimitiveDrawState.Both;
-        });
-        if (useMsBuffers)
-            fbo.blitMsBuffersToTextures(true);
-        // If there are no hidden edges, then we're done & can run the AO passes using the normal depthAndOrder texture.
-        if (haveHiddenEdges) {
-            // AO needs the pick data (orderAndDepth) for the hidden edges.  We don't want it in with the other pick data though since they are not pickable, so we will use other textures.
-            // If not multisampling we will re-use the ping-pong/transparency textures since we are done with ping-ponging at this point and transparency happens later.
-            // If multisampling then we will use the accumulation texture for featureIDs and a special texture for depthAndOrder since the revealage texture is not the right type for multisampling.
-            // First we will need to copy what's in the pick buffers so far into the hidden pick buffers.
-            System.instance.applyRenderState(this._noDepthMaskRenderState);
-            fbo = (useMsBuffers ? this._fbos.pingPongMS : this._fbos.pingPong);
-            fbStack.execute(fbo, true, useMsBuffers, () => {
-                const params = getDrawParams(this.target, this._geometry.copyPickBuffers);
-                this.target.techniques.draw(params);
-            });
-            if (useMsBuffers)
-                fbo.blitMsBuffersToTextures(false, 1); // only want to blit the depth/order target
-            // Now draw the hidden edges, using an fbo which places their depth/order into the hidden pick buffers.
-            // Since we are not writing to the actual pick buffers we let this._readPickDataFromPingPong remain false.
-            fbo = this._fbos.opaqueAndCompositeAllHidden;
-            this._primitiveDrawState = PrimitiveDrawState.Pickable;
-            fbStack.execute(fbo, true, useMsBuffers, () => {
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
-            });
-            this._primitiveDrawState = PrimitiveDrawState.Both;
-            if (useMsBuffers) {
-                // Only want to blit the color and depth/order targets as the featureId target is not blit-able and will generate a GL error.
-                fbo.blitMsBuffersToTextures(false, 0);
-                fbo.blitMsBuffersToTextures(false, 2);
-            }
-            this._needHiddenEdges = false;
-        }
-        this._needHiddenEdges = haveHiddenEdges; // this will cause the alternate renderAndOrder texture with the hidden edges to be read for the 2nd AO blur pass.
-        this.renderAmbientOcclusion();
-        this._needHiddenEdges = false;
-    }
-    renderLayers(commands, needComposite, pass) {
-        const fbo = (needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll);
-        const useMsBuffers = 1 /* OpaqueLayers */ === pass && fbo.isMultisampled && this.useMsBuffers;
-        this._readPickDataFromPingPong = !useMsBuffers;
-        System.instance.frameBufferStack.execute(fbo, true, useMsBuffers, () => {
-            this.drawPass(commands, pass, true);
-        });
-        this._readPickDataFromPingPong = false;
-    }
-    renderForVolumeClassification(commands, compositeFlags, renderForReadPixels) {
-        const needComposite = 0 /* None */ !== compositeFlags;
-        const needAO = 0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */);
-        const fbStack = System.instance.frameBufferStack;
-        if (renderForReadPixels || needAO) {
-            this._readPickDataFromPingPong = true;
-            fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll, true, this.useMsBuffers, () => {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, true, 19 /* VolumeClassifiedRealityData */);
-            });
-        }
-        else {
-            this._readPickDataFromPingPong = false;
-            fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor, true, this.useMsBuffers, () => {
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false, 19 /* VolumeClassifiedRealityData */);
-            });
-        }
-    }
-    renderIndexedClassifierForReadPixels(cmds, state, renderForIntersectingVolumes, needComposite) {
-        this._readPickDataFromPingPong = true;
-        const fbo = (renderForIntersectingVolumes ? (needComposite ? this._fbos.idsAndZComposite : this._fbos.idsAndZ)
-            : (needComposite ? this._fbos.idsAndAltZComposite : this._fbos.idsAndAltZ));
-        System.instance.frameBufferStack.execute(fbo, true, false, () => {
-            System.instance.applyRenderState(state);
-            this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
-        });
-        this._readPickDataFromPingPong = false;
-    }
-    clearTranslucent() {
-        System.instance.applyRenderState(this._noDepthMaskRenderState);
-        System.instance.frameBufferStack.execute(this._fbos.clearTranslucent, true, false, () => {
-            const params = getDrawParams(this.target, this._geometry.clearTranslucent);
-            this.target.techniques.draw(params);
-        });
-    }
-    renderTranslucent(commands) {
-        System.instance.frameBufferStack.execute(this._fbos.translucent, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
-        });
-    }
-    pingPong() {
-        if (this._fbos.opaqueAll.isMultisampled && this.useMsBuffers) {
-            // If we are multisampling we can just blit the FeatureId and DepthAndOrder MS buffers to their textures.
-            this._fbos.opaqueAll.blitMsBuffersToTextures(false, 1);
-            this._fbos.opaqueAll.blitMsBuffersToTextures(false, 2);
-        }
-        else {
-            System.instance.applyRenderState(this._noDepthMaskRenderState);
-            System.instance.frameBufferStack.execute(this._fbos.pingPong, true, this.useMsBuffers, () => {
-                const params = getDrawParams(this.target, this._geometry.copyPickBuffers);
-                this.target.techniques.draw(params);
-            });
-        }
-    }
-    getBackgroundFbo(needComposite) { return needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor; }
-    get _samplerFbo() { return this._readPickDataFromPingPong ? this._fbos.pingPong : this._fbos.opaqueAll; }
-    getSamplerTexture(index) { return this._samplerFbo.getColor(index); }
-}
-class MPFrameBuffers extends FrameBuffers {
-    init(textures, depth) {
-        if (!super.init(textures, depth, undefined))
-            return false;
-        assert(undefined === this.accumulation);
-        this.accumulation = FrameBuffer.create([textures.accumulation], depth);
-        this.revealage = FrameBuffer.create([textures.revealage], depth);
-        this.featureId = FrameBuffer.create([textures.featureId], depth);
-        return undefined !== this.accumulation && undefined !== this.revealage && undefined !== this.featureId;
-    }
-    enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS) {
-        super.enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS);
-        if (undefined !== this.featureId) {
-            this.featureIdWithDepth = FrameBuffer.create([this.featureId.getColor(0)], depth);
-            this.featureIdWithDepthAltZ = FrameBuffer.create([this.featureId.getColor(0)], volClassDepth);
-        }
-    }
-    disableVolumeClassifier() {
-        super.disableVolumeClassifier();
-        if (undefined !== this.featureIdWithDepth) {
-            this.featureIdWithDepth = dispose(this.featureIdWithDepth);
-            this.featureIdWithDepthAltZ = dispose(this.featureIdWithDepthAltZ);
-        }
-    }
-    get isDisposed() {
-        return super.isDisposed
-            && undefined === this.accumulation
-            && undefined === this.revealage
-            && undefined === this.featureId
-            && undefined === this.featureIdWithDepth
-            && undefined === this.featureIdWithDepthAltZ;
-    }
-    dispose() {
-        super.dispose();
-        this.accumulation = dispose(this.accumulation);
-        this.revealage = dispose(this.revealage);
-        this.featureId = dispose(this.featureId);
-        this.disableVolumeClassifier();
-    }
-}
-class MPGeometry extends Geometry {
-    collectStatistics(stats) {
-        super.collectStatistics(stats);
-        collectGeometryStatistics(this.copyColor, stats);
-    }
-    init(textures) {
-        if (!super.init(textures))
-            return false;
-        assert(undefined === this.copyColor);
-        this.copyColor = SingleTexturedViewportQuadGeometry.createGeometry(textures.featureId.getHandle(), 18 /* CopyColor */);
-        return undefined !== this.copyColor;
-    }
-    get isDisposed() { return super.isDisposed && undefined === this.copyColor; }
-    dispose() {
-        super.dispose();
-        this.copyColor = dispose(this.copyColor);
-    }
-}
-// Compositor used when multiple render targets are not supported (WEBGL_draw_buffers not available or fewer than 4 color attachments supported).
-// This falls back to multi-pass rendering in place of MRT rendering, which has obvious performance implications.
-// The chief use case is iOS.
-class MPCompositor extends Compositor {
-    constructor(target) {
-        super(target, new MPFrameBuffers(), new MPGeometry());
-        this._currentRenderTargetIndex = 0;
-        this._drawMultiPassDepth = true;
-        this._opaqueRenderStateNoZWt = new RenderState();
-        this._scratchBgColor = new FloatRgba();
-        this._opaqueRenderStateNoZWt.flags.depthTest = true;
-        this._opaqueRenderStateNoZWt.flags.depthMask = false;
-    }
-    getRenderState(pass) {
-        switch (pass) {
-            case 2 /* OpaqueLinear */:
-            case 3 /* OpaquePlanar */:
-            case 4 /* OpaqueGeneral */:
-                return this._drawMultiPassDepth ? this._opaqueRenderState : this._opaqueRenderStateNoZWt;
-        }
-        return super.getRenderState(pass);
-    }
-    get _fbos() { return this._frameBuffers; }
-    get _geometry() { return this._geom; }
-    get currentRenderTargetIndex() { return this._currentRenderTargetIndex; }
-    set currentRenderTargetIndex(index) { this._currentRenderTargetIndex = index; }
-    get featureIds() { return this._readPickDataFromPingPong ? this._textures.accumulation : this._textures.featureId; }
-    get depthAndOrder() { return this._readPickDataFromPingPong ? this._textures.revealage : this._textures.depthAndOrder; }
-    getBackgroundFbo(needComposite) { return needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor; }
-    enableVolumeClassifierFbos(textures, depth, volClassDepth, depthMS, volClassDepthMS) {
-        this._fbos.enableVolumeClassifier(textures, depth, volClassDepth, depthMS, volClassDepthMS);
-    }
-    disableVolumeClassifierFbos() { this._fbos.disableVolumeClassifier(); }
-    clearOpaque(needComposite) {
-        const bg = this._scratchBgColor;
-        this.target.uniforms.style.cloneBackgroundRgba(bg);
-        this.clearFbo(needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor, bg.red, bg.green, bg.blue, bg.alpha, true);
-        this.clearFbo(this._fbos.depthAndOrder, 0, 0, 0, 0, false);
-        this.clearFbo(this._fbos.featureId, 0, 0, 0, 0, false);
-    }
-    clearHiddenPick() {
-    }
-    renderOpaque(commands, compositeFlags, renderForReadPixels) {
-        if (0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */) && !renderForReadPixels) {
-            this.renderOpaqueAO(commands);
-            return;
-        }
-        // Output the first 2 passes to color and pick data buffers. (All 3 in the case of rendering for readPixels()).
-        this._readPickDataFromPingPong = true;
-        const needComposite = 0 /* None */ !== compositeFlags;
-        const needAO = 0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */);
-        const colorFbo = needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor;
-        this.drawOpaquePass(colorFbo, commands, 2 /* OpaqueLinear */, false);
-        this.drawOpaquePass(colorFbo, commands, 3 /* OpaquePlanar */, true);
-        if (renderForReadPixels || needAO)
-            this.drawOpaquePass(colorFbo, commands, 4 /* OpaqueGeneral */, true);
-        this._readPickDataFromPingPong = false;
-        // The general pass (and following) will not bother to write to pick buffers and so can read from the actual pick buffers.
-        if (!renderForReadPixels) {
-            System.instance.frameBufferStack.execute(colorFbo, true, false, () => {
-                this._drawMultiPassDepth = true; // for OpaqueGeneral
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false);
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
-            });
-        }
-    }
-    renderOpaqueAO(commands) {
-        const fbStack = System.instance.frameBufferStack;
-        const haveHiddenEdges = 0 !== commands.getCommands(8 /* HiddenEdge */).length;
-        // Output the linear, planar, and pickable surfaces to color and pick data buffers.
-        this._readPickDataFromPingPong = true;
-        const colorFbo = this._fbos.opaqueAndCompositeColor;
-        this.drawOpaquePass(colorFbo, commands, 2 /* OpaqueLinear */, false);
-        this.drawOpaquePass(colorFbo, commands, 3 /* OpaquePlanar */, true);
-        this._primitiveDrawState = PrimitiveDrawState.Pickable;
-        this.drawOpaquePass(colorFbo, commands, 4 /* OpaqueGeneral */, true);
-        this._primitiveDrawState = PrimitiveDrawState.Both;
-        this._readPickDataFromPingPong = false;
-        // Output the non-pickable surfaces and hidden edges to just the color buffer.
-        fbStack.execute(colorFbo, true, false, () => {
-            this._drawMultiPassDepth = true; // for OpaqueGeneral
-            this._primitiveDrawState = PrimitiveDrawState.NonPickable;
-            this.drawPass(commands, 4 /* OpaqueGeneral */, false);
-            if (haveHiddenEdges)
-                this.drawPass(commands, 8 /* HiddenEdge */, false);
-            this._primitiveDrawState = PrimitiveDrawState.Both;
-        });
-        if (haveHiddenEdges) {
-            // First copy the depthAndOrder texture to the revealage texture which we will use for the hidden edge pick data (don't need full pick with featureIds).
-            System.instance.applyRenderState(this._noDepthMaskRenderState);
-            this.copyFbo(this._textures.depthAndOrder, this._fbos.revealage);
-            // So far only the non-pickable hidden edges have been drawn for AO, so we need to draw the pickable ones to the hidden depthAndOrder (revealage).
-            this._primitiveDrawState = PrimitiveDrawState.Pickable;
-            // Since we only need to draw color and depthAndOrder instead of calling drawOpaquePass just do what we need here.
-            this._drawMultiPassDepth = true;
-            fbStack.execute(colorFbo, true, false, () => this.drawPass(commands, 8 /* HiddenEdge */, false));
-            this._drawMultiPassDepth = false;
-            this._currentRenderTargetIndex = 2;
-            fbStack.execute(this._fbos.revealage, true, false, () => this.drawPass(commands, 8 /* HiddenEdge */, false));
-            this._currentRenderTargetIndex = 0;
-            this._readPickDataFromPingPong = false;
-            this._primitiveDrawState = PrimitiveDrawState.Both;
-        }
-        this._needHiddenEdges = haveHiddenEdges; // this will cause the alternate renderAndOrder texture to be read for the 2nd AO blur pass.
-        this.renderAmbientOcclusion();
-        this._needHiddenEdges = false;
-    }
-    renderLayers(commands, needComposite, pass) {
-        this._readPickDataFromPingPong = true;
-        const colorFbo = needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor;
-        this.drawOpaquePass(colorFbo, commands, pass, true);
-        this._readPickDataFromPingPong = false;
-    }
-    renderForVolumeClassification(commands, compositeFlags, renderForReadPixels) {
-        const needComposite = 0 /* None */ !== compositeFlags;
-        const needAO = 0 /* None */ !== (compositeFlags & 4 /* AmbientOcclusion */);
-        const colorFbo = needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor;
-        if (renderForReadPixels || needAO) {
-            this._readPickDataFromPingPong = true;
-            this.drawOpaquePass(colorFbo, commands, 4 /* OpaqueGeneral */, true, 19 /* VolumeClassifiedRealityData */);
-            if (needAO)
-                this.renderAmbientOcclusion();
-        }
-        else {
-            this._readPickDataFromPingPong = false;
-            System.instance.frameBufferStack.execute(colorFbo, true, false, () => {
-                this._drawMultiPassDepth = true; // for OpaqueGeneral
-                this.drawPass(commands, 4 /* OpaqueGeneral */, false, 19 /* VolumeClassifiedRealityData */);
-            });
-        }
-    }
-    renderIndexedClassifierForReadPixels(cmds, state, renderForIntersectingVolumes, _needComposite) {
-        // Note that we only need to render to the Id textures here, no color, since the color buffer is not used in readPixels.
-        this._readPickDataFromPingPong = true;
-        this._currentRenderTargetIndex = 1;
-        const fbo = (renderForIntersectingVolumes ? this._fbos.featureIdWithDepth : this._fbos.featureIdWithDepthAltZ);
-        System.instance.frameBufferStack.execute(fbo, true, false, () => {
-            System.instance.applyRenderState(state);
-            this.target.techniques.execute(this.target, cmds, 4 /* OpaqueGeneral */);
-        });
-        this._currentRenderTargetIndex = 0;
-        this._readPickDataFromPingPong = false;
-    }
-    // ###TODO: For readPixels(), could skip rendering color...also could skip rendering depth and/or element ID depending upon selector...
-    drawOpaquePass(colorFbo, commands, pass, pingPong, cmdPass = 255 /* None */) {
-        const commandPass = 255 /* None */ === cmdPass ? pass : cmdPass;
-        const stack = System.instance.frameBufferStack;
-        this._drawMultiPassDepth = true;
-        if (!this.target.isReadPixelsInProgress) {
-            stack.execute(colorFbo, true, false, () => this.drawPass(commands, pass, pingPong, commandPass));
-            this._drawMultiPassDepth = false;
-        }
-        this._currentRenderTargetIndex++;
-        if (!this.target.isReadPixelsInProgress || Pixel.Selector.None !== (this.target.readPixelsSelector & Pixel.Selector.Feature)) {
-            stack.execute(this._fbos.featureId, true, false, () => this.drawPass(commands, pass, pingPong && this._drawMultiPassDepth, commandPass));
-            this._drawMultiPassDepth = false;
-        }
-        this._currentRenderTargetIndex++;
-        if (!this.target.isReadPixelsInProgress || Pixel.Selector.None !== (this.target.readPixelsSelector & Pixel.Selector.GeometryAndDistance)) {
-            stack.execute(this._fbos.depthAndOrder, true, false, () => this.drawPass(commands, pass, pingPong && this._drawMultiPassDepth, commandPass));
-        }
-        this._currentRenderTargetIndex = 0;
-    }
-    clearTranslucent() {
-        this.clearFbo(this._fbos.accumulation, 0, 0, 0, 1, false);
-        this.clearFbo(this._fbos.revealage, 1, 0, 0, 1, false);
-    }
-    renderTranslucent(commands) {
-        System.instance.frameBufferStack.execute(this._fbos.accumulation, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
-        });
-        this._currentRenderTargetIndex = 1;
-        System.instance.frameBufferStack.execute(this._fbos.revealage, true, false, () => {
-            this.drawPass(commands, 7 /* Translucent */);
-        });
-        this._currentRenderTargetIndex = 0;
-    }
-    pingPong() {
-        System.instance.applyRenderState(this._noDepthMaskRenderState);
-        this.copyFbo(this._textures.featureId, this._fbos.accumulation);
-        this.copyFbo(this._textures.depthAndOrder, this._fbos.revealage);
-    }
-    copyFbo(src, dst) {
-        const geom = this._geometry.copyColor;
-        geom.texture = src.getHandle();
-        System.instance.frameBufferStack.execute(dst, true, false, () => {
-            const params = getDrawParams(this.target, geom);
-            this.target.techniques.draw(params);
-        });
-    }
-    clearFbo(fbo, red, green, blue, alpha, andDepth) {
-        const system = System.instance;
-        const gl = system.context;
-        system.frameBufferStack.execute(fbo, true, false, () => {
-            system.applyRenderState(andDepth ? RenderState.defaults : this._noDepthMaskRenderState);
-            gl.clearColor(red, green, blue, alpha);
-            let bit = GL.BufferBit.Color;
-            if (andDepth) {
-                gl.clearDepth(1.0);
-                bit |= GL.BufferBit.Depth;
-            }
-            gl.clear(bit);
-        });
-    }
-}
 //# sourceMappingURL=SceneCompositor.js.map