@geoblocks/cesium-post-process 0.3.0 → 0.4.0

package/README.md

@@ -24,10 +24,14 @@ const snowLine = new SnowLine(viewer, {
   altitude: 2000,  // meters above the ellipsoid where the snow is half covering
   transition: 200, // height of the band over which the snow thins out, in meters
   maxSlope: 50,    // steepest slope that holds snow, in degrees
-  coverage: 1,     // opacity of the snow, 0 to 1
+  coverage: 1,     // opacity of the snow, 0 to 1; at 0 the stage is off
   patchiness: 0,   // 0 to 1: at 1 the coverage is the share of the ground the snow covers, the noise leaving the rest bare
   waterLevel: 564, // meters above the ellipsoid: what lies within a quarter meter of it holds no snow, so a flat lake stays water
   sunDirection: sun, // the direction toward the sun the snow is shaded by, in world coordinates; Cesium's own sun if none
+  grain: 90,       // the noise's largest scale, in meters, its finer ones a third and a ninth of it: a few meters for a garden
+  sceneLight: 0,   // 0 to 1: how far the snow's brightness is the scene's own, its shadows and its dusk kept; 0 the sun's shading alone
+  steepCover: 0.35, // the thin cover the steep slopes keep, as a fraction of the coverage; 0 for none on a building's walls
+  origin: position, // the point of the world the noise is laid about; the camera's position when activated if none
 });
 snowLine.active = true;
 
@@ -77,6 +81,7 @@ const rainRings = new RainRings(viewer, {
   maxSlope: 30,      // steepest slope that takes a ring, in degrees
   color: new Color(0.31, 0.39, 0.5, 0.6), // slate on a light ground, pale on a dark one; the alpha is how strongly it shows
   origin: position,  // the point of the world the cells are laid about; the camera's position when activated if none
+  clock: () => performance.now() / 1000, // the time the rings run by, in seconds; one that stands still keeps them still (less motion)
 });
 rainRings.active = true;
 

package/local-frame.js

@@ -1,4 +1,4 @@
-import {Matrix4} from '@cesium/core';
+import {Cartesian3, FixedFrameTransforms, Matrix4} from '@cesium/core';
 
 /**
  * The local frame's coordinates from the eye's, for a shader that wants a pixel's place in a small frame (east-north-up about a point) to
@@ -13,3 +13,45 @@ import {Matrix4} from '@cesium/core';
 export function localFromEye(frame, viewMatrix, result = new Matrix4()) {
   return Matrix4.inverseTransformation(Matrix4.multiply(viewMatrix, frame, result), result);
 }
+
+/**
+ * A local frame, east-north-up about an origin, for an effect that lays a pattern over the ground: the origin given, or the camera's
+ * position when the frame is first anchored.
+ */
+export class LocalFrame {
+  /** @param {Cartesian3} [origin] */
+  constructor(origin) {
+    this.origin_ = origin && Cartesian3.clone(origin);
+    /** @type {Matrix4 | undefined} */
+    this.frame_ = undefined;
+    this.scratch_ = new Matrix4();
+  }
+
+  /** The point of the world the frame is laid about; undefined until anchored if none was given. */
+  get origin() {
+    return this.origin_;
+  }
+
+  set origin(value) {
+    this.origin_ = value && Cartesian3.clone(value);
+    this.frame_ = undefined;
+  }
+
+  /**
+   * The origin, the camera's position if there is none yet.
+   * @param {import('@cesium/engine').Scene} scene
+   */
+  anchor(scene) {
+    this.origin_ ??= Cartesian3.clone(scene.camera.positionWC);
+    return this.origin_;
+  }
+
+  /**
+   * The local frame's coordinates from the camera's eye's (localFromEye), anchored first.
+   * @param {import('@cesium/engine').Scene} scene
+   */
+  fromEye(scene) {
+    this.frame_ ??= FixedFrameTransforms.eastNorthUpToFixedFrame(this.anchor(scene), scene.ellipsoid, new Matrix4());
+    return localFromEye(this.frame_, scene.camera.viewMatrix, this.scratch_);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geoblocks/cesium-post-process",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "BSD-3-Clause",
   "type": "module",
   "repository": {
@@ -56,5 +56,5 @@
     "@cesium/core": ">=0.1.0",
     "@cesium/engine": ">=10"
   },
-  "gitHead": "866feb087ad153c2303fdf12b670ec78f192f825"
+  "gitHead": "c9101c5e42f96f2ccc28cfb396dbe08c55e29a09"
 }

package/rain-rings.js

@@ -1,10 +1,10 @@
-import {Cartesian3, Cartesian4, Color, FixedFrameTransforms, Matrix4, Math as CesiumMath} from '@cesium/core';
+import {Cartesian3, Cartesian4, Color, Math as CesiumMath} from '@cesium/core';
 import {PostProcessStage} from '@cesium/engine';
 import {acquireTerrainDepth, releaseTerrainDepth} from './depth-test.js';
 import Effect from './effect.js';
 import {acquireFrames, releaseFrames} from './frame-clock.js';
 import {heightUniforms} from './height.js';
-import {localFromEye} from './local-frame.js';
+import {LocalFrame} from './local-frame.js';
 import EyeFromDepth from './shaders/EyeFromDepth.js';
 import Hash from './shaders/Hash.js';
 import Height from './shaders/Height.js';
@@ -28,10 +28,11 @@ export default class RainRings extends Effect {
   /**
    * @param {import('@cesium/engine').CesiumWidget} viewer
    * @param {{intensity?: number, cell?: number, reach?: number, waterLevel?: number, maxSlope?: number, rate?: number,
-   *   color?: Color, origin?: Cartesian3}} [options] The share of the cells that have a drop, 0 to 1; the cell's size and the ring's growth
-   *   on the ground, in meters (the ring on water is clipped at 0.3 cell); the water's height above the ellipsoid, in meters, or undefined
-   *   for none; the steepest slope that takes a ring, in degrees; rings a second in a cell; the ring's color, its alpha how strongly it shows; the
-   *   point of the world the cells are laid about.
+   *   color?: Color, origin?: Cartesian3, clock?: () => number}} [options] The share of the cells that have a drop, 0 to 1; the cell's size
+   *   and the ring's growth on the ground, in meters (the ring on water is clipped at 0.3 cell); the water's height above the ellipsoid, in
+   *   meters, or undefined for none; the steepest slope that takes a ring, in degrees; rings a second in a cell; the ring's color, its alpha how
+   *   strongly it shows; the point of the world the cells are laid about; the time the rings run by, in seconds (the wall clock's by default;
+   *   one that stands still keeps them still, for a viewer who asks for less motion).
    */
   constructor(viewer, options = {}) {
     super(viewer);
@@ -42,23 +43,9 @@ export default class RainRings extends Effect {
     this.maxSlope_ = options.maxSlope ?? 30;
     this.rate_ = options.rate ?? 1.6;
     this.color_ = options.color ?? new Color(0.31, 0.39, 0.5, 0.6);
-    this.origin_ = options.origin && Cartesian3.clone(options.origin);
-    /** @type {Matrix4 | undefined} */
-    this.localFrame_ = undefined;
+    this.frame_ = new LocalFrame(options.origin);
+    this.clock_ = options.clock ?? (() => performance.now() / 1000);
     this.colorScratch_ = new Cartesian4();
-    this.localScratch_ = new Matrix4();
-  }
-
-  /**
-   * The local frame, east-north-up about the origin: the camera's position when the effect is activated, if none was given.
-   * @private
-   * @param {import('@cesium/engine').Scene} scene
-   */
-  frameAt_(scene) {
-    this.origin_ ??= Cartesian3.clone(scene.camera.positionWC);
-    const frame = this.localFrame_ ?? FixedFrameTransforms.eastNorthUpToFixedFrame(this.origin_, scene.ellipsoid, new Matrix4());
-    this.localFrame_ = frame;
-    return frame;
   }
 
   /**
@@ -70,14 +57,14 @@ export default class RainRings extends Effect {
       fragmentShader: EyeFromDepth + Height + Hash + Normal + RainRingsShader,
       uniforms: {
         ...heightUniforms(scene),
-        localFromEye: () => localFromEye(this.frameAt_(scene), scene.camera.viewMatrix, this.localScratch_),
+        localFromEye: () => this.frame_.fromEye(scene),
         intensity: () => this.intensity_,
         cell: () => this.cell_,
         reach: () => this.reach_,
         waterLevel: () => this.waterLevel_ ?? NO_WATER,
         maxSlope: () => CesiumMath.toRadians(this.maxSlope_),
         rate: () => this.rate_,
-        time: () => (performance.now() / 1000) % TIME_PERIOD,
+        time: () => this.clock_() % TIME_PERIOD,
         color: () => Cartesian4.fromColor(this.color_, this.colorScratch_),
       },
     });
@@ -91,7 +78,7 @@ export default class RainRings extends Effect {
    * @param {import('@cesium/engine').Scene} scene
    */
   activated_(scene) {
-    this.frameAt_(scene);
+    this.frame_.anchor(scene);
     acquireTerrainDepth(scene);
     if (this.intensity_ > 0) {
       acquireFrames(scene, FRAME_RATE);
@@ -204,12 +191,11 @@ export default class RainRings extends Effect {
    * the effect is activated if none is given. Keep it within a few kilometers of what is looked at.
    */
   get origin() {
-    return this.origin_;
+    return this.frame_.origin;
   }
 
   set origin(value) {
-    this.origin_ = value && Cartesian3.clone(value);
-    this.localFrame_ = undefined;
+    this.frame_.origin = value;
     this.viewer.scene.requestRender();
   }
 }

package/shaders/SnowLine.js

@@ -1,2 +1,2 @@
 // This file is automatically rebuilt from SnowLine.glsl.
-export default "// Snow above an altitude, on slopes gentle enough to hold it, shaded by the sun and by the\n// brightness of the scene so that the relief stays readable. The slope comes from a normal\n// rebuilt from the neighboring pixels and smoothed over the facets of the terrain. Noise anchored\n// to the ground breaks up the edge of the snow, which lasts lower on the slopes away from the sun.\nprecision highp sampler2D;\nuniform sampler2D colorTexture;\nuniform sampler2D depthTexture;\n// meters above the ellipsoid: half covered at the altitude, over a band transition meters high\nuniform float altitude;\nuniform float transition;\n// radians\nuniform float maxSlope;\n// 0 to 1\nuniform float coverage;\n// 0 to 1: how far the coverage thins the snow into patches, where 0 fades it\nuniform float patchiness;\n// meters above the ellipsoid, far above anything with no water: none lies within a quarter meter of it\nuniform float waterLevel;\n// the sun toward which the snow is shaded, in eye coordinates, when ownSun is 1; else Cesium's\nuniform vec3 sunEC;\nuniform float ownSun;\nin vec2 v_textureCoordinates;\n\nconst vec3 SNOW_SHADE = vec3(0.80, 0.87, 1.0);\nconst vec3 SNOW_SUN = vec3(1.0, 0.98, 0.94);\n// meters the snow line moves down on a slope facing away from the sun, and up on one facing it\nconst float ASPECT_SHIFT = 0.6;\n// meters the noise moves the snow line, as a fraction of the transition\nconst float NOISE_SHIFT = 0.8;\n// part of the snow that still covers the steep slopes at the limit, as a fraction of the coverage\nconst float STEEP_SNOW = 0.35;\n// half width of the slope limit, in radians (8 degrees), so that the snow thins out across the\n// facets of the terrain rather than stopping at their edges\nconst float SLOPE_EDGE = 0.14;\n// the coverage, moved by the noise, from which the snow begins and is whole when it is patches; how far the noise moves it\nconst vec2 PATCH = vec2(0.25, 0.6);\nconst float PATCH_NOISE = 1.6;\n// meters from the water's level within which a surface is water, and beyond which it is not\nconst vec2 WET = vec2(0.1, 0.25);\n\nfloat hash(vec3 p) {\n  p = fract(p * 0.3183099 + 0.1);\n  p *= 17.0;\n  return fract(p.x * p.y * p.z * (p.x + p.y + p.z));\n}\n\nfloat valueNoise(vec3 p) {\n  vec3 i = floor(p);\n  vec3 f = fract(p);\n  f = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(mix(hash(i), hash(i + vec3(1, 0, 0)), f.x), mix(hash(i + vec3(0, 1, 0)), hash(i + vec3(1, 1, 0)), f.x), f.y),\n    mix(mix(hash(i + vec3(0, 0, 1)), hash(i + vec3(1, 0, 1)), f.x), mix(hash(i + vec3(0, 1, 1)), hash(i + vec3(1, 1, 1)), f.x), f.y),\n    f.z);\n}\n\n// 0 to 1, from a few octaves anchored to the ground\nfloat groundNoise(vec3 world) {\n  return 0.55 * valueNoise(world / 90.0) + 0.3 * valueNoise(world / 30.0) + 0.15 * valueNoise(world / 10.0);\n}\n\nvoid main() {\n  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);\n  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);\n  vec3 normal = smoothNormalAt(depthTexture, v_textureCoordinates, eye.xyz);\n  float slope = acos(clamp(dot(normal, up), -1.0, 1.0));\n\n  float sun = max(dot(normal, ownSun > 0.5 ? sunEC : czm_sunDirectionEC), 0.0);\n  float noise = groundNoise((czm_inverseView * vec4(eye.xyz, 1.0)).xyz) - 0.5;\n  // lower on the slopes away from the sun, irregular along the edge\n  float shift = transition * (NOISE_SHIFT * noise + ASPECT_SHIFT * (0.5 - sun));\n  float snowLine = altitude + shift;\n  float snow = smoothstep(snowLine - 0.5 * transition, snowLine + 0.5 * transition, heightAt(eye.xyz));\n  // opaque before the top of the band, so that the imagery does not show through the snow\n  snow = smoothstep(0.0, 0.7, snow);\n  // the steep slopes keep a thin, patchy cover, and the rock shows through\n  float steep = smoothstep(maxSlope - SLOPE_EDGE, maxSlope + SLOPE_EDGE, slope);\n  snow *= 1.0 - steep * (1.0 - STEEP_SNOW * smoothstep(0.35, 0.65, noise + 0.5));\n  // the coverage an opacity, or, by the patchiness, the share of the ground the snow covers, the noise leaving it in patches\n  float scattered = smoothstep(PATCH.x, PATCH.y, coverage + PATCH_NOISE * noise);\n  // eye.w is 0 for the sky\n  snow *= mix(coverage, scattered, patchiness) * eye.w;\n  snow *= smoothstep(WET.x, WET.y, abs(heightAt(eye.xyz) - waterLevel));\n  float brightness = czm_luminance(sceneColor.rgb);\n  // blue in the shade, warm in the sun, with the relief of the scene kept in the brightness\n  vec3 lit = mix(SNOW_SHADE, SNOW_SUN, sun) * clamp(0.68 + 0.25 * sun + 0.1 * brightness, 0.0, 1.0);\n  out_FragColor = vec4(mix(sceneColor.rgb, lit, snow), sceneColor.a);\n}\n";
+export default "// Snow above an altitude, on slopes gentle enough to hold it, shaded by the sun and by the\n// brightness of the scene so that the relief stays readable. The slope comes from a normal\n// rebuilt from the neighboring pixels and smoothed over the facets of the terrain. Noise anchored\n// to the ground breaks up the edge of the snow, which lasts lower on the slopes away from the sun.\nprecision highp sampler2D;\nuniform sampler2D colorTexture;\nuniform sampler2D depthTexture;\n// meters above the ellipsoid: half covered at the altitude, over a band transition meters high\nuniform float altitude;\nuniform float transition;\n// radians\nuniform float maxSlope;\n// 0 to 1\nuniform float coverage;\n// 0 to 1: how far the coverage thins the snow into patches, where 0 fades it\nuniform float patchiness;\n// meters: the noise's largest scale, its finer ones a third and a ninth of it\nuniform float grain;\n// 0 to 1: how far the snow's brightness is the scene's own (its shadows, the dusk), where 0 is the sun's shading\nuniform float sceneLight;\n// 0 to 1: the part of the snow that still covers the steep slopes at the limit, as a fraction of the coverage\nuniform float steepCover;\n// the local frame's coordinates from the eye's, made in double precision on the CPU (local-frame.js): the noise's place\nuniform mat4 localFromEye;\n// meters above the ellipsoid, far above anything with no water: none lies within a quarter meter of it\nuniform float waterLevel;\n// the sun toward which the snow is shaded, in eye coordinates, when ownSun is 1; else Cesium's\nuniform vec3 sunEC;\nuniform float ownSun;\nin vec2 v_textureCoordinates;\n\nconst vec3 SNOW_SHADE = vec3(0.80, 0.87, 1.0);\nconst vec3 SNOW_SUN = vec3(1.0, 0.98, 0.94);\n// meters the snow line moves down on a slope facing away from the sun, and up on one facing it\nconst float ASPECT_SHIFT = 0.6;\n// meters the noise moves the snow line, as a fraction of the transition\nconst float NOISE_SHIFT = 0.8;\n// half width of the slope limit, in radians (8 degrees), so that the snow thins out across the\n// facets of the terrain rather than stopping at their edges\nconst float SLOPE_EDGE = 0.14;\n// the coverage, moved by the noise, from which the snow begins and is whole when it is patches; how far the noise moves it\nconst vec2 PATCH = vec2(0.25, 0.6);\nconst float PATCH_NOISE = 1.6;\n// meters from the water's level within which a surface is water, and beyond which it is not\nconst vec2 WET = vec2(0.1, 0.25);\n\nfloat hash(vec3 p) {\n  p = fract(p * 0.3183099 + 0.1);\n  p *= 17.0;\n  return fract(p.x * p.y * p.z * (p.x + p.y + p.z));\n}\n\nfloat valueNoise(vec3 p) {\n  vec3 i = floor(p);\n  vec3 f = fract(p);\n  f = f * f * (3.0 - 2.0 * f);\n  return mix(\n    mix(mix(hash(i), hash(i + vec3(1, 0, 0)), f.x), mix(hash(i + vec3(0, 1, 0)), hash(i + vec3(1, 1, 0)), f.x), f.y),\n    mix(mix(hash(i + vec3(0, 0, 1)), hash(i + vec3(1, 0, 1)), f.x), mix(hash(i + vec3(0, 1, 1)), hash(i + vec3(1, 1, 1)), f.x), f.y),\n    f.z);\n}\n\n// 0 to 1, from a few octaves anchored to the ground, in the local frame: in world coordinates a float steps by half a meter\nfloat groundNoise(vec3 local) {\n  return 0.55 * valueNoise(local / grain) + 0.3 * valueNoise(3.0 * local / grain) + 0.15 * valueNoise(9.0 * local / grain);\n}\n\nvoid main() {\n  vec4 sceneColor = texture(colorTexture, v_textureCoordinates);\n  vec4 eye = eyeAt(depthTexture, v_textureCoordinates);\n  vec3 normal = smoothNormalAt(depthTexture, v_textureCoordinates, eye.xyz);\n  float slope = acos(clamp(dot(normal, up), -1.0, 1.0));\n\n  float sun = max(dot(normal, ownSun > 0.5 ? sunEC : czm_sunDirectionEC), 0.0);\n  float noise = groundNoise((localFromEye * vec4(eye.xyz, 1.0)).xyz) - 0.5;\n  // lower on the slopes away from the sun, irregular along the edge\n  float shift = transition * (NOISE_SHIFT * noise + ASPECT_SHIFT * (0.5 - sun));\n  float snowLine = altitude + shift;\n  float snow = smoothstep(snowLine - 0.5 * transition, snowLine + 0.5 * transition, heightAt(eye.xyz));\n  // opaque before the top of the band, so that the imagery does not show through the snow\n  snow = smoothstep(0.0, 0.7, snow);\n  // the steep slopes keep a thin, patchy cover, and the rock shows through\n  float steep = smoothstep(maxSlope - SLOPE_EDGE, maxSlope + SLOPE_EDGE, slope);\n  snow *= 1.0 - steep * (1.0 - steepCover * smoothstep(0.35, 0.65, noise + 0.5));\n  // the coverage an opacity, or, by the patchiness, the share of the ground the snow covers, the noise leaving it in patches\n  float scattered = smoothstep(PATCH.x, PATCH.y, coverage + PATCH_NOISE * noise);\n  // eye.w is 0 for the sky\n  snow *= mix(coverage, scattered, patchiness) * eye.w;\n  snow *= smoothstep(WET.x, WET.y, abs(heightAt(eye.xyz) - waterLevel));\n  float brightness = czm_luminance(sceneColor.rgb);\n  // blue in the shade, warm in the sun, with the relief of the scene kept in the brightness; or as bright as the scene, its shadows and its\n  // dusk kept on the snow\n  float shaded = clamp(0.68 + 0.25 * sun + 0.1 * brightness, 0.0, 1.0);\n  float scene = clamp(0.15 + 1.35 * brightness, 0.0, 1.0);\n  vec3 lit = mix(SNOW_SHADE, SNOW_SUN, sun) * mix(shaded, scene, sceneLight);\n  out_FragColor = vec4(mix(sceneColor.rgb, lit, snow), sceneColor.a);\n}\n";

package/snow-line.js

@@ -3,6 +3,7 @@ import {PostProcessStage} from '@cesium/engine';
 import {acquireTerrainDepth, releaseTerrainDepth} from './depth-test.js';
 import Effect from './effect.js';
 import {heightUniforms} from './height.js';
+import {LocalFrame} from './local-frame.js';
 import EyeFromDepth from './shaders/EyeFromDepth.js';
 import Height from './shaders/Height.js';
 import Normal from './shaders/Normal.js';
@@ -21,7 +22,7 @@ export default class SnowLine extends Effect {
   /**
    * @param {import('@cesium/engine').CesiumWidget} viewer
    * @param {{altitude?: number, transition?: number, maxSlope?: number, coverage?: number, patchiness?: number, waterLevel?: number,
-   *   sunDirection?: Cartesian3}} [options]
+   *   sunDirection?: Cartesian3, grain?: number, sceneLight?: number, steepCover?: number, origin?: Cartesian3}} [options]
    */
   constructor(viewer, options = {}) {
     super(viewer);
@@ -32,6 +33,10 @@ export default class SnowLine extends Effect {
     this.patchiness_ = options.patchiness ?? 0;
     this.waterLevel_ = options.waterLevel;
     this.sunDirection_ = options.sunDirection && Cartesian3.normalize(options.sunDirection, new Cartesian3());
+    this.grain_ = options.grain ?? 90;
+    this.sceneLight_ = options.sceneLight ?? 0;
+    this.steepCover_ = options.steepCover ?? 0.35;
+    this.frame_ = new LocalFrame(options.origin);
   }
 
   /**
@@ -39,7 +44,7 @@ export default class SnowLine extends Effect {
    * @param {import('@cesium/engine').Scene} scene
    */
   createStage_(scene) {
-    return new PostProcessStage({
+    const stage = new PostProcessStage({
       fragmentShader: EyeFromDepth + Height + Normal + SnowLineShader,
       uniforms: {
         ...heightUniforms(scene),
@@ -51,8 +56,15 @@ export default class SnowLine extends Effect {
         waterLevel: () => this.waterLevel_ ?? NO_WATER,
         sunEC: () => this.sunDirection_ ? Matrix4.multiplyByPointAsVector(scene.camera.viewMatrix, this.sunDirection_, sunScratch) : sunScratch,
         ownSun: () => this.sunDirection_ ? 1 : 0,
+        grain: () => this.grain_,
+        sceneLight: () => this.sceneLight_,
+        steepCover: () => this.steepCover_,
+        localFromEye: () => this.frame_.fromEye(scene),
       },
     });
+    // with no coverage the pass would only copy: off
+    stage.enabled = this.coverage_ > 0;
+    return stage;
   }
 
   /**
@@ -60,6 +72,7 @@ export default class SnowLine extends Effect {
    * @param {import('@cesium/engine').Scene} scene
    */
   activated_(scene) {
+    this.frame_.anchor(scene);
     acquireTerrainDepth(scene);
   }
 
@@ -108,7 +121,7 @@ export default class SnowLine extends Effect {
   }
 
   /**
-   * Opacity of the snow, 0 to 1.
+   * Opacity of the snow, 0 (none: the stage is off) to 1.
    */
   get coverage() {
     return this.coverage_;
@@ -116,6 +129,9 @@ export default class SnowLine extends Effect {
 
   set coverage(value) {
     this.coverage_ = value;
+    if (this.stage_) {
+      this.stage_.enabled = value > 0;
+    }
     this.viewer.scene.requestRender();
   }
 
@@ -157,4 +173,56 @@ export default class SnowLine extends Effect {
     this.sunDirection_ = value && Cartesian3.normalize(value, new Cartesian3());
     this.viewer.scene.requestRender();
   }
+
+  /**
+   * The noise's largest scale, in meters, its finer ones a third and a ninth of it: the size of the patches and of the snow line's
+   * irregularities. A few meters for a garden, tens for a mountainside.
+   */
+  get grain() {
+    return this.grain_;
+  }
+
+  set grain(value) {
+    this.grain_ = value;
+    this.viewer.scene.requestRender();
+  }
+
+  /**
+   * How far the snow's brightness is the scene's own, 0 to 1: at 0 the snow is shaded by the sun alone and stays bright at dusk; at 1 it
+   * keeps the scene's shadows and darkens with its light, for a scene lit by a light of its own that goes down at night.
+   */
+  get sceneLight() {
+    return this.sceneLight_;
+  }
+
+  set sceneLight(value) {
+    this.sceneLight_ = value;
+    this.viewer.scene.requestRender();
+  }
+
+  /**
+   * The thin cover the steep slopes keep at the limit, as a fraction of the coverage, 0 to 1: the rock showing through on a mountain; 0
+   * for none on the walls of a building.
+   */
+  get steepCover() {
+    return this.steepCover_;
+  }
+
+  set steepCover(value) {
+    this.steepCover_ = value;
+    this.viewer.scene.requestRender();
+  }
+
+  /**
+   * The point of the world the noise is laid about, which keeps the snow's patches where they are as the camera moves; the camera's
+   * position when the effect is activated if none is given. Keep it within a few kilometers of what is looked at for a grain of a few meters.
+   */
+  get origin() {
+    return this.frame_.origin;
+  }
+
+  set origin(value) {
+    this.frame_.origin = value;
+    this.viewer.scene.requestRender();
+  }
 }