HDR Rendering

Source/Renderer/AutomaticUniforms.js

@@ -1686,6 +1686,34 @@ define([
             getValue : function(uniformState) {
                 return uniformState.invertClassificationColor;
             }
+        }),
+
+        /**
+         * An automatic GLSL uniform that will be used for gamma correction.
+         *
+         * @alias czm_gamma
+         * @glslUniform
+         */
+        czm_gamma : new AutomaticUniform({
+            size : 1,
+            datatype : WebGLConstants.FLOAT,
+            getValue : function(uniformState) {
+                return uniformState.gamma;
+            }
+        }),
+
+        /**
+         * An automatic GLSL uniform that defines the color of light emitted by the sun.
+         *
+         * @alias czm_sunColor
+         * @glslUniform
+         */
+        czm_sunColor: new AutomaticUniform({
+            size: 1,
+            datatype: WebGLConstants.FLOAT_VEC4,
+            getValue: function(uniformState) {
+                return uniformState.sunColor;
+            }
         })
     };
 

Source/Renderer/Context.js

@@ -274,11 +274,15 @@ define([
         this._blendMinmax = !!getExtension(gl, ['EXT_blend_minmax']);
         this._elementIndexUint = !!getExtension(gl, ['OES_element_index_uint']);
         this._depthTexture = !!getExtension(gl, ['WEBGL_depth_texture', 'WEBKIT_WEBGL_depth_texture']);
-        this._textureFloat = !!getExtension(gl, ['OES_texture_float']);
-        this._textureHalfFloat = !!getExtension(gl, ['OES_texture_half_float']);
         this._fragDepth = !!getExtension(gl, ['EXT_frag_depth']);
         this._debugShaders = getExtension(gl, ['WEBGL_debug_shaders']);
 
+        this._textureFloat = !!getExtension(gl, ['OES_texture_float']);
+        this._textureHalfFloat = !!getExtension(gl, ['OES_texture_half_float']);
+
+        this._textureFloatLinear = !!getExtension(gl, ['OES_texture_float_linear']);
+        this._textureHalfFloatLinear = !!getExtension(gl, ['OES_texture_half_float_linear']);
+
         this._colorBufferFloat = !!getExtension(gl, ['EXT_color_buffer_float', 'WEBGL_color_buffer_float']);
         this._colorBufferHalfFloat = !!getExtension(gl, ['EXT_color_buffer_half_float']);
 
@@ -564,7 +568,7 @@ define([
         },
 
         /**
-         * <code>true</code> if OES_texture_float is supported.  This extension provides
+         * <code>true</code> if OES_texture_float is supported. This extension provides
          * access to floating point textures that, for example, can be attached to framebuffers for high dynamic range.
          * @memberof Context.prototype
          * @type {Boolean}
@@ -577,7 +581,7 @@ define([
         },
 
         /**
-         * <code>true</code> if OES_texture_half_float is supported.  This extension provides
+         * <code>true</code> if OES_texture_half_float is supported. This extension provides
          * access to floating point textures that, for example, can be attached to framebuffers for high dynamic range.
          * @memberof Context.prototype
          * @type {Boolean}
@@ -589,6 +593,39 @@ define([
             }
         },
 
+        /**
+         * <code>true</code> if OES_texture_float_linear is supported. This extension provides
+         * access to linear sampling methods for minification and magnification filters of floating-point textures.
+         * @memberof Context.prototype
+         * @type {Boolean}
+         * @see {@link https://www.khronos.org/registry/webgl/extensions/OES_texture_float_linear/}
+         */
+        textureFloatLinear : {
+            get : function() {
+                return this._textureFloatLinear;
+            }
+        },
+
+        /**
+         * <code>true</code> if OES_texture_half_float_linear is supported. This extension provides
+         * access to linear sampling methods for minification and magnification filters of half floating-point textures.
+         * @memberof Context.prototype
+         * @type {Boolean}
+         * @see {@link https://www.khronos.org/registry/webgl/extensions/OES_texture_half_float_linear/}
+         */
+        textureHalfFloatLinear : {
+            get : function() {
+                return this._textureHalfFloatLinear;
+            }
+        },
+
+        /**
+         * <code>true</code> if EXT_texture_filter_anisotropic is supported. This extension provides
+         * access to anisotropic filtering for textured surfaces at an oblique angle from the viewer.
+         * @memberof Context.prototype
+         * @type {Boolean}
+         * @see {@link https://www.khronos.org/registry/webgl/extensions/EXT_texture_filter_anisotropic/}
+         */
         textureFilterAnisotropic : {
             get : function() {
                 return !!this._textureFilterAnisotropic;

Source/Renderer/CubeMap.js

@@ -162,7 +162,7 @@ define([
         }
         gl.bindTexture(textureTarget, null);
 
-        this._gl = gl;
+        this._context = context;
         this._textureFilterAnisotropic = context._textureFilterAnisotropic;
         this._textureTarget = textureTarget;
         this._texture = texture;
@@ -231,13 +231,16 @@ define([
                     (minificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_NEAREST) ||
                     (minificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_LINEAR);
 
-                // float textures only support nearest filtering, so override the sampler's settings
-                if (this._pixelDatatype === PixelDatatype.FLOAT || this._pixelDatatype === PixelDatatype.HALF_FLOAT) {
+                var context = this._context;
+                var pixelDatatype = this._pixelDatatype;
+
+                // float textures only support nearest filtering unless the linear extensions are supported, so override the sampler's settings
+                if ((pixelDatatype === PixelDatatype.FLOAT && !context.textureFloatLinear) || (pixelDatatype === PixelDatatype.HALF_FLOAT && !context.textureHalfFloatLinear)) {
                     minificationFilter = mipmap ? TextureMinificationFilter.NEAREST_MIPMAP_NEAREST : TextureMinificationFilter.NEAREST;
                     magnificationFilter = TextureMagnificationFilter.NEAREST;
                 }
 
-                var gl = this._gl;
+                var gl = context._gl;
                 var target = this._textureTarget;
 
                 gl.activeTexture(gl.TEXTURE0);
@@ -332,7 +335,7 @@ define([
 
         this._hasMipmap = true;
 
-        var gl = this._gl;
+        var gl = this._context._gl;
         var target = this._textureTarget;
         gl.hint(gl.GENERATE_MIPMAP_HINT, hint);
         gl.activeTexture(gl.TEXTURE0);
@@ -346,7 +349,7 @@ define([
     };
 
     CubeMap.prototype.destroy = function() {
-        this._gl.deleteTexture(this._texture);
+        this._context._gl.deleteTexture(this._texture);
         this._positiveX = destroyObject(this._positiveX);
         this._negativeX = destroyObject(this._negativeX);
         this._positiveY = destroyObject(this._positiveY);

Source/Renderer/Texture.js

@@ -385,13 +385,16 @@ define([
                     (minificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_NEAREST) ||
                     (minificationFilter === TextureMinificationFilter.LINEAR_MIPMAP_LINEAR);
 
-                // float textures only support nearest filtering, so override the sampler's settings
-                if (this._pixelDatatype === PixelDatatype.FLOAT || this._pixelDatatype === PixelDatatype.HALF_FLOAT) {
+                var context = this._context;
+                var pixelDatatype = this._pixelDatatype;
+
+                // float textures only support nearest filtering unless the linear extensions are supported, so override the sampler's settings
+                if ((pixelDatatype === PixelDatatype.FLOAT && !context.textureFloatLinear) || (pixelDatatype === PixelDatatype.HALF_FLOAT && !context.textureHalfFloatLinear)) {
                     minificationFilter = mipmap ? TextureMinificationFilter.NEAREST_MIPMAP_NEAREST : TextureMinificationFilter.NEAREST;
                     magnificationFilter = TextureMagnificationFilter.NEAREST;
                 }
 
-                var gl = this._context._gl;
+                var gl = context._gl;
                 var target = this._textureTarget;
 
                 gl.activeTexture(gl.TEXTURE0);

Source/Renderer/UniformState.js

@@ -46,6 +46,10 @@ define([
          * @type {Texture}
          */
         this.globeDepthTexture = undefined;
+        /**
+         * @type {Number}
+         */
+        this.gamma = undefined;
 
         this._viewport = new BoundingRectangle();
         this._viewportCartesian4 = new Cartesian4();
@@ -143,6 +147,7 @@ define([
         this._sunPositionColumbusView = new Cartesian3();
         this._sunDirectionWC = new Cartesian3();
         this._sunDirectionEC = new Cartesian3();
+        this._sunColor = new Color();
         this._moonDirectionEC = new Cartesian3();
 
         this._pass = undefined;
@@ -737,6 +742,17 @@ define([
             }
         },
 
+        /**
+         * The color of the light emitted by the sun.
+         * @memberof UniformState.prototype
+         * @type {Color}
+         */
+        sunColor: {
+            get: function() {
+                return this._sunColor;
+            }
+        },
+
         /**
          * A normalized vector to the moon in eye coordinates at the current scene time.  In 3D mode, this
          * returns the actual vector from the camera position to the moon position.  In 2D and Columbus View, it returns
@@ -1069,6 +1085,7 @@ define([
         }
 
         setSunAndMoonDirections(this, frameState);
+        this._sunColor = Color.clone(frameState.sunColor, this._sunColor);
 
         var brdfLutGenerator = frameState.brdfLutGenerator;
         var brdfLut = defined(brdfLutGenerator) ? brdfLutGenerator.colorTexture : undefined;