fix crash due to undefined clipping planes texture

CHANGES.md

@@ -23,6 +23,7 @@ Change Log
 * Fixed incorrect 3D Tiles statistics when a tile fails during processing. [#6558](https://github.com/AnalyticalGraphicsInc/cesium/pull/6558)
 * Fixed race condition causing intermittent crash when changing geometry show value [#3061](https://github.com/AnalyticalGraphicsInc/cesium/issues/3061)
 * `ProviderViewModel`s with no category are displayed in an untitled group in `BaseLayerPicker` instead of being labeled as `'Other'` [#6574](https://github.com/AnalyticalGraphicsInc/cesium/pull/6574)
+* Fixed a bug causing intermittent crashes with clipping planes due to uninitialized textures. [#6576](https://github.com/AnalyticalGraphicsInc/cesium/pull/6576)
 * Added a workaround for clipping planes causing a picking shader compilation failure for gltf models and 3D Tilesets in Internet Explorer [#6575](https://github.com/AnalyticalGraphicsInc/cesium/issues/6575)
 
 ### 1.45 - 2018-05-01

Source/Scene/Batched3DModel3DTileContent.js

@@ -513,6 +513,12 @@ define([
             this._model._clippingPlanes = (tilesetClippingPlanes.enabled && this._tile._isClipped) ? tilesetClippingPlanes : undefined;
         }
 
+        // If the model references a different ClippingPlaneCollection due to the tileset's collection being replaced with a
+        // ClippingPlaneCollection that gives this tile the same clipping status, update the model to use the new ClippingPlaneCollection.
+        if (defined(tilesetClippingPlanes) && defined(this._model._clippingPlanes) && this._model._clippingPlanes !== tilesetClippingPlanes) {
+            this._model._clippingPlanes = tilesetClippingPlanes;
+        }
+
         this._model.update(frameState);
 
         // If any commands were pushed, add derived commands

Source/Scene/ClippingPlaneCollection.js

@@ -459,7 +459,8 @@ define([
 
         if (!defined(clippingPlanesTexture)) {
             // Allocate twice as much space as needed to avoid frequent texture reallocation.
-            requiredResolution.x *= 2;
+            // Allocate in the Y direction, since texture may be as wide as context texture support.
+            requiredResolution.y *= 2;
 
             var sampler = new Sampler({
                 wrapS : TextureWrap.CLAMP_TO_EDGE,
@@ -502,16 +503,22 @@ define([
         }
         if (!this._multipleDirtyPlanes) {
             // partial updates possible
-            var offsetY = Math.floor(dirtyIndex / clippingPlanesTexture.width);
-            var offsetX = Math.floor(dirtyIndex - offsetY * clippingPlanesTexture.width);
+            var offsetX = 0;
+            var offsetY = 0;
             if (useFloatTexture) {
+                offsetY = Math.floor(dirtyIndex / clippingPlanesTexture.width);
+                offsetX = Math.floor(dirtyIndex - offsetY * clippingPlanesTexture.width);
+
                 packPlanesAsFloats(this, dirtyIndex, dirtyIndex + 1);
                 clippingPlanesTexture.copyFrom({
                     width : 1,
                     height : 1,
                     arrayBufferView : this._float32View
                 }, offsetX, offsetY);
             } else {
+                offsetY = Math.floor((dirtyIndex * 2) / clippingPlanesTexture.width);
+                offsetX = Math.floor((dirtyIndex * 2) - offsetY * clippingPlanesTexture.width);
+
                 packPlanesAsUint8(this, dirtyIndex, dirtyIndex + 1);
                 clippingPlanesTexture.copyFrom({
                     width : 2,
@@ -665,6 +672,33 @@ define([
         return context.floatingPointTexture;
     };
 
+    /**
+     * Function for getting the clipping plane collection's texture resolution.
+     * If the ClippingPlaneCollection hasn't been updated, returns the resolution that will be
+     * allocated based on the current plane count.
+     *
+     * @param {ClippingPlaneCollection} clippingPlaneCollection The clipping plane collection
+     * @param {Context} context The rendering context
+     * @param {Cartesian2} result A Cartesian2 for the result.
+     * @returns {Cartesian2} The required resolution.
+     * @private
+     */
+    ClippingPlaneCollection.getTextureResolution = function(clippingPlaneCollection, context, result) {
+        var texture = clippingPlaneCollection.texture;
+        if (defined(texture)) {
+            result.x = texture.width;
+            result.y = texture.height;
+            return result;
+        }
+
+        var pixelsNeeded = ClippingPlaneCollection.useFloatTexture(context) ? clippingPlaneCollection.length : clippingPlaneCollection.length * 2;
+        var requiredResolution = computeTextureResolution(pixelsNeeded, result);
+
+        // Allocate twice as much space as needed to avoid frequent texture reallocation.
+        requiredResolution.y *= 2;
+        return requiredResolution;
+    };
+
     /**
      * Returns true if this object was destroyed; otherwise, false.
      * <br /><br />

Source/Scene/GlobeSurfaceShaderSet.js

@@ -123,7 +123,7 @@ define([
             var fs = this.baseFragmentShaderSource.clone();
 
             if (currentClippingShaderState !== 0) {
-                fs.sources.unshift(getClippingFunction(clippingPlanes)); // Need to go before GlobeFS
+                fs.sources.unshift(getClippingFunction(clippingPlanes, frameState.context)); // Need to go before GlobeFS
             }
 
             vs.defines.push(quantizationDefine);

Source/Scene/Instanced3DModel3DTileContent.js

@@ -520,6 +520,12 @@ define([
                 // Link/Dereference directly to avoid ownership checks.
                 model._clippingPlanes = (tilesetClippingPlanes.enabled && this._tile._isClipped) ? tilesetClippingPlanes : undefined;
             }
+
+            // If the model references a different ClippingPlaneCollection due to the tileset's collection being replaced with a
+            // ClippingPlaneCollection that gives this tile the same clipping status, update the model to use the new ClippingPlaneCollection.
+            if (defined(tilesetClippingPlanes) && defined(model._clippingPlanes) && model._clippingPlanes !== tilesetClippingPlanes) {
+                model._clippingPlanes = tilesetClippingPlanes;
+            }
         }
 
         this._modelInstanceCollection.update(frameState);

Source/Scene/Model.js

@@ -2043,7 +2043,7 @@ define([
             finalFS = Model._modifyShaderForColor(finalFS, model._hasPremultipliedAlpha);
         }
         if (addClippingPlaneCode) {
-            finalFS = modifyShaderForClippingPlanes(finalFS, clippingPlaneCollection);
+            finalFS = modifyShaderForClippingPlanes(finalFS, clippingPlaneCollection, context);
         }
 
         var drawVS = modifyShader(vs, id, model._vertexShaderLoaded);
@@ -2066,7 +2066,7 @@ define([
             }
 
             if (addClippingPlaneCode) {
-                pickFS = modifyShaderForClippingPlanes(pickFS, clippingPlaneCollection);
+                pickFS = modifyShaderForClippingPlanes(pickFS, clippingPlaneCollection, context);
             }
 
             if (!FeatureDetection.isInternetExplorer()) {
@@ -3960,9 +3960,9 @@ define([
         }
     }
 
-    function modifyShaderForClippingPlanes(shader, clippingPlaneCollection) {
+    function modifyShaderForClippingPlanes(shader, clippingPlaneCollection, context) {
         shader = ShaderSource.replaceMain(shader, 'gltf_clip_main');
-        shader += Model._getClippingFunction(clippingPlaneCollection) + '\n';
+        shader += Model._getClippingFunction(clippingPlaneCollection, context) + '\n';
         shader +=
             'uniform sampler2D gltf_clippingPlanes; \n' +
             'uniform mat4 gltf_clippingPlanesMatrix; \n' +

Source/Scene/PointCloud3DTileContent.js

@@ -1126,7 +1126,7 @@ define([
                   'uniform mat4 u_clippingPlanesMatrix; \n' +
                   'uniform vec4 u_clippingPlanesEdgeStyle; \n';
             fs += '\n';
-            fs += getClippingFunction(clippingPlanes);
+            fs += getClippingFunction(clippingPlanes, context);
             fs += '\n';
         }
 

Source/Scene/getClippingFunction.js

@@ -1,36 +1,43 @@
 define([
+        '../Core/Cartesian2',
         '../Core/Check',
-        '../Renderer/PixelDatatype'
+        '../Renderer/PixelDatatype',
+        './ClippingPlaneCollection'
     ], function(
+        Cartesian2,
         Check,
-        PixelDatatype) {
+        PixelDatatype,
+        ClippingPlaneCollection) {
     'use strict';
 
+    var textureResolutionScratch = new Cartesian2();
     /**
      * Gets the GLSL functions needed to retrieve clipping planes from a ClippingPlaneCollection's texture.
      *
      * @param {ClippingPlaneCollection} clippingPlaneCollection ClippingPlaneCollection with a defined texture.
+     * @param {Context} context The current rendering context.
      * @returns {String} A string containing GLSL functions for retrieving clipping planes.
      * @private
      */
-    function getClippingFunction(clippingPlaneCollection) {
+    function getClippingFunction(clippingPlaneCollection, context) {
         //>>includeStart('debug', pragmas.debug);
         Check.typeOf.object('clippingPlaneCollection', clippingPlaneCollection);
+        Check.typeOf.object('context', context);
         //>>includeEnd('debug');
         var unionClippingRegions = clippingPlaneCollection.unionClippingRegions;
         var clippingPlanesLength = clippingPlaneCollection.length;
-        var texture = clippingPlaneCollection.texture;
-        var usingFloatTexture = texture.pixelDatatype === PixelDatatype.FLOAT;
-        var width = texture.width;
-        var height = texture.height;
+        var usingFloatTexture = ClippingPlaneCollection.useFloatTexture(context);
+        var textureResolution = ClippingPlaneCollection.getTextureResolution(clippingPlaneCollection, context, textureResolutionScratch);
+        var width = textureResolution.x;
+        var height = textureResolution.y;
 
         var functions = usingFloatTexture ? getClippingPlaneFloat(width, height) : getClippingPlaneUint8(width, height);
         functions += '\n';
-        functions += unionClippingRegions ? clippingFunctionUnion(usingFloatTexture, clippingPlanesLength) : clippingFunctionIntersect(usingFloatTexture, clippingPlanesLength);
+        functions += unionClippingRegions ? clippingFunctionUnion(clippingPlanesLength) : clippingFunctionIntersect(clippingPlanesLength);
         return functions;
     }
 
-    function clippingFunctionUnion(usingFloatTexture, clippingPlanesLength) {
+    function clippingFunctionUnion(clippingPlanesLength) {
         var functionString =
             'float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n' +
             '{\n' +
@@ -66,7 +73,7 @@ define([
         return functionString;
     }
 
-    function clippingFunctionIntersect(usingFloatTexture, clippingPlanesLength) {
+    function clippingFunctionIntersect(clippingPlanesLength) {
         var functionString =
             'float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n' +
             '{\n' +

Specs/Scene/Batched3DModel3DTileContentSpec.js

@@ -319,6 +319,39 @@ defineSuite([
         });
     });
 
+    it('Links model to tileset clipping planes if tileset clipping planes are reassigned', function() {
+        return Cesium3DTilesTester.loadTileset(scene, withBatchTableUrl).then(function(tileset) {
+            var tile = tileset._root;
+            var model = tile.content._model;
+
+            expect(model.clippingPlanes).toBeUndefined();
+
+            var clippingPlaneCollection = new ClippingPlaneCollection({
+                planes : [
+                    new ClippingPlane(Cartesian3.UNIT_X, 0.0)
+                ]
+            });
+            tileset.clippingPlanes = clippingPlaneCollection;
+            clippingPlaneCollection.update(scene.frameState);
+            tile.update(tileset, scene.frameState);
+
+            expect(model.clippingPlanes).toBeDefined();
+            expect(model.clippingPlanes).toBe(tileset.clippingPlanes);
+
+            var newClippingPlaneCollection = new ClippingPlaneCollection({
+                planes : [
+                    new ClippingPlane(Cartesian3.UNIT_X, 0.0)
+                ]
+            });
+            tileset.clippingPlanes = newClippingPlaneCollection;
+            newClippingPlaneCollection.update(scene.frameState);
+            expect(model.clippingPlanes).not.toBe(tileset.clippingPlanes);
+
+            tile.update(tileset, scene.frameState);
+            expect(model.clippingPlanes).toBe(tileset.clippingPlanes);
+        });
+    });
+
     it('rebuilds Model shaders when clipping planes change', function() {
         spyOn(Model, '_getClippingFunction').and.callThrough();