@itwin/core-frontend 5.2.0-dev.3 → 5.2.0-dev.30

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

@@ -5,7 +5,7 @@
 /** @packageDocumentation
  * @module WebGL
  */
-import { assert, dispose } from "@itwin/core-bentley";
+import { assert, dispose, expectDefined } from "@itwin/core-bentley";
 import { Transform, Vector2d, Vector3d } from "@itwin/core-geometry";
 import { ModelFeature, RenderMode, SpatialClassifierInsideDisplay, SpatialClassifierOutsideDisplay, } from "@itwin/core-common";
 import { RenderType } from "@itwin/webgl-compatibility";
@@ -244,10 +244,10 @@ class FrameBuffers {
     init(textures, depth, depthMS) {
         if (!this.initPotentialMSFbos(textures, depth, depthMS))
             return false;
-        this.depthAndOrder = FrameBuffer.create([textures.depthAndOrder], depth);
-        this.contours = FrameBuffer.create([textures.contours], depth);
-        this.hilite = FrameBuffer.create([textures.hilite], depth);
-        this.hiliteUsingStencil = FrameBuffer.create([textures.hilite], depth);
+        this.depthAndOrder = FrameBuffer.create([expectDefined(textures.depthAndOrder)], depth);
+        this.contours = FrameBuffer.create([expectDefined(textures.contours)], depth);
+        this.hilite = FrameBuffer.create([expectDefined(textures.hilite)], depth);
+        this.hiliteUsingStencil = FrameBuffer.create([expectDefined(textures.hilite)], depth);
         if (!this.depthAndOrder || !this.contours || !this.hilite || !this.hiliteUsingStencil)
             return false;
         assert(undefined === this.opaqueAll);
@@ -358,7 +358,13 @@ class FrameBuffers {
         if (undefined === boundColor)
             return;
         if (undefined === this.stencilSet) {
+            if (undefined === textures.volClassBlend) {
+                throw new Error("Volume classifier blend texture is not defined.");
+            }
             if (undefined !== depthMS) { // if multisampling use the multisampled depth everywhere
+                if (undefined === textures.volClassBlendMsBuff) {
+                    throw new Error("Volume classifier blend multisample buffer is not defined.");
+                }
                 this.stencilSet = FrameBuffer.create([], depth, [], [], depthMS);
                 this.altZOnly = FrameBuffer.create([], volClassDepth, [], [], volClassDepthMS);
                 this.volClassCreateBlend = FrameBuffer.create([textures.volClassBlend], depth, [textures.volClassBlendMsBuff], [GL.MultiSampling.Filter.Nearest], depthMS);
@@ -483,25 +489,25 @@ class Geometry {
     }
     init(textures) {
         assert(undefined === this.composite);
-        this.composite = CompositeGeometry.createGeometry(textures.color.getHandle(), textures.accumulation.getHandle(), textures.revealage.getHandle(), textures.hilite.getHandle());
+        this.composite = CompositeGeometry.createGeometry(expectDefined(textures.color?.getHandle()), expectDefined(textures.accumulation?.getHandle()), expectDefined(textures.revealage?.getHandle()), expectDefined(textures.hilite?.getHandle()));
         if (undefined === this.composite)
             return false;
         assert(undefined === this.copyPickBuffers);
-        this.copyPickBuffers = CopyPickBufferGeometry.createGeometry(textures.featureId.getHandle(), textures.depthAndOrder.getHandle());
+        this.copyPickBuffers = CopyPickBufferGeometry.createGeometry(expectDefined(textures.featureId?.getHandle()), expectDefined(textures.depthAndOrder?.getHandle()));
         this.clearTranslucent = ViewportQuadGeometry.create(16 /* TechniqueId.OITClearTranslucent */);
         this.clearPickAndColor = ViewportQuadGeometry.create(21 /* TechniqueId.ClearPickAndColor */);
         return undefined !== this.copyPickBuffers && undefined !== this.clearTranslucent && undefined !== this.clearPickAndColor;
     }
     enableOcclusion(textures, depth) {
         assert(undefined !== textures.occlusion && undefined !== textures.occlusionBlur && undefined !== textures.depthAndOrder && undefined !== textures.occlusionBlur);
-        this.composite.occlusion = textures.occlusion.getHandle();
-        this.occlusion = AmbientOcclusionGeometry.createGeometry(textures.depthAndOrder.getHandle(), depth.getHandle());
-        this.occlusionXBlur = BlurGeometry.createGeometry(textures.occlusion.getHandle(), textures.depthAndOrder.getHandle(), undefined, new Vector2d(1.0, 0.0), BlurType.NoTest);
+        expectDefined(this.composite).occlusion = textures.occlusion.getHandle();
+        this.occlusion = AmbientOcclusionGeometry.createGeometry(expectDefined(textures.depthAndOrder.getHandle()), expectDefined(depth.getHandle()));
+        this.occlusionXBlur = BlurGeometry.createGeometry(expectDefined(textures.occlusion.getHandle()), expectDefined(textures.depthAndOrder.getHandle()), undefined, new Vector2d(1.0, 0.0), BlurType.NoTest);
         const depthAndOrderHidden = (undefined === textures.depthAndOrderHidden ? textures.revealage?.getHandle() : textures.depthAndOrderHidden.getHandle());
-        this.occlusionYBlur = BlurGeometry.createGeometry(textures.occlusionBlur.getHandle(), textures.depthAndOrder.getHandle(), depthAndOrderHidden, new Vector2d(0.0, 1.0), BlurType.TestOrder);
+        this.occlusionYBlur = BlurGeometry.createGeometry(expectDefined(textures.occlusionBlur.getHandle()), expectDefined(textures.depthAndOrder.getHandle()), depthAndOrderHidden, new Vector2d(0.0, 1.0), BlurType.TestOrder);
     }
     disableOcclusion() {
-        this.composite.occlusion = undefined;
+        expectDefined(this.composite).occlusion = undefined;
         this.occlusion = dispose(this.occlusion);
         this.occlusionXBlur = dispose(this.occlusionXBlur);
         this.occlusionYBlur = dispose(this.occlusionYBlur);
@@ -509,9 +515,9 @@ class Geometry {
     enableVolumeClassifier(textures, depth) {
         assert(undefined === this.volClassColorStencil && undefined === this.volClassCopyZ && undefined === this.volClassSetBlend && undefined === this.volClassBlend);
         this.volClassColorStencil = ViewportQuadGeometry.create(20 /* TechniqueId.VolClassColorUsingStencil */);
-        this.volClassCopyZ = SingleTexturedViewportQuadGeometry.createGeometry(depth.getHandle(), 31 /* TechniqueId.VolClassCopyZ */);
-        this.volClassSetBlend = VolumeClassifierGeometry.createVCGeometry(depth.getHandle());
-        this.volClassBlend = SingleTexturedViewportQuadGeometry.createGeometry(textures.volClassBlend.getHandle(), 33 /* TechniqueId.VolClassBlend */);
+        this.volClassCopyZ = SingleTexturedViewportQuadGeometry.createGeometry(expectDefined(depth.getHandle()), 31 /* TechniqueId.VolClassCopyZ */);
+        this.volClassSetBlend = VolumeClassifierGeometry.createVCGeometry(expectDefined(depth.getHandle()));
+        this.volClassBlend = SingleTexturedViewportQuadGeometry.createGeometry(expectDefined(textures.volClassBlend?.getHandle()), 33 /* TechniqueId.VolClassBlend */);
         return undefined !== this.volClassColorStencil && undefined !== this.volClassCopyZ && undefined !== this.volClassSetBlend && undefined !== this.volClassBlend;
     }
     disableVolumeClassifier() {
@@ -795,7 +801,7 @@ class Compositor extends SceneCompositor {
     forceBufferChange() { this._width = this._height = -1; }
     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; }
+    get _samplerFbo() { return this._readPickDataFromPingPong ? expectDefined(this._fbos.pingPong) : expectDefined(this._fbos.opaqueAll); }
     getSamplerTexture(index) { return this._samplerFbo.getColor(index); }
     drawPrimitive(primitive, exec, outputsToPick) {
         if ((outputsToPick && this._primitiveDrawState !== PrimitiveDrawState.NonPickable) ||
@@ -803,14 +809,14 @@ class Compositor extends SceneCompositor {
             primitive.draw(exec);
     }
     clearOpaque(needComposite) {
-        const fbo = needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll;
+        const fbo = needComposite ? expectDefined(this._fbos.opaqueAndCompositeAll) : expectDefined(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._geom.clearPickAndColor);
+            const params = getDrawParams(this.target, expectDefined(this._geom.clearPickAndColor));
             this.target.techniques.draw(params);
             // Clear depth buffer
             system.applyRenderState(RenderState.defaults); // depthMask == true.
@@ -819,7 +825,7 @@ class Compositor extends SceneCompositor {
         });
     }
     renderLayers(commands, needComposite, pass) {
-        const fbo = (needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll);
+        const fbo = (needComposite ? expectDefined(this._fbos.opaqueAndCompositeAll) : expectDefined(this._fbos.opaqueAll));
         const useMsBuffers = 1 /* RenderPass.OpaqueLayers */ === pass && fbo.isMultisampled && this.useMsBuffers;
         this._readPickDataFromPingPong = !useMsBuffers;
         System.instance.frameBufferStack.execute(fbo, true, useMsBuffers, () => {
@@ -835,7 +841,7 @@ class Compositor extends SceneCompositor {
         const needComposite = 0 /* CompositeFlags.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);
+        let fbo = (needComposite ? expectDefined(this._fbos.opaqueAndCompositeAll) : expectDefined(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, () => {
@@ -851,7 +857,7 @@ class Compositor extends SceneCompositor {
         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);
+            fbo = (needComposite ? expectDefined(this._fbos.opaqueAndCompositeColor) : expectDefined(this._fbos.opaqueColor));
             fbStack.execute(fbo, true, useMsBuffers, () => {
                 this.drawPass(commands, 5 /* RenderPass.OpaqueGeneral */, false);
                 this.drawPass(commands, 9 /* RenderPass.HiddenEdge */, false);
@@ -865,7 +871,7 @@ class Compositor extends SceneCompositor {
         const fbStack = System.instance.frameBufferStack;
         const haveHiddenEdges = 0 !== commands.getCommands(9 /* RenderPass.HiddenEdge */).length;
         // Output the linear, planar, and pickable surfaces to color and pick data buffers.
-        let fbo = this._fbos.opaqueAndCompositeAll;
+        let fbo = expectDefined(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, () => {
@@ -879,7 +885,7 @@ class Compositor extends SceneCompositor {
         });
         this._readPickDataFromPingPong = false;
         // Output the non-pickable surfaces and hidden edges to just the color buffer.
-        fbo = this._fbos.opaqueAndCompositeColor;
+        fbo = expectDefined(this._fbos.opaqueAndCompositeColor);
         fbStack.execute(fbo, true, useMsBuffers, () => {
             this._primitiveDrawState = PrimitiveDrawState.NonPickable;
             this.drawPass(commands, 5 /* RenderPass.OpaqueGeneral */, false);
@@ -896,16 +902,16 @@ class Compositor extends SceneCompositor {
             // 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);
+            fbo = (useMsBuffers ? expectDefined(this._fbos.pingPongMS) : expectDefined(this._fbos.pingPong));
             fbStack.execute(fbo, true, useMsBuffers, () => {
-                const params = getDrawParams(this.target, this._geom.copyPickBuffers);
+                const params = getDrawParams(this.target, expectDefined(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;
+            fbo = expectDefined(this._fbos.opaqueAndCompositeAllHidden);
             this._primitiveDrawState = PrimitiveDrawState.Pickable;
             fbStack.execute(fbo, true, useMsBuffers, () => {
                 this.drawPass(commands, 9 /* RenderPass.HiddenEdge */, false);
@@ -951,7 +957,7 @@ class Compositor extends SceneCompositor {
             }
         }
         const needComposite = 0 /* CompositeFlags.None */ !== compositeFlags;
-        const fbo = (needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor);
+        const fbo = (needComposite ? expectDefined(this._fbos.opaqueAndCompositeColor) : expectDefined(this._fbos.opaqueColor));
         const useMsBuffers = fbo.isMultisampled && this.useMsBuffers;
         const system = System.instance;
         const fbStack = system.frameBufferStack;
@@ -1022,21 +1028,21 @@ class Compositor extends SceneCompositor {
         const fbStack = System.instance.frameBufferStack;
         if (renderForReadPixels || needAO) {
             this._readPickDataFromPingPong = true;
-            fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeAll : this._fbos.opaqueAll, true, this.useMsBuffers, () => {
+            fbStack.execute(needComposite ? expectDefined(this._fbos.opaqueAndCompositeAll) : expectDefined(this._fbos.opaqueAll), true, this.useMsBuffers, () => {
                 this.drawPass(commands, 5 /* RenderPass.OpaqueGeneral */, true, 20 /* RenderPass.VolumeClassifiedRealityData */);
             });
         }
         else {
             this._readPickDataFromPingPong = false;
-            fbStack.execute(needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor, true, this.useMsBuffers, () => {
+            fbStack.execute(needComposite ? expectDefined(this._fbos.opaqueAndCompositeColor) : expectDefined(this._fbos.opaqueColor), true, this.useMsBuffers, () => {
                 this.drawPass(commands, 5 /* RenderPass.OpaqueGeneral */, false, 20 /* RenderPass.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));
+        const fbo = (renderForIntersectingVolumes ? (needComposite ? expectDefined(this._fbos.idsAndZComposite) : expectDefined(this._fbos.idsAndZ))
+            : (needComposite ? expectDefined(this._fbos.idsAndAltZComposite) : expectDefined(this._fbos.idsAndAltZ)));
         System.instance.frameBufferStack.execute(fbo, true, false, () => {
             System.instance.applyRenderState(state);
             this.target.techniques.execute(this.target, cmds, 5 /* RenderPass.OpaqueGeneral */);
@@ -1045,29 +1051,29 @@ class Compositor extends SceneCompositor {
     }
     clearTranslucent() {
         System.instance.applyRenderState(this._noDepthMaskRenderState);
-        System.instance.frameBufferStack.execute(this._fbos.clearTranslucent, true, false, () => {
-            const params = getDrawParams(this.target, this._geom.clearTranslucent);
+        System.instance.frameBufferStack.execute(expectDefined(this._fbos.clearTranslucent), true, false, () => {
+            const params = getDrawParams(this.target, expectDefined(this._geom.clearTranslucent));
             this.target.techniques.draw(params);
         });
     }
     renderTranslucent(commands) {
-        System.instance.frameBufferStack.execute(this._fbos.translucent, true, false, () => {
+        System.instance.frameBufferStack.execute(expectDefined(this._fbos.translucent), true, false, () => {
             this.drawPass(commands, 8 /* RenderPass.Translucent */);
         });
     }
     getBackgroundFbo(needComposite) {
-        return needComposite ? this._fbos.opaqueAndCompositeColor : this._fbos.opaqueColor;
+        return needComposite ? expectDefined(this._fbos.opaqueAndCompositeColor) : expectDefined(this._fbos.opaqueColor);
     }
     pingPong() {
-        if (this._fbos.opaqueAll.isMultisampled && this.useMsBuffers) {
+        if (expectDefined(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);
+            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);
+            System.instance.frameBufferStack.execute(expectDefined(this._fbos.pingPong), true, this.useMsBuffers, () => {
+                const params = getDrawParams(this.target, expectDefined(this._geom.copyPickBuffers));
                 this.target.techniques.draw(params);
             });
         }
@@ -1084,29 +1090,29 @@ class Compositor extends SceneCompositor {
     renderAmbientOcclusion() {
         const system = System.instance;
         // Render unblurred ambient occlusion based on depth buffer
-        let fbo = this._fbos.occlusion;
+        let fbo = expectDefined(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);
+            const params = getDrawParams(this.target, expectDefined(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;
+        fbo = expectDefined(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);
+            const params = getDrawParams(this.target, expectDefined(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;
+        fbo = expectDefined(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);
+            const params = getDrawParams(this.target, expectDefined(this._geom.occlusionYBlur));
             this.target.techniques.draw(params);
         });
         this.target.endPerfMetricRecord();
@@ -1208,11 +1214,11 @@ class Compositor extends SceneCompositor {
                     assert(false, "Failed to initialize occlusion textures");
                     return false;
                 }
-                if (!this._fbos.enableOcclusion(this._textures, this._depth, this._depthMS)) {
+                if (!this._fbos.enableOcclusion(this._textures, expectDefined(this._depth), this._depthMS)) {
                     assert(false, "Failed to initialize occlusion frame buffers");
                     return false;
                 }
-                this._geom.enableOcclusion(this._textures, this._depth);
+                this._geom.enableOcclusion(this._textures, expectDefined(this._depth));
             }
             else {
                 this._geom.disableOcclusion();
@@ -1230,9 +1236,9 @@ class Compositor extends SceneCompositor {
                     return false;
                 if (!this._textures.enableVolumeClassifier(width, height, this._antialiasSamples))
                     return false;
-                if (!this._geom.enableVolumeClassifier(this._textures, this._depth))
+                if (!this._geom.enableVolumeClassifier(this._textures, expectDefined(this._depth)))
                     return false;
-                this.enableVolumeClassifierFbos(this._textures, this._depth, this._vcAltDepthStencil, this._depthMS, this._vcAltDepthStencilMS);
+                this.enableVolumeClassifierFbos(this._textures, expectDefined(this._depth), this._vcAltDepthStencil, this._depthMS, this._vcAltDepthStencilMS);
                 this._haveVolumeClassifier = true;
             }
             else {
@@ -1313,7 +1319,7 @@ class Compositor extends SceneCompositor {
         this.renderLayers(commands, needComposite, 7 /* RenderPass.TranslucentLayers */);
         this.target.endPerfMetricRecord();
         if (needComposite) {
-            this._geom.composite.update(compositeFlags);
+            expectDefined(this._geom.composite).update(compositeFlags);
             this.target.beginPerfMetricRecord("Render Translucent");
             this.clearTranslucent();
             this.renderTranslucent(commands);
@@ -1391,7 +1397,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._fbos.opaqueColor, true, this.useMsBuffers, () => {
+            system.frameBufferStack.execute(expectDefined(this._fbos.opaqueColor), true, this.useMsBuffers, () => {
                 system.applyRenderState(RenderState.defaults);
                 system.context.clearDepth(1.0);
                 system.context.clear(GL.BufferBit.Depth);
@@ -1668,14 +1674,14 @@ class Compositor extends SceneCompositor {
     }
     renderIndexedVolumeClassifier(cmdsByIndex, needComposite) {
         // Set the stencil for the given classifier stencil volume.
-        System.instance.frameBufferStack.execute(this._fbos.stencilSet, false, this.useMsBuffers, () => {
-            this.target.pushState(this._vcBranchState);
-            System.instance.applyRenderState(this._vcSetStencilRenderState);
+        System.instance.frameBufferStack.execute(expectDefined(this._fbos.stencilSet), false, this.useMsBuffers, () => {
+            this.target.pushState(expectDefined(this._vcBranchState));
+            System.instance.applyRenderState(expectDefined(this._vcSetStencilRenderState));
             this.target.techniques.executeForIndexedClassifier(this.target, cmdsByIndex, 6 /* RenderPass.Classification */);
             this.target.popBranch();
         });
         // Process the stencil for the pick data.
-        this.renderIndexedClassifierForReadPixels(cmdsByIndex, this._vcPickDataRenderState, true, needComposite);
+        this.renderIndexedClassifierForReadPixels(cmdsByIndex, expectDefined(this._vcPickDataRenderState), true, needComposite);
     }
     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
@@ -1713,8 +1719,8 @@ class Compositor extends SceneCompositor {
                     this.target.techniques.execute(this.target, cmds, 5 /* RenderPass.OpaqueGeneral */);
                 }
                 else {
-                    this.target.pushState(this._vcBranchState);
-                    System.instance.applyRenderState(this._vcDebugRenderState);
+                    this.target.pushState(expectDefined(this._vcBranchState));
+                    System.instance.applyRenderState(expectDefined(this._vcDebugRenderState));
                     this.target.techniques.execute(this.target, cmds, 6 /* RenderPass.Classification */);
                     this.target.popBranch();
                 }
@@ -1742,7 +1748,7 @@ class Compositor extends SceneCompositor {
         const needAltZ = (doColorByElement && !doColorByElementForIntersectingVolumes) || needOutsideDraw;
         let zOnlyFbo = this._fbos.stencilSet;
         let volClassBlendFbo = this._fbos.volClassCreateBlend;
-        let volClassBlendReadZTexture = this._vcAltDepthStencil.getHandle();
+        let volClassBlendReadZTexture = expectDefined(this._vcAltDepthStencil?.getHandle());
         let volClassBlendReadZTextureFbo = this._fbos.altZOnly;
         if (!needAltZ) {
             // Initialize the blend texture and the stencil.
@@ -1759,15 +1765,15 @@ class Compositor extends SceneCompositor {
             zOnlyFbo = this._fbos.altZOnly;
             volClassBlendFbo = this._fbos.volClassCreateBlendAltZ;
             assert(undefined !== volClassBlendFbo);
-            volClassBlendReadZTexture = this._depth.getHandle();
+            volClassBlendReadZTexture = expectDefined(this._depth?.getHandle());
             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);
-                this.target.techniques.draw(getDrawParams(this.target, this._geom.volClassCopyZ)); // This method uses the EXT_frag_depth extension
+                System.instance.applyRenderState(expectDefined(this._vcCopyZRenderState));
+                this.target.techniques.draw(getDrawParams(this.target, expectDefined(this._geom.volClassCopyZ))); // This method uses the EXT_frag_depth extension
                 System.instance.bindTexture2d(TextureUnit.Zero, undefined);
                 this.target.popBranch();
             });
@@ -1775,26 +1781,29 @@ class Compositor extends SceneCompositor {
         if (renderForReadPixels) {
             // Set the stencil for all of the classifier volumes.
             System.instance.frameBufferStack.execute(this._fbos.altZOnly, false, this.useMsBuffers, () => {
-                this.target.pushState(this._vcBranchState);
-                System.instance.applyRenderState(this._vcSetStencilRenderState);
+                this.target.pushState(expectDefined(this._vcBranchState));
+                System.instance.applyRenderState(expectDefined(this._vcSetStencilRenderState));
                 this.target.techniques.execute(this.target, cmds, 6 /* RenderPass.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);
+                expectDefined(this._vcSetStencilRenderState).flags.depthMask = true;
+                System.instance.applyRenderState(expectDefined(this._vcSetStencilRenderState));
                 System.instance.context.clearDepth(1.0);
                 System.instance.context.clear(GL.BufferBit.Depth);
-                this._vcSetStencilRenderState.flags.depthMask = false;
+                expectDefined(this._vcSetStencilRenderState).flags.depthMask = false;
                 this.target.popBranch();
                 System.instance.bindTexture2d(TextureUnit.Two, undefined);
                 System.instance.bindTexture2d(TextureUnit.Five, undefined);
             });
+            if (undefined === this._vcColorRenderState || undefined === this._vcBranchState) {
+                throw new Error("this._vcColorRenderState or this._vcBranchState is undefined");
+            }
             this.target.pushState(this._vcBranchState);
             this._vcColorRenderState.flags.depthTest = true;
             this._vcColorRenderState.flags.depthMask = true;
             this._vcColorRenderState.flags.cull = true;
             this._vcColorRenderState.flags.blend = false;
             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;
+            this.target.activeVolumeClassifierTexture = this._geom.volClassCopyZ?.texture;
             if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
                 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);
@@ -1814,8 +1823,8 @@ class Compositor extends SceneCompositor {
             // Set the stencil using all of the volume classifiers.  This will be used to do the outside and/or the inside if they need to be done.
             // If we are not modifying the outside and the inside is using color-by-element for intersecting volumes, then the stencil will get set later.
             fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
-                this.target.pushState(this._vcBranchState);
-                System.instance.applyRenderState(this._vcSetStencilRenderState);
+                this.target.pushState(expectDefined(this._vcBranchState));
+                System.instance.applyRenderState(expectDefined(this._vcSetStencilRenderState));
                 this.target.techniques.execute(this.target, cmds, 6 /* RenderPass.Classification */);
                 this.target.popBranch();
                 System.instance.bindTexture2d(TextureUnit.Two, undefined);
@@ -1826,6 +1835,9 @@ class Compositor extends SceneCompositor {
             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
             fbStack.execute(volClassBlendFbo, false, this.useMsBuffers, () => {
+                if (undefined === this._geom.volClassSetBlend || undefined === this._vcColorRenderState) {
+                    throw new Error("this._geom.volClassSetBlend or this._vcColorRenderState is undefined");
+                }
                 this._geom.volClassSetBlend.boundaryType = BoundaryType.Outside;
                 this._geom.volClassSetBlend.texture = volClassBlendReadZTexture;
                 this.target.pushState(this.target.decorationsState);
@@ -1852,6 +1864,9 @@ class Compositor extends SceneCompositor {
                 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
                 fbStack.execute(volClassBlendFbo, false, this.useMsBuffers, () => {
+                    if (undefined === this._geom.volClassSetBlend || undefined === this._vcColorRenderState) {
+                        throw new Error("this._geom.volClassSetBlend or this._vcColorRenderState is undefined");
+                    }
                     this._geom.volClassSetBlend.boundaryType = BoundaryType.Inside;
                     this._geom.volClassSetBlend.texture = volClassBlendReadZTexture;
                     this.target.pushState(this.target.decorationsState);
@@ -1870,13 +1885,16 @@ class Compositor extends SceneCompositor {
                     const nxtCmds = cmdsByIndex.slice(i, i + numCmdsPerClassifier);
                     // Set the stencil for this one classifier.
                     fbStack.execute(zOnlyFbo, false, this.useMsBuffers, () => {
-                        this.target.pushState(this._vcBranchState);
-                        System.instance.applyRenderState(this._vcSetStencilRenderState);
+                        this.target.pushState(expectDefined(this._vcBranchState));
+                        System.instance.applyRenderState(expectDefined(this._vcSetStencilRenderState));
                         this.target.techniques.execute(this.target, nxtCmds, 6 /* RenderPass.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.
                     fbStack.execute(volClassBlendFbo, true, this.useMsBuffers, () => {
+                        if (undefined === this._vcColorRenderState || undefined === this._vcBranchState) {
+                            throw new Error("this._vcColorRenderState or this._vcBranchState is undefined");
+                        }
                         this.target.pushState(this._vcBranchState);
                         this._vcColorRenderState.blend.color = [1.0, 1.0, 1.0, 0.35];
                         this._vcColorRenderState.blend.setBlendFuncSeparate(GL.BlendFactor.One, GL.BlendFactor.ConstAlpha, GL.BlendFactor.Zero, GL.BlendFactor.Zero);
@@ -1893,6 +1911,9 @@ class Compositor extends SceneCompositor {
                 if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
                     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, () => {
+                    if (undefined === this._vcColorRenderState || undefined === this._vcBranchState) {
+                        throw new Error("this._vcColorRenderState or this._vcBranchState is undefined");
+                    }
                     // 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
                     // anything that is in front of the reality model by reading the Z texture from the standard Z buffer (which has the reality mesh Z's in it).
@@ -1908,7 +1929,7 @@ class Compositor extends SceneCompositor {
                     System.instance.applyRenderState(this._vcColorRenderState);
                     System.instance.context.clearDepth(1.0);
                     System.instance.context.clear(GL.BufferBit.Depth);
-                    this.target.activeVolumeClassifierTexture = this._geom.volClassCopyZ.texture;
+                    this.target.activeVolumeClassifierTexture = this._geom.volClassCopyZ?.texture;
                     this.target.techniques.execute(this.target, cmds, 5 /* RenderPass.OpaqueGeneral */);
                     this.target.activeVolumeClassifierTexture = undefined;
                     this._vcColorRenderState.flags.depthTest = false;
@@ -1932,8 +1953,8 @@ class Compositor extends SceneCompositor {
         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._fbos.stencilSet, false, this.useMsBuffers, () => {
-                this.target.pushState(this._vcBranchState);
-                System.instance.applyRenderState(this._vcSetStencilRenderState);
+                this.target.pushState(expectDefined(this._vcBranchState));
+                System.instance.applyRenderState(expectDefined(this._vcSetStencilRenderState));
                 if (needAltZ) {
                     // If we are using the alternate Z then the stencil that goes with the original Z has not been cleared yet, so clear it here.
                     System.instance.context.clearStencil(0);
@@ -1944,9 +1965,15 @@ class Compositor extends SceneCompositor {
             });
             if (this._antialiasSamples > 1 && undefined !== this._depthMS && this.useMsBuffers)
                 this._fbos.altZOnly.blitMsBuffersToTextures(true, -1); // make sure that the Z buffer that we are about to read has been blitted
+            if (undefined === this._fbos.volClassCreateBlend) {
+                throw new Error("this._fbos.volClassCreateBlend is undefined");
+            }
             fbStack.execute(this._fbos.volClassCreateBlend, false, this.useMsBuffers, () => {
+                if (undefined === this._geom.volClassSetBlend || undefined === this._vcColorRenderState) {
+                    throw new Error("this._geom.volClassSetBlend or this._vcColorRenderState is undefined");
+                }
                 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._geom.volClassSetBlend.texture = expectDefined(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);
                 this._vcColorRenderState.flags.blend = false;
                 System.instance.applyRenderState(this._vcColorRenderState);
@@ -1962,6 +1989,9 @@ class Compositor extends SceneCompositor {
             volClassBlendFbo.blitMsBuffersToTextures(false); // make sure the volClassBlend texture that we are about to read has been blitted
         }
         fbStack.execute(fboColorAndZ, false, this.useMsBuffers, () => {
+            if (undefined === this._vcBlendRenderState || undefined === this._geom.volClassBlend) {
+                throw new Error("this._vcBlendRenderState or this._geom.volClassBlend is undefined");
+            }
             this.target.pushState(this.target.decorationsState);
             this._vcBlendRenderState.blend.setBlendFuncSeparate(GL.BlendFactor.SrcAlpha, GL.BlendFactor.Zero, GL.BlendFactor.OneMinusSrcAlpha, GL.BlendFactor.One);
             System.instance.applyRenderState(this._vcBlendRenderState);
@@ -1976,13 +2006,16 @@ class Compositor extends SceneCompositor {
         if (undefined !== flashedClassifierCmds && !doColorByElement) {
             // Set the stencil for this one classifier.
             fbStack.execute(this._fbos.stencilSet, false, this.useMsBuffers, () => {
-                this.target.pushState(this._vcBranchState);
-                System.instance.applyRenderState(this._vcSetStencilRenderState);
+                this.target.pushState(expectDefined(this._vcBranchState));
+                System.instance.applyRenderState(expectDefined(this._vcSetStencilRenderState));
                 this.target.techniques.executeForIndexedClassifier(this.target, flashedClassifierCmds, 5 /* RenderPass.OpaqueGeneral */);
                 this.target.popBranch();
             });
             // Process the stencil to flash the contents.
             fbStack.execute(fboColorAndZ, true, this.useMsBuffers, () => {
+                if (undefined === this._vcColorRenderState || undefined === this._geom.volClassColorStencil) {
+                    throw new Error("this._vcColorRenderState or this._geom.volClassColorStencil is undefined");
+                }
                 this.target.pushState(this.target.decorationsState);
                 this._vcColorRenderState.blend.color = [1.0, 1.0, 1.0, this.target.flashIntensity * 0.2];
                 this._vcColorRenderState.blend.setBlendFuncSeparate(GL.BlendFactor.ConstAlpha, GL.BlendFactor.Zero, GL.BlendFactor.One, GL.BlendFactor.One);
@@ -1995,7 +2028,7 @@ class Compositor extends SceneCompositor {
     }
     renderHilite(commands) {
         const system = System.instance;
-        system.frameBufferStack.execute(this._fbos.hilite, true, false, () => {
+        system.frameBufferStack.execute(expectDefined(this._fbos.hilite), true, false, () => {
             // Clear the hilite buffer.
             system.context.clearColor(0, 0, 0, 0);
             system.context.clear(GL.BufferBit.Color);
@@ -2005,7 +2038,7 @@ class Compositor extends SceneCompositor {
         // Process planar classifiers
         const planarClassifierCmds = commands.getCommands(18 /* RenderPass.HilitePlanarClassification */);
         if (0 !== planarClassifierCmds.length) {
-            system.frameBufferStack.execute(this._fbos.hiliteUsingStencil, true, false, () => {
+            system.frameBufferStack.execute(expectDefined(this._fbos.hiliteUsingStencil), true, false, () => {
                 system.applyRenderState(this._opaqueRenderState);
                 this.target.techniques.execute(this.target, planarClassifierCmds, 18 /* RenderPass.HilitePlanarClassification */);
             });
@@ -2014,22 +2047,22 @@ class Compositor extends SceneCompositor {
         const vcHiliteCmds = commands.getCommands(16 /* RenderPass.HiliteClassification */);
         if (0 !== vcHiliteCmds.length && undefined !== this._vcBranchState) {
             // Set the stencil for the given classifier stencil volume.
-            system.frameBufferStack.execute(this._fbos.stencilSet, false, false, () => {
-                this.target.pushState(this._vcBranchState);
-                system.applyRenderState(this._vcSetStencilRenderState);
+            system.frameBufferStack.execute(expectDefined(this._fbos.stencilSet), false, false, () => {
+                this.target.pushState(expectDefined(this._vcBranchState));
+                system.applyRenderState(expectDefined(this._vcSetStencilRenderState));
                 this.target.techniques.execute(this.target, vcHiliteCmds, 10 /* RenderPass.Hilite */);
                 this.target.popBranch();
             });
             // Process the stencil for the hilite data.
-            system.frameBufferStack.execute(this._fbos.hiliteUsingStencil, true, false, () => {
-                system.applyRenderState(this._vcPickDataRenderState);
+            system.frameBufferStack.execute(expectDefined(this._fbos.hiliteUsingStencil), true, false, () => {
+                system.applyRenderState(expectDefined(this._vcPickDataRenderState));
                 this.target.techniques.execute(this.target, vcHiliteCmds, 10 /* RenderPass.Hilite */);
             });
         }
     }
     composite() {
         System.instance.applyRenderState(RenderState.defaults);
-        const params = getDrawParams(this.target, this._geom.composite);
+        const params = getDrawParams(this.target, expectDefined(this._geom.composite));
         this.target.techniques.draw(params);
     }
     getRenderState(pass) {