From 28d2921c14ea5e4ea5a62ce30451948b01116955 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Fri, 6 Oct 2017 17:30:41 +0200
Subject: [PATCH 01/26] Added properties ImageryLayer.minificationFilter and
 .magnificationFilter

---
 CHANGES.md                      |  9 +++++
 Source/Scene/ImageryLayer.js    | 67 +++++++++++++++++++++++++++++----
 Specs/Scene/ImageryLayerSpec.js | 23 +++++++++++
 3 files changed, 92 insertions(+), 7 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 432dff7bc1a0..a064ecbeb424 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -1,5 +1,14 @@
 Change Log
 ==========
+
+### 1.39 - 2017-11-??
+
+* Added two new properties to `ImageryLayer` that allow for adjusting the texture sampler used for up- and down-sampling
+  of image tiles, namely `minificationFilter` and `magnificationFilter` with possible values `LINEAR`
+  (the default) and `NEAREST` defined in `TextureMinificationFilter` and `TextureMagnificationFilter`.
+  [#5846](https://github.com/AnalyticalGraphicsInc/cesium/issues/5846)
+    
+
 ### 1.38 - 2017-10-02
 
 * Breaking changes
diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index c03383ec04c1..1834642aeea2 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -136,6 +136,14 @@ define([
      *                          the gamma value to use for the tile.  The function is executed for every
      *                          frame and for every tile, so it must be fast.
      * @param {ImagerySplitDirection|Function} [options.splitDirection=ImagerySplitDirection.NONE] The {@link ImagerySplitDirection} split to apply to this layer.
+     * @param {TextureMinificationFilter} [options.minificationFilter=TextureMinificationFilter.LINEAR] The
+     *                                    texture minification filter to apply to this layer. Possible values
+     *                                    are <code>TextureMinificationFilter.LINEAR</code> and
+     *                                    <code>TextureMinificationFilter.NEAREST</code>.
+     * @param {TextureMagnificationFilter} [options.magnificationFilter=TextureMagnificationFilter.LINEAR] The
+     *                                     texture minification filter to apply to this layer. Possible values
+     *                                     are <code>TextureMagnificationFilter.LINEAR</code> and
+     *                                     <code>TextureMagnificationFilter.NEAREST</code>.
      * @param {Boolean} [options.show=true] True if the layer is shown; otherwise, false.
      * @param {Number} [options.maximumAnisotropy=maximum supported] The maximum anisotropy level to use
      *        for texture filtering.  If this parameter is not specified, the maximum anisotropy supported
@@ -211,6 +219,22 @@ define([
          */
         this.splitDirection = defaultValue(options.splitDirection, defaultValue(imageryProvider.defaultSplit, ImageryLayer.DEFAULT_SPLIT));
 
+        /**
+         * The {@link TextureMinificationFilter} to apply to this layer.
+         *
+         * @type {TextureMinificationFilter}
+         * @default {@link ImageryLayer.DEFAULT_MINIFICATION_FILTER}
+         */
+        this.minificationFilter = defaultValue(options.minificationFilter, defaultValue(imageryProvider.defaultMinificationFilter, ImageryLayer.DEFAULT_MINIFICATION_FILTER));
+
+        /**
+         * The {@link TextureMagnificationFilter} to apply to this layer.
+         *
+         * @type {TextureMagnificationFilter}
+         * @default {@link ImageryLayer.DEFAULT_MAGNIFICATION_FILTER}
+         */
+        this.magnificationFilter = defaultValue(options.magnificationFilter, defaultValue(imageryProvider.defaultMagnificationFilter, ImageryLayer.DEFAULT_MAGNIFICATION_FILTER));
+
         /**
          * Determines if this layer is shown.
          *
@@ -309,13 +333,29 @@ define([
     ImageryLayer.DEFAULT_GAMMA = 1.0;
 
     /**
-     * This value is used as the default spliat for the imagery layer if one is not provided during construction
+     * This value is used as the default split for the imagery layer if one is not provided during construction
      * or by the imagery provider.
      * @type {ImagerySplitDirection}
      * @default ImagerySplitDirection.NONE
      */
     ImageryLayer.DEFAULT_SPLIT = ImagerySplitDirection.NONE;
 
+    /**
+     * This value is used as the default texture magnification filter for the imagery layer if one is not provided
+     * during construction or by the imagery provider.
+     * @type {TextureMagnificationFilter}
+     * @default TextureMagnificationFilter.LINEAR
+     */
+    ImageryLayer.DEFAULT_MAGNIFICATION_FILTER = TextureMagnificationFilter.LINEAR;
+
+    /**
+     * This value is used as the default texture minification filter for the imagery layer if one is not provided
+     * during construction or by the imagery provider.
+     * @type {TextureMinificationFilter}
+     * @default TextureMinificationFilter.LINEAR
+     */
+    ImageryLayer.DEFAULT_MINIFICATION_FILTER = TextureMinificationFilter.LINEAR;
+
     /**
      * Gets a value indicating whether this layer is the base layer in the
      * {@link ImageryLayerCollection}.  The base layer is the one that underlies all
@@ -764,6 +804,11 @@ define([
             }
         }
 
+        var sampler = new Sampler({
+            minificationFilter : this.minificationFilter,
+            magnificationFilter : this.magnificationFilter
+        });
+
         // Imagery does not need to be discarded, so upload it to WebGL.
         var texture;
         if (defined(image.internalFormat)) {
@@ -774,13 +819,15 @@ define([
                 height : image.height,
                 source : {
                     arrayBufferView : image.bufferView
-                }
+                },
+                sampler: sampler
             });
         } else {
             texture = new Texture({
                 context : context,
                 source : image,
-                pixelFormat : imageryProvider.hasAlphaChannel ? PixelFormat.RGBA : PixelFormat.RGB
+                pixelFormat : imageryProvider.hasAlphaChannel ? PixelFormat.RGBA : PixelFormat.RGB,
+                sampler: sampler
             });
         }
 
@@ -799,11 +846,17 @@ define([
             var mipmapSampler = context.cache.imageryLayer_mipmapSampler;
             if (!defined(mipmapSampler)) {
                 var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;
+                var minificationFilter = imageryLayer.minificationFilter;
+                if (imageryLayer.minificationFilter === TextureMinificationFilter.NEAREST) {
+                    minificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
+                } else if (imageryLayer.minificationFilter === TextureMinificationFilter.LINEAR) {
+                    minificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
+                }
                 mipmapSampler = context.cache.imageryLayer_mipmapSampler = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,
-                    minificationFilter : TextureMinificationFilter.LINEAR_MIPMAP_LINEAR,
-                    magnificationFilter : TextureMagnificationFilter.LINEAR,
+                    minificationFilter : minificationFilter,
+                    magnificationFilter : imageryLayer.magnificationFilter,
                     maximumAnisotropy : Math.min(maximumSupportedAnisotropy, defaultValue(imageryLayer._maximumAnisotropy, maximumSupportedAnisotropy))
                 });
             }
@@ -815,8 +868,8 @@ define([
                 nonMipmapSampler = context.cache.imageryLayer_nonMipmapSampler = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,
-                    minificationFilter : TextureMinificationFilter.LINEAR,
-                    magnificationFilter : TextureMagnificationFilter.LINEAR
+                    minificationFilter : imageryLayer.minificationFilter,
+                    magnificationFilter : imageryLayer.magnificationFilter
                 });
             }
             texture.sampler = nonMipmapSampler;
diff --git a/Specs/Scene/ImageryLayerSpec.js b/Specs/Scene/ImageryLayerSpec.js
index fbb3211d453e..fbcc38c51af9 100644
--- a/Specs/Scene/ImageryLayerSpec.js
+++ b/Specs/Scene/ImageryLayerSpec.js
@@ -7,6 +7,8 @@ defineSuite([
         'Core/Rectangle',
         'Core/RequestScheduler',
         'Renderer/ComputeEngine',
+        'Renderer/TextureMagnificationFilter',
+        'Renderer/TextureMinificationFilter',
         'Scene/ArcGisMapServerImageryProvider',
         'Scene/BingMapsImageryProvider',
         'Scene/createTileMapServiceImageryProvider',
@@ -30,6 +32,8 @@ defineSuite([
         Rectangle,
         RequestScheduler,
         ComputeEngine,
+        TextureMagnificationFilter,
+        TextureMinificationFilter,
         ArcGisMapServerImageryProvider,
         BingMapsImageryProvider,
         createTileMapServiceImageryProvider,
@@ -367,6 +371,25 @@ defineSuite([
         expect(layer.isDestroyed()).toEqual(true);
     });
 
+    it('texture filter properties work as expected', function() {
+        var provider = new SingleTileImageryProvider({
+            url : 'Data/Images/Red16x16.png'
+        });
+
+        var layer = new ImageryLayer(provider, {});
+        expect(layer.magnificationFilter).toEqual(TextureMagnificationFilter.LINEAR);
+        expect(layer.minificationFilter).toEqual(TextureMinificationFilter.LINEAR);
+        layer.destroy();
+
+        layer = new ImageryLayer(provider, {
+            magnificationFilter: TextureMagnificationFilter.NEAREST,
+            minificationFilter: TextureMinificationFilter.NEAREST
+        });
+        expect(layer.magnificationFilter).toEqual(TextureMagnificationFilter.NEAREST);
+        expect(layer.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
+        layer.destroy();
+    });
+
     it('returns HTTP status code information in TileProviderError', function() {
         // Web browsers unfortunately provide very little information about what went wrong when an Image fails
         // to load.  But when an imagery provider is configured to use a TileDiscardPolicy, Cesium downloads the image

From 4aff9c229892e875737b292c552c3748a50c29ca Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Mon, 9 Oct 2017 16:44:41 +0200
Subject: [PATCH 02/26] Renamed local var as mipmapMinificationFilter

---
 Source/Scene/ImageryLayer.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 1834642aeea2..73838deff408 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -846,16 +846,16 @@ define([
             var mipmapSampler = context.cache.imageryLayer_mipmapSampler;
             if (!defined(mipmapSampler)) {
                 var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;
-                var minificationFilter = imageryLayer.minificationFilter;
+                var mipmapMinificationFilter = imageryLayer.minificationFilter;
                 if (imageryLayer.minificationFilter === TextureMinificationFilter.NEAREST) {
-                    minificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
+                    mipmapMinificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
                 } else if (imageryLayer.minificationFilter === TextureMinificationFilter.LINEAR) {
-                    minificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
+                    mipmapMinificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
                 }
                 mipmapSampler = context.cache.imageryLayer_mipmapSampler = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,
-                    minificationFilter : minificationFilter,
+                    minificationFilter : mipmapMinificationFilter,
                     magnificationFilter : imageryLayer.magnificationFilter,
                     maximumAnisotropy : Math.min(maximumSupportedAnisotropy, defaultValue(imageryLayer._maximumAnisotropy, maximumSupportedAnisotropy))
                 });

From c1e0e5451a1c30a03ef7ee3b8b86bf52bb4beec8 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Mon, 9 Oct 2017 17:18:29 +0200
Subject: [PATCH 03/26] Added some more API doc

---
 Source/Scene/ImageryLayer.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 73838deff408..70f5861b6b27 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -221,6 +221,8 @@ define([
 
         /**
          * The {@link TextureMinificationFilter} to apply to this layer.
+         * Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
+         * and {@link TextureMinificationFilter.NEAREST}.
          *
          * @type {TextureMinificationFilter}
          * @default {@link ImageryLayer.DEFAULT_MINIFICATION_FILTER}
@@ -229,6 +231,8 @@ define([
 
         /**
          * The {@link TextureMagnificationFilter} to apply to this layer.
+         * Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
+         * and {@link TextureMagnificationFilter.NEAREST}.
          *
          * @type {TextureMagnificationFilter}
          * @default {@link ImageryLayer.DEFAULT_MAGNIFICATION_FILTER}

From daa095f229e7304a4d1a1fd534c206ffbad9f28c Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Tue, 10 Oct 2017 10:52:56 +0200
Subject: [PATCH 04/26] Made TextureMagnification/MinificationFilter public and
 added API-docs.

---
 Source/Renderer/TextureMagnificationFilter.js | 20 +++++++++++-
 Source/Renderer/TextureMinificationFilter.js  | 32 ++++++++++++++++++-
 2 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/Source/Renderer/TextureMagnificationFilter.js b/Source/Renderer/TextureMagnificationFilter.js
index ba87c508d991..5911e0ce82f6 100644
--- a/Source/Renderer/TextureMagnificationFilter.js
+++ b/Source/Renderer/TextureMagnificationFilter.js
@@ -7,12 +7,30 @@ define([
     'use strict';
 
     /**
-     * @private
+     * Enumerates all possible filters used when magnifying WebGL textures, which takes places when zooming
+     * into imagery. Provides the possible values for the {@link ImageryLayer#magnificationFilter} property.
+     *
+     * @alias TextureMagnificationFilter
+     *
+     * @see TextureMinificationFilter
+     * @see ImageryLayer#magnificationFilter
      */
     var TextureMagnificationFilter = {
+        /**
+         * Nearest neighbor sampling of image pixels to texture.
+         */
         NEAREST : WebGLConstants.NEAREST,
+        /**
+         * Bi-linear interpolation of image pixels to texture.
+         */
         LINEAR : WebGLConstants.LINEAR,
 
+        /**
+         * Validates the given <code>textureMinificationFilter</code> with respect to the possible enum values.
+         *
+         * @param textureMagnificationFilter
+         * @returns {boolean} <code>true</code> if <code>textureMagnificationFilter</code> is valid.
+         */
         validate : function(textureMagnificationFilter) {
             return ((textureMagnificationFilter === TextureMagnificationFilter.NEAREST) ||
                     (textureMagnificationFilter === TextureMagnificationFilter.LINEAR));
diff --git a/Source/Renderer/TextureMinificationFilter.js b/Source/Renderer/TextureMinificationFilter.js
index 270d5d9ecc39..56888e0d0c68 100644
--- a/Source/Renderer/TextureMinificationFilter.js
+++ b/Source/Renderer/TextureMinificationFilter.js
@@ -7,16 +7,46 @@ define([
     'use strict';
 
     /**
-     * @private
+     * Enumerates all possible filters used when minifying WebGL textures, which takes places when zooming
+     * out of imagery. Provides the possible values for the {@link ImageryLayer#minificationFilter} property.
+     *
+     * @alias TextureMinificationFilter
+     *
+     * @see TextureMagnificationFilter
+     * @see ImageryLayer#minificationFilter
      */
     var TextureMinificationFilter = {
+        /**
+         * Nearest neighbor sampling of image pixels to texture.
+         */
         NEAREST : WebGLConstants.NEAREST,
+        /**
+         * Bi-linear interpolation of image pixels to texture.
+         */
         LINEAR : WebGLConstants.LINEAR,
+        /**
+         * WebGL <code>NEAREST_MIPMAP_NEAREST</code> interpolation of image pixels to texture.
+         */
         NEAREST_MIPMAP_NEAREST : WebGLConstants.NEAREST_MIPMAP_NEAREST,
+        /**
+         * WebGL <code>LINEAR_MIPMAP_NEAREST</code> interpolation of image pixels to texture.
+         */
         LINEAR_MIPMAP_NEAREST : WebGLConstants.LINEAR_MIPMAP_NEAREST,
+        /**
+         * WebGL <code>NEAREST_MIPMAP_LINEAR</code> interpolation of image pixels to texture.
+         */
         NEAREST_MIPMAP_LINEAR : WebGLConstants.NEAREST_MIPMAP_LINEAR,
+        /**
+         * WebGL <code>LINEAR_MIPMAP_LINEAR</code> interpolation of image pixels to texture.
+         */
         LINEAR_MIPMAP_LINEAR : WebGLConstants.LINEAR_MIPMAP_LINEAR,
 
+        /**
+         * Validates the given <code>textureMinificationFilter</code> with respect to the possible enum values.
+         *
+         * @param textureMinificationFilter
+         * @returns {boolean} <code>true</code> if <code>textureMinificationFilter</code> is valid.
+         */
         validate : function(textureMinificationFilter) {
             return ((textureMinificationFilter === TextureMinificationFilter.NEAREST) ||
                     (textureMinificationFilter === TextureMinificationFilter.LINEAR) ||

From cb90b622baeefd698d49c0a01f95f6da2de085ed Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Tue, 10 Oct 2017 11:12:12 +0200
Subject: [PATCH 05/26] Update wrt public
 TextureMagnification/MinificationFilter enums

---
 CHANGES.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGES.md b/CHANGES.md
index a064ecbeb424..f955ba6f31d8 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -7,6 +7,7 @@ Change Log
   of image tiles, namely `minificationFilter` and `magnificationFilter` with possible values `LINEAR`
   (the default) and `NEAREST` defined in `TextureMinificationFilter` and `TextureMagnificationFilter`.
   [#5846](https://github.com/AnalyticalGraphicsInc/cesium/issues/5846)
+  Hence, the enums `TextureMagnificationFilter` and `TextureMinificationFilter` have been made public. 
     
 
 ### 1.38 - 2017-10-02

From b5fe6092294b2c36e7a7bb206ae2bb137184cee8 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 17:58:04 -0700
Subject: [PATCH 06/26] avoid line breaks

---
 CHANGES.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index f955ba6f31d8..0a1134bb0a9a 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -3,11 +3,8 @@ Change Log
 
 ### 1.39 - 2017-11-??
 
-* Added two new properties to `ImageryLayer` that allow for adjusting the texture sampler used for up- and down-sampling
-  of image tiles, namely `minificationFilter` and `magnificationFilter` with possible values `LINEAR`
-  (the default) and `NEAREST` defined in `TextureMinificationFilter` and `TextureMagnificationFilter`.
-  [#5846](https://github.com/AnalyticalGraphicsInc/cesium/issues/5846)
-  Hence, the enums `TextureMagnificationFilter` and `TextureMinificationFilter` have been made public. 
+* Added two new properties to `ImageryLayer` that allow for adjusting the texture sampler used for up- and down-sampling of image tiles, namely `minificationFilter` and `magnificationFilter` with possible values `LINEAR` (the default) and `NEAREST` defined in `TextureMinificationFilter` and `TextureMagnificationFilter`. [#5846](https://github.com/AnalyticalGraphicsInc/cesium/issues/5846)
+* The enums `TextureMinificationFilter` and `TextureMagnificationFilter` have been made public to support the new texture filter properties mentioned above. 
     
 
 ### 1.38 - 2017-10-02

From 2dd4fd3c425c4bb064940f8a1330c68cf6be8070 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:00:04 -0700
Subject: [PATCH 07/26] Use @exports so enum doc appears as its own section in
 the documentation

---
 Source/Renderer/TextureMagnificationFilter.js | 2 +-
 Source/Renderer/TextureMinificationFilter.js  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Renderer/TextureMagnificationFilter.js b/Source/Renderer/TextureMagnificationFilter.js
index 5911e0ce82f6..e96a0a7251af 100644
--- a/Source/Renderer/TextureMagnificationFilter.js
+++ b/Source/Renderer/TextureMagnificationFilter.js
@@ -10,7 +10,7 @@ define([
      * Enumerates all possible filters used when magnifying WebGL textures, which takes places when zooming
      * into imagery. Provides the possible values for the {@link ImageryLayer#magnificationFilter} property.
      *
-     * @alias TextureMagnificationFilter
+     * @exports TextureMagnificationFilter
      *
      * @see TextureMinificationFilter
      * @see ImageryLayer#magnificationFilter
diff --git a/Source/Renderer/TextureMinificationFilter.js b/Source/Renderer/TextureMinificationFilter.js
index 56888e0d0c68..30e55dbc4320 100644
--- a/Source/Renderer/TextureMinificationFilter.js
+++ b/Source/Renderer/TextureMinificationFilter.js
@@ -10,7 +10,7 @@ define([
      * Enumerates all possible filters used when minifying WebGL textures, which takes places when zooming
      * out of imagery. Provides the possible values for the {@link ImageryLayer#minificationFilter} property.
      *
-     * @alias TextureMinificationFilter
+     * @exports TextureMinificationFilter
      *
      * @see TextureMagnificationFilter
      * @see ImageryLayer#minificationFilter

From b9b8ab79938d07811115dfb2cb5c95e83d95a016 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:02:01 -0700
Subject: [PATCH 08/26] added @type {Number} and @constant to enum values

---
 Source/Renderer/TextureMagnificationFilter.js |  6 ++++++
 Source/Renderer/TextureMinificationFilter.js  | 18 ++++++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/Source/Renderer/TextureMagnificationFilter.js b/Source/Renderer/TextureMagnificationFilter.js
index e96a0a7251af..91a6c5bac67e 100644
--- a/Source/Renderer/TextureMagnificationFilter.js
+++ b/Source/Renderer/TextureMagnificationFilter.js
@@ -18,10 +18,16 @@ define([
     var TextureMagnificationFilter = {
         /**
          * Nearest neighbor sampling of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         NEAREST : WebGLConstants.NEAREST,
         /**
          * Bi-linear interpolation of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         LINEAR : WebGLConstants.LINEAR,
 
diff --git a/Source/Renderer/TextureMinificationFilter.js b/Source/Renderer/TextureMinificationFilter.js
index 30e55dbc4320..e14c9d47b1f4 100644
--- a/Source/Renderer/TextureMinificationFilter.js
+++ b/Source/Renderer/TextureMinificationFilter.js
@@ -18,26 +18,44 @@ define([
     var TextureMinificationFilter = {
         /**
          * Nearest neighbor sampling of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         NEAREST : WebGLConstants.NEAREST,
         /**
          * Bi-linear interpolation of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         LINEAR : WebGLConstants.LINEAR,
         /**
          * WebGL <code>NEAREST_MIPMAP_NEAREST</code> interpolation of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         NEAREST_MIPMAP_NEAREST : WebGLConstants.NEAREST_MIPMAP_NEAREST,
         /**
          * WebGL <code>LINEAR_MIPMAP_NEAREST</code> interpolation of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         LINEAR_MIPMAP_NEAREST : WebGLConstants.LINEAR_MIPMAP_NEAREST,
         /**
          * WebGL <code>NEAREST_MIPMAP_LINEAR</code> interpolation of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         NEAREST_MIPMAP_LINEAR : WebGLConstants.NEAREST_MIPMAP_LINEAR,
         /**
          * WebGL <code>LINEAR_MIPMAP_LINEAR</code> interpolation of image pixels to texture.
+         *
+         * @type {Number}
+         * @constant
          */
         LINEAR_MIPMAP_LINEAR : WebGLConstants.LINEAR_MIPMAP_LINEAR,
 

From 722cd71d6b38520587da1dc92001b1e2bac78149 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:03:09 -0700
Subject: [PATCH 09/26] use upper case Boolean

---
 Source/Renderer/TextureMagnificationFilter.js | 2 +-
 Source/Renderer/TextureMinificationFilter.js  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Renderer/TextureMagnificationFilter.js b/Source/Renderer/TextureMagnificationFilter.js
index 91a6c5bac67e..2fd64b300d4a 100644
--- a/Source/Renderer/TextureMagnificationFilter.js
+++ b/Source/Renderer/TextureMagnificationFilter.js
@@ -35,7 +35,7 @@ define([
          * Validates the given <code>textureMinificationFilter</code> with respect to the possible enum values.
          *
          * @param textureMagnificationFilter
-         * @returns {boolean} <code>true</code> if <code>textureMagnificationFilter</code> is valid.
+         * @returns {Boolean} <code>true</code> if <code>textureMagnificationFilter</code> is valid.
          */
         validate : function(textureMagnificationFilter) {
             return ((textureMagnificationFilter === TextureMagnificationFilter.NEAREST) ||
diff --git a/Source/Renderer/TextureMinificationFilter.js b/Source/Renderer/TextureMinificationFilter.js
index e14c9d47b1f4..df08f2d960ed 100644
--- a/Source/Renderer/TextureMinificationFilter.js
+++ b/Source/Renderer/TextureMinificationFilter.js
@@ -63,7 +63,7 @@ define([
          * Validates the given <code>textureMinificationFilter</code> with respect to the possible enum values.
          *
          * @param textureMinificationFilter
-         * @returns {boolean} <code>true</code> if <code>textureMinificationFilter</code> is valid.
+         * @returns {Boolean} <code>true</code> if <code>textureMinificationFilter</code> is valid.
          */
         validate : function(textureMinificationFilter) {
             return ((textureMinificationFilter === TextureMinificationFilter.NEAREST) ||

From d5ccbb839245eaf2d87eb4cc222c7ac2b784ab1e Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:04:07 -0700
Subject: [PATCH 10/26] made validate() methods @private

---
 Source/Renderer/TextureMagnificationFilter.js | 2 ++
 Source/Renderer/TextureMinificationFilter.js  | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/Source/Renderer/TextureMagnificationFilter.js b/Source/Renderer/TextureMagnificationFilter.js
index 2fd64b300d4a..edb9f3bf354d 100644
--- a/Source/Renderer/TextureMagnificationFilter.js
+++ b/Source/Renderer/TextureMagnificationFilter.js
@@ -34,6 +34,8 @@ define([
         /**
          * Validates the given <code>textureMinificationFilter</code> with respect to the possible enum values.
          *
+         * @private
+         *
          * @param textureMagnificationFilter
          * @returns {Boolean} <code>true</code> if <code>textureMagnificationFilter</code> is valid.
          */
diff --git a/Source/Renderer/TextureMinificationFilter.js b/Source/Renderer/TextureMinificationFilter.js
index df08f2d960ed..0f31ea0ee810 100644
--- a/Source/Renderer/TextureMinificationFilter.js
+++ b/Source/Renderer/TextureMinificationFilter.js
@@ -62,6 +62,8 @@ define([
         /**
          * Validates the given <code>textureMinificationFilter</code> with respect to the possible enum values.
          *
+         * @private
+         *
          * @param textureMinificationFilter
          * @returns {Boolean} <code>true</code> if <code>textureMinificationFilter</code> is valid.
          */

From 8d27fe19ba02ddd74b15bb5e8fee2126e6e39570 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:11:32 -0700
Subject: [PATCH 11/26] added defaultMinificationFilter and
 defaultMagnificationFilter to ImageryProvider

---
 Source/Scene/ImageryProvider.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/Source/Scene/ImageryProvider.js b/Source/Scene/ImageryProvider.js
index 3cfdc11e9ace..efb784ee01fb 100644
--- a/Source/Scene/ImageryProvider.js
+++ b/Source/Scene/ImageryProvider.js
@@ -93,6 +93,22 @@ define([
          */
         this.defaultGamma = undefined;
 
+        /**
+         * The default texture minification filter to apply to this provider.
+         *
+         * @type {TextureMinificationFilter}
+         * @default undefined
+         */
+        this.defaultMinificationFilter = undefined;
+
+        /**
+         * The default texture magnification filter to apply to this provider.
+         *
+         * @type {TextureMagnificationFilter}
+         * @default undefined
+         */
+        this.defaultMagnificationFilter = undefined;
+
         DeveloperError.throwInstantiationError();
     }
 

From 3ec59b0ca4d1d9616179d143a7125f983a68ffc8 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:16:03 -0700
Subject: [PATCH 12/26] Updated api docs minification/magnificationFilter props

---
 Source/Scene/ImageryLayer.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 70f5861b6b27..27b32ae5634a 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -224,6 +224,9 @@ define([
          * Possible values are {@link TextureMinificationFilter.LINEAR} (the default)
          * and {@link TextureMinificationFilter.NEAREST}.
          *
+         * To take effect, this property must be set immediately after adding the imagery layer.
+         * Once a texture is loaded it won't be possible to change the texture filter used.
+         *
          * @type {TextureMinificationFilter}
          * @default {@link ImageryLayer.DEFAULT_MINIFICATION_FILTER}
          */
@@ -234,6 +237,9 @@ define([
          * Possible values are {@link TextureMagnificationFilter.LINEAR} (the default)
          * and {@link TextureMagnificationFilter.NEAREST}.
          *
+         * To take effect, this property must be set immediately after adding the imagery layer.
+         * Once a texture is loaded it won't be possible to change the texture filter used.
+         *
          * @type {TextureMagnificationFilter}
          * @default {@link ImageryLayer.DEFAULT_MAGNIFICATION_FILTER}
          */

From e5b9b618dba05351c9b176467f4172dfc466e398 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:17:47 -0700
Subject: [PATCH 13/26] fixed order of constants

---
 Source/Scene/ImageryLayer.js | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 27b32ae5634a..080979cc675e 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -350,14 +350,6 @@ define([
      */
     ImageryLayer.DEFAULT_SPLIT = ImagerySplitDirection.NONE;
 
-    /**
-     * This value is used as the default texture magnification filter for the imagery layer if one is not provided
-     * during construction or by the imagery provider.
-     * @type {TextureMagnificationFilter}
-     * @default TextureMagnificationFilter.LINEAR
-     */
-    ImageryLayer.DEFAULT_MAGNIFICATION_FILTER = TextureMagnificationFilter.LINEAR;
-
     /**
      * This value is used as the default texture minification filter for the imagery layer if one is not provided
      * during construction or by the imagery provider.
@@ -366,6 +358,14 @@ define([
      */
     ImageryLayer.DEFAULT_MINIFICATION_FILTER = TextureMinificationFilter.LINEAR;
 
+    /**
+     * This value is used as the default texture magnification filter for the imagery layer if one is not provided
+     * during construction or by the imagery provider.
+     * @type {TextureMagnificationFilter}
+     * @default TextureMagnificationFilter.LINEAR
+     */
+    ImageryLayer.DEFAULT_MAGNIFICATION_FILTER = TextureMagnificationFilter.LINEAR;
+
     /**
      * Gets a value indicating whether this layer is the base layer in the
      * {@link ImageryLayerCollection}.  The base layer is the one that underlies all

From 47f66bab213324cba85e17f99f2242ebd0ed7e0f Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:18:40 -0700
Subject: [PATCH 14/26] fixed coding style

---
 Source/Scene/ImageryLayer.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 080979cc675e..8d0b666e1541 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -830,14 +830,14 @@ define([
                 source : {
                     arrayBufferView : image.bufferView
                 },
-                sampler: sampler
+                sampler : sampler
             });
         } else {
             texture = new Texture({
                 context : context,
                 source : image,
                 pixelFormat : imageryProvider.hasAlphaChannel ? PixelFormat.RGBA : PixelFormat.RGB,
-                sampler: sampler
+                sampler : sampler
             });
         }
 

From 88d3458d0428928ece5a225dea81391ddadf0dc2 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@gmail.com>
Date: Wed, 11 Oct 2017 18:41:26 -0700
Subject: [PATCH 15/26] added new test for default texture filters of
 ImageryProvider

---
 Specs/Scene/ImageryLayerSpec.js | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/Specs/Scene/ImageryLayerSpec.js b/Specs/Scene/ImageryLayerSpec.js
index fbcc38c51af9..efb9c181ba1a 100644
--- a/Specs/Scene/ImageryLayerSpec.js
+++ b/Specs/Scene/ImageryLayerSpec.js
@@ -371,22 +371,38 @@ defineSuite([
         expect(layer.isDestroyed()).toEqual(true);
     });
 
-    it('texture filter properties work as expected', function() {
+    it('allows setting texture filter properties', function() {
         var provider = new SingleTileImageryProvider({
             url : 'Data/Images/Red16x16.png'
         });
 
-        var layer = new ImageryLayer(provider, {});
-        expect(layer.magnificationFilter).toEqual(TextureMagnificationFilter.LINEAR);
+        // expect default LINEAR
+        var layer = new ImageryLayer(provider);
         expect(layer.minificationFilter).toEqual(TextureMinificationFilter.LINEAR);
+        expect(layer.magnificationFilter).toEqual(TextureMagnificationFilter.LINEAR);
         layer.destroy();
 
+        // change to NEAREST
         layer = new ImageryLayer(provider, {
-            magnificationFilter: TextureMagnificationFilter.NEAREST,
-            minificationFilter: TextureMinificationFilter.NEAREST
+            minificationFilter: TextureMinificationFilter.NEAREST,
+            magnificationFilter: TextureMagnificationFilter.NEAREST
         });
+        expect(layer.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
         expect(layer.magnificationFilter).toEqual(TextureMagnificationFilter.NEAREST);
+        layer.destroy();
+    });
+
+    it('uses default texture filter properties of ImageryProvider', function() {
+        var provider = new SingleTileImageryProvider({
+            url : 'Data/Images/Red16x16.png'
+        });
+
+        provider.defaultMinificationFilter = TextureMinificationFilter.NEAREST;
+        provider.defaultMagnificationFilter = TextureMinificationFilter.NEAREST;
+
+        var layer = new ImageryLayer(provider);
         expect(layer.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
+        expect(layer.magnificationFilter).toEqual(TextureMagnificationFilter.NEAREST);
         layer.destroy();
     });
 

From eb5ec0c73c4e608ded594e56516ab6dc1dc98f94 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Thu, 12 Oct 2017 18:39:34 +0200
Subject: [PATCH 16/26] fix: turned context.cache.imageryLayer_<x>Sampler into
 context.cache.imageryLayer<x>Samplers so that we can holds samplers with
 different configurations

---
 Source/Scene/ImageryLayer.js | 50 +++++++++++++++++++++++++-----------
 1 file changed, 35 insertions(+), 15 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 8d0b666e1541..7f2cc4cf2f04 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -850,36 +850,56 @@ define([
         imagery.state = ImageryState.TEXTURE_LOADED;
     };
 
+    function getSamplerKey(minificationFilter, magnificationFilter, maximumAnisotropy) {
+        return minificationFilter + ':' + magnificationFilter + ':' + maximumAnisotropy;
+    }
+
     function finalizeReprojectTexture(imageryLayer, context, imagery, texture) {
         // Use mipmaps if this texture has power-of-two dimensions.
         if (!PixelFormat.isCompressedFormat(texture.pixelFormat) && CesiumMath.isPowerOfTwo(texture.width) && CesiumMath.isPowerOfTwo(texture.height)) {
-            var mipmapSampler = context.cache.imageryLayer_mipmapSampler;
+            var mipmapMinificationFilter = imageryLayer.minificationFilter;
+            if (mipmapMinificationFilter === TextureMinificationFilter.NEAREST) {
+                mipmapMinificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
+            } else if (mipmapMinificationFilter === TextureMinificationFilter.LINEAR) {
+                mipmapMinificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
+            }
+            var mipmapMagnificationFilter = imageryLayer.magnificationFilter;
+            var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;
+            var maximumAnisotropy = Math.min(maximumSupportedAnisotropy, defaultValue(imageryLayer._maximumAnisotropy, maximumSupportedAnisotropy));
+            var mipmapSamplerKey = getSamplerKey(mipmapMinificationFilter, mipmapMagnificationFilter, maximumAnisotropy);
+            var mipmapSamplers = context.cache.imageryLayerMipmapSamplers;
+            var mipmapSampler = mipmapSamplers && mipmapSamplers[mipmapSamplerKey];
             if (!defined(mipmapSampler)) {
-                var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;
-                var mipmapMinificationFilter = imageryLayer.minificationFilter;
-                if (imageryLayer.minificationFilter === TextureMinificationFilter.NEAREST) {
-                    mipmapMinificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
-                } else if (imageryLayer.minificationFilter === TextureMinificationFilter.LINEAR) {
-                    mipmapMinificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
+                if (!defined(mipmapSamplers)) {
+                    mipmapSamplers = context.cache.imageryLayerMipmapSamplers = {};
                 }
-                mipmapSampler = context.cache.imageryLayer_mipmapSampler = new Sampler({
+                mipmapSampler = mipmapSamplers[mipmapSamplerKey] = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,
                     minificationFilter : mipmapMinificationFilter,
-                    magnificationFilter : imageryLayer.magnificationFilter,
-                    maximumAnisotropy : Math.min(maximumSupportedAnisotropy, defaultValue(imageryLayer._maximumAnisotropy, maximumSupportedAnisotropy))
+                    magnificationFilter : mipmapMagnificationFilter,
+                    maximumAnisotropy : maximumAnisotropy
                 });
             }
-            texture.generateMipmap(MipmapHint.NICEST);
+            //texture.generateMipmap(MipmapHint.NICEST);
+            //texture.generateMipmap();
             texture.sampler = mipmapSampler;
+            texture.generateMipmap(MipmapHint.FASTEST);
         } else {
-            var nonMipmapSampler = context.cache.imageryLayer_nonMipmapSampler;
+            var minificationFilter = imageryLayer.minificationFilter;
+            var magnificationFilter = imageryLayer.magnificationFilter;
+            var nonMipmapSamplerKey = getSamplerKey(minificationFilter, magnificationFilter, 0);
+            var nonMipmapSamplers = context.cache.imageryLayerNonMipmapSamplers;
+            var nonMipmapSampler = nonMipmapSamplers && nonMipmapSamplers[nonMipmapSamplerKey];
             if (!defined(nonMipmapSampler)) {
-                nonMipmapSampler = context.cache.imageryLayer_nonMipmapSampler = new Sampler({
+                if (!defined(nonMipmapSamplers)) {
+                    nonMipmapSamplers = context.cache.imageryLayerNonMipmapSamplers = {};
+                }
+                nonMipmapSampler = nonMipmapSamplers[nonMipmapSamplerKey] = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,
-                    minificationFilter : imageryLayer.minificationFilter,
-                    magnificationFilter : imageryLayer.magnificationFilter
+                    minificationFilter : minificationFilter,
+                    magnificationFilter : magnificationFilter
                 });
             }
             texture.sampler = nonMipmapSampler;

From 924dc1cd3c6814ee1d600462b79e85f3a106c43e Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Thu, 12 Oct 2017 19:09:03 +0200
Subject: [PATCH 17/26] reverted experimental change

---
 Source/Scene/ImageryLayer.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 7f2cc4cf2f04..5ec28357a9fd 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -881,10 +881,8 @@ define([
                     maximumAnisotropy : maximumAnisotropy
                 });
             }
-            //texture.generateMipmap(MipmapHint.NICEST);
-            //texture.generateMipmap();
+            texture.generateMipmap(MipmapHint.NICEST);
             texture.sampler = mipmapSampler;
-            texture.generateMipmap(MipmapHint.FASTEST);
         } else {
             var minificationFilter = imageryLayer.minificationFilter;
             var magnificationFilter = imageryLayer.magnificationFilter;

From 3d5bfaa650df738e20b268cb3e3b43c7e2103173 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Fri, 13 Oct 2017 12:33:26 +0200
Subject: [PATCH 18/26] create mipmap textures only for linear mini/magni
 filters

---
 Source/Scene/ImageryLayer.js | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 5ec28357a9fd..37a8ea4a6fd0 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -855,18 +855,19 @@ define([
     }
 
     function finalizeReprojectTexture(imageryLayer, context, imagery, texture) {
-        // Use mipmaps if this texture has power-of-two dimensions.
-        if (!PixelFormat.isCompressedFormat(texture.pixelFormat) && CesiumMath.isPowerOfTwo(texture.width) && CesiumMath.isPowerOfTwo(texture.height)) {
-            var mipmapMinificationFilter = imageryLayer.minificationFilter;
-            if (mipmapMinificationFilter === TextureMinificationFilter.NEAREST) {
-                mipmapMinificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
-            } else if (mipmapMinificationFilter === TextureMinificationFilter.LINEAR) {
-                mipmapMinificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
+        var minificationFilter = imageryLayer.minificationFilter;
+        var magnificationFilter = imageryLayer.magnificationFilter;
+        var usesLinearTextureFilter = minificationFilter === TextureMinificationFilter.LINEAR && magnificationFilter === TextureMinificationFilter.LINEAR;
+        // Use mipmaps if this texture uses linear filters and has power-of-two dimensions.
+        if (usesLinearTextureFilter && !PixelFormat.isCompressedFormat(texture.pixelFormat) && CesiumMath.isPowerOfTwo(texture.width) && CesiumMath.isPowerOfTwo(texture.height)) {
+            if (minificationFilter === TextureMinificationFilter.NEAREST) {
+                minificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
+            } else if (minificationFilter === TextureMinificationFilter.LINEAR) {
+                minificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
             }
-            var mipmapMagnificationFilter = imageryLayer.magnificationFilter;
             var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;
             var maximumAnisotropy = Math.min(maximumSupportedAnisotropy, defaultValue(imageryLayer._maximumAnisotropy, maximumSupportedAnisotropy));
-            var mipmapSamplerKey = getSamplerKey(mipmapMinificationFilter, mipmapMagnificationFilter, maximumAnisotropy);
+            var mipmapSamplerKey = getSamplerKey(minificationFilter, magnificationFilter, maximumAnisotropy);
             var mipmapSamplers = context.cache.imageryLayerMipmapSamplers;
             var mipmapSampler = mipmapSamplers && mipmapSamplers[mipmapSamplerKey];
             if (!defined(mipmapSampler)) {
@@ -876,16 +877,14 @@ define([
                 mipmapSampler = mipmapSamplers[mipmapSamplerKey] = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,
-                    minificationFilter : mipmapMinificationFilter,
-                    magnificationFilter : mipmapMagnificationFilter,
+                    minificationFilter : minificationFilter,
+                    magnificationFilter : magnificationFilter,
                     maximumAnisotropy : maximumAnisotropy
                 });
             }
             texture.generateMipmap(MipmapHint.NICEST);
             texture.sampler = mipmapSampler;
         } else {
-            var minificationFilter = imageryLayer.minificationFilter;
-            var magnificationFilter = imageryLayer.magnificationFilter;
             var nonMipmapSamplerKey = getSamplerKey(minificationFilter, magnificationFilter, 0);
             var nonMipmapSamplers = context.cache.imageryLayerNonMipmapSamplers;
             var nonMipmapSampler = nonMipmapSamplers && nonMipmapSamplers[nonMipmapSamplerKey];

From 151f8fe3e502d728829b27b0984bdec5da4f95aa Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Fri, 13 Oct 2017 13:16:43 +0200
Subject: [PATCH 19/26] added texture filter example to Sandcastle

---
 .../Imagery Layers Texture Filters.html       | 110 ++++++++++++++++++
 .../Imagery Layers Texture Filters.jpg        | Bin 0 -> 8135 bytes
 2 files changed, 110 insertions(+)
 create mode 100644 Apps/Sandcastle/gallery/Imagery Layers Texture Filters.html
 create mode 100644 Apps/Sandcastle/gallery/Imagery Layers Texture Filters.jpg

diff --git a/Apps/Sandcastle/gallery/Imagery Layers Texture Filters.html b/Apps/Sandcastle/gallery/Imagery Layers Texture Filters.html
new file mode 100644
index 000000000000..c82ceb588ff8
--- /dev/null
+++ b/Apps/Sandcastle/gallery/Imagery Layers Texture Filters.html	
@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1, user-scalable=no">
+    <meta name="description" content="Set the texture minification and magnification filters of an imagery layer.">
+    <meta name="cesium-sandcastle-labels" content="Beginner, Tutorials, Showcases">
+    <title>Cesium Demo</title>
+    <script type="text/javascript" src="../Sandcastle-header.js"></script>
+    <script type="text/javascript" src="../../../ThirdParty/requirejs-2.1.20/require.js"></script>
+    <script type="text/javascript">
+    require.config({
+        baseUrl : '../../../Source',
+        waitSeconds : 60
+    });
+    </script>
+</head>
+<body class="sandcastle-loading" data-sandcastle-bucket="bucket-requirejs.html">
+
+<style>
+    @import url(../templates/bucket.css);
+
+    #slider {
+        position: absolute;
+        left: 50%;
+        top: 0px;
+        background-color: #D3D3D3;
+        width: 2px;
+        height: 100%;
+        z-index: 9999;
+    }
+
+    #slider:hover {
+        cursor: ew-resize;
+    }
+
+</style>
+
+<div id="cesiumContainer" class="fullSize">
+    <div id="slider"></div>
+</div>
+<div id="loadingOverlay"><h1>Loading...</h1></div>
+<div id="toolbar"></div>
+
+<script id="cesium_sandcastle_script">
+
+
+function startup(Cesium) {
+    'use strict';
+//Sandcastle_Begin
+var viewer = new Cesium.Viewer('cesiumContainer');
+viewer.camera.flyTo({destination : new Cesium.Rectangle.fromDegrees(-84, 43, -80, 47)});
+
+var layers = viewer.imageryLayers;
+layers.removeAll();
+
+var layerLinear = layers.addImageryProvider(Cesium.createTileMapServiceImageryProvider({
+    url : require.toUrl('Assets/Textures/NaturalEarthII')
+}));
+
+var layerNearest = layers.addImageryProvider(Cesium.createTileMapServiceImageryProvider({
+    url : require.toUrl('Assets/Textures/NaturalEarthII')
+}));
+
+// Set the texture minification and magnification filters of layerNearest. Default is LINEAR.
+layerNearest.minificationFilter = Cesium.TextureMinificationFilter.NEAREST;
+layerNearest.magnificationFilter = Cesium.TextureMagnificationFilter.NEAREST;
+
+// The remaining code installs a split layer so the effect of the texture filters becomes apparent.
+
+layerNearest.splitDirection = Cesium.ImagerySplitDirection.RIGHT;
+
+var slider = document.getElementById('slider');
+viewer.scene.imagerySplitPosition = (slider.offsetLeft) / slider.parentElement.offsetWidth;
+
+var dragStartX = 0;
+
+document.getElementById('slider').addEventListener('mousedown', mouseDown, false);
+window.addEventListener('mouseup', mouseUp, false);
+
+function mouseUp() {
+    window.removeEventListener('mousemove', sliderMove, true);
+}
+
+function mouseDown(e) {
+    var slider = document.getElementById('slider');
+    dragStartX = e.clientX - slider.offsetLeft;
+    window.addEventListener('mousemove', sliderMove, true);
+}
+
+function sliderMove(e) {
+    var slider = document.getElementById('slider');
+    var splitPosition = (e.clientX - dragStartX) / slider.parentElement.offsetWidth;
+    slider.style.left = 100.0 * splitPosition + "%";
+    viewer.scene.imagerySplitPosition = splitPosition;
+}
+//Sandcastle_End
+
+    Sandcastle.finishedLoading();
+}
+if (typeof Cesium !== "undefined") {
+    startup(Cesium);
+} else if (typeof require === "function") {
+    require(["Cesium"], startup);
+}
+</script>
+
+</body>
+</html>
diff --git a/Apps/Sandcastle/gallery/Imagery Layers Texture Filters.jpg b/Apps/Sandcastle/gallery/Imagery Layers Texture Filters.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..1b2318fe46a0922a6409696b5fc1dea7ddec4410
GIT binary patch
literal 8135
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
R*}Y<t7b8V8>jBE|{{oMXOx^$h

literal 0
HcmV?d00001


From dbf8d3a4db928e8a13ba676835ae0d07f0af516a Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Fri, 13 Oct 2017 13:34:36 +0200
Subject: [PATCH 20/26] fixed a harmless typo

---
 Source/Scene/ImageryLayer.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 37a8ea4a6fd0..5580f4c8f0ab 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -857,7 +857,7 @@ define([
     function finalizeReprojectTexture(imageryLayer, context, imagery, texture) {
         var minificationFilter = imageryLayer.minificationFilter;
         var magnificationFilter = imageryLayer.magnificationFilter;
-        var usesLinearTextureFilter = minificationFilter === TextureMinificationFilter.LINEAR && magnificationFilter === TextureMinificationFilter.LINEAR;
+        var usesLinearTextureFilter = minificationFilter === TextureMinificationFilter.LINEAR && magnificationFilter === TextureMagnificationFilter.LINEAR;
         // Use mipmaps if this texture uses linear filters and has power-of-two dimensions.
         if (usesLinearTextureFilter && !PixelFormat.isCompressedFormat(texture.pixelFormat) && CesiumMath.isPowerOfTwo(texture.width) && CesiumMath.isPowerOfTwo(texture.height)) {
             if (minificationFilter === TextureMinificationFilter.NEAREST) {

From 3d632cd64ed89f6bf9968ca157056a744629d196 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Thu, 19 Oct 2017 11:36:46 +0200
Subject: [PATCH 21/26] be more explicit about checking if something is
 undefined

---
 Source/Scene/ImageryLayer.js | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 5580f4c8f0ab..97995ac670d7 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -858,22 +858,21 @@ define([
         var minificationFilter = imageryLayer.minificationFilter;
         var magnificationFilter = imageryLayer.magnificationFilter;
         var usesLinearTextureFilter = minificationFilter === TextureMinificationFilter.LINEAR && magnificationFilter === TextureMagnificationFilter.LINEAR;
-        // Use mipmaps if this texture uses linear filters and has power-of-two dimensions.
+        // Use mipmaps if this texture has power-of-two dimensions.
+        // In addition, we only use mipmaps if the texture filters are both LINEAR, because a NEAREST filter
+        // in Cesium v1.39 had no effect on mipmaps (see discussion on PR #5890).
         if (usesLinearTextureFilter && !PixelFormat.isCompressedFormat(texture.pixelFormat) && CesiumMath.isPowerOfTwo(texture.width) && CesiumMath.isPowerOfTwo(texture.height)) {
-            if (minificationFilter === TextureMinificationFilter.NEAREST) {
-                minificationFilter = TextureMinificationFilter.NEAREST_MIPMAP_NEAREST;
-            } else if (minificationFilter === TextureMinificationFilter.LINEAR) {
-                minificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
-            }
+            minificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
             var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;
             var maximumAnisotropy = Math.min(maximumSupportedAnisotropy, defaultValue(imageryLayer._maximumAnisotropy, maximumSupportedAnisotropy));
             var mipmapSamplerKey = getSamplerKey(minificationFilter, magnificationFilter, maximumAnisotropy);
             var mipmapSamplers = context.cache.imageryLayerMipmapSamplers;
-            var mipmapSampler = mipmapSamplers && mipmapSamplers[mipmapSamplerKey];
+            if (!defined(mipmapSamplers)) {
+                mipmapSamplers = {};
+                context.cache.imageryLayerMipmapSamplers = mipmapSamplers;
+            }
+            var mipmapSampler = mipmapSamplers[mipmapSamplerKey];
             if (!defined(mipmapSampler)) {
-                if (!defined(mipmapSamplers)) {
-                    mipmapSamplers = context.cache.imageryLayerMipmapSamplers = {};
-                }
                 mipmapSampler = mipmapSamplers[mipmapSamplerKey] = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,
@@ -887,11 +886,12 @@ define([
         } else {
             var nonMipmapSamplerKey = getSamplerKey(minificationFilter, magnificationFilter, 0);
             var nonMipmapSamplers = context.cache.imageryLayerNonMipmapSamplers;
-            var nonMipmapSampler = nonMipmapSamplers && nonMipmapSamplers[nonMipmapSamplerKey];
+            if (!defined(nonMipmapSamplers)) {
+                nonMipmapSamplers = {};
+                context.cache.imageryLayerNonMipmapSamplers = nonMipmapSamplers;
+            }
+            var nonMipmapSampler = nonMipmapSamplers[nonMipmapSamplerKey];
             if (!defined(nonMipmapSampler)) {
-                if (!defined(nonMipmapSamplers)) {
-                    nonMipmapSamplers = context.cache.imageryLayerNonMipmapSamplers = {};
-                }
                 nonMipmapSampler = nonMipmapSamplers[nonMipmapSamplerKey] = new Sampler({
                     wrapS : TextureWrap.CLAMP_TO_EDGE,
                     wrapT : TextureWrap.CLAMP_TO_EDGE,

From c826ec9f690ef398c30be92d6ef02e50ee6162b4 Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Thu, 19 Oct 2017 11:48:26 +0200
Subject: [PATCH 22/26] merged upstream

---
 CHANGES.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index 01f7ddc2b2cb..a48e252a6803 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -4,7 +4,6 @@ Change Log
 ### 1.39 - 2017-11-01
 
 * Added function that inserts missing namespace declarations into KML files. [#5860](https://github.com/AnalyticalGraphicsInc/cesium/pull/5860)
-
 * Added support for the layer.json `parentUrl` property in `CesiumTerrainProvider` to allow for compositing of tilesets.
 * Fixed a bug that caused KML ground overlays to appear distorted when rotation was applied. [#5914](https://github.com/AnalyticalGraphicsInc/cesium/issues/5914)
 * Added two new properties to `ImageryLayer` that allow for adjusting the texture sampler used for up- and down-sampling of image tiles, namely `minificationFilter` and `magnificationFilter` with possible values `LINEAR` (the default) and `NEAREST` defined in `TextureMinificationFilter` and `TextureMagnificationFilter`. [#5846](https://github.com/AnalyticalGraphicsInc/cesium/issues/5846)

From 356f677f0fd978c7824006a6e31cdab945677db5 Mon Sep 17 00:00:00 2001
From: Sean Lilley <lilleyse@gmail.com>
Date: Thu, 19 Oct 2017 13:17:58 -0400
Subject: [PATCH 23/26] Tweak comment wording

---
 Source/Scene/ImageryLayer.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Source/Scene/ImageryLayer.js b/Source/Scene/ImageryLayer.js
index 97995ac670d7..839da40ee183 100644
--- a/Source/Scene/ImageryLayer.js
+++ b/Source/Scene/ImageryLayer.js
@@ -859,8 +859,7 @@ define([
         var magnificationFilter = imageryLayer.magnificationFilter;
         var usesLinearTextureFilter = minificationFilter === TextureMinificationFilter.LINEAR && magnificationFilter === TextureMagnificationFilter.LINEAR;
         // Use mipmaps if this texture has power-of-two dimensions.
-        // In addition, we only use mipmaps if the texture filters are both LINEAR, because a NEAREST filter
-        // in Cesium v1.39 had no effect on mipmaps (see discussion on PR #5890).
+        // In addition, mipmaps are only generated if the texture filters are both LINEAR.
         if (usesLinearTextureFilter && !PixelFormat.isCompressedFormat(texture.pixelFormat) && CesiumMath.isPowerOfTwo(texture.width) && CesiumMath.isPowerOfTwo(texture.height)) {
             minificationFilter = TextureMinificationFilter.LINEAR_MIPMAP_LINEAR;
             var maximumSupportedAnisotropy = ContextLimits.maximumTextureFilterAnisotropy;

From d5cf4537741df19b6a390b0173e4e17d94d468ca Mon Sep 17 00:00:00 2001
From: Norman Fomferra <norman.fomferra@brockmann-consult.de>
Date: Mon, 23 Oct 2017 16:04:46 +0200
Subject: [PATCH 24/26] added assertions for imagery.texture.sampler

---
 Specs/Scene/ImageryLayerSpec.js | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Specs/Scene/ImageryLayerSpec.js b/Specs/Scene/ImageryLayerSpec.js
index efb9c181ba1a..22fe1c728999 100644
--- a/Specs/Scene/ImageryLayerSpec.js
+++ b/Specs/Scene/ImageryLayerSpec.js
@@ -191,6 +191,9 @@ defineSuite([
                         return imagery.state === ImageryState.READY;
                     }).then(function() {
                         expect(imagery.texture).toBeDefined();
+                        expect(imagery.texture.sampler).toBeDefined();
+                        expect(imagery.texture.sampler.minificationFilter).toEqual(TextureMinificationFilter.LINEAR_MIPMAP_LINEAR);
+                        expect(imagery.texture.sampler.magnificationFilter).toEqual(TextureMinificationFilter.LINEAR);
                         expect(textureBeforeReprojection).not.toEqual(imagery.texture);
                         imagery.releaseReference();
                     });
@@ -273,6 +276,9 @@ defineSuite([
                             return imagery.state === ImageryState.READY;
                         }).then(function() {
                             expect(imagery.texture).toBeDefined();
+                            expect(imagery.texture.sampler).toBeDefined();
+                            expect(imagery.texture.sampler.minificationFilter).toEqual(TextureMinificationFilter.LINEAR_MIPMAP_LINEAR);
+                            expect(imagery.texture.sampler.magnificationFilter).toEqual(TextureMinificationFilter.LINEAR);
                             expect(textureBeforeReprojection).not.toEqual(imagery.texture);
                             imagery.releaseReference();
                         });
@@ -319,6 +325,9 @@ defineSuite([
                         return imagery.state === ImageryState.READY;
                     }).then(function() {
                         expect(imagery.texture).toBeDefined();
+                        expect(imagery.texture.sampler).toBeDefined();
+                        expect(imagery.texture.sampler.minificationFilter).toEqual(TextureMinificationFilter.LINEAR_MIPMAP_LINEAR);
+                        expect(imagery.texture.sampler.magnificationFilter).toEqual(TextureMinificationFilter.LINEAR);
                         expect(imagery.texture).toBe(imagery.textureWebMercator);
                         imagery.releaseReference();
                     });

From a621f1396964aab8c31edf52a610e85d0f4cfd4d Mon Sep 17 00:00:00 2001
From: hpinkos <pinkos.hannah@gmail.com>
Date: Mon, 23 Oct 2017 11:11:38 -0400
Subject: [PATCH 25/26] fix freezeRenderState test

---
 Specs/Renderer/RenderStateSpec.js | 9 +++++++--
 Specs/customizeJasmine.js         | 4 ++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/Specs/Renderer/RenderStateSpec.js b/Specs/Renderer/RenderStateSpec.js
index 2a80493f342f..163ac9796fa0 100644
--- a/Specs/Renderer/RenderStateSpec.js
+++ b/Specs/Renderer/RenderStateSpec.js
@@ -1,14 +1,16 @@
 defineSuite([
+        'Renderer/RenderState',
+        'Core/defined',
         'Core/WebGLConstants',
         'Core/WindingOrder',
         'Renderer/ContextLimits',
-        'Renderer/RenderState',
         'Specs/createContext'
     ], function(
+        RenderState,
+        defined,
         WebGLConstants,
         WindingOrder,
         ContextLimits,
-        RenderState,
         createContext) {
     'use strict';
 
@@ -408,6 +410,9 @@ defineSuite([
     });
 
     it('freezes render states', function(){
+        if (window.release) {
+            return;
+        }
         var rs = RenderState.fromCache();
         expect(function() {
             rs.depthRange = {};
diff --git a/Specs/customizeJasmine.js b/Specs/customizeJasmine.js
index 21dbdce268f3..5ba92c14c77a 100644
--- a/Specs/customizeJasmine.js
+++ b/Specs/customizeJasmine.js
@@ -140,6 +140,10 @@ define([
             window.webglStub = true;
         }
 
+        if (release) {
+            window.release = true;
+        }
+
         //env.catchExceptions(true);
 
         env.beforeEach(function () {

From c635584938252c7148025af10cfc0cc2ba426fdd Mon Sep 17 00:00:00 2001
From: Matthew Amato <matt.amato@gmail.com>
Date: Mon, 23 Oct 2017 13:39:40 -0400
Subject: [PATCH 26/26] Fix release tests

Cleans up #5466 which had some incomplete tests causing release builds to
fail. Also simplified the tests to check frozen state instead of relying on
exception handling.

Also removed some uneeded `/*global defineSuite*/` statements I found while
in the code
---
 Specs/DataSources/KmlTourFlyToSpec.js   |  1 -
 Specs/DataSources/KmlTourSpec.js        |  1 -
 Specs/Renderer/RenderStateSpec.js       | 17 +------
 Specs/Renderer/freezeRenderStateSpec.js | 60 ++++---------------------
 Specs/Scene/TimeDynamicImagerySpec.js   |  1 -
 Specs/customizeJasmine.js               |  6 +--
 Specs/spec-main.js                      |  3 ++
 7 files changed, 15 insertions(+), 74 deletions(-)

diff --git a/Specs/DataSources/KmlTourFlyToSpec.js b/Specs/DataSources/KmlTourFlyToSpec.js
index 71ee413aeb8e..49d61154f1ca 100644
--- a/Specs/DataSources/KmlTourFlyToSpec.js
+++ b/Specs/DataSources/KmlTourFlyToSpec.js
@@ -1,4 +1,3 @@
-/*global defineSuite*/
 defineSuite([
         'DataSources/KmlTourFlyTo',
         'DataSources/KmlCamera',
diff --git a/Specs/DataSources/KmlTourSpec.js b/Specs/DataSources/KmlTourSpec.js
index aca9c72fc898..98014337bb5a 100644
--- a/Specs/DataSources/KmlTourSpec.js
+++ b/Specs/DataSources/KmlTourSpec.js
@@ -1,4 +1,3 @@
-/*global defineSuite*/
 defineSuite([
         'DataSources/KmlTour',
         'DataSources/KmlTourFlyTo',
diff --git a/Specs/Renderer/RenderStateSpec.js b/Specs/Renderer/RenderStateSpec.js
index 163ac9796fa0..a65c20d60914 100644
--- a/Specs/Renderer/RenderStateSpec.js
+++ b/Specs/Renderer/RenderStateSpec.js
@@ -409,22 +409,9 @@ defineSuite([
         expect(cache[fullKey]).not.toBeDefined();
     });
 
-    it('freezes render states', function(){
-        if (window.release) {
-            return;
-        }
+    it('freezes render states', function() {
         var rs = RenderState.fromCache();
-        expect(function() {
-            rs.depthRange = {};
-        }).toThrow();
-
-        expect(function() {
-            rs.frontFace = WindingOrder.COUNTER_CLOCKWISE;
-        }).toThrow();
-
-        expect(function() {
-            rs._applyFunctions.push(function(){});
-        }).not.toThrow();
+        expect(Object.isFrozen(rs)).toBe(!window.specsUsingRelease);
     });
 
     it('fails to create (frontFace)', function() {
diff --git a/Specs/Renderer/freezeRenderStateSpec.js b/Specs/Renderer/freezeRenderStateSpec.js
index b702657356b0..c12030f324c9 100644
--- a/Specs/Renderer/freezeRenderStateSpec.js
+++ b/Specs/Renderer/freezeRenderStateSpec.js
@@ -1,67 +1,23 @@
-/*global defineSuite*/
 defineSuite([
         'Renderer/freezeRenderState'
       ], function(
           freezeRenderState) {
     'use strict';
 
-    it('works for literals', function() {
+    it('works as expected', function() {
         var fresh = {
             a: 1,
-            b: 'b',
-            c: 2.2,
-            u: undefined,
-            n: null
-        };
-
-        var frozen = freezeRenderState(fresh);
-
-        expect(function() {
-            frozen.a = 2;
-        }).toThrow();
-
-        expect(function() {
-            frozen.b = 'c';
-        }).toThrow();
-
-        expect(function() {
-            frozen.c = 2;
-        }).toThrow();
-
-    });
-
-    it('works for deep objects', function() {
-        var fresh = {
-            a: 2,
-            o: {
-                b: 2,
+            b: {
                 c: 'c'
-            }
-        };
-
-        var frozen = freezeRenderState(fresh);
-
-        expect(function() {
-            frozen.o.b = 3;
-            frozen.o.c = 'dddd';
-        }).toThrow();
-    });
-
-    it('ignores _applyFunctions', function() {
-        var fresh = {
-            a: 1,
+            },
             _applyFunctions: [function() { }]
         };
 
         var frozen = freezeRenderState(fresh);
-
-        expect(function() {
-            frozen.a = 0;
-        }).toThrow();
-
-        expect(function() {
-            frozen._applyFunctions.push(function() { });
-        }).not.toThrow();
+        expect(Object.isFrozen(frozen)).toBe(true);
+        expect(Object.isFrozen(frozen.a)).toBe(true);
+        expect(Object.isFrozen(frozen.b)).toBe(true);
+        expect(Object.isFrozen(frozen.c)).toBe(true);
+        expect(Object.isFrozen(frozen._applyFunctions)).toBe(false);
     });
-
 });
diff --git a/Specs/Scene/TimeDynamicImagerySpec.js b/Specs/Scene/TimeDynamicImagerySpec.js
index 4e26c96f545a..c0af7ab448b8 100644
--- a/Specs/Scene/TimeDynamicImagerySpec.js
+++ b/Specs/Scene/TimeDynamicImagerySpec.js
@@ -1,4 +1,3 @@
-/*global defineSuite*/
 defineSuite([
         'Scene/TimeDynamicImagery',
         'Core/Clock',
diff --git a/Specs/customizeJasmine.js b/Specs/customizeJasmine.js
index 5ba92c14c77a..4528777b094d 100644
--- a/Specs/customizeJasmine.js
+++ b/Specs/customizeJasmine.js
@@ -42,6 +42,8 @@ define([
             });
         }
 
+        window.specsUsingRelease = release;
+
         window.fdefineSuite = function(deps, name, suite, categories) {
             defineSuite(deps, name, suite, categories, true);
         };
@@ -140,10 +142,6 @@ define([
             window.webglStub = true;
         }
 
-        if (release) {
-            window.release = true;
-        }
-
         //env.catchExceptions(true);
 
         env.beforeEach(function () {
diff --git a/Specs/spec-main.js b/Specs/spec-main.js
index 9ba3c174eeea..78342be219ad 100644
--- a/Specs/spec-main.js
+++ b/Specs/spec-main.js
@@ -21,6 +21,7 @@
     }
 
     var built = getQueryParameter('built');
+    var release = getQueryParameter('release');
 
     var toRequire = ['Cesium'];
 
@@ -73,6 +74,8 @@
          */
         window.jasmine = jasmineRequire.core(jasmineRequire);
 
+        window.specsUsingRelease = release;
+
         window.defineSuite = function(deps, name, suite, categories) {
             /*global define,describe*/
             if (typeof suite === 'object' || typeof suite === 'string') {