@cesium/engine 10.1.0 → 11.0.0

package/Source/Scene/SpecularEnvironmentCubeMap.js

@@ -0,0 +1,240 @@
+import defined from "../Core/defined.js";
+import destroyObject from "../Core/destroyObject.js";
+import Event from "../Core/Event.js";
+import loadKTX2 from "../Core/loadKTX2.js";
+import PixelFormat from "../Core/PixelFormat.js";
+import CubeMap from "../Renderer/CubeMap.js";
+import PixelDatatype from "../Renderer/PixelDatatype.js";
+import Sampler from "../Renderer/Sampler.js";
+import TextureMinificationFilter from "../Renderer/TextureMinificationFilter.js";
+
+/**
+ * Manages a cube map for use as a specular environment map.
+ *
+ * @alias SpecularEnvironmentCubeMap
+ * @constructor
+ *
+ * @param {string} url The url to the KTX2 file containing the specular environment map and convoluted mipmaps.
+ * @private
+ */
+function SpecularEnvironmentCubeMap(url) {
+  this._url = url;
+
+  this._cubeMapBuffers = undefined;
+  this._texture = undefined;
+
+  this._maximumMipmapLevel = undefined;
+
+  this._loading = false;
+  this._ready = false;
+
+  this._errorEvent = new Event();
+}
+
+Object.defineProperties(SpecularEnvironmentCubeMap.prototype, {
+  /**
+   * The url to the KTX2 file containing the specular environment map and convoluted mipmaps.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {string}
+   * @readonly
+   */
+  url: {
+    get: function () {
+      return this._url;
+    },
+  },
+  /**
+   * Gets an event that is raised when encountering an asynchronous error.  By subscribing
+   * to the event, you will be notified of the error and can potentially recover from it.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {Event}
+   * @readonly
+   */
+  errorEvent: {
+    get: function () {
+      return this._errorEvent;
+    },
+  },
+  /**
+   * A texture containing all the packed convolutions.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {Texture}
+   * @readonly
+   */
+  texture: {
+    get: function () {
+      return this._texture;
+    },
+  },
+  /**
+   * The maximum number of mip levels with valid environment map data.
+   * This may differ from the number of mips in the WebGL cubemap.
+   * The data loaded at <code>maximumMipmapLevel</code> is suitable for
+   * PBR rendering of a material with maximum roughness (1.0).
+   * @memberOf SpecularEnvironmentCubeMap.prototype
+   * @type {number}
+   * @readonly
+   */
+  maximumMipmapLevel: {
+    get: function () {
+      return this._maximumMipmapLevel;
+    },
+  },
+  /**
+   * Determines if the cube map is complete and ready to use.
+   * @memberof SpecularEnvironmentCubeMap.prototype
+   * @type {boolean}
+   * @readonly
+   */
+  ready: {
+    get: function () {
+      return this._ready;
+    },
+  },
+});
+
+SpecularEnvironmentCubeMap.isSupported = function (context) {
+  const supportsFloatBuffersAndTextures =
+    (context.colorBufferHalfFloat && context.halfFloatingPointTexture) ||
+    (context.floatingPointTexture && context.colorBufferFloat);
+  return supportsFloatBuffersAndTextures && context.supportsTextureLod;
+};
+
+function cleanupResources(map) {
+  map._cubeMapBuffers = undefined;
+}
+
+/**
+ * Loads the environment map image and constructs the cube map for specular radiance calculations.
+ * <p>
+ * Once the image is loaded, the next call cleans up unused resources. Every call after that is a no-op.
+ * </p>
+ * @param {FrameState} frameState The frame state.
+ *
+ * @private
+ */
+SpecularEnvironmentCubeMap.prototype.update = function (frameState) {
+  const { context } = frameState;
+
+  if (!SpecularEnvironmentCubeMap.isSupported(context)) {
+    return;
+  }
+
+  if (defined(this._texture)) {
+    cleanupResources(this);
+    return;
+  }
+
+  if (!defined(this._texture) && !this._loading) {
+    const cachedTexture = context.textureCache.getTexture(this._url);
+    if (defined(cachedTexture)) {
+      cleanupResources(this);
+      this._texture = cachedTexture;
+      this._maximumMipmapLevel = this._texture.maximumMipmapLevel;
+      this._ready = true;
+    }
+  }
+
+  const cubeMapBuffers = this._cubeMapBuffers;
+  if (!defined(cubeMapBuffers) && !this._loading) {
+    const that = this;
+    loadKTX2(this._url)
+      .then(function (buffers) {
+        that._cubeMapBuffers = buffers;
+        that._loading = false;
+      })
+      .catch(function (error) {
+        if (that.isDestroyed()) {
+          return;
+        }
+        that._errorEvent.raiseEvent(error);
+      });
+    this._loading = true;
+  }
+
+  if (!defined(this._cubeMapBuffers)) {
+    return;
+  }
+
+  // Datatype is defined if it is a normalized type (i.e. ..._UNORM, ..._SFLOAT)
+  let { pixelDatatype } = cubeMapBuffers[0].positiveX;
+  if (!defined(pixelDatatype)) {
+    pixelDatatype = context.halfFloatingPointTexture
+      ? PixelDatatype.HALF_FLOAT
+      : PixelDatatype.FLOAT;
+  }
+  const pixelFormat = PixelFormat.RGBA;
+
+  const mipLevels = cubeMapBuffers.length;
+  this._maximumMipmapLevel = mipLevels - 1;
+
+  const faceSize = cubeMapBuffers[0].positiveX.width;
+  const expectedMipLevels = Math.log2(faceSize) + 1;
+  if (mipLevels !== expectedMipLevels) {
+    // We assume the last supplied mip level was computed as the specular radiance
+    // for roughness 1.0.
+    // Fill the remaining levels with null values, to avoid WebGL errors.
+    const dummyMipLevel = {};
+    Object.values(CubeMap.FaceName).forEach((faceName) => {
+      dummyMipLevel[faceName] = undefined;
+    });
+    for (let mipLevel = mipLevels; mipLevel < expectedMipLevels; mipLevel++) {
+      cubeMapBuffers.push(dummyMipLevel);
+    }
+  }
+
+  const sampler = new Sampler({
+    minificationFilter: TextureMinificationFilter.LINEAR_MIPMAP_LINEAR,
+  });
+
+  const cubeMap = new CubeMap({
+    context: context,
+    source: cubeMapBuffers[0],
+    flipY: false,
+    pixelDatatype: pixelDatatype,
+    pixelFormat: pixelFormat,
+    sampler: sampler,
+  });
+  cubeMap.loadMipmaps(cubeMapBuffers.slice(1));
+  this._texture = cubeMap;
+
+  this._texture.maximumMipmapLevel = this._maximumMipmapLevel;
+  context.textureCache.addTexture(this._url, this._texture);
+
+  this._ready = true;
+};
+
+/**
+ * Returns true if this object was destroyed; otherwise, false.
+ * <p>
+ * If this object was destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+ * </p>
+ *
+ * @returns {boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+ *
+ * @see SpecularEnvironmentCubeMap#destroy
+ */
+SpecularEnvironmentCubeMap.prototype.isDestroyed = function () {
+  return false;
+};
+
+/**
+ * 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.
+ * <p>
+ * Once an object is destroyed, it should not be used; calling any function other than
+ * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+ * assign the return value (<code>undefined</code>) to the object as done in the example.
+ * </p>
+ *
+ * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+ *
+ * @see SpecularEnvironmentCubeMap#isDestroyed
+ */
+SpecularEnvironmentCubeMap.prototype.destroy = function () {
+  cleanupResources(this);
+  this._texture = this._texture && this._texture.destroy();
+  return destroyObject(this);
+};
+export default SpecularEnvironmentCubeMap;

package/Source/Scene/Tonemapper.js

@@ -1,52 +1,64 @@
 /**
  * A tonemapping algorithm when rendering with high dynamic range.
  *
- * @enum {number}
- * @private
+ * @enum {string}
  */
 const Tonemapper = {
   /**
-   * Use the Reinhard tonemapping operator.
+   * Use the Reinhard tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  REINHARD: 0,
+  REINHARD: "REINHARD",
 
   /**
-   * Use the modified Reinhard tonemapping operator.
+   * Use the modified Reinhard tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  MODIFIED_REINHARD: 1,
+  MODIFIED_REINHARD: "MODIFIED_REINHARD",
 
   /**
-   * Use the Filmic tonemapping operator.
+   * Use the Filmic tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  FILMIC: 2,
+  FILMIC: "FILMIC",
 
   /**
-   * Use the ACES tonemapping operator.
+   * Use the ACES tonemapping.
    *
-   * @type {number}
+   * @type {string}
    * @constant
    */
-  ACES: 3,
+  ACES: "ACES",
 
   /**
-   * @private
+   * Use the PBR Neutral tonemapping {@link https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral|from Khronos}.
+   *
+   * @type {string}
+   * @constant
    */
-  validate: function (tonemapper) {
-    return (
-      tonemapper === Tonemapper.REINHARD ||
-      tonemapper === Tonemapper.MODIFIED_REINHARD ||
-      tonemapper === Tonemapper.FILMIC ||
-      tonemapper === Tonemapper.ACES
-    );
-  },
+  PBR_NEUTRAL: "PBR_NEUTRAL",
 };
+
+/**
+ * Validate whether the provided value is a known Tonemapper type
+ * @private
+ *
+ * @param {string} tonemapper
+ */
+export function validateTonemapper(tonemapper) {
+  return (
+    tonemapper === Tonemapper.REINHARD ||
+    tonemapper === Tonemapper.MODIFIED_REINHARD ||
+    tonemapper === Tonemapper.FILMIC ||
+    tonemapper === Tonemapper.ACES ||
+    tonemapper === Tonemapper.PBR_NEUTRAL
+  );
+}
+
 export default Object.freeze(Tonemapper);

package/Source/Scene/VoxelPrimitive.js

@@ -332,12 +332,6 @@ function VoxelPrimitive(options) {
   this._transformNormalLocalToWorld = new Matrix3();
 
   // Rendering
-  /**
-   * @type {boolean}
-   * @private
-   */
-  this._jitter = false;
-
   /**
    * @type {boolean}
    * @private
@@ -704,29 +698,6 @@ Object.defineProperties(VoxelPrimitive.prototype, {
     },
   },
 
-  /**
-   * Gets or sets whether or not to jitter the view ray during the raymarch.
-   * This reduces stair-step artifacts but introduces noise.
-   *
-   * @memberof VoxelPrimitive.prototype
-   * @type {boolean}
-   */
-  jitter: {
-    get: function () {
-      return this._jitter;
-    },
-    set: function (jitter) {
-      //>>includeStart('debug', pragmas.debug);
-      Check.typeOf.bool("jitter", jitter);
-      //>>includeEnd('debug');
-
-      if (this._jitter !== jitter) {
-        this._jitter = jitter;
-        this._shaderDirty = true;
-      }
-    },
-  },
-
   /**
    * Gets or sets the nearest sampling.
    *

package/Source/Scene/VoxelRenderResources.js

@@ -215,9 +215,6 @@ function VoxelRenderResources(primitive) {
       ShaderDestination.FRAGMENT
     );
   }
-  if (primitive._jitter) {
-    shaderBuilder.addDefine("JITTER", undefined, ShaderDestination.FRAGMENT);
-  }
   if (primitive._nearestSampling) {
     shaderBuilder.addDefine(
       "NEAREST_SAMPLING",

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -103,6 +103,7 @@ import czm_nearFarScalar from './Functions/nearFarScalar.js'
 import czm_octDecode from './Functions/octDecode.js'
 import czm_packDepth from './Functions/packDepth.js'
 import czm_pbrLighting from './Functions/pbrLighting.js'
+import czm_pbrNeutralTonemapping from './Functions/pbrNeutralTonemapping.js'
 import czm_phong from './Functions/phong.js'
 import czm_planeDistance from './Functions/planeDistance.js'
 import czm_pointAlongRay from './Functions/pointAlongRay.js'
@@ -112,7 +113,6 @@ import czm_readDepth from './Functions/readDepth.js'
 import czm_readNonPerspective from './Functions/readNonPerspective.js'
 import czm_reverseLogDepth from './Functions/reverseLogDepth.js'
 import czm_round from './Functions/round.js'
-import czm_sampleOctahedralProjection from './Functions/sampleOctahedralProjection.js'
 import czm_saturation from './Functions/saturation.js'
 import czm_shadowDepthCompare from './Functions/shadowDepthCompare.js'
 import czm_shadowVisibility from './Functions/shadowVisibility.js'
@@ -241,6 +241,7 @@ export default {
     czm_octDecode : czm_octDecode,
     czm_packDepth : czm_packDepth,
     czm_pbrLighting : czm_pbrLighting,
+    czm_pbrNeutralTonemapping : czm_pbrNeutralTonemapping,
     czm_phong : czm_phong,
     czm_planeDistance : czm_planeDistance,
     czm_pointAlongRay : czm_pointAlongRay,
@@ -250,7 +251,6 @@ export default {
     czm_readNonPerspective : czm_readNonPerspective,
     czm_reverseLogDepth : czm_reverseLogDepth,
     czm_round : czm_round,
-    czm_sampleOctahedralProjection : czm_sampleOctahedralProjection,
     czm_saturation : czm_saturation,
     czm_shadowDepthCompare : czm_shadowDepthCompare,
     czm_shadowVisibility : czm_shadowVisibility,

package/Source/Shaders/Builtin/Functions/pbrLighting.glsl

@@ -96,8 +96,8 @@ float GGX(float alphaRoughness, float NdotH)
  */
 float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float alphaRoughness)
 {
-    float NdotL = dot(normal, lightDirection);
-    float NdotV = abs(dot(normal, viewDirection));
+    float NdotL = clamp(dot(normal, lightDirection), 0.0, 1.0);
+    float NdotV = clamp(dot(normal, viewDirection), 0.0, 1.0);
     float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);
     float NdotH = clamp(dot(normal, halfwayDirection), 0.0, 1.0);
     float D = GGX(alphaRoughness, NdotH);

package/Source/Shaders/Builtin/Functions/pbrLighting.js

@@ -97,8 +97,8 @@ float GGX(float alphaRoughness, float NdotH)\n\
  */\n\
 float computeDirectSpecularStrength(vec3 normal, vec3 lightDirection, vec3 viewDirection, vec3 halfwayDirection, float alphaRoughness)\n\
 {\n\
-    float NdotL = dot(normal, lightDirection);\n\
-    float NdotV = abs(dot(normal, viewDirection));\n\
+    float NdotL = clamp(dot(normal, lightDirection), 0.0, 1.0);\n\
+    float NdotV = clamp(dot(normal, viewDirection), 0.0, 1.0);\n\
     float G = smithVisibilityGGX(alphaRoughness, NdotL, NdotV);\n\
     float NdotH = clamp(dot(normal, halfwayDirection), 0.0, 1.0);\n\
     float D = GGX(alphaRoughness, NdotH);\n\

package/Source/Shaders/Builtin/Functions/pbrNeutralTonemapping.glsl

@@ -0,0 +1,23 @@
+// KhronosGroup https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral
+
+// Input color is non-negative and resides in the Linear Rec. 709 color space.
+// Output color is also Linear Rec. 709, but in the [0, 1] range.
+
+vec3 czm_pbrNeutralTonemapping(vec3 color) {
+    const float startCompression = 0.8 - 0.04;
+    const float desaturation = 0.15;
+
+    float x = min(color.r, min(color.g, color.b));
+    float offset = czm_branchFreeTernary(x < 0.08, x - 6.25 * x * x, 0.04);
+    color -= offset;
+
+    float peak = max(color.r, max(color.g, color.b));
+    if (peak < startCompression) return color;
+
+    const float d = 1.0 - startCompression;
+    float newPeak = 1.0 - d * d / (peak + d - startCompression);
+    color *= newPeak / peak;
+
+    float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+    return mix(color, newPeak * vec3(1.0, 1.0, 1.0), g);
+}

package/Source/Shaders/Builtin/Functions/pbrNeutralTonemapping.js

@@ -0,0 +1,25 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// KhronosGroup https://github.com/KhronosGroup/ToneMapping/tree/main/PBR_Neutral\n\
+\n\
+// Input color is non-negative and resides in the Linear Rec. 709 color space.\n\
+// Output color is also Linear Rec. 709, but in the [0, 1] range.\n\
+\n\
+vec3 czm_pbrNeutralTonemapping(vec3 color) {\n\
+    const float startCompression = 0.8 - 0.04;\n\
+    const float desaturation = 0.15;\n\
+\n\
+    float x = min(color.r, min(color.g, color.b));\n\
+    float offset = czm_branchFreeTernary(x < 0.08, x - 6.25 * x * x, 0.04);\n\
+    color -= offset;\n\
+\n\
+    float peak = max(color.r, max(color.g, color.b));\n\
+    if (peak < startCompression) return color;\n\
+\n\
+    const float d = 1.0 - startCompression;\n\
+    float newPeak = 1.0 - d * d / (peak + d - startCompression);\n\
+    color *= newPeak / peak;\n\
+\n\
+    float g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);\n\
+    return mix(color, newPeak * vec3(1.0, 1.0, 1.0), g);\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/textureCube.glsl

@@ -6,12 +6,31 @@
  * @glslFunction
  *
  * @param {samplerCube} sampler The sampler.
- * @param {vec3} p The coordinates to sample the texture at.
+ * @param {vec3} p The coordinate at which to sample the texture.
  */
 vec4 czm_textureCube(samplerCube sampler, vec3 p) {
 #if __VERSION__ == 300
     return texture(sampler, p);
-#else  
+#else
     return textureCube(sampler, p);
 #endif
+}
+
+/**
+ * A wrapper around the textureLod (WebGL2) / textureCube (WebGL1)
+ * function to allow for WebGL 1 support in fragment shaders.
+ *
+ * @name czm_textureCubeLod
+ * @glslFunction
+ *
+ * @param {samplerCube} sampler The sampler.
+ * @param {vec3} p The coordinate at which to sample the texture.
+ * @param {float} lod The mipmap level from which to sample.
+ */
+vec4 czm_textureCube(samplerCube sampler, vec3 p, float lod) {
+#if __VERSION__ == 300
+    return textureLod(sampler, p, lod);
+#elif defined(GL_EXT_shader_texture_lod)
+    return textureCubeLodEXT(sampler, p, lod);
+#endif
 }

package/Source/Shaders/Builtin/Functions/textureCube.js

@@ -7,12 +7,31 @@ export default "/**\n\
  * @glslFunction\n\
  *\n\
  * @param {samplerCube} sampler The sampler.\n\
- * @param {vec3} p The coordinates to sample the texture at.\n\
+ * @param {vec3} p The coordinate at which to sample the texture.\n\
  */\n\
 vec4 czm_textureCube(samplerCube sampler, vec3 p) {\n\
 #if __VERSION__ == 300\n\
     return texture(sampler, p);\n\
-#else  \n\
+#else\n\
     return textureCube(sampler, p);\n\
 #endif\n\
+}\n\
+\n\
+/**\n\
+ * A wrapper around the textureLod (WebGL2) / textureCube (WebGL1)\n\
+ * function to allow for WebGL 1 support in fragment shaders.\n\
+ *\n\
+ * @name czm_textureCubeLod\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {samplerCube} sampler The sampler.\n\
+ * @param {vec3} p The coordinate at which to sample the texture.\n\
+ * @param {float} lod The mipmap level from which to sample.\n\
+ */\n\
+vec4 czm_textureCube(samplerCube sampler, vec3 p, float lod) {\n\
+#if __VERSION__ == 300\n\
+    return textureLod(sampler, p, lod);\n\
+#elif defined(GL_EXT_shader_texture_lod)\n\
+    return textureCubeLodEXT(sampler, p, lod);\n\
+#endif\n\
 }";

package/Source/Shaders/Builtin/Structs/materialInput.glsl

@@ -13,6 +13,7 @@
  * @property {float} height The height of the terrain in meters above or below the ellipsoid.  Only available for globe materials.
  * @property {float} slope The slope of the terrain in radians.  0 is flat; pi/2 is vertical.  Only available for globe materials.
  * @property {float} aspect The aspect of the terrain in radians.  0 is East, pi/2 is North, pi is West, 3pi/2 is South.  Only available for globe materials.
+* @property {float} waterMask The value of the water mask. 0 is land, 1 is water. Only available for globe materials.
  */
 struct czm_materialInput
 {
@@ -25,4 +26,5 @@ struct czm_materialInput
     float height;
     float slope;
     float aspect;
+    float waterMask;
 };

package/Source/Shaders/Builtin/Structs/materialInput.js

@@ -14,6 +14,7 @@ export default "/**\n\
  * @property {float} height The height of the terrain in meters above or below the ellipsoid.  Only available for globe materials.\n\
  * @property {float} slope The slope of the terrain in radians.  0 is flat; pi/2 is vertical.  Only available for globe materials.\n\
  * @property {float} aspect The aspect of the terrain in radians.  0 is East, pi/2 is North, pi is West, 3pi/2 is South.  Only available for globe materials.\n\
+* @property {float} waterMask The value of the water mask. 0 is land, 1 is water. Only available for globe materials.\n\
  */\n\
 struct czm_materialInput\n\
 {\n\
@@ -26,5 +27,6 @@ struct czm_materialInput\n\
     float height;\n\
     float slope;\n\
     float aspect;\n\
+    float waterMask;\n\
 };\n\
 ";

package/Source/Shaders/GlobeFS.glsl

@@ -49,7 +49,7 @@ uniform vec4 u_colorsToAlpha[TEXTURE_UNITS];
 uniform vec4 u_dayTextureTexCoordsRectangle[TEXTURE_UNITS];
 #endif
 
-#ifdef SHOW_REFLECTIVE_OCEAN
+#if defined(HAS_WATER_MASK) && (defined(SHOW_REFLECTIVE_OCEAN) || defined(APPLY_MATERIAL))
 uniform sampler2D u_waterMask;
 uniform vec4 u_waterMaskTranslationAndScale;
 uniform float u_zoomedOutOceanSpecularIntensity;
@@ -362,7 +362,7 @@ void main()
     float fade = 0.0;
 #endif
 
-#ifdef SHOW_REFLECTIVE_OCEAN
+#if defined(HAS_WATER_MASK) && (defined(SHOW_REFLECTIVE_OCEAN) || defined(APPLY_MATERIAL))
     vec2 waterMaskTranslation = u_waterMaskTranslationAndScale.xy;
     vec2 waterMaskScale = u_waterMaskTranslationAndScale.zw;
     vec2 waterMaskTextureCoordinates = v_textureCoordinates.xy * waterMaskScale + waterMaskTranslation;
@@ -370,6 +370,7 @@ void main()
 
     float mask = texture(u_waterMask, waterMaskTextureCoordinates).r;
 
+    #ifdef SHOW_REFLECTIVE_OCEAN
     if (mask > 0.0)
     {
         mat3 enuToEye = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalEC);
@@ -381,6 +382,7 @@ void main()
 
         color = computeWaterColor(v_positionEC, textureCoordinates, enuToEye, color, mask, fade);
     }
+    #endif
 #endif
 
 #ifdef APPLY_MATERIAL
@@ -392,6 +394,10 @@ void main()
     materialInput.slope = v_slope;
     materialInput.height = v_height;
     materialInput.aspect = v_aspect;
+    #ifdef HAS_WATER_MASK
+        materialInput.waterMask = mask;
+    #endif
+
     czm_material material = czm_getMaterial(materialInput);
     vec4 materialColor = vec4(material.diffuse, material.alpha);
     color = alphaBlend(materialColor, color);
@@ -422,7 +428,7 @@ void main()
 #ifdef ENABLE_CLIPPING_POLYGONS
     vec2 clippingPosition = v_clippingPosition;
     int regionIndex = v_regionIndex;
-    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);    
+    clipPolygons(u_clippingDistance, CLIPPING_POLYGON_REGIONS_LENGTH, clippingPosition, regionIndex);
 #endif
 
 #ifdef HIGHLIGHT_FILL_TILE
@@ -489,7 +495,7 @@ void main()
             #endif
 
             #ifndef HDR
-                fogColor.rgb = czm_acesTonemapping(fogColor.rgb);
+                fogColor.rgb = czm_pbrNeutralTonemapping(fogColor.rgb);
                 fogColor.rgb = czm_inverseGamma(fogColor.rgb);
             #endif