| Distance | ++ + + | +Plane Count | ++ + + | +
distance determines which side of the plane the origin
+ * is on. If distance is positive, the origin is in the half-space
+ * in the direction of the normal; if negative, the origin is in the half-space
+ * opposite to the normal; if zero, the plane passes through the origin.
+ */
+ function ClippingPlane(normal, distance) {
+ this._distance = distance;
+ this._normal = new UpdateChangedCartesian3(normal, this);
+ this.onChangeCallback = undefined;
+ this.index = -1; // to be set by ClippingPlaneCollection
+ }
+
+ defineProperties(ClippingPlane.prototype, {
+ /**
+ * The shortest distance from the origin to the plane. The sign of
+ * distance determines which side of the plane the origin
+ * is on. If distance is positive, the origin is in the half-space
+ * in the direction of the normal; if negative, the origin is in the half-space
+ * opposite to the normal; if zero, the plane passes through the origin.
+ *
+ * @type {Number}
+ * @memberof ClippingPlane.prototype
+ */
+ distance : {
+ get : function() {
+ return this._distance;
+ },
+ set : function(value) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.number('value', value);
+ //>>includeEnd('debug');
+ if (defined(this.onChangeCallback) && value !== this._distance) {
+ this.onChangeCallback(this.index);
+ }
+ this._distance = value;
+ }
+ },
+ /**
+ * The plane's normal.
+ *
+ * @type {Cartesian3}
+ * @memberof ClippingPlane.prototype
+ */
+ normal : {
+ get : function() {
+ return this._normal;
+ },
+ set : function(value) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.object('value', value);
+ //>>includeEnd('debug');
+ if (defined(this.onChangeCallback) && !Cartesian3.equals(this._normal._cartesian3, value)) {
+ this.onChangeCallback(this.index);
+ }
+ // Set without firing callback again
+ Cartesian3.clone(value, this._normal._cartesian3);
+ }
+ }
+ });
+
+ /**
+ * Create a ClippingPlane from a Plane object.
+ *
+ * @param {Plane} plane The plane containing parameters to copy
+ * @param {ClippingPlane} [result] The object on which to store the result
+ * @returns {ClippingPlane} The ClippingPlane generated from the plane's parameters.
+ */
+ ClippingPlane.fromPlane = function(plane, result) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.object('plane', plane);
+ //>>includeEnd('debug');
+
+ if (!defined(result)) {
+ result = new ClippingPlane(plane.normal, plane.distance);
+ } else {
+ result.normal = plane.normal;
+ result.distance = plane.distance;
+ }
+ return result;
+ };
+
+ /**
+ * Clones the ClippingPlane without setting its ownership.
+ * @param {ClippingPlane} clippingPlane The ClippingPlane to be cloned
+ * @param {ClippingPlane} [result] The object on which to store the cloned parameters.
+ * @returns {ClippingPlane} a clone of the input ClippingPlane
+ */
+ ClippingPlane.clone = function(clippingPlane, result) {
+ if (!defined(result)) {
+ return new ClippingPlane(clippingPlane.normal, clippingPlane.distance);
+ }
+ result.normal = clippingPlane.normal;
+ result.distance = clippingPlane.distance;
+ return result;
+ };
+
+ /**
+ * Wrapper on Cartesian3 that allows detection of Plane changes from "members of members," for example:
+ *
+ * var clippingPlane = new ClippingPlane(...);
+ * clippingPlane.normal.z = -1.0;
+ *
+ * @private
+ */
+ function UpdateChangedCartesian3(normal, clippingPlane) {
+ this._clippingPlane = clippingPlane;
+ this._cartesian3 = Cartesian3.clone(normal);
+ }
+
+ function makeGetterStter(key) {
+ return {
+ get : function() {
+ return this._cartesian3[key];
+ },
+ set : function(value) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.number('value', value);
+ //>>includeEnd('debug');
+ if (defined(this._clippingPlane.onChangeCallback) && value !== this._cartesian3[key]) {
+ this._clippingPlane.onChangeCallback(this._clippingPlane.index);
+ }
+ this._cartesian3[key] = value;
+ }
+ };
+ }
+
+ defineProperties(UpdateChangedCartesian3.prototype, {
+ x : makeGetterStter('x'),
+ y : makeGetterStter('y'),
+ z : makeGetterStter('z')
+ });
+
+ return ClippingPlane;
+});
diff --git a/Source/Core/ClippingPlaneCollection.js b/Source/Core/ClippingPlaneCollection.js
index 56369d69202f..b1ca230c41d8 100644
--- a/Source/Core/ClippingPlaneCollection.js
+++ b/Source/Core/ClippingPlaneCollection.js
@@ -1,40 +1,68 @@
define([
+ './AttributeCompression',
+ './Cartesian2',
'./Cartesian3',
'./Cartesian4',
+ './Math',
'./Check',
+ './ClippingPlane',
'./Color',
'./defaultValue',
'./defined',
'./defineProperties',
+ './deprecationWarning',
+ './destroyObject',
'./DeveloperError',
'./FeatureDetection',
'./Intersect',
'./Matrix4',
- './Plane'
+ './PixelFormat',
+ './Plane',
+ '../Renderer/ContextLimits',
+ '../Renderer/PixelDatatype',
+ '../Renderer/Sampler',
+ '../Renderer/Texture',
+ '../Renderer/TextureMagnificationFilter',
+ '../Renderer/TextureMinificationFilter',
+ '../Renderer/TextureWrap'
], function(
+ AttributeCompression,
+ Cartesian2,
Cartesian3,
Cartesian4,
+ CesiumMath,
Check,
+ ClippingPlane,
Color,
defaultValue,
defined,
defineProperties,
+ deprecationWarning,
+ destroyObject,
DeveloperError,
FeatureDetection,
Intersect,
Matrix4,
- Plane) {
+ PixelFormat,
+ Plane,
+ ContextLimits,
+ PixelDatatype,
+ Sampler,
+ Texture,
+ TextureMagnificationFilter,
+ TextureMinificationFilter,
+ TextureWrap) {
'use strict';
/**
* Specifies a set of clipping planes. Clipping planes selectively disable rendering in a region on the
- * outside of the specified list of {@link Plane} objects.
+ * outside of the specified list of {@link ClippingPlane} objects for a single gltf model, 3D Tileset, or the globe.
*
* @alias ClippingPlaneCollection
* @constructor
*
* @param {Object} [options] Object with the following properties:
- * @param {Plane[]} [options.planes=[]] An array of up to 6 {@link Plane} objects used to selectively disable rendering on the outside of each plane.
+ * @param {ClippingPlane[]} [options.planes=[]] An array of {@link ClippingPlane} objects used to selectively disable rendering on the outside of each plane.
* @param {Boolean} [options.enabled=true] Determines whether the clipping planes are active.
* @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The 4x4 transformation matrix specifying an additional transform relative to the clipping planes original coordinate system.
* @param {Boolean} [options.unionClippingRegions=false] If true, a region will be clipped if included in any plane in the collection. Otherwise, the region to be clipped must intersect the regions defined by all planes in this collection.
@@ -44,20 +72,26 @@ define([
function ClippingPlaneCollection(options) {
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+ this._planes = [];
+ this._containsUntrackablePlanes = false;
+
+ // Do partial texture updates if just one plane is dirty.
+ // If many planes are dirty, refresh the entire texture.
+ this._dirtyIndex = -1;
+ this._manyDirtyPlanes = false;
+
+ // Add each plane to check if it's actually a Plane object instead of a ClippingPlane.
+ // Use of Plane objects will be deprecated.
var planes = options.planes;
if (defined(planes)) {
- this._planes = planes.slice(0);
- } else {
- this._planes = [];
+ var planesLength = planes.length;
+ for (var i = 0; i < planesLength; ++i) {
+ this.add(planes[i]);
+ }
}
- /**
- * Determines whether the clipping planes are active.
- *
- * @type {Boolean}
- * @default true
- */
- this.enabled = defaultValue(options.enabled, true);
+ this._enabled = false;
+ this.enabled = defaultValue(options.enabled, true); // set using setter
/**
* The 4x4 transformation matrix specifying an additional transform relative to the clipping planes
@@ -84,9 +118,18 @@ define([
*/
this.edgeWidth = defaultValue(options.edgeWidth, 0.0);
+ // If this ClippingPlaneCollection has an owner, only its owner should update or destroy it.
+ // This is because in a Cesium3DTileset multiple models may reference the tileset's ClippingPlaneCollection.
+ this._owner = undefined;
+
this._testIntersection = undefined;
this._unionClippingRegions = undefined;
- this.unionClippingRegions = defaultValue(options.unionClippingRegions, false);
+ this.unionClippingRegions = defaultValue(options.unionClippingRegions, false); // set using setter
+
+ this._uint8View = undefined;
+ this._float32View = undefined;
+
+ this._clippingPlanesTexture = undefined;
}
function unionIntersectFunction(value) {
@@ -126,34 +169,92 @@ define([
return this._unionClippingRegions;
},
set : function(value) {
- if (this._unionClippingRegions !== value) {
- this._unionClippingRegions = value;
- this._testIntersection = value ? unionIntersectFunction : defaultIntersectFunction;
+ if (this._unionClippingRegions === value) {
+ return;
}
+ this._unionClippingRegions = value;
+ this._testIntersection = value ? unionIntersectFunction : defaultIntersectFunction;
+ }
+ },
+
+ /**
+ * If true, clipping will be enabled.
+ *
+ * @memberof ClippingPlaneCollection.prototype
+ * @type {Boolean}
+ * @default false
+ */
+ enabled : {
+ get : function() {
+ return this._enabled;
+ },
+ set : function(value) {
+ if (this._enabled === value) {
+ return;
+ }
+ this._enabled = value;
+ }
+ },
+
+ /**
+ * Returns a texture containing packed, untransformed clipping planes.
+ *
+ * @memberof ClippingPlaneCollection.prototype
+ * @type {Texture}
+ * @readonly
+ * @private
+ */
+ texture : {
+ get : function() {
+ return this._clippingPlanesTexture;
+ }
+ },
+
+ /**
+ * A reference to the ClippingPlaneCollection's owner, if any.
+ *
+ * @memberof ClippingPlaneCollection.prototype
+ * @readonly
+ * @private
+ */
+ owner : {
+ get : function() {
+ return this._owner;
}
}
});
+ function setIndexDirty(collection, index) {
+ // If there's already a different _dirtyIndex set, more than one plane has changed since update.
+ // Entire texture must be reloaded
+ collection._manyDirtyPlanes = collection._manyDirtyPlanes || (collection._dirtyIndex !== -1 && collection._dirtyIndex !== index);
+ collection._dirtyIndex = index;
+ }
+
/**
- * Adds the specified {@link Plane} to the collection to be used to selectively disable rendering
+ * Adds the specified {@link ClippingPlane} to the collection to be used to selectively disable rendering
* on the outside of each plane. Use {@link ClippingPlaneCollection#unionClippingRegions} to modify
* how modify the clipping behavior of multiple planes.
*
- * @param {Plane} plane The plane to add to the collection.
- *
- * @exception {DeveloperError} The plane added exceeds the maximum number of supported clipping planes.
+ * @param {ClippingPlane} plane The ClippingPlane to add to the collection.
*
* @see ClippingPlaneCollection#unionClippingRegions
* @see ClippingPlaneCollection#remove
* @see ClippingPlaneCollection#removeAll
*/
ClippingPlaneCollection.prototype.add = function(plane) {
- //>>includeStart('debug', pragmas.debug);
- if (this.length >= ClippingPlaneCollection.MAX_CLIPPING_PLANES) {
- throw new DeveloperError('The maximum number of clipping planes supported is ' + ClippingPlaneCollection.MAX_CLIPPING_PLANES);
+ var newPlaneIndex = this._planes.length;
+ if (plane instanceof ClippingPlane) {
+ var that = this;
+ plane.onChangeCallback = function(index) {
+ setIndexDirty(that, index);
+ };
+ plane.index = newPlaneIndex;
+ } else {
+ deprecationWarning('ClippingPlaneCollection.add', 'Ability to use Plane objects with ClippingPlaneCollection.add is deprecated and will be removed in Cesium 1.45. Please use ClippingPlane objects instead.');
+ this._containsUntrackablePlanes = true;
}
- //>>includeEnd('debug');
-
+ setIndexDirty(this, newPlaneIndex);
this._planes.push(plane);
};
@@ -165,7 +266,7 @@ define([
* in the collection.
*
* @param {Number} index The zero-based index of the plane.
- * @returns {Plane} The plane at the specified index.
+ * @returns {ClippingPlane} The ClippingPlane at the specified index.
*
* @see ClippingPlaneCollection#length
*/
@@ -189,39 +290,53 @@ define([
}
/**
- * Checks whether this collection contains the given plane.
+ * Checks whether this collection contains a ClippingPlane equal to the given ClippingPlane.
*
- * @param {Plane} [plane] The plane to check for.
- * @returns {Boolean} true if this collection contains the plane, false otherwise.
+ * @param {ClippingPlane} [clippingPlane] The ClippingPlane to check for.
+ * @returns {Boolean} true if this collection contains the ClippingPlane, false otherwise.
*
* @see ClippingPlaneCollection#get
*/
- ClippingPlaneCollection.prototype.contains = function(plane) {
- return indexOf(this._planes, plane) !== -1;
+ ClippingPlaneCollection.prototype.contains = function(clippingPlane) {
+ return indexOf(this._planes, clippingPlane) !== -1;
};
/**
- * Removes the first occurrence of the given plane from the collection.
+ * Removes the first occurrence of the given ClippingPlane from the collection.
*
- * @param {Plane} plane
+ * @param {ClippingPlane} clippingPlane
* @returns {Boolean} true if the plane was removed; false if the plane was not found in the collection.
*
* @see ClippingPlaneCollection#add
* @see ClippingPlaneCollection#contains
* @see ClippingPlaneCollection#removeAll
*/
- ClippingPlaneCollection.prototype.remove = function(plane) {
+ ClippingPlaneCollection.prototype.remove = function(clippingPlane) {
var planes = this._planes;
- var index = indexOf(planes, plane);
+ var index = indexOf(planes, clippingPlane);
if (index === -1) {
return false;
}
+ // Unlink this ClippingPlaneCollection from the ClippingPlane
+ if (clippingPlane instanceof ClippingPlane) {
+ clippingPlane.onChangeCallback = undefined;
+ clippingPlane.index = -1;
+ }
+
+ // Shift and update indices
var length = planes.length - 1;
for (var i = index; i < length; ++i) {
- planes[i] = planes[i + 1];
+ var planeToKeep = planes[i + 1];
+ planes[i] = planeToKeep;
+ if (planeToKeep instanceof ClippingPlane) {
+ planeToKeep.index = i;
+ }
}
+
+ // Indicate planes texture is dirty
+ this._manyDirtyPlanes = true;
planes.length = length;
return true;
@@ -234,53 +349,203 @@ define([
* @see ClippingPlaneCollection#remove
*/
ClippingPlaneCollection.prototype.removeAll = function() {
+ // Dereference this ClippingPlaneCollection from all ClippingPlanes
+ var planes = this._planes;
+ var planesCount = planes.length;
+ for (var i = 0; i < planesCount; ++i) {
+ var plane = planes[i];
+ if (plane instanceof ClippingPlane) {
+ plane.onChangeCallback = undefined;
+ plane.index = -1;
+ }
+ }
+ this._manyDirtyPlanes = true;
this._planes = [];
};
- var scratchPlane = new Plane(Cartesian3.UNIT_X, 0.0);
- var scratchMatrix = new Matrix4();
+ var octEncodeScratch = new Cartesian2();
+ var rightShift = 1.0 / 256.0;
/**
- * Applies the transformations to each plane and packs it into an array.
- * @private
- *
- * @param {Matrix4} viewMatrix The 4x4 matrix to transform the plane into eyespace.
- * @param {Cartesian4[]} [array] The array into which the planes will be packed.
- * @returns {Cartesian4[]} The array of packed planes.
+ * Encodes a normalized vector into 4 SNORM values in the range [0-255] following the 'oct' encoding.
+ * oct32 precision is higher than the default oct16, hence the additional 2 uint16 values.
*/
- ClippingPlaneCollection.prototype.transformAndPackPlanes = function(viewMatrix, array) {
- //>>includeStart('debug', pragmas.debug);
- Check.typeOf.object('viewMatrix', viewMatrix);
- //>>includeEnd('debug');
+ function oct32EncodeNormal(vector, result) {
+ AttributeCompression.octEncodeInRange(vector, 65535, octEncodeScratch);
+ result.x = octEncodeScratch.x * rightShift;
+ result.y = octEncodeScratch.x;
+ result.z = octEncodeScratch.y * rightShift;
+ result.w = octEncodeScratch.y;
+ return result;
+ }
- var planes = this._planes;
- var length = planes.length;
+ var distanceEncodeScratch = new Cartesian4();
+ var oct32EncodeScratch = new Cartesian4();
+ function packPlanesAsUint8(clippingPlaneCollection, startIndex, endIndex) {
+ var uint8View = clippingPlaneCollection._uint8View;
+ var planes = clippingPlaneCollection._planes;
+ var byteIndex = 0;
+ for (var i = startIndex; i < endIndex; ++i) {
+ var plane = planes[i];
- var index = 0;
- if (!defined(array)) {
- array = new Array(length);
- } else {
- index = array.length;
- array.length = length;
- }
+ var oct32Normal = oct32EncodeNormal(plane.normal, oct32EncodeScratch);
+ uint8View[byteIndex] = oct32Normal.x;
+ uint8View[byteIndex + 1] = oct32Normal.y;
+ uint8View[byteIndex + 2] = oct32Normal.z;
+ uint8View[byteIndex + 3] = oct32Normal.w;
- var i;
- for (i = index; i < length; ++i) {
- array[i] = new Cartesian4();
+ var encodedDistance = Cartesian4.packFloat(plane.distance, distanceEncodeScratch);
+ uint8View[byteIndex + 4] = encodedDistance.x;
+ uint8View[byteIndex + 5] = encodedDistance.y;
+ uint8View[byteIndex + 6] = encodedDistance.z;
+ uint8View[byteIndex + 7] = encodedDistance.w;
+
+ byteIndex += 8;
}
+ }
- var transform = Matrix4.multiply(viewMatrix, this.modelMatrix, scratchMatrix);
+ // Pack starting at the beginning of the buffer to allow partial update
+ function packPlanesAsFloats(clippingPlaneCollection, startIndex, endIndex) {
+ var float32View = clippingPlaneCollection._float32View;
+ var planes = clippingPlaneCollection._planes;
- for (i = 0; i < length; ++i) {
+ var floatIndex = 0;
+ for (var i = startIndex; i < endIndex; ++i) {
var plane = planes[i];
- var packedPlane = array[i];
+ var normal = plane.normal;
- Plane.transform(plane, transform, scratchPlane);
+ float32View[floatIndex] = normal.x;
+ float32View[floatIndex + 1] = normal.y;
+ float32View[floatIndex + 2] = normal.z;
+ float32View[floatIndex + 3] = plane.distance;
- Cartesian3.clone(scratchPlane.normal, packedPlane);
- packedPlane.w = scratchPlane.distance;
+ floatIndex += 4; // each plane is 4 floats
}
+ }
+
+ function computeTextureResolution(pixelsNeeded, result) {
+ var maxSize = ContextLimits.maximumTextureSize;
+ var width = Math.min(pixelsNeeded, maxSize);
+ var height = Math.ceil(pixelsNeeded / width);
+ result.x = width;
+ result.y = height;
+ return result;
+ }
- return array;
+ var textureResolutionScratch = new Cartesian2();
+ /**
+ * Called when {@link Viewer} or {@link CesiumWidget} render the scene to
+ * build the resources for clipping planes.
+ * + * Do not call this function directly. + *
+ */ + ClippingPlaneCollection.prototype.update = function(frameState) { + var clippingPlanesTexture = this._clippingPlanesTexture; + var context = frameState.context; + var useFloatTexture = ClippingPlaneCollection.useFloatTexture(context); + + // Compute texture requirements for current planes + // In RGBA FLOAT, A plane is 4 floats packed to a RGBA. + // In RGBA UNSIGNED_BYTE, A plane is a float in [0, 1) packed to RGBA and an Oct32 quantized normal, + // so 8 bits or 2 pixels in RGBA. + var pixelsNeeded = useFloatTexture ? this.length : this.length * 2; + var requiredResolution = computeTextureResolution(pixelsNeeded, textureResolutionScratch); + + if (defined(clippingPlanesTexture)) { + var currentPixelCount = clippingPlanesTexture.width * clippingPlanesTexture.height; + // Recreate the texture if it isn't big enough or is 4 times larger than it needs to be + if (currentPixelCount < pixelsNeeded || + pixelsNeeded < 0.25 * currentPixelCount) { + clippingPlanesTexture.destroy(); + clippingPlanesTexture = undefined; + } + } + + if (!defined(clippingPlanesTexture)) { + // Allocate twice as much space as needed to avoid frequent texture reallocation. + requiredResolution.x *= 2; + + var sampler = new Sampler({ + wrapS : TextureWrap.CLAMP_TO_EDGE, + wrapT : TextureWrap.CLAMP_TO_EDGE, + minificationFilter : TextureMinificationFilter.NEAREST, + magnificationFilter : TextureMagnificationFilter.NEAREST + }); + + if (useFloatTexture) { + clippingPlanesTexture = new Texture({ + context : context, + width : requiredResolution.x, + height : requiredResolution.y, + pixelFormat : PixelFormat.RGBA, + pixelDatatype : PixelDatatype.FLOAT, + sampler : sampler, + flipY : false + }); + this._float32View = new Float32Array(requiredResolution.x * requiredResolution.y * 4); + } else { + clippingPlanesTexture = new Texture({ + context : context, + width : requiredResolution.x, + height : requiredResolution.y, + pixelFormat : PixelFormat.RGBA, + pixelDatatype : PixelDatatype.UNSIGNED_BYTE, + sampler : sampler, + flipY : false + }); + this._uint8View = new Uint8Array(requiredResolution.x * requiredResolution.y * 4); + } + + this._clippingPlanesTexture = clippingPlanesTexture; + this._manyDirtyPlanes = true; + } + + // Use of Plane objects will be deprecated. + // But until then, we have no way of telling if they changed since last frame, so we have to do a full udpate. + var refreshFullTexture = this._manyDirtyPlanes || this._containsUntrackablePlanes; + var dirtyIndex = this._dirtyIndex; + + if (!refreshFullTexture && dirtyIndex === -1) { + return; + } + + if (!refreshFullTexture) { + // partial updates possible + var offsetY = Math.floor(dirtyIndex / clippingPlanesTexture.width); + var offsetX = Math.floor(dirtyIndex - offsetY * clippingPlanesTexture.width); + if (useFloatTexture) { + packPlanesAsFloats(this, dirtyIndex, dirtyIndex + 1); + clippingPlanesTexture.copyFrom({ + width : 1, + height : 1, + arrayBufferView : this._float32View + }, offsetX, offsetY); + } else { + packPlanesAsUint8(this, dirtyIndex, dirtyIndex + 1); + clippingPlanesTexture.copyFrom({ + width : 2, + height : 1, + arrayBufferView : this._uint8View + }, offsetX, offsetY); + } + } else if (useFloatTexture) { + packPlanesAsFloats(this, 0, this._planes.length); + clippingPlanesTexture.copyFrom({ + width : clippingPlanesTexture.width, + height : clippingPlanesTexture.height, + arrayBufferView : this._float32View + }); + } else { + packPlanesAsUint8(this, 0, this._planes.length); + clippingPlanesTexture.copyFrom({ + width : clippingPlanesTexture.width, + height : clippingPlanesTexture.height, + arrayBufferView : this._uint8View + }); + } + + this._manyDirtyPlanes = false; + this._dirtyIndex = -1; }; /** @@ -302,12 +567,17 @@ define([ planes.length = length; for (i = index; i < length; ++i) { - result._planes[i] = new Plane(Cartesian3.UNIT_X, 0.0); + result._planes[i] = new ClippingPlane(Cartesian3.UNIT_X, 0.0); } } for (i = 0; i < length; ++i) { - Plane.clone(this._planes[i], result._planes[i]); + var resultPlane = result._planes[i]; + resultPlane.index = i; + resultPlane.onChangeCallback = function(index) { + setIndexDirty(result, index); + }; + ClippingPlane.clone(this._planes[i], resultPlane); } result.enabled = this.enabled; @@ -319,18 +589,20 @@ define([ return result; }; + var scratchMatrix = new Matrix4(); + var scratchPlane = new Plane(Cartesian3.UNIT_X, 0.0); /** - * Determines the type intersection with the planes of this ClippingPlaneCollection instance and the specified {@link BoundingVolume}. + * Determines the type intersection with the planes of this ClippingPlaneCollection instance and the specified {@link TileBoundingVolume}. * @private * - * @param {Object} boundingVolume The volume to determine the intersection with the planes. + * @param {Object} tileBoundingVolume The volume to determine the intersection with the planes. * @param {Matrix4} [transform] An optional, additional matrix to transform the plane to world coordinates. * @returns {Intersect} {@link Intersect.INSIDE} if the entire volume is on the side of the planes * the normal is pointing and should be entirely rendered, {@link Intersect.OUTSIDE} * if the entire volume is on the opposite side and should be clipped, and * {@link Intersect.INTERSECTING} if the volume intersects the planes. */ - ClippingPlaneCollection.prototype.computeIntersectionWithBoundingVolume = function(boundingVolume, transform) { + ClippingPlaneCollection.prototype.computeIntersectionWithBoundingVolume = function(tileBoundingVolume, transform) { var planes = this._planes; var length = planes.length; @@ -351,9 +623,9 @@ define([ for (var i = 0; i < length; ++i) { var plane = planes[i]; - Plane.transform(plane, modelMatrix, scratchPlane); + Plane.transform(plane, modelMatrix, scratchPlane); // ClippingPlane can be used for Plane math - var value = boundingVolume.intersectPlane(scratchPlane); + var value = tileBoundingVolume.intersectPlane(scratchPlane); if (value === Intersect.INTERSECTING) { intersection = value; } else if (this._testIntersection(value)) { @@ -364,22 +636,104 @@ define([ return intersection; }; + /** + * Returns a Number encapsulating the state for this ClippingPlaneCollection. + * + * Clipping mode is encoded in the sign of the number, which is just the plane count. + * Used for checking if shader regeneration is necessary. + * + * @returns {Number} A Number that describes the ClippingPlaneCollection's state. + * @private + */ + ClippingPlaneCollection.prototype.clippingPlanesState = function() { + return this._unionClippingRegions ? this._planes.length : -this._planes.length; + }; + + /** + * Sets the owner for the input ClippingPlaneCollection if there wasn't another owner. + * Destroys the owner's previous ClippingPlaneCollection if setting is successful. + * + * @param {ClippingPlaneCollection} [clippingPlaneCollection] A ClippingPlaneCollection (or undefined) being attached to an object + * @param {Object} owner An Object that should receive the new ClippingPlaneCollection + * @param {String} key The Key for the Object to reference the ClippingPlaneCollection + * @private + */ + ClippingPlaneCollection.setOwnership = function(clippingPlaneCollection, owner, key) { + // Don't destroy the ClippingPlaneCollection if it is already owned by newOwner + if (clippingPlaneCollection === owner[key]) { + return; + } + // Destroy the existing ClippingPlaneCollection, if any + owner[key] = owner[key] && owner[key].destroy(); + if (defined(clippingPlaneCollection)) { + //>>includeStart('debug', pragmas.debug); + if (defined(clippingPlaneCollection._owner)) { + throw new DeveloperError('ClippingPlaneCollection should only be assigned to one object'); + } + //>>includeEnd('debug'); + clippingPlaneCollection._owner = owner; + owner[key] = clippingPlaneCollection; + } + }; + /** * Determines if rendering with clipping planes is supported. * - * @returns {Boolean}true if ClippingPlaneCollections are supported; otherwise, returns false
+ * @returns {Boolean} true if ClippingPlaneCollections are supported
+ * @deprecated
*/
ClippingPlaneCollection.isSupported = function() {
- return !FeatureDetection.isInternetExplorer();
+ deprecationWarning('ClippingPlaneCollection.isSupported', 'ClippingPlaneCollection.isSupported is deprecated and will be removed in Cesium 1.45. Clipping Planes are now supported on all platforms capable of running Cesium.');
+ return true;
+ };
+
+ /**
+ * Function for checking if the context will allow clipping planes with floating point textures.
+ *
+ * @param {Context} context The Context that will contain clipped objects and clipping textures.
+ * @returns {Boolean} true if floating point textures can be used for clipping planes.
+ * @private
+ */
+ ClippingPlaneCollection.useFloatTexture = function(context) {
+ return context.floatingPointTexture;
+ };
+
+ /**
+ * Returns true if this object was destroyed; otherwise, false.
+ * isDestroyed will result in a {@link DeveloperError} exception.
+ *
+ * @returns {Boolean} true if this object was destroyed; otherwise, false.
+ *
+ * @see ClippingPlaneCollection#destroy
+ */
+ ClippingPlaneCollection.prototype.isDestroyed = function() {
+ return false;
};
/**
- * The maximum number of supported clipping planes.
+ * Destroys the WebGL resources held by this object. Destroying an object allows for deterministic
+ * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+ * isDestroyed will result in a {@link DeveloperError} exception. Therefore,
+ * assign the return value (undefined) to the object as done in the example.
+ *
+ * @returns {undefined}
*
- * @type {number}
- * @constant
+ * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+ *
+ *
+ * @example
+ * clippingPlanes = clippingPlanes && clippingPlanes .destroy();
+ *
+ * @see ClippingPlaneCollection#isDestroyed
*/
- ClippingPlaneCollection.MAX_CLIPPING_PLANES = 6;
+ ClippingPlaneCollection.prototype.destroy = function() {
+ this._clippingPlanesTexture = this._clippingPlanesTexture && this._clippingPlanesTexture.destroy();
+ return destroyObject(this);
+ };
return ClippingPlaneCollection;
});
diff --git a/Source/DataSources/ModelGraphics.js b/Source/DataSources/ModelGraphics.js
index 5dedd97c6f94..1b6c77f82b32 100644
--- a/Source/DataSources/ModelGraphics.js
+++ b/Source/DataSources/ModelGraphics.js
@@ -55,7 +55,7 @@ define([
* @param {Property} [options.color=Color.WHITE] A Property specifying the {@link Color} that blends with the model's rendered color.
* @param {Property} [options.colorBlendMode=ColorBlendMode.HIGHLIGHT] An enum Property specifying how the color blends with the model.
* @param {Property} [options.colorBlendAmount=0.5] A numeric Property specifying the color strength when the colorBlendMode is MIX. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
- * @param {Property} [options.clippingPlanes] A property specifying the {@link ClippingPlaneCollection} used to selectively disable rendering the model. Clipping planes are not currently supported in Internet Explorer.
+ * @param {Property} [options.clippingPlanes] A property specifying the {@link ClippingPlaneCollection} used to selectively disable rendering the model.
*
* @see {@link https://cesiumjs.org/tutorials/3D-Models-Tutorial/|3D Models Tutorial}
* @demo {@link https://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=3D%20Models.html|Cesium Sandcastle 3D Models Demo}
diff --git a/Source/DataSources/ModelVisualizer.js b/Source/DataSources/ModelVisualizer.js
index 68779e161e51..37954219c7a2 100644
--- a/Source/DataSources/ModelVisualizer.js
+++ b/Source/DataSources/ModelVisualizer.js
@@ -126,9 +126,6 @@ define([
incrementallyLoadTextures : Property.getValueOrDefault(modelGraphics._incrementallyLoadTextures, time, defaultIncrementallyLoadTextures),
scene : this._scene
});
-
- model.readyPromise.otherwise(onModelError);
-
model.id = entity;
primitives.add(model);
@@ -137,9 +134,12 @@ define([
url : resource.url,
animationsRunning : false,
nodeTransformationsScratch : {},
- originalNodeMatrixHash : {}
+ originalNodeMatrixHash : {},
+ loadFail : false
};
modelHash[entity.id] = modelData;
+
+ checkModelLoad(model, entity, modelHash);
}
model.show = true;
@@ -250,7 +250,7 @@ define([
//>>includeEnd('debug');
var modelData = this._modelHash[entity.id];
- if (!defined(modelData)) {
+ if (!defined(modelData) || modelData.loadFail) {
return BoundingSphereState.FAILED;
}
@@ -324,8 +324,11 @@ define([
}
}
- function onModelError(error) {
- console.error(error);
+ function checkModelLoad(model, entity, modelHash){
+ model.readyPromise.otherwise(function(error){
+ console.error(error);
+ modelHash[entity.id].loadFail = true;
+ });
}
return ModelVisualizer;
diff --git a/Source/Renderer/AutomaticUniforms.js b/Source/Renderer/AutomaticUniforms.js
index 82c0b64ad9fd..1556c5b2ad9c 100644
--- a/Source/Renderer/AutomaticUniforms.js
+++ b/Source/Renderer/AutomaticUniforms.js
@@ -912,6 +912,20 @@ define([
}
}),
+ /**
+ * An automatic GLSL uniform that indicates if the current camera is orthographic in 3D.
+ *
+ * @alias czm_orthographicIn3D
+ * @see UniformState#orthographicIn3D
+ */
+ czm_orthographicIn3D : new AutomaticUniform({
+ size : 1,
+ datatype : WebGLConstants.FLOAT,
+ getValue : function(uniformState) {
+ return uniformState.orthographicIn3D ? 1 : 0;
+ }
+ }),
+
/**
* An automatic GLSL uniform representing a 3x3 normal transformation matrix that
* transforms normal vectors in model coordinates to eye coordinates.
diff --git a/Source/Renderer/UniformState.js b/Source/Renderer/UniformState.js
index 27ced786160e..7c9194b3ce6d 100644
--- a/Source/Renderer/UniformState.js
+++ b/Source/Renderer/UniformState.js
@@ -873,6 +873,18 @@ define([
get : function() {
return this._invertClassificationColor;
}
+ },
+
+ /**
+ * Whether or not the current projection is orthographic in 3D.
+ *
+ * @memberOf UniformState.prototype
+ * @type {Boolean}
+ */
+ orthographicIn3D : {
+ get : function() {
+ return this._orthographicIn3D;
+ }
}
});
diff --git a/Source/Scene/BatchTable.js b/Source/Scene/BatchTable.js
index e32799823b04..bbe799c529c9 100644
--- a/Source/Scene/BatchTable.js
+++ b/Source/Scene/BatchTable.js
@@ -16,7 +16,8 @@ define([
'../Renderer/Sampler',
'../Renderer/Texture',
'../Renderer/TextureMagnificationFilter',
- '../Renderer/TextureMinificationFilter'
+ '../Renderer/TextureMinificationFilter',
+ './getUnpackFloatFunction'
], function(
Cartesian2,
Cartesian3,
@@ -35,7 +36,8 @@ define([
Sampler,
Texture,
TextureMagnificationFilter,
- TextureMinificationFilter) {
+ TextureMinificationFilter,
+ getUnpackFloatFunction) {
'use strict';
/**
@@ -226,48 +228,18 @@ define([
var scratchPackedFloatCartesian4 = new Cartesian4();
- var SHIFT_LEFT_8 = 256.0;
- var SHIFT_LEFT_16 = 65536.0;
- var SHIFT_LEFT_24 = 16777216.0;
-
- var SHIFT_RIGHT_8 = 1.0 / SHIFT_LEFT_8;
- var SHIFT_RIGHT_16 = 1.0 / SHIFT_LEFT_16;
- var SHIFT_RIGHT_24 = 1.0 / SHIFT_LEFT_24;
-
- var BIAS = 38.0;
-
- function unpackFloat(value) {
- var temp = value.w / 2.0;
- var exponent = Math.floor(temp);
- var sign = (temp - exponent) * 2.0;
- exponent = exponent - BIAS;
-
- sign = sign * 2.0 - 1.0;
- sign = -sign;
-
- if (exponent >= BIAS) {
- return sign < 0.0 ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
- }
-
- var unpacked = sign * value.x * SHIFT_RIGHT_8;
- unpacked += sign * value.y * SHIFT_RIGHT_16;
- unpacked += sign * value.z * SHIFT_RIGHT_24;
-
- return unpacked * Math.pow(10.0, exponent);
- }
-
function getPackedFloat(array, index, result) {
var packed = Cartesian4.unpack(array, index, scratchPackedFloatCartesian4);
- var x = unpackFloat(packed);
+ var x = Cartesian4.unpackFloat(packed);
packed = Cartesian4.unpack(array, index + 4, scratchPackedFloatCartesian4);
- var y = unpackFloat(packed);
+ var y = Cartesian4.unpackFloat(packed);
packed = Cartesian4.unpack(array, index + 8, scratchPackedFloatCartesian4);
- var z = unpackFloat(packed);
+ var z = Cartesian4.unpackFloat(packed);
packed = Cartesian4.unpack(array, index + 12, scratchPackedFloatCartesian4);
- var w = unpackFloat(packed);
+ var w = Cartesian4.unpackFloat(packed);
return Cartesian4.fromElements(x, y, z, w, result);
}
@@ -275,50 +247,18 @@ define([
if (!FeatureDetection.supportsTypedArrays()) {
return;
}
- var scratchFloatArray = new Float32Array(1);
-
- function packFloat(value, result) {
- scratchFloatArray[0] = value;
- value = scratchFloatArray[0];
-
- if (value === 0.0) {
- return Cartesian4.clone(Cartesian4.ZERO, result);
- }
-
- var sign = value < 0.0 ? 1.0 : 0.0;
- var exponent;
-
- if (!isFinite(value)) {
- value = 0.1;
- exponent = BIAS;
- } else {
- value = Math.abs(value);
- exponent = Math.floor(CesiumMath.logBase(value, 10)) + 1.0;
- value = value / Math.pow(10.0, exponent);
- }
-
- var temp = value * SHIFT_LEFT_8;
- result.x = Math.floor(temp);
- temp = (temp - result.x) * SHIFT_LEFT_8;
- result.y = Math.floor(temp);
- temp = (temp - result.y) * SHIFT_LEFT_8;
- result.z = Math.floor(temp);
- result.w = (exponent + BIAS) * 2.0 + sign;
-
- return result;
- }
function setPackedAttribute(value, array, index) {
- var packed = packFloat(value.x, scratchPackedFloatCartesian4);
+ var packed = Cartesian4.packFloat(value.x, scratchPackedFloatCartesian4);
Cartesian4.pack(packed, array, index);
- packed = packFloat(value.y, packed);
+ packed = Cartesian4.packFloat(value.y, packed);
Cartesian4.pack(packed, array, index + 4);
- packed = packFloat(value.z, packed);
+ packed = Cartesian4.packFloat(value.z, packed);
Cartesian4.pack(packed, array, index + 8);
- packed = packFloat(value.w, packed);
+ packed = Cartesian4.packFloat(value.w, packed);
Cartesian4.pack(packed, array, index + 12);
}
@@ -527,20 +467,7 @@ define([
return '';
}
- return 'float unpackFloat(vec4 value) \n' +
- '{ \n' +
- ' value *= 255.0; \n' +
- ' float temp = value.w / 2.0; \n' +
- ' float exponent = floor(temp); \n' +
- ' float sign = (temp - exponent) * 2.0; \n' +
- ' exponent = exponent - float(' + BIAS + '); \n' +
- ' sign = sign * 2.0 - 1.0; \n' +
- ' sign = -sign; \n' +
- ' float unpacked = sign * value.x * float(' + SHIFT_RIGHT_8 + '); \n' +
- ' unpacked += sign * value.y * float(' + SHIFT_RIGHT_16 + '); \n' +
- ' unpacked += sign * value.z * float(' + SHIFT_RIGHT_24 + '); \n' +
- ' return unpacked * pow(10.0, exponent); \n' +
- '} \n';
+ return getUnpackFloatFunction('unpackFloat');
}
function getComponentType(componentsPerAttribute) {
diff --git a/Source/Scene/Batched3DModel3DTileContent.js b/Source/Scene/Batched3DModel3DTileContent.js
index 5ecb891e1a73..2f6f2a350dd0 100644
--- a/Source/Scene/Batched3DModel3DTileContent.js
+++ b/Source/Scene/Batched3DModel3DTileContent.js
@@ -1,5 +1,4 @@
define([
- '../Core/ClippingPlaneCollection',
'../Core/Color',
'../Core/defaultValue',
'../Core/defined',
@@ -20,7 +19,6 @@ define([
'./Model',
'./ModelUtility'
], function(
- ClippingPlaneCollection,
Color,
defaultValue,
defined,
@@ -69,6 +67,10 @@ define([
this._batchTable = undefined;
this._features = undefined;
+ // Populate from gltf when available
+ this._batchIdAttributeName = undefined;
+ this._diffuseAttributeOrUniformName = {};
+
/**
* @inheritdoc Cesium3DTileContent#featurePropertiesDirty
*/
@@ -206,11 +208,15 @@ define([
function getVertexShaderCallback(content) {
return function(vs, programId) {
var batchTable = content._batchTable;
- var gltf = content._model.gltf;
var handleTranslucent = !defined(content._tileset.classificationType);
- var batchIdAttributeName = getBatchIdAttributeName(gltf);
- var diffuseAttributeOrUniformName = ModelUtility.getDiffuseAttributeOrUniform(gltf, programId);
- var callback = batchTable.getVertexShaderCallback(handleTranslucent, batchIdAttributeName, diffuseAttributeOrUniformName);
+
+ var gltf = content._model.gltf;
+ if (defined(gltf)) {
+ content._batchIdAttributeName = getBatchIdAttributeName(gltf);
+ content._diffuseAttributeOrUniformName[programId] = ModelUtility.getDiffuseAttributeOrUniform(gltf, programId);
+ }
+
+ var callback = batchTable.getVertexShaderCallback(handleTranslucent, content._batchIdAttributeName, content._diffuseAttributeOrUniformName[programId]);
return defined(callback) ? callback(vs) : vs;
};
}
@@ -218,9 +224,13 @@ define([
function getPickVertexShaderCallback(content) {
return function(vs) {
var batchTable = content._batchTable;
+
var gltf = content._model.gltf;
- var batchIdAttributeName = getBatchIdAttributeName(gltf);
- var callback = batchTable.getPickVertexShaderCallback(batchIdAttributeName);
+ if (defined(gltf)) {
+ content._batchIdAttributeName = getBatchIdAttributeName(gltf);
+ }
+
+ var callback = batchTable.getPickVertexShaderCallback(content._batchIdAttributeName);
return defined(callback) ? callback(vs) : vs;
};
}
@@ -228,10 +238,13 @@ define([
function getFragmentShaderCallback(content) {
return function(fs, programId) {
var batchTable = content._batchTable;
- var gltf = content._model.gltf;
var handleTranslucent = !defined(content._tileset.classificationType);
- var diffuseAttributeOrUniformName = ModelUtility.getDiffuseAttributeOrUniform(gltf, programId);
- var callback = batchTable.getFragmentShaderCallback(handleTranslucent, diffuseAttributeOrUniformName);
+
+ var gltf = content._model.gltf;
+ if (defined(gltf)) {
+ content._diffuseAttributeOrUniformName[programId] = ModelUtility.getDiffuseAttributeOrUniform(gltf, programId);
+ }
+ var callback = batchTable.getFragmentShaderCallback(handleTranslucent, content._diffuseAttributeOrUniformName[programId]);
return defined(callback) ? callback(fs) : fs;
};
}
@@ -379,15 +392,6 @@ define([
};
if (!defined(tileset.classificationType)) {
- var clippingPlanes;
- if (defined(tileset.clippingPlanes)) {
- clippingPlanes = tileset.clippingPlanes.clone();
- } else {
- clippingPlanes = new ClippingPlaneCollection({
- enabled : false
- });
- }
-
// PERFORMANCE_IDEA: patch the shader on demand, e.g., the first time show/color changes.
// The pick shader still needs to be patched.
content._model = new Model({
@@ -409,8 +413,7 @@ define([
pickFragmentShaderLoaded : batchTable.getPickFragmentShaderCallback(),
pickUniformMapLoaded : batchTable.getPickUniformMapCallback(),
addBatchIdToGeneratedShaders : (batchLength > 0), // If the batch table has values in it, generated shaders will need a batchId attribute
- pickObject : pickObject,
- clippingPlanes : clippingPlanes
+ pickObject : pickObject
});
} else {
// This transcodes glTF to an internal representation for geometry so we can take advantage of the re-batching of vector data.
@@ -503,12 +506,11 @@ define([
// Update clipping planes
var tilesetClippingPlanes = this._tileset.clippingPlanes;
- var modelClippingPlanes = this._model.clippingPlanes;
- if (defined(tilesetClippingPlanes)) {
- tilesetClippingPlanes.clone(modelClippingPlanes);
- modelClippingPlanes.enabled = tilesetClippingPlanes.enabled && this._tile._isClipped;
- } else if (defined(modelClippingPlanes) && modelClippingPlanes.enabled) {
- modelClippingPlanes.enabled = false;
+ if (this._tile.clippingPlanesDirty && defined(tilesetClippingPlanes)) {
+ // Dereference the clipping planes from the model if they are irrelevant.
+ // Link/Dereference directly to avoid ownership checks.
+ // This will also trigger synchronous shader regeneration to remove or add the clipping plane and color blending code.
+ this._model._clippingPlanes = (tilesetClippingPlanes.enabled && this._tile._isClipped) ? tilesetClippingPlanes : undefined;
}
this._model.update(frameState);
diff --git a/Source/Scene/Cesium3DTile.js b/Source/Scene/Cesium3DTile.js
index 5ffb0114e887..e386a997586b 100644
--- a/Source/Scene/Cesium3DTile.js
+++ b/Source/Scene/Cesium3DTile.js
@@ -310,6 +310,16 @@ define([
*/
this._optimChildrenWithinParent = Cesium3DTileOptimizationHint.NOT_COMPUTED;
+ /**
+ * Tracks if the tile's relationship with a ClippingPlaneCollection has changed with regards
+ * to the ClippingPlaneCollection's state.
+ *
+ * @type {Boolean}
+ *
+ * @private
+ */
+ this.clippingPlanesDirty = false;
+
// Members that are updated every frame for tree traversal and rendering optimizations:
this._distanceToCamera = 0;
this._visibilityPlaneMask = 0;
@@ -329,6 +339,7 @@ define([
this._ancestorWithContent = undefined;
this._ancestorWithLoadedContent = undefined;
this._isClipped = true;
+ this._clippingPlanesState = 0; // encapsulates (_isClipped, clippingPlanes.enabled) and number/function
this._debugBoundingVolume = undefined;
this._debugContentBoundingVolume = undefined;
@@ -1048,6 +1059,23 @@ define([
content.update(tileset, frameState);
}
+ function updateClippingPlanes(tile, tileset) {
+ // Compute and compare ClippingPlanes state:
+ // - enabled-ness - are clipping planes enabled? is this tile clipped?
+ // - clipping plane count
+ // - clipping function (union v. intersection)
+ var clippingPlanes = tileset.clippingPlanes;
+ var currentClippingPlanesState = 0;
+ if (defined(clippingPlanes) && tile._isClipped && clippingPlanes.enabled) {
+ currentClippingPlanesState = clippingPlanes.clippingPlanesState();
+ }
+ // If clippingPlaneState for tile changed, mark clippingPlanesDirty so content can update
+ if (currentClippingPlanesState !== tile._clippingPlanesState) {
+ tile._clippingPlanesState = currentClippingPlanesState;
+ tile.clippingPlanesDirty = true;
+ }
+ }
+
/**
* Get the draw commands needed to render this tile.
*
@@ -1055,9 +1083,12 @@ define([
*/
Cesium3DTile.prototype.update = function(tileset, frameState) {
var initCommandLength = frameState.commandList.length;
+ updateClippingPlanes(this, tileset);
applyDebugSettings(this, tileset, frameState);
updateContent(this, tileset, frameState);
this._commandsLength = frameState.commandList.length - initCommandLength;
+
+ this.clippingPlanesDirty = false; // reset after content update
};
var scratchCommandList = [];
diff --git a/Source/Scene/Cesium3DTileBatchTable.js b/Source/Scene/Cesium3DTileBatchTable.js
index 528e2d7caaae..be54a96ac99c 100644
--- a/Source/Scene/Cesium3DTileBatchTable.js
+++ b/Source/Scene/Cesium3DTileBatchTable.js
@@ -1331,10 +1331,12 @@ define([
for (var i = commandStart; i < commandEnd; ++i) {
var command = commandList[i];
var derivedCommands = command.derivedCommands.tileset;
- if (!defined(derivedCommands)) {
+ // Command may be marked dirty from Model shader recompilation for clipping planes
+ if (!defined(derivedCommands) || command.dirty) {
derivedCommands = {};
command.derivedCommands.tileset = derivedCommands;
derivedCommands.originalCommand = deriveCommand(command);
+ command.dirty = false;
}
updateDerivedCommand(derivedCommands.originalCommand, command);
diff --git a/Source/Scene/Cesium3DTileset.js b/Source/Scene/Cesium3DTileset.js
index 699fc5d41595..ddfbdcab4d21 100644
--- a/Source/Scene/Cesium3DTileset.js
+++ b/Source/Scene/Cesium3DTileset.js
@@ -3,6 +3,7 @@ define([
'../Core/Cartesian3',
'../Core/Cartographic',
'../Core/Check',
+ '../Core/ClippingPlaneCollection',
'../Core/defaultValue',
'../Core/defined',
'../Core/defineProperties',
@@ -46,6 +47,7 @@ define([
Cartesian3,
Cartographic,
Check,
+ ClippingPlaneCollection,
defaultValue,
defined,
defineProperties,
@@ -111,7 +113,7 @@ define([
* @param {Number} [options.skipLevels=1] When skipLevelOfDetail is true, a constant defining the minimum number of levels to skip when loading tiles. When it is 0, no levels are skipped. Used in conjunction with skipScreenSpaceErrorFactor to determine which tiles to load.
* @param {Boolean} [options.immediatelyLoadDesiredLevelOfDetail=false] When skipLevelOfDetail is true, only tiles that meet the maximum screen space error will ever be downloaded. Skipping factors are ignored and just the desired tiles are loaded.
* @param {Boolean} [options.loadSiblings=false] When skipLevelOfDetail is true, determines whether siblings of visible tiles are always downloaded during traversal.
- * @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset. Clipping planes are not currently supported in Internet Explorer.
+ * @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
* @param {ClassificationType} [options.classificationType] Determines whether terrain, 3D Tiles or both will be classified by this tileset. See {@link Cesium3DTileset#classificationType} for details about restrictions and limitations.
* @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid determining the size and shape of the globe.
* @param {Boolean} [options.debugFreezeFrame=false] For debugging only. Determines if only the tiles from last frame should be used for rendering.
@@ -547,11 +549,7 @@ define([
*/
this.loadSiblings = defaultValue(options.loadSiblings, false);
- /**
- * The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset. Clipping planes are not currently supported in Internet Explorer.
- *
- * @type {ClippingPlaneCollection}
- */
+ this._clippingPlanes = undefined;
this.clippingPlanes = options.clippingPlanes;
/**
@@ -814,6 +812,19 @@ define([
return this._asset;
}
},
+ /**
+ * The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
+ *
+ * @type {ClippingPlaneCollection}
+ */
+ clippingPlanes : {
+ get : function() {
+ return this._clippingPlanes;
+ },
+ set : function(value) {
+ ClippingPlaneCollection.setOwnership(value, this, '_clippingPlanes');
+ }
+ },
/**
* Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.
@@ -1846,6 +1857,12 @@ define([
this._loadTimestamp = JulianDate.clone(frameState.time);
}
+ // Update clipping planes
+ var clippingPlanes = this._clippingPlanes;
+ if (defined(clippingPlanes) && clippingPlanes.enabled) {
+ clippingPlanes.update(frameState);
+ }
+
this._timeSinceLoad = Math.max(JulianDate.secondsDifference(frameState.time, this._loadTimestamp) * 1000, 0.0);
this._skipLevelOfDetail = this.skipLevelOfDetail && !defined(this._classificationType) && !this._disableSkipLevelOfDetail;
@@ -1930,6 +1947,9 @@ define([
// Destroy debug labels
this._tileDebugLabels = this._tileDebugLabels && this._tileDebugLabels.destroy();
+ // Destroy clipping plane collection
+ this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
+
// Traverse the tree and destroy all tiles
if (defined(this._root)) {
var stack = scratchStack;
diff --git a/Source/Scene/ClassificationType.js b/Source/Scene/ClassificationType.js
index 4d5f4f403965..2b92bb5f9d75 100644
--- a/Source/Scene/ClassificationType.js
+++ b/Source/Scene/ClassificationType.js
@@ -7,7 +7,7 @@ define([
/**
* Whether a classification affects terrain, 3D Tiles or both.
*
- * @exports ClassificationOption
+ * @exports ClassificationType
*/
var ClassificationType = {
/**
diff --git a/Source/Scene/DracoLoader.js b/Source/Scene/DracoLoader.js
new file mode 100644
index 000000000000..4821e4dc511c
--- /dev/null
+++ b/Source/Scene/DracoLoader.js
@@ -0,0 +1,197 @@
+define([
+ '../Core/arraySlice',
+ '../Core/ComponentDatatype',
+ '../Core/defined',
+ '../Core/FeatureDetection',
+ '../Core/TaskProcessor',
+ '../Renderer/Buffer',
+ '../Renderer/BufferUsage',
+ '../ThirdParty/GltfPipeline/ForEach',
+ '../ThirdParty/when'
+ ], function(
+ arraySlice,
+ ComponentDatatype,
+ defined,
+ FeatureDetection,
+ TaskProcessor,
+ Buffer,
+ BufferUsage,
+ ForEach,
+ when) {
+ 'use strict';
+
+ /**
+ * @private
+ */
+ function DracoLoader() {}
+
+ // Maximum concurrency to use when deocding draco models
+ DracoLoader._maxDecodingConcurrency = Math.max(FeatureDetection.hardwareConcurrency - 1, 1);
+
+ // Exposed for testing purposes
+ DracoLoader._decoderTaskProcessor = undefined;
+ DracoLoader._getDecoderTaskProcessor = function () {
+ if (!defined(DracoLoader._decoderTaskProcessor)) {
+ DracoLoader._decoderTaskProcessor = new TaskProcessor('decodeDraco', DracoLoader._maxDecodingConcurrency);
+ }
+
+ return DracoLoader._decoderTaskProcessor;
+ };
+
+ function hasExtension(model) {
+ return (defined(model.extensionsRequired.KHR_draco_mesh_compression)
+ || defined(model.extensionsUsed.KHR_draco_mesh_compression));
+ }
+
+ function addBufferToModelResources(model, buffer) {
+ var resourceBuffers = model._rendererResources.buffers;
+ var bufferViewId = Object.keys(resourceBuffers).length;
+ resourceBuffers[bufferViewId] = buffer;
+ model._geometryByteLength += buffer.sizeInBytes;
+
+ return bufferViewId;
+ }
+
+ function addNewVertexBuffer(typedArray, model, context) {
+ var vertexBuffer = Buffer.createVertexBuffer({
+ context : context,
+ typedArray : typedArray,
+ usage : BufferUsage.STATIC_DRAW
+ });
+ vertexBuffer.vertexArrayDestroyable = false;
+
+ return addBufferToModelResources(model, vertexBuffer);
+ }
+
+ function addNewIndexBuffer(typedArray, model, context) {
+ var indexBuffer = Buffer.createIndexBuffer({
+ context : context,
+ typedArray : typedArray,
+ usage : BufferUsage.STATIC_DRAW,
+ indexDatatype : ComponentDatatype.fromTypedArray(typedArray)
+ });
+ indexBuffer.vertexArrayDestroyable = false;
+
+ var bufferViewId = addBufferToModelResources(model, indexBuffer);
+ return {
+ bufferViewId: bufferViewId,
+ numberOfIndices : indexBuffer.numberOfIndices
+ };
+ }
+
+ function addDecodededBuffers(primitive, model, context) {
+ return function (result) {
+ var decodedIndexBuffer = addNewIndexBuffer(result.indexArray, model, context);
+
+ var attributes = {};
+ var decodedAttributeData = result.attributeData;
+ for (var attributeName in decodedAttributeData) {
+ if (decodedAttributeData.hasOwnProperty(attributeName)) {
+ var attribute = decodedAttributeData[attributeName];
+ var vertexArray = attribute.array;
+ var vertexBufferView = addNewVertexBuffer(vertexArray, model, context);
+
+ var data = attribute.data;
+ data.bufferView = vertexBufferView;
+
+ attributes[attributeName] = data;
+ }
+ }
+
+ model._decodedData[primitive.mesh + '.primitive.' + primitive.primitive] = {
+ bufferView : decodedIndexBuffer.bufferViewId,
+ numberOfIndices : decodedIndexBuffer.numberOfIndices,
+ attributes : attributes
+ };
+ };
+ }
+
+ function scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context) {
+ var taskData = loadResources.primitivesToDecode.peek();
+ if (!defined(taskData)) {
+ // All primitives are processing
+ return;
+ }
+
+ var promise = decoderTaskProcessor.scheduleTask(taskData, [taskData.array.buffer]);
+ if (!defined(promise)) {
+ // Cannot schedule another task this frame
+ return;
+ }
+
+ loadResources.primitivesToDecode.dequeue();
+ return promise.then(addDecodededBuffers(taskData, model, context));
+ }
+
+ /**
+ * Parses draco extension on model primitives and
+ * adds the decoding data to the model's load resources.
+ *
+ * @private
+ */
+ DracoLoader.parse = function(model) {
+ if (!hasExtension(model)) {
+ return;
+ }
+
+ var loadResources = model._loadResources;
+ loadResources.decoding = true;
+
+ var gltf = model.gltf;
+ ForEach.mesh(gltf, function(mesh, meshId) {
+ ForEach.meshPrimitive(mesh, function(primitive, primitiveId) {
+ if (!defined(primitive.extensions)) {
+ return;
+ }
+
+ var compressionData = primitive.extensions.KHR_draco_mesh_compression;
+ if (!defined(compressionData)) {
+ return;
+ }
+
+ var bufferView = gltf.bufferViews[compressionData.bufferView];
+ var typedArray = arraySlice(gltf.buffers[bufferView.buffer].extras._pipeline.source, bufferView.byteOffset, bufferView.byteOffset + bufferView.byteLength);
+
+ loadResources.primitivesToDecode.enqueue({
+ mesh : meshId,
+ primitive : primitiveId,
+ array : typedArray,
+ bufferView : bufferView,
+ compressedAttributes : compressionData.attributes
+ });
+ });
+ });
+ };
+
+ /**
+ * Schedules decoding tasks available this frame.
+ * @private
+ */
+ DracoLoader.decode = function(model, context) {
+ if (!hasExtension(model)) {
+ return when.resolve();
+ }
+
+ var loadResources = model._loadResources;
+ if (loadResources.primitivesToDecode.length === 0) {
+ // No more tasks to schedule
+ return when.resolve();
+ }
+
+ var decoderTaskProcessor = DracoLoader._getDecoderTaskProcessor();
+ var decodingPromises = [];
+
+ var promise = scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context);
+ while (defined(promise)) {
+ decodingPromises.push(promise);
+ promise = scheduleDecodingTask(decoderTaskProcessor, model, loadResources, context);
+ }
+
+ return when.all(decodingPromises).then(function () {
+ // Done decoding when there are no more active tasks
+ loadResources.decoding = (decoderTaskProcessor._activeTasks !== 0);
+ });
+ };
+
+ return DracoLoader;
+});
diff --git a/Source/Scene/Globe.js b/Source/Scene/Globe.js
index 343295c50c1d..5d391dbebf31 100644
--- a/Source/Scene/Globe.js
+++ b/Source/Scene/Globe.js
@@ -266,7 +266,7 @@ define([
}
},
/**
- * A property specifying a {@link ClippingPlaneCollection} used to selectively disable rendering on the outside of each plane. Clipping planes are not currently supported in Internet Explorer.
+ * A property specifying a {@link ClippingPlaneCollection} used to selectively disable rendering on the outside of each plane.
*
* @memberof Globe.prototype
* @type {ClippingPlaneCollection}
diff --git a/Source/Scene/GlobeSurfaceShaderSet.js b/Source/Scene/GlobeSurfaceShaderSet.js
index c46fe650b6bf..85c775b1c00c 100644
--- a/Source/Scene/GlobeSurfaceShaderSet.js
+++ b/Source/Scene/GlobeSurfaceShaderSet.js
@@ -1,22 +1,27 @@
define([
+ '../Core/ClippingPlaneCollection',
'../Core/defined',
'../Core/destroyObject',
'../Core/TerrainQuantization',
'../Renderer/ShaderProgram',
- '../Scene/SceneMode'
+ '../Scene/SceneMode',
+ './getClippingFunction'
], function(
+ ClippingPlaneCollection,
defined,
destroyObject,
TerrainQuantization,
ShaderProgram,
- SceneMode) {
+ SceneMode,
+ getClippingFunction) {
'use strict';
- function GlobeSurfaceShader(numberOfDayTextures, flags, material, shaderProgram) {
+ function GlobeSurfaceShader(numberOfDayTextures, flags, material, shaderProgram, clippingShaderState) {
this.numberOfDayTextures = numberOfDayTextures;
this.flags = flags;
this.material = material;
this.shaderProgram = shaderProgram;
+ this.clippingShaderState = clippingShaderState;
}
/**
@@ -64,7 +69,7 @@ define([
return useWebMercatorProjection ? get2DYPositionFractionMercatorProjection : get2DYPositionFractionGeographicProjection;
}
- GlobeSurfaceShaderSet.prototype.getShaderProgram = function(frameState, surfaceTile, numberOfDayTextures, applyBrightness, applyContrast, applyHue, applySaturation, applyGamma, applyAlpha, applySplit, showReflectiveOcean, showOceanWaves, enableLighting, hasVertexNormals, useWebMercatorProjection, enableFog, enableClippingPlanes, unionClippingRegions) {
+ GlobeSurfaceShaderSet.prototype.getShaderProgram = function(frameState, surfaceTile, numberOfDayTextures, applyBrightness, applyContrast, applyHue, applySaturation, applyGamma, applyAlpha, applySplit, showReflectiveOcean, showOceanWaves, enableLighting, hasVertexNormals, useWebMercatorProjection, enableFog, enableClippingPlanes, clippingPlanes) {
var quantization = 0;
var quantizationDefine = '';
@@ -93,27 +98,36 @@ define([
(applySplit << 15) |
(enableClippingPlanes << 16);
+ var currentClippingShaderState = 0;
+ if (defined(clippingPlanes)) {
+ currentClippingShaderState = enableClippingPlanes ? clippingPlanes.clippingPlanesState() : 0;
+ }
var surfaceShader = surfaceTile.surfaceShader;
if (defined(surfaceShader) &&
surfaceShader.numberOfDayTextures === numberOfDayTextures &&
surfaceShader.flags === flags &&
- surfaceShader.material === this.material) {
+ surfaceShader.material === this.material &&
+ surfaceShader.clippingShaderState === currentClippingShaderState) {
return surfaceShader.shaderProgram;
}
- // New tile, or tile changed number of textures or flags.
+ // New tile, or tile changed number of textures, flags, or clipping planes
var shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures];
if (!defined(shadersByFlags)) {
shadersByFlags = this._shadersByTexturesFlags[numberOfDayTextures] = [];
}
surfaceShader = shadersByFlags[flags];
- if (!defined(surfaceShader) || surfaceShader.material !== this.material) {
+ if (!defined(surfaceShader) || surfaceShader.material !== this.material || surfaceShader.clippingShaderState !== currentClippingShaderState) {
// Cache miss - we've never seen this combination of numberOfDayTextures and flags before.
var vs = this.baseVertexShaderSource.clone();
var fs = this.baseFragmentShaderSource.clone();
+ if (currentClippingShaderState !== 0) {
+ fs.sources.unshift(getClippingFunction(clippingPlanes)); // Need to go before GlobeFS
+ }
+
vs.defines.push(quantizationDefine);
fs.defines.push('TEXTURE_UNITS ' + numberOfDayTextures);
@@ -167,10 +181,6 @@ define([
if (enableClippingPlanes) {
fs.defines.push('ENABLE_CLIPPING_PLANES');
-
- if (unionClippingRegions) {
- fs.defines.push('UNION_CLIPPING_REGIONS');
- }
}
var computeDayColor = '\
@@ -212,7 +222,7 @@ define([
attributeLocations : terrainEncoding.getAttributeLocations()
});
- surfaceShader = shadersByFlags[flags] = new GlobeSurfaceShader(numberOfDayTextures, flags, this.material, shader);
+ surfaceShader = shadersByFlags[flags] = new GlobeSurfaceShader(numberOfDayTextures, flags, this.material, shader, currentClippingShaderState);
}
surfaceTile.surfaceShader = surfaceShader;
diff --git a/Source/Scene/GlobeSurfaceTileProvider.js b/Source/Scene/GlobeSurfaceTileProvider.js
index ddf1fc10d641..9d9ea96e7e7b 100644
--- a/Source/Scene/GlobeSurfaceTileProvider.js
+++ b/Source/Scene/GlobeSurfaceTileProvider.js
@@ -172,7 +172,7 @@ define([
* @type {ClippingPlaneCollection}
* @private
*/
- this.clippingPlanes = undefined;
+ this._clippingPlanes = undefined;
}
defineProperties(GlobeSurfaceTileProvider.prototype, {
@@ -302,6 +302,21 @@ define([
this._quadtree.invalidateAllTiles();
}
}
+ },
+ /**
+ * The {@link ClippingPlaneCollection} used to selectively disable rendering the tileset.
+ *
+ * @type {ClippingPlaneCollection}
+ *
+ * @private
+ */
+ clippingPlanes : {
+ get : function() {
+ return this._clippingPlanes;
+ },
+ set : function(value) {
+ ClippingPlaneCollection.setOwnership(value, this, '_clippingPlanes');
+ }
}
});
@@ -396,7 +411,11 @@ define([
tiles.length = 0;
}
}
-
+ // update clipping planes
+ var clippingPlanes = this._clippingPlanes;
+ if (defined(clippingPlanes) && clippingPlanes.enabled) {
+ clippingPlanes.update(frameState);
+ }
this._usedDrawCommands = 0;
};
@@ -548,7 +567,7 @@ define([
}
}
- var clippingPlanes = this.clippingPlanes;
+ var clippingPlanes = this._clippingPlanes;
if (defined(clippingPlanes) && clippingPlanes.enabled) {
var planeIntersection = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
tile.isClipped = (planeIntersection !== Intersect.INSIDE);
@@ -666,6 +685,8 @@ define([
*/
GlobeSurfaceTileProvider.prototype.destroy = function() {
this._tileProvider = this._tileProvider && this._tileProvider.destroy();
+ this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
+
return destroyObject(this);
};
@@ -826,7 +847,8 @@ define([
}
};
- function createTileUniformMap(frameState) {
+ var scratchClippingPlaneMatrix = new Matrix4();
+ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
var uniformMap = {
u_initialColor : function() {
return this.properties.initialColor;
@@ -914,11 +936,17 @@ define([
u_dayTextureSplit : function() {
return this.properties.dayTextureSplit;
},
- u_clippingPlanesLength : function() {
- return this.properties.clippingPlanes.length;
- },
u_clippingPlanes : function() {
- return this.properties.clippingPlanes;
+ var clippingPlanes = globeSurfaceTileProvider._clippingPlanes;
+ if (defined(clippingPlanes) && defined(clippingPlanes.texture)) {
+ // Check in case clippingPlanes hasn't been updated yet.
+ return clippingPlanes.texture;
+ }
+ return frameState.context.defaultTexture;
+ },
+ u_clippingPlanesMatrix : function() {
+ var clippingPlanes = globeSurfaceTileProvider._clippingPlanes;
+ return defined(clippingPlanes) ? Matrix4.multiply(frameState.context.uniformState.view, clippingPlanes.modelMatrix, scratchClippingPlaneMatrix) : Matrix4.IDENTITY;
},
u_clippingPlanesEdgeStyle : function() {
var style = this.properties.clippingPlanesEdgeColor;
@@ -963,7 +991,6 @@ define([
minMaxHeight : new Cartesian2(),
scaleAndBias : new Matrix4(),
- clippingPlanes : [],
clippingPlanesEdgeColor : Color.clone(Color.WHITE),
clippingPlanesEdgeWidth : 0.0
}
@@ -1211,7 +1238,7 @@ define([
command.boundingVolume = new BoundingSphere();
command.orientedBoundingBox = undefined;
- uniformMap = createTileUniformMap(frameState);
+ uniformMap = createTileUniformMap(frameState, tileProvider);
tileProvider._drawCommands.push(command);
tileProvider._uniformMaps.push(uniformMap);
@@ -1342,37 +1369,18 @@ define([
Matrix4.clone(encoding.matrix, uniformMapProperties.scaleAndBias);
// update clipping planes
- var clippingPlanes = tileProvider.clippingPlanes;
- var length = 0;
-
- if (defined(clippingPlanes) && tile.isClipped) {
- length = clippingPlanes.length;
- }
-
- var packedPlanes = uniformMapProperties.clippingPlanes;
- var packedLength = packedPlanes.length;
- if (packedLength !== length) {
- packedPlanes.length = length;
-
- for (var i = packedLength; i < length; ++i) {
- packedPlanes[i] = new Cartesian4();
- }
- }
-
- if (defined(clippingPlanes) && clippingPlanes.enabled && tile.isClipped) {
- clippingPlanes.transformAndPackPlanes(context.uniformState.view, packedPlanes);
+ var clippingPlanes = tileProvider._clippingPlanes;
+ var clippingPlanesEnabled = defined(clippingPlanes) && clippingPlanes.enabled && tile.isClipped;
+ if (clippingPlanesEnabled) {
uniformMapProperties.clippingPlanesEdgeColor = Color.clone(clippingPlanes.edgeColor, uniformMapProperties.clippingPlanesEdgeColor);
uniformMapProperties.clippingPlanesEdgeWidth = clippingPlanes.edgeWidth;
}
- var clippingPlanesEnabled = defined(clippingPlanes) && clippingPlanes.enabled && (uniformMapProperties.clippingPlanes.length > 0) && ClippingPlaneCollection.isSupported();
- var unionClippingRegions = clippingPlanesEnabled ? clippingPlanes.unionClippingRegions : false;
-
if (defined(tileProvider.uniformMap)) {
uniformMap = combine(uniformMap, tileProvider.uniformMap);
}
- command.shaderProgram = tileProvider._surfaceShaderSet.getShaderProgram(frameState, surfaceTile, numberOfDayTextures, applyBrightness, applyContrast, applyHue, applySaturation, applyGamma, applyAlpha, applySplit, showReflectiveOcean, showOceanWaves, tileProvider.enableLighting, hasVertexNormals, useWebMercatorProjection, applyFog, clippingPlanesEnabled, unionClippingRegions);
+ command.shaderProgram = tileProvider._surfaceShaderSet.getShaderProgram(frameState, surfaceTile, numberOfDayTextures, applyBrightness, applyContrast, applyHue, applySaturation, applyGamma, applyAlpha, applySplit, showReflectiveOcean, showOceanWaves, tileProvider.enableLighting, hasVertexNormals, useWebMercatorProjection, applyFog, clippingPlanesEnabled, clippingPlanes);
command.castShadows = castShadows;
command.receiveShadows = receiveShadows;
command.renderState = renderState;
diff --git a/Source/Scene/Instanced3DModel3DTileContent.js b/Source/Scene/Instanced3DModel3DTileContent.js
index 1373144e21bb..01f65513809f 100644
--- a/Source/Scene/Instanced3DModel3DTileContent.js
+++ b/Source/Scene/Instanced3DModel3DTileContent.js
@@ -1,7 +1,6 @@
define([
'../Core/AttributeCompression',
'../Core/Cartesian3',
- '../Core/ClippingPlaneCollection',
'../Core/Color',
'../Core/ComponentDatatype',
'../Core/defaultValue',
@@ -29,7 +28,6 @@ define([
], function(
AttributeCompression,
Cartesian3,
- ClippingPlaneCollection,
Color,
ComponentDatatype,
defaultValue,
@@ -511,24 +509,21 @@ define([
this._modelInstanceCollection.modelMatrix = this._tile.computedTransform;
this._modelInstanceCollection.shadows = this._tileset.shadows;
this._modelInstanceCollection.debugWireframe = this._tileset.debugWireframe;
- this._modelInstanceCollection.update(frameState);
- // Update clipping planes
- var tilesetClippingPlanes = this._tileset.clippingPlanes;
var model = this._modelInstanceCollection._model;
- var modelClippingPlanes = model.clippingPlanes;
- if (defined(tilesetClippingPlanes)) {
- if (!defined(modelClippingPlanes)) {
- model.clippingPlanes = new ClippingPlaneCollection();
- modelClippingPlanes = model.clippingPlanes;
- }
- tilesetClippingPlanes.clone(modelClippingPlanes);
- modelClippingPlanes.enabled = tilesetClippingPlanes.enabled && this._tile._isClipped;
- } else if (defined(modelClippingPlanes) && modelClippingPlanes.enabled) {
- modelClippingPlanes.enabled = false;
+ if (defined(model)) {
+ // Update for clipping planes
+ var tilesetClippingPlanes = this._tileset.clippingPlanes;
+ if (this._tile.clippingPlanesDirty && defined(tilesetClippingPlanes)) {
+ // Dereference the clipping planes from the model if they are irrelevant - saves on shading
+ // Link/Dereference directly to avoid ownership checks.
+ model._clippingPlanes = (tilesetClippingPlanes.enabled && this._tile._isClipped) ? tilesetClippingPlanes : undefined;
+ }
}
+ this._modelInstanceCollection.update(frameState);
+
// If any commands were pushed, add derived commands
var commandEnd = frameState.commandList.length;
if ((commandStart < commandEnd) && frameState.passes.render) {
diff --git a/Source/Scene/Model.js b/Source/Scene/Model.js
index 5a117e19c976..85990ae8a704 100644
--- a/Source/Scene/Model.js
+++ b/Source/Scene/Model.js
@@ -63,6 +63,8 @@ define([
'./Axis',
'./BlendingState',
'./ColorBlendMode',
+ './DracoLoader',
+ './getClippingFunction',
'./HeightReference',
'./JobType',
'./ModelAnimationCache',
@@ -139,6 +141,8 @@ define([
Axis,
BlendingState,
ColorBlendMode,
+ DracoLoader,
+ getClippingFunction,
HeightReference,
JobType,
ModelAnimationCache,
@@ -267,7 +271,7 @@ define([
* @param {Number} [options.colorBlendAmount=0.5] Value used to determine the color strength when the colorBlendMode is MIX. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
* @param {Color} [options.silhouetteColor=Color.RED] The silhouette color. If more than 256 models have silhouettes enabled, there is a small chance that overlapping models will have minor artifacts.
* @param {Number} [options.silhouetteSize=0.0] The size of the silhouette in pixels.
- * @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the model. Clipping planes are not currently supported in Internet Explorer.
+ * @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
*
* @exception {DeveloperError} bgltf is not a valid Binary glTF file.
* @exception {DeveloperError} Only glTF Binary version 1 is supported.
@@ -490,6 +494,7 @@ define([
this.color = defaultValue(options.color, Color.WHITE);
this._color = new Color();
this._colorPreviousAlpha = 1.0;
+ this._hasPremultipliedAlpha = false;
/**
* Defines how the color blends with the model.
@@ -511,12 +516,12 @@ define([
*/
this.colorBlendAmount = defaultValue(options.colorBlendAmount, 0.5);
- /**
- * The {@link ClippingPlaneCollection} used to selectively disable rendering the model. Clipping planes are not currently supported in Internet Explorer.
- *
- * @type {ClippingPlaneCollection}
- */
+ this._colorShadingEnabled = isColorShadingEnabled(this);
+
+ this._clippingPlanes = undefined;
this.clippingPlanes = options.clippingPlanes;
+ // Used for checking if shaders need to be regenerated due to clipping plane changes.
+ this._clippingPlanesState = 0;
/**
* This property is for debugging only; it is not for production use nor is it optimized.
@@ -616,6 +621,7 @@ define([
this._cachedRendererResources = undefined;
this._loadRendererResourcesFromCache = false;
this._updatedGltfVersion = false;
+ this._decodedData = {};
this._cachedGeometryByteLength = 0;
this._cachedTexturesByteLength = 0;
@@ -623,6 +629,12 @@ define([
this._texturesByteLength = 0;
this._trianglesLength = 0;
+ // Hold references to programs and shaders for shader reconstruction.
+ // Hold these separately because _cachedGltf may get released (this.releaseGltfJson)
+ this._sourcePrograms = undefined;
+ this._sourceShaders = undefined;
+ this._quantizedVertexShaders = {};
+
this._nodeCommands = [];
this._pickIds = [];
@@ -631,8 +643,6 @@ define([
this._rtcCenterEye = undefined; // in eye coordinates
this._rtcCenter3D = undefined; // in world coordinates
this._rtcCenter2D = undefined; // in projected world coordinates
-
- this._packedClippingPlanes = [];
}
defineProperties(Model.prototype, {
@@ -999,6 +1009,26 @@ define([
get : function() {
return this._cachedTexturesByteLength;
}
+ },
+
+ /**
+ * The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
+ *
+ * @memberof Model.prototype
+ *
+ * @type {ClippingPlaneCollection}
+ */
+ clippingPlanes : {
+ get : function() {
+ return this._clippingPlanes;
+ },
+ set : function(value) {
+ if (value === this._clippingPlanes) {
+ return;
+ }
+ // Handle destroying, checking of unknown, checking for existing ownership
+ ClippingPlaneCollection.setOwnership(value, this, '_clippingPlanes');
+ }
}
});
@@ -1006,6 +1036,15 @@ define([
return context.stencilBuffer;
}
+ function isColorShadingEnabled(model) {
+ return !Color.equals(model.color, Color.WHITE) || (model.colorBlendMode !== ColorBlendMode.HIGHLIGHT);
+ }
+
+ function isClippingEnabled(model) {
+ var clippingPlanes = model._clippingPlanes;
+ return defined(clippingPlanes) && clippingPlanes.enabled;
+ }
+
/**
* Determines if silhouettes are supported.
*
@@ -1060,7 +1099,7 @@ define([
* @param {Number} [options.colorBlendAmount=0.5] Value used to determine the color strength when the colorBlendMode is MIX. A value of 0.0 results in the model's rendered color while a value of 1.0 results in a solid color, with any value in-between resulting in a mix of the two.
* @param {Color} [options.silhouetteColor=Color.RED] The silhouette color. If more than 256 models have silhouettes enabled, there is a small chance that overlapping models will have minor artifacts.
* @param {Number} [options.silhouetteSize=0.0] The size of the silhouette in pixels.
- * @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the model. Clipping planes are not currently supported in Internet Explorer.
+ * @param {ClippingPlaneCollection} [options.clippingPlanes] The {@link ClippingPlaneCollection} used to selectively disable rendering the model.
*
* @returns {Model} The newly created model.
*
@@ -1304,9 +1343,13 @@ define([
///////////////////////////////////////////////////////////////////////////
function getFailedLoadFunction(model, type, path) {
- return function() {
+ return function(error) {
model._state = ModelState.FAILED;
- model._readyPromise.reject(new RuntimeError('Failed to load ' + type + ': ' + path));
+ var message = 'Failed to load ' + type + ': ' + path;
+ if (defined(error)) {
+ message += '\n' + error.message;
+ }
+ model._readyPromise.reject(new RuntimeError(message));
};
}
@@ -1369,8 +1412,11 @@ define([
// through glTF accessors to create the bufferview's index buffer.
ForEach.accessor(model.gltf, function(accessor) {
var bufferViewId = accessor.bufferView;
- var bufferView = bufferViews[bufferViewId];
+ if (!defined(bufferViewId)) {
+ return;
+ }
+ var bufferView = bufferViews[bufferViewId];
if ((bufferView.target === WebGLConstants.ELEMENT_ARRAY_BUFFER) && !defined(indexBufferIds[bufferViewId])) {
indexBufferIds[bufferViewId] = true;
indexBuffersToCreate.enqueue({
@@ -1875,39 +1921,99 @@ define([
///////////////////////////////////////////////////////////////////////////
+ // When building programs for the first time, do not include modifiers for clipping planes and color
+ // since this is the version of the program that will be cached.
function createProgram(id, model, context) {
- var programs = model.gltf.programs;
- var shaders = model.gltf.shaders;
- var program = programs[id];
+ var program = model._sourcePrograms[id];
+ var shaders = model._sourceShaders;
+ var quantizedVertexShaders = model._quantizedVertexShaders;
- var attributeLocations = createAttributeLocations(model, program.attributes);
var vs = shaders[program.vertexShader].extras._pipeline.source;
var fs = shaders[program.fragmentShader].extras._pipeline.source;
- // Add pre-created attributes to attributeLocations
- var attributesLength = program.attributes.length;
- var precreatedAttributes = model._precreatedAttributes;
- if (defined(precreatedAttributes)) {
- for (var attrName in precreatedAttributes) {
- if (precreatedAttributes.hasOwnProperty(attrName)) {
- attributeLocations[attrName] = attributesLength++;
- }
+ if (model.extensionsUsed.WEB3D_quantized_attributes) {
+ var quantizedVS = quantizedVertexShaders[id];
+ if (!defined(quantizedVS)) {
+ quantizedVS = modifyShaderForQuantizedAttributes(vs, id, model);
+ quantizedVertexShaders[id] = quantizedVS;
+ }
+ vs = quantizedVS;
+ }
+
+ var drawVS = modifyShader(vs, id, model._vertexShaderLoaded);
+ var drawFS = modifyShader(fs, id, model._fragmentShaderLoaded);
+
+ var pickFS, pickVS;
+ if (model.allowPicking) {
+ // PERFORMANCE_IDEA: Can optimize this shader with a glTF hint. https://github.com/KhronosGroup/glTF/issues/181
+ pickVS = modifyShader(vs, id, model._pickVertexShaderLoaded);
+ pickFS = modifyShader(fs, id, model._pickFragmentShaderLoaded);
+
+ if (!model._pickFragmentShaderLoaded) {
+ pickFS = ShaderSource.createPickFragmentShaderSource(fs, 'uniform');
}
}
+ createAttributesAndProgram(id, drawFS, drawVS, pickFS, pickVS, model, context);
+ }
+
+ function recreateProgram(id, model, context) {
+ var program = model._sourcePrograms[id];
+ var shaders = model._sourceShaders;
+ var quantizedVertexShaders = model._quantizedVertexShaders;
+
+ var clippingPlaneCollection = model.clippingPlanes;
+ var addClippingPlaneCode = isClippingEnabled(model);
+
+ var vs = shaders[program.vertexShader].extras._pipeline.source;
+ var fs = shaders[program.fragmentShader].extras._pipeline.source;
if (model.extensionsUsed.WEB3D_quantized_attributes) {
- vs = modifyShaderForQuantizedAttributes(vs, id, model);
+ vs = quantizedVertexShaders[id];
}
- var premultipliedAlpha = hasPremultipliedAlpha(model);
- var finalFS = modifyShaderForColor(fs, premultipliedAlpha);
- if (ClippingPlaneCollection.isSupported()) {
- finalFS = modifyShaderForClippingPlanes(finalFS);
+ var finalFS = fs;
+ if (isColorShadingEnabled(model)) {
+ finalFS = Model._modifyShaderForColor(finalFS, model._hasPremultipliedAlpha);
+ }
+ if (addClippingPlaneCode) {
+ finalFS = modifyShaderForClippingPlanes(finalFS, clippingPlaneCollection);
}
var drawVS = modifyShader(vs, id, model._vertexShaderLoaded);
var drawFS = modifyShader(finalFS, id, model._fragmentShaderLoaded);
+ var pickFS, pickVS;
+ if (model.allowPicking) {
+ // PERFORMANCE_IDEA: Can optimize this shader with a glTF hint. https://github.com/KhronosGroup/glTF/issues/181
+ pickVS = modifyShader(vs, id, model._pickVertexShaderLoaded);
+ pickFS = modifyShader(fs, id, model._pickFragmentShaderLoaded);
+
+ if (!model._pickFragmentShaderLoaded) {
+ pickFS = ShaderSource.createPickFragmentShaderSource(fs, 'uniform');
+ }
+
+ if (addClippingPlaneCode) {
+ pickFS = modifyShaderForClippingPlanes(pickFS, clippingPlaneCollection);
+ }
+ }
+ createAttributesAndProgram(id, drawFS, drawVS, pickFS, pickVS, model, context);
+ }
+
+ function createAttributesAndProgram(id, drawFS, drawVS, pickFS, pickVS, model, context) {
+ var program = model._sourcePrograms[id];
+ var attributeLocations = createAttributeLocations(model, program.attributes);
+
+ // Add pre-created attributes to attributeLocations
+ var attributesLength = program.attributes.length;
+ var precreatedAttributes = model._precreatedAttributes;
+ if (defined(precreatedAttributes)) {
+ for (var attrName in precreatedAttributes) {
+ if (precreatedAttributes.hasOwnProperty(attrName)) {
+ attributeLocations[attrName] = attributesLength++;
+ }
+ }
+ }
+
drawVS = ModelUtility.modifyVertexShaderForLogDepth(model.gltf, drawVS);
drawFS = ModelUtility.modifyFragmentShaderForLogDepth(drawFS);
@@ -1919,14 +2025,6 @@ define([
});
if (model.allowPicking) {
- // PERFORMANCE_IDEA: Can optimize this shader with a glTF hint. https://github.com/KhronosGroup/glTF/issues/181
- var pickVS = modifyShader(vs, id, model._pickVertexShaderLoaded);
- var pickFS = modifyShader(fs, id, model._pickFragmentShaderLoaded);
-
- if (!model._pickFragmentShaderLoaded) {
- pickFS = ShaderSource.createPickFragmentShaderSource(fs, 'uniform');
- }
-
pickVS = ModelUtility.modifyVertexShaderForLogDepth(model.gltf, pickVS);
pickFS = ModelUtility.modifyFragmentShaderForLogDepth(pickFS);
@@ -2393,6 +2491,7 @@ define([
for (var i = 0; i < primitivesLength; ++i) {
var primitive = primitives[i];
+ var decodedData = model._decodedData[meshId + '.primitive.' + i];
// GLTF_SPEC: This does not take into account attribute arrays,
// indicated by when an attribute points to a parameter with a
@@ -2412,7 +2511,27 @@ define([
// Skip if the attribute is not used by the material, e.g., because the asset was exported
// with an attribute that wasn't used and the asset wasn't optimized.
if (defined(attributeLocation)) {
+ // Use attributes of previously decoded draco geometry
+ if (defined(decodedData)) {
+ var decodedAttributes = decodedData.attributes;
+ if (decodedAttributes.hasOwnProperty(attributeName)) {
+ var decodedAttribute = decodedAttributes[attributeName];
+ attributes.push({
+ index : attributeLocation,
+ vertexBuffer : rendererBuffers[decodedAttribute.bufferView],
+ componentsPerAttribute : decodedAttribute.componentsPerAttribute,
+ componentDatatype : decodedAttribute.componentDatatype,
+ normalize: decodedAttribute.normalized,
+ offsetInBytes : decodedAttribute.byteOffset,
+ strideInBytes : decodedAttribute.byteStride
+ });
+
+ continue;
+ }
+ }
+
var a = accessors[primitiveAttributes[attributeName]];
+
var normalize = false;
if (defined(a.normalized) && a.normalized) {
normalize = true;
@@ -2449,7 +2568,14 @@ define([
var indexBuffer;
if (defined(primitive.indices)) {
var accessor = accessors[primitive.indices];
- indexBuffer = rendererBuffers[accessor.bufferView];
+ var bufferView = accessor.bufferView;
+
+ // Used decoded draco buffer if available
+ if (defined(decodedData)) {
+ bufferView = decodedData.bufferView;
+ }
+
+ indexBuffer = rendererBuffers[bufferView];
}
rendererVertexArrays[meshId + '.primitive.' + i] = new VertexArray({
context : context,
@@ -2515,7 +2641,7 @@ define([
var polygonOffset = defaultValue(statesFunctions.polygonOffset, [0.0, 0.0]);
// Change the render state to use traditional alpha blending instead of premultiplied alpha blending
- if (booleanStates[WebGLConstants.BLEND] && hasPremultipliedAlpha(model)) {
+ if (booleanStates[WebGLConstants.BLEND] && model._hasPremultipliedAlpha) {
if ((blendFuncSeparate[0] === WebGLConstants.ONE) && (blendFuncSeparate[1] === WebGLConstants.ONE_MINUS_SRC_ALPHA)) {
blendFuncSeparate[0] = WebGLConstants.SRC_ALPHA;
blendFuncSeparate[1] = WebGLConstants.ONE_MINUS_SRC_ALPHA;
@@ -2800,33 +2926,21 @@ define([
};
}
- function createClippingPlanesLengthFunction(model) {
- return function() {
- return model._packedClippingPlanes.length;
- };
- }
-
- function createClippingPlanesUnionRegionsFunction(model) {
+ var scratchClippingPlaneMatrix = new Matrix4();
+ function createClippingPlanesMatrixFunction(model) {
return function() {
var clippingPlanes = model.clippingPlanes;
if (!defined(clippingPlanes)) {
- return false;
+ return Matrix4.IDENTITY;
}
-
- return clippingPlanes.unionClippingRegions;
+ return Matrix4.multiply(model._modelViewMatrix, clippingPlanes.modelMatrix, scratchClippingPlaneMatrix);
};
}
function createClippingPlanesFunction(model) {
return function() {
var clippingPlanes = model.clippingPlanes;
- var packedPlanes = model._packedClippingPlanes;
-
- if (defined(clippingPlanes) && clippingPlanes.enabled) {
- clippingPlanes.transformAndPackPlanes(model._modelViewMatrix, packedPlanes);
- }
-
- return packedPlanes;
+ return (!defined(clippingPlanes) || !clippingPlanes.enabled) ? model._defaultTexture : clippingPlanes.texture;
};
}
@@ -2896,6 +3010,7 @@ define([
var material = materials[primitive.material];
var technique = techniques[material.technique];
var programId = technique.program;
+ var decodedData = model._decodedData[id + '.primitive.' + i];
var boundingSphere;
var positionAccessor = primitive.attributes.POSITION;
@@ -2909,6 +3024,12 @@ define([
var count;
if (defined(ix)) {
count = ix.count;
+
+ // Use indices of the previously decoded Draco geometry.
+ if (defined(decodedData)) {
+ count = decodedData.numberOfIndices;
+ }
+
offset = (ix.byteOffset / IndexDatatype.getSizeInBytes(ix.componentType)); // glTF has offset in bytes. Cesium has offsets in indices
}
else {
@@ -2938,10 +3059,9 @@ define([
uniformMap = combine(uniformMap, {
gltf_color : createColorFunction(model),
gltf_colorBlend : createColorBlendFunction(model),
- gltf_clippingPlanesLength: createClippingPlanesLengthFunction(model),
- gltf_clippingPlanesUnionRegions: createClippingPlanesUnionRegionsFunction(model),
- gltf_clippingPlanes: createClippingPlanesFunction(model, context),
- gltf_clippingPlanesEdgeStyle: createClippingPlanesEdgeStyleFunction(model)
+ gltf_clippingPlanes: createClippingPlanesFunction(model),
+ gltf_clippingPlanesEdgeStyle: createClippingPlanesEdgeStyleFunction(model),
+ gltf_clippingPlanesMatrix: createClippingPlanesMatrixFunction(model)
});
// Allow callback to modify the uniformMap
@@ -2981,7 +3101,7 @@ define([
vertexArray : vertexArray,
count : count,
offset : offset,
- shaderProgram : rendererPrograms[technique.program],
+ shaderProgram : rendererPrograms[programId],
castShadows : castShadows,
receiveShadows : receiveShadows,
uniformMap : uniformMap,
@@ -3022,7 +3142,7 @@ define([
vertexArray : vertexArray,
count : count,
offset : offset,
- shaderProgram : rendererPickPrograms[technique.program],
+ shaderProgram : rendererPickPrograms[programId],
uniformMap : pickUniformMap,
renderState : rs,
owner : owner,
@@ -3058,12 +3178,13 @@ define([
silhouetteColorCommand2D : undefined,
// Generated on demand when color alpha is less than 1.0
translucentCommand : undefined,
- translucentCommand2D : undefined
+ translucentCommand2D : undefined,
+ // For updating node commands on shader reconstruction
+ programId : programId
};
runtimeNode.commands.push(nodeCommand);
nodeCommands.push(nodeCommand);
}
-
}
function createRuntimeNodes(model, context, scene3DOnly) {
@@ -3192,6 +3313,11 @@ define([
var context = frameState.context;
var scene3DOnly = frameState.scene3DOnly;
+ // Retain references to updated source shaders and programs for rebuilding as needed
+ model._sourcePrograms = model.gltf.programs;
+ model._sourceShaders = model.gltf.shaders;
+ model._hasPremultipliedAlpha = hasPremultipliedAlpha(model);
+
ModelUtility.checkSupportedGlExtensions(model.gltf.glExtensionsUsed, context);
if (model._loadRendererResourcesFromCache) {
var resources = model._rendererResources;
@@ -3515,14 +3641,14 @@ define([
return translucentCommand;
}
- function updateColor(model, frameState) {
+ function updateColor(model, frameState, forceDerive) {
// Generate translucent commands when the blend color has an alpha in the range (0.0, 1.0) exclusive
var scene3DOnly = frameState.scene3DOnly;
var alpha = model.color.alpha;
if ((alpha > 0.0) && (alpha < 1.0)) {
var nodeCommands = model._nodeCommands;
var length = nodeCommands.length;
- if (!defined(nodeCommands[0].translucentCommand)) {
+ if (!defined(nodeCommands[0].translucentCommand) || forceDerive) {
for (var i = 0; i < length; ++i) {
var nodeCommand = nodeCommands[i];
var command = nodeCommand.command;
@@ -3735,42 +3861,29 @@ define([
}
}
- function modifyShaderForClippingPlanes(shader) {
+ function modifyShaderForClippingPlanes(shader, clippingPlaneCollection) {
shader = ShaderSource.replaceMain(shader, 'gltf_clip_main');
+ shader += Model._getClippingFunction(clippingPlaneCollection) + '\n';
shader +=
- 'uniform int gltf_clippingPlanesLength; \n' +
- 'uniform bool gltf_clippingPlanesUnionRegions; \n' +
- 'uniform vec4 gltf_clippingPlanes[czm_maxClippingPlanes]; \n' +
+ 'uniform sampler2D gltf_clippingPlanes; \n' +
'uniform vec4 gltf_clippingPlanesEdgeStyle; \n' +
+ 'uniform mat4 gltf_clippingPlanesMatrix; \n' +
'void main() \n' +
'{ \n' +
' gltf_clip_main(); \n' +
- ' if (gltf_clippingPlanesLength > 0) \n' +
+ ' float clipDistance = clip(gl_FragCoord, gltf_clippingPlanes, gltf_clippingPlanesMatrix);' +
+ ' vec4 clippingPlanesEdgeColor = vec4(1.0); \n' +
+ ' clippingPlanesEdgeColor.rgb = gltf_clippingPlanesEdgeStyle.rgb; \n' +
+ ' float clippingPlanesEdgeWidth = gltf_clippingPlanesEdgeStyle.a; \n' +
+ ' if (clipDistance > 0.0 && clipDistance < clippingPlanesEdgeWidth) \n' +
' { \n' +
- ' float clipDistance; \n' +
- ' if (gltf_clippingPlanesUnionRegions) \n' +
- ' { \n' +
- ' clipDistance = czm_discardIfClippedWithUnion(gltf_clippingPlanes, gltf_clippingPlanesLength); \n' +
- ' } \n' +
- ' else \n' +
- ' { \n' +
- ' clipDistance = czm_discardIfClippedWithIntersect(gltf_clippingPlanes, gltf_clippingPlanesLength); \n' +
- ' } \n' +
- ' \n' +
- ' vec4 clippingPlanesEdgeColor = vec4(1.0); \n' +
- ' clippingPlanesEdgeColor.rgb = gltf_clippingPlanesEdgeStyle.rgb; \n' +
- ' float clippingPlanesEdgeWidth = gltf_clippingPlanesEdgeStyle.a; \n' +
- ' if (clipDistance > 0.0 && clipDistance < clippingPlanesEdgeWidth) \n' +
- ' { \n' +
- ' gl_FragColor = clippingPlanesEdgeColor; \n' +
- ' } \n' +
+ ' gl_FragColor = clippingPlanesEdgeColor;\n' +
' } \n' +
'} \n';
-
return shader;
}
- function updateSilhouette(model, frameState) {
+ function updateSilhouette(model, frameState, force) {
// Generate silhouette commands when the silhouette size is greater than 0.0 and the alpha is greater than 0.0
// There are two silhouette commands:
// 1. silhouetteModelCommand : render model normally while enabling stencil mask
@@ -3787,25 +3900,16 @@ define([
model._colorPreviousAlpha = model.color.alpha;
model._silhouetteColorPreviousAlpha = model.silhouetteColor.alpha;
- if (dirty) {
+ if (dirty || force) {
createSilhouetteCommands(model, frameState);
}
}
- function updateClippingPlanes(model) {
- var clippingPlanes = model.clippingPlanes;
- var length = 0;
- if (defined(clippingPlanes) && clippingPlanes.enabled) {
- length = clippingPlanes.length;
- }
-
- var packedPlanes = model._packedClippingPlanes;
- var packedLength = packedPlanes.length;
- if (packedLength !== length) {
- packedPlanes.length = length;
-
- for (var i = packedLength; i < length; ++i) {
- packedPlanes[i] = new Cartesian4();
+ function updateClippingPlanes(model, frameState) {
+ var clippingPlanes = model._clippingPlanes;
+ if (defined(clippingPlanes) && clippingPlanes.owner === model) {
+ if (clippingPlanes.enabled) {
+ clippingPlanes.update(frameState);
}
}
}
@@ -4037,7 +4141,7 @@ define([
// Use renderer resources from cache instead of loading/creating them?
var cachedRendererResources;
var cacheKey = this.cacheKey;
- if (defined(cacheKey)) {
+ if (defined(cacheKey)) { // cache key given? this model will pull from or contribute to context level cache
context.cache.modelRendererResourceCache = defaultValue(context.cache.modelRendererResourceCache, {});
var modelCaches = context.cache.modelRendererResourceCache;
@@ -4057,7 +4161,7 @@ define([
modelCaches[this.cacheKey] = cachedRendererResources;
}
this._cachedRendererResources = cachedRendererResources;
- } else {
+ } else { // cache key not given? this model doesn't care about context level cache at all. Cache is here to simplify freeing on destroy.
cachedRendererResources = new CachedRendererResources(context);
cachedRendererResources.count = 1;
this._cachedRendererResources = cachedRendererResources;
@@ -4099,7 +4203,8 @@ define([
// Transition from LOADING -> LOADED once resources are downloaded and created.
// Textures may continue to stream in while in the LOADED state.
if (loadResources.pendingBufferLoads === 0) {
- if (!this._updatedGltfVersion) {
+ if (!loadResources.initialized) {
+ // glTF pipeline updates
var options = {
optimizeForCesium: true,
addBatchIdToGeneratedShaders : this._addBatchIdToGeneratedShaders
@@ -4111,6 +4216,19 @@ define([
addDefaults(this.gltf);
processModelMaterialsCommon(this.gltf, options);
processPbrMetallicRoughness(this.gltf, options);
+
+ // Start draco decoding
+ DracoLoader.parse(this);
+
+ loadResources.initialized = true;
+ }
+
+ if (!loadResources.finishedDecoding()) {
+ DracoLoader.decode(this, context)
+ .otherwise(getFailedLoadFunction(this, 'model', this.basePath));
+ }
+
+ if (loadResources.finishedDecoding() && !loadResources.resourcesParsed) {
// We do this after to make sure that the ids don't change
addBuffersToLoadResources(this);
@@ -4126,12 +4244,16 @@ define([
this._boundingSphere = computeBoundingSphere(this);
this._initialRadius = this._boundingSphere.radius;
- this._updatedGltfVersion = true;
+
+ loadResources.resourcesParsed = true;
}
- if (this._updatedGltfVersion && loadResources.pendingShaderLoads === 0) {
+
+ if (loadResources.resourcesParsed &&
+ loadResources.pendingShaderLoads === 0) {
createResources(this, frameState);
}
}
+
if (loadResources.finished() ||
(incrementallyLoadTextures && loadResources.finishedEverythingButTextureCreation())) {
this._state = ModelState.LOADED;
@@ -4223,11 +4345,6 @@ define([
}
}
- var clippingPlanes = this.clippingPlanes;
- if (defined(clippingPlanes) && clippingPlanes.enabled) {
- Matrix4.multiply(context.uniformState.view3D, modelMatrix, this._modelViewMatrix);
- }
-
// Update modelMatrix throughout the graph as needed
if (animated || modelTransformChanged || justLoaded) {
updateNodeHierarchyModelMatrix(this, modelTransformChanged, justLoaded, frameState.mapProjection);
@@ -4247,9 +4364,32 @@ define([
updateWireframe(this);
updateShowBoundingVolume(this);
updateShadows(this);
- updateColor(this, frameState);
- updateSilhouette(this, frameState);
updateClippingPlanes(this, frameState);
+
+ // Regnerate shaders if ClippingPlaneCollection state changed or it was removed
+ var clippingPlanes = this._clippingPlanes;
+ var currentClippingPlanesState = 0;
+ if (defined(clippingPlanes) && clippingPlanes.enabled) {
+ Matrix4.multiply(context.uniformState.view3D, modelMatrix, this._modelViewMatrix);
+ currentClippingPlanesState = clippingPlanes.clippingPlanesState();
+ }
+
+ var shouldRegenerateShaders = this._clippingPlanesState !== currentClippingPlanesState;
+ this._clippingPlanesState = currentClippingPlanesState;
+
+ // Regenerate shaders if color shading changed from last update
+ var currentlyColorShadingEnabled = isColorShadingEnabled(this);
+ if (currentlyColorShadingEnabled !== this._colorShadingEnabled) {
+ this._colorShadingEnabled = currentlyColorShadingEnabled;
+ shouldRegenerateShaders = true;
+ }
+
+ if (shouldRegenerateShaders) {
+ regenerateShaders(this, frameState);
+ } else {
+ updateColor(this, frameState, false);
+ updateSilhouette(this, frameState, false);
+ }
}
if (justLoaded) {
@@ -4328,6 +4468,83 @@ define([
}
};
+ function destroyIfNotCached(rendererResources, cachedRendererResources) {
+ if (rendererResources.programs !== cachedRendererResources.programs) {
+ destroy(rendererResources.programs);
+ }
+ if (rendererResources.pickPrograms !== cachedRendererResources.pickPrograms) {
+ destroy(rendererResources.pickPrograms);
+ }
+ if (rendererResources.silhouettePrograms !== cachedRendererResources.silhouettePrograms) {
+ destroy(rendererResources.silhouettePrograms);
+ }
+ }
+
+ // Run from update iff:
+ // - everything is loaded
+ // - clipping planes state change OR color state set
+ // Run this from destructor after removing color state and clipping plane state
+ function regenerateShaders(model, frameState) {
+ // In regards to _cachedRendererResources:
+ // Fair to assume that this is data that should just never get modified due to clipping planes or model color.
+ // So if clipping planes or model color active:
+ // - delink _rendererResources.*programs and create new dictionaries.
+ // - do NOT destroy any programs - might be used by copies of the model or by might be needed in the future if clipping planes/model color is deactivated
+
+ // If clipping planes and model color inactive:
+ // - destroy _rendererResources.*programs
+ // - relink _rendererResources.*programs to _cachedRendererResources
+
+ // In both cases, need to mark commands as dirty, re-run derived commands (elsewhere)
+
+ var rendererResources = model._rendererResources;
+ var cachedRendererResources = model._cachedRendererResources;
+ destroyIfNotCached(rendererResources, cachedRendererResources);
+
+ if (isClippingEnabled(model) || isColorShadingEnabled(model)) {
+ rendererResources.programs = {};
+ rendererResources.pickPrograms = {};
+ rendererResources.silhouettePrograms = {};
+
+ var sourcePrograms = model._sourcePrograms;
+
+ ForEach.object(sourcePrograms, function(program, id) {
+ recreateProgram(id, model, frameState.context);
+ });
+ } else {
+ rendererResources.programs = cachedRendererResources.programs;
+ rendererResources.pickPrograms = cachedRendererResources.pickPrograms;
+ rendererResources.silhouettePrograms = cachedRendererResources.silhouettePrograms;
+ }
+
+ // Fix all the commands, marking them as dirty so everything that derives will re-derive
+ var rendererPrograms = rendererResources.programs;
+ var rendererPickPrograms = rendererResources.pickPrograms;
+
+ var nodeCommands = model._nodeCommands;
+ var commandCount = nodeCommands.length;
+ for (var i = 0; i < commandCount; ++i) {
+ var nodeCommand = nodeCommands[i];
+ var programId = nodeCommand.programId;
+
+ var renderProgram = rendererPrograms[programId];
+ var pickProgram = rendererPickPrograms[programId];
+
+ nodeCommand.command.shaderProgram = renderProgram;
+ nodeCommand.pickCommand.shaderProgram = pickProgram;
+ if (defined(nodeCommand.command2D)) {
+ nodeCommand.command2D.shaderProgram = renderProgram;
+ }
+ if (defined(nodeCommand.pickCommand2D)) {
+ nodeCommand.pickCommand2D.shaderProgram = pickProgram;
+ }
+ }
+
+ // Force update silhouette commands/shaders
+ updateColor(model, frameState, true);
+ updateSilhouette(model, frameState, true);
+ }
+
/**
* Returns true if this object was destroyed; otherwise, false.
* {s} placeholder in the URL template.
* If this parameter is a single string, each character in the string is a subdomain. If it is
@@ -133,10 +135,10 @@ define([
// Use CRS with 1.3.0 and going forward.
// For GeographicTilingScheme, use CRS:84 vice EPSG:4326 to specify lon, lat (x, y) ordering for
// bbox requests.
- parameters.crs = options.tilingScheme instanceof WebMercatorTilingScheme ? 'EPSG:3857' : 'CRS:84';
+ parameters.crs = defaultValue(options.crs, options.tilingScheme instanceof WebMercatorTilingScheme ? 'EPSG:3857' : 'CRS:84');
} else {
// SRS for WMS 1.1.0 or 1.1.1.
- parameters.srs = options.tilingScheme instanceof WebMercatorTilingScheme ? 'EPSG:3857' : 'EPSG:4326';
+ parameters.srs = defaultValue(options.srs, options.tilingScheme instanceof WebMercatorTilingScheme ? 'EPSG:3857' : 'EPSG:4326');
}
resource.setQueryParameters(parameters, true);
diff --git a/Source/Scene/getClippingFunction.js b/Source/Scene/getClippingFunction.js
new file mode 100644
index 000000000000..495700e3eb87
--- /dev/null
+++ b/Source/Scene/getClippingFunction.js
@@ -0,0 +1,168 @@
+define([
+ '../Core/Check',
+ '../Renderer/PixelDatatype',
+ './getUnpackFloatFunction'
+ ], function(
+ Check,
+ PixelDatatype,
+ getUnpackFloatFunction) {
+ 'use strict';
+
+ /**
+ * Gets the glsl functions needed to retrieve clipping planes from a ClippingPlaneCollection's texture.
+ *
+ * @param {ClippingPlaneCollection} clippingPlaneCollection ClippingPlaneCollection with a defined texture.
+ * @returns {String} A string containing glsl functions for retrieving clipping planes.
+ * @private
+ */
+ function getClippingFunction(clippingPlaneCollection) {
+ //>>includeStart('debug', pragmas.debug);
+ Check.typeOf.object('clippingPlaneCollection', clippingPlaneCollection);
+ //>>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 functions = usingFloatTexture ? getClippingPlaneFloat(width, height) : getClippingPlaneUint8(width, height);
+ functions += '\n';
+ functions += unionClippingRegions ? clippingFunctionUnion(usingFloatTexture, clippingPlanesLength) : clippingFunctionIntersect(usingFloatTexture, clippingPlanesLength);
+ return functions;
+ }
+
+ function clippingFunctionUnion(usingFloatTexture, clippingPlanesLength) {
+ var functionString =
+ 'float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n' +
+ '{\n' +
+ ' vec4 position = czm_windowToEyeCoordinates(fragCoord);\n' +
+ ' vec3 clipNormal = vec3(0.0);\n' +
+ ' vec3 clipPosition = vec3(0.0);\n' +
+ ' float clipAmount = 0.0;\n' +
+ ' float pixelWidth = czm_metersPerPixel(position);\n' +
+ ' bool breakAndDiscard = false;\n' +
+
+ ' for (int i = 0; i < ' + clippingPlanesLength + '; ++i)\n' +
+ ' {\n' +
+ ' vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);\n' +
+
+ ' clipNormal = clippingPlane.xyz;\n' +
+ ' clipPosition = -clippingPlane.w * clipNormal;\n' +
+
+ ' float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;\n' +
+ ' clipAmount = max(amount, clipAmount);\n' +
+
+ ' if (amount <= 0.0)\n' +
+ ' {\n' +
+ ' breakAndDiscard = true;\n' +
+ ' break;\n' + // HLSL compiler bug if we discard here: https://bugs.chromium.org/p/angleproject/issues/detail?id=1945#c6
+ ' }\n' +
+ ' }\n' +
+
+ ' if (breakAndDiscard) {\n' +
+ ' discard;\n' +
+ ' }\n' +
+ ' return clipAmount;\n' +
+ '}\n';
+ return functionString;
+ }
+
+ function clippingFunctionIntersect(usingFloatTexture, clippingPlanesLength) {
+ var functionString =
+ 'float clip(vec4 fragCoord, sampler2D clippingPlanes, mat4 clippingPlanesMatrix)\n' +
+ '{\n' +
+ ' bool clipped = true;\n' +
+ ' vec4 position = czm_windowToEyeCoordinates(fragCoord);\n' +
+ ' vec3 clipNormal = vec3(0.0);\n' +
+ ' vec3 clipPosition = vec3(0.0);\n' +
+ ' float clipAmount = 0.0;\n' +
+ ' float pixelWidth = czm_metersPerPixel(position);\n' +
+
+ ' for (int i = 0; i < ' + clippingPlanesLength + '; ++i)\n' +
+ ' {\n' +
+ ' vec4 clippingPlane = getClippingPlane(clippingPlanes, i, clippingPlanesMatrix);\n' +
+
+ ' clipNormal = clippingPlane.xyz;\n' +
+ ' clipPosition = -clippingPlane.w * clipNormal;\n' +
+
+ ' float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;\n' +
+ ' clipAmount = max(amount, clipAmount);\n' +
+
+ ' clipped = clipped && (amount <= 0.0);\n' +
+ ' }\n' +
+
+ ' if (clipped)\n' +
+ ' {\n' +
+ ' discard;\n' +
+ ' }\n' +
+
+ ' return clipAmount;\n' +
+ '}\n';
+ return functionString;
+ }
+
+ function getClippingPlaneFloat(width, height) {
+ var pixelWidth = 1.0 / width;
+ var pixelHeight = 1.0 / height;
+
+ var pixelWidthString = pixelWidth + '';
+ if (pixelWidthString.indexOf('.') === -1) {
+ pixelWidthString += '.0';
+ }
+ var pixelHeightString = pixelHeight + '';
+ if (pixelHeightString.indexOf('.' === -1)) {
+ pixelHeightString += '.0';
+ }
+
+ var functionString =
+ 'vec4 getClippingPlane(sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)\n' +
+ '{\n' +
+ ' int pixY = clippingPlaneNumber / ' + width + ';\n' +
+ ' int pixX = clippingPlaneNumber - (pixY * ' + width + ');\n' +
+ ' float u = (float(pixX) + 0.5) * ' + pixelWidthString + ';\n' + // sample from center of pixel
+ ' float v = (float(pixY) + 0.5) * ' + pixelHeightString + ';\n' +
+ ' vec4 plane = texture2D(packedClippingPlanes, vec2(u, v));\n' +
+ ' return czm_transformPlane(transform, plane);\n' +
+ '}\n';
+ return functionString;
+ }
+
+ function getClippingPlaneUint8(width, height) {
+ var pixelWidth = 1.0 / width;
+ var pixelHeight = 1.0 / height;
+
+ var pixelWidthString = pixelWidth + '';
+ if (pixelWidthString.indexOf('.') === -1) {
+ pixelWidthString += '.0';
+ }
+ var pixelHeightString = pixelHeight + '';
+ if (pixelHeightString.indexOf('.' === -1)) {
+ pixelHeightString += '.0';
+ }
+
+ var functionString =
+ getUnpackFloatFunction('unpackFloatDistance') +
+ '\n' +
+ 'vec4 getClippingPlane(sampler2D packedClippingPlanes, int clippingPlaneNumber, mat4 transform)\n' +
+ '{\n' +
+ ' int clippingPlaneStartIndex = clippingPlaneNumber * 2;\n' + // clipping planes are two pixels each
+ ' int pixY = clippingPlaneStartIndex / ' + width + ';\n' +
+ ' int pixX = clippingPlaneStartIndex - (pixY * ' + width + ');\n' +
+ ' float u = (float(pixX) + 0.5) * ' + pixelWidthString + ';\n' + // sample from center of pixel
+ ' float v = (float(pixY) + 0.5) * ' + pixelHeightString + ';\n' +
+
+ ' vec4 oct32 = texture2D(packedClippingPlanes, vec2(u, v)) * 255.0;\n' +
+ ' vec2 oct = vec2(oct32.x * 256.0 + oct32.y, oct32.z * 256.0 + oct32.w);\n' +
+
+ ' vec4 plane;\n' +
+ ' plane.xyz = czm_octDecode(oct, 65535.0);\n' +
+ ' plane.w = unpackFloatDistance(texture2D(packedClippingPlanes, vec2(u + ' + pixelWidthString + ', v)));\n' +
+
+ ' return czm_transformPlane(transform, plane);\n' +
+ '}\n';
+ return functionString;
+ }
+
+ return getClippingFunction;
+});
diff --git a/Source/Scene/getUnpackFloatFunction.js b/Source/Scene/getUnpackFloatFunction.js
new file mode 100644
index 000000000000..dae8fb286cab
--- /dev/null
+++ b/Source/Scene/getUnpackFloatFunction.js
@@ -0,0 +1,42 @@
+define([
+ '../Core/defined'
+ ], function(
+ defined) {
+ 'use strict';
+
+ var SHIFT_RIGHT_8 = 1.0 / 256.0;
+ var SHIFT_RIGHT_16 = 1.0 / 65536.0;
+ var SHIFT_RIGHT_24 = 1.0 / 16777216.0;
+
+ var BIAS = 38.0;
+
+ /**
+ * Gets a glsl function that takes a vec4 representing a float packed to Uint8 RGBA and returns the unpacked float.
+ *
+ * @param {String} [functionName='unpackFloat'] An optional name for the glsl function.
+ * @returns {String} A string containing a glsl function that takes a vec4 and returns a float.
+ * @private
+ * @see Cartesian4#packFloat
+ */
+ function getUnpackFloatFunction(functionName) {
+ if (!defined(functionName)) {
+ functionName = 'unpackFloat';
+ }
+ return 'float ' + functionName + '(vec4 value) \n' +
+ '{ \n' +
+ ' value *= 255.0; \n' +
+ ' float temp = value.w / 2.0; \n' +
+ ' float exponent = floor(temp); \n' +
+ ' float sign = (temp - exponent) * 2.0; \n' +
+ ' exponent = exponent - float(' + BIAS + '); \n' +
+ ' sign = sign * 2.0 - 1.0; \n' +
+ ' sign = -sign; \n' +
+ ' float unpacked = sign * value.x * float(' + SHIFT_RIGHT_8 + '); \n' +
+ ' unpacked += sign * value.y * float(' + SHIFT_RIGHT_16 + '); \n' +
+ ' unpacked += sign * value.z * float(' + SHIFT_RIGHT_24 + '); \n' +
+ ' return unpacked * pow(10.0, exponent); \n' +
+ '} \n';
+ }
+
+ return getUnpackFloatFunction;
+});
diff --git a/Source/Shaders/Builtin/Constants/maxClippingPlanes.glsl b/Source/Shaders/Builtin/Constants/maxClippingPlanes.glsl
deleted file mode 100644
index 30c377df1668..000000000000
--- a/Source/Shaders/Builtin/Constants/maxClippingPlanes.glsl
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * The maximum amount of planes that can be clipped by czm_clipPlanes.
- *
- * @name czm_maxClippingPlanes
- * @glslConstant
- * @see czm_clipPlanes
- */
-const int czm_maxClippingPlanes = 6;
diff --git a/Source/Shaders/Builtin/Functions/discardIfClippedWithIntersect.glsl b/Source/Shaders/Builtin/Functions/discardIfClippedWithIntersect.glsl
deleted file mode 100644
index 987dd8d354c8..000000000000
--- a/Source/Shaders/Builtin/Functions/discardIfClippedWithIntersect.glsl
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- * Clip a fragment by an array of clipping planes. Clipping plane regions are joined by the intersect operation, so
- * a fragment must be clipped by all of the planes to be discarded.
- *
- * @name czm_discardIfClippedWithIntersect
- * @glslFunction
- *
- * @param {vec4[]} clippingPlanes The array of planes used to clip, defined in eyespace.
- * @param {int} clippingPlanesLength The number of planes in the array of clipping planes.
- * @returns {float} The distance away from a clipped fragment, in eyespace
- */
-float czm_discardIfClippedWithIntersect(vec4 clippingPlanes[czm_maxClippingPlanes], int clippingPlanesLength)
-{
- if (clippingPlanesLength > 0)
- {
- bool clipped = true;
- vec4 position = czm_windowToEyeCoordinates(gl_FragCoord);
- vec3 clipNormal = vec3(0.0);
- vec3 clipPosition = vec3(0.0);
- float clipAmount = 0.0;
- float pixelWidth = czm_metersPerPixel(position);
-
- for (int i = 0; i < czm_maxClippingPlanes; ++i)
- {
- if (i == clippingPlanesLength)
- {
- break;
- }
-
- clipNormal = clippingPlanes[i].xyz;
- clipPosition = -clippingPlanes[i].w * clipNormal;
-
- float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;
- clipAmount = max(amount, clipAmount);
-
- clipped = clipped && (amount <= 0.0);
- }
-
- if (clipped)
- {
- discard;
- }
-
- return clipAmount;
- }
-
- return 0.0;
-}
diff --git a/Source/Shaders/Builtin/Functions/discardIfClippedWithUnion.glsl b/Source/Shaders/Builtin/Functions/discardIfClippedWithUnion.glsl
deleted file mode 100644
index ae6110f8346f..000000000000
--- a/Source/Shaders/Builtin/Functions/discardIfClippedWithUnion.glsl
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Clip a fragment by an array of clipping planes. Clipping plane regions are joined with the union operation,
- * therefore if a fragment is clipped by any of the planes, it is discarded.
- *
- * @name czm_discardIfClippedWithUnion
- * @glslFunction
- *
- * @param {vec4[]} clippingPlanes The array of planes used to clip, defined in eyespace.
- * @param {int} clippingPlanesLength The number of planes in the array of clipping planes.
- * @returns {float} The distance away from a clipped fragment, in eyespace
- */
-float czm_discardIfClippedWithUnion(vec4 clippingPlanes[czm_maxClippingPlanes], int clippingPlanesLength)
-{
- if (clippingPlanesLength > 0)
- {
- vec4 position = czm_windowToEyeCoordinates(gl_FragCoord);
- vec3 clipNormal = vec3(0.0);
- vec3 clipPosition = vec3(0.0);
- float clipAmount = 0.0;
- float pixelWidth = czm_metersPerPixel(position);
-
- for (int i = 0; i < czm_maxClippingPlanes; ++i)
- {
- if (i == clippingPlanesLength)
- {
- break;
- }
-
- clipNormal = clippingPlanes[i].xyz;
- clipPosition = -clippingPlanes[i].w * clipNormal;
-
- float amount = dot(clipNormal, (position.xyz - clipPosition)) / pixelWidth;
- clipAmount = max(amount, clipAmount);
-
- if (amount <= 0.0)
- {
- discard;
- }
- }
-
- return clipAmount;
- }
-
- return 0.0;
-}
diff --git a/Source/Shaders/Builtin/Functions/metersPerPixel.glsl b/Source/Shaders/Builtin/Functions/metersPerPixel.glsl
index 953008963e28..f6066d21e0b5 100644
--- a/Source/Shaders/Builtin/Functions/metersPerPixel.glsl
+++ b/Source/Shaders/Builtin/Functions/metersPerPixel.glsl
@@ -1,6 +1,6 @@
/**
* Computes the size of a pixel in meters at a distance from the eye.
-
+
* @name czm_metersPerPixel
* @glslFunction
*
@@ -14,13 +14,13 @@ float czm_metersPerPixel(vec4 positionEC)
float height = czm_viewport.w;
float pixelWidth;
float pixelHeight;
-
+
float top = czm_frustumPlanes.x;
float bottom = czm_frustumPlanes.y;
float left = czm_frustumPlanes.z;
float right = czm_frustumPlanes.w;
-
- if (czm_sceneMode == czm_sceneMode2D)
+
+ if (czm_sceneMode == czm_sceneMode2D || czm_orthographicIn3D == 1.0)
{
float frustumWidth = right - left;
float frustumHeight = top - bottom;
diff --git a/Source/Shaders/Builtin/Functions/octDecode.glsl b/Source/Shaders/Builtin/Functions/octDecode.glsl
index ce4df362da12..98b2736f706a 100644
--- a/Source/Shaders/Builtin/Functions/octDecode.glsl
+++ b/Source/Shaders/Builtin/Functions/octDecode.glsl
@@ -28,7 +28,7 @@
* Decodes a unit-length vector in 'oct' encoding to a normalized 3-component Cartesian vector.
* The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
* Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
- *
+ *
* @name czm_octDecode
* @param {vec2} encoded The oct-encoded, unit-length vector
* @returns {vec3} The decoded and normalized vector
@@ -42,7 +42,7 @@
* Decodes a unit-length vector in 'oct' encoding packed into a floating-point number to a normalized 3-component Cartesian vector.
* The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
* Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
- *
+ *
* @name czm_octDecode
* @param {float} encoded The oct-encoded, unit-length vector
* @returns {vec3} The decoded and normalized vector
@@ -54,12 +54,12 @@
float y = (temp - x) * 256.0;
return czm_octDecode(vec2(x, y));
}
-
+
/**
* Decodes three unit-length vectors in 'oct' encoding packed into two floating-point numbers to normalized 3-component Cartesian vectors.
* The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
* Cigolle et al 2014: http://jcgt.org/published/0003/02/01/
- *
+ *
* @name czm_octDecode
* @param {vec2} encoded The packed oct-encoded, unit-length vectors.
* @param {vec3} vector1 One decoded and normalized vector.
@@ -80,4 +80,4 @@
vector2 = czm_octDecode(encodedFloat2);
vector3 = czm_octDecode(vec2(x, y));
}
-
+
diff --git a/Source/Shaders/Builtin/Functions/transformPlane.glsl b/Source/Shaders/Builtin/Functions/transformPlane.glsl
new file mode 100644
index 000000000000..3f0412c891cb
--- /dev/null
+++ b/Source/Shaders/Builtin/Functions/transformPlane.glsl
@@ -0,0 +1,8 @@
+vec4 czm_transformPlane(mat4 transform, vec4 clippingPlane) {
+ vec3 transformedDirection = normalize((transform * vec4(clippingPlane.xyz, 0.0)).xyz);
+ vec3 transformedPosition = (transform * vec4(clippingPlane.xyz * -clippingPlane.w, 1.0)).xyz;
+ vec4 transformedPlane;
+ transformedPlane.xyz = transformedDirection;
+ transformedPlane.w = -dot(transformedDirection, transformedPosition);
+ return transformedPlane;
+}
diff --git a/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.glsl b/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.glsl
index f429c26875ec..91bd5e3164f6 100644
--- a/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.glsl
+++ b/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.glsl
@@ -31,9 +31,12 @@ vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)
vec4 q = vec4(x, y, z, 1.0);
q /= fragmentCoordinate.w;
- if (czm_inverseProjection != mat4(0.0)) {
+ if (!(czm_inverseProjection == mat4(0.0))) // IE and Edge sometimes do something weird with != between mat4s
+ {
q = czm_inverseProjection * q;
- } else {
+ }
+ else
+ {
float top = czm_frustumPlanes.x;
float bottom = czm_frustumPlanes.y;
float left = czm_frustumPlanes.z;
diff --git a/Source/Shaders/GlobeFS.glsl b/Source/Shaders/GlobeFS.glsl
index f41b6eb34b31..bf64b95bcdf5 100644
--- a/Source/Shaders/GlobeFS.glsl
+++ b/Source/Shaders/GlobeFS.glsl
@@ -52,8 +52,8 @@ uniform vec2 u_lightingFadeDistance;
#endif
#ifdef ENABLE_CLIPPING_PLANES
-uniform int u_clippingPlanesLength;
-uniform vec4 u_clippingPlanes[czm_maxClippingPlanes];
+uniform sampler2D u_clippingPlanes;
+uniform mat4 u_clippingPlanesMatrix;
uniform vec4 u_clippingPlanesEdgeStyle;
#endif
@@ -156,11 +156,7 @@ vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat
void main()
{
#ifdef ENABLE_CLIPPING_PLANES
- #ifdef UNION_CLIPPING_REGIONS
- float clipDistance = czm_discardIfClippedWithUnion(u_clippingPlanes, u_clippingPlanesLength);
- #else
- float clipDistance = czm_discardIfClippedWithIntersect(u_clippingPlanes, u_clippingPlanesLength);
- #endif
+ float clipDistance = clip(gl_FragCoord, u_clippingPlanes, u_clippingPlanesMatrix);
#endif
// The clamp below works around an apparent bug in Chrome Canary v23.0.1241.0
diff --git a/Source/ThirdParty/draco-decoder-gltf.js b/Source/ThirdParty/draco-decoder-gltf.js
new file mode 100644
index 000000000000..bf59515f91c6
--- /dev/null
+++ b/Source/ThirdParty/draco-decoder-gltf.js
@@ -0,0 +1,27 @@
+define([], function() {
+ DracoDecoderModule = {};
+ var Module = DracoDecoderModule; // included code may refer to Module (e.g. from file packager), so alias it
+
+var isRuntimeInitialized=false;var isModuleParsed=false;Module["onRuntimeInitialized"]=(function(){isRuntimeInitialized=true;if(isModuleParsed){if(typeof Module["onModuleLoaded"]==="function"){Module["onModuleLoaded"](Module)}}});Module["onModuleParsed"]=(function(){isModuleParsed=true;if(isRuntimeInitialized){if(typeof Module["onModuleLoaded"]==="function"){Module["onModuleLoaded"](Module)}}});function isVersionSupported(versionString){if(typeof versionString!=="string")return false;const version=versionString.split(".");if(version.length<2||version.length>3)return false;if(version[0]==1&&version[1]>=0&&version[1]<=2)return true;if(version[0]!=0||version[1]>10)return false;return true}Module["isVersionSupported"]=isVersionSupported;var Module;if(!Module)Module=(typeof DracoDecoderModule!=="undefined"?DracoDecoderModule:null)||{};var moduleOverrides={};var key;for(key in Module){if(Module.hasOwnProperty(key)){moduleOverrides[key]=Module[key]}}var ENVIRONMENT_IS_WEB=false;var ENVIRONMENT_IS_WORKER=false;var ENVIRONMENT_IS_NODE=false;var ENVIRONMENT_IS_SHELL=false;if(Module["ENVIRONMENT"]){if(Module["ENVIRONMENT"]==="WEB"){ENVIRONMENT_IS_WEB=true}else if(Module["ENVIRONMENT"]==="WORKER"){ENVIRONMENT_IS_WORKER=true}else if(Module["ENVIRONMENT"]==="NODE"){ENVIRONMENT_IS_NODE=true}else if(Module["ENVIRONMENT"]==="SHELL"){ENVIRONMENT_IS_SHELL=true}else{throw new Error("The provided Module['ENVIRONMENT'] value is not valid. It must be one of: WEB|WORKER|NODE|SHELL.")}}else{ENVIRONMENT_IS_WEB=typeof window==="object";ENVIRONMENT_IS_WORKER=typeof importScripts==="function";ENVIRONMENT_IS_NODE=typeof process==="object"&&typeof require==="function"&&!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_WORKER;ENVIRONMENT_IS_SHELL=!ENVIRONMENT_IS_WEB&&!ENVIRONMENT_IS_NODE&&!ENVIRONMENT_IS_WORKER}if(ENVIRONMENT_IS_NODE){if(!Module["print"])Module["print"]=console.log;if(!Module["printErr"])Module["printErr"]=console.warn;var nodeFS;var nodePath;Module["read"]=function shell_read(filename,binary){var ret;ret=tryParseAsDataURI(filename);if(!ret){if(!nodeFS)nodeFS=require("fs");if(!nodePath)nodePath=require("path");filename=nodePath["normalize"](filename);ret=nodeFS["readFileSync"](filename)}return binary?ret:ret.toString()};Module["readBinary"]=function readBinary(filename){var ret=Module["read"](filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}assert(ret.buffer);return ret};if(!Module["thisProgram"]){if(process["argv"].length>1){Module["thisProgram"]=process["argv"][1].replace(/\\/g,"/")}else{Module["thisProgram"]="unknown-program"}}Module["arguments"]=process["argv"].slice(2);process["on"]("uncaughtException",(function(ex){if(!(ex instanceof ExitStatus)){throw ex}}));Module["inspect"]=(function(){return"[Emscripten Module object]"})}else if(ENVIRONMENT_IS_SHELL){if(!Module["print"])Module["print"]=print;if(typeof printErr!="undefined")Module["printErr"]=printErr;if(typeof read!="undefined"){Module["read"]=function shell_read(f){var data=tryParseAsDataURI(f);if(data){return intArrayToString(data)}return read(f)}}else{Module["read"]=function shell_read(){throw"no read() available"}}Module["readBinary"]=function readBinary(f){var data;data=tryParseAsDataURI(f);if(data){return data}if(typeof readbuffer==="function"){return new Uint8Array(readbuffer(f))}data=read(f,"binary");assert(typeof data==="object");return data};if(typeof scriptArgs!="undefined"){Module["arguments"]=scriptArgs}else if(typeof arguments!="undefined"){Module["arguments"]=arguments}if(typeof quit==="function"){Module["quit"]=(function(status,toThrow){quit(status)})}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){Module["read"]=function shell_read(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}};if(ENVIRONMENT_IS_WORKER){Module["readBinary"]=function readBinary(url){try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}}}Module["readAsync"]=function readAsync(url,onload,onerror){var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=function xhr_onload(){if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror()};xhr.onerror=onerror;xhr.send(null)};if(typeof arguments!="undefined"){Module["arguments"]=arguments}if(typeof console!=="undefined"){if(!Module["print"])Module["print"]=function shell_print(x){console.log(x)};if(!Module["printErr"])Module["printErr"]=function shell_printErr(x){console.warn(x)}}else{var TRY_USE_DUMP=false;if(!Module["print"])Module["print"]=TRY_USE_DUMP&&typeof dump!=="undefined"?(function(x){dump(x)}):(function(x){})}if(typeof Module["setWindowTitle"]==="undefined"){Module["setWindowTitle"]=(function(title){document.title=title})}}else{throw new Error("Unknown runtime environment. Where are we?")}if(!Module["print"]){Module["print"]=(function(){})}if(!Module["printErr"]){Module["printErr"]=Module["print"]}if(!Module["arguments"]){Module["arguments"]=[]}if(!Module["thisProgram"]){Module["thisProgram"]="./this.program"}if(!Module["quit"]){Module["quit"]=(function(status,toThrow){throw toThrow})}Module.print=Module["print"];Module.printErr=Module["printErr"];Module["preRun"]=[];Module["postRun"]=[];for(key in moduleOverrides){if(moduleOverrides.hasOwnProperty(key)){Module[key]=moduleOverrides[key]}}moduleOverrides=undefined;var Runtime={setTempRet0:(function(value){tempRet0=value;return value}),getTempRet0:(function(){return tempRet0}),stackSave:(function(){return STACKTOP}),stackRestore:(function(stackTop){STACKTOP=stackTop}),getNativeTypeSize:(function(type){switch(type){case"i1":case"i8":return 1;case"i16":return 2;case"i32":return 4;case"i64":return 8;case"float":return 4;case"double":return 8;default:{if(type[type.length-1]==="*"){return Runtime.QUANTUM_SIZE}else if(type[0]==="i"){var bits=parseInt(type.substr(1));assert(bits%8===0);return bits/8}else{return 0}}}}),getNativeFieldSize:(function(type){return Math.max(Runtime.getNativeTypeSize(type),Runtime.QUANTUM_SIZE)}),STACK_ALIGN:16,prepVararg:(function(ptr,type){if(type==="double"||type==="i64"){if(ptr&7){assert((ptr&7)===4);ptr+=4}}else{assert((ptr&3)===0)}return ptr}),getAlignSize:(function(type,size,vararg){if(!vararg&&(type=="i64"||type=="double"))return 8;if(!type)return Math.min(size,8);return Math.min(size||(type?Runtime.getNativeFieldSize(type):0),Runtime.QUANTUM_SIZE)}),dynCall:(function(sig,ptr,args){if(args&&args.length){return Module["dynCall_"+sig].apply(null,[ptr].concat(args))}else{return Module["dynCall_"+sig].call(null,ptr)}}),functionPointers:[],addFunction:(function(func){for(var i=0;i>>0)):0)?(E=n+i|0,E=h[E>>0]|h[E+1>>0]<<8|h[E+2>>0]<<16|h[E+3>>0]<<24,A=o,f[A>>2]=p,f[A+4>>2]=q,wh(a,E)|0,im(B),f[r>>2]=a,f[r+4>>2]=0,f[C>>2]=f[r>>2],f[C+4>>2]=f[r+4>>2],ld(B,c,C)|0):0){E=1;u=D;return E|0}E=0;u=D;return E|0}case 1:{a:do if((m|0)>(e|0)|(m|0)==(e|0)&l>>>0>d>>>0){i=b[n+d>>0]|0;g=Hl(j|0,k|0,2,0)|0;E=o;f[E>>2]=g;f[E+4>>2]=I;if((i&255)>6){f[s>>2]=i&255;nl(4934,s)|0;break}d=Hl(j|0,k|0,6,0)|0;e=I;if(!((m|0)<(e|0)|(m|0)==(e|0)&l>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0 >>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;q=Hl(g|0,j|0,4,0)|0;p=I;if((i|0)<(p|0)|(i|0)==(p|0)&e>>>0>>0)r=x;else r=(x>>>0)%(s>>>0)|0;else r=x&q;j=f[(f[a>>2]|0)+(r<<2)>>2]|0;if((j|0)!=0?(e=f[j>>2]|0,(e|0)!=0):0){p=(v|0)==0;if(k){if(p){d=e;while(1){w=f[d+4>>2]|0;if(!((w|0)==(x|0)|(w&q|0)==(r|0))){d=r;break a}w=b[d+8+11>>0]|0;if(!((w<<24>>24<0?f[d+12>>2]|0:w&255)|0)){j=d;break}d=f[d>>2]|0;if(!d){d=r;break a}}a=j+20|0;return a|0}else j=e;b:while(1){o=f[j+4>>2]|0;if(!((o|0)==(x|0)|(o&q|0)==(r|0))){d=r;break a}k=j+8|0;m=b[k+11>>0]|0;o=m<<24>>24<0;m=m&255;do if(((o?f[j+12>>2]|0:m)|0)==(v|0)){l=f[k>>2]|0;if(o)if(!(ij(l,w,v)|0)){z=63;break b}else break;if((l&255)<<24>>24==(b[w>>0]|0)){l=w;do{m=m+-1|0;k=k+1|0;if(!m){z=63;break b}l=l+1|0}while((b[k>>0]|0)==(b[l>>0]|0))}}while(0);j=f[j>>2]|0;if(!j){d=r;break a}}if((z|0)==63){a=j+20|0;return a|0}}if(p){while(1){d=f[e+4>>2]|0;if((d|0)!=(x|0)){if(d>>>0>=s>>>0)d=(d>>>0)%(s>>>0)|0;if((d|0)!=(r|0)){d=r;break a}}w=b[e+8+11>>0]|0;if(!((w<<24>>24<0?f[e+12>>2]|0:w&255)|0)){j=e;break}e=f[e>>2]|0;if(!e){d=r;break a}}a=j+20|0;return a|0}c:while(1){j=f[e+4>>2]|0;if((j|0)!=(x|0)){if(j>>>0>=s>>>0)j=(j>>>0)%(s>>>0)|0;if((j|0)!=(r|0)){d=r;break a}}j=e+8|0;l=b[j+11>>0]|0;m=l<<24>>24<0;l=l&255;do if(((m?f[e+12>>2]|0:l)|0)==(v|0)){k=f[j>>2]|0;if(m)if(!(ij(k,w,v)|0)){j=e;z=63;break c}else break;if((k&255)<<24>>24==(b[w>>0]|0)){k=w;do{l=l+-1|0;j=j+1|0;if(!l){j=e;z=63;break c}k=k+1|0}while((b[j>>0]|0)==(b[k>>0]|0))}}while(0);e=f[e>>2]|0;if(!e){d=r;break a}}if((z|0)==63){a=j+20|0;return a|0}}else d=r}else d=0;while(0);l=Rk(24)|0;lh(l+8|0,c);f[l+20>>2]=0;f[l+4>>2]=x;f[l>>2]=0;k=a+12|0;i=$(((f[k>>2]|0)+1|0)>>>0);A=$(s>>>0);g=$(n[a+16>>2]);do if(u|i>$(A*g)){d=(s>>>0<3|(s+-1&s|0)!=0)&1|s<<1;e=~~$(W($(i/g)))>>>0;Zf(a,d>>>0>>0;h=l?i:q;if((h|0)!=0?(k=ij(r?f[g>>2]|0:g,m?f[j>>2]|0:j,h)|0,(k|0)!=0):0){if((k|0)<0)break}else u=4;if((u|0)==4?q>>>0>>0:0)break;h=q>>>0>>0?q:i;if((h|0)!=0?(n=ij(m?f[j>>2]|0:j,r?f[g>>2]|0:g,h)|0,(n|0)!=0):0){if((n|0)>=0)u=36}else u=20;if((u|0)==20?!l:0)u=36;if((u|0)==36){f[d>>2]=c;f[e>>2]=c;d=e;return d|0}m=t+4|0;h=f[m>>2]|0;if(!h){i=t+8|0;h=f[i>>2]|0;if((f[h>>2]|0)!=(t|0))do{p=f[i>>2]|0;i=p+8|0;h=f[i>>2]|0}while((f[h>>2]|0)!=(p|0))}else while(1){i=f[h>>2]|0;if(!i)break;else h=i}do if((h|0)!=(o|0)){j=h+16|0;k=b[j+11>>0]|0;l=k<<24>>24<0;k=l?f[h+20>>2]|0:k&255;i=k>>>0
>>0?k:q;if((i|0)!=0?(s=ij(r?f[g>>2]|0:g,l?f[j>>2]|0:j,i)|0,(s|0)!=0):0){if((s|0)<0)break}else u=30;if((u|0)==30?q>>>0
>>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;r=Hl(g|0,j|0,4,0)|0;q=I;if((i|0)<(q|0)|(i|0)==(q|0)&e>>>0
>>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;r=Hl(g|0,j|0,4,0)|0;q=I;if((i|0)<(q|0)|(i|0)==(q|0)&e>>>0
>>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;r=Hl(g|0,j|0,4,0)|0;q=I;if((i|0)<(q|0)|(i|0)==(q|0)&e>>>0
>>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;r=Hl(g|0,j|0,4,0)|0;q=I;if((i|0)<(q|0)|(i|0)==(q|0)&e>>>0
>>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;r=Hl(g|0,j|0,4,0)|0;q=I;if((i|0)<(q|0)|(i|0)==(q|0)&e>>>0
>>0)i=k;else{g=(f[c>>2]|0)+g|0;g=h[g>>0]|h[g+1>>0]<<8|h[g+2>>0]<<16|h[g+3>>0]<<24;b[a>>0]=g;b[a+1>>0]=g>>8;b[a+2>>0]=g>>16;b[a+3>>0]=g>>24;g=l;g=Hl(f[g>>2]|0,f[g+4>>2]|0,4,0)|0;j=I;e=l;f[e>>2]=g;f[e+4>>2]=j;e=i;i=f[e+4>>2]|0;e=f[e>>2]|0}k=a+4|0;r=Hl(g|0,j|0,4,0)|0;q=I;if((i|0)<(q|0)|(i|0)==(q|0)&e>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(oe(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+32|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+52|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+72|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;f[m>>2]=f[d>>2];f[n>>2]=f[m>>2];ib(a,q,n);q=1;u=o;return q|0}function td(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;o=u;u=u+16|0;n=o+4|0;m=o;i=c+8|0;k=i;e=f[k>>2]|0;k=f[k+4>>2]|0;l=c+16|0;j=l;g=f[j>>2]|0;j=f[j+4>>2]|0;p=Hl(g|0,j|0,4,0)|0;q=I;if((k|0)<(q|0)|(k|0)==(q|0)&e>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(oe(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+32|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+52|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+72|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;f[m>>2]=f[d>>2];f[n>>2]=f[m>>2];gb(a,q,n);q=1;u=o;return q|0}function ud(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;o=u;u=u+16|0;n=o+4|0;m=o;i=c+8|0;k=i;e=f[k>>2]|0;k=f[k+4>>2]|0;l=c+16|0;j=l;g=f[j>>2]|0;j=f[j+4>>2]|0;p=Hl(g|0,j|0,4,0)|0;q=I;if((k|0)<(q|0)|(k|0)==(q|0)&e>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(nd(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+28|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+48|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+68|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;f[m>>2]=f[d>>2];f[n>>2]=f[m>>2];ub(a,q,n);q=1;u=o;return q|0}function vd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;o=u;u=u+16|0;n=o+4|0;m=o;i=c+8|0;k=i;e=f[k>>2]|0;k=f[k+4>>2]|0;l=c+16|0;j=l;g=f[j>>2]|0;j=f[j+4>>2]|0;p=Hl(g|0,j|0,4,0)|0;q=I;if((k|0)<(q|0)|(k|0)==(q|0)&e>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(nd(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+28|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+48|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+68|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;f[m>>2]=f[d>>2];f[n>>2]=f[m>>2];tb(a,q,n);q=1;u=o;return q|0}function wd(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0;q=f[a+8>>2]|0;k=a+76|0;d=f[k>>2]|0;m=f[d+80>>2]|0;r=c+84|0;b[r>>0]=0;j=c+68|0;h=c+72|0;g=f[h>>2]|0;e=f[j>>2]|0;l=g-e>>2;if(m>>>0<=l>>>0){if(m>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(oe(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+32|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+52|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+72|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;c=d;d=f[c+4>>2]|0;p=m;f[p>>2]=f[c>>2];f[p+4>>2]=d;f[n>>2]=f[m>>2];f[n+4>>2]=f[m+4>>2];hb(a,q,n);q=1;u=o;return q|0}function yd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;o=u;u=u+16|0;n=o+8|0;m=o;i=c+8|0;k=i;e=f[k>>2]|0;k=f[k+4>>2]|0;l=c+16|0;j=l;g=f[j>>2]|0;j=f[j+4>>2]|0;p=Hl(g|0,j|0,4,0)|0;q=I;if((k|0)<(q|0)|(k|0)==(q|0)&e>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(oe(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+32|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+52|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+72|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;c=d;d=f[c+4>>2]|0;p=m;f[p>>2]=f[c>>2];f[p+4>>2]=d;f[n>>2]=f[m>>2];f[n+4>>2]=f[m+4>>2];fb(a,q,n);q=1;u=o;return q|0}function zd(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0,r=0;q=f[a+8>>2]|0;k=a+112|0;d=f[k>>2]|0;m=f[d+80>>2]|0;r=c+84|0;b[r>>0]=0;j=c+68|0;h=c+72|0;g=f[h>>2]|0;e=f[j>>2]|0;l=g-e>>2;if(m>>>0<=l>>>0){if(m>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(nd(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+28|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+48|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+68|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;c=d;d=f[c+4>>2]|0;p=m;f[p>>2]=f[c>>2];f[p+4>>2]=d;f[n>>2]=f[m>>2];f[n+4>>2]=f[m+4>>2];sb(a,q,n);q=1;u=o;return q|0}function Bd(a,c,d){a=a|0;c=c|0;d=d|0;var e=0,g=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0,p=0,q=0;o=u;u=u+16|0;n=o+8|0;m=o;i=c+8|0;k=i;e=f[k>>2]|0;k=f[k+4>>2]|0;l=c+16|0;j=l;g=f[j>>2]|0;j=f[j+4>>2]|0;p=Hl(g|0,j|0,4,0)|0;q=I;if((k|0)<(q|0)|(k|0)==(q|0)&e>>>0
>>0)e=f[k>>2]|0;else{e=(f[c>>2]|0)+g|0;e=h[e>>0]|h[e+1>>0]<<8|h[e+2>>0]<<16|h[e+3>>0]<<24;b[k>>0]=e;b[k+1>>0]=e>>8;b[k+2>>0]=e>>16;b[k+3>>0]=e>>24;p=l;p=Hl(f[p>>2]|0,f[p+4>>2]|0,4,0)|0;q=l;f[q>>2]=p;f[q+4>>2]=I}if(!e){q=1;u=o;return q|0}if(!(nd(a+12|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+28|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+48|0,c)|0)){q=0;u=o;return q|0}if(!(oe(a+68|0,c)|0)){q=0;u=o;return q|0}q=f[k>>2]|0;c=d;d=f[c+4>>2]|0;p=m;f[p>>2]=f[c>>2];f[p+4>>2]=d;f[n>>2]=f[m>>2];f[n+4>>2]=f[m+4>>2];rb(a,q,n);q=1;u=o;return q|0}function Cd(a,c){a=a|0;c=c|0;var d=0,e=0,g=0,h=0,i=0,j=0,k=0,l=0,m=0,n=0,o=0;m=u;u=u+16|0;k=m;if(!(Wb(a,c)|0)){a=0;u=m;return a|0}j=Na[f[(f[a>>2]|0)+24>>2]&127](a)|0;l=a+36|0;h=a+40|0;d=f[h>>2]|0;e=f[l>>2]|0;g=d-e>>2;if(j>>>0<=g>>>0){if(j>>>0
>>0){a=0;return a|0}ef(f[a>>2]|0,(f[b>>2]|0)+g|0,o|0)|0;q=r;q=Hl(f[q>>2]|0,f[q+4>>2]|0,o|0,0)|0;b=r;f[b>>2]=q;f[b+4>>2]=I;f[t>>2]=f[a>>2];f[s>>2]=0;a=1;return a|0}function pe(a,b,c,d){a=a|0;b=$(b);c=$(c);d=d|0;var e=La,f=La,g=0.0,h=La,i=La,j=0.0,k=0.0,l=0.0,m=0.0;if(!(b>=$(0.0)))ra(9337,9190,191,9351);if(!(c>=$(0.0)))ra(9380,9190,192,9351);if(!(b<=$(1.0)))ra(9394,9190,193,9351);if(!(c<=$(1.0)))ra(9408,9190,194,9351);f=$(b+c);e=$(b-c);if(!(e<=$(.5))|(!(e>=$(-.5))|(!(f>=$(.5))|!(f<=$(1.5))))){do if(!(f<=$(.5))){if(f>=$(1.5)){e=$($(1.5)-c);c=$($(1.5)-b);break}if(!(e<=$(-.5))){e=$(c+$(.5));c=$(b+$(-.5));break}else{e=$(c+$(-.5));c=$(b+$(.5));break}}else{e=$($(.5)-c);c=$($(.5)-b)}while(0);b=e;i=$(e-c);f=$(c+e);g=-1.0}else{i=e;g=1.0}h=$(+b*2.0+-1.0);b=$(+c*2.0+-1.0);l=+f*2.0;j=l+-1.0;l=3.0-l;m=+i*2.0;k=m+1.0;m=1.0-m;k=m