From 2ce55fbb5028edf5bafbc5922dba62c38a83a884 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Sat, 15 Jul 2023 13:25:20 -0500
Subject: [PATCH 01/38] some experimentation

---
 chunky/src/java/se/llbit/math/Ray.java | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 064efb6ed2..405dd72c61 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -269,6 +269,8 @@ public float[] getBiomeWaterColor(Scene scene) {
    * Set this ray to a random diffuse reflection of the input ray.
    */
   public final void diffuseReflection(Ray ray, Random random) {
+    boolean SUN_SAMPLING_TEST = true;
+
     set(ray);
 
     // get random point on unit disk
@@ -277,6 +279,10 @@ public final void diffuseReflection(Ray ray, Random random) {
     double r = FastMath.sqrt(x1);
     double theta = 2 * Math.PI * x2;
 
+    if(SUN_SAMPLING_TEST) {
+
+    }
+
     // project to point on hemisphere in tangent space
     double tx = r * FastMath.cos(theta);
     double ty = r * FastMath.sin(theta);
@@ -314,6 +320,11 @@ public final void diffuseReflection(Ray ray, Random random) {
     d.x = ux * tx + vx * ty + n.x * tz;
     d.y = uy * tx + vy * ty + n.y * tz;
     d.z = uz * tx + vz * ty + n.z * tz;
+//    if(random.nextFloat() < 0.5) {
+//      d.x = -0.5;
+//      d.y = 0.7071;
+//      d.z = 0.5;
+//    }
 
     o.scaleAdd(Ray.OFFSET, d);
     currentMaterial = prevMaterial;

From a06fe8e39b193294fe8330a53e3af00d3fe58144 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Sat, 15 Jul 2023 13:42:32 -0500
Subject: [PATCH 02/38] added some incorrect math

---
 chunky/src/java/se/llbit/math/Ray.java | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 405dd72c61..0a7c81100d 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -279,15 +279,32 @@ public final void diffuseReflection(Ray ray, Random random) {
     double r = FastMath.sqrt(x1);
     double theta = 2 * Math.PI * x2;
 
-    if(SUN_SAMPLING_TEST) {
-
-    }
-
     // project to point on hemisphere in tangent space
     double tx = r * FastMath.cos(theta);
     double ty = r * FastMath.sin(theta);
     double tz = FastMath.sqrt(1 - x1);
 
+    if(SUN_SAMPLING_TEST) {
+      double DESIRED_DX = -0.5;
+      double DESIRED_DY = FastMath.sqrt(0.5);
+      double DESIRED_DZ = 0.5;
+      double desired_tx, desired_ty, desired_tz;
+      if(QuickMath.abs(n.x) > .1) {
+        desired_tx = DESIRED_DX*n.z*(n.y*n.y - n.x*n.x - n.z*n.z) + DESIRED_DZ*n.x*(n.x*n.x - n.y*n.y + n.z*n.z);
+        desired_ty = DESIRED_DX*n.x*n.y - DESIRED_DY*(n.x*n.x + n.z*n.z) + DESIRED_DZ*(n.y*n.z);
+        desired_tz = -DESIRED_DX*n.x + DESIRED_DY*n.y - DESIRED_DZ*n.z;
+        double sqrtxz = FastMath.sqrt(n.x*n.x+n.z*n.z);
+        desired_tx /= sqrtxz;
+        desired_ty /= sqrtxz;
+        if(desired_tz > 0) {
+          tx = desired_tx;
+          ty = desired_ty;
+          tz = desired_tz;
+        }
+      }
+
+    }
+
     // transform from tangent space to world space
     double xx, xy, xz;
     double ux, uy, uz;

From af86166715ef19982fb3c1c6d0ad0de85b449ea5 Mon Sep 17 00:00:00 2001
From: Justin Barker <justintimecuber@gmail.com>
Date: Sun, 16 Jul 2023 17:15:03 -0500
Subject: [PATCH 03/38] fix math

---
 chunky/src/java/se/llbit/math/Ray.java | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 0a7c81100d..2935bf21df 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -285,14 +285,14 @@ public final void diffuseReflection(Ray ray, Random random) {
     double tz = FastMath.sqrt(1 - x1);
 
     if(SUN_SAMPLING_TEST) {
-      double DESIRED_DX = -0.5;
-      double DESIRED_DY = FastMath.sqrt(0.5);
+      double DESIRED_DX = 0.5;
       double DESIRED_DZ = 0.5;
+      double DESIRED_DY = FastMath.sqrt(1 - DESIRED_DX*DESIRED_DX - DESIRED_DZ*DESIRED_DZ);
       double desired_tx, desired_ty, desired_tz;
       if(QuickMath.abs(n.x) > .1) {
-        desired_tx = DESIRED_DX*n.z*(n.y*n.y - n.x*n.x - n.z*n.z) + DESIRED_DZ*n.x*(n.x*n.x - n.y*n.y + n.z*n.z);
+        desired_tx = DESIRED_DX*n.z - DESIRED_DZ*n.x;
         desired_ty = DESIRED_DX*n.x*n.y - DESIRED_DY*(n.x*n.x + n.z*n.z) + DESIRED_DZ*(n.y*n.z);
-        desired_tz = -DESIRED_DX*n.x + DESIRED_DY*n.y - DESIRED_DZ*n.z;
+        desired_tz = DESIRED_DX*n.x + DESIRED_DY*n.y + DESIRED_DZ*n.z;
         double sqrtxz = FastMath.sqrt(n.x*n.x+n.z*n.z);
         desired_tx /= sqrtxz;
         desired_ty /= sqrtxz;
@@ -337,11 +337,6 @@ public final void diffuseReflection(Ray ray, Random random) {
     d.x = ux * tx + vx * ty + n.x * tz;
     d.y = uy * tx + vy * ty + n.y * tz;
     d.z = uz * tx + vz * ty + n.z * tz;
-//    if(random.nextFloat() < 0.5) {
-//      d.x = -0.5;
-//      d.y = 0.7071;
-//      d.z = 0.5;
-//    }
 
     o.scaleAdd(Ray.OFFSET, d);
     currentMaterial = prevMaterial;

From fcfbc591c5b9b48e6c338cfdcf1d05362c22eb01 Mon Sep 17 00:00:00 2001
From: Justin Barker <justintimecuber@gmail.com>
Date: Sun, 16 Jul 2023 17:58:10 -0500
Subject: [PATCH 04/38] add math for when |n.x| <= 0.1

---
 chunky/src/java/se/llbit/math/Ray.java | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 2935bf21df..e18e6eb168 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -289,20 +289,25 @@ public final void diffuseReflection(Ray ray, Random random) {
       double DESIRED_DZ = 0.5;
       double DESIRED_DY = FastMath.sqrt(1 - DESIRED_DX*DESIRED_DX - DESIRED_DZ*DESIRED_DZ);
       double desired_tx, desired_ty, desired_tz;
+      desired_tz = DESIRED_DX*n.x + DESIRED_DY*n.y + DESIRED_DZ*n.z;
       if(QuickMath.abs(n.x) > .1) {
         desired_tx = DESIRED_DX*n.z - DESIRED_DZ*n.x;
-        desired_ty = DESIRED_DX*n.x*n.y - DESIRED_DY*(n.x*n.x + n.z*n.z) + DESIRED_DZ*(n.y*n.z);
-        desired_tz = DESIRED_DX*n.x + DESIRED_DY*n.y + DESIRED_DZ*n.z;
+        desired_ty = DESIRED_DX*n.x*n.y - DESIRED_DY*(n.x*n.x + n.z*n.z) + DESIRED_DZ*n.y*n.z;
         double sqrtxz = FastMath.sqrt(n.x*n.x+n.z*n.z);
         desired_tx /= sqrtxz;
         desired_ty /= sqrtxz;
-        if(desired_tz > 0) {
-          tx = desired_tx;
-          ty = desired_ty;
-          tz = desired_tz;
-        }
+      } else {
+        desired_tx = DESIRED_DZ*n.y - DESIRED_DY*n.z;
+        desired_ty = DESIRED_DY*n.x*n.y - DESIRED_DX*(n.y*n.y + n.z*n.z) + DESIRED_DZ*n.x*n.z;
+        double sqrtyz = FastMath.sqrt(n.y*n.y+n.z*n.z);
+        desired_tx /= sqrtyz;
+        desired_ty /= sqrtyz;
+      }
+      if(desired_tz > 0) {
+        tx = desired_tx;
+        ty = desired_ty;
+        tz = desired_tz;
       }
-
     }
 
     // transform from tangent space to world space

From f435a53cebcfebf9965a095e8c5dbb619060b340 Mon Sep 17 00:00:00 2001
From: Justin Barker <justintimecuber@gmail.com>
Date: Sun, 16 Jul 2023 20:17:34 -0500
Subject: [PATCH 05/38] first decently-working implementation

---
 .../chunky/renderer/scene/PathTracer.java     |  4 +-
 chunky/src/java/se/llbit/math/Ray.java        | 70 +++++++++++++------
 2 files changed, 50 insertions(+), 24 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index a373d6e7b6..c88e15f442 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -232,7 +232,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
                 }
               }
 
-              reflected.diffuseReflection(ray, random);
+              reflected.diffuseReflection(ray, random, scene);
               hit = pathTrace(scene, reflected, state, 0, false) || hit;
               if (hit) {
                 ray.color.x = ray.color.x * (emittance + directLightR * scene.sun.emittance.x + (
@@ -249,7 +249,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
               }
 
             } else {
-              reflected.diffuseReflection(ray, random);
+              reflected.diffuseReflection(ray, random, scene);
 
               hit = pathTrace(scene, reflected, state, 0, false) || hit;
               if (hit) {
diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index e18e6eb168..03be5c2ff2 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -268,8 +268,13 @@ public float[] getBiomeWaterColor(Scene scene) {
   /**
    * Set this ray to a random diffuse reflection of the input ray.
    */
-  public final void diffuseReflection(Ray ray, Random random) {
+  public final void diffuseReflection(Ray ray, Random random, Scene scene) {
+
+    //TODO: Make these configurable
     boolean SUN_SAMPLING_TEST = true;
+    double DEFAULT_CIRCLE_RADIUS = scene.sun().getSunRadius() * 1.2;
+    double MIN_CIRCLE_RADIUS = DEFAULT_CIRCLE_RADIUS / 10;
+    double SUN_SAMPLE_CHANCE = 0.25;
 
     set(ray);
 
@@ -282,34 +287,55 @@ public final void diffuseReflection(Ray ray, Random random) {
     // project to point on hemisphere in tangent space
     double tx = r * FastMath.cos(theta);
     double ty = r * FastMath.sin(theta);
-    double tz = FastMath.sqrt(1 - x1);
 
     if(SUN_SAMPLING_TEST) {
-      double DESIRED_DX = 0.5;
-      double DESIRED_DZ = 0.5;
-      double DESIRED_DY = FastMath.sqrt(1 - DESIRED_DX*DESIRED_DX - DESIRED_DZ*DESIRED_DZ);
+      double sun_az = scene.sun().getAzimuth();
+      double sun_alt = scene.sun().getAltitude();
+      double desired_dx = FastMath.cos(sun_az)*FastMath.cos(sun_alt);
+      double desired_dz = FastMath.sin(sun_az)*FastMath.cos(sun_alt);
+      double desired_dy = FastMath.sin(sun_alt);
       double desired_tx, desired_ty, desired_tz;
-      desired_tz = DESIRED_DX*n.x + DESIRED_DY*n.y + DESIRED_DZ*n.z;
-      if(QuickMath.abs(n.x) > .1) {
-        desired_tx = DESIRED_DX*n.z - DESIRED_DZ*n.x;
-        desired_ty = DESIRED_DX*n.x*n.y - DESIRED_DY*(n.x*n.x + n.z*n.z) + DESIRED_DZ*n.y*n.z;
-        double sqrtxz = FastMath.sqrt(n.x*n.x+n.z*n.z);
-        desired_tx /= sqrtxz;
-        desired_ty /= sqrtxz;
-      } else {
-        desired_tx = DESIRED_DZ*n.y - DESIRED_DY*n.z;
-        desired_ty = DESIRED_DY*n.x*n.y - DESIRED_DX*(n.y*n.y + n.z*n.z) + DESIRED_DZ*n.x*n.z;
-        double sqrtyz = FastMath.sqrt(n.y*n.y+n.z*n.z);
-        desired_tx /= sqrtyz;
-        desired_ty /= sqrtyz;
-      }
+      desired_tz = desired_dx*n.x + desired_dy*n.y + desired_dz*n.z;
       if(desired_tz > 0) {
-        tx = desired_tx;
-        ty = desired_ty;
-        tz = desired_tz;
+        if(QuickMath.abs(n.x) > .1) {
+          desired_tx = desired_dx * n.z - desired_dz * n.x;
+          desired_ty = desired_dx * n.x * n.y - desired_dy * (n.x * n.x + n.z * n.z) + desired_dz * n.y * n.z;
+          double sqrtxz = FastMath.hypot(n.x, n.z);
+          desired_tx /= sqrtxz;
+          desired_ty /= sqrtxz;
+        } else {
+          desired_tx = desired_dz * n.y - desired_dy * n.z;
+          desired_ty = desired_dy * n.x * n.y - desired_dx * (n.y * n.y + n.z * n.z) + desired_dz * n.x * n.z;
+          double sqrtzy = FastMath.hypot(n.z, n.y);
+          desired_tx /= sqrtzy;
+          desired_ty /= sqrtzy;
+        }
+        double circle_radius = FastMath.min(DEFAULT_CIRCLE_RADIUS, 1 - FastMath.hypot(desired_tx, desired_ty) - Ray.EPSILON);
+        double sample_chance = SUN_SAMPLE_CHANCE * circle_radius * circle_radius / (DEFAULT_CIRCLE_RADIUS * DEFAULT_CIRCLE_RADIUS);
+        if(circle_radius >= MIN_CIRCLE_RADIUS) {
+          if(random.nextDouble() < sample_chance) {
+            tx = desired_tx + tx * circle_radius;
+            ty = desired_ty + ty * circle_radius;
+            ray.color.scale(circle_radius * circle_radius / sample_chance);
+          } else {
+            while(FastMath.hypot(tx - desired_tx, ty - desired_ty) < circle_radius) {
+              tx -= desired_tx;
+              ty -= desired_ty;
+              // Avoid very unlikely infinite loop
+              if(tx == 0 && ty == 0) {
+                break;
+              }
+              tx /= circle_radius;
+              ty /= circle_radius;
+            }
+            ray.color.scale((1 - circle_radius * circle_radius) / (1 - sample_chance));
+          }
+        }
       }
     }
 
+    double tz = FastMath.sqrt(1 - tx*tx - ty*ty);
+
     // transform from tangent space to world space
     double xx, xy, xz;
     double ux, uy, uz;

From 7b69564cf7419f3005a89717793bd4ed133126ff Mon Sep 17 00:00:00 2001
From: Justin Barker <justintimecuber@gmail.com>
Date: Mon, 17 Jul 2023 11:07:58 -0500
Subject: [PATCH 06/38] add to sun sampling strategy enum (and GUI dropdown)

---
 .../chunky/renderer/SunSamplingStrategy.java      | 15 ++++++++++-----
 chunky/src/java/se/llbit/math/Ray.java            |  5 ++---
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/SunSamplingStrategy.java b/chunky/src/java/se/llbit/chunky/renderer/SunSamplingStrategy.java
index 48773593df..6e280a1bc1 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/SunSamplingStrategy.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/SunSamplingStrategy.java
@@ -19,10 +19,11 @@
 import se.llbit.util.Registerable;
 
 public enum SunSamplingStrategy implements Registerable {
-    OFF("Off", "Sun is not sampled with next event estimation.", false, true, false, true),
-    NON_LUMINOUS("Non-Luminous", "Sun is drawn on the skybox but it does not contribute to the lighting of the scene.", false, false, false, false),
-    FAST("Fast", "Fast sun sampling algorithm. Lower noise but does not correctly model some visual effects.", true, false, false, false),
-    HIGH_QUALITY("High Quality", "High quality sun sampling. More noise but correctly models visual effects such as caustics.", true, true, true, true);
+    OFF("Off", "Sun is not sampled with next event estimation.", false, true, false, true, false),
+    NON_LUMINOUS("Non-Luminous", "Sun is drawn on the skybox but it does not contribute to the lighting of the scene.", false, false, false, false, false),
+    FAST("Fast", "Fast sun sampling algorithm. Lower noise but does not correctly model some visual effects.", true, false, false, false, false),
+    HIGH_QUALITY("High Quality", "High quality sun sampling. More noise but correctly models visual effects such as caustics.", true, true, true, true, false),
+    DIFFUSE("Diffuse", "Sun is sampled on a certain percentage of diffuse reflections. Correctly models visual effects while reducing noise for direct and diffuse illumination.", false, true, false, true, true);
 
     private final String displayName;
     private final String description;
@@ -31,8 +32,9 @@ public enum SunSamplingStrategy implements Registerable {
     private final boolean diffuseSun;
     private final boolean strictDirectLight;
     private final boolean sunLuminosity;
+    private final boolean diffuseSampling;
 
-    SunSamplingStrategy(String displayName, String description, boolean sunSampling, boolean diffuseSun, boolean strictDirectLight, boolean sunLuminosity) {
+    SunSamplingStrategy(String displayName, String description, boolean sunSampling, boolean diffuseSun, boolean strictDirectLight, boolean sunLuminosity, boolean diffuseSampling) {
         this.displayName = displayName;
         this.description = description;
 
@@ -40,6 +42,7 @@ public enum SunSamplingStrategy implements Registerable {
         this.diffuseSun = diffuseSun;
         this.strictDirectLight = strictDirectLight;
         this.sunLuminosity = sunLuminosity;
+        this.diffuseSampling = diffuseSampling;
     }
 
     @Override
@@ -72,4 +75,6 @@ public boolean isStrictDirectLight() {
     public boolean isSunLuminosity() {
         return sunLuminosity;
     }
+
+    public boolean isDiffuseSampling() { return diffuseSampling; }
 }
diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 03be5c2ff2..ea0c89717c 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -271,10 +271,9 @@ public float[] getBiomeWaterColor(Scene scene) {
   public final void diffuseReflection(Ray ray, Random random, Scene scene) {
 
     //TODO: Make these configurable
-    boolean SUN_SAMPLING_TEST = true;
     double DEFAULT_CIRCLE_RADIUS = scene.sun().getSunRadius() * 1.2;
     double MIN_CIRCLE_RADIUS = DEFAULT_CIRCLE_RADIUS / 10;
-    double SUN_SAMPLE_CHANCE = 0.25;
+    double SUN_SAMPLE_CHANCE = 0.1;
 
     set(ray);
 
@@ -288,7 +287,7 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
     double tx = r * FastMath.cos(theta);
     double ty = r * FastMath.sin(theta);
 
-    if(SUN_SAMPLING_TEST) {
+    if(scene.getSunSamplingStrategy().isDiffuseSampling()) {
       double sun_az = scene.sun().getAzimuth();
       double sun_alt = scene.sun().getAltitude();
       double desired_dx = FastMath.cos(sun_az)*FastMath.cos(sun_alt);

From f64b971ffb9c27efbae33b134be69603b184055f Mon Sep 17 00:00:00 2001
From: Justin Barker <justintimecuber@gmail.com>
Date: Mon, 17 Jul 2023 14:55:59 -0500
Subject: [PATCH 07/38] Add more GUI controls

---
 .../se/llbit/chunky/renderer/scene/Sun.java   | 53 +++++++++++++++++++
 .../chunky/ui/render/tabs/LightingTab.java    | 31 ++++++++++-
 chunky/src/java/se/llbit/math/Ray.java        |  5 +-
 .../chunky/ui/render/tabs/LightingTab.fxml    | 10 ++++
 4 files changed, 95 insertions(+), 4 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
index a368620aa4..153ea0b84f 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
@@ -61,6 +61,36 @@ public class Sun implements JsonSerializable {
    */
   public static final double MAX_APPARENT_BRIGHTNESS = 50;
 
+  /**
+   * Default probability for diffuse sun sampling
+   */
+  public static final double DEFAULT_DIFFUSE_SAMPLE_CHANCE = 0.1;
+
+  /**
+   * Minimum probability for diffuse sun sampling
+   */
+  public static final double MIN_DIFFUSE_SAMPLE_CHANCE = 0.001;
+
+  /**
+   * Maximum probability for diffuse sun sampling
+   */
+  public static final double MAX_DIFFUSE_SAMPLE_CHANCE = 0.9;
+
+  /**
+   * Default radius (relative to sun) for diffuse sun sampling
+   */
+  public static final double DEFAULT_DIFFUSE_SAMPLE_RADIUS = 1.2;
+
+  /**
+   * Minimum radius (relative to sun) for diffuse sun sampling
+   */
+  public static final double MIN_DIFFUSE_SAMPLE_RADIUS = 0.1;
+
+  /**
+   * Maximum radius (relative to sun) for diffuse sun sampling
+   */
+  public static final double MAX_DIFFUSE_SAMPLE_RADIUS = 5;
+
   private static final double xZenithChroma[][] =
       {{0.00166, -0.00375, 0.00209, 0}, {-0.02903, 0.06377, -0.03203, 0.00394},
           {0.11693, -0.21196, 0.06052, 0.25886},};
@@ -137,6 +167,9 @@ public class Sun implements JsonSerializable {
   private Vector3 apparentTextureBrightness = new Vector3(1, 1, 1);
   private boolean enableTextureModification = false;
 
+  private double diffuseSampleChance = DEFAULT_DIFFUSE_SAMPLE_CHANCE;
+  private double diffuseSampleRadius = DEFAULT_DIFFUSE_SAMPLE_RADIUS;
+
   private double azimuth = Math.PI / 2.5;
   private double altitude = Math.PI / 3;
 
@@ -202,6 +235,8 @@ public void set(Sun other) {
     radius = other.radius;
     enableTextureModification = other.enableTextureModification;
     luminosityPdf = other.luminosityPdf;
+    diffuseSampleRadius = other.diffuseSampleRadius;
+    diffuseSampleChance = other.diffuseSampleChance;
     initSun();
   }
 
@@ -475,6 +510,10 @@ public void getRandomSunDirection(Ray reflected, Random random) {
     apparentColorObj.add("green", apparentColor.y);
     apparentColorObj.add("blue", apparentColor.z);
     sun.add("apparentColor", apparentColorObj);
+    JsonObject diffuseSamplingObj = new JsonObject();
+    diffuseSamplingObj.add("chance", diffuseSampleChance);
+    diffuseSamplingObj.add("radius", diffuseSampleRadius);
+    sun.add("diffuseSampling", diffuseSamplingObj);
     sun.add("drawTexture", drawTexture);
     return sun;
   }
@@ -502,6 +541,12 @@ public void importFromJson(JsonObject json) {
       apparentColor.z = apparentColorObj.get("blue").doubleValue(1);
     }
 
+    if(json.get("diffuseSampling").isObject()) {
+      JsonObject diffuseSamplingObj = json.get("diffuseSampling").object();
+      diffuseSampleChance = diffuseSamplingObj.get("chance").doubleValue(DEFAULT_DIFFUSE_SAMPLE_CHANCE);
+      diffuseSampleRadius = diffuseSamplingObj.get("radius").doubleValue(DEFAULT_DIFFUSE_SAMPLE_RADIUS);
+    }
+
     drawTexture = json.get("drawTexture").boolValue(drawTexture);
 
     initSun();
@@ -528,4 +573,12 @@ public void setDrawTexture(boolean value) {
   public boolean drawTexture() {
     return drawTexture;
   }
+
+  public double getDiffuseSampleChance() { return diffuseSampleChance; }
+
+  public void setDiffuseSampleChance(double d) { diffuseSampleChance = d; }
+
+  public double getDiffuseSampleRadius() { return diffuseSampleRadius; }
+
+  public void setDiffuseSampleRadius(double d) { diffuseSampleRadius = d; }
 }
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/LightingTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/LightingTab.java
index bedf302107..fad34d5742 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/LightingTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/LightingTab.java
@@ -55,6 +55,9 @@ public class LightingTab extends ScrollPane implements RenderControlsTab, Initia
   @FXML private DoubleAdjuster sunIntensity;
   @FXML private CheckBox drawSun;
   @FXML private ComboBox<SunSamplingStrategy> sunSamplingStrategy;
+  @FXML private TitledPane diffuseSamplingDetailsPane;
+  @FXML private DoubleAdjuster diffuseSampleChance;
+  @FXML private DoubleAdjuster diffuseSampleRadius;
   @FXML private DoubleAdjuster sunLuminosity;
   @FXML private DoubleAdjuster apparentSunBrightness;
   @FXML private DoubleAdjuster sunRadius;
@@ -134,9 +137,33 @@ public LightingTab() throws IOException {
 
     sunSamplingStrategy.getItems().addAll(SunSamplingStrategy.values());
     sunSamplingStrategy.getSelectionModel().selectedItemProperty().addListener(
-            (observable, oldValue, newValue) -> scene.setSunSamplingStrategy(newValue));
+            (observable, oldValue, newValue) -> {
+              scene.setSunSamplingStrategy(newValue);
+
+              boolean visible = scene != null && scene.getSunSamplingStrategy().isDiffuseSampling();
+              diffuseSamplingDetailsPane.setVisible(visible);
+              diffuseSamplingDetailsPane.setExpanded(visible);
+              diffuseSamplingDetailsPane.setManaged(visible);
+            });
     sunSamplingStrategy.setTooltip(new Tooltip("Determines how the sun is sampled at each bounce."));
 
+    boolean visible = scene != null && scene.getSunSamplingStrategy().isDiffuseSampling();
+    diffuseSamplingDetailsPane.setVisible(visible);
+    diffuseSamplingDetailsPane.setExpanded(visible);
+    diffuseSamplingDetailsPane.setManaged(visible);
+
+    diffuseSampleChance.setName("Diffuse sample chance");
+    diffuseSampleChance.setTooltip("Probability of sampling the sun on each diffuse bounce");
+    diffuseSampleChance.setRange(Sun.MIN_DIFFUSE_SAMPLE_CHANCE, Sun.MAX_DIFFUSE_SAMPLE_CHANCE);
+    diffuseSampleChance.clampBoth();
+    diffuseSampleChance.onValueChange(value -> scene.sun().setDiffuseSampleChance(value));
+
+    diffuseSampleRadius.setName("Diffuse sample radius");
+    diffuseSampleRadius.setTooltip("Radius of possible sun sampling bounces (relative to the sun's radius)");
+    diffuseSampleRadius.setRange(Sun.MIN_DIFFUSE_SAMPLE_RADIUS, Sun.MAX_DIFFUSE_SAMPLE_RADIUS);
+    diffuseSampleRadius.clampMin();
+    diffuseSampleRadius.onValueChange(value -> scene.sun().setDiffuseSampleRadius(value));
+
     sunIntensity.setName("Sunlight intensity");
     sunIntensity.setTooltip("Changes the intensity of sunlight. Only used when Sun Sampling Strategy is set to FAST or HIGH_QUALITY.");
     sunIntensity.setRange(Sun.MIN_INTENSITY, Sun.MAX_INTENSITY);
@@ -203,6 +230,8 @@ public void setController(RenderControlsFxController controller) {
     sunAltitude.set(QuickMath.radToDeg(scene.sun().getAltitude()));
     enableEmitters.setSelected(scene.getEmittersEnabled());
     sunSamplingStrategy.getSelectionModel().select(scene.getSunSamplingStrategy());
+    diffuseSampleChance.set(scene.sun().getDiffuseSampleChance());
+    diffuseSampleRadius.set(scene.sun().getDiffuseSampleRadius());
     drawSun.setSelected(scene.sun().drawTexture());
     sunColor.colorProperty().removeListener(sunColorListener);
     sunColor.setColor(ColorUtil.toFx(scene.sun().getColor()));
diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index ea0c89717c..de0228b6d4 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -270,10 +270,9 @@ public float[] getBiomeWaterColor(Scene scene) {
    */
   public final void diffuseReflection(Ray ray, Random random, Scene scene) {
 
-    //TODO: Make these configurable
-    double DEFAULT_CIRCLE_RADIUS = scene.sun().getSunRadius() * 1.2;
+    double DEFAULT_CIRCLE_RADIUS = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
     double MIN_CIRCLE_RADIUS = DEFAULT_CIRCLE_RADIUS / 10;
-    double SUN_SAMPLE_CHANCE = 0.1;
+    double SUN_SAMPLE_CHANCE = scene.sun().getDiffuseSampleChance();
 
     set(ray);
 
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/LightingTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/LightingTab.fxml
index 63708d2812..9487e5c5a3 100644
--- a/chunky/src/res/se/llbit/chunky/ui/render/tabs/LightingTab.fxml
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/LightingTab.fxml
@@ -12,6 +12,7 @@
 <?import se.llbit.fx.LuxColorPicker?>
 <?import javafx.scene.control.ChoiceBox?>
 <?import javafx.scene.control.ComboBox?>
+<?import javafx.scene.control.TitledPane?>
 
 <fx:root type="javafx.scene.control.ScrollPane" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1">
   <VBox spacing="10.0">
@@ -31,6 +32,15 @@
       <Label text="Sun Sampling Strategy:" />
       <ComboBox fx:id="sunSamplingStrategy" />
     </HBox>
+    <TitledPane fx:id="diffuseSamplingDetailsPane" animated="false" text="Diffuse sampling details">
+      <VBox spacing="10.0">
+        <padding>
+          <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
+        </padding>
+        <DoubleAdjuster fx:id="diffuseSampleChance" />
+        <DoubleAdjuster fx:id="diffuseSampleRadius" />
+      </VBox>
+    </TitledPane>
     <DoubleAdjuster fx:id="sunIntensity" maxWidth="1.7976931348623157E308" />
     <DoubleAdjuster fx:id="sunLuminosity" maxWidth="Infinity" />
     <DoubleAdjuster fx:id="apparentSunBrightness" maxWidth="Infinity" />

From c22644a3b4aedbdb10783900073d08f2c1fe3791 Mon Sep 17 00:00:00 2001
From: Justin Barker <justintimecuber@gmail.com>
Date: Mon, 17 Jul 2023 15:24:57 -0500
Subject: [PATCH 08/38] small code changes and added comments

---
 chunky/src/java/se/llbit/math/Ray.java | 71 ++++++++++++++++----------
 1 file changed, 43 insertions(+), 28 deletions(-)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index de0228b6d4..c26c4c83b1 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -270,10 +270,6 @@ public float[] getBiomeWaterColor(Scene scene) {
    */
   public final void diffuseReflection(Ray ray, Random random, Scene scene) {
 
-    double DEFAULT_CIRCLE_RADIUS = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
-    double MIN_CIRCLE_RADIUS = DEFAULT_CIRCLE_RADIUS / 10;
-    double SUN_SAMPLE_CHANCE = scene.sun().getDiffuseSampleChance();
-
     set(ray);
 
     // get random point on unit disk
@@ -285,54 +281,73 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
     // project to point on hemisphere in tangent space
     double tx = r * FastMath.cos(theta);
     double ty = r * FastMath.sin(theta);
+    double tz; // to be initialized later, after potentially changing tx and ty
 
+    // diffuse sun sampling (importance sampling)
     if(scene.getSunSamplingStrategy().isDiffuseSampling()) {
-      double sun_az = scene.sun().getAzimuth();
-      double sun_alt = scene.sun().getAltitude();
-      double desired_dx = FastMath.cos(sun_az)*FastMath.cos(sun_alt);
-      double desired_dz = FastMath.sin(sun_az)*FastMath.cos(sun_alt);
-      double desired_dy = FastMath.sin(sun_alt);
-      double desired_tx, desired_ty, desired_tz;
-      desired_tz = desired_dx*n.x + desired_dy*n.y + desired_dz*n.z;
-      if(desired_tz > 0) {
+
+      // constants
+      final double DEFAULT_CIRCLE_RADIUS = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
+      final double MIN_CIRCLE_RADIUS = DEFAULT_CIRCLE_RADIUS / 10;
+      final double SUN_SAMPLE_CHANCE = scene.sun().getDiffuseSampleChance();
+
+      final double sun_az = scene.sun().getAzimuth();
+      final double sun_alt = scene.sun().getAltitude();
+      final double sun_dx = FastMath.cos(sun_az)*FastMath.cos(sun_alt);
+      final double sun_dz = FastMath.sin(sun_az)*FastMath.cos(sun_alt);
+      final double sun_dy = FastMath.sin(sun_alt);
+
+      // determine the sun direction in tangent space
+      // since we know the sun's direction in world space easily, we must reverse the algebra done later in this method
+      // (I calculated the inverse matrix by hand and it was not fun)
+      double sun_tx, sun_ty, sun_tz;
+      sun_tz = sun_dx*n.x + sun_dy*n.y + sun_dz*n.z;
+      if(sun_tz > 0) { // if sun_tz is negative, that means that the sun is behind the current surface, so skip sampling
         if(QuickMath.abs(n.x) > .1) {
-          desired_tx = desired_dx * n.z - desired_dz * n.x;
-          desired_ty = desired_dx * n.x * n.y - desired_dy * (n.x * n.x + n.z * n.z) + desired_dz * n.y * n.z;
+          sun_tx = sun_dx * n.z - sun_dz * n.x;
+          sun_ty = sun_dx * n.x * n.y - sun_dy * (n.x * n.x + n.z * n.z) + sun_dz * n.y * n.z;
           double sqrtxz = FastMath.hypot(n.x, n.z);
-          desired_tx /= sqrtxz;
-          desired_ty /= sqrtxz;
+          sun_tx /= sqrtxz;
+          sun_ty /= sqrtxz;
         } else {
-          desired_tx = desired_dz * n.y - desired_dy * n.z;
-          desired_ty = desired_dy * n.x * n.y - desired_dx * (n.y * n.y + n.z * n.z) + desired_dz * n.x * n.z;
+          sun_tx = sun_dz * n.y - sun_dy * n.z;
+          sun_ty = sun_dy * n.x * n.y - sun_dx * (n.y * n.y + n.z * n.z) + sun_dz * n.x * n.z;
           double sqrtzy = FastMath.hypot(n.z, n.y);
-          desired_tx /= sqrtzy;
-          desired_ty /= sqrtzy;
+          sun_tx /= sqrtzy;
+          sun_ty /= sqrtzy;
         }
-        double circle_radius = FastMath.min(DEFAULT_CIRCLE_RADIUS, 1 - FastMath.hypot(desired_tx, desired_ty) - Ray.EPSILON);
+        // radius of the circle being sampled, but must not go outside the unit circle
+        double circle_radius = FastMath.min(DEFAULT_CIRCLE_RADIUS, 1 - FastMath.hypot(sun_tx, sun_ty) - Ray.EPSILON);
+        // if the circle radius is reduced, also reduce the sample chance
         double sample_chance = SUN_SAMPLE_CHANCE * circle_radius * circle_radius / (DEFAULT_CIRCLE_RADIUS * DEFAULT_CIRCLE_RADIUS);
         if(circle_radius >= MIN_CIRCLE_RADIUS) {
           if(random.nextDouble() < sample_chance) {
-            tx = desired_tx + tx * circle_radius;
-            ty = desired_ty + ty * circle_radius;
+            // sun sampling
+            tx = sun_tx + tx * circle_radius;
+            ty = sun_ty + ty * circle_radius;
+            // diminish the contribution of the ray based on the circle area and the sample chance
             ray.color.scale(circle_radius * circle_radius / sample_chance);
           } else {
-            while(FastMath.hypot(tx - desired_tx, ty - desired_ty) < circle_radius) {
-              tx -= desired_tx;
-              ty -= desired_ty;
-              // Avoid very unlikely infinite loop
+            // non-sun sampling
+            // now, rather than guaranteeing that the ray is cast within a circle, instead guarantee that it does not
+            while(FastMath.hypot(tx - sun_tx, ty - sun_ty) < circle_radius) {
+              tx -= sun_tx;
+              ty -= sun_ty;
+              // avoid very unlikely infinite loop
               if(tx == 0 && ty == 0) {
                 break;
               }
               tx /= circle_radius;
               ty /= circle_radius;
             }
+            // correct for the fact that we are now undersampling everything but the sun
             ray.color.scale((1 - circle_radius * circle_radius) / (1 - sample_chance));
           }
         }
       }
     }
 
-    double tz = FastMath.sqrt(1 - tx*tx - ty*ty);
+    tz = FastMath.sqrt(1 - tx*tx - ty*ty);
 
     // transform from tangent space to world space
     double xx, xy, xz;

From 51cc441cb9ce76a7f057c4e19f15f7c0e7ecd32b Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Wed, 19 Jul 2023 13:03:07 -0500
Subject: [PATCH 09/38] New method for situations when the sun is at a shallow
 angle

---
 .../se/llbit/chunky/renderer/scene/Sun.java   | 10 ++-
 chunky/src/java/se/llbit/math/Ray.java        | 80 ++++++++++++-------
 2 files changed, 60 insertions(+), 30 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
index 153ea0b84f..c969757aca 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
@@ -576,9 +576,15 @@ public boolean drawTexture() {
 
   public double getDiffuseSampleChance() { return diffuseSampleChance; }
 
-  public void setDiffuseSampleChance(double d) { diffuseSampleChance = d; }
+  public void setDiffuseSampleChance(double d) {
+    diffuseSampleChance = d;
+    scene.refresh();
+  }
 
   public double getDiffuseSampleRadius() { return diffuseSampleRadius; }
 
-  public void setDiffuseSampleRadius(double d) { diffuseSampleRadius = d; }
+  public void setDiffuseSampleRadius(double d) {
+    diffuseSampleRadius = d;
+    scene.refresh();
+  }
 }
diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index c26c4c83b1..896aa8dcdf 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -21,6 +21,7 @@
 import se.llbit.chunky.block.Lava;
 import se.llbit.chunky.block.Water;
 import se.llbit.chunky.renderer.scene.Scene;
+import se.llbit.chunky.renderer.scene.Sun;
 import se.llbit.chunky.world.BlockData;
 import se.llbit.chunky.world.Material;
 
@@ -287,10 +288,6 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
     if(scene.getSunSamplingStrategy().isDiffuseSampling()) {
 
       // constants
-      final double DEFAULT_CIRCLE_RADIUS = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
-      final double MIN_CIRCLE_RADIUS = DEFAULT_CIRCLE_RADIUS / 10;
-      final double SUN_SAMPLE_CHANCE = scene.sun().getDiffuseSampleChance();
-
       final double sun_az = scene.sun().getAzimuth();
       final double sun_alt = scene.sun().getAltitude();
       final double sun_dx = FastMath.cos(sun_az)*FastMath.cos(sun_alt);
@@ -300,28 +297,25 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
       // determine the sun direction in tangent space
       // since we know the sun's direction in world space easily, we must reverse the algebra done later in this method
       // (I calculated the inverse matrix by hand and it was not fun)
-      double sun_tx, sun_ty, sun_tz;
-      sun_tz = sun_dx*n.x + sun_dy*n.y + sun_dz*n.z;
-      if(sun_tz > 0) { // if sun_tz is negative, that means that the sun is behind the current surface, so skip sampling
-        if(QuickMath.abs(n.x) > .1) {
-          sun_tx = sun_dx * n.z - sun_dz * n.x;
-          sun_ty = sun_dx * n.x * n.y - sun_dy * (n.x * n.x + n.z * n.z) + sun_dz * n.y * n.z;
-          double sqrtxz = FastMath.hypot(n.x, n.z);
-          sun_tx /= sqrtxz;
-          sun_ty /= sqrtxz;
-        } else {
-          sun_tx = sun_dz * n.y - sun_dy * n.z;
-          sun_ty = sun_dy * n.x * n.y - sun_dx * (n.y * n.y + n.z * n.z) + sun_dz * n.x * n.z;
-          double sqrtzy = FastMath.hypot(n.z, n.y);
-          sun_tx /= sqrtzy;
-          sun_ty /= sqrtzy;
-        }
-        // radius of the circle being sampled, but must not go outside the unit circle
-        double circle_radius = FastMath.min(DEFAULT_CIRCLE_RADIUS, 1 - FastMath.hypot(sun_tx, sun_ty) - Ray.EPSILON);
-        // if the circle radius is reduced, also reduce the sample chance
-        double sample_chance = SUN_SAMPLE_CHANCE * circle_radius * circle_radius / (DEFAULT_CIRCLE_RADIUS * DEFAULT_CIRCLE_RADIUS);
-        if(circle_radius >= MIN_CIRCLE_RADIUS) {
-          if(random.nextDouble() < sample_chance) {
+      double sun_tx, sun_ty, sqrt;
+      if(QuickMath.abs(n.x) > .1) {
+        sun_tx = sun_dx * n.z - sun_dz * n.x;
+        sun_ty = sun_dx * n.x * n.y - sun_dy * (n.x * n.x + n.z * n.z) + sun_dz * n.y * n.z;
+        sqrt = FastMath.hypot(n.x, n.z);
+      } else {
+        sun_tx = sun_dz * n.y - sun_dy * n.z;
+        sun_ty = sun_dy * n.x * n.y - sun_dx * (n.y * n.y + n.z * n.z) + sun_dz * n.x * n.z;
+        sqrt = FastMath.hypot(n.z, n.y);
+      }
+      sun_tx /= sqrt;
+      sun_ty /= sqrt;
+      double circle_radius = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
+      double sample_chance = scene.sun().getDiffuseSampleChance();
+      // check if there is any chance of the sun being visible
+      if(FastMath.hypot(sun_tx, sun_ty) - circle_radius < 1) {
+        // if the sun is not at too shallow of an angle, then sample a circular region
+        if(FastMath.hypot(sun_tx, sun_ty) + circle_radius + Ray.EPSILON < 1) {
+          if (random.nextDouble() < sample_chance) {
             // sun sampling
             tx = sun_tx + tx * circle_radius;
             ty = sun_ty + ty * circle_radius;
@@ -330,11 +324,11 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
           } else {
             // non-sun sampling
             // now, rather than guaranteeing that the ray is cast within a circle, instead guarantee that it does not
-            while(FastMath.hypot(tx - sun_tx, ty - sun_ty) < circle_radius) {
+            while (FastMath.hypot(tx - sun_tx, ty - sun_ty) < circle_radius) {
               tx -= sun_tx;
               ty -= sun_ty;
               // avoid very unlikely infinite loop
-              if(tx == 0 && ty == 0) {
+              if (tx == 0 && ty == 0) {
                 break;
               }
               tx /= circle_radius;
@@ -343,6 +337,36 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
             // correct for the fact that we are now undersampling everything but the sun
             ray.color.scale((1 - circle_radius * circle_radius) / (1 - sample_chance));
           }
+        } else {
+          // the sun is at a shallow angle, so instead we're using a "rectangular-ish segment"
+          // it is important that we sample from a shape which we can easily calculate the area of
+          double minr = FastMath.hypot(sun_tx, sun_ty) - circle_radius;
+          double sun_theta = FastMath.atan2(sun_ty, sun_tx);
+          double segment_area_proportion = ((1 - minr * minr) * circle_radius) / Math.PI;
+          sample_chance *= segment_area_proportion / (circle_radius * circle_radius);
+          sample_chance = FastMath.min(sample_chance, Sun.MAX_DIFFUSE_SAMPLE_CHANCE);
+          if(random.nextDouble() < sample_chance) {
+            // sun sampling
+            r = FastMath.sqrt(1 - (1 - minr * minr) * x1);
+            theta = sun_theta + (2 * x2 - 1) * circle_radius;
+            tx = r * FastMath.cos(theta);
+            ty = r * FastMath.sin(theta);
+            // diminish the contribution of the ray based on the segment area and the sample chance
+            ray.color.scale(segment_area_proportion / sample_chance);
+          } else {
+            // non-sun sampling
+            // basically, if we are going to sample the sun segment, reset the rng until we don't
+            while(r > minr || FastMath.abs(theta - sun_theta) < circle_radius) {
+              x1 = random.nextDouble();
+              x2 = random.nextDouble();
+              r = FastMath.sqrt(x1);
+              theta = 2 * Math.PI * x2;
+            }
+            tx = r * FastMath.cos(theta);
+            ty = r * FastMath.sin(theta);
+            // correct for the fact that we are now undersampling everything but the sun
+            ray.color.scale((1 - segment_area_proportion) / (1 - sample_chance));
+          }
         }
       }
     }

From 1ac7640ae30d1d735efb361a7d89d6b9d2fd2dee Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Wed, 19 Jul 2023 13:44:39 -0500
Subject: [PATCH 10/38] make the rectangle method more accurately predict where
 the top and bottom of the sun will be

---
 chunky/src/java/se/llbit/math/Ray.java | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 896aa8dcdf..79827f6f0c 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -298,6 +298,7 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
       // since we know the sun's direction in world space easily, we must reverse the algebra done later in this method
       // (I calculated the inverse matrix by hand and it was not fun)
       double sun_tx, sun_ty, sqrt;
+      double sun_tz = sun_dx*n.x + sun_dy*n.y + sun_dz*n.z;
       if(QuickMath.abs(n.x) > .1) {
         sun_tx = sun_dx * n.z - sun_dz * n.x;
         sun_ty = sun_dx * n.x * n.y - sun_dy * (n.x * n.x + n.z * n.z) + sun_dz * n.y * n.z;
@@ -340,14 +341,16 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
         } else {
           // the sun is at a shallow angle, so instead we're using a "rectangular-ish segment"
           // it is important that we sample from a shape which we can easily calculate the area of
-          double minr = FastMath.hypot(sun_tx, sun_ty) - circle_radius;
+          double sun_alt_relative = FastMath.asin(sun_tz);
+          double minr = FastMath.cos(sun_alt_relative + circle_radius);
+          double maxr = FastMath.cos(FastMath.max(sun_alt_relative - circle_radius, 0));
           double sun_theta = FastMath.atan2(sun_ty, sun_tx);
-          double segment_area_proportion = ((1 - minr * minr) * circle_radius) / Math.PI;
+          double segment_area_proportion = ((maxr * maxr - minr * minr) * circle_radius) / Math.PI;
           sample_chance *= segment_area_proportion / (circle_radius * circle_radius);
           sample_chance = FastMath.min(sample_chance, Sun.MAX_DIFFUSE_SAMPLE_CHANCE);
           if(random.nextDouble() < sample_chance) {
             // sun sampling
-            r = FastMath.sqrt(1 - (1 - minr * minr) * x1);
+            r = FastMath.sqrt(minr * minr * x1 + maxr * maxr * (1 - x1));
             theta = sun_theta + (2 * x2 - 1) * circle_radius;
             tx = r * FastMath.cos(theta);
             ty = r * FastMath.sin(theta);

From 2fa48708e92838107efada0edd0662c12d03da49 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Wed, 19 Jul 2023 17:00:07 -0500
Subject: [PATCH 11/38] maybe handle certain cases better

---
 chunky/src/java/se/llbit/math/Ray.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 79827f6f0c..0becf9c027 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -312,8 +312,9 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
       sun_ty /= sqrt;
       double circle_radius = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
       double sample_chance = scene.sun().getDiffuseSampleChance();
+      double sun_alt_relative = FastMath.asin(sun_tz);
       // check if there is any chance of the sun being visible
-      if(FastMath.hypot(sun_tx, sun_ty) - circle_radius < 1) {
+      if(sun_alt_relative + circle_radius > Ray.EPSILON) {
         // if the sun is not at too shallow of an angle, then sample a circular region
         if(FastMath.hypot(sun_tx, sun_ty) + circle_radius + Ray.EPSILON < 1) {
           if (random.nextDouble() < sample_chance) {
@@ -341,7 +342,6 @@ public final void diffuseReflection(Ray ray, Random random, Scene scene) {
         } else {
           // the sun is at a shallow angle, so instead we're using a "rectangular-ish segment"
           // it is important that we sample from a shape which we can easily calculate the area of
-          double sun_alt_relative = FastMath.asin(sun_tz);
           double minr = FastMath.cos(sun_alt_relative + circle_radius);
           double maxr = FastMath.cos(FastMath.max(sun_alt_relative - circle_radius, 0));
           double sun_theta = FastMath.atan2(sun_ty, sun_tx);

From bde089eac93da175f6f133f9d1bc9c181d12a4a4 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Mon, 4 Sep 2023 03:59:45 -0400
Subject: [PATCH 12/38] fix ray.color changing between subsequent branches

---
 chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 9949d21dee..1980335242 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -310,6 +310,8 @@ private static boolean doDiffuseReflection(Ray ray, Ray next, Material currentMa
       }
 
     } else {
+      // If diffuse sun sampling is performed, then ray.color will be altered, but it should be the same on each iteration of ray branching
+      Vector4 rayColor = new Vector4(ray.color);
       next.diffuseReflection(ray, random, scene);
 
       hit = pathTrace(scene, next, state, 0, false) || hit;
@@ -323,6 +325,7 @@ private static boolean doDiffuseReflection(Ray ray, Ray next, Material currentMa
         cumulativeColor.y += ray.color.y * indirectEmitterColor.y;
         cumulativeColor.z += ray.color.z * indirectEmitterColor.z;
       }
+      ray.color.set(rayColor);
     }
     return hit;
   }

From d02b7a909bfe3831e0e468971b13b965d4bf8576 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Tue, 26 Sep 2023 19:13:48 -0400
Subject: [PATCH 13/38] unused import

---
 chunky/src/java/se/llbit/math/Ray.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index 5a75e0dc53..e4567939fb 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -22,7 +22,6 @@
 import se.llbit.chunky.block.minecraft.Water;
 import se.llbit.chunky.renderer.scene.Scene;
 import se.llbit.chunky.renderer.scene.Sun;
-import se.llbit.chunky.world.BlockData;
 import se.llbit.chunky.world.Material;
 
 import java.util.Random;

From 905d5dfce0d363e1d8c756bce287adda2ea8962b Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Wed, 27 Sep 2023 02:25:48 -0400
Subject: [PATCH 14/38] initial testing

---
 .../se/llbit/chunky/renderer/scene/Fog.java   | 29 +++++++++++++++++++
 .../chunky/renderer/scene/PathTracer.java     | 10 +++----
 .../renderer/scene/PreviewRayTracer.java      | 13 +++++++--
 .../se/llbit/chunky/renderer/scene/Scene.java |  2 +-
 .../chunky/world/material/FogMaterial.java    | 28 ++++++++++++++++++
 5 files changed, 74 insertions(+), 8 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/world/material/FogMaterial.java

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index 76f16794e3..2a25098930 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -2,9 +2,11 @@
 
 import java.util.ArrayList;
 import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
 
 import se.llbit.chunky.PersistentSettings;
+import se.llbit.chunky.world.material.FogMaterial;
 import se.llbit.json.JsonArray;
 import se.llbit.json.JsonObject;
 import se.llbit.json.JsonValue;
@@ -97,7 +99,33 @@ private static double clampDy(double dy) {
     return dy;
   }
 
+  public boolean intersect(Ray ray) {
+    // Amount of fog the ray should pass through before being scattered
+    // Sampled from an exponential distribution
+    double fogPenetrated = -Math.log(1 - ThreadLocalRandom.current().nextDouble());
+    double scaleHeight = 20;
+    double expHeightDiff = fogPenetrated * ray.d.y / (scaleHeight * uniformDensity);
+    double expYfHs = Math.exp(-(ray.o.y + scene.origin.y) / scaleHeight) - expHeightDiff;
+    if(expYfHs <= 0) {
+      // The ray does not encounter enough fog to be scattered - no intersection.
+      return false;
+    }
+    double yf = -Math.log(expYfHs) * scaleHeight;
+    double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
+    if(dist >= ray.t) {
+      // The ray would have encountered enough fog to be scattered, but something is in the way.
+      return false;
+    }
+    ray.t = dist;
+    ray.setNormal(ray.d);
+    ray.invertNormal();
+    ray.setCurrentMaterial(FogMaterial.INSTANCE);
+    ray.color.set(fogColor.x, fogColor.y, fogColor.z, 1);
+    return true;
+  }
+
   public void addSkyFog(Ray ray, Vector4 scatterLight) {
+    /*
     if (mode == FogMode.UNIFORM) {
       if (uniformDensity > 0.0) {
         double fog;
@@ -118,6 +146,7 @@ public void addSkyFog(Ray ray, Vector4 scatterLight) {
       double y2 = y1 + dy * FOG_LIMIT;
       addLayeredFog(ray.color, dy, y1, y2, scatterLight);
     }
+    */
   }
 
   public void addGroundFog(Ray ray, Vector3 ox, double airDistance, Vector4 scatterLight, double scatterOffset) {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 061ea45c5c..e7712499e3 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -65,7 +65,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
 
     while (true) {
 
-      if (!PreviewRayTracer.nextIntersection(scene, ray)) {
+      if (!PreviewRayTracer.nextIntersection(scene, ray, true)) {
         if (ray.getPrevMaterial().isWater()) {
           ray.color.set(0, 0, 0, 1);
           hit = true;
@@ -170,7 +170,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
         airDistance = ray.distance;
       }
     }
-
+/*
     // This is a simplistic fog model which gives greater artistic freedom but
     // less realism. The user can select fog color and density; in a more
     // realistic model color would depend on viewing angle and sun color/position.
@@ -197,7 +197,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
       getDirectLightAttenuation(scene, atmos, state);
       scene.fog.addGroundFog(ray, ox, airDistance, state.attenuation, offset);
     }
-
+*/
     return hit;
   }
 
@@ -520,7 +520,7 @@ private static void sampleEmitterFace(Scene scene, Ray ray, Grid.EmitterPosition
 
       emitterRay.o.scaleAdd(Ray.OFFSET, emitterRay.d);
       emitterRay.distance += Ray.OFFSET;
-      PreviewRayTracer.nextIntersection(scene, emitterRay);
+      PreviewRayTracer.nextIntersection(scene, emitterRay, true);
       if (Math.abs(emitterRay.distance - distance) < Ray.OFFSET) {
         double e = Math.abs(emitterRay.d.dot(emitterRay.getNormal()));
         e /= Math.max(distance * distance, 1);
@@ -576,7 +576,7 @@ public static void getDirectLightAttenuation(Scene scene, Ray ray, WorkerState s
     attenuation.w = 1;
     while (attenuation.w > 0) {
       ray.o.scaleAdd(Ray.OFFSET, ray.d);
-      if (!PreviewRayTracer.nextIntersection(scene, ray)) {
+      if (!PreviewRayTracer.nextIntersection(scene, ray, true)) {
         break;
       }
       double mult = 1 - ray.color.w;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
index c2446e9c23..ae990e291e 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
@@ -25,6 +25,8 @@
 import se.llbit.math.Vector3;
 import se.llbit.math.Vector4;
 
+import java.util.Random;
+
 /**
  * @author Jesper Öqvist <jesper@llbit.se>
  */
@@ -41,7 +43,7 @@ public class PreviewRayTracer implements RayTracer {
       ray.setCurrentMaterial(Air.INSTANCE);
     }
     while (true) {
-      if (!nextIntersection(scene, ray)) {
+      if (!nextIntersection(scene, ray, false)) {
         if (mapIntersection(scene, ray)) {
           break;
         }
@@ -85,7 +87,7 @@ public static double skyOcclusion(Scene scene, WorkerState state) {
    * Find next ray intersection.
    * @return Next intersection
    */
-  public static boolean nextIntersection(Scene scene, Ray ray) {
+  public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog) {
     ray.setPrevMaterial(ray.getCurrentMaterial(), ray.getCurrentData());
     ray.t = Double.POSITIVE_INFINITY;
     boolean hit = false;
@@ -95,6 +97,9 @@ public static boolean nextIntersection(Scene scene, Ray ray) {
     if (scene.isWaterPlaneEnabled()) {
       hit = waterPlaneIntersection(scene, ray) || hit;
     }
+    if (particleFog) {
+      hit = scene.fog.intersect(ray) || hit;
+    }
     if (scene.intersect(ray)) {
       // Octree tracer handles updating distance.
       return true;
@@ -110,6 +115,10 @@ public static boolean nextIntersection(Scene scene, Ray ray) {
     }
   }
 
+  public static boolean nextIntersection(Scene scene, Ray ray) {
+    return nextIntersection(scene, ray, false);
+  }
+
   private static boolean waterPlaneIntersection(Scene scene, Ray ray) {
     double t = (scene.getEffectiveWaterPlaneHeight() - ray.o.y - scene.origin.y) / ray.d.y;
     if (scene.getWaterPlaneChunkClip()) {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
index 32b6b7340a..207a49a9b9 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
@@ -1682,7 +1682,7 @@ public boolean traceTarget(Ray ray) {
     ray.o.x -= origin.x;
     ray.o.y -= origin.y;
     ray.o.z -= origin.z;
-    while (PreviewRayTracer.nextIntersection(this, ray)) {
+    while (PreviewRayTracer.nextIntersection(this, ray, false)) {
       if (ray.getCurrentMaterial() != Air.INSTANCE) {
         return true;
       }
diff --git a/chunky/src/java/se/llbit/chunky/world/material/FogMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/FogMaterial.java
new file mode 100644
index 0000000000..430aa020b7
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/world/material/FogMaterial.java
@@ -0,0 +1,28 @@
+/* Copyright (c) 2019 Jesper Öqvist <jesper@llbit.se>
+ *
+ * This file is part of Chunky.
+ *
+ * Chunky is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chunky is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with Chunky.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package se.llbit.chunky.world.material;
+
+import se.llbit.chunky.resources.Texture;
+import se.llbit.chunky.world.Material;
+
+public class FogMaterial extends Material {
+  public static final FogMaterial INSTANCE = new FogMaterial();
+
+  private FogMaterial() {
+    super("fog", Texture.air);
+  }
+}

From 62f6c6b57f983688222994c0e972eadff56ee515 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Wed, 27 Sep 2023 19:06:14 -0400
Subject: [PATCH 15/38] add to material list, better normals

---
 .../se/llbit/chunky/renderer/scene/Fog.java   | 27 +++++++++++++++----
 .../se/llbit/chunky/world/ExtraMaterials.java |  3 +++
 ...Material.java => ParticleFogMaterial.java} |  8 +++---
 3 files changed, 29 insertions(+), 9 deletions(-)
 rename chunky/src/java/se/llbit/chunky/world/material/{FogMaterial.java => ParticleFogMaterial.java} (80%)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index 2a25098930..59ed6ebc04 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -5,8 +5,9 @@
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
 
+import org.apache.commons.math3.util.FastMath;
 import se.llbit.chunky.PersistentSettings;
-import se.llbit.chunky.world.material.FogMaterial;
+import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.json.JsonArray;
 import se.llbit.json.JsonObject;
 import se.llbit.json.JsonValue;
@@ -100,9 +101,10 @@ private static double clampDy(double dy) {
   }
 
   public boolean intersect(Ray ray) {
+    Random random = ThreadLocalRandom.current();
     // Amount of fog the ray should pass through before being scattered
     // Sampled from an exponential distribution
-    double fogPenetrated = -Math.log(1 - ThreadLocalRandom.current().nextDouble());
+    double fogPenetrated = -Math.log(1 - random.nextDouble());
     double scaleHeight = 20;
     double expHeightDiff = fogPenetrated * ray.d.y / (scaleHeight * uniformDensity);
     double expYfHs = Math.exp(-(ray.o.y + scene.origin.y) / scaleHeight) - expHeightDiff;
@@ -117,9 +119,24 @@ public boolean intersect(Ray ray) {
       return false;
     }
     ray.t = dist;
-    ray.setNormal(ray.d);
-    ray.invertNormal();
-    ray.setCurrentMaterial(FogMaterial.INSTANCE);
+    // pick a random normal vector based on a spherical particle
+    Vector3 a1 = new Vector3();
+    a1.cross(ray.d, new Vector3(0, 1, 0));
+    a1.normalize();
+    Vector3 a2 = new Vector3();
+    a2.cross(ray.d, a1);
+    // get random point on unit disk
+    double x1 = random.nextDouble();
+    double x2 = random.nextDouble();
+    double r = FastMath.sqrt(x1);
+    double theta = 2 * Math.PI * x2;
+    double t1 = r * FastMath.cos(theta);
+    double t2 = r * FastMath.sin(theta);
+    a1.scale(t1);
+    a1.scaleAdd(t2, a2);
+    a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
+    ray.setNormal(a1);
+    ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
     ray.color.set(fogColor.x, fogColor.y, fogColor.z, 1);
     return true;
   }
diff --git a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
index f34613f649..90331a73f6 100644
--- a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
+++ b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
@@ -20,6 +20,7 @@
 import se.llbit.chunky.entity.CalibratedSculkSensorAmethyst;
 import se.llbit.chunky.entity.Campfire;
 import se.llbit.chunky.world.material.CloudMaterial;
+import se.llbit.chunky.world.material.ParticleFogMaterial;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -31,6 +32,7 @@ public class ExtraMaterials {
 
   static {
     idMap.put("cloud", CloudMaterial.INSTANCE);
+    idMap.put("particle_fog", ParticleFogMaterial.INSTANCE);
     idMap.put("candle_flame", Candle.flameMaterial);
     idMap.put("campfire_flame", Campfire.flameMaterial);
     idMap.put("soul_campfire_flame", Campfire.soulFlameMaterial);
@@ -40,6 +42,7 @@ public class ExtraMaterials {
 
   public static void loadDefaultMaterialProperties() {
     CloudMaterial.INSTANCE.restoreDefaults();
+    ParticleFogMaterial.INSTANCE.restoreDefaults();
 
     Candle.flameMaterial.restoreDefaults();
     Candle.flameMaterial.emittance = 1.0f;
diff --git a/chunky/src/java/se/llbit/chunky/world/material/FogMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
similarity index 80%
rename from chunky/src/java/se/llbit/chunky/world/material/FogMaterial.java
rename to chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
index 430aa020b7..ac57cc3806 100644
--- a/chunky/src/java/se/llbit/chunky/world/material/FogMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
@@ -19,10 +19,10 @@
 import se.llbit.chunky.resources.Texture;
 import se.llbit.chunky.world.Material;
 
-public class FogMaterial extends Material {
-  public static final FogMaterial INSTANCE = new FogMaterial();
+public class ParticleFogMaterial extends Material {
+  public static final ParticleFogMaterial INSTANCE = new ParticleFogMaterial();
 
-  private FogMaterial() {
-    super("fog", Texture.air);
+  private ParticleFogMaterial() {
+    super("particle_fog", Texture.air);
   }
 }

From 4e29353299bea82dfaed08c6dc41516fc824177e Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Fri, 29 Sep 2023 13:47:51 -0400
Subject: [PATCH 16/38] Create abstract FogVolume class & add layer fog type

---
 .../renderer/scene/ExponentialFogVolume.java  | 41 +++++++++++++
 .../se/llbit/chunky/renderer/scene/Fog.java   | 59 ++++++-------------
 .../chunky/renderer/scene/FogVolume.java      | 31 ++++++++++
 .../chunky/renderer/scene/LayerFogVolume.java | 41 +++++++++++++
 .../chunky/renderer/scene/PathTracer.java     |  6 +-
 .../renderer/scene/PreviewRayTracer.java      | 12 ++--
 .../se/llbit/chunky/renderer/scene/Scene.java |  2 +-
 7 files changed, 143 insertions(+), 49 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
new file mode 100644
index 0000000000..7797a6832d
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
@@ -0,0 +1,41 @@
+package se.llbit.chunky.renderer.scene;
+
+import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+
+import java.util.Random;
+
+public class ExponentialFogVolume extends FogVolume {
+  public double scaleHeight;
+  public double scaleOffset;
+  public ExponentialFogVolume(Vector3 color, double density, double scaleHeight, double scaleOffset) {
+    this.color = color;
+    this.density = density;
+    this.scaleHeight = scaleHeight;
+    this.scaleOffset = scaleOffset;
+  }
+  public boolean intersect(Ray ray, Scene scene, Random random) {
+    // Amount of fog the ray should pass through before being scattered
+    // Sampled from an exponential distribution
+    double fogPenetrated = -Math.log(1 - random.nextDouble());
+    double expHeightDiff = fogPenetrated * ray.d.y / (scaleHeight * density);
+    double expYfHs = Math.exp(-(ray.o.y + scene.origin.y - scaleOffset) / scaleHeight) - expHeightDiff;
+    if(expYfHs <= 0) {
+      // The ray does not encounter enough fog to be scattered - no intersection.
+      return false;
+    }
+    double yf = -Math.log(expYfHs) * scaleHeight + scaleOffset;
+    double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
+    if(dist >= ray.t) {
+      // The ray would have encountered enough fog to be scattered, but something is in the way.
+      return false;
+    }
+    ray.t = dist;
+    // pick a random normal vector based on a spherical particle
+    setRandomNormal(ray, random);
+    ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
+    ray.color.set(color.x, color.y, color.z, 1);
+    return true;
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index 59ed6ebc04..a1ea098545 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -24,6 +24,7 @@ public final class Fog implements JsonSerializable {
   protected double uniformDensity = Scene.DEFAULT_FOG_DENSITY;
   protected double skyFogDensity = 1;
   protected ArrayList<FogLayer> layers = new ArrayList<>(0);
+  protected ArrayList<FogVolume> volumes = new ArrayList<>(0);
   protected Vector3 fogColor = new Vector3(PersistentSettings.getFogColorRed(), PersistentSettings.getFogColorGreen(), PersistentSettings.getFogColorBlue());
 
   private static final double EXTINCTION_FACTOR = 0.04;
@@ -32,6 +33,9 @@ public final class Fog implements JsonSerializable {
 
   public Fog(Scene scene) {
     this.scene = scene;
+    //addVolume(new ExponentialFogVolume(new Vector3(1, 0, 0), 0.001, 20, 100));
+    //addVolume(new ExponentialFogVolume(new Vector3(0, 0, 1), 0.0001, -20, 100));
+    addVolume(new LayerFogVolume(new Vector3(0.5, 0.5, 1), 0.004, 20, 200));
   }
 
   public boolean fogEnabled() {
@@ -61,6 +65,9 @@ public boolean fastFog() {
   public ArrayList<FogLayer> getFogLayers() {
     return layers;
   }
+  public ArrayList<FogVolume> getFogVolumes() {
+    return volumes;
+  }
 
   public void addLayer() {
     layers.add(new FogLayer(scene));
@@ -72,6 +79,16 @@ public void removeLayer(int index) {
     scene.refresh();
   }
 
+  public void addVolume(FogVolume v) {
+    volumes.add(v);
+    scene.refresh();
+  }
+
+  public void removeVolume(int index) {
+    volumes.remove(index);
+    scene.refresh();
+  }
+
   public void setY(int index, double value) {
     layers.get(index).setY(value);
     scene.refresh();
@@ -100,47 +117,6 @@ private static double clampDy(double dy) {
     return dy;
   }
 
-  public boolean intersect(Ray ray) {
-    Random random = ThreadLocalRandom.current();
-    // Amount of fog the ray should pass through before being scattered
-    // Sampled from an exponential distribution
-    double fogPenetrated = -Math.log(1 - random.nextDouble());
-    double scaleHeight = 20;
-    double expHeightDiff = fogPenetrated * ray.d.y / (scaleHeight * uniformDensity);
-    double expYfHs = Math.exp(-(ray.o.y + scene.origin.y) / scaleHeight) - expHeightDiff;
-    if(expYfHs <= 0) {
-      // The ray does not encounter enough fog to be scattered - no intersection.
-      return false;
-    }
-    double yf = -Math.log(expYfHs) * scaleHeight;
-    double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
-    if(dist >= ray.t) {
-      // The ray would have encountered enough fog to be scattered, but something is in the way.
-      return false;
-    }
-    ray.t = dist;
-    // pick a random normal vector based on a spherical particle
-    Vector3 a1 = new Vector3();
-    a1.cross(ray.d, new Vector3(0, 1, 0));
-    a1.normalize();
-    Vector3 a2 = new Vector3();
-    a2.cross(ray.d, a1);
-    // get random point on unit disk
-    double x1 = random.nextDouble();
-    double x2 = random.nextDouble();
-    double r = FastMath.sqrt(x1);
-    double theta = 2 * Math.PI * x2;
-    double t1 = r * FastMath.cos(theta);
-    double t2 = r * FastMath.sin(theta);
-    a1.scale(t1);
-    a1.scaleAdd(t2, a2);
-    a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
-    ray.setNormal(a1);
-    ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
-    ray.color.set(fogColor.x, fogColor.y, fogColor.z, 1);
-    return true;
-  }
-
   public void addSkyFog(Ray ray, Vector4 scatterLight) {
     /*
     if (mode == FogMode.UNIFORM) {
@@ -301,6 +277,7 @@ public void set(Fog other) {
     uniformDensity = other.uniformDensity;
     skyFogDensity = other.skyFogDensity;
     layers = new ArrayList<>(other.layers);
+    volumes = new ArrayList<>(other.volumes);
     fogColor.set(other.fogColor);
   }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
new file mode 100644
index 0000000000..b16e926928
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
@@ -0,0 +1,31 @@
+package se.llbit.chunky.renderer.scene;
+
+import org.apache.commons.math3.util.FastMath;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+
+import java.util.Random;
+
+public abstract class FogVolume {
+  public Vector3 color;
+  public double density;
+  public abstract boolean intersect(Ray ray, Scene scene, Random random);
+  public void setRandomNormal(Ray ray, Random random) {
+    Vector3 a1 = new Vector3();
+    a1.cross(ray.d, new Vector3(0, 1, 0));
+    a1.normalize();
+    Vector3 a2 = new Vector3();
+    a2.cross(ray.d, a1);
+    // get random point on unit disk
+    double x1 = random.nextDouble();
+    double x2 = random.nextDouble();
+    double r = FastMath.sqrt(x1);
+    double theta = 2 * Math.PI * x2;
+    double t1 = r * FastMath.cos(theta);
+    double t2 = r * FastMath.sin(theta);
+    a1.scale(t1);
+    a1.scaleAdd(t2, a2);
+    a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
+    ray.setNormal(a1);
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
new file mode 100644
index 0000000000..8b6bfbcde4
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
@@ -0,0 +1,41 @@
+package se.llbit.chunky.renderer.scene;
+
+import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+
+import java.util.Random;
+
+public class LayerFogVolume extends FogVolume {
+  public double layerHeight;
+  public double scaleOffset;
+  public LayerFogVolume(Vector3 color, double density, double layerHeight, double scaleOffset) {
+    this.color = color;
+    this.density = density;
+    this.layerHeight = layerHeight;
+    this.scaleOffset = scaleOffset;
+  }
+  public boolean intersect(Ray ray, Scene scene, Random random) {
+    // Amount of fog the ray should pass through before being scattered
+    // Sampled from an exponential distribution
+    double fogPenetrated = -Math.log(1 - random.nextDouble());
+    double atanHeightDiff = fogPenetrated * ray.d.y / (layerHeight * density);
+    double atanYfHs = Math.atan((ray.o.y + scene.origin.y - scaleOffset) / layerHeight) + atanHeightDiff;
+    if(Math.PI/2 - Math.abs(atanYfHs) <= 0) {
+      // The ray does not encounter enough fog to be scattered - no intersection.
+      return false;
+    }
+    double yf = Math.tan(atanYfHs) * layerHeight + scaleOffset;
+    double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
+    if(dist >= ray.t) {
+      // The ray would have encountered enough fog to be scattered, but something is in the way.
+      return false;
+    }
+    ray.t = dist;
+    // pick a random normal vector based on a spherical particle
+    setRandomNormal(ray, random);
+    ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
+    ray.color.set(color.x, color.y, color.z, 1);
+    return true;
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index e7712499e3..09aa166ab4 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -65,7 +65,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
 
     while (true) {
 
-      if (!PreviewRayTracer.nextIntersection(scene, ray, true)) {
+      if (!PreviewRayTracer.nextIntersection(scene, ray, true, random)) {
         if (ray.getPrevMaterial().isWater()) {
           ray.color.set(0, 0, 0, 1);
           hit = true;
@@ -520,7 +520,7 @@ private static void sampleEmitterFace(Scene scene, Ray ray, Grid.EmitterPosition
 
       emitterRay.o.scaleAdd(Ray.OFFSET, emitterRay.d);
       emitterRay.distance += Ray.OFFSET;
-      PreviewRayTracer.nextIntersection(scene, emitterRay, true);
+      PreviewRayTracer.nextIntersection(scene, emitterRay, true, random);
       if (Math.abs(emitterRay.distance - distance) < Ray.OFFSET) {
         double e = Math.abs(emitterRay.d.dot(emitterRay.getNormal()));
         e /= Math.max(distance * distance, 1);
@@ -576,7 +576,7 @@ public static void getDirectLightAttenuation(Scene scene, Ray ray, WorkerState s
     attenuation.w = 1;
     while (attenuation.w > 0) {
       ray.o.scaleAdd(Ray.OFFSET, ray.d);
-      if (!PreviewRayTracer.nextIntersection(scene, ray, true)) {
+      if (!PreviewRayTracer.nextIntersection(scene, ray, true, state.random)) {
         break;
       }
       double mult = 1 - ray.color.w;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
index ae990e291e..28b1299378 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
@@ -43,7 +43,7 @@ public class PreviewRayTracer implements RayTracer {
       ray.setCurrentMaterial(Air.INSTANCE);
     }
     while (true) {
-      if (!nextIntersection(scene, ray, false)) {
+      if (!nextIntersection(scene, ray)) {
         if (mapIntersection(scene, ray)) {
           break;
         }
@@ -85,9 +85,11 @@ public static double skyOcclusion(Scene scene, WorkerState state) {
 
   /**
    * Find next ray intersection.
+   * @param particleFog Whether to process particle fog
+   * @param random Used for particle fog, can be null if particleFog is false
    * @return Next intersection
    */
-  public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog) {
+  public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog, Random random) {
     ray.setPrevMaterial(ray.getCurrentMaterial(), ray.getCurrentData());
     ray.t = Double.POSITIVE_INFINITY;
     boolean hit = false;
@@ -98,7 +100,9 @@ public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog
       hit = waterPlaneIntersection(scene, ray) || hit;
     }
     if (particleFog) {
-      hit = scene.fog.intersect(ray) || hit;
+      for(FogVolume v : scene.fog.getFogVolumes()) {
+        hit = v.intersect(ray, scene, random) || hit;
+      }
     }
     if (scene.intersect(ray)) {
       // Octree tracer handles updating distance.
@@ -116,7 +120,7 @@ public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog
   }
 
   public static boolean nextIntersection(Scene scene, Ray ray) {
-    return nextIntersection(scene, ray, false);
+    return nextIntersection(scene, ray, false, null);
   }
 
   private static boolean waterPlaneIntersection(Scene scene, Ray ray) {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
index 207a49a9b9..32b6b7340a 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
@@ -1682,7 +1682,7 @@ public boolean traceTarget(Ray ray) {
     ray.o.x -= origin.x;
     ray.o.y -= origin.y;
     ray.o.z -= origin.z;
-    while (PreviewRayTracer.nextIntersection(this, ray, false)) {
+    while (PreviewRayTracer.nextIntersection(this, ray)) {
       if (ray.getCurrentMaterial() != Air.INSTANCE) {
         return true;
       }

From b0455aea64840b3f6e076c76354b1232e4679080 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Fri, 29 Sep 2023 13:57:34 -0400
Subject: [PATCH 17/38] rename scaleOffset to yOffset

---
 .../chunky/renderer/scene/ExponentialFogVolume.java    | 10 +++++-----
 .../se/llbit/chunky/renderer/scene/LayerFogVolume.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
index 7797a6832d..5c1167f9ec 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
@@ -8,24 +8,24 @@
 
 public class ExponentialFogVolume extends FogVolume {
   public double scaleHeight;
-  public double scaleOffset;
-  public ExponentialFogVolume(Vector3 color, double density, double scaleHeight, double scaleOffset) {
+  public double yOffset;
+  public ExponentialFogVolume(Vector3 color, double density, double scaleHeight, double yOffset) {
     this.color = color;
     this.density = density;
     this.scaleHeight = scaleHeight;
-    this.scaleOffset = scaleOffset;
+    this.yOffset = yOffset;
   }
   public boolean intersect(Ray ray, Scene scene, Random random) {
     // Amount of fog the ray should pass through before being scattered
     // Sampled from an exponential distribution
     double fogPenetrated = -Math.log(1 - random.nextDouble());
     double expHeightDiff = fogPenetrated * ray.d.y / (scaleHeight * density);
-    double expYfHs = Math.exp(-(ray.o.y + scene.origin.y - scaleOffset) / scaleHeight) - expHeightDiff;
+    double expYfHs = Math.exp(-(ray.o.y + scene.origin.y - yOffset) / scaleHeight) - expHeightDiff;
     if(expYfHs <= 0) {
       // The ray does not encounter enough fog to be scattered - no intersection.
       return false;
     }
-    double yf = -Math.log(expYfHs) * scaleHeight + scaleOffset;
+    double yf = -Math.log(expYfHs) * scaleHeight + yOffset;
     double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
     if(dist >= ray.t) {
       // The ray would have encountered enough fog to be scattered, but something is in the way.
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
index 8b6bfbcde4..482d93eee7 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
@@ -8,24 +8,24 @@
 
 public class LayerFogVolume extends FogVolume {
   public double layerHeight;
-  public double scaleOffset;
-  public LayerFogVolume(Vector3 color, double density, double layerHeight, double scaleOffset) {
+  public double yOffset;
+  public LayerFogVolume(Vector3 color, double density, double layerHeight, double yOffset) {
     this.color = color;
     this.density = density;
     this.layerHeight = layerHeight;
-    this.scaleOffset = scaleOffset;
+    this.yOffset = yOffset;
   }
   public boolean intersect(Ray ray, Scene scene, Random random) {
     // Amount of fog the ray should pass through before being scattered
     // Sampled from an exponential distribution
     double fogPenetrated = -Math.log(1 - random.nextDouble());
     double atanHeightDiff = fogPenetrated * ray.d.y / (layerHeight * density);
-    double atanYfHs = Math.atan((ray.o.y + scene.origin.y - scaleOffset) / layerHeight) + atanHeightDiff;
+    double atanYfHs = Math.atan((ray.o.y + scene.origin.y - yOffset) / layerHeight) + atanHeightDiff;
     if(Math.PI/2 - Math.abs(atanYfHs) <= 0) {
       // The ray does not encounter enough fog to be scattered - no intersection.
       return false;
     }
-    double yf = Math.tan(atanYfHs) * layerHeight + scaleOffset;
+    double yf = Math.tan(atanYfHs) * layerHeight + yOffset;
     double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
     if(dist >= ray.t) {
       // The ray would have encountered enough fog to be scattered, but something is in the way.

From 134250213648894f128ef2d6fa324df34860e2fb Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Fri, 29 Sep 2023 18:17:47 -0400
Subject: [PATCH 18/38] Cuboid fog

---
 .../renderer/scene/CuboidFogVolume.java       | 65 +++++++++++++++++++
 .../se/llbit/chunky/renderer/scene/Fog.java   |  8 +--
 chunky/src/java/se/llbit/math/AABB.java       | 16 +++++
 3 files changed, 84 insertions(+), 5 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
new file mode 100644
index 0000000000..85459987b9
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
@@ -0,0 +1,65 @@
+package se.llbit.chunky.renderer.scene;
+
+import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.math.AABB;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+
+import java.util.Random;
+
+public class CuboidFogVolume extends FogVolume {
+  public AABB bounds;
+  public CuboidFogVolume(Vector3 color, double density, AABB bounds) {
+    this.color = color;
+    this.density = density;
+    this.bounds = bounds;
+  }
+
+  @Override
+  public void setRandomNormal(Ray ray, Random random) {
+    super.setRandomNormal(ray, random);
+  }
+
+  public boolean intersect(Ray ray, Scene scene, Random random) {
+    // Amount of fog the ray should pass through before being scattered
+    // Sampled from an exponential distribution
+    double fogPenetrated = -Math.log(1 - random.nextDouble());
+    double fogDistance = fogPenetrated / density;
+    AABB boundsTranslated = bounds.getTranslated(-scene.origin.x, -scene.origin.y, -scene.origin.z);
+    double dist;
+    if(boundsTranslated.inside(ray.o)) {
+      boundsTranslated.intersectFromInside(ray);
+      if(fogDistance > ray.tNext) {
+        // The ray makes it out of the box without hitting fog
+        return false;
+      } else {
+        dist = fogDistance;
+      }
+    } else {
+      // Outside the box
+      if(!boundsTranslated.quickIntersect(ray)) {
+        // The ray misses the box
+        return false;
+      }
+      Ray throughBox = new Ray(ray);
+      throughBox.o.scaleAdd(ray.tNext + Ray.OFFSET, ray.d);
+      boundsTranslated.intersectFromInside(throughBox);
+      if(fogDistance > throughBox.tNext) {
+        // The ray makes it through the box without hitting fog
+        return false;
+      } else {
+        dist = ray.tNext + fogDistance;
+      }
+    }
+    if(dist >= ray.t) {
+      // The ray would have encountered enough fog to be scattered, but something is in the way.
+      return false;
+    }
+    ray.t = dist;
+    // pick a random normal vector based on a spherical particle
+    setRandomNormal(ray, random);
+    ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
+    ray.color.set(color.x, color.y, color.z, 1);
+    return true;
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index a1ea098545..55aef0232b 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -11,10 +11,7 @@
 import se.llbit.json.JsonArray;
 import se.llbit.json.JsonObject;
 import se.llbit.json.JsonValue;
-import se.llbit.math.QuickMath;
-import se.llbit.math.Ray;
-import se.llbit.math.Vector3;
-import se.llbit.math.Vector4;
+import se.llbit.math.*;
 import se.llbit.util.JsonSerializable;
 
 public final class Fog implements JsonSerializable {
@@ -35,7 +32,8 @@ public Fog(Scene scene) {
     this.scene = scene;
     //addVolume(new ExponentialFogVolume(new Vector3(1, 0, 0), 0.001, 20, 100));
     //addVolume(new ExponentialFogVolume(new Vector3(0, 0, 1), 0.0001, -20, 100));
-    addVolume(new LayerFogVolume(new Vector3(0.5, 0.5, 1), 0.004, 20, 200));
+    //addVolume(new LayerFogVolume(new Vector3(0.5, 0.5, 1), 0.004, 20, 200));
+    addVolume(new CuboidFogVolume(new Vector3(1, 0, 1), 0.01, new AABB(-650, -550, 150, 250, 450, 550)));
   }
 
   public boolean fogEnabled() {
diff --git a/chunky/src/java/se/llbit/math/AABB.java b/chunky/src/java/se/llbit/math/AABB.java
index 34797d3514..6b60490014 100644
--- a/chunky/src/java/se/llbit/math/AABB.java
+++ b/chunky/src/java/se/llbit/math/AABB.java
@@ -257,6 +257,22 @@ public boolean quickIntersect(Ray ray) {
     }
   }
 
+  /**
+   * Test for intersection while exiting the bounding box.
+   * @param ray Ray to test for intersection.
+   * @return False if the ray does not start inside the box.
+   */
+  public boolean intersectFromInside(Ray ray) {
+    if(!inside(ray.o)) {
+      return false;
+    }
+    double tx = ((ray.d.x >= 0 ? xmax : xmin) - ray.o.x) / ray.d.x;
+    double ty = ((ray.d.y >= 0 ? ymax : ymin) - ray.o.y) / ray.d.y;
+    double tz = ((ray.d.z >= 0 ? zmax : zmin) - ray.o.z) / ray.d.z;
+    ray.tNext = Math.min(tx, Math.min(ty, tz));
+    return true;
+  }
+
   /**
    * Test if point is inside the bounding box.
    *

From 3b5daf7b33eab3b75e9f6e4816a28bfd10b8348d Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Sat, 30 Sep 2023 00:57:09 +0200
Subject: [PATCH 19/38] Add cuboid and spherical volumes

---
 .../renderer/scene/CuboidFogVolume.java       | 68 +++++++++++++++++
 .../se/llbit/chunky/renderer/scene/Fog.java   | 10 +--
 .../chunky/renderer/scene/FogVolume.java      |  8 ++
 .../renderer/scene/SphericalFogVolume.java    | 74 +++++++++++++++++++
 chunky/src/java/se/llbit/math/AABB.java       |  7 +-
 5 files changed, 157 insertions(+), 10 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
new file mode 100644
index 0000000000..a6fc6d2330
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
@@ -0,0 +1,68 @@
+package se.llbit.chunky.renderer.scene;
+
+import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.math.AABB;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+
+import java.util.Random;
+
+public class CuboidFogVolume extends FogVolume {
+
+  private AABB aabb;
+
+  @Override
+  public boolean intersect(Ray ray, Scene scene, Random random) {
+    double distance;
+    double fogPenetrated = -Math.log(1 - random.nextDouble());
+    double fogDistance = fogPenetrated / density;
+    AABB aabbTranslated = aabb.getTranslated(-scene.origin.x, -scene.origin.y, -scene.origin.z);
+    if (!aabbTranslated.inside(ray.o)) {
+      Ray test = new Ray(ray);
+      if (aabbTranslated.hitTest(test)) {
+        distance = test.tNext;
+        distance += fogDistance;
+      } else {
+        return false;
+      }
+    } else {
+      distance = fogDistance;
+    }
+
+    if (distance > ray.t) {
+      return false;
+    }
+
+    Vector3 o = new Vector3(ray.o);
+    o.scaleAdd(distance, ray.d);
+    if (aabbTranslated.inside(o)) {
+      ray.t = distance;
+      setRandomNormal(ray, random);
+      ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
+      ray.color.set(color.x, color.y, color.z, 1);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public void setBounds(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) {
+    this.aabb = new AABB(xmin, xmax, ymin, ymax, zmin, zmax);
+  }
+
+  public void setBounds(AABB aabb) {
+    this.aabb = aabb;
+  }
+
+  public CuboidFogVolume(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, Vector3 color, double density) {
+    this.aabb = new AABB(xmin, xmax, ymin, ymax, zmin, zmax);
+    this.color = color;
+    this.density = density;
+  }
+
+  public CuboidFogVolume(AABB aabb, Vector3 color, double density) {
+    this.aabb = aabb;
+    this.color = color;
+    this.density = density;
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index a1ea098545..f908a76df5 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -5,16 +5,11 @@
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
 
-import org.apache.commons.math3.util.FastMath;
 import se.llbit.chunky.PersistentSettings;
-import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.json.JsonArray;
 import se.llbit.json.JsonObject;
 import se.llbit.json.JsonValue;
-import se.llbit.math.QuickMath;
-import se.llbit.math.Ray;
-import se.llbit.math.Vector3;
-import se.llbit.math.Vector4;
+import se.llbit.math.*;
 import se.llbit.util.JsonSerializable;
 
 public final class Fog implements JsonSerializable {
@@ -33,9 +28,6 @@ public final class Fog implements JsonSerializable {
 
   public Fog(Scene scene) {
     this.scene = scene;
-    //addVolume(new ExponentialFogVolume(new Vector3(1, 0, 0), 0.001, 20, 100));
-    //addVolume(new ExponentialFogVolume(new Vector3(0, 0, 1), 0.0001, -20, 100));
-    addVolume(new LayerFogVolume(new Vector3(0.5, 0.5, 1), 0.004, 20, 200));
   }
 
   public boolean fogEnabled() {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
index b16e926928..2eb3894b14 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
@@ -28,4 +28,12 @@ public void setRandomNormal(Ray ray, Random random) {
     a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
     ray.setNormal(a1);
   }
+
+  public void setDensity(double value) {
+    this.density = value;
+  }
+
+  public void setColor(Vector3 value) {
+    this.color = new Vector3(value);
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
new file mode 100644
index 0000000000..f24d9e6198
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
@@ -0,0 +1,74 @@
+package se.llbit.chunky.renderer.scene;
+
+import org.apache.commons.math3.util.FastMath;
+import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+
+import java.util.Random;
+
+public class SphericalFogVolume extends FogVolume {
+  private Vector3 center;
+  private double radius;
+
+  @Override
+  public boolean intersect(Ray ray, Scene scene, Random random) {
+    double distance;
+    double fogPenetrated = -Math.log(1 - random.nextDouble());
+    double fogDistance = fogPenetrated / density;
+    Vector3 o = new Vector3(ray.o);
+    Vector3 transformedCenter = new Vector3(center.x + -scene.origin.x, center.y + -scene.origin.y, center.z + -scene.origin.z);
+    Vector3 centerFromRayOrigin = new Vector3(transformedCenter);
+    centerFromRayOrigin.sub(o);
+    double rayDistanceFromCenter = centerFromRayOrigin.length();
+    if (rayDistanceFromCenter > radius) {
+      o.scaleAdd(rayDistanceFromCenter, ray.d);
+      o.sub(transformedCenter);
+      double distanceOfPointClosestToCenter = o.length();
+      if (distanceOfPointClosestToCenter <= radius) {
+        distance = distanceOfPointClosestToCenter;
+        distance -= FastMath.sqrt(FastMath.pow(radius, 2) - FastMath.pow(distanceOfPointClosestToCenter, 2));
+        distance += fogDistance;
+      } else {
+        return false;
+      }
+    } else {
+      distance = fogDistance;
+    }
+    if (distance > ray.t) {
+      return false;
+    }
+    if (distance <= radius) {
+      ray.t = distance;
+      setRandomNormal(ray, random);
+      ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
+      ray.color.set(color.x, color.y, color.z, 1);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public Vector3 getCenter() {
+    return this.center;
+  }
+
+  public void setCenter(Vector3 value) {
+    this.center = new Vector3(value);
+  }
+
+  public double getRadius() {
+    return this.radius;
+  }
+
+  public void setRadius(double value) {
+    this.radius = value;
+  }
+
+  public SphericalFogVolume(Vector3 center, double radius, Vector3 color, double density) {
+    this.center = center;
+    this.radius = radius;
+    this.color = color;
+    this.density = density;
+  }
+}
diff --git a/chunky/src/java/se/llbit/math/AABB.java b/chunky/src/java/se/llbit/math/AABB.java
index 34797d3514..dad0f918ff 100644
--- a/chunky/src/java/se/llbit/math/AABB.java
+++ b/chunky/src/java/se/llbit/math/AABB.java
@@ -333,7 +333,12 @@ public boolean hitTest(Ray ray) {
       }
     }
 
-    return tNear < tFar + Ray.EPSILON && tFar > 0;
+    if (tNear < tFar + Ray.EPSILON && tFar > 0) {
+      ray.tNext = tNear;
+      return true;
+    } else {
+      return false;
+    }
   }
 
   /**

From 40950f8504c1fb10bd385cd86838e2b6fd5ec73a Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Fri, 29 Sep 2023 23:32:15 -0400
Subject: [PATCH 20/38] tweaks to fog code, add per-fog materials for emittance
 etc.

---
 .../renderer/scene/CuboidFogVolume.java       |  7 +++--
 .../renderer/scene/ExponentialFogVolume.java  | 24 +++++++++++++----
 .../se/llbit/chunky/renderer/scene/Fog.java   |  5 ++++
 .../chunky/renderer/scene/FogVolume.java      | 26 +++++++++++++++++--
 .../chunky/renderer/scene/LayerFogVolume.java | 23 +++++++++++++---
 .../renderer/scene/SphericalFogVolume.java    |  5 ++--
 .../world/material/ParticleFogMaterial.java   | 18 +------------
 7 files changed, 73 insertions(+), 35 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
index a6fc6d2330..12eb786fed 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
@@ -38,8 +38,7 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     if (aabbTranslated.inside(o)) {
       ray.t = distance;
       setRandomNormal(ray, random);
-      ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
-      ray.color.set(color.x, color.y, color.z, 1);
+      setRayMaterialAndColor(ray);
       return true;
     } else {
       return false;
@@ -54,13 +53,13 @@ public void setBounds(AABB aabb) {
     this.aabb = aabb;
   }
 
-  public CuboidFogVolume(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, Vector3 color, double density) {
+  public CuboidFogVolume(Vector3 color, double density, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) {
     this.aabb = new AABB(xmin, xmax, ymin, ymax, zmin, zmax);
     this.color = color;
     this.density = density;
   }
 
-  public CuboidFogVolume(AABB aabb, Vector3 color, double density) {
+  public CuboidFogVolume(Vector3 color, double density, AABB aabb) {
     this.aabb = aabb;
     this.color = color;
     this.density = density;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
index 5c1167f9ec..e3f4510a96 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
@@ -1,14 +1,13 @@
 package se.llbit.chunky.renderer.scene;
 
-import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
 
 import java.util.Random;
 
 public class ExponentialFogVolume extends FogVolume {
-  public double scaleHeight;
-  public double yOffset;
+  private double scaleHeight;
+  private double yOffset;
   public ExponentialFogVolume(Vector3 color, double density, double scaleHeight, double yOffset) {
     this.color = color;
     this.density = density;
@@ -34,8 +33,23 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     ray.t = dist;
     // pick a random normal vector based on a spherical particle
     setRandomNormal(ray, random);
-    ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
-    ray.color.set(color.x, color.y, color.z, 1);
+    setRayMaterialAndColor(ray);
     return true;
   }
+
+  public void setScaleHeight(double s) {
+    scaleHeight = s;
+  }
+
+  public double getScaleHeight() {
+    return scaleHeight;
+  }
+
+  public void setYOffset(double y) {
+    yOffset = y;
+  }
+
+  public double getYOffset() {
+    return yOffset;
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index f908a76df5..7cbf5dbe3b 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -28,6 +28,11 @@ public final class Fog implements JsonSerializable {
 
   public Fog(Scene scene) {
     this.scene = scene;
+    addVolume(new ExponentialFogVolume(new Vector3(0.5, 0.6, 1), 0.01, 50, 64));
+    addVolume(new CuboidFogVolume(new Vector3(1, 1, 1), 0.1, -625, -525, 125, 225, 450, 550));
+    SphericalFogVolume sfv = new SphericalFogVolume(new Vector3(0.7, 0, 1), 0.02, new Vector3(-700, 175, 500), 50);
+    sfv.getMaterial().emittance = 1;
+    addVolume(sfv);
   }
 
   public boolean fogEnabled() {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
index 2eb3894b14..51477bf890 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
@@ -1,15 +1,20 @@
 package se.llbit.chunky.renderer.scene;
 
 import org.apache.commons.math3.util.FastMath;
+import se.llbit.chunky.world.Material;
+import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
 
 import java.util.Random;
 
 public abstract class FogVolume {
-  public Vector3 color;
-  public double density;
+  protected Vector3 color;
+  protected double density;
+  protected Material material = new ParticleFogMaterial();
+
   public abstract boolean intersect(Ray ray, Scene scene, Random random);
+
   public void setRandomNormal(Ray ray, Random random) {
     Vector3 a1 = new Vector3();
     a1.cross(ray.d, new Vector3(0, 1, 0));
@@ -29,11 +34,28 @@ public void setRandomNormal(Ray ray, Random random) {
     ray.setNormal(a1);
   }
 
+  public void setRayMaterialAndColor(Ray ray) {
+    ray.setCurrentMaterial(material);
+    ray.color.set(color.x, color.y, color.z, 1);
+  }
+
+  public Material getMaterial() {
+    return material;
+  }
+
   public void setDensity(double value) {
     this.density = value;
   }
 
+  public double getDensity() {
+    return density;
+  }
+
   public void setColor(Vector3 value) {
     this.color = new Vector3(value);
   }
+
+  public Vector3 getColor() {
+    return color;
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
index 482d93eee7..5ffdfd7c8a 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
@@ -7,8 +7,8 @@
 import java.util.Random;
 
 public class LayerFogVolume extends FogVolume {
-  public double layerHeight;
-  public double yOffset;
+  private double layerHeight;
+  private double yOffset;
   public LayerFogVolume(Vector3 color, double density, double layerHeight, double yOffset) {
     this.color = color;
     this.density = density;
@@ -34,8 +34,23 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     ray.t = dist;
     // pick a random normal vector based on a spherical particle
     setRandomNormal(ray, random);
-    ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
-    ray.color.set(color.x, color.y, color.z, 1);
+    setRayMaterialAndColor(ray);
     return true;
   }
+
+  public void setLayerHeight(double l) {
+    layerHeight = l;
+  }
+
+  public double getLayerHeight() {
+    return layerHeight;
+  }
+
+  public void setYOffset(double y) {
+    yOffset = y;
+  }
+
+  public double getYOffset() {
+    return yOffset;
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
index f24d9e6198..3056a473e8 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
@@ -41,8 +41,7 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     if (distance <= radius) {
       ray.t = distance;
       setRandomNormal(ray, random);
-      ray.setCurrentMaterial(ParticleFogMaterial.INSTANCE);
-      ray.color.set(color.x, color.y, color.z, 1);
+      setRayMaterialAndColor(ray);
       return true;
     } else {
       return false;
@@ -65,7 +64,7 @@ public void setRadius(double value) {
     this.radius = value;
   }
 
-  public SphericalFogVolume(Vector3 center, double radius, Vector3 color, double density) {
+  public SphericalFogVolume(Vector3 color, double density, Vector3 center, double radius) {
     this.center = center;
     this.radius = radius;
     this.color = color;
diff --git a/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
index ac57cc3806..c183b732f6 100644
--- a/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
@@ -1,19 +1,3 @@
-/* Copyright (c) 2019 Jesper Öqvist <jesper@llbit.se>
- *
- * This file is part of Chunky.
- *
- * Chunky is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Chunky is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * You should have received a copy of the GNU General Public License
- * along with Chunky.  If not, see <http://www.gnu.org/licenses/>.
- */
 package se.llbit.chunky.world.material;
 
 import se.llbit.chunky.resources.Texture;
@@ -22,7 +6,7 @@
 public class ParticleFogMaterial extends Material {
   public static final ParticleFogMaterial INSTANCE = new ParticleFogMaterial();
 
-  private ParticleFogMaterial() {
+  public ParticleFogMaterial() {
     super("particle_fog", Texture.air);
   }
 }

From f669b33ddeff1d6e0d27147e42efb75f55ababa1 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Mon, 2 Oct 2023 21:42:51 +0200
Subject: [PATCH 21/38] Implement JsonSerializable and add GUI

- Re-enabled use of old (fast) fog.
- Made PathTracer `addSkyFog()` in diffuse reflections.
- Added an option to render particle fog in the render preview to the `Advanced` tab.
- Set the default uniform fog density to 0.05.
- Fixed the sphere implementation.
- Moved all fog controls to a new `Fog` tab.
- Renamed the `Sky & Fog` tab to `Sky`.
---
 .../renderer/scene/CuboidFogVolume.java       |  62 ++-
 .../renderer/scene/ExponentialFogVolume.java  |  33 +-
 .../se/llbit/chunky/renderer/scene/Fog.java   |  49 +-
 .../chunky/renderer/scene/FogVolume.java      |  98 +++-
 .../chunky/renderer/scene/FogVolumeType.java  |   6 +
 .../chunky/renderer/scene/LayerFogVolume.java |  47 +-
 .../chunky/renderer/scene/PathTracer.java     |   6 +-
 .../renderer/scene/PreviewRayTracer.java      |   2 +-
 .../se/llbit/chunky/renderer/scene/Scene.java |  15 +-
 .../renderer/scene/SphericalFogVolume.java    | 134 ++++-
 .../RenderControlsFxController.java           |   1 +
 .../dialogs/FogVolumeTypeSelectorDialog.java  |  32 ++
 .../render/settings/UniformFogSettings.java   |   2 +-
 .../chunky/ui/render/tabs/AdvancedTab.java    |   8 +
 .../llbit/chunky/ui/render/tabs/FogTab.java   | 505 ++++++++++++++++++
 .../llbit/chunky/ui/render/tabs/SkyTab.java   |  36 +-
 .../se/llbit/chunky/world/ExtraMaterials.java |   3 -
 .../chunky/ui/render/tabs/AdvancedTab.fxml    |   1 +
 .../llbit/chunky/ui/render/tabs/FogTab.fxml   |  49 ++
 .../llbit/chunky/ui/render/tabs/SkyTab.fxml   |  19 -
 .../se/llbit/chunky/PersistentSettings.java   |   9 +
 21 files changed, 990 insertions(+), 127 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/FogVolumeType.java
 create mode 100644 chunky/src/java/se/llbit/chunky/ui/dialogs/FogVolumeTypeSelectorDialog.java
 create mode 100644 chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
 create mode 100644 chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
index 12eb786fed..8156766a0a 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
@@ -1,6 +1,7 @@
 package se.llbit.chunky.renderer.scene;
 
-import se.llbit.chunky.world.material.ParticleFogMaterial;
+import org.apache.commons.math3.util.FastMath;
+import se.llbit.json.JsonObject;
 import se.llbit.math.AABB;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
@@ -8,13 +9,18 @@
 import java.util.Random;
 
 public class CuboidFogVolume extends FogVolume {
-
+  private static final double DEFAULT_XMIN = -10;
+  private static final double DEFAULT_XMAX = 10;
+  private static final double DEFAULT_YMIN = 100;
+  private static final double DEFAULT_YMAX = 120;
+  private static final double DEFAULT_ZMIN = -10;
+  private static final double DEFAULT_ZMAX = 10;
   private AABB aabb;
 
   @Override
   public boolean intersect(Ray ray, Scene scene, Random random) {
     double distance;
-    double fogPenetrated = -Math.log(1 - random.nextDouble());
+    double fogPenetrated = -FastMath.log(1 - random.nextDouble());
     double fogDistance = fogPenetrated / density;
     AABB aabbTranslated = aabb.getTranslated(-scene.origin.x, -scene.origin.y, -scene.origin.z);
     if (!aabbTranslated.inside(ray.o)) {
@@ -29,7 +35,7 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
       distance = fogDistance;
     }
 
-    if (distance > ray.t) {
+    if (distance >= ray.t) {
       return false;
     }
 
@@ -46,22 +52,58 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
   }
 
   public void setBounds(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) {
-    this.aabb = new AABB(xmin, xmax, ymin, ymax, zmin, zmax);
+    setBounds(new AABB(xmin, xmax, ymin, ymax, zmin, zmax));
   }
 
-  public void setBounds(AABB aabb) {
+  private void setBounds(AABB aabb) {
     this.aabb = aabb;
   }
 
+  public AABB getBounds() {
+    return new AABB(this.aabb.xmin, this.aabb.xmax, this.aabb.ymin, this.aabb.ymax, this.aabb.zmin, this.aabb.zmax);
+  }
+
   public CuboidFogVolume(Vector3 color, double density, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) {
-    this.aabb = new AABB(xmin, xmax, ymin, ymax, zmin, zmax);
-    this.color = color;
-    this.density = density;
+    this(color, density, new AABB(xmin, xmax, ymin, ymax, zmin, zmax));
   }
 
   public CuboidFogVolume(Vector3 color, double density, AABB aabb) {
+    this.type = FogVolumeType.CUBOID;
     this.aabb = aabb;
-    this.color = color;
+    this.color = new Vector3(color);
     this.density = density;
   }
+
+  public CuboidFogVolume(Vector3 color, double density) {
+    this(color, density, new AABB(DEFAULT_XMIN, DEFAULT_XMAX, DEFAULT_YMIN, DEFAULT_YMAX, DEFAULT_ZMIN, DEFAULT_ZMAX));
+  }
+
+  @Override
+  public JsonObject volumeSpecificPropertiesToJson() {
+    JsonObject properties = new JsonObject();
+    JsonObject pos1 = new JsonObject();
+    pos1.add("x", aabb.xmin);
+    pos1.add("y", aabb.ymin);
+    pos1.add("z", aabb.zmin);
+    properties.add("pos1", pos1);
+    JsonObject pos2 = new JsonObject();
+    pos2.add("x", aabb.xmax);
+    pos2.add("y", aabb.ymax);
+    pos2.add("z", aabb.zmax);
+    properties.add("pos2", pos2);
+    return properties;
+  }
+
+  @Override
+  public void importVolumeSpecificProperties(JsonObject json) {
+    JsonObject pos1 = json.get("pos1").object();
+    double x1 = pos1.get("x").doubleValue(aabb.xmin);
+    double y1 = pos1.get("y").doubleValue(aabb.ymin);
+    double z1 = pos1.get("z").doubleValue(aabb.zmin);
+    JsonObject pos2 = json.get("pos2").object();
+    double x2 = pos2.get("x").doubleValue(aabb.xmax);
+    double y2 = pos2.get("y").doubleValue(aabb.ymax);
+    double z2 = pos2.get("z").doubleValue(aabb.zmax);
+    aabb = new AABB(x1, x2, y1, y2, z1, z2);
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
index e3f4510a96..bfa7473a0d 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
@@ -1,30 +1,41 @@
 package se.llbit.chunky.renderer.scene;
 
+import org.apache.commons.math3.util.FastMath;
+import se.llbit.json.JsonObject;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
 
 import java.util.Random;
 
 public class ExponentialFogVolume extends FogVolume {
+  public static final double DEFAULT_SCALE_HEIGHT = 20;
+  public static final double DEFAULT_Y_OFFSET = 0;
   private double scaleHeight;
   private double yOffset;
   public ExponentialFogVolume(Vector3 color, double density, double scaleHeight, double yOffset) {
-    this.color = color;
+    this.type = FogVolumeType.EXPONENTIAL;
+    this.color = new Vector3(color);
     this.density = density;
     this.scaleHeight = scaleHeight;
     this.yOffset = yOffset;
   }
+
+  public ExponentialFogVolume(Vector3 color, double density) {
+    this(color, density, DEFAULT_SCALE_HEIGHT, DEFAULT_Y_OFFSET);
+  }
+
+  @Override
   public boolean intersect(Ray ray, Scene scene, Random random) {
     // Amount of fog the ray should pass through before being scattered
     // Sampled from an exponential distribution
-    double fogPenetrated = -Math.log(1 - random.nextDouble());
+    double fogPenetrated = -FastMath.log(1 - random.nextDouble());
     double expHeightDiff = fogPenetrated * ray.d.y / (scaleHeight * density);
-    double expYfHs = Math.exp(-(ray.o.y + scene.origin.y - yOffset) / scaleHeight) - expHeightDiff;
+    double expYfHs = FastMath.exp(-(ray.o.y + scene.origin.y - yOffset) / scaleHeight) - expHeightDiff;
     if(expYfHs <= 0) {
       // The ray does not encounter enough fog to be scattered - no intersection.
       return false;
     }
-    double yf = -Math.log(expYfHs) * scaleHeight + yOffset;
+    double yf = -FastMath.log(expYfHs) * scaleHeight + yOffset;
     double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
     if(dist >= ray.t) {
       // The ray would have encountered enough fog to be scattered, but something is in the way.
@@ -52,4 +63,18 @@ public void setYOffset(double y) {
   public double getYOffset() {
     return yOffset;
   }
+
+  @Override
+  public JsonObject volumeSpecificPropertiesToJson() {
+    JsonObject properties = new JsonObject();
+    properties.add("scaleHeight", scaleHeight);
+    properties.add("yOffset", yOffset);
+    return properties;
+  }
+
+  @Override
+  public void importVolumeSpecificProperties(JsonObject json) {
+    scaleHeight = json.get("scaleHeight").doubleValue(scaleHeight);
+    yOffset = json.get("yOffset").doubleValue(yOffset);
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index 7cbf5dbe3b..51b254e465 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -2,7 +2,6 @@
 
 import java.util.ArrayList;
 import java.util.Random;
-import java.util.concurrent.ThreadLocalRandom;
 import java.util.stream.Collectors;
 
 import se.llbit.chunky.PersistentSettings;
@@ -28,11 +27,6 @@ public final class Fog implements JsonSerializable {
 
   public Fog(Scene scene) {
     this.scene = scene;
-    addVolume(new ExponentialFogVolume(new Vector3(0.5, 0.6, 1), 0.01, 50, 64));
-    addVolume(new CuboidFogVolume(new Vector3(1, 1, 1), 0.1, -625, -525, 125, 225, 450, 550));
-    SphericalFogVolume sfv = new SphericalFogVolume(new Vector3(0.7, 0, 1), 0.02, new Vector3(-700, 175, 500), 50);
-    sfv.getMaterial().emittance = 1;
-    addVolume(sfv);
   }
 
   public boolean fogEnabled() {
@@ -76,11 +70,29 @@ public void removeLayer(int index) {
     scene.refresh();
   }
 
-  public void addVolume(FogVolume v) {
-    volumes.add(v);
+  private FogVolume getVolumeFromType(FogVolumeType fogVolumeType) {
+    switch (fogVolumeType) {
+      case LAYER:
+        return new LayerFogVolume(fogColor, uniformDensity);
+      case SPHERE:
+        return new SphericalFogVolume(fogColor, uniformDensity);
+      case CUBOID:
+        return new CuboidFogVolume(fogColor, uniformDensity);
+      case EXPONENTIAL:
+      default:
+        return new ExponentialFogVolume(fogColor, uniformDensity);
+    }
+  }
+
+  public void addVolume(FogVolumeType fogVolumeType) {
+    addVolume(getVolumeFromType(fogVolumeType));
     scene.refresh();
   }
 
+  public void addVolume(FogVolume fogVolume) {
+    volumes.add(fogVolume);
+  }
+
   public void removeVolume(int index) {
     volumes.remove(index);
     scene.refresh();
@@ -115,7 +127,7 @@ private static double clampDy(double dy) {
   }
 
   public void addSkyFog(Ray ray, Vector4 scatterLight) {
-    /*
+
     if (mode == FogMode.UNIFORM) {
       if (uniformDensity > 0.0) {
         double fog;
@@ -136,7 +148,7 @@ public void addSkyFog(Ray ray, Vector4 scatterLight) {
       double y2 = y1 + dy * FOG_LIMIT;
       addLayeredFog(ray.color, dy, y1, y2, scatterLight);
     }
-    */
+
   }
 
   public void addGroundFog(Ray ray, Vector3 ox, double airDistance, Vector4 scatterLight, double scatterOffset) {
@@ -232,6 +244,11 @@ private double sampleLayeredScatterOffset(Random random, double y1, double y2, d
       jsonLayers.add(jsonLayer);
     }
     fogObj.add("layers", jsonLayers);
+    JsonArray jsonVolumes = new JsonArray();
+    for (FogVolume volume : volumes) {
+      jsonVolumes.add(volume.toJson());
+    }
+    fogObj.add("volumes", jsonVolumes);
     JsonObject colorObj = new JsonObject();
     colorObj.add("red", fogColor.x);
     colorObj.add("green", fogColor.y);
@@ -250,6 +267,15 @@ public void importFromJson(JsonObject json, Scene scene) {
         o.get("breadth").doubleValue(0),
         o.get("density").doubleValue(0),
         scene)).collect(Collectors.toCollection(ArrayList<FogLayer>::new));
+    JsonArray jsonVolumes = json.get("volumes").array();
+    volumes.clear();
+    for (JsonValue jsonVolume : jsonVolumes) {
+      JsonObject jsonVolumeObject = jsonVolume.asObject();
+      FogVolumeType fogVolumeType = FogVolumeType.valueOf(jsonVolumeObject.get("type").asString(""));
+      FogVolume fogVolume = getVolumeFromType(fogVolumeType);
+      fogVolume.importFromJson(jsonVolumeObject);
+      addVolume(fogVolume);
+    }
     JsonObject colorObj = json.get("color").object();
     fogColor.x = colorObj.get("red").doubleValue(fogColor.x);
     fogColor.y = colorObj.get("green").doubleValue(fogColor.y);
@@ -261,7 +287,8 @@ public void importFromLegacy(JsonObject json) {
     mode = json.get("fogEnabled").boolValue(mode != FogMode.NONE) ? FogMode.NONE : FogMode.UNIFORM;
     uniformDensity = json.get("fogDensity").doubleValue(uniformDensity);
     skyFogDensity = json.get("skyFogDensity").doubleValue(skyFogDensity);
-    layers = new ArrayList<>(0);
+    layers.clear();
+    volumes.clear();
     JsonObject colorObj = json.get("fogColor").object();
     fogColor.x = colorObj.get("red").doubleValue(fogColor.x);
     fogColor.y = colorObj.get("green").doubleValue(fogColor.y);
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
index 51477bf890..40059f0d62 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
@@ -3,12 +3,15 @@
 import org.apache.commons.math3.util.FastMath;
 import se.llbit.chunky.world.Material;
 import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.json.JsonObject;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
+import se.llbit.util.JsonSerializable;
 
 import java.util.Random;
 
-public abstract class FogVolume {
+public abstract class FogVolume implements JsonSerializable {
+  protected FogVolumeType type;
   protected Vector3 color;
   protected double density;
   protected Material material = new ParticleFogMaterial();
@@ -43,6 +46,46 @@ public Material getMaterial() {
     return material;
   }
 
+  public double getEmittance() {
+    return this.material.emittance;
+  }
+
+  public void setEmittance(float value) {
+    this.material.emittance = value;
+  }
+
+  public double getSpecular() {
+    return this.material.specular;
+  }
+
+  public void setSpecular(float value) {
+    this.material.specular = value;
+  }
+
+  public double getSmoothness() {
+    return this.material.getPerceptualSmoothness();
+  }
+
+  public void setSmoothness(double value) {
+    this.material.setPerceptualSmoothness(value);
+  }
+
+  public double getIor() {
+    return this.material.ior;
+  }
+
+  public void setIor(float value) {
+    this.material.ior = value;
+  }
+
+  public double getMetalness() {
+    return this.material.metalness;
+  }
+
+  public void setMetalness(float value) {
+    this.material.metalness = value;
+  }
+
   public void setDensity(double value) {
     this.density = value;
   }
@@ -56,6 +99,57 @@ public void setColor(Vector3 value) {
   }
 
   public Vector3 getColor() {
-    return color;
+    return new Vector3(color);
+  }
+
+  public FogVolumeType getType() {
+    return type;
+  }
+
+  protected abstract JsonObject volumeSpecificPropertiesToJson();
+
+  @Override
+  public JsonObject toJson() {
+    JsonObject properties = volumeSpecificPropertiesToJson();
+    properties.add("type", type.name());
+    JsonObject colorObj = new JsonObject();
+    colorObj.add("red", color.x);
+    colorObj.add("green", color.y);
+    colorObj.add("blue", color.z);
+    properties.add("color", colorObj);
+    properties.add("density", density);
+    properties.add("materialProperties", materialPropertiesToJson());
+    return properties;
+  }
+
+  protected JsonObject materialPropertiesToJson() {
+    JsonObject materialProperties = new JsonObject();
+    materialProperties.add("emittance", material.emittance);
+    materialProperties.add("specular", material.specular);
+    materialProperties.add("roughness", material.roughness);
+    materialProperties.add("ior", material.ior);
+    materialProperties.add("metalness", material.metalness);
+    return materialProperties;
+  }
+
+  protected abstract void importVolumeSpecificProperties(JsonObject jsonObject);
+
+  public void importFromJson(JsonObject json) {
+    JsonObject colorObj = json.get("color").object();
+    color.x = colorObj.get("red").doubleValue(color.x);
+    color.y = colorObj.get("green").doubleValue(color.y);
+    color.z = colorObj.get("blue").doubleValue(color.z);
+    density = json.get("density").doubleValue(Scene.DEFAULT_FOG_DENSITY);
+    JsonObject materialProperties = json.get("materialProperties").object();
+    importMaterialProperties(materialProperties);
+    importVolumeSpecificProperties(json);
+  }
+
+  protected void importMaterialProperties(JsonObject json) {
+    material.emittance = json.get("emittance").floatValue(material.emittance);
+    material.specular = json.get("specular").floatValue(material.specular);
+    material.roughness = json.get("roughness").floatValue(material.roughness);
+    material.ior = json.get("ior").floatValue(material.ior);
+    material.metalness = json.get("metalness").floatValue(material.metalness);
   }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolumeType.java b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolumeType.java
new file mode 100644
index 0000000000..c798be7065
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolumeType.java
@@ -0,0 +1,6 @@
+package se.llbit.chunky.renderer.scene;
+
+public enum FogVolumeType {
+  EXPONENTIAL, LAYER, SPHERE, CUBOID
+
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
index 5ffdfd7c8a..8bc62a4d6c 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
@@ -1,31 +1,40 @@
 package se.llbit.chunky.renderer.scene;
 
-import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.json.JsonObject;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
 
 import java.util.Random;
 
 public class LayerFogVolume extends FogVolume {
-  private double layerHeight;
+  public static final double DEFAULT_Y_OFFSET = 62;
+  public static final double DEFAULT_BREADTH = 5;
+  private double layerBreadth;
   private double yOffset;
-  public LayerFogVolume(Vector3 color, double density, double layerHeight, double yOffset) {
-    this.color = color;
+  public LayerFogVolume(Vector3 color, double density, double layerBreadth, double yOffset) {
+    this.type = FogVolumeType.LAYER;
+    this.color = new Vector3(color);
     this.density = density;
-    this.layerHeight = layerHeight;
+    this.layerBreadth = layerBreadth;
     this.yOffset = yOffset;
   }
+
+  public LayerFogVolume(Vector3 color, double density) {
+    this(color, density, DEFAULT_BREADTH, DEFAULT_Y_OFFSET);
+  }
+
+  @Override
   public boolean intersect(Ray ray, Scene scene, Random random) {
     // Amount of fog the ray should pass through before being scattered
     // Sampled from an exponential distribution
     double fogPenetrated = -Math.log(1 - random.nextDouble());
-    double atanHeightDiff = fogPenetrated * ray.d.y / (layerHeight * density);
-    double atanYfHs = Math.atan((ray.o.y + scene.origin.y - yOffset) / layerHeight) + atanHeightDiff;
+    double atanHeightDiff = fogPenetrated * ray.d.y / (layerBreadth * density);
+    double atanYfHs = Math.atan((ray.o.y + scene.origin.y - yOffset) / layerBreadth) + atanHeightDiff;
     if(Math.PI/2 - Math.abs(atanYfHs) <= 0) {
       // The ray does not encounter enough fog to be scattered - no intersection.
       return false;
     }
-    double yf = Math.tan(atanYfHs) * layerHeight + yOffset;
+    double yf = Math.tan(atanYfHs) * layerBreadth + yOffset;
     double dist = (yf - (ray.o.y + scene.origin.y)) / ray.d.y;
     if(dist >= ray.t) {
       // The ray would have encountered enough fog to be scattered, but something is in the way.
@@ -38,12 +47,12 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     return true;
   }
 
-  public void setLayerHeight(double l) {
-    layerHeight = l;
+  public void setLayerBreadth(double l) {
+    layerBreadth = l;
   }
 
-  public double getLayerHeight() {
-    return layerHeight;
+  public double getLayerBreadth() {
+    return layerBreadth;
   }
 
   public void setYOffset(double y) {
@@ -53,4 +62,18 @@ public void setYOffset(double y) {
   public double getYOffset() {
     return yOffset;
   }
+
+  @Override
+  public JsonObject volumeSpecificPropertiesToJson() {
+    JsonObject properties = new JsonObject();
+    properties.add("layerBreadth", layerBreadth);
+    properties.add("yOffset", yOffset);
+    return properties;
+  }
+
+  @Override
+  public void importVolumeSpecificProperties(JsonObject json) {
+    layerBreadth = json.get("layerBreadth").doubleValue(layerBreadth);
+    yOffset = json.get("yOffset").doubleValue(yOffset);
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 09aa166ab4..ae7fd6578b 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -84,7 +84,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
         } else {
           // Indirect sky hit - diffuse color.
           scene.sky.getSkyColorDiffuseSun(ray, scene.getSunSamplingStrategy().isDiffuseSun());
-          // Skip sky fog - likely not noticeable in diffuse reflection.
+          addSkyFog(scene, ray, state, ox, od);
           hit = true;
         }
         break;
@@ -170,7 +170,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
         airDistance = ray.distance;
       }
     }
-/*
+
     // This is a simplistic fog model which gives greater artistic freedom but
     // less realism. The user can select fog color and density; in a more
     // realistic model color would depend on viewing angle and sun color/position.
@@ -197,7 +197,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
       getDirectLightAttenuation(scene, atmos, state);
       scene.fog.addGroundFog(ray, ox, airDistance, state.attenuation, offset);
     }
-*/
+
     return hit;
   }
 
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
index 28b1299378..ee21e55c2a 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
@@ -43,7 +43,7 @@ public class PreviewRayTracer implements RayTracer {
       ray.setCurrentMaterial(Air.INSTANCE);
     }
     while (true) {
-      if (!nextIntersection(scene, ray)) {
+      if (!nextIntersection(scene, ray, scene.getPreviewParticleFog(), state.random)) {
         if (mapIntersection(scene, ray)) {
           break;
         }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
index 32b6b7340a..76a9b008b4 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
@@ -149,7 +149,7 @@ public class Scene implements JsonSerializable, Refreshable {
   /**
    * Default fog density.
    */
-  public static final double DEFAULT_FOG_DENSITY = 0.0;
+  public static final double DEFAULT_FOG_DENSITY = 0.05;
 
   /**
    * Default post processing filter.
@@ -343,6 +343,8 @@ public class Scene implements JsonSerializable, Refreshable {
 
   protected volatile boolean isLoading = false;
 
+  private boolean previewParticleFog = PersistentSettings.getPreviewParticleFog();
+
   /**
    * Creates a scene with all default settings.
    *
@@ -454,6 +456,7 @@ public synchronized void copyState(Scene other, boolean copyChunks) {
     preventNormalEmitterWithSampling = other.preventNormalEmitterWithSampling;
     fancierTranslucency = other.fancierTranslucency;
     transmissivityCap = other.transmissivityCap;
+    previewParticleFog = other.previewParticleFog;
     transparentSky = other.transparentSky;
     yClipMin = other.yClipMin;
     yClipMax = other.yClipMax;
@@ -3431,4 +3434,14 @@ public void setTransmissivityCap(double value) {
     transmissivityCap = value;
     refresh();
   }
+
+  public boolean getPreviewParticleFog() {
+    return this.previewParticleFog;
+  }
+
+  public void setPreviewParticleFog(boolean value) {
+    this.previewParticleFog = value;
+    PersistentSettings.setPreviewParticleFog(value);
+    refresh();
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
index 3056a473e8..be3ce2774b 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
@@ -1,33 +1,29 @@
 package se.llbit.chunky.renderer.scene;
 
 import org.apache.commons.math3.util.FastMath;
-import se.llbit.chunky.world.material.ParticleFogMaterial;
+import se.llbit.json.JsonObject;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
 
 import java.util.Random;
 
 public class SphericalFogVolume extends FogVolume {
-  private Vector3 center;
-  private double radius;
+  private static final double DEFAULT_X = 0;
+  private static final double DEFAULT_Y = 100;
+  private static final double DEFAULT_Z = 0;
+  private static final double DEFAULT_RADIUS = 10;
+  private Sphere sphere;
 
   @Override
   public boolean intersect(Ray ray, Scene scene, Random random) {
     double distance;
     double fogPenetrated = -Math.log(1 - random.nextDouble());
     double fogDistance = fogPenetrated / density;
-    Vector3 o = new Vector3(ray.o);
-    Vector3 transformedCenter = new Vector3(center.x + -scene.origin.x, center.y + -scene.origin.y, center.z + -scene.origin.z);
-    Vector3 centerFromRayOrigin = new Vector3(transformedCenter);
-    centerFromRayOrigin.sub(o);
-    double rayDistanceFromCenter = centerFromRayOrigin.length();
-    if (rayDistanceFromCenter > radius) {
-      o.scaleAdd(rayDistanceFromCenter, ray.d);
-      o.sub(transformedCenter);
-      double distanceOfPointClosestToCenter = o.length();
-      if (distanceOfPointClosestToCenter <= radius) {
-        distance = distanceOfPointClosestToCenter;
-        distance -= FastMath.sqrt(FastMath.pow(radius, 2) - FastMath.pow(distanceOfPointClosestToCenter, 2));
+    Sphere sphereTranslated = sphere.getTranslated(-scene.origin.x, -scene.origin.y, -scene.origin.z);
+    if (!sphereTranslated.isInside(ray.o)) {
+      Ray test = new Ray(ray);
+      if (sphereTranslated.intersect(test)) {
+        distance = test.t;
         distance += fogDistance;
       } else {
         return false;
@@ -35,10 +31,13 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     } else {
       distance = fogDistance;
     }
-    if (distance > ray.t) {
+    if (distance >= ray.t) {
       return false;
     }
-    if (distance <= radius) {
+
+    Vector3 o = new Vector3(ray.o);
+    o.scaleAdd(distance, ray.d);
+    if (sphereTranslated.isInside(o)) {
       ray.t = distance;
       setRandomNormal(ray, random);
       setRayMaterialAndColor(ray);
@@ -49,25 +48,110 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
   }
 
   public Vector3 getCenter() {
-    return this.center;
+    return new Vector3(this.sphere.center);
+  }
+
+  public void setCenter(Vector3 center) {
+    this.sphere = new Sphere(center, this.sphere.radius);
+  }
+
+  public void setCenterX(double value) {
+    setCenter(new Vector3(value, this.sphere.center.y, this.sphere.center.z));
+  }
+
+  public void setCenterY(double value) {
+    setCenter(new Vector3(this.sphere.center.x, value, this.sphere.center.z));
   }
 
-  public void setCenter(Vector3 value) {
-    this.center = new Vector3(value);
+  public void setCenterZ(double value) {
+    setCenter(new Vector3(this.sphere.center.x, this.sphere.center.y, value));
   }
 
+
   public double getRadius() {
-    return this.radius;
+    return this.sphere.radius;
   }
 
   public void setRadius(double value) {
-    this.radius = value;
+    this.sphere = new Sphere(this.sphere.center, value);
   }
 
   public SphericalFogVolume(Vector3 color, double density, Vector3 center, double radius) {
-    this.center = center;
-    this.radius = radius;
-    this.color = color;
+    type = FogVolumeType.SPHERE;
+    this.sphere = new Sphere(new Vector3(center), radius);
+    this.color = new Vector3(color);
     this.density = density;
   }
+
+  public SphericalFogVolume(Vector3 color, double density) {
+    this(color, density, new Vector3(DEFAULT_X, DEFAULT_Y, DEFAULT_Z), DEFAULT_RADIUS);
+  }
+
+  @Override
+  public JsonObject volumeSpecificPropertiesToJson() {
+    JsonObject properties = new JsonObject();
+    JsonObject position = new JsonObject();
+    position.add("x", this.sphere.center.x);
+    position.add("y", this.sphere.center.y);
+    position.add("z", this.sphere.center.z);
+    properties.add("position", position);
+    properties.add("radius", this.sphere.radius);
+    return properties;
+  }
+
+  @Override
+  public void importVolumeSpecificProperties(JsonObject json) {
+    JsonObject position = json.get("position").object();
+    double x = position.get("x").doubleValue(this.sphere.center.x);
+    double y = position.get("y").doubleValue(this.sphere.center.y);
+    double z = position.get("z").doubleValue(this.sphere.center.z);
+    double radius = json.get("radius").doubleValue(this.sphere.radius);
+    this.sphere = new Sphere(new Vector3(x, y, z), radius);
+  }
+
+  // FogVolume-specific sphere implementation.
+  private static class Sphere {
+    double radius;
+    Vector3 center;
+
+    Sphere(Vector3 center, double radius) {
+      this.center = new Vector3(center);
+      this.radius = radius;
+    }
+
+    boolean isInside(Vector3 point) {
+      double distance = new Vector3(center.x - point.x, center.y - point.y, center.z - point.z).length();
+      return distance <= radius;
+    }
+
+    boolean intersect(Ray ray) {
+      Vector3 rayOrigin = new Vector3(ray.o);
+      Vector3 rayDirection = new Vector3(ray.d);
+
+      double t = rayDirection.dot(new Vector3(center.x - rayOrigin.x, center.y - rayOrigin.y, center.z - rayOrigin.z));
+      if (t < 0) {
+        return false;
+      }
+
+      Vector3 tPoint = new Vector3(rayOrigin);
+      tPoint.scaleAdd(t, rayDirection);
+
+      double tCenterDistance = new Vector3(center.x - tPoint.x, center.y - tPoint.y, center.z - tPoint.z).length();
+
+      if (isInside(tPoint)) {
+        double x = FastMath.sqrt(radius * radius - tCenterDistance * tCenterDistance);
+        double t1 = t - x;
+        double t2 = t + x;
+        if (t1 >= 0) {
+          ray.t = t1;
+          return true;
+        }
+      }
+      return false;
+    }
+
+    Sphere getTranslated(double x, double y, double z) {
+      return new Sphere(new Vector3(center.x + x, center.y + y, center.z + z), this.radius);
+    }
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/ui/controller/RenderControlsFxController.java b/chunky/src/java/se/llbit/chunky/ui/controller/RenderControlsFxController.java
index d7b4bfa7c4..78b3f0c158 100644
--- a/chunky/src/java/se/llbit/chunky/ui/controller/RenderControlsFxController.java
+++ b/chunky/src/java/se/llbit/chunky/ui/controller/RenderControlsFxController.java
@@ -98,6 +98,7 @@ private void buildTabs() {
       tabs.add(new GeneralTab());
       tabs.add(new LightingTab());
       tabs.add(new SkyTab());
+      tabs.add(new FogTab());
       tabs.add(new WaterTab());
       tabs.add(new CameraTab());
       tabs.add(new EntitiesTab());
diff --git a/chunky/src/java/se/llbit/chunky/ui/dialogs/FogVolumeTypeSelectorDialog.java b/chunky/src/java/se/llbit/chunky/ui/dialogs/FogVolumeTypeSelectorDialog.java
new file mode 100644
index 0000000000..46dc73d41a
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/ui/dialogs/FogVolumeTypeSelectorDialog.java
@@ -0,0 +1,32 @@
+package se.llbit.chunky.ui.dialogs;
+
+import javafx.geometry.Insets;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.ChoiceBox;
+import javafx.scene.control.Dialog;
+import javafx.scene.control.DialogPane;
+import javafx.scene.layout.VBox;
+import se.llbit.chunky.renderer.scene.FogVolumeType;
+
+public class FogVolumeTypeSelectorDialog extends Dialog<ButtonType> {
+  protected ChoiceBox<FogVolumeType> choiceBox = new ChoiceBox<>();
+
+  public FogVolumeTypeSelectorDialog() {
+    this.setTitle("Select fog volume type");
+
+    DialogPane dialogPane = this.getDialogPane();
+    VBox vBox = new VBox();
+
+    choiceBox.getItems().addAll(FogVolumeType.values());
+
+    vBox.getChildren().add(choiceBox);
+    vBox.setPadding(new Insets(10));
+
+    dialogPane.setContent(vBox);
+    dialogPane.getButtonTypes().addAll(ButtonType.OK, ButtonType.CANCEL);
+  }
+
+  public FogVolumeType getType() {
+    return choiceBox.getSelectionModel().getSelectedItem();
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/settings/UniformFogSettings.java b/chunky/src/java/se/llbit/chunky/ui/render/settings/UniformFogSettings.java
index bd7afd9492..1780796b02 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/settings/UniformFogSettings.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/settings/UniformFogSettings.java
@@ -51,7 +51,7 @@ public UniformFogSettings() throws IOException {
 
   @Override public void initialize(URL location, ResourceBundle resources) {
     fogDensity.setTooltip("Fog thickness. Set to 0 to disable volumetric fog effect.");
-    fogDensity.setRange(0, 1);
+    fogDensity.setRange(0.000001, 1);
     fogDensity.setMaximumFractionDigits(6);
     fogDensity.makeLogarithmic();
     fogDensity.clampMin();
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java
index 8dc587d111..df6e311745 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java
@@ -69,6 +69,7 @@ public class AdvancedTab extends ScrollPane implements RenderControlsTab, Initia
   @FXML private CheckBox shutdown;
   @FXML private CheckBox fastFog;
   @FXML private CheckBox fancierTranslucency;
+  @FXML private CheckBox previewParticleFog;
   @FXML private DoubleAdjuster transmissivityCap;
   @FXML private IntegerAdjuster cacheResolution;
   @FXML private DoubleAdjuster animationTime;
@@ -163,6 +164,12 @@ public PictureExportFormat fromString(String string) {
         transmissivityCap.setVisible(newValue);
         transmissivityCap.setManaged(newValue);
       });
+
+    previewParticleFog.setTooltip(new Tooltip("Render particle fog in the render preview."));
+    previewParticleFog.selectedProperty().addListener((observer, oldValue, newValue) ->
+      scene.setPreviewParticleFog(newValue)
+    );
+
     boolean tcapVisible = scene != null && scene.getFancierTranslucency();
     transmissivityCap.setVisible(tcapVisible);
     transmissivityCap.setManaged(tcapVisible);
@@ -334,6 +341,7 @@ public void update(Scene scene) {
     outputMode.getSelectionModel().select(scene.getOutputMode());
     fastFog.setSelected(scene.fog.fastFog());
     fancierTranslucency.setSelected(scene.getFancierTranslucency());
+    previewParticleFog.setSelected(scene.getPreviewParticleFog());
     transmissivityCap.set(scene.getTransmissivityCap());
     renderThreads.set(PersistentSettings.getNumThreads());
     cpuLoad.set(PersistentSettings.getCPULoad());
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
new file mode 100644
index 0000000000..26f69c30c0
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
@@ -0,0 +1,505 @@
+/* Copyright (c) 2016 - 2021 Jesper Öqvist <jesper@llbit.se>
+ * Copyright (c) 2016 - 2021 Chunky contributors
+ *
+ * This file is part of Chunky.
+ *
+ * Chunky is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chunky is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with Chunky.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package se.llbit.chunky.ui.render.tabs;
+
+import javafx.beans.property.ReadOnlyStringWrapper;
+import javafx.fxml.FXML;
+import javafx.fxml.FXMLLoader;
+import javafx.fxml.Initializable;
+import javafx.scene.Node;
+import javafx.scene.control.*;
+import javafx.scene.layout.*;
+import se.llbit.chunky.renderer.scene.*;
+import se.llbit.chunky.ui.DoubleAdjuster;
+import se.llbit.chunky.ui.DoubleTextField;
+import se.llbit.chunky.ui.controller.RenderControlsFxController;
+import se.llbit.chunky.ui.dialogs.FogVolumeTypeSelectorDialog;
+import se.llbit.chunky.ui.elements.TextFieldLabelWrapper;
+import se.llbit.chunky.ui.render.RenderControlsTab;
+import se.llbit.chunky.ui.render.settings.LayeredFogSettings;
+import se.llbit.chunky.ui.render.settings.UniformFogSettings;
+import se.llbit.fx.LuxColorPicker;
+import se.llbit.math.AABB;
+import se.llbit.math.ColorUtil;
+import se.llbit.math.Vector3;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.ResourceBundle;
+
+public class FogTab extends ScrollPane implements RenderControlsTab, Initializable {
+  private Scene scene;
+
+  private static class FogVolumeData {
+    final String type;
+
+    FogVolumeData(FogVolume fogVolume) {
+      this.type = fogVolume.getType().name();
+    }
+  }
+
+  @FXML private ComboBox<FogMode> fogMode;
+  @FXML private TitledPane fogDetailsPane;
+  @FXML private VBox fogDetailsBox;
+  @FXML private TableView<FogVolumeData> fogVolumeTable;
+  @FXML private TableColumn<FogVolumeData, String> typeCol;
+  @FXML private Button addVolume;
+  @FXML private Button removeVolume;
+  @FXML private VBox volumeSpecificControls;
+
+  private final UniformFogSettings uniformFogSettings = new UniformFogSettings();
+  private final LayeredFogSettings layeredFogSettings = new LayeredFogSettings();
+  private final FogVolumeTypeSelectorDialog fogVolumeTypeSelectorDialog = new FogVolumeTypeSelectorDialog();
+
+  public FogTab() throws IOException {
+    FXMLLoader loader = new FXMLLoader(getClass().getResource("FogTab.fxml"));
+    loader.setRoot(this);
+    loader.setController(this);
+    loader.load();
+  }
+
+  @Override public void setController(RenderControlsFxController controller) {
+    scene = controller.getRenderController().getSceneManager().getScene();
+    uniformFogSettings.setRenderController(controller.getRenderController());
+    layeredFogSettings.setRenderController(controller.getRenderController());
+  }
+
+  @Override public void initialize(URL location, ResourceBundle resources) {
+    fogMode.getItems().addAll(FogMode.values());
+    fogMode.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
+      scene.setFogMode(newValue);
+      switch (newValue) {
+        case NONE: {
+          fogDetailsBox.getChildren().setAll(new Label("Selected mode has no settings."));
+          break;
+        }
+        case UNIFORM: {
+          fogDetailsBox.getChildren().setAll(uniformFogSettings);
+          break;
+        }
+        case LAYERED: {
+          fogDetailsBox.getChildren().setAll(layeredFogSettings);
+          break;
+        }
+      }
+      fogDetailsPane.setExpanded(true);
+    });
+
+    fogVolumeTable.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
+      updateControls();
+    });
+    typeCol.setCellValueFactory(data -> new ReadOnlyStringWrapper(data.getValue().type));
+    typeCol.setSortable(false);
+
+    addVolume.setOnAction(e -> {
+      if (fogVolumeTypeSelectorDialog.showAndWait().orElse(ButtonType.CANCEL) == ButtonType.OK) {
+        FogVolumeType type = fogVolumeTypeSelectorDialog.getType();
+        scene.fog.addVolume(type);
+        rebuildList();
+        fogVolumeTable.getSelectionModel().selectLast();
+      }
+    });
+
+    removeVolume.setOnAction(e -> {
+      int index = fogVolumeTable.getSelectionModel().getSelectedIndex();
+      scene.fog.removeVolume(index);
+      rebuildList();
+    });
+  }
+
+  @Override public void update(Scene scene) {
+    fogMode.getSelectionModel().select(scene.fog.getFogMode());
+    uniformFogSettings.update(scene);
+    layeredFogSettings.update(scene);
+    rebuildList();
+  }
+
+  private void rebuildList() {
+    fogVolumeTable.getSelectionModel().clearSelection();
+    fogVolumeTable.getItems().clear();
+    for (FogVolume fogVolume : scene.fog.getFogVolumes()) {
+      FogVolumeData fogVolumeData = new FogVolumeData(fogVolume);
+      fogVolumeTable.getItems().add(fogVolumeData);
+    }
+  }
+
+  private void updateControls() {
+    volumeSpecificControls.getChildren().clear();
+    if (!fogVolumeTable.getSelectionModel().isEmpty()) {
+      int index = fogVolumeTable.getSelectionModel().getSelectedIndex();
+      FogVolume fogVolume = scene.fog.getFogVolumes().get(index);
+
+      DoubleAdjuster density = new DoubleAdjuster();
+      density.setName("Fog density");
+      density.setTooltip("Fog thickness");
+      density.setMaximumFractionDigits(6);
+      density.setRange(0.000001, 1);
+      density.clampMin();
+      density.set(fogVolume.getDensity());
+      density.onValueChange(value -> {
+        fogVolume.setDensity(value);
+        scene.refresh();
+      });
+
+      HBox fogColorPickerBox = new HBox();
+      fogColorPickerBox.setSpacing(10);
+      Label label = new Label("Fog color:");
+      LuxColorPicker luxColorPicker = new LuxColorPicker();
+      luxColorPicker.setColor(ColorUtil.toFx(fogVolume.getColor()));
+      luxColorPicker.colorProperty().addListener(
+        (observable, oldValue, newValue) -> {
+          fogVolume.setColor(ColorUtil.fromFx(newValue));
+          scene.refresh();
+        });
+      fogColorPickerBox.getChildren().addAll(label, luxColorPicker);
+
+      DoubleAdjuster emittance = new DoubleAdjuster();
+      emittance.setName("Emittance");
+      emittance.setRange(0, 100);
+      emittance.clampMin();
+      emittance.set(fogVolume.getEmittance());
+      emittance.onValueChange(value -> {
+        fogVolume.setEmittance(value.floatValue());
+        scene.refresh();
+      });
+
+      DoubleAdjuster specular = new DoubleAdjuster();
+      specular.setName("Specular");
+      specular.setRange(0, 1);
+      specular.clampBoth();
+      specular.set(fogVolume.getSpecular());
+      specular.onValueChange(value -> {
+        fogVolume.setSpecular(value.floatValue());
+        scene.refresh();
+      });
+
+      DoubleAdjuster smoothness = new DoubleAdjuster();
+      smoothness.setName("Smoothness");
+      smoothness.setRange(0, 1);
+      smoothness.clampBoth();
+      smoothness.set(fogVolume.getSmoothness());
+      smoothness.onValueChange(value -> {
+        fogVolume.setSmoothness(value.floatValue());
+        scene.refresh();
+      });
+
+      DoubleAdjuster ior = new DoubleAdjuster();
+      ior.setName("IoR");
+      ior.setRange(0, 5);
+      ior.set(fogVolume.getIor());
+      ior.onValueChange(value -> {
+        fogVolume.setIor(value.floatValue());
+        scene.refresh();
+      });
+
+      DoubleAdjuster metalness = new DoubleAdjuster();
+      metalness.setName("Metalness");
+      metalness.setRange(0, 1);
+      metalness.clampBoth();
+      metalness.set(fogVolume.getMetalness());
+      metalness.onValueChange(value -> {
+        fogVolume.setMetalness(value.floatValue());
+        scene.refresh();
+      });
+
+      Separator separator = new Separator();
+
+      volumeSpecificControls.getChildren().addAll(
+        density,
+        fogColorPickerBox,
+        emittance,
+        specular,
+        smoothness,
+        ior,
+        metalness,
+        separator
+      );
+
+      ColumnConstraints labelConstraints = new ColumnConstraints();
+      labelConstraints.setHgrow(Priority.NEVER);
+      labelConstraints.setPrefWidth(90);
+      ColumnConstraints posFieldConstraints = new ColumnConstraints();
+      posFieldConstraints.setMinWidth(20);
+      posFieldConstraints.setPrefWidth(90);
+
+      switch (fogVolume.getType()) {
+        case EXPONENTIAL: {
+          ExponentialFogVolume exponentialFogVolume = (ExponentialFogVolume) fogVolume;
+          DoubleAdjuster scaleHeight = new DoubleAdjuster();
+          scaleHeight.setName("Height scale");
+          scaleHeight.setTooltip("Scales the vertical distribution of the fog");
+          scaleHeight.setRange(1, 50);
+          scaleHeight.set(exponentialFogVolume.getScaleHeight());
+          scaleHeight.onValueChange(value -> {
+            exponentialFogVolume.setScaleHeight(value);
+            scene.refresh();
+          });
+
+          DoubleAdjuster yOffset = new DoubleAdjuster();
+          yOffset.setName("Y-offset");
+          yOffset.setTooltip("Y-offset (altitude) of the distribution");
+          yOffset.setRange(-100, 100);
+          yOffset.set(exponentialFogVolume.getYOffset());
+          yOffset.onValueChange(value -> {
+            exponentialFogVolume.setYOffset(value);
+            scene.refresh();
+          });
+
+          volumeSpecificControls.getChildren().addAll(scaleHeight, yOffset);
+          break;
+        }
+        case LAYER: {
+          LayerFogVolume layerFogVolume = (LayerFogVolume) fogVolume;
+          DoubleAdjuster layerBreadth = new DoubleAdjuster();
+          layerBreadth.setName("Layer thickness");
+          layerBreadth.setTooltip("Scales the vertical distribution of the fog");
+          layerBreadth.setRange(0.001, 100);
+          layerBreadth.set(layerFogVolume.getLayerBreadth());
+          layerBreadth.clampMin();
+          layerBreadth.onValueChange(value -> {
+            layerFogVolume.setLayerBreadth(value);
+            scene.refresh();
+          });
+
+          DoubleAdjuster yOffset = new DoubleAdjuster();
+          yOffset.setName("Layer altitude");
+          yOffset.setTooltip("Y-coordinate (altitude) of the fog layer");
+          yOffset.setRange(-64, 320);
+          yOffset.set(layerFogVolume.getYOffset());
+          yOffset.onValueChange(value -> {
+            layerFogVolume.setYOffset(value);
+            scene.refresh();
+          });
+
+          volumeSpecificControls.getChildren().addAll(layerBreadth, yOffset);
+          break;
+        }
+        case SPHERE: {
+          SphericalFogVolume sphericalFogVolume = (SphericalFogVolume) fogVolume;
+
+          DoubleTextField posX = new DoubleTextField();
+          DoubleTextField posY = new DoubleTextField();
+          DoubleTextField posZ = new DoubleTextField();
+
+          posX.setTooltip(new Tooltip("Sphere x-coordinate (east/west)"));
+          posY.setTooltip(new Tooltip("Sphere y-coordinate (up/down)"));
+          posZ.setTooltip(new Tooltip("Sphere z-coordinate (south/north)"));
+
+          Vector3 center = sphericalFogVolume.getCenter();
+          posX.valueProperty().setValue(center.x);
+          posY.valueProperty().setValue(center.y);
+          posZ.valueProperty().setValue(center.z);
+
+          posX.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              sphericalFogVolume.setCenterX(newValue.doubleValue());
+              scene.refresh();
+            });
+          posY.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              sphericalFogVolume.setCenterY(newValue.doubleValue());
+              scene.refresh();
+            });
+          posZ.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              sphericalFogVolume.setCenterZ(newValue.doubleValue());
+              scene.refresh();
+            });
+
+          TextFieldLabelWrapper xText = new TextFieldLabelWrapper();
+          TextFieldLabelWrapper yText = new TextFieldLabelWrapper();
+          TextFieldLabelWrapper zText = new TextFieldLabelWrapper();
+
+          xText.setTextField(posX);
+          yText.setTextField(posY);
+          zText.setTextField(posZ);
+
+          xText.setLabelText("x:");
+          yText.setLabelText("y:");
+          zText.setLabelText("z:");
+
+          GridPane gridPane = new GridPane();
+          gridPane.setHgap(6);
+          gridPane.getColumnConstraints().addAll(
+            labelConstraints,
+            posFieldConstraints,
+            posFieldConstraints,
+            posFieldConstraints
+          );
+          gridPane.addRow(0, new Label("Center:"), xText, yText, zText);
+
+          DoubleAdjuster radius = new DoubleAdjuster();
+          radius.setName("Radius");
+          radius.setTooltip("Radius of the sphere");
+          radius.setRange(0.001, 100);
+          radius.set(sphericalFogVolume.getRadius());
+          radius.clampMin();
+          radius.onValueChange(value -> {
+            sphericalFogVolume.setRadius(value);
+            scene.refresh();
+          });
+
+          volumeSpecificControls.getChildren().addAll(gridPane, radius);
+          break;
+        }
+        case CUBOID: {
+          CuboidFogVolume cuboidFogVolume = (CuboidFogVolume) fogVolume;
+
+          DoubleTextField x1 = new DoubleTextField();
+          DoubleTextField y1 = new DoubleTextField();
+          DoubleTextField z1 = new DoubleTextField();
+          DoubleTextField x2 = new DoubleTextField();
+          DoubleTextField y2 = new DoubleTextField();
+          DoubleTextField z2 = new DoubleTextField();
+
+          x1.setTooltip(new Tooltip("X-coordinate (east/west) of first corner"));
+          y1.setTooltip(new Tooltip("Y-coordinate (up/down) of first corner"));
+          z1.setTooltip(new Tooltip("Z-coordinate (south/north) of first corner"));
+          x2.setTooltip(new Tooltip("X-coordinate (east/west) of second corner"));
+          y2.setTooltip(new Tooltip("Y-coordinate (up/down) of second corner"));
+          z2.setTooltip(new Tooltip("Z-coordinate (south/north) of second corner"));
+
+          AABB bounds = cuboidFogVolume.getBounds();
+          x1.valueProperty().setValue(bounds.xmin);
+          y1.valueProperty().setValue(bounds.ymin);
+          z1.valueProperty().setValue(bounds.zmin);
+          x2.valueProperty().setValue(bounds.xmax);
+          y2.valueProperty().setValue(bounds.ymax);
+          z2.valueProperty().setValue(bounds.zmax);
+
+          x1.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              cuboidFogVolume.setBounds(
+                Math.min(newValue.doubleValue(), x2.valueProperty().doubleValue()),
+                Math.max(newValue.doubleValue(), x2.valueProperty().doubleValue()),
+                Math.min(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.max(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.min(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue()),
+                Math.max(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue())
+              );
+              scene.refresh();
+            });
+          y1.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              cuboidFogVolume.setBounds(
+                Math.min(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.max(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.min(newValue.doubleValue(), y2.valueProperty().doubleValue()),
+                Math.max(newValue.doubleValue(), y2.valueProperty().doubleValue()),
+                Math.min(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue()),
+                Math.max(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue())
+              );
+              scene.refresh();
+            });
+          z1.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              cuboidFogVolume.setBounds(
+                Math.min(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.max(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.min(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.max(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.min(newValue.doubleValue(), z2.valueProperty().doubleValue()),
+                Math.max(newValue.doubleValue(), z2.valueProperty().doubleValue())
+              );
+              scene.refresh();
+            });
+          x2.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              cuboidFogVolume.setBounds(
+                Math.min(x1.valueProperty().doubleValue(), newValue.doubleValue()),
+                Math.max(x1.valueProperty().doubleValue(), newValue.doubleValue()),
+                Math.min(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.max(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.min(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue()),
+                Math.max(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue())
+              );
+              scene.refresh();
+            });
+          y2.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              cuboidFogVolume.setBounds(
+                Math.min(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.max(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.min(y1.valueProperty().doubleValue(), newValue.doubleValue()),
+                Math.max(y1.valueProperty().doubleValue(), newValue.doubleValue()),
+                Math.min(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue()),
+                Math.max(z1.valueProperty().doubleValue(), z2.valueProperty().doubleValue())
+              );
+              scene.refresh();
+            });
+          z2.valueProperty().addListener(
+            (observable, oldValue, newValue) -> {
+              cuboidFogVolume.setBounds(
+                Math.min(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.max(x1.valueProperty().doubleValue(), x2.valueProperty().doubleValue()),
+                Math.min(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.max(y1.valueProperty().doubleValue(), y2.valueProperty().doubleValue()),
+                Math.min(z1.valueProperty().doubleValue(), newValue.doubleValue()),
+                Math.max(z1.valueProperty().doubleValue(), newValue.doubleValue())
+              );
+              scene.refresh();
+            });
+
+          TextFieldLabelWrapper x1Text = new TextFieldLabelWrapper();
+          TextFieldLabelWrapper y1Text = new TextFieldLabelWrapper();
+          TextFieldLabelWrapper z1Text = new TextFieldLabelWrapper();
+          TextFieldLabelWrapper x2Text = new TextFieldLabelWrapper();
+          TextFieldLabelWrapper y2Text = new TextFieldLabelWrapper();
+          TextFieldLabelWrapper z2Text = new TextFieldLabelWrapper();
+
+          x1Text.setTextField(x1);
+          y1Text.setTextField(y1);
+          z1Text.setTextField(z1);
+          x2Text.setTextField(x2);
+          y2Text.setTextField(y2);
+          z2Text.setTextField(z2);
+
+          x1Text.setLabelText("x:");
+          y1Text.setLabelText("y:");
+          z1Text.setLabelText("z:");
+          x2Text.setLabelText("x:");
+          y2Text.setLabelText("y:");
+          z2Text.setLabelText("z:");
+
+          GridPane gridPane = new GridPane();
+          gridPane.setHgap(6);
+          gridPane.setVgap(10);
+          gridPane.getColumnConstraints().addAll(
+            labelConstraints,
+            posFieldConstraints,
+            posFieldConstraints,
+            posFieldConstraints
+          );
+          gridPane.addRow(0, new Label("Corner 1:"), x1Text, y1Text, z1Text);
+          gridPane.addRow(1, new Label("Corner 2:"), x2Text, y2Text, z2Text);
+
+          volumeSpecificControls.getChildren().addAll(gridPane);
+          break;
+        }
+      }
+    }
+  }
+
+  @Override public String getTabTitle() {
+    return "Fog";
+  }
+
+  @Override public Node getTabContent() {
+    return this;
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
index 4bed610878..b947a5eae4 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
@@ -27,7 +27,6 @@
 import javafx.scene.Node;
 import javafx.scene.control.CheckBox;
 import javafx.scene.control.ChoiceBox;
-import javafx.scene.control.ComboBox;
 import javafx.scene.control.Label;
 import javafx.scene.control.ScrollPane;
 import javafx.scene.control.TitledPane;
@@ -35,7 +34,6 @@
 import javafx.scene.layout.HBox;
 import javafx.scene.layout.VBox;
 import javafx.util.StringConverter;
-import se.llbit.chunky.renderer.scene.FogMode;
 import se.llbit.chunky.renderer.scene.Scene;
 import se.llbit.chunky.renderer.scene.SimulatedSky;
 import se.llbit.chunky.renderer.scene.Sky;
@@ -43,8 +41,6 @@
 import se.llbit.chunky.ui.elements.GradientEditor;
 import se.llbit.chunky.ui.controller.RenderControlsFxController;
 import se.llbit.chunky.ui.render.RenderControlsTab;
-import se.llbit.chunky.ui.render.settings.LayeredFogSettings;
-import se.llbit.chunky.ui.render.settings.UniformFogSettings;
 import se.llbit.chunky.ui.render.settings.SkyboxSettings;
 import se.llbit.chunky.ui.render.settings.SkymapSettings;
 import se.llbit.fx.LuxColorPicker;
@@ -68,9 +64,6 @@ public class SkyTab extends ScrollPane implements RenderControlsTab, Initializab
   @FXML private DoubleAdjuster cloudX;
   @FXML private DoubleAdjuster cloudY;
   @FXML private DoubleAdjuster cloudZ;
-  @FXML private ComboBox<FogMode> fogMode;
-  @FXML private TitledPane fogDetailsPane;
-  @FXML private VBox fogDetailsBox;
   private final VBox simulatedSettings = new VBox();
   private DoubleAdjuster horizonOffset = new DoubleAdjuster();
   private ChoiceBox<SimulatedSky> simulatedSky = new ChoiceBox<>();
@@ -79,8 +72,6 @@ public class SkyTab extends ScrollPane implements RenderControlsTab, Initializab
   private final VBox colorEditor = new VBox(colorPicker);
   private final SkyboxSettings skyboxSettings = new SkyboxSettings();
   private final SkymapSettings skymapSettings = new SkymapSettings();
-  private final UniformFogSettings uniformFogSettings = new UniformFogSettings();
-  private final LayeredFogSettings layeredFogSettings = new LayeredFogSettings();
 
   private ChangeListener<? super javafx.scene.paint.Color> skyColorListener =
       (observable, oldValue, newValue) -> scene.sky().setColor(ColorUtil.fromFx(newValue));
@@ -100,8 +91,6 @@ public SkyTab() throws IOException {
     scene = controller.getRenderController().getSceneManager().getScene();
     skyboxSettings.setRenderController(controller.getRenderController());
     skymapSettings.setRenderController(controller.getRenderController());
-    uniformFogSettings.setRenderController(controller.getRenderController());
-    layeredFogSettings.setRenderController(controller.getRenderController());
   }
 
   @Override public void initialize(URL location, ResourceBundle resources) {
@@ -154,26 +143,6 @@ public SimulatedSky fromString(String string) {
     cloudZ.setRange(-256, 256);
     cloudZ.onValueChange(value -> scene.sky().setCloudZOffset(value));
 
-    fogMode.getItems().addAll(FogMode.values());
-    fogMode.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
-      scene.setFogMode(newValue);
-      switch (newValue) {
-        case NONE: {
-          fogDetailsBox.getChildren().setAll(new Label("Selected mode has no settings."));
-          break;
-        }
-        case UNIFORM: {
-          fogDetailsBox.getChildren().setAll(uniformFogSettings);
-          break;
-        }
-        case LAYERED: {
-          fogDetailsBox.getChildren().setAll(layeredFogSettings);
-          break;
-        }
-      }
-      fogDetailsPane.setExpanded(true);
-    });
-
     skyMode.setTooltip(new Tooltip("Set the type of sky to be used in the scene."));
     skyMode.getItems().addAll(Sky.SkyMode.values());
     skyMode.getSelectionModel().selectedItemProperty()
@@ -232,7 +201,6 @@ public SimulatedSky fromString(String string) {
     cloudX.set(scene.sky().cloudXOffset());
     cloudY.set(scene.sky().cloudYOffset());
     cloudZ.set(scene.sky().cloudZOffset());
-    fogMode.getSelectionModel().select(scene.fog.getFogMode());
     horizonOffset.set(scene.sky().getHorizonOffset());
     simulatedSky.setValue(scene.sky().getSimulatedSky());
     gradientEditor.setGradient(scene.sky().getGradient());
@@ -241,12 +209,10 @@ public SimulatedSky fromString(String string) {
     colorPicker.colorProperty().addListener(skyColorListener);
     skyboxSettings.update(scene);
     skymapSettings.update(scene);
-    uniformFogSettings.update(scene);
-    layeredFogSettings.update(scene);
   }
 
   @Override public String getTabTitle() {
-    return "Sky & Fog";
+    return "Sky";
   }
 
   @Override public Node getTabContent() {
diff --git a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
index 90331a73f6..f34613f649 100644
--- a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
+++ b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
@@ -20,7 +20,6 @@
 import se.llbit.chunky.entity.CalibratedSculkSensorAmethyst;
 import se.llbit.chunky.entity.Campfire;
 import se.llbit.chunky.world.material.CloudMaterial;
-import se.llbit.chunky.world.material.ParticleFogMaterial;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -32,7 +31,6 @@ public class ExtraMaterials {
 
   static {
     idMap.put("cloud", CloudMaterial.INSTANCE);
-    idMap.put("particle_fog", ParticleFogMaterial.INSTANCE);
     idMap.put("candle_flame", Candle.flameMaterial);
     idMap.put("campfire_flame", Campfire.flameMaterial);
     idMap.put("soul_campfire_flame", Campfire.soulFlameMaterial);
@@ -42,7 +40,6 @@ public class ExtraMaterials {
 
   public static void loadDefaultMaterialProperties() {
     CloudMaterial.INSTANCE.restoreDefaults();
-    ParticleFogMaterial.INSTANCE.restoreDefaults();
 
     Candle.flameMaterial.restoreDefaults();
     Candle.flameMaterial.emittance = 1.0f;
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml
index 6c9b960236..9d5474ce64 100644
--- a/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml
@@ -25,6 +25,7 @@
     <CheckBox fx:id="shutdown" mnemonicParsing="false" text="Shutdown computer when render completes" />
     <CheckBox fx:id="fastFog" mnemonicParsing="false" text="Fast fog" />
     <CheckBox fx:id="fancierTranslucency" mnemonicParsing="false" text="Fancier translucency" />
+    <CheckBox fx:id="previewParticleFog" mnemonicParsing="false" text="Preview particle fog" />
     <DoubleAdjuster fx:id="transmissivityCap" />
     <IntegerAdjuster fx:id="cacheResolution" />
     <DoubleAdjuster fx:id="animationTime" />
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml
new file mode 100644
index 0000000000..bedc1aafe0
--- /dev/null
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ComboBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.Separator?>
+<?import javafx.scene.control.TitledPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.control.ScrollPane?>
+
+<?import javafx.scene.control.TableView?>
+<?import javafx.scene.control.TableColumn?>
+<fx:root type="javafx.scene.control.ScrollPane" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1">
+  <VBox spacing="10.0">
+    <Label text="Fast fog settings" />
+    <HBox alignment="CENTER_LEFT" prefWidth="200.0" spacing="10.0">
+      <Label text="Fog mode:" />
+      <ComboBox fx:id="fogMode" prefWidth="150.0" />
+    </HBox>
+    <TitledPane fx:id="fogDetailsPane" animated="false" text="Fog settings">
+      <VBox.margin>
+        <Insets />
+      </VBox.margin>
+      <VBox fx:id="fogDetailsBox" spacing="10.0">
+        <padding>
+          <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
+        </padding>
+        <Label text="Selected mode has no settings." />
+      </VBox>
+    </TitledPane>
+    <Separator />
+    <Label text="Particle fog settings" />
+    <HBox alignment="CENTER_LEFT" prefWidth="200.0" spacing="10.0">
+      <Button fx:id="addVolume" mnemonicParsing="false" text="Add volume" />
+      <Button fx:id="removeVolume" mnemonicParsing="false" text="Remove volume" />
+    </HBox>
+    <TableView fx:id="fogVolumeTable" prefHeight="120.0">
+      <columns>
+        <TableColumn fx:id="typeCol" text="Volume type" prefWidth="200" />
+      </columns>
+    </TableView>
+    <VBox fx:id="volumeSpecificControls" spacing="10.0" VBox.vgrow="ALWAYS" maxWidth="400"/>
+    <padding>
+      <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
+    </padding>
+  </VBox>
+</fx:root>
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
index 97399d4cb4..2bc883708e 100644
--- a/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
@@ -3,16 +3,13 @@
 <?import javafx.geometry.Insets?>
 <?import javafx.scene.control.CheckBox?>
 <?import javafx.scene.control.ChoiceBox?>
-<?import javafx.scene.control.ComboBox?>
 <?import javafx.scene.control.Label?>
 <?import javafx.scene.control.Separator?>
 <?import javafx.scene.control.TitledPane?>
 <?import javafx.scene.layout.HBox?>
 <?import javafx.scene.layout.VBox?>
 <?import javafx.scene.control.ScrollPane?>
-<?import javafx.scene.text.Text?>
 <?import se.llbit.chunky.ui.DoubleAdjuster?>
-<?import se.llbit.fx.LuxColorPicker?>
 
 <fx:root type="javafx.scene.control.ScrollPane" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1">
   <VBox spacing="10.0">
@@ -38,22 +35,6 @@
     <DoubleAdjuster fx:id="cloudX" name="Cloud X" />
     <DoubleAdjuster fx:id="cloudY" name="Cloud Y" />
     <DoubleAdjuster fx:id="cloudZ" name="Cloud Z" />
-    <Separator />
-    <HBox alignment="CENTER_LEFT" prefWidth="200.0" spacing="10.0">
-      <Label text="Fog mode:" />
-      <ComboBox fx:id="fogMode" prefWidth="150.0" />
-    </HBox>
-    <TitledPane fx:id="fogDetailsPane" animated="false" text="Fog settings">
-      <VBox.margin>
-        <Insets />
-      </VBox.margin>
-      <VBox fx:id="fogDetailsBox" spacing="10.0">
-        <padding>
-          <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
-        </padding>
-        <Label text="Selected mode has no settings." />
-      </VBox>
-    </TitledPane>
     <padding>
       <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
     </padding>
diff --git a/lib/src/se/llbit/chunky/PersistentSettings.java b/lib/src/se/llbit/chunky/PersistentSettings.java
index 547ebe2556..13ee5126dd 100644
--- a/lib/src/se/llbit/chunky/PersistentSettings.java
+++ b/lib/src/se/llbit/chunky/PersistentSettings.java
@@ -656,4 +656,13 @@ public static void setTableSortConfig(String table, JsonArray config) {
     tables.get(table).asObject().set("sort", config);
     save();
   }
+
+  public static void setPreviewParticleFog(boolean value) {
+    settings.setBool("previewParticleFog", value);
+    save();
+  }
+
+  public static boolean getPreviewParticleFog() {
+    return settings.getBool("previewParticleFog", false);
+  }
 }

From 420b1192db8e50f813f98802bb5dd5c967922d42 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Sun, 8 Oct 2023 15:49:04 +0200
Subject: [PATCH 22/38] Implement anisotropy for particle fog

Includes changes from #1621.

Co-Authored-By: Justin Barker <46458276+JustinTimeCuber@users.noreply.github.com>
---
 .../se/llbit/chunky/chunk/BlockPalette.java   |  28 ++-
 .../renderer/scene/CuboidFogVolume.java       |   4 +
 .../renderer/scene/ExponentialFogVolume.java  |   5 +-
 .../chunky/renderer/scene/FogVolume.java      |  44 +---
 .../chunky/renderer/scene/LayerFogVolume.java |   5 +-
 .../chunky/renderer/scene/PathTracer.java     | 201 ++++++++++++++----
 .../renderer/scene/PreviewRayTracer.java      |   2 +-
 .../renderer/scene/SphericalFogVolume.java    |   4 +
 .../llbit/chunky/ui/render/tabs/FogTab.java   |  82 +++----
 .../java/se/llbit/chunky/world/Material.java  |   4 +
 chunky/src/java/se/llbit/math/Ray.java        |   7 -
 11 files changed, 234 insertions(+), 152 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/chunk/BlockPalette.java b/chunky/src/java/se/llbit/chunky/chunk/BlockPalette.java
index 9fc15279d2..b4bf968d8e 100644
--- a/chunky/src/java/se/llbit/chunky/chunk/BlockPalette.java
+++ b/chunky/src/java/se/llbit/chunky/chunk/BlockPalette.java
@@ -347,10 +347,10 @@ public static Map<String, Consumer<Block>> getDefaultMaterialProperties() {
       }
     });
     materialProperties.put("minecraft:torch", block -> {
-      block.emittance = 50.0f;
+      block.emittance = 1.0f;
     });
     materialProperties.put("minecraft:wall_torch", block -> {
-      block.emittance = 50.0f;
+      block.emittance = 1.0f;
     });
     materialProperties.put("minecraft:fire", block -> {
       block.emittance = 1.0f;
@@ -448,16 +448,16 @@ public static Map<String, Consumer<Block>> getDefaultMaterialProperties() {
       block.emittance = 0.6f;
     });
     materialProperties.put("minecraft:soul_fire_torch", block -> { // MC 20w06a-20w16a
-      block.emittance = 35.0f;
+      block.emittance = 0.6f;
     });
     materialProperties.put("minecraft:soul_torch", block -> { // MC >= 20w17a
-      block.emittance = 35.0f;
+      block.emittance = 0.6f;
     });
     materialProperties.put("minecraft:soul_fire_wall_torch", block -> { // MC 20w06a-20w16a
-      block.emittance = 35.0f;
+      block.emittance = 0.6f;
     });
     materialProperties.put("minecraft:soul_wall_torch", block -> { // MC >= 20w17a
-      block.emittance = 35.0f;
+      block.emittance = 0.6f;
     });
     materialProperties.put("minecraft:soul_fire", block -> {
       block.emittance = 0.6f;
@@ -523,16 +523,24 @@ public static Map<String, Consumer<Block>> getDefaultMaterialProperties() {
       }
     });
     materialProperties.put("minecraft:small_amethyst_bud", block -> {
-      block.emittance = 1.0f / 15f;
+      if (block instanceof AmethystCluster && ((AmethystCluster) block).isLit()) {
+        block.emittance = 1.0f / 15f;
+      }
     });
     materialProperties.put("minecraft:medium_amethyst_bud", block -> {
-      block.emittance = 1.0f / 15f * 2;
+      if (block instanceof AmethystCluster && ((AmethystCluster) block).isLit()) {
+        block.emittance = 1.0f / 15f * 2;
+      }
     });
     materialProperties.put("minecraft:large_amethyst_bud", block -> {
-      block.emittance = 1.0f / 15f * 4;
+      if (block instanceof AmethystCluster && ((AmethystCluster) block).isLit()) {
+        block.emittance = 1.0f / 15f * 4;
+      }
     });
     materialProperties.put("minecraft:amethyst_cluster", block -> {
-      block.emittance = 1.0f / 15f * 5;
+      if (block instanceof AmethystCluster && ((AmethystCluster) block).isLit()) {
+        block.emittance = 1.0f / 15f * 5;
+      }
     });
     materialProperties.put("minecraft:tinted_glass", glassConfig);
     materialProperties.put("minecraft:sculk_sensor", block -> {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
index 8156766a0a..7eacf5ba9c 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
@@ -43,8 +43,12 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     o.scaleAdd(distance, ray.d);
     if (aabbTranslated.inside(o)) {
       ray.t = distance;
+      // pick a random normal vector based on a spherical particle.
+      // This is done only to prevent fog from looking ugly in the render preview and
+      // should have no effect on the path-traced render.
       setRandomNormal(ray, random);
       setRayMaterialAndColor(ray);
+      ray.specular = false;
       return true;
     } else {
       return false;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
index bfa7473a0d..f379139c7e 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
@@ -42,9 +42,12 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
       return false;
     }
     ray.t = dist;
-    // pick a random normal vector based on a spherical particle
+    // pick a random normal vector based on a spherical particle.
+    // This is done only to prevent fog from looking ugly in the render preview and
+    // should have no effect on the path-traced render.
     setRandomNormal(ray, random);
     setRayMaterialAndColor(ray);
+    ray.specular = false;
     return true;
   }
 
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
index 40059f0d62..dcdfb97d5c 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
@@ -54,36 +54,12 @@ public void setEmittance(float value) {
     this.material.emittance = value;
   }
 
-  public double getSpecular() {
-    return this.material.specular;
+  public double getAnisotropy() {
+    return this.material.anisotropy;
   }
 
-  public void setSpecular(float value) {
-    this.material.specular = value;
-  }
-
-  public double getSmoothness() {
-    return this.material.getPerceptualSmoothness();
-  }
-
-  public void setSmoothness(double value) {
-    this.material.setPerceptualSmoothness(value);
-  }
-
-  public double getIor() {
-    return this.material.ior;
-  }
-
-  public void setIor(float value) {
-    this.material.ior = value;
-  }
-
-  public double getMetalness() {
-    return this.material.metalness;
-  }
-
-  public void setMetalness(float value) {
-    this.material.metalness = value;
+  public void setAnisotropy(float value) {
+    this.material.anisotropy = value;
   }
 
   public void setDensity(double value) {
@@ -95,7 +71,7 @@ public double getDensity() {
   }
 
   public void setColor(Vector3 value) {
-    this.color = new Vector3(value);
+    this.color.set(value);
   }
 
   public Vector3 getColor() {
@@ -125,10 +101,7 @@ public JsonObject toJson() {
   protected JsonObject materialPropertiesToJson() {
     JsonObject materialProperties = new JsonObject();
     materialProperties.add("emittance", material.emittance);
-    materialProperties.add("specular", material.specular);
-    materialProperties.add("roughness", material.roughness);
-    materialProperties.add("ior", material.ior);
-    materialProperties.add("metalness", material.metalness);
+    materialProperties.add("anisotropy", material.anisotropy);
     return materialProperties;
   }
 
@@ -147,9 +120,6 @@ public void importFromJson(JsonObject json) {
 
   protected void importMaterialProperties(JsonObject json) {
     material.emittance = json.get("emittance").floatValue(material.emittance);
-    material.specular = json.get("specular").floatValue(material.specular);
-    material.roughness = json.get("roughness").floatValue(material.roughness);
-    material.ior = json.get("ior").floatValue(material.ior);
-    material.metalness = json.get("metalness").floatValue(material.metalness);
+    material.anisotropy = json.get("anisotropy").floatValue(material.anisotropy);
   }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
index 8bc62a4d6c..9db6e76a5b 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
@@ -41,9 +41,12 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
       return false;
     }
     ray.t = dist;
-    // pick a random normal vector based on a spherical particle
+    // pick a random normal vector based on a spherical particle.
+    // This is done only to prevent fog from looking ugly in the render preview and
+    // should have no effect on the path-traced render.
     setRandomNormal(ray, random);
     setRayMaterialAndColor(ray);
+    ray.specular = false;
     return true;
   }
 
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index ae7fd6578b..85080366c4 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -23,6 +23,7 @@
 import se.llbit.chunky.renderer.EmitterSamplingStrategy;
 import se.llbit.chunky.renderer.WorkerState;
 import se.llbit.chunky.world.Material;
+import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.math.*;
 
 import java.util.List;
@@ -45,7 +46,7 @@ public class PathTracer implements RayTracer {
     } else {
       ray.setCurrentMaterial(Air.INSTANCE);
     }
-    pathTrace(scene, ray, state, 1, true);
+    pathTrace(scene, ray, state, true);
   }
 
   /**
@@ -54,7 +55,7 @@ public class PathTracer implements RayTracer {
    * @param firstReflection {@code true} if the ray has not yet hit the first
    * diffuse or specular reflection
    */
-  public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int addEmitted,
+  public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
                                   boolean firstReflection) {
 
     boolean hit = false;
@@ -138,10 +139,13 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
       int count = firstReflection ? scene.getCurrentBranchCount() : 1;
       for (int i = 0; i < count; i++) {
         boolean doMetal = pMetal > Ray.EPSILON && random.nextFloat() < pMetal;
-        if (doMetal || (pSpecular > Ray.EPSILON && random.nextFloat() < pSpecular)) {
+
+        if (currentMat instanceof ParticleFogMaterial) {
+          hit |= doParticleFogReflection(ray, next, currentMat, cumulativeColor, random, state, scene);
+        } else if (doMetal || (pSpecular > Ray.EPSILON && random.nextFloat() < pSpecular)) {
           hit |= doSpecularReflection(ray, next, cumulativeColor, doMetal, random, state, scene);
         } else if(random.nextFloat() < pDiffuse) {
-          hit |= doDiffuseReflection(ray, next, currentMat, cumulativeColor, addEmitted, random, state, scene);
+          hit |= doDiffuseReflection(ray, next, currentMat, cumulativeColor, random, state, scene);
         } else if (n1 != n2) {
           hit |= doRefraction(ray, next, currentMat, prevMat, cumulativeColor, n1, n2, pDiffuse, random, state, scene);
         } else {
@@ -201,13 +205,82 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state, int add
     return hit;
   }
 
+  private static boolean doParticleFogReflection(Ray ray, Ray next, Material currentMat, Vector4 cumulativeColor, Random random, WorkerState state, Scene scene) {
+    boolean hit = false;
+    Vector3 emittance = new Vector3();
+    next.set(ray);
+    Vector3 inboundDirection = new Vector3(ray.d);
+    inboundDirection.scale(-1);
+
+    if (scene.emittersEnabled && currentMat.emittance > Ray.EPSILON) {
+      // Quadratic emittance mapping, so a pixel that's 50% darker will emit only 25% as much light
+      // This is arbitrary but gives pretty good results in most cases.
+      emittance = new Vector3(ray.color.x * ray.color.x, ray.color.y * ray.color.y, ray.color.z * ray.color.z);
+      emittance.scale(currentMat.emittance * scene.emitterIntensity);
+      hit = true;
+    }
+
+    if (scene.getSunSamplingStrategy().doSunSampling()) {
+      scene.sun.getRandomSunDirection(next, random);
+      double cosTheta = inboundDirection.dot(next.d);
+
+      double directLightR = 0;
+      double directLightG = 0;
+      double directLightB = 0;
+
+      next.setCurrentMaterial(next.getPrevMaterial(), next.getPrevData());
+
+      getDirectLightAttenuation(scene, next, state);
+
+      Vector4 attenuation = state.attenuation;
+      if (attenuation.w > 0) {
+        double mult = phaseHG(cosTheta, ray.getCurrentMaterial().anisotropy) * (scene.getSunSamplingStrategy().isSunLuminosity() ? scene.sun().getLuminosityPdf() : 1);
+        directLightR = attenuation.x * attenuation.w * mult;
+        directLightG = attenuation.y * attenuation.w * mult;
+        directLightB = attenuation.z * attenuation.w * mult;
+        hit = true;
+      }
+
+      next.set(ray);
+      Vector3 outboundDirection = new Vector3();
+      double x1 = random.nextDouble();
+      double x2 = random.nextDouble();
+      henyeyGreensteinSampleP(ray.getCurrentMaterial().anisotropy, inboundDirection, outboundDirection, x1, x2);
+      next.d.set(outboundDirection);
+      next.d.normalize();
+
+      hit |= pathTrace(scene, next, state, false);
+      if (hit) {
+        cumulativeColor.x += emittance.x + ray.color.x * (directLightR * scene.sun.emittance.x + next.color.x);
+        cumulativeColor.y += emittance.y + ray.color.y * (directLightG * scene.sun.emittance.y + next.color.y);
+        cumulativeColor.z += emittance.z + ray.color.z * (directLightB * scene.sun.emittance.z + next.color.z);
+      }
+    } else {
+      Vector4 rayColor = new Vector4(ray.color);
+
+      Vector3 outboundDirection = new Vector3();
+      double x1 = random.nextDouble();
+      double x2 = random.nextDouble();
+      henyeyGreensteinSampleP(ray.getCurrentMaterial().anisotropy, inboundDirection, outboundDirection, x1, x2);
+      next.d.set(outboundDirection);
+      next.d.normalize();
+
+      hit |= pathTrace(scene, next, state, false);
+      if (hit) {
+        cumulativeColor.x += emittance.x + ray.color.x * (next.color.x);
+        cumulativeColor.y += emittance.y + ray.color.y * (next.color.y);
+        cumulativeColor.z += emittance.z + ray.color.z * (next.color.z);
+      }
+      ray.color.set(rayColor);
+
+    }
+    return hit;
+  }
+
   private static boolean doSpecularReflection(Ray ray, Ray next, Vector4 cumulativeColor, boolean doMetal, Random random, WorkerState state, Scene scene) {
     boolean hit = false;
     next.specularReflection(ray, random);
-    if (pathTrace(scene, next, state, 1, false)) {
-      ray.emittance.x = ray.color.x * next.emittance.x;
-      ray.emittance.y = ray.color.y * next.emittance.y;
-      ray.emittance.z = ray.color.z * next.emittance.z;
+    if (pathTrace(scene, next, state, false)) {
 
       if (doMetal) {
         // use the albedo color as specular color
@@ -224,20 +297,17 @@ private static boolean doSpecularReflection(Ray ray, Ray next, Vector4 cumulativ
     return hit;
   }
 
-  private static boolean doDiffuseReflection(Ray ray, Ray next, Material currentMat, Vector4 cumulativeColor, int addEmitted, Random random, WorkerState state, Scene scene) {
+  private static boolean doDiffuseReflection(Ray ray, Ray next, Material currentMat, Vector4 cumulativeColor, Random random, WorkerState state, Scene scene) {
     boolean hit = false;
-    float emittance = 0;
+    Vector3 emittance = new Vector3();
     Vector4 indirectEmitterColor = new Vector4(0, 0, 0, 0);
 
     if (scene.emittersEnabled && (!scene.isPreventNormalEmitterWithSampling() || scene.getEmitterSamplingStrategy() == EmitterSamplingStrategy.NONE || ray.depth == 0) && currentMat.emittance > Ray.EPSILON) {
 
-      emittance = addEmitted;
-      ray.emittance.x = ray.color.x * ray.color.x *
-        currentMat.emittance * scene.emitterIntensity;
-      ray.emittance.y = ray.color.y * ray.color.y *
-        currentMat.emittance * scene.emitterIntensity;
-      ray.emittance.z = ray.color.z * ray.color.z *
-        currentMat.emittance * scene.emitterIntensity;
+      // Quadratic emittance mapping, so a pixel that's 50% darker will emit only 25% as much light
+      // This is arbitrary but gives pretty good results in most cases.
+      emittance = new Vector3(ray.color.x * ray.color.x, ray.color.y * ray.color.y, ray.color.z * ray.color.z);
+      emittance.scale(currentMat.emittance * scene.emitterIntensity);
 
       hit = true;
     } else if (scene.emittersEnabled && scene.emitterSamplingStrategy != EmitterSamplingStrategy.NONE && scene.getEmitterGrid() != null) {
@@ -294,14 +364,11 @@ private static boolean doDiffuseReflection(Ray ray, Ray next, Material currentMa
       }
 
       next.diffuseReflection(ray, random, scene);
-      hit = pathTrace(scene, next, state, 0, false) || hit;
+      hit = pathTrace(scene, next, state, false) || hit;
       if (hit) {
-        cumulativeColor.x += ray.color.x * (emittance + directLightR * scene.sun.emittance.x + (
-          next.color.x + next.emittance.x) + (indirectEmitterColor.x));
-        cumulativeColor.y += ray.color.y * (emittance + directLightG * scene.sun.emittance.y + (
-          next.color.y + next.emittance.y) + (indirectEmitterColor.y));
-        cumulativeColor.z += ray.color.z * (emittance + directLightB * scene.sun.emittance.z + (
-          next.color.z + next.emittance.z) + (indirectEmitterColor.z));
+        cumulativeColor.x += emittance.x + ray.color.x * (directLightR * scene.sun.emittance.x + next.color.x + indirectEmitterColor.x);
+        cumulativeColor.y += emittance.y + ray.color.y * (directLightG * scene.sun.emittance.y + next.color.y + indirectEmitterColor.y);
+        cumulativeColor.z += emittance.z + ray.color.z * (directLightB * scene.sun.emittance.z + next.color.z + indirectEmitterColor.z);
       } else if (indirectEmitterColor.x > Ray.EPSILON || indirectEmitterColor.y > Ray.EPSILON || indirectEmitterColor.z > Ray.EPSILON) {
         hit = true;
         cumulativeColor.x += ray.color.x * indirectEmitterColor.x;
@@ -314,11 +381,11 @@ private static boolean doDiffuseReflection(Ray ray, Ray next, Material currentMa
       Vector4 rayColor = new Vector4(ray.color);
       next.diffuseReflection(ray, random, scene);
 
-      hit = pathTrace(scene, next, state, 0, false) || hit;
+      hit = pathTrace(scene, next, state, false) || hit;
       if (hit) {
-        cumulativeColor.x += ray.color.x * (emittance + (next.color.x + next.emittance.x) + (indirectEmitterColor.x));
-        cumulativeColor.y += ray.color.y * (emittance + (next.color.y + next.emittance.y) + (indirectEmitterColor.y));
-        cumulativeColor.z += ray.color.z * (emittance + (next.color.z + next.emittance.z) + (indirectEmitterColor.z));
+        cumulativeColor.x += emittance.x + ray.color.x * (next.color.x + indirectEmitterColor.x);
+        cumulativeColor.y += emittance.y + ray.color.y * (next.color.y + indirectEmitterColor.y);
+        cumulativeColor.z += emittance.z + ray.color.z * (next.color.z + indirectEmitterColor.z);
       } else if (indirectEmitterColor.x > Ray.EPSILON || indirectEmitterColor.y > Ray.EPSILON || indirectEmitterColor.z > Ray.EPSILON) {
         hit = true;
         cumulativeColor.x += ray.color.x * indirectEmitterColor.x;
@@ -341,10 +408,7 @@ private static boolean doRefraction(Ray ray, Ray next, Material currentMat, Mate
     if (doRefraction && radicand < Ray.EPSILON) {
       // Total internal reflection.
       next.specularReflection(ray, random);
-      if (pathTrace(scene, next, state, 1, false)) {
-        ray.emittance.x = ray.color.x * next.emittance.x;
-        ray.emittance.y = ray.color.y * next.emittance.y;
-        ray.emittance.z = ray.color.z * next.emittance.z;
+      if (pathTrace(scene, next, state, false)) {
 
         cumulativeColor.x += next.color.x;
         cumulativeColor.y += next.color.y;
@@ -365,10 +429,7 @@ private static boolean doRefraction(Ray ray, Ray next, Material currentMat, Mate
 
       if (random.nextFloat() < Rtheta) {
         next.specularReflection(ray, random);
-        if (pathTrace(scene, next, state, 1, false)) {
-          ray.emittance.x = ray.color.x * next.emittance.x;
-          ray.emittance.y = ray.color.y * next.emittance.y;
-          ray.emittance.z = ray.color.z * next.emittance.z;
+        if (pathTrace(scene, next, state, false)) {
 
           cumulativeColor.x += next.color.x;
           cumulativeColor.y += next.color.y;
@@ -404,7 +465,7 @@ private static boolean doRefraction(Ray ray, Ray next, Material currentMat, Mate
           next.o.scaleAdd(Ray.OFFSET, next.d);
         }
 
-        if (pathTrace(scene, next, state, 1, false)) {
+        if (pathTrace(scene, next, state, false)) {
           // Calculate the color and emittance of the refracted ray
           translucentRayColor(scene, ray, next, cumulativeColor, pDiffuse);
           hit = true;
@@ -419,7 +480,7 @@ private static boolean doTransmission(Ray ray, Ray next, Vector4 cumulativeColor
     next.set(ray);
     next.o.scaleAdd(Ray.OFFSET, next.d);
 
-    if (pathTrace(scene, next, state, 1, false)) {
+    if (pathTrace(scene, next, state, false)) {
       // Calculate the color and emittance of the refracted ray
       translucentRayColor(scene, ray, next, cumulativeColor, pDiffuse);
       hit = true;
@@ -484,8 +545,6 @@ private static void translucentRayColor(Scene scene, Ray ray, Ray next, Vector4
     Vector4 outputColor = new Vector4(0, 0, 0, 0);
     outputColor.multiplyEntrywise(new Vector4(rgbTrans, 1), next.color);
     cumulativeColor.add(outputColor);
-    // Use emittance from next ray
-    ray.emittance.multiplyEntrywise(rgbTrans, next.emittance);
   }
 
   private static double reassignTransmissivity(double from, double to, double other, double trans, double cap) {
@@ -598,4 +657,66 @@ public static void getDirectLightAttenuation(Scene scene, Ray ray, WorkerState s
     }
   }
 
+  private static final double INV_4_PI = 1 / (4 * FastMath.PI);
+
+  /**
+   * Code adapted from <a href="https://github.com/mmp/pbrt-v3/blob/b47ed0d334cde4c475def0044c974b7db173ff99/src/core/medium.h#L69">pbrt</a>
+   */
+  private static double phaseHG(double cosTheta, double g) {
+    double denominator = 1 + g * g + 2 * g * cosTheta;
+    return INV_4_PI * (1 - g * g) / (denominator * FastMath.sqrt(denominator));
+  }
+
+  /**
+   * Code adapted from <a href="https://github.com/mmp/pbrt-v3/blob/b47ed0d334cde4c475def0044c974b7db173ff99/src/core/medium.cpp#L193">pbrt</a>
+   */
+  private static double henyeyGreensteinSampleP(double g, Vector3 wo, Vector3 wi, double x1, double x2) {
+    double cosTheta;
+    if (FastMath.abs(g) < 1e-3) {
+      cosTheta = 1 - 2 * x1;
+    } else {
+      double sqrTerm = (1 - g * g) / (1 + g - 2 * g * x1);
+      cosTheta = -(1 + g * g - sqrTerm * sqrTerm) / (2 * g);
+    }
+
+    double sinTheta = FastMath.sqrt(FastMath.max(0d, 1 - cosTheta * cosTheta));
+    double phi = 2 * FastMath.PI * x2;
+    Vector3 v1 = new Vector3();
+    Vector3 v2 = new Vector3();
+    coordinateSystem(wo, v1, v2);
+    wi.set(sphericalDirection(sinTheta, cosTheta, phi, v1, v2, wo));
+    return phaseHG(cosTheta, g);
+  }
+
+  /**
+   * Code adapted from <a href="https://github.com/mmp/pbrt-v3/blob/b47ed0d334cde4c475def0044c974b7db173ff99/src/core/geometry.h#L1020">pbrt</a>
+   */
+  private static void coordinateSystem(Vector3 v1, Vector3 v2, Vector3 v3) {
+    Vector3 x;
+    if (FastMath.abs(v1.x) > FastMath.abs(v1.y)) {
+      x = new Vector3(-v1.z, 0, v1.x);
+      x.scale(1 / FastMath.sqrt(v1.x * v1.x + v1.z * v1.z));
+    } else {
+      x = new Vector3(0, v1.z, -v1.y);
+      x.scale(FastMath.sqrt(v1.y * v1.y + v1.z * v1.z));
+    }
+    v2.set(x);
+    v3.cross(v1, v2);
+  }
+
+  /**
+   * Code adapted from <a href="https://github.com/mmp/pbrt-v3/blob/b47ed0d334cde4c475def0044c974b7db173ff99/src/core/geometry.h#L1465C25-L1465C25">pbrt</a>
+   */
+  private static Vector3 sphericalDirection(double sinTheta, double cosTheta, double phi, Vector3 x, Vector3 y, Vector3 z) {
+    Vector3 x1 = new Vector3(x);
+    Vector3 y1 = new Vector3(y);
+    Vector3 z1 = new Vector3(z);
+    x1.scale(sinTheta * FastMath.cos(phi));
+    y1.scale(sinTheta * FastMath.sin(phi));
+    z1.scale(cosTheta);
+    x1.add(y1);
+    x1.add(z1);
+    return x1;
+  }
+
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
index ee21e55c2a..fee21e1af8 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
@@ -101,7 +101,7 @@ public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog
     }
     if (particleFog) {
       for(FogVolume v : scene.fog.getFogVolumes()) {
-        hit = v.intersect(ray, scene, random) || hit;
+        hit |= v.intersect(ray, scene, random);
       }
     }
     if (scene.intersect(ray)) {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
index be3ce2774b..84ade06077 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
@@ -39,8 +39,12 @@ public boolean intersect(Ray ray, Scene scene, Random random) {
     o.scaleAdd(distance, ray.d);
     if (sphereTranslated.isInside(o)) {
       ray.t = distance;
+      // pick a random normal vector based on a spherical particle.
+      // This is done only to prevent fog from looking ugly in the render preview and
+      // should have no effect on the path-traced render.
       setRandomNormal(ray, random);
       setRayMaterialAndColor(ray);
+      ray.specular = false;
       return true;
     } else {
       return false;
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
index 26f69c30c0..176c8eb7fe 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
@@ -144,17 +144,6 @@ private void updateControls() {
       int index = fogVolumeTable.getSelectionModel().getSelectedIndex();
       FogVolume fogVolume = scene.fog.getFogVolumes().get(index);
 
-      DoubleAdjuster density = new DoubleAdjuster();
-      density.setName("Fog density");
-      density.setTooltip("Fog thickness");
-      density.setMaximumFractionDigits(6);
-      density.setRange(0.000001, 1);
-      density.clampMin();
-      density.set(fogVolume.getDensity());
-      density.onValueChange(value -> {
-        fogVolume.setDensity(value);
-        scene.refresh();
-      });
 
       HBox fogColorPickerBox = new HBox();
       fogColorPickerBox.setSpacing(10);
@@ -168,6 +157,31 @@ private void updateControls() {
         });
       fogColorPickerBox.getChildren().addAll(label, luxColorPicker);
 
+      DoubleAdjuster density = new DoubleAdjuster();
+      density.setName("Fog density");
+      density.setTooltip("Fog thickness");
+      density.setMaximumFractionDigits(6);
+      density.setRange(0.000001, 1);
+      density.clampMin();
+      density.set(fogVolume.getDensity());
+      density.onValueChange(value -> {
+        fogVolume.setDensity(value);
+        scene.refresh();
+      });
+
+      DoubleAdjuster anisotropy = new DoubleAdjuster();
+      anisotropy.setName("Anisotropy");
+      anisotropy.setTooltip("Changes the direction light is more likely to be scattered.\n" +
+        "Positive values increase the chance light scatters into its original direction of travel.\n" +
+        "Negative values increase the chance light scatters away from its original direction of travel");
+      anisotropy.set(fogVolume.getAnisotropy());
+      anisotropy.setRange(-1, 1);
+      anisotropy.clampBoth();
+      anisotropy.onValueChange(value -> {
+        fogVolume.setAnisotropy(value.floatValue());
+        scene.refresh();
+      });
+
       DoubleAdjuster emittance = new DoubleAdjuster();
       emittance.setName("Emittance");
       emittance.setRange(0, 100);
@@ -178,55 +192,13 @@ private void updateControls() {
         scene.refresh();
       });
 
-      DoubleAdjuster specular = new DoubleAdjuster();
-      specular.setName("Specular");
-      specular.setRange(0, 1);
-      specular.clampBoth();
-      specular.set(fogVolume.getSpecular());
-      specular.onValueChange(value -> {
-        fogVolume.setSpecular(value.floatValue());
-        scene.refresh();
-      });
-
-      DoubleAdjuster smoothness = new DoubleAdjuster();
-      smoothness.setName("Smoothness");
-      smoothness.setRange(0, 1);
-      smoothness.clampBoth();
-      smoothness.set(fogVolume.getSmoothness());
-      smoothness.onValueChange(value -> {
-        fogVolume.setSmoothness(value.floatValue());
-        scene.refresh();
-      });
-
-      DoubleAdjuster ior = new DoubleAdjuster();
-      ior.setName("IoR");
-      ior.setRange(0, 5);
-      ior.set(fogVolume.getIor());
-      ior.onValueChange(value -> {
-        fogVolume.setIor(value.floatValue());
-        scene.refresh();
-      });
-
-      DoubleAdjuster metalness = new DoubleAdjuster();
-      metalness.setName("Metalness");
-      metalness.setRange(0, 1);
-      metalness.clampBoth();
-      metalness.set(fogVolume.getMetalness());
-      metalness.onValueChange(value -> {
-        fogVolume.setMetalness(value.floatValue());
-        scene.refresh();
-      });
-
       Separator separator = new Separator();
 
       volumeSpecificControls.getChildren().addAll(
-        density,
         fogColorPickerBox,
+        density,
+        anisotropy,
         emittance,
-        specular,
-        smoothness,
-        ior,
-        metalness,
         separator
       );
 
diff --git a/chunky/src/java/se/llbit/chunky/world/Material.java b/chunky/src/java/se/llbit/chunky/world/Material.java
index 572af56774..24f064b409 100644
--- a/chunky/src/java/se/llbit/chunky/world/Material.java
+++ b/chunky/src/java/se/llbit/chunky/world/Material.java
@@ -75,6 +75,8 @@ public abstract class Material {
    */
   public float metalness = 0;
 
+  public float anisotropy = 0;
+
   /**
    * Subsurface scattering property.
    */
@@ -104,6 +106,7 @@ public void restoreDefaults() {
     specular = 0;
     emittance = 0;
     roughness = 0;
+    anisotropy = 0;
     subSurfaceScattering = false;
   }
 
@@ -125,6 +128,7 @@ public void loadMaterialProperties(JsonObject json) {
     emittance = json.get("emittance").floatValue(emittance);
     roughness = json.get("roughness").floatValue(roughness);
     metalness = json.get("metalness").floatValue(metalness);
+    anisotropy = json.get("anisotropy").floatValue(anisotropy);
   }
 
   public boolean isWater() {
diff --git a/chunky/src/java/se/llbit/math/Ray.java b/chunky/src/java/se/llbit/math/Ray.java
index e4567939fb..6f98a7261d 100644
--- a/chunky/src/java/se/llbit/math/Ray.java
+++ b/chunky/src/java/se/llbit/math/Ray.java
@@ -69,11 +69,6 @@ public class Ray {
    */
   public Vector4 color = new Vector4();
 
-  /**
-   * Emittance of previously intersected surface.
-   */
-  public Vector3 emittance = new Vector3();
-
   /**
    * Previous material.
    */
@@ -150,7 +145,6 @@ public void setDefault() {
     currentMaterial = Air.INSTANCE;
     depth = 0;
     color.set(0, 0, 0, 0);
-    emittance.set(0, 0, 0);
     specular = true;
   }
 
@@ -167,7 +161,6 @@ public void set(Ray other) {
     n.set(other.n);
     geomN.set(other.geomN);
     color.set(0, 0, 0, 0);
-    emittance.set(0, 0, 0);
     specular = other.specular;
   }
 

From 23739f7f3802667c0b27cf6fd4cdcfda30b65d26 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Thu, 12 Oct 2023 22:18:21 +0200
Subject: [PATCH 23/38] Implement fog clouds

---
 .../chunky/renderer/scene/PathTracer.java     |   3 +-
 .../renderer/scene/PreviewRayTracer.java      |   2 +-
 .../se/llbit/chunky/renderer/scene/Scene.java |   7 +
 .../se/llbit/chunky/renderer/scene/Sky.java   | 258 +++++++++++++++---
 .../chunky/ui/render/tabs/MaterialsTab.java   |  13 +-
 .../llbit/chunky/ui/render/tabs/SkyTab.java   | 115 ++++++--
 .../se/llbit/chunky/world/ExtraMaterials.java |   2 +
 .../se/llbit/chunky/world/VolumeMaterial.java |   9 +
 .../chunky/world/material/CloudMaterial.java  |   1 -
 .../world/material/ParticleFogMaterial.java   |   4 +-
 .../world/material/VolumeCloudMaterial.java   |  28 ++
 .../llbit/chunky/ui/render/tabs/SkyTab.fxml   |  24 +-
 12 files changed, 386 insertions(+), 80 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
 create mode 100644 chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 85080366c4..c4cab0aecb 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -23,6 +23,7 @@
 import se.llbit.chunky.renderer.EmitterSamplingStrategy;
 import se.llbit.chunky.renderer.WorkerState;
 import se.llbit.chunky.world.Material;
+import se.llbit.chunky.world.VolumeMaterial;
 import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.math.*;
 
@@ -140,7 +141,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
       for (int i = 0; i < count; i++) {
         boolean doMetal = pMetal > Ray.EPSILON && random.nextFloat() < pMetal;
 
-        if (currentMat instanceof ParticleFogMaterial) {
+        if (currentMat instanceof VolumeMaterial) {
           hit |= doParticleFogReflection(ray, next, currentMat, cumulativeColor, random, state, scene);
         } else if (doMetal || (pSpecular > Ray.EPSILON && random.nextFloat() < pSpecular)) {
           hit |= doSpecularReflection(ray, next, cumulativeColor, doMetal, random, state, scene);
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
index fee21e1af8..cb5059ee81 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
@@ -94,7 +94,7 @@ public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog
     ray.t = Double.POSITIVE_INFINITY;
     boolean hit = false;
     if (scene.sky().cloudsEnabled()) {
-      hit = scene.sky().cloudIntersection(scene, ray);
+      hit = scene.sky().cloudIntersection(scene, ray, random);
     }
     if (scene.isWaterPlaneEnabled()) {
       hit = waterPlaneIntersection(scene, ray) || hit;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
index 76a9b008b4..e80d838dd0 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
@@ -3251,6 +3251,13 @@ public void setMetalness(String materialName, float value) {
     refresh(ResetReason.MATERIALS_CHANGED);
   }
 
+  public void setAnisotropy(String materialName, float value) {
+    JsonObject material = materials.getOrDefault(materialName, new JsonObject()).object();
+    material.set("anisotropy", Json.of(value));
+    materials.put(materialName, material);
+    refresh(ResetReason.MATERIALS_CHANGED);
+  }
+
   public int getYClipMin() {
     return yClipMin;
   }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
index fce0a6abda..ef44a301ff 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
@@ -25,6 +25,7 @@
 import se.llbit.chunky.world.Clouds;
 import se.llbit.chunky.world.SkymapTexture;
 import se.llbit.chunky.world.material.CloudMaterial;
+import se.llbit.chunky.world.material.VolumeCloudMaterial;
 import se.llbit.json.Json;
 import se.llbit.json.JsonArray;
 import se.llbit.json.JsonObject;
@@ -34,6 +35,7 @@
 import se.llbit.resources.ImageLoader;
 import se.llbit.util.JsonSerializable;
 import se.llbit.util.JsonUtil;
+import se.llbit.util.Pair;
 import se.llbit.util.annotation.NotNull;
 import se.llbit.util.annotation.Nullable;
 
@@ -63,6 +65,8 @@ public class Sky implements JsonSerializable {
 
   protected static final int DEFAULT_CLOUD_SIZE = 12;
 
+  private static final double DEFAULT_CLOUD_DENSITY = 0.2;
+
   /**
    * Minimum sky light intensity
    */
@@ -155,7 +159,10 @@ public static SkyMode get(String name) {
 
   private boolean mirrored = true;
   private boolean cloudsEnabled = false;
-  private double cloudSize = DEFAULT_CLOUD_SIZE;
+  private boolean volumetricClouds = false;
+  private double cloudDensity = DEFAULT_CLOUD_DENSITY;
+  private final Vector3 cloudColor = new Vector3(1, 1, 1);
+  private final Vector3 cloudSize = new Vector3(DEFAULT_CLOUD_SIZE, 4, DEFAULT_CLOUD_SIZE);
   private final Vector3 cloudOffset = new Vector3(0, DEFAULT_CLOUD_HEIGHT, 0);
 
   private double skyExposure = DEFAULT_INTENSITY;
@@ -229,7 +236,10 @@ public void loadSkymap(String fileName, @Nullable File sceneDirectory) {
   public void set(Sky other) {
     cloudsEnabled = other.cloudsEnabled;
     cloudOffset.set(other.cloudOffset);
-    cloudSize = other.cloudSize;
+    cloudSize.set(other.cloudSize);
+    cloudColor.set(other.cloudColor);
+    volumetricClouds = other.volumetricClouds;
+    cloudDensity = other.cloudDensity;
     skymapFileName = other.skymapFileName;
     skymap = other.skymap;
     yaw = other.yaw;
@@ -633,7 +643,7 @@ public void setSkyCacheResolution(int resolution) {
     sky.add("mode", mode.name());
     sky.add("horizonOffset", horizonOffset);
     sky.add("cloudsEnabled", cloudsEnabled);
-    sky.add("cloudSize", cloudSize);
+    sky.add("cloudSize", cloudSize.toJson());
     sky.add("cloudOffset", cloudOffset.toJson());
 
     // Always save gradient.
@@ -695,7 +705,12 @@ public void importFromJson(JsonObject json) {
     }
     horizonOffset = json.get("horizonOffset").doubleValue(horizonOffset);
     cloudsEnabled = json.get("cloudsEnabled").boolValue(cloudsEnabled);
-    cloudSize = json.get("cloudSize").doubleValue(cloudSize);
+    if (json.get("cloudSize").isObject()) {
+      cloudSize.fromJson(json.get("cloudSize").object());
+    } else {
+      double xzSize = json.get("cloudSize").doubleValue(DEFAULT_CLOUD_SIZE);
+      cloudSize.set(xzSize, 5, xzSize);
+    }
     if (json.get("cloudOffset").isObject()) {
       cloudOffset.fromJson(json.get("cloudOffset").object());
     }
@@ -911,17 +926,43 @@ public double getHorizonOffset() {
     return horizonOffset;
   }
 
-  public void setCloudSize(double newValue) {
-    if (newValue != cloudSize) {
-      cloudSize = newValue;
+  public void setCloudSizeX(double newValue) {
+    if (newValue != cloudSize.x) {
+      cloudSize.x = newValue;
+      if (cloudsEnabled) {
+        scene.refresh();
+      }
+    }
+  }
+
+  public double getCloudSizeX() {
+    return cloudSize.x;
+  }
+
+  public void setCloudSizeY(double newValue) {
+    if (newValue != cloudSize.y) {
+      cloudSize.y = newValue;
+      if (cloudsEnabled) {
+        scene.refresh();
+      }
+    }
+  }
+
+  public double getCloudSizeY() {
+    return cloudSize.y;
+  }
+
+  public void setCloudSizeZ(double newValue) {
+    if (newValue != cloudSize.z) {
+      cloudSize.z = newValue;
       if (cloudsEnabled) {
         scene.refresh();
       }
     }
   }
 
-  public double cloudSize() {
-    return cloudSize;
+  public double getCloudSizeZ() {
+    return cloudSize.z;
   }
 
   public void setCloudXOffset(double newValue) {
@@ -987,15 +1028,162 @@ public boolean cloudsEnabled() {
     return cloudsEnabled;
   }
 
-  public boolean cloudIntersection(Scene scene, Ray ray) {
+  public Vector3 getCloudColor() {
+    return new Vector3(cloudColor);
+  }
+
+  public void setCloudColor(Vector3 color) {
+    cloudColor.set(color);
+    scene.refresh();
+  }
+
+  public boolean getVolumetricClouds() {
+    return volumetricClouds;
+  }
+
+  public void setVolumetricClouds(boolean value) {
+    volumetricClouds = value;
+    scene.refresh();
+  }
+
+  public double getCloudDensity() {
+    return cloudDensity;
+  }
+
+  public void setCloudDensity(double value) {
+    cloudDensity = value;
+    scene.refresh();
+  }
+
+  private Pair<Double, Double> getCloudDistance(Scene scene, Ray ray) {
+    Pair<Boolean, Boolean> cloudIntersectionTest = cloudIntersection(scene, ray);
+    boolean hitCloud = cloudIntersectionTest.thing1;
+    boolean insideCloud = cloudIntersectionTest.thing2;
+    if (!hitCloud) {
+      return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+    } else {
+      if (!volumetricClouds) {
+        double t = ray.t;
+        double tExit;
+        if (insideCloud) {
+          tExit = 1d;
+        } else {
+          tExit = 0d;
+        }
+        return new Pair<>(t, tExit);
+      } else {
+        if (insideCloud) {
+          double t;
+          double tExit;
+          t = 0;
+          tExit = ray.t;
+          return new Pair<>(t, tExit);
+        } else {
+          double t = ray.t;
+          double tExit;
+          double depth = 0;
+          while (true) {
+            if (depth >= 1000) {
+              return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+            }
+            Ray nextIntersection = new Ray(ray);
+            nextIntersection.t = Double.POSITIVE_INFINITY;
+            nextIntersection.o.scaleAdd(t + Ray.OFFSET, ray.d);
+            Pair<Boolean, Boolean> testSecondIntersection = cloudIntersection(scene, nextIntersection);
+            if (!testSecondIntersection.thing1) {
+              return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+            } else {
+              if (testSecondIntersection.thing2) {
+                tExit = t + Ray.OFFSET + nextIntersection.t;
+                break;
+              } else {
+                t += Ray.OFFSET + nextIntersection.t;
+                depth++;
+              }
+            }
+          }
+          return new Pair<>(t, tExit);
+        }
+      }
+    }
+  }
+
+  public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
+    if (random == null) {
+      return false;
+    }
+    Ray test = new Ray(ray);
+    test.t = ray.t;
+    Pair<Double, Double> cloudDistance = getCloudDistance(scene, test);
+    double firstIntersection = cloudDistance.thing1;
+    if (firstIntersection == Double.POSITIVE_INFINITY) {
+      return false;
+    }
+    double secondIntersection = cloudDistance.thing2;
+    double t;
+    if (volumetricClouds) {
+      double testFirstIntersection = firstIntersection;
+      double testSecondIntersection = secondIntersection;
+      Vector3 normal = new Vector3(test.getNormal());
+      int depth = 0;
+      while (true) {
+        if (depth >= 1000) {
+          return false;
+        }
+        double fogPenetrated = -FastMath.log(1 - random.nextDouble());
+        double fogDistance = fogPenetrated / cloudDensity;
+        if (testFirstIntersection + fogDistance < testSecondIntersection) {
+          t = testFirstIntersection + fogDistance;
+          ray.setNormal(normal);
+          ray.setCurrentMaterial(VolumeCloudMaterial.INSTANCE);
+          ray.specular = false;
+          break;
+        } else {
+          Ray test2 = new Ray(ray);
+          test2.t = Double.POSITIVE_INFINITY;
+          test2.o.scaleAdd(testSecondIntersection + Ray.OFFSET, ray.d);
+          Pair<Double, Double> testCloudDistance = getCloudDistance(scene, test2);
+          if (testCloudDistance.thing1 == Double.POSITIVE_INFINITY) {
+            return false;
+          }
+          testFirstIntersection += (testSecondIntersection - testFirstIntersection) + Ray.OFFSET + testCloudDistance.thing1;
+          testSecondIntersection += Ray.OFFSET + testCloudDistance.thing2;
+          normal.set(test2.getNormal());
+          depth++;
+        }
+      }
+    } else {
+      t = firstIntersection;
+      ray.setNormal(test.getNormal());
+      if (secondIntersection == 1) {
+        ray.setCurrentMaterial(Air.INSTANCE);
+      } else {
+        ray.setCurrentMaterial(CloudMaterial.INSTANCE);
+      }
+    }
+    ray.t = t;
+    ray.color.set(cloudColor.x, cloudColor.y, cloudColor.z, 1);
+    return true;
+  }
+
+  /**
+   * Test for a cloud intersection. If the ray intersects a cloud,
+   * the distance to the intersection is stored in <code>ray.t</code>.
+   * @return {@link se.llbit.util.Pair} of Booleans.
+   * @param ray Ray with which to test for cloud intersection.
+   * <code>pair.thing1</code>: <code>true</code> if the ray intersected a cloud.
+   * <code>pair.thing2</code>: <code>true</code> if the ray origin is inside a cloud.
+   */
+  private Pair<Boolean, Boolean> cloudIntersection(Scene scene, Ray ray) {
     double ox = ray.o.x + scene.origin.x;
     double oy = ray.o.y + scene.origin.y;
     double oz = ray.o.z + scene.origin.z;
     double offsetX = cloudOffset.x;
     double offsetY = cloudOffset.y;
     double offsetZ = cloudOffset.z;
-    double inv_size = 1 / cloudSize;
-    double cloudTop = offsetY + 5;
+    double invSizeX = 1 / cloudSize.x;
+    double invSizeZ = 1 / cloudSize.z;
+    double cloudTop = offsetY + cloudSize.y;
     int target = 1;
     double t_offset = 0;
     if (oy < offsetY || oy > cloudTop) {
@@ -1005,16 +1193,16 @@ public boolean cloudIntersection(Scene scene, Ray ray) {
         t_offset = (cloudTop - oy) / ray.d.y;
       }
       if (t_offset < 0) {
-        return false;
+        return new Pair<>(false, false);
       }
       // Ray is entering cloud.
-      if (inCloud((ray.d.x * t_offset + ox) * inv_size + offsetX,
-          (ray.d.z * t_offset + oz) * inv_size + offsetZ)) {
+      if (inCloud((ray.d.x * t_offset + ox) * invSizeX + offsetX,
+          (ray.d.z * t_offset + oz) * invSizeZ + offsetZ)) {
         ray.setNormal(0, -Math.signum(ray.d.y), 0);
-        enterCloud(ray, t_offset);
-        return true;
+        ray.t = t_offset;
+        return new Pair<>(true, false);
       }
-    } else if (inCloud(ox * inv_size + offsetX, oz * inv_size + offsetZ)) {
+    } else if (inCloud(ox * invSizeX + offsetX, oz * invSizeZ + offsetZ)) {
       target = 0;
     }
     double tExit;
@@ -1026,16 +1214,16 @@ public boolean cloudIntersection(Scene scene, Ray ray) {
     if (ray.t < tExit) {
       tExit = ray.t;
     }
-    double x0 = (ox + ray.d.x * t_offset) * inv_size + offsetX;
-    double z0 = (oz + ray.d.z * t_offset) * inv_size + offsetZ;
+    double x0 = (ox + ray.d.x * t_offset) * invSizeX + offsetX;
+    double z0 = (oz + ray.d.z * t_offset) * invSizeZ + offsetZ;
     double xp = x0;
     double zp = z0;
     int ix = (int) Math.floor(xp);
     int iz = (int) Math.floor(zp);
     int xmod = (int) Math.signum(ray.d.x), zmod = (int) Math.signum(ray.d.z);
     int xo = (1 + xmod) / 2, zo = (1 + zmod) / 2;
-    double dx = Math.abs(ray.d.x) * inv_size;
-    double dz = Math.abs(ray.d.z) * inv_size;
+    double dx = Math.abs(ray.d.x) * invSizeX;
+    double dz = Math.abs(ray.d.z) * invSizeZ;
     double t = 0;
     int i = 0;
     int nx = 0, nz = 0;
@@ -1129,15 +1317,15 @@ public boolean cloudIntersection(Scene scene, Ray ray) {
     int ny = 0;
     if (target == 1) {
       if (t > tExit) {
-        return false;
+        return new Pair<>(false, false);
       }
       if (nx == 0 && ny == 0 && nz == 0) {
         // fix ray.n being set to zero (issue #643)
-        return false;
+        return new Pair<>(false, false);
       }
       ray.setNormal(nx, ny, nz);
-      enterCloud(ray, t + t_offset);
-      return true;
+      ray.t = t + t_offset;
+      return new Pair<>(true, false);
     } else {
       if (t > tExit) {
         nx = 0;
@@ -1150,24 +1338,12 @@ public boolean cloudIntersection(Scene scene, Ray ray) {
       }
       if (nx == 0 && ny == 0 && nz == 0) {
         // fix ray.n being set to zero (issue #643)
-        return false;
+        return new Pair<>(false, false);
       }
       ray.setNormal(nx, ny, nz);
-      exitCloud(ray, t);
+      ray.t = t;
+      return new Pair<>(true, true);
     }
-    return true;
-  }
-
-  private static void enterCloud(Ray ray, double t) {
-    ray.t = t;
-    ray.color.set(CloudMaterial.color);
-    ray.setCurrentMaterial(CloudMaterial.INSTANCE);
-  }
-
-  private static void exitCloud(Ray ray, double t) {
-    ray.t = t;
-    ray.color.set(CloudMaterial.color);
-    ray.setCurrentMaterial(Air.INSTANCE);
   }
 
   private static boolean inCloud(double x, double z) {
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
index a1644556ee..8f1f248f53 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
@@ -54,6 +54,7 @@ public class MaterialsTab extends HBox implements RenderControlsTab, Initializab
   private final DoubleAdjuster ior = new DoubleAdjuster();
   private final DoubleAdjuster perceptualSmoothness = new DoubleAdjuster();
   private final DoubleAdjuster metalness = new DoubleAdjuster();
+  private final DoubleAdjuster anisotropy = new DoubleAdjuster();
   private final ListView<String> listView;
 
   public MaterialsTab() {
@@ -72,6 +73,9 @@ public MaterialsTab() {
     metalness.setName("Metalness");
     metalness.setRange(0, 1);
     metalness.setTooltip("Metalness (texture-tinted reflectivity) of the selected material.");
+    anisotropy.setName("Volume scatter anisotropy");
+    anisotropy.setRange(-1, 1);
+    anisotropy.clampBoth();
     ObservableList<String> blockIds = FXCollections.observableArrayList();
     blockIds.addAll(MaterialStore.collections.keySet());
     blockIds.addAll(ExtraMaterials.idMap.keySet());
@@ -87,7 +91,7 @@ public MaterialsTab() {
     settings.setSpacing(10);
     settings.getChildren().addAll(
         new Label("Material Properties"),
-        emittance, specular, perceptualSmoothness, ior, metalness,
+        emittance, specular, perceptualSmoothness, ior, metalness, anisotropy,
         new Label("(set to zero to disable)"));
     setPadding(new Insets(10));
     setSpacing(15);
@@ -117,6 +121,7 @@ private void updateSelectedMaterial(String materialName) {
       double iorAcc = 0;
       double perceptualSmoothnessAcc = 0;
       double metalnessAcc = 0;
+      double anisotropyAcc = 0;
       Collection<Block> blocks = MaterialStore.collections.get(materialName);
       for (Block block : blocks) {
         emAcc += block.emittance;
@@ -124,12 +129,14 @@ private void updateSelectedMaterial(String materialName) {
         iorAcc += block.ior;
         perceptualSmoothnessAcc += block.getPerceptualSmoothness();
         metalnessAcc += block.metalness;
+        anisotropyAcc += block.anisotropy;
       }
       emittance.set(emAcc / blocks.size());
       specular.set(specAcc / blocks.size());
       ior.set(iorAcc / blocks.size());
       perceptualSmoothness.set(perceptualSmoothnessAcc / blocks.size());
       metalness.set(metalnessAcc / blocks.size());
+      anisotropy.set(anisotropyAcc / blocks.size());
       materialExists = true;
     } else if (ExtraMaterials.idMap.containsKey(materialName)) {
       Material material = ExtraMaterials.idMap.get(materialName);
@@ -139,6 +146,7 @@ private void updateSelectedMaterial(String materialName) {
         ior.set(material.ior);
         perceptualSmoothness.set(material.getPerceptualSmoothness());
         metalness.set(material.metalness);
+        anisotropy.set(material.anisotropy);
         materialExists = true;
       }
     } else if (MaterialStore.blockIds.contains(materialName)) {
@@ -149,6 +157,7 @@ private void updateSelectedMaterial(String materialName) {
       ior.set(block.ior);
       perceptualSmoothness.set(block.getPerceptualSmoothness());
       metalness.set(block.metalness);
+      anisotropy.set(block.anisotropy);
       materialExists = true;
     }
     if (materialExists) {
@@ -157,12 +166,14 @@ private void updateSelectedMaterial(String materialName) {
       ior.onValueChange(value -> scene.setIor(materialName, value.floatValue()));
       perceptualSmoothness.onValueChange(value -> scene.setPerceptualSmoothness(materialName, value.floatValue()));
       metalness.onValueChange(value -> scene.setMetalness(materialName, value.floatValue()));
+      anisotropy.onValueChange(value -> scene.setAnisotropy(materialName, value.floatValue()));
     } else {
       emittance.onValueChange(value -> {});
       specular.onValueChange(value -> {});
       ior.onValueChange(value -> {});
       perceptualSmoothness.onValueChange(value -> {});
       metalness.onValueChange(value -> {});
+      anisotropy.onValueChange(value -> {});
     }
   }
 
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
index b947a5eae4..996bdd797b 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
@@ -60,10 +60,16 @@ public class SkyTab extends ScrollPane implements RenderControlsTab, Initializab
   @FXML private VBox skyModeSettings;
   @FXML private CheckBox transparentSkyEnabled;
   @FXML private CheckBox cloudsEnabled;
-  @FXML private DoubleAdjuster cloudSize;
-  @FXML private DoubleAdjuster cloudX;
-  @FXML private DoubleAdjuster cloudY;
-  @FXML private DoubleAdjuster cloudZ;
+  @FXML private TitledPane cloudDetailsPane;
+  @FXML private DoubleAdjuster cloudSizeX;
+  @FXML private DoubleAdjuster cloudSizeY;
+  @FXML private DoubleAdjuster cloudSizeZ;
+  @FXML private DoubleAdjuster cloudOffsetX;
+  @FXML private DoubleAdjuster cloudOffsetY;
+  @FXML private DoubleAdjuster cloudOffsetZ;
+  @FXML private LuxColorPicker cloudColor;
+  @FXML private CheckBox enableVolumetricClouds;
+  @FXML private DoubleAdjuster cloudDensity;
   private final VBox simulatedSettings = new VBox();
   private DoubleAdjuster horizonOffset = new DoubleAdjuster();
   private ChoiceBox<SimulatedSky> simulatedSky = new ChoiceBox<>();
@@ -75,6 +81,9 @@ public class SkyTab extends ScrollPane implements RenderControlsTab, Initializab
 
   private ChangeListener<? super javafx.scene.paint.Color> skyColorListener =
       (observable, oldValue, newValue) -> scene.sky().setColor(ColorUtil.fromFx(newValue));
+
+  private ChangeListener<? super javafx.scene.paint.Color> cloudColorListener =
+    (observable, oldValue, newValue) -> scene.sky().setCloudColor(ColorUtil.fromFx(newValue));
   private EventHandler<ActionEvent> simSkyListener = event -> {
     int selected = simulatedSky.getSelectionModel().getSelectedIndex();
     scene.sky().setSimulatedSkyMode(selected);
@@ -126,22 +135,68 @@ public SimulatedSky fromString(String string) {
     simulatedSky.setOnAction(simSkyListener);
     simulatedSky.setTooltip(new Tooltip(skiesTooltip(Sky.skies)));
 
-    cloudSize.setName("Cloud size");
-    cloudSize.setTooltip("Cloud size, measured in blocks per pixel of clouds.png texture");
-    cloudSize.setRange(0.1, 128);
-    cloudSize.clampMin();
-    cloudSize.makeLogarithmic();
-    cloudSize.onValueChange(value -> scene.sky().setCloudSize(value));
-
-    cloudX.setTooltip("Cloud X offset.");
-    cloudX.setRange(-256, 256);
-    cloudX.onValueChange(value -> scene.sky().setCloudXOffset(value));
-    cloudY.setTooltip("Cloud Y offset.");
-    cloudY.setRange(-64, 320);
-    cloudY.onValueChange(value -> scene.sky().setCloudYOffset(value));
-    cloudZ.setTooltip("Cloud Z offset.");
-    cloudZ.setRange(-256, 256);
-    cloudZ.onValueChange(value -> scene.sky().setCloudZOffset(value));
+    cloudsEnabled.setTooltip(new Tooltip("Toggle visibility of Minecraft-style clouds."));
+    cloudsEnabled.selectedProperty().addListener((observable, oldValue, newValue) -> {
+      scene.sky().setCloudsEnabled(newValue);
+      cloudDetailsPane.setVisible(newValue);
+      cloudDetailsPane.setExpanded(newValue);
+      cloudDetailsPane.setManaged(newValue);
+    });
+
+    cloudDetailsPane.setVisible(false);
+    cloudDetailsPane.setExpanded(false);
+    cloudDetailsPane.setManaged(false);
+
+    cloudSizeX.setName("Cloud X scale");
+    cloudSizeX.setTooltip("Scale of the X-dimension of the clouds, measured in blocks per pixel of clouds.png texture");
+    cloudSizeX.setRange(0.01, 128);
+    cloudSizeX.clampMin();
+    cloudSizeX.makeLogarithmic();
+    cloudSizeX.onValueChange(value -> scene.sky().setCloudSizeX(value));
+
+    cloudSizeY.setName("Cloud Y scale");
+    cloudSizeY.setTooltip("Scale of the Y-dimension of the clouds, measured in blocks per pixel of clouds.png texture");
+    cloudSizeY.setRange(0.01, 128);
+    cloudSizeY.clampMin();
+    cloudSizeY.makeLogarithmic();
+    cloudSizeY.onValueChange(value -> scene.sky().setCloudSizeY(value));
+
+    cloudSizeZ.setName("Cloud Z scale");
+    cloudSizeZ.setTooltip("Scale of the Z-dimension of the clouds, measured in blocks per pixel of clouds.png texture");
+    cloudSizeZ.setRange(0.01, 128);
+    cloudSizeZ.clampMin();
+    cloudSizeZ.makeLogarithmic();
+    cloudSizeZ.onValueChange(value -> scene.sky().setCloudSizeZ(value));
+
+    cloudOffsetX.setName("Cloud X offset");
+    cloudOffsetX.setTooltip("Changes the X-offset of the clouds.");
+    cloudOffsetX.setRange(-256, 256);
+    cloudOffsetX.onValueChange(value -> scene.sky().setCloudXOffset(value));
+
+    cloudOffsetY.setName("Cloud Y offset");
+    cloudOffsetY.setTooltip("Changes the altitude of the clouds.");
+    cloudOffsetY.setRange(-64, 320);
+    cloudOffsetY.onValueChange(value -> scene.sky().setCloudYOffset(value));
+
+    cloudOffsetZ.setName("Cloud Z offset");
+    cloudOffsetZ.setTooltip("Changes the Z-offset of the clouds.");
+    cloudOffsetZ.setRange(-256, 256);
+    cloudOffsetZ.onValueChange(value -> scene.sky().setCloudZOffset(value));
+
+    cloudColor.colorProperty().addListener(cloudColorListener);
+
+    enableVolumetricClouds.setTooltip(new Tooltip("Use a volume scatter for the cloud material."));
+    enableVolumetricClouds.selectedProperty().addListener((observable, oldValue, newValue) -> {
+      scene.sky().setVolumetricClouds(newValue);
+      cloudDensity.setDisable(!newValue);
+    });
+
+    cloudDensity.setName("Volumetric cloud density");
+    cloudDensity.setRange(0.000001, 1);
+    cloudDensity.clampMin();
+    cloudDensity.setMaximumFractionDigits(6);
+    cloudDensity.onValueChange(value -> scene.sky().setCloudDensity(value));
+    cloudDensity.setDisable(true);
 
     skyMode.setTooltip(new Tooltip("Set the type of sky to be used in the scene."));
     skyMode.getItems().addAll(Sky.SkyMode.values());
@@ -182,11 +237,6 @@ public SimulatedSky fromString(String string) {
         .setTooltip(new Tooltip("Disables sky rendering for background compositing."));
     transparentSkyEnabled.selectedProperty().addListener(
         (observable, oldValue, newValue) -> scene.setTransparentSky(newValue));
-    cloudsEnabled.setTooltip(new Tooltip("Toggle visibility of Minecraft-style clouds."));
-    cloudsEnabled.selectedProperty().addListener((observable, oldValue, newValue) -> {
-
-      scene.sky().setCloudsEnabled(newValue);
-    });
     colorPicker.colorProperty().addListener(skyColorListener);
   }
 
@@ -197,10 +247,17 @@ public SimulatedSky fromString(String string) {
     simulatedSky.setOnAction(simSkyListener);
     cloudsEnabled.setSelected(scene.sky().cloudsEnabled());
     transparentSkyEnabled.setSelected(scene.transparentSky());
-    cloudSize.set(scene.sky().cloudSize());
-    cloudX.set(scene.sky().cloudXOffset());
-    cloudY.set(scene.sky().cloudYOffset());
-    cloudZ.set(scene.sky().cloudZOffset());
+    cloudSizeX.set(scene.sky().getCloudSizeX());
+    cloudSizeY.set(scene.sky().getCloudSizeY());
+    cloudSizeZ.set(scene.sky().getCloudSizeZ());
+    cloudOffsetX.set(scene.sky().cloudXOffset());
+    cloudOffsetY.set(scene.sky().cloudYOffset());
+    cloudOffsetZ.set(scene.sky().cloudZOffset());
+    cloudColor.colorProperty().removeListener(cloudColorListener);
+    cloudColor.setColor(ColorUtil.toFx(scene.sky().getCloudColor()));
+    cloudColor.colorProperty().addListener(cloudColorListener);
+    enableVolumetricClouds.setSelected(scene.sky().getVolumetricClouds());
+    cloudDensity.set(scene.sky().getCloudDensity());
     horizonOffset.set(scene.sky().getHorizonOffset());
     simulatedSky.setValue(scene.sky().getSimulatedSky());
     gradientEditor.setGradient(scene.sky().getGradient());
diff --git a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
index f34613f649..d0fd052535 100644
--- a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
+++ b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
@@ -20,6 +20,7 @@
 import se.llbit.chunky.entity.CalibratedSculkSensorAmethyst;
 import se.llbit.chunky.entity.Campfire;
 import se.llbit.chunky.world.material.CloudMaterial;
+import se.llbit.chunky.world.material.VolumeCloudMaterial;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -31,6 +32,7 @@ public class ExtraMaterials {
 
   static {
     idMap.put("cloud", CloudMaterial.INSTANCE);
+    idMap.put("volume_cloud", VolumeCloudMaterial.INSTANCE);
     idMap.put("candle_flame", Candle.flameMaterial);
     idMap.put("campfire_flame", Campfire.flameMaterial);
     idMap.put("soul_campfire_flame", Campfire.soulFlameMaterial);
diff --git a/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java b/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
new file mode 100644
index 0000000000..b1f9ebb5e5
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
@@ -0,0 +1,9 @@
+package se.llbit.chunky.world;
+
+import se.llbit.chunky.resources.Texture;
+
+public class VolumeMaterial extends Material {
+  public VolumeMaterial(String name, Texture texture) {
+    super(name, texture);
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java
index 9040b2dacd..5ec2ca32dd 100644
--- a/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java
@@ -21,7 +21,6 @@
 
 public class CloudMaterial extends Material {
   public static final CloudMaterial INSTANCE = new CloudMaterial();
-  public static float[] color = {1, 1, 1, 1};
 
   private CloudMaterial() {
     super("cloud", Texture.air);
diff --git a/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
index c183b732f6..3187f9bedb 100644
--- a/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
@@ -1,9 +1,9 @@
 package se.llbit.chunky.world.material;
 
 import se.llbit.chunky.resources.Texture;
-import se.llbit.chunky.world.Material;
+import se.llbit.chunky.world.VolumeMaterial;
 
-public class ParticleFogMaterial extends Material {
+public class ParticleFogMaterial extends VolumeMaterial {
   public static final ParticleFogMaterial INSTANCE = new ParticleFogMaterial();
 
   public ParticleFogMaterial() {
diff --git a/chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java
new file mode 100644
index 0000000000..d916035d1e
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java
@@ -0,0 +1,28 @@
+/* Copyright (c) 2019 Jesper Öqvist <jesper@llbit.se>
+ *
+ * This file is part of Chunky.
+ *
+ * Chunky is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Chunky is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * You should have received a copy of the GNU General Public License
+ * along with Chunky.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package se.llbit.chunky.world.material;
+
+import se.llbit.chunky.resources.Texture;
+import se.llbit.chunky.world.VolumeMaterial;
+
+public class VolumeCloudMaterial extends VolumeMaterial {
+  public static final VolumeCloudMaterial INSTANCE = new VolumeCloudMaterial();
+
+  private VolumeCloudMaterial() {
+    super("volume_cloud", Texture.air);
+  }
+}
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
index 2bc883708e..7901b882ef 100644
--- a/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
@@ -10,6 +10,7 @@
 <?import javafx.scene.layout.VBox?>
 <?import javafx.scene.control.ScrollPane?>
 <?import se.llbit.chunky.ui.DoubleAdjuster?>
+<?import se.llbit.fx.LuxColorPicker?>
 
 <fx:root type="javafx.scene.control.ScrollPane" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1">
   <VBox spacing="10.0">
@@ -31,10 +32,25 @@
     <CheckBox fx:id="transparentSkyEnabled" mnemonicParsing="false" text="Transparent sky" />
     <Separator />
     <CheckBox fx:id="cloudsEnabled" mnemonicParsing="false" text="Enable clouds" />
-    <DoubleAdjuster fx:id="cloudSize" />
-    <DoubleAdjuster fx:id="cloudX" name="Cloud X" />
-    <DoubleAdjuster fx:id="cloudY" name="Cloud Y" />
-    <DoubleAdjuster fx:id="cloudZ" name="Cloud Z" />
+    <TitledPane fx:id="cloudDetailsPane" animated="false" text="Cloud settings">
+      <VBox spacing="10.0">
+        <padding>
+          <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
+        </padding>
+        <DoubleAdjuster fx:id="cloudSizeX" />
+        <DoubleAdjuster fx:id="cloudSizeY" />
+        <DoubleAdjuster fx:id="cloudSizeZ" />
+        <DoubleAdjuster fx:id="cloudOffsetX" />
+        <DoubleAdjuster fx:id="cloudOffsetY" />
+        <DoubleAdjuster fx:id="cloudOffsetZ" />
+        <HBox alignment="CENTER_LEFT" spacing="10.0">
+          <Label text="Cloud color:" />
+          <LuxColorPicker fx:id="cloudColor" />
+        </HBox>
+        <CheckBox fx:id="enableVolumetricClouds" mnemonicParsing="false" text="Volumetric clouds"/>
+        <DoubleAdjuster fx:id="cloudDensity" />
+      </VBox>
+    </TitledPane>
     <padding>
       <Insets bottom="10.0" left="10.0" right="10.0" top="10.0" />
     </padding>

From 5df81007d1e1af51e5826e8cd07603df4cc1fe99 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Thu, 12 Oct 2023 23:29:53 +0200
Subject: [PATCH 24/38] Set fog positions to camera / target controls

---
 .../llbit/chunky/ui/render/tabs/FogTab.java   | 103 ++++++++++++++++--
 .../chunky/ui/render/tabs/MaterialsTab.java   |   5 +-
 2 files changed, 97 insertions(+), 11 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
index 176c8eb7fe..9df293c620 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
@@ -144,7 +144,6 @@ private void updateControls() {
       int index = fogVolumeTable.getSelectionModel().getSelectedIndex();
       FogVolume fogVolume = scene.fog.getFogVolumes().get(index);
 
-
       HBox fogColorPickerBox = new HBox();
       fogColorPickerBox.setSpacing(10);
       Label label = new Label("Fog color:");
@@ -305,6 +304,28 @@ private void updateControls() {
           yText.setLabelText("y:");
           zText.setLabelText("z:");
 
+          Button toCamera = new Button();
+          toCamera.setText("To camera");
+          toCamera.setOnAction(event -> {
+            Vector3 cameraPosition = new Vector3(scene.camera().getPosition());
+            posX.valueProperty().setValue(cameraPosition.x);
+            posY.valueProperty().setValue(cameraPosition.y);
+            posZ.valueProperty().setValue(cameraPosition.z);
+            scene.refresh();
+          });
+
+          Button toTarget = new Button();
+          toTarget.setText("To target");
+          toTarget.setOnAction(event -> {
+            Vector3 targetPosition = scene.getTargetPosition();
+            if (targetPosition != null) {
+              posX.valueProperty().setValue(targetPosition.x);
+              posY.valueProperty().setValue(targetPosition.y);
+              posZ.valueProperty().setValue(targetPosition.z);
+              scene.refresh();
+            }
+          });
+
           GridPane gridPane = new GridPane();
           gridPane.setHgap(6);
           gridPane.getColumnConstraints().addAll(
@@ -315,6 +336,10 @@ private void updateControls() {
           );
           gridPane.addRow(0, new Label("Center:"), xText, yText, zText);
 
+          HBox hBox = new HBox();
+          hBox.setSpacing(10);
+          hBox.getChildren().addAll(toCamera, toTarget);
+
           DoubleAdjuster radius = new DoubleAdjuster();
           radius.setName("Radius");
           radius.setTooltip("Radius of the sphere");
@@ -326,7 +351,7 @@ private void updateControls() {
             scene.refresh();
           });
 
-          volumeSpecificControls.getChildren().addAll(gridPane, radius);
+          volumeSpecificControls.getChildren().addAll(gridPane, hBox, radius);
           break;
         }
         case CUBOID: {
@@ -448,19 +473,79 @@ private void updateControls() {
           y2Text.setLabelText("y:");
           z2Text.setLabelText("z:");
 
-          GridPane gridPane = new GridPane();
-          gridPane.setHgap(6);
-          gridPane.setVgap(10);
-          gridPane.getColumnConstraints().addAll(
+          Button pos1ToCamera = new Button();
+          pos1ToCamera.setText("To camera");
+          pos1ToCamera.setOnAction(event -> {
+            Vector3 cameraPosition = new Vector3(scene.camera().getPosition());
+            x1.valueProperty().setValue(cameraPosition.x);
+            y1.valueProperty().setValue(cameraPosition.y);
+            z1.valueProperty().setValue(cameraPosition.z);
+            scene.refresh();
+          });
+
+          Button pos1ToTarget = new Button();
+          pos1ToTarget.setText("To target");
+          pos1ToTarget.setOnAction(event -> {
+            Vector3 targetPosition = scene.getTargetPosition();
+            if (targetPosition != null) {
+              x1.valueProperty().setValue(targetPosition.x);
+              y1.valueProperty().setValue(targetPosition.y);
+              z1.valueProperty().setValue(targetPosition.z);
+              scene.refresh();
+            }
+          });
+
+          Button pos2ToCamera = new Button();
+          pos2ToCamera.setText("To camera");
+          pos2ToCamera.setOnAction(event -> {
+            Vector3 cameraPosition = new Vector3(scene.camera().getPosition());
+            x2.valueProperty().setValue(cameraPosition.x);
+            y2.valueProperty().setValue(cameraPosition.y);
+            z2.valueProperty().setValue(cameraPosition.z);
+            scene.refresh();
+          });
+
+          Button pos2ToTarget = new Button();
+          pos2ToTarget.setText("To target");
+          pos2ToTarget.setOnAction(event -> {
+            Vector3 targetPosition = scene.getTargetPosition();
+            if (targetPosition != null) {
+              x2.valueProperty().setValue(targetPosition.x);
+              y2.valueProperty().setValue(targetPosition.y);
+              z2.valueProperty().setValue(targetPosition.z);
+              scene.refresh();
+            }
+          });
+
+          GridPane gridPane1 = new GridPane();
+          gridPane1.setHgap(6);
+          gridPane1.getColumnConstraints().addAll(
             labelConstraints,
             posFieldConstraints,
             posFieldConstraints,
             posFieldConstraints
           );
-          gridPane.addRow(0, new Label("Corner 1:"), x1Text, y1Text, z1Text);
-          gridPane.addRow(1, new Label("Corner 2:"), x2Text, y2Text, z2Text);
+          gridPane1.addRow(0, new Label("Corner 1:"), x1Text, y1Text, z1Text);
+
+          HBox hBox1 = new HBox();
+          hBox1.setSpacing(10);
+          hBox1.getChildren().addAll(pos1ToCamera, pos1ToTarget);
+
+          GridPane gridPane2 = new GridPane();
+          gridPane2.setHgap(6);
+          gridPane2.getColumnConstraints().addAll(
+            labelConstraints,
+            posFieldConstraints,
+            posFieldConstraints,
+            posFieldConstraints
+          );
+          gridPane2.addRow(1, new Label("Corner 2:"), x2Text, y2Text, z2Text);
+
+          HBox hBox2 = new HBox();
+          hBox2.setSpacing(10);
+          hBox2.getChildren().addAll(pos2ToCamera, pos2ToTarget);
 
-          volumeSpecificControls.getChildren().addAll(gridPane);
+          volumeSpecificControls.getChildren().addAll(gridPane1, hBox1, gridPane2, hBox2);
           break;
         }
       }
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
index 8f1f248f53..ec87aed459 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
@@ -73,7 +73,7 @@ public MaterialsTab() {
     metalness.setName("Metalness");
     metalness.setRange(0, 1);
     metalness.setTooltip("Metalness (texture-tinted reflectivity) of the selected material.");
-    anisotropy.setName("Volume scatter anisotropy");
+    anisotropy.setName("Anisotropy");
     anisotropy.setRange(-1, 1);
     anisotropy.clampBoth();
     ObservableList<String> blockIds = FXCollections.observableArrayList();
@@ -92,7 +92,8 @@ public MaterialsTab() {
     settings.getChildren().addAll(
         new Label("Material Properties"),
         emittance, specular, perceptualSmoothness, ior, metalness, anisotropy,
-        new Label("(set to zero to disable)"));
+        new Label("(set to zero to disable)\n" +
+          "'Anisotropy' is effective only on the 'volume_cloud' material."));
     setPadding(new Insets(10));
     setSpacing(15);
     TextField filterField = new TextField();

From b8b08a0956e1cbf2964f57a2ce31a1bc19106857 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Thu, 12 Oct 2023 23:36:30 +0200
Subject: [PATCH 25/38] Do not create new Vector3's

---
 chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
index 9df293c620..5b683543de 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
@@ -307,7 +307,7 @@ private void updateControls() {
           Button toCamera = new Button();
           toCamera.setText("To camera");
           toCamera.setOnAction(event -> {
-            Vector3 cameraPosition = new Vector3(scene.camera().getPosition());
+            Vector3 cameraPosition = scene.camera().getPosition();
             posX.valueProperty().setValue(cameraPosition.x);
             posY.valueProperty().setValue(cameraPosition.y);
             posZ.valueProperty().setValue(cameraPosition.z);
@@ -476,7 +476,7 @@ private void updateControls() {
           Button pos1ToCamera = new Button();
           pos1ToCamera.setText("To camera");
           pos1ToCamera.setOnAction(event -> {
-            Vector3 cameraPosition = new Vector3(scene.camera().getPosition());
+            Vector3 cameraPosition = scene.camera().getPosition();
             x1.valueProperty().setValue(cameraPosition.x);
             y1.valueProperty().setValue(cameraPosition.y);
             z1.valueProperty().setValue(cameraPosition.z);
@@ -498,7 +498,7 @@ private void updateControls() {
           Button pos2ToCamera = new Button();
           pos2ToCamera.setText("To camera");
           pos2ToCamera.setOnAction(event -> {
-            Vector3 cameraPosition = new Vector3(scene.camera().getPosition());
+            Vector3 cameraPosition = scene.camera().getPosition();
             x2.valueProperty().setValue(cameraPosition.x);
             y2.valueProperty().setValue(cameraPosition.y);
             z2.valueProperty().setValue(cameraPosition.z);

From f120a9e3c9e03ae5121fcf3d89fb1f48691ec9f7 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Fri, 13 Oct 2023 00:56:01 +0200
Subject: [PATCH 26/38] Set a random normal for volumetric clouds

---
 .../se/llbit/chunky/renderer/scene/Sky.java   | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
index ef44a301ff..49987d9593 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
@@ -1124,7 +1124,6 @@ public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
     if (volumetricClouds) {
       double testFirstIntersection = firstIntersection;
       double testSecondIntersection = secondIntersection;
-      Vector3 normal = new Vector3(test.getNormal());
       int depth = 0;
       while (true) {
         if (depth >= 1000) {
@@ -1134,7 +1133,25 @@ public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
         double fogDistance = fogPenetrated / cloudDensity;
         if (testFirstIntersection + fogDistance < testSecondIntersection) {
           t = testFirstIntersection + fogDistance;
-          ray.setNormal(normal);
+
+          // Set a random normal
+          Vector3 a1 = new Vector3();
+          a1.cross(ray.d, new Vector3(0, 1, 0));
+          a1.normalize();
+          Vector3 a2 = new Vector3();
+          a2.cross(ray.d, a1);
+          // get random point on unit disk
+          double x1 = random.nextDouble();
+          double x2 = random.nextDouble();
+          double r = FastMath.sqrt(x1);
+          double theta = 2 * Math.PI * x2;
+          double t1 = r * FastMath.cos(theta);
+          double t2 = r * FastMath.sin(theta);
+          a1.scale(t1);
+          a1.scaleAdd(t2, a2);
+          a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
+          ray.setNormal(a1);
+
           ray.setCurrentMaterial(VolumeCloudMaterial.INSTANCE);
           ray.specular = false;
           break;
@@ -1148,7 +1165,6 @@ public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
           }
           testFirstIntersection += (testSecondIntersection - testFirstIntersection) + Ray.OFFSET + testCloudDistance.thing1;
           testSecondIntersection += Ray.OFFSET + testCloudDistance.thing2;
-          normal.set(test2.getNormal());
           depth++;
         }
       }

From ba2ed0ea4cedd2d928626b84193675575b1ba5ee Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Fri, 13 Oct 2023 02:41:55 +0200
Subject: [PATCH 27/38] Remove unused import

---
 chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index c4cab0aecb..a7163fb132 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -24,7 +24,6 @@
 import se.llbit.chunky.renderer.WorkerState;
 import se.llbit.chunky.world.Material;
 import se.llbit.chunky.world.VolumeMaterial;
-import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.math.*;
 
 import java.util.List;

From ad2391a0c592847e9a538a5f0e9a8b70e9e9e68e Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Sat, 14 Oct 2023 10:50:14 +0200
Subject: [PATCH 28/38] Move `Preview particle fog` to `Fog` tab

---
 .../java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java   | 7 -------
 chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java | 6 ++++++
 .../res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml    | 1 -
 chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml  | 2 ++
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java
index df6e311745..012d8d47e5 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/AdvancedTab.java
@@ -69,7 +69,6 @@ public class AdvancedTab extends ScrollPane implements RenderControlsTab, Initia
   @FXML private CheckBox shutdown;
   @FXML private CheckBox fastFog;
   @FXML private CheckBox fancierTranslucency;
-  @FXML private CheckBox previewParticleFog;
   @FXML private DoubleAdjuster transmissivityCap;
   @FXML private IntegerAdjuster cacheResolution;
   @FXML private DoubleAdjuster animationTime;
@@ -165,11 +164,6 @@ public PictureExportFormat fromString(String string) {
         transmissivityCap.setManaged(newValue);
       });
 
-    previewParticleFog.setTooltip(new Tooltip("Render particle fog in the render preview."));
-    previewParticleFog.selectedProperty().addListener((observer, oldValue, newValue) ->
-      scene.setPreviewParticleFog(newValue)
-    );
-
     boolean tcapVisible = scene != null && scene.getFancierTranslucency();
     transmissivityCap.setVisible(tcapVisible);
     transmissivityCap.setManaged(tcapVisible);
@@ -341,7 +335,6 @@ public void update(Scene scene) {
     outputMode.getSelectionModel().select(scene.getOutputMode());
     fastFog.setSelected(scene.fog.fastFog());
     fancierTranslucency.setSelected(scene.getFancierTranslucency());
-    previewParticleFog.setSelected(scene.getPreviewParticleFog());
     transmissivityCap.set(scene.getTransmissivityCap());
     renderThreads.set(PersistentSettings.getNumThreads());
     cpuLoad.set(PersistentSettings.getCPULoad());
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
index 5b683543de..730f45d125 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/FogTab.java
@@ -56,6 +56,7 @@ private static class FogVolumeData {
   @FXML private ComboBox<FogMode> fogMode;
   @FXML private TitledPane fogDetailsPane;
   @FXML private VBox fogDetailsBox;
+  @FXML private CheckBox previewParticleFog;
   @FXML private TableView<FogVolumeData> fogVolumeTable;
   @FXML private TableColumn<FogVolumeData, String> typeCol;
   @FXML private Button addVolume;
@@ -80,6 +81,10 @@ public FogTab() throws IOException {
   }
 
   @Override public void initialize(URL location, ResourceBundle resources) {
+    previewParticleFog.setTooltip(new Tooltip("Render particle fog in the render preview."));
+    previewParticleFog.selectedProperty().addListener((observer, oldValue, newValue) ->
+      scene.setPreviewParticleFog(newValue)
+    );
     fogMode.getItems().addAll(FogMode.values());
     fogMode.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) -> {
       scene.setFogMode(newValue);
@@ -126,6 +131,7 @@ public FogTab() throws IOException {
     fogMode.getSelectionModel().select(scene.fog.getFogMode());
     uniformFogSettings.update(scene);
     layeredFogSettings.update(scene);
+    previewParticleFog.setSelected(scene.getPreviewParticleFog());
     rebuildList();
   }
 
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml
index 9d5474ce64..6c9b960236 100644
--- a/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/AdvancedTab.fxml
@@ -25,7 +25,6 @@
     <CheckBox fx:id="shutdown" mnemonicParsing="false" text="Shutdown computer when render completes" />
     <CheckBox fx:id="fastFog" mnemonicParsing="false" text="Fast fog" />
     <CheckBox fx:id="fancierTranslucency" mnemonicParsing="false" text="Fancier translucency" />
-    <CheckBox fx:id="previewParticleFog" mnemonicParsing="false" text="Preview particle fog" />
     <DoubleAdjuster fx:id="transmissivityCap" />
     <IntegerAdjuster fx:id="cacheResolution" />
     <DoubleAdjuster fx:id="animationTime" />
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml
index bedc1aafe0..7861538990 100644
--- a/chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/FogTab.fxml
@@ -12,6 +12,7 @@
 
 <?import javafx.scene.control.TableView?>
 <?import javafx.scene.control.TableColumn?>
+<?import javafx.scene.control.CheckBox?>
 <fx:root type="javafx.scene.control.ScrollPane" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1">
   <VBox spacing="10.0">
     <Label text="Fast fog settings" />
@@ -32,6 +33,7 @@
     </TitledPane>
     <Separator />
     <Label text="Particle fog settings" />
+    <CheckBox fx:id="previewParticleFog" mnemonicParsing="false" text="Preview particle fog" />
     <HBox alignment="CENTER_LEFT" prefWidth="200.0" spacing="10.0">
       <Button fx:id="addVolume" mnemonicParsing="false" text="Add volume" />
       <Button fx:id="removeVolume" mnemonicParsing="false" text="Remove volume" />

From c3a7721e98b5a34da6222c418fae812ac242bed9 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Sat, 14 Oct 2023 10:50:40 +0200
Subject: [PATCH 29/38] Enable `Preview particle fog` by default

---
 lib/src/se/llbit/chunky/PersistentSettings.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/src/se/llbit/chunky/PersistentSettings.java b/lib/src/se/llbit/chunky/PersistentSettings.java
index 13ee5126dd..03d370caee 100644
--- a/lib/src/se/llbit/chunky/PersistentSettings.java
+++ b/lib/src/se/llbit/chunky/PersistentSettings.java
@@ -663,6 +663,6 @@ public static void setPreviewParticleFog(boolean value) {
   }
 
   public static boolean getPreviewParticleFog() {
-    return settings.getBool("previewParticleFog", false);
+    return settings.getBool("previewParticleFog", true);
   }
 }

From 913b798b6031d7cdc327807225987d66d3f3dcc9 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Sat, 14 Oct 2023 11:09:31 +0200
Subject: [PATCH 30/38] Add volumetric cloud JSON

---
 .../se/llbit/chunky/renderer/scene/Sky.java   | 32 ++++++++++++++++---
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
index 49987d9593..1d32fe9cec 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
@@ -645,6 +645,13 @@ public void setSkyCacheResolution(int resolution) {
     sky.add("cloudsEnabled", cloudsEnabled);
     sky.add("cloudSize", cloudSize.toJson());
     sky.add("cloudOffset", cloudOffset.toJson());
+    JsonObject cloudColorObj = new JsonObject();
+    cloudColorObj.add("red", cloudColor.x);
+    cloudColorObj.add("green", cloudColor.y);
+    cloudColorObj.add("blue", cloudColor.z);
+    sky.add("cloudColor", cloudColorObj);
+    sky.add("volumetricClouds", volumetricClouds);
+    sky.add("cloudDensity", cloudDensity);
 
     // Always save gradient.
     sky.add("gradient", gradientJson(gradient));
@@ -714,6 +721,16 @@ public void importFromJson(JsonObject json) {
     if (json.get("cloudOffset").isObject()) {
       cloudOffset.fromJson(json.get("cloudOffset").object());
     }
+    if (json.get("cloudColor").isObject()) {
+      JsonObject colorObj = json.get("cloudColor").object();
+      cloudColor.x = colorObj.get("red").doubleValue(cloudColor.x);
+      cloudColor.y = colorObj.get("green").doubleValue(cloudColor.y);
+      cloudColor.z = colorObj.get("blue").doubleValue(cloudColor.z);
+    } else {
+      cloudColor.set(1, 1, 1);
+    }
+    volumetricClouds = json.get("volumetricClouds").boolValue(false);
+    cloudDensity = json.get("cloudDensity").doubleValue(cloudDensity);
 
     if (json.get("gradient").isArray()) {
       List<Vector4> theGradient = gradientFromJson(json.get("gradient").array());
@@ -724,9 +741,9 @@ public void importFromJson(JsonObject json) {
 
     if (json.get("color").isObject()) {
       JsonObject colorObj = json.get("color").object();
-      color.x = colorObj.get("red").doubleValue(1);
-      color.y = colorObj.get("green").doubleValue(1);
-      color.z = colorObj.get("blue").doubleValue(1);
+      color.x = colorObj.get("red").doubleValue(color.x);
+      color.y = colorObj.get("green").doubleValue(color.y);
+      color.z = colorObj.get("blue").doubleValue(color.z);
     } else {
       // Maintain backwards-compatibility with scenes saved in older Chunky versions
       color.set(JsonUtil.vec3FromJsonArray(json.get("color")));
@@ -1109,7 +1126,7 @@ private Pair<Double, Double> getCloudDistance(Scene scene, Ray ray) {
   }
 
   public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
-    if (random == null) {
+    if (random == null && volumetricClouds) {
       return false;
     }
     Ray test = new Ray(ray);
@@ -1134,6 +1151,10 @@ public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
         if (testFirstIntersection + fogDistance < testSecondIntersection) {
           t = testFirstIntersection + fogDistance;
 
+          if (t >= ray.t) {
+            return false;
+          }
+
           // Set a random normal
           Vector3 a1 = new Vector3();
           a1.cross(ray.d, new Vector3(0, 1, 0));
@@ -1170,6 +1191,9 @@ public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
       }
     } else {
       t = firstIntersection;
+      if (t >= ray.t) {
+        return false;
+      }
       ray.setNormal(test.getNormal());
       if (secondIntersection == 1) {
         ray.setCurrentMaterial(Air.INSTANCE);

From 217df7f288d495ddb6e7277be6fd2370f1b0fff7 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Sat, 14 Oct 2023 11:10:36 +0200
Subject: [PATCH 31/38] Add IntersectionConfig

---
 .../renderer/scene/IntersectionConfig.java    | 19 ++++++++
 .../chunky/renderer/scene/PathTracer.java     |  6 +--
 .../renderer/scene/PreviewRayTracer.java      | 48 +++++++++++++------
 .../se/llbit/chunky/renderer/scene/Scene.java |  4 +-
 4 files changed, 58 insertions(+), 19 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java b/chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java
new file mode 100644
index 0000000000..cf9bb3487e
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java
@@ -0,0 +1,19 @@
+package se.llbit.chunky.renderer.scene;
+
+public class IntersectionConfig {
+  public final boolean cloudIntersect;
+  public final boolean fogIntersect;
+  public final boolean waterPlaneIntersect;
+  public final boolean sceneIntersect;
+
+  public IntersectionConfig(boolean cloudIntersect, boolean fogIntersect, boolean waterPlaneIntersect, boolean sceneIntersect) {
+    this.cloudIntersect = cloudIntersect;
+    this.fogIntersect = fogIntersect;
+    this.waterPlaneIntersect = waterPlaneIntersect;
+    this.sceneIntersect = sceneIntersect;
+  }
+
+  public static IntersectionConfig defaultIntersect(Scene scene, boolean isRenderPreview) {
+    return new IntersectionConfig(scene.sky().cloudsEnabled(), !isRenderPreview || scene.getPreviewParticleFog(), scene.isWaterPlaneEnabled(), true);
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index a7163fb132..39e7ea7f0b 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -66,7 +66,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
 
     while (true) {
 
-      if (!PreviewRayTracer.nextIntersection(scene, ray, true, random)) {
+      if (!PreviewRayTracer.nextIntersection(scene, ray, random, IntersectionConfig.defaultIntersect(scene, false))) {
         if (ray.getPrevMaterial().isWater()) {
           ray.color.set(0, 0, 0, 1);
           hit = true;
@@ -579,7 +579,7 @@ private static void sampleEmitterFace(Scene scene, Ray ray, Grid.EmitterPosition
 
       emitterRay.o.scaleAdd(Ray.OFFSET, emitterRay.d);
       emitterRay.distance += Ray.OFFSET;
-      PreviewRayTracer.nextIntersection(scene, emitterRay, true, random);
+      PreviewRayTracer.nextIntersection(scene, emitterRay, random, IntersectionConfig.defaultIntersect(scene, false));
       if (Math.abs(emitterRay.distance - distance) < Ray.OFFSET) {
         double e = Math.abs(emitterRay.d.dot(emitterRay.getNormal()));
         e /= Math.max(distance * distance, 1);
@@ -635,7 +635,7 @@ public static void getDirectLightAttenuation(Scene scene, Ray ray, WorkerState s
     attenuation.w = 1;
     while (attenuation.w > 0) {
       ray.o.scaleAdd(Ray.OFFSET, ray.d);
-      if (!PreviewRayTracer.nextIntersection(scene, ray, true, state.random)) {
+      if (!PreviewRayTracer.nextIntersection(scene, ray, state.random, IntersectionConfig.defaultIntersect(scene, false))) {
         break;
       }
       double mult = 1 - ray.color.w;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
index cb5059ee81..32be683d0e 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
@@ -43,7 +43,7 @@ public class PreviewRayTracer implements RayTracer {
       ray.setCurrentMaterial(Air.INSTANCE);
     }
     while (true) {
-      if (!nextIntersection(scene, ray, scene.getPreviewParticleFog(), state.random)) {
+      if (!nextIntersection(scene, ray, state.random, IntersectionConfig.defaultIntersect(scene, true))) {
         if (mapIntersection(scene, ray)) {
           break;
         }
@@ -70,7 +70,7 @@ public static double skyOcclusion(Scene scene, WorkerState state) {
     Ray ray = state.ray;
     double occlusion = 1.0;
     while (true) {
-      if (!nextIntersection(scene, ray)) {
+      if (!nextIntersection(scene, ray, state.random, IntersectionConfig.defaultIntersect(scene, false))) {
         break;
       } else {
         occlusion *= (1 - ray.color.w);
@@ -85,28 +85,27 @@ public static double skyOcclusion(Scene scene, WorkerState state) {
 
   /**
    * Find next ray intersection.
-   * @param particleFog Whether to process particle fog
    * @param random Used for particle fog, can be null if particleFog is false
    * @return Next intersection
    */
-  public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog, Random random) {
+  public static boolean nextIntersection(Scene scene, Ray ray, Random random, IntersectionConfig config) {
     ray.setPrevMaterial(ray.getCurrentMaterial(), ray.getCurrentData());
     ray.t = Double.POSITIVE_INFINITY;
     boolean hit = false;
-    if (scene.sky().cloudsEnabled()) {
-      hit = scene.sky().cloudIntersection(scene, ray, random);
+    if (config.cloudIntersect) {
+      hit |= cloudIntersection(scene, ray, random);
     }
-    if (scene.isWaterPlaneEnabled()) {
-      hit = waterPlaneIntersection(scene, ray) || hit;
+    if (config.waterPlaneIntersect) {
+      hit |= waterPlaneIntersection(scene, ray);
     }
-    if (particleFog) {
-      for(FogVolume v : scene.fog.getFogVolumes()) {
-        hit |= v.intersect(ray, scene, random);
-      }
+    if (config.fogIntersect) {
+      hit |= fogIntersection(scene, ray, random);
     }
-    if (scene.intersect(ray)) {
+    if (config.sceneIntersect) {
       // Octree tracer handles updating distance.
-      return true;
+      if (sceneIntersection(scene, ray)) {
+        return true;
+      }
     }
     if (hit) {
       ray.distance += ray.t;
@@ -120,7 +119,22 @@ public static boolean nextIntersection(Scene scene, Ray ray, boolean particleFog
   }
 
   public static boolean nextIntersection(Scene scene, Ray ray) {
-    return nextIntersection(scene, ray, false, null);
+    return nextIntersection(scene, ray, null, new IntersectionConfig((scene.sky.cloudsEnabled() && !scene.sky.getVolumetricClouds()), false, scene.waterPlaneEnabled, true));
+  }
+
+  private static boolean cloudIntersection(Scene scene, Ray ray, Random random) {
+    return scene.sky.cloudIntersection(scene, ray, random);
+  }
+
+  private static boolean fogIntersection(Scene scene, Ray ray, Random random) {
+    if (random == null) {
+      return false;
+    }
+    boolean hit = false;
+    for(FogVolume v : scene.fog.getFogVolumes()) {
+      hit |= v.intersect(ray, scene, random);
+    }
+    return hit;
   }
 
   private static boolean waterPlaneIntersection(Scene scene, Ray ray) {
@@ -152,6 +166,10 @@ private static boolean waterPlaneIntersection(Scene scene, Ray ray) {
     return false;
   }
 
+  private static boolean sceneIntersection(Scene scene, Ray ray) {
+    return scene.intersect(ray);
+  }
+
   // Chunk pattern config
   private static final double chunkPatternLineWidth = 0.5; // in blocks
   private static final double chunkPatternLinePosition = 8 - chunkPatternLineWidth / 2;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
index e80d838dd0..cdc8cfc111 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
@@ -1685,7 +1685,9 @@ public boolean traceTarget(Ray ray) {
     ray.o.x -= origin.x;
     ray.o.y -= origin.y;
     ray.o.z -= origin.z;
-    while (PreviewRayTracer.nextIntersection(this, ray)) {
+    while (PreviewRayTracer.nextIntersection(this, ray, null,
+      new IntersectionConfig((sky.cloudsEnabled() && !sky.getVolumetricClouds()),
+        false, waterPlaneEnabled, true))) {
       if (ray.getCurrentMaterial() != Air.INSTANCE) {
         return true;
       }

From b7b1121d211e5574bbb87b673bd9974991ea8858 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Tue, 17 Oct 2023 22:51:55 +0200
Subject: [PATCH 32/38] Implement multiple cloud layers

---
 .../chunky/renderer/scene/CloudLayer.java     | 542 ++++++++++++++++
 .../renderer/scene/CuboidFogVolume.java       |   2 +-
 .../renderer/scene/ExponentialFogVolume.java  |   2 +-
 .../se/llbit/chunky/renderer/scene/Fog.java   |  27 +-
 .../chunky/renderer/scene/FogVolume.java      |  35 +-
 .../renderer/scene/IntersectionConfig.java    |   2 +-
 .../chunky/renderer/scene/LayerFogVolume.java |   2 +-
 .../renderer/scene/PreviewRayTracer.java      |  11 +-
 .../se/llbit/chunky/renderer/scene/Scene.java |  13 +-
 .../se/llbit/chunky/renderer/scene/Sky.java   | 601 +++++-------------
 .../renderer/scene/SphericalFogVolume.java    |   2 +-
 .../se/llbit/chunky/renderer/scene/Sun.java   |  23 +-
 .../llbit/chunky/ui/render/tabs/SkyTab.java   | 231 ++++++-
 .../se/llbit/chunky/world/ExtraMaterials.java |   6 -
 .../se/llbit/chunky/world/VolumeMaterial.java |  25 +
 .../chunky/world/material/CloudMaterial.java  |   4 +-
 .../world/material/ParticleFogMaterial.java   |   2 -
 .../world/material/VolumeCloudMaterial.java   |   4 +-
 chunky/src/java/se/llbit/math/ColorUtil.java  |  17 +
 .../llbit/chunky/ui/render/tabs/SkyTab.fxml   |  16 +-
 20 files changed, 985 insertions(+), 582 deletions(-)
 create mode 100644 chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java
new file mode 100644
index 0000000000..e37f3a4097
--- /dev/null
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java
@@ -0,0 +1,542 @@
+package se.llbit.chunky.renderer.scene;
+
+import org.apache.commons.math3.util.FastMath;
+import se.llbit.chunky.block.minecraft.Air;
+import se.llbit.chunky.world.Clouds;
+import se.llbit.chunky.world.Material;
+import se.llbit.chunky.world.VolumeMaterial;
+import se.llbit.chunky.world.material.CloudMaterial;
+import se.llbit.chunky.world.material.VolumeCloudMaterial;
+import se.llbit.json.JsonObject;
+import se.llbit.math.ColorUtil;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+import se.llbit.util.JsonSerializable;
+import se.llbit.util.Pair;
+
+import java.util.Random;
+
+public class CloudLayer implements JsonSerializable {
+  /**
+   * Default cloud y-position
+   */
+  protected static final int DEFAULT_CLOUD_HEIGHT = 128;
+
+  protected static final int DEFAULT_CLOUD_SIZE = 12;
+
+  protected static final double DEFAULT_CLOUD_DENSITY = 0.2;
+
+  private final Vector3 size = new Vector3(DEFAULT_CLOUD_SIZE, 4, DEFAULT_CLOUD_SIZE);
+  private final Vector3 offset = new Vector3(0, DEFAULT_CLOUD_HEIGHT, 0);
+  private final Vector3 color = new Vector3(1, 1, 1);
+  private boolean volumetricClouds = false;
+  private double density = DEFAULT_CLOUD_DENSITY;
+  private final Material material = new CloudMaterial();
+  private final VolumeMaterial volumeMaterial = new VolumeCloudMaterial();
+
+  public Vector3 getCloudColor() {
+    return new Vector3(color);
+  }
+
+  public void setCloudColor(Vector3 color) {
+    this.color.set(color);
+  }
+
+
+  public boolean getVolumetricClouds() {
+    return volumetricClouds;
+  }
+
+  public void setVolumetricClouds(boolean value) {
+    volumetricClouds = value;
+  }
+
+
+  public double getCloudDensity() {
+    return density;
+  }
+
+  public void setCloudDensity(double value) {
+    density = value;
+  }
+
+
+  public double getCloudSizeX() {
+    return size.x;
+  }
+
+  public void setCloudSizeX(double newValue) {
+    if (newValue != size.x) {
+      size.x = newValue;
+    }
+  }
+
+
+  public double getCloudSizeY() {
+    return size.y;
+  }
+
+  public void setCloudSizeY(double newValue) {
+    if (newValue != size.y) {
+      size.y = newValue;
+    }
+  }
+
+
+  public double getCloudSizeZ() {
+    return size.z;
+  }
+
+  public void setCloudSizeZ(double newValue) {
+    if (newValue != size.z) {
+      size.z = newValue;
+    }
+  }
+
+
+  public double getCloudXOffset() {
+    return offset.x;
+  }
+
+  public void setCloudXOffset(double newValue) {
+    if (newValue != offset.x) {
+      offset.x = newValue;
+    }
+  }
+
+
+  /**
+   * @return The current cloud height
+   */
+  public double getCloudYOffset() {
+    return offset.y;
+  }
+
+  /**
+   * Change the cloud height
+   */
+  public void setCloudYOffset(double newValue) {
+    if (newValue != offset.y) {
+      offset.y = newValue;
+    }
+  }
+
+
+  public double getCloudZOffset() {
+    return offset.z;
+  }
+
+  public void setCloudZOffset(double newValue) {
+    if (newValue != offset.z) {
+      offset.z = newValue;
+    }
+  }
+
+  public float getEmittance() {
+    return volumetricClouds ? volumeMaterial.emittance : material.emittance;
+  }
+
+  public void setEmittance(float value) {
+    if (volumetricClouds) {
+      volumeMaterial.emittance = value;
+    } else {
+      material.emittance = value;
+    }
+  }
+
+  public float getSpecular() {
+    return material.specular;
+  }
+
+  public void setSpecular(float value) {
+    material.specular = value;
+  }
+
+  public float getSmoothness() {
+    return (float) material.getPerceptualSmoothness();
+  }
+
+  public void setSmoothness(float value) {
+    material.setPerceptualSmoothness(value);
+  }
+
+  public float getIor() {
+    return material.ior;
+  }
+
+  public void setIor(float value) {
+    material.ior = value;
+  }
+
+  public float getMetalness() {
+    return material.metalness;
+  }
+
+  public void setMetalness(float value) {
+    material.emittance = value;
+  }
+
+  public float getAnisotropy() {
+    return volumeMaterial.anisotropy;
+  }
+
+  public void setAnisotropy(float value) {
+    volumeMaterial.anisotropy = value;
+  }
+
+  private Pair<Double, Double> getCloudDistance(Scene scene, Ray ray) {
+    Pair<Boolean, Boolean> cloudIntersectionTest = cloudIntersection(scene, ray);
+    boolean hitCloud = cloudIntersectionTest.thing1;
+    boolean insideCloud = cloudIntersectionTest.thing2;
+    if (!hitCloud) {
+      return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+    } else {
+      if (!volumetricClouds) {
+        double t = ray.t;
+        double tExit;
+        if (insideCloud) {
+          tExit = 1d;
+        } else {
+          tExit = 0d;
+        }
+        return new Pair<>(t, tExit);
+      } else {
+        if (insideCloud) {
+          double t;
+          double tExit;
+          t = 0;
+          tExit = ray.t;
+          return new Pair<>(t, tExit);
+        } else {
+          double t = ray.t;
+          double tExit;
+          double depth = 0;
+          while (true) {
+            if (depth >= 1000) {
+              return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+            }
+            Ray nextIntersection = new Ray(ray);
+            nextIntersection.t = Double.POSITIVE_INFINITY;
+            nextIntersection.o.scaleAdd(t + Ray.OFFSET, ray.d);
+            Pair<Boolean, Boolean> testSecondIntersection = cloudIntersection(scene, nextIntersection);
+            if (!testSecondIntersection.thing1) {
+              return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
+            } else {
+              if (testSecondIntersection.thing2) {
+                tExit = t + Ray.OFFSET + nextIntersection.t;
+                break;
+              } else {
+                t += Ray.OFFSET + nextIntersection.t;
+                depth++;
+              }
+            }
+          }
+          return new Pair<>(t, tExit);
+        }
+      }
+    }
+  }
+
+  public boolean intersect(Scene scene, Ray ray, Random random) {
+    if (random == null && volumetricClouds) {
+      return false;
+    }
+    Ray test = new Ray(ray);
+    test.t = ray.t;
+    Pair<Double, Double> cloudDistance = getCloudDistance(scene, test);
+    double firstIntersection = cloudDistance.thing1;
+    if (firstIntersection == Double.POSITIVE_INFINITY) {
+      return false;
+    }
+    double secondIntersection = cloudDistance.thing2;
+    double t;
+    if (volumetricClouds) {
+      double testFirstIntersection = firstIntersection;
+      double testSecondIntersection = secondIntersection;
+      int depth = 0;
+      while (true) {
+        if (depth >= 1000) {
+          return false;
+        }
+        double fogPenetrated = -FastMath.log(1 - random.nextDouble());
+        double fogDistance = fogPenetrated / density;
+        if (testFirstIntersection + fogDistance < testSecondIntersection) {
+          t = testFirstIntersection + fogDistance;
+
+          if (t >= ray.t) {
+            return false;
+          }
+
+          volumeMaterial.setRandomSphericalNormal(ray, random);
+
+          ray.setCurrentMaterial(volumeMaterial);
+          ray.specular = false;
+          break;
+        } else {
+          Ray test2 = new Ray(ray);
+          test2.t = Double.POSITIVE_INFINITY;
+          test2.o.scaleAdd(testSecondIntersection + Ray.OFFSET, ray.d);
+          Pair<Double, Double> testCloudDistance = getCloudDistance(scene, test2);
+          if (testCloudDistance.thing1 == Double.POSITIVE_INFINITY) {
+            return false;
+          }
+          testFirstIntersection += (testSecondIntersection - testFirstIntersection) + Ray.OFFSET + testCloudDistance.thing1;
+          testSecondIntersection += Ray.OFFSET + testCloudDistance.thing2;
+          depth++;
+        }
+      }
+    } else {
+      t = firstIntersection;
+      if (t >= ray.t) {
+        return false;
+      }
+      ray.setNormal(test.getNormal());
+      if (secondIntersection == 1) {
+        ray.setCurrentMaterial(Air.INSTANCE);
+      } else {
+        ray.setCurrentMaterial(material);
+      }
+    }
+    ray.t = t;
+    ray.color.set(color.x, color.y, color.z, 1);
+    return true;
+  }
+
+  /**
+   * Test for a cloud intersection. If the ray intersects a cloud,
+   * the distance to the intersection is stored in <code>ray.t</code>.
+   * @param ray Ray with which to test for cloud intersection.
+   * @return {@link se.llbit.util.Pair} of Booleans.
+   * <code>pair.thing1</code>: <code>true</code> if the ray intersected a cloud.
+   * <code>pair.thing2</code>: <code>true</code> if the ray origin is inside a cloud.
+   */
+  private Pair<Boolean, Boolean> cloudIntersection(Scene scene, Ray ray) {
+    double ox = ray.o.x + scene.origin.x;
+    double oy = ray.o.y + scene.origin.y;
+    double oz = ray.o.z + scene.origin.z;
+    double offsetX = offset.x;
+    double offsetY = offset.y;
+    double offsetZ = offset.z;
+    double invSizeX = 1 / size.x;
+    double invSizeZ = 1 / size.z;
+    double cloudTop = offsetY + size.y;
+    int target = 1;
+    double t_offset = 0;
+    if (oy < offsetY || oy > cloudTop) {
+      if (ray.d.y > 0) {
+        t_offset = (offsetY - oy) / ray.d.y;
+      } else {
+        t_offset = (cloudTop - oy) / ray.d.y;
+      }
+      if (t_offset < 0) {
+        return new Pair<>(false, false);
+      }
+      // Ray is entering cloud.
+      if (inCloud((ray.d.x * t_offset + ox) * invSizeX + offsetX,
+        (ray.d.z * t_offset + oz) * invSizeZ + offsetZ)) {
+        ray.setNormal(0, -Math.signum(ray.d.y), 0);
+        ray.t = t_offset;
+        return new Pair<>(true, false);
+      }
+    } else if (inCloud(ox * invSizeX + offsetX, oz * invSizeZ + offsetZ)) {
+      target = 0;
+    }
+    double tExit;
+    if (ray.d.y > 0) {
+      tExit = (cloudTop - oy) / ray.d.y - t_offset;
+    } else {
+      tExit = (offsetY - oy) / ray.d.y - t_offset;
+    }
+    if (ray.t < tExit) {
+      tExit = ray.t;
+    }
+    double x0 = (ox + ray.d.x * t_offset) * invSizeX + offsetX;
+    double z0 = (oz + ray.d.z * t_offset) * invSizeZ + offsetZ;
+    double xp = x0;
+    double zp = z0;
+    int ix = (int) Math.floor(xp);
+    int iz = (int) Math.floor(zp);
+    int xmod = (int) Math.signum(ray.d.x), zmod = (int) Math.signum(ray.d.z);
+    int xo = (1 + xmod) / 2, zo = (1 + zmod) / 2;
+    double dx = Math.abs(ray.d.x) * invSizeX;
+    double dz = Math.abs(ray.d.z) * invSizeZ;
+    double t = 0;
+    int i = 0;
+    int nx = 0, nz = 0;
+    if (dx > dz) {
+      double m = dz / dx;
+      double xrem = xmod * (ix + xo - xp);
+      double zlimit = xrem * m;
+      while (t < tExit) {
+        double zrem = zmod * (iz + zo - zp);
+        if (zrem < zlimit) {
+          iz += zmod;
+          if (Clouds.getCloud(ix, iz) == target) {
+            t = i / dx + zrem / dz;
+            nx = 0;
+            nz = -zmod;
+            break;
+          }
+          ix += xmod;
+          if (Clouds.getCloud(ix, iz) == target) {
+            t = (i + xrem) / dx;
+            nx = -xmod;
+            nz = 0;
+            break;
+          }
+        } else {
+          ix += xmod;
+          if (Clouds.getCloud(ix, iz) == target) {
+            t = (i + xrem) / dx;
+            nx = -xmod;
+            nz = 0;
+            break;
+          }
+          if (zrem <= m) {
+            iz += zmod;
+            if (Clouds.getCloud(ix, iz) == target) {
+              t = i / dx + zrem / dz;
+              nx = 0;
+              nz = -zmod;
+              break;
+            }
+          }
+        }
+        t = i / dx;
+        i += 1;
+        zp = z0 + zmod * i * m;
+      }
+    } else {
+      double m = dx / dz;
+      double zrem = zmod * (iz + zo - zp);
+      double xlimit = zrem * m;
+      while (t < tExit) {
+        double xrem = xmod * (ix + xo - xp);
+        if (xrem < xlimit) {
+          ix += xmod;
+          if (Clouds.getCloud(ix, iz) == target) {
+            t = i / dz + xrem / dx;
+            nx = -xmod;
+            nz = 0;
+            break;
+          }
+          iz += zmod;
+          if (Clouds.getCloud(ix, iz) == target) {
+            t = (i + zrem) / dz;
+            nx = 0;
+            nz = -zmod;
+            break;
+          }
+        } else {
+          iz += zmod;
+          if (Clouds.getCloud(ix, iz) == target) {
+            t = (i + zrem) / dz;
+            nx = 0;
+            nz = -zmod;
+            break;
+          }
+          if (xrem <= m) {
+            ix += xmod;
+            if (Clouds.getCloud(ix, iz) == target) {
+              t = i / dz + xrem / dx;
+              nx = -xmod;
+              nz = 0;
+              break;
+            }
+          }
+        }
+        t = i / dz;
+        i += 1;
+        xp = x0 + xmod * i * m;
+      }
+    }
+    int ny = 0;
+    if (target == 1) {
+      if (t > tExit) {
+        return new Pair<>(false, false);
+      }
+      if (nx == 0 && ny == 0 && nz == 0) {
+        // fix ray.n being set to zero (issue #643)
+        return new Pair<>(false, false);
+      }
+      ray.setNormal(nx, ny, nz);
+      ray.t = t + t_offset;
+      return new Pair<>(true, false);
+    } else {
+      if (t > tExit) {
+        nx = 0;
+        ny = (int) Math.signum(ray.d.y);
+        nz = 0;
+        t = tExit;
+      } else {
+        nx = -nx;
+        nz = -nz;
+      }
+      if (nx == 0 && ny == 0 && nz == 0) {
+        // fix ray.n being set to zero (issue #643)
+        return new Pair<>(false, false);
+      }
+      ray.setNormal(nx, ny, nz);
+      ray.t = t;
+      return new Pair<>(true, true);
+    }
+  }
+
+  private static boolean inCloud(double x, double z) {
+    return Clouds.getCloud((int) Math.floor(x), (int) Math.floor(z)) == 1;
+  }
+
+  public JsonObject toJson() {
+    JsonObject cloudLayerJson = new JsonObject();
+    cloudLayerJson.add("size", size.toJson());
+    cloudLayerJson.add("offset", offset.toJson());
+    cloudLayerJson.add("color", ColorUtil.rgbToJson(color));
+    cloudLayerJson.add("volumetricClouds", volumetricClouds);
+    cloudLayerJson.add("density", density);
+    cloudLayerJson.add("flatMaterialProperties", flatMaterialToJson());
+    cloudLayerJson.add("volumeMaterialProperties", volumeMaterialToJson());
+    return cloudLayerJson;
+  }
+
+  private JsonObject flatMaterialToJson() {
+    JsonObject flatMaterial = new JsonObject();
+    flatMaterial.add("emittance", material.emittance);
+    flatMaterial.add("specular", material.specular);
+    flatMaterial.add("roughness", material.roughness);
+    flatMaterial.add("ior", material.ior);
+    flatMaterial.add("metalness", material.metalness);
+    return flatMaterial;
+  }
+
+  private JsonObject volumeMaterialToJson() {
+    JsonObject volumeMaterialObject = new JsonObject();
+    volumeMaterialObject.add("emittance", volumeMaterial.emittance);
+    volumeMaterialObject.add("anisotropy", volumeMaterial.anisotropy);
+    return volumeMaterialObject;
+  }
+
+  public void importFromJson(JsonObject json) {
+    size.fromJson(json.get("size").asObject());
+    offset.fromJson(json.get("offset").asObject());
+    color.set(ColorUtil.jsonToRGB(json.get("color").asObject()));
+    volumetricClouds = json.get("volumetricClouds").boolValue(volumetricClouds);
+    density = json.get("density").doubleValue(density);
+    JsonObject flatMaterialProperties = json.get("flatMaterialProperties").asObject();
+    importFlatMaterial(flatMaterialProperties);
+    JsonObject volumeMaterialProperties = json.get("volumeMaterialProperties").asObject();
+    importVolumeMaterial(volumeMaterialProperties);
+  }
+
+  private void importFlatMaterial(JsonObject json) {
+    material.emittance = json.get("emittance").floatValue(material.emittance);
+    material.specular = json.get("specular").floatValue(material.specular);
+    material.roughness = json.get("roughness").floatValue(material.roughness);
+    material.ior = json.get("ior").floatValue(material.ior);
+    material.metalness = json.get("metalness").floatValue(material.metalness);
+  }
+
+  private void importVolumeMaterial(JsonObject json) {
+    volumeMaterial.emittance = json.get("emittance").floatValue(material.emittance);
+    volumeMaterial.anisotropy = json.get("anisotropy").floatValue(material.anisotropy);
+  }
+}
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
index 7eacf5ba9c..cc112f9904 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CuboidFogVolume.java
@@ -18,7 +18,7 @@ public class CuboidFogVolume extends FogVolume {
   private AABB aabb;
 
   @Override
-  public boolean intersect(Ray ray, Scene scene, Random random) {
+  public boolean intersect(Scene scene, Ray ray, Random random) {
     double distance;
     double fogPenetrated = -FastMath.log(1 - random.nextDouble());
     double fogDistance = fogPenetrated / density;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
index f379139c7e..1c1559be63 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/ExponentialFogVolume.java
@@ -25,7 +25,7 @@ public ExponentialFogVolume(Vector3 color, double density) {
   }
 
   @Override
-  public boolean intersect(Ray ray, Scene scene, Random random) {
+  public boolean intersect(Scene scene, Ray ray, Random random) {
     // Amount of fog the ray should pass through before being scattered
     // Sampled from an exponential distribution
     double fogPenetrated = -FastMath.log(1 - random.nextDouble());
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
index 51b254e465..e95c45b1d0 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Fog.java
@@ -230,6 +230,17 @@ private double sampleLayeredScatterOffset(Random random, double y1, double y2, d
     return (offsetY - y1) / clampDy(dy);
   }
 
+  public boolean particleFogIntersection(Scene scene, Ray ray, Random random) {
+    if (random == null) {
+      return false;
+    }
+    boolean hit = false;
+    for (FogVolume v : volumes) {
+      hit |= v.intersect(scene, ray, random);
+    }
+    return hit;
+  }
+
   @Override public JsonObject toJson() {
     JsonObject fogObj = new JsonObject();
     fogObj.add("mode", mode.name());
@@ -249,11 +260,7 @@ private double sampleLayeredScatterOffset(Random random, double y1, double y2, d
       jsonVolumes.add(volume.toJson());
     }
     fogObj.add("volumes", jsonVolumes);
-    JsonObject colorObj = new JsonObject();
-    colorObj.add("red", fogColor.x);
-    colorObj.add("green", fogColor.y);
-    colorObj.add("blue", fogColor.z);
-    fogObj.add("color", colorObj);
+    fogObj.add("color", ColorUtil.rgbToJson(fogColor));
     fogObj.add("fastFog", fastFog);
     return fogObj;
   }
@@ -276,10 +283,7 @@ public void importFromJson(JsonObject json, Scene scene) {
       fogVolume.importFromJson(jsonVolumeObject);
       addVolume(fogVolume);
     }
-    JsonObject colorObj = json.get("color").object();
-    fogColor.x = colorObj.get("red").doubleValue(fogColor.x);
-    fogColor.y = colorObj.get("green").doubleValue(fogColor.y);
-    fogColor.z = colorObj.get("blue").doubleValue(fogColor.z);
+    fogColor.set(ColorUtil.jsonToRGB(json.get("color").object()));
     fastFog = json.get("fastFog").boolValue(fastFog);
   }
 
@@ -289,10 +293,7 @@ public void importFromLegacy(JsonObject json) {
     skyFogDensity = json.get("skyFogDensity").doubleValue(skyFogDensity);
     layers.clear();
     volumes.clear();
-    JsonObject colorObj = json.get("fogColor").object();
-    fogColor.x = colorObj.get("red").doubleValue(fogColor.x);
-    fogColor.y = colorObj.get("green").doubleValue(fogColor.y);
-    fogColor.z = colorObj.get("blue").doubleValue(fogColor.z);
+    fogColor.set(ColorUtil.jsonToRGB(json.get("fogColor").asObject()));
     fastFog = json.get("fastFog").boolValue(fastFog);
   }
 
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
index dcdfb97d5c..2905e2335a 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/FogVolume.java
@@ -1,9 +1,10 @@
 package se.llbit.chunky.renderer.scene;
 
-import org.apache.commons.math3.util.FastMath;
 import se.llbit.chunky.world.Material;
+import se.llbit.chunky.world.VolumeMaterial;
 import se.llbit.chunky.world.material.ParticleFogMaterial;
 import se.llbit.json.JsonObject;
+import se.llbit.math.ColorUtil;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
 import se.llbit.util.JsonSerializable;
@@ -14,27 +15,12 @@ public abstract class FogVolume implements JsonSerializable {
   protected FogVolumeType type;
   protected Vector3 color;
   protected double density;
-  protected Material material = new ParticleFogMaterial();
+  protected VolumeMaterial material = new ParticleFogMaterial();
 
-  public abstract boolean intersect(Ray ray, Scene scene, Random random);
+  public abstract boolean intersect(Scene scene, Ray ray, Random random);
 
   public void setRandomNormal(Ray ray, Random random) {
-    Vector3 a1 = new Vector3();
-    a1.cross(ray.d, new Vector3(0, 1, 0));
-    a1.normalize();
-    Vector3 a2 = new Vector3();
-    a2.cross(ray.d, a1);
-    // get random point on unit disk
-    double x1 = random.nextDouble();
-    double x2 = random.nextDouble();
-    double r = FastMath.sqrt(x1);
-    double theta = 2 * Math.PI * x2;
-    double t1 = r * FastMath.cos(theta);
-    double t2 = r * FastMath.sin(theta);
-    a1.scale(t1);
-    a1.scaleAdd(t2, a2);
-    a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
-    ray.setNormal(a1);
+    material.setRandomSphericalNormal(ray, random);
   }
 
   public void setRayMaterialAndColor(Ray ray) {
@@ -88,11 +74,7 @@ public FogVolumeType getType() {
   public JsonObject toJson() {
     JsonObject properties = volumeSpecificPropertiesToJson();
     properties.add("type", type.name());
-    JsonObject colorObj = new JsonObject();
-    colorObj.add("red", color.x);
-    colorObj.add("green", color.y);
-    colorObj.add("blue", color.z);
-    properties.add("color", colorObj);
+    properties.add("color", ColorUtil.rgbToJson(color));
     properties.add("density", density);
     properties.add("materialProperties", materialPropertiesToJson());
     return properties;
@@ -108,10 +90,7 @@ protected JsonObject materialPropertiesToJson() {
   protected abstract void importVolumeSpecificProperties(JsonObject jsonObject);
 
   public void importFromJson(JsonObject json) {
-    JsonObject colorObj = json.get("color").object();
-    color.x = colorObj.get("red").doubleValue(color.x);
-    color.y = colorObj.get("green").doubleValue(color.y);
-    color.z = colorObj.get("blue").doubleValue(color.z);
+    color.set(ColorUtil.jsonToRGB(json.get("color").asObject()));
     density = json.get("density").doubleValue(Scene.DEFAULT_FOG_DENSITY);
     JsonObject materialProperties = json.get("materialProperties").object();
     importMaterialProperties(materialProperties);
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java b/chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java
index cf9bb3487e..526870150a 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/IntersectionConfig.java
@@ -14,6 +14,6 @@ public IntersectionConfig(boolean cloudIntersect, boolean fogIntersect, boolean
   }
 
   public static IntersectionConfig defaultIntersect(Scene scene, boolean isRenderPreview) {
-    return new IntersectionConfig(scene.sky().cloudsEnabled(), !isRenderPreview || scene.getPreviewParticleFog(), scene.isWaterPlaneEnabled(), true);
+    return new IntersectionConfig(true, !isRenderPreview || scene.getPreviewParticleFog(), scene.isWaterPlaneEnabled(), true);
   }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
index 9db6e76a5b..3f150b0384 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/LayerFogVolume.java
@@ -24,7 +24,7 @@ public LayerFogVolume(Vector3 color, double density) {
   }
 
   @Override
-  public boolean intersect(Ray ray, Scene scene, Random random) {
+  public boolean intersect(Scene scene, Ray ray, Random random) {
     // Amount of fog the ray should pass through before being scattered
     // Sampled from an exponential distribution
     double fogPenetrated = -Math.log(1 - random.nextDouble());
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
index 32be683d0e..4e066044d3 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PreviewRayTracer.java
@@ -119,7 +119,7 @@ public static boolean nextIntersection(Scene scene, Ray ray, Random random, Inte
   }
 
   public static boolean nextIntersection(Scene scene, Ray ray) {
-    return nextIntersection(scene, ray, null, new IntersectionConfig((scene.sky.cloudsEnabled() && !scene.sky.getVolumetricClouds()), false, scene.waterPlaneEnabled, true));
+    return nextIntersection(scene, ray, null, new IntersectionConfig(true, false, scene.waterPlaneEnabled, true));
   }
 
   private static boolean cloudIntersection(Scene scene, Ray ray, Random random) {
@@ -127,14 +127,7 @@ private static boolean cloudIntersection(Scene scene, Ray ray, Random random) {
   }
 
   private static boolean fogIntersection(Scene scene, Ray ray, Random random) {
-    if (random == null) {
-      return false;
-    }
-    boolean hit = false;
-    for(FogVolume v : scene.fog.getFogVolumes()) {
-      hit |= v.intersect(ray, scene, random);
-    }
-    return hit;
+    return scene.fog.particleFogIntersection(scene, ray, random);
   }
 
   private static boolean waterPlaneIntersection(Scene scene, Ray ray) {
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
index cdc8cfc111..ec85a87a17 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java
@@ -1686,7 +1686,7 @@ public boolean traceTarget(Ray ray) {
     ray.o.y -= origin.y;
     ray.o.z -= origin.z;
     while (PreviewRayTracer.nextIntersection(this, ray, null,
-      new IntersectionConfig((sky.cloudsEnabled() && !sky.getVolumetricClouds()),
+      new IntersectionConfig(true,
         false, waterPlaneEnabled, true))) {
       if (ray.getCurrentMaterial() != Air.INSTANCE) {
         return true;
@@ -2658,11 +2658,7 @@ public void setUseCustomWaterColor(boolean value) {
     json.add("waterVisibility", waterVisibility);
     json.add("useCustomWaterColor", useCustomWaterColor);
     if (useCustomWaterColor) {
-      JsonObject colorObj = new JsonObject();
-      colorObj.add("red", waterColor.x);
-      colorObj.add("green", waterColor.y);
-      colorObj.add("blue", waterColor.z);
-      json.add("waterColor", colorObj);
+      json.add("waterColor", ColorUtil.rgbToJson(waterColor));
     }
     waterShading.save(json);
     json.add("fog", fog.toJson());
@@ -2940,10 +2936,7 @@ public synchronized void importFromJson(JsonObject json) {
     waterVisibility = json.get("waterVisibility").doubleValue(waterVisibility);
     useCustomWaterColor = json.get("useCustomWaterColor").boolValue(useCustomWaterColor);
     if (useCustomWaterColor) {
-      JsonObject colorObj = json.get("waterColor").object();
-      waterColor.x = colorObj.get("red").doubleValue(waterColor.x);
-      waterColor.y = colorObj.get("green").doubleValue(waterColor.y);
-      waterColor.z = colorObj.get("blue").doubleValue(waterColor.z);
+      waterColor.set(ColorUtil.jsonToRGB(json.get("waterColor").asObject()));
     }
     String waterShader = json.get("waterShader").stringValue("SIMPLEX");
     if(waterShader.equals("LEGACY"))
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
index 1d32fe9cec..1b5f79f6ce 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Sky.java
@@ -58,15 +58,6 @@ public class Sky implements JsonSerializable {
    */
   public static final double DEFAULT_INTENSITY = 1;
 
-  /**
-   * Default cloud y-position
-   */
-  protected static final int DEFAULT_CLOUD_HEIGHT = 128;
-
-  protected static final int DEFAULT_CLOUD_SIZE = 12;
-
-  private static final double DEFAULT_CLOUD_DENSITY = 0.2;
-
   /**
    * Minimum sky light intensity
    */
@@ -158,12 +149,8 @@ public static SkyMode get(String name) {
   private double yaw = 0, pitch = 0, roll = 0;
 
   private boolean mirrored = true;
-  private boolean cloudsEnabled = false;
-  private boolean volumetricClouds = false;
-  private double cloudDensity = DEFAULT_CLOUD_DENSITY;
-  private final Vector3 cloudColor = new Vector3(1, 1, 1);
-  private final Vector3 cloudSize = new Vector3(DEFAULT_CLOUD_SIZE, 4, DEFAULT_CLOUD_SIZE);
-  private final Vector3 cloudOffset = new Vector3(0, DEFAULT_CLOUD_HEIGHT, 0);
+
+  private ArrayList<CloudLayer> cloudLayers = new ArrayList<>(0);
 
   private double skyExposure = DEFAULT_INTENSITY;
   private double skyLightModifier = DEFAULT_INTENSITY;
@@ -234,12 +221,7 @@ public void loadSkymap(String fileName, @Nullable File sceneDirectory) {
    * Set the sky equal to other sky.
    */
   public void set(Sky other) {
-    cloudsEnabled = other.cloudsEnabled;
-    cloudOffset.set(other.cloudOffset);
-    cloudSize.set(other.cloudSize);
-    cloudColor.set(other.cloudColor);
-    volumetricClouds = other.volumetricClouds;
-    cloudDensity = other.cloudDensity;
+    cloudLayers = new ArrayList<>(other.cloudLayers);
     skymapFileName = other.skymapFileName;
     skymap = other.skymap;
     yaw = other.yaw;
@@ -642,25 +624,16 @@ public void setSkyCacheResolution(int resolution) {
     sky.add("apparentSkyLight", apparentSkyLightModifier);
     sky.add("mode", mode.name());
     sky.add("horizonOffset", horizonOffset);
-    sky.add("cloudsEnabled", cloudsEnabled);
-    sky.add("cloudSize", cloudSize.toJson());
-    sky.add("cloudOffset", cloudOffset.toJson());
-    JsonObject cloudColorObj = new JsonObject();
-    cloudColorObj.add("red", cloudColor.x);
-    cloudColorObj.add("green", cloudColor.y);
-    cloudColorObj.add("blue", cloudColor.z);
-    sky.add("cloudColor", cloudColorObj);
-    sky.add("volumetricClouds", volumetricClouds);
-    sky.add("cloudDensity", cloudDensity);
+    JsonArray cloudLayersJson = new JsonArray();
+    for (CloudLayer layer : cloudLayers) {
+      cloudLayersJson.add(layer.toJson());
+    }
+    sky.add("cloudLayers", cloudLayersJson);
 
     // Always save gradient.
     sky.add("gradient", gradientJson(gradient));
 
-    JsonObject colorObj = new JsonObject();
-    colorObj.add("red", color.x);
-    colorObj.add("green", color.y);
-    colorObj.add("blue", color.z);
-    sky.add("color", colorObj);
+    sky.add("color", ColorUtil.rgbToJson(color));
 
     switch (mode) {
       case SKYMAP_EQUIRECTANGULAR:
@@ -711,26 +684,31 @@ public void importFromJson(JsonObject json) {
       mode = SkyMode.SKYMAP_ANGULAR;
     }
     horizonOffset = json.get("horizonOffset").doubleValue(horizonOffset);
-    cloudsEnabled = json.get("cloudsEnabled").boolValue(cloudsEnabled);
-    if (json.get("cloudSize").isObject()) {
-      cloudSize.fromJson(json.get("cloudSize").object());
-    } else {
-      double xzSize = json.get("cloudSize").doubleValue(DEFAULT_CLOUD_SIZE);
-      cloudSize.set(xzSize, 5, xzSize);
-    }
-    if (json.get("cloudOffset").isObject()) {
-      cloudOffset.fromJson(json.get("cloudOffset").object());
-    }
-    if (json.get("cloudColor").isObject()) {
-      JsonObject colorObj = json.get("cloudColor").object();
-      cloudColor.x = colorObj.get("red").doubleValue(cloudColor.x);
-      cloudColor.y = colorObj.get("green").doubleValue(cloudColor.y);
-      cloudColor.z = colorObj.get("blue").doubleValue(cloudColor.z);
+
+    if (json.get("cloudLayers").isUnknown()) {
+      boolean cloudsEnabled = json.get("cloudsEnabled").boolValue(false);
+      if (cloudsEnabled) {
+        double cloudSize = json.get("cloudSize").doubleValue(12);
+        Vector3 cloudOffset = JsonUtil.vec3FromJsonObject(json.get("cloudOffset").asObject());
+        CloudLayer cloudLayer = new CloudLayer();
+        cloudLayer.setCloudSizeX(cloudSize);
+        cloudLayer.setCloudSizeY(5);
+        cloudLayer.setCloudSizeZ(cloudSize);
+        cloudLayer.setCloudXOffset(cloudOffset.x);
+        cloudLayer.setCloudYOffset(cloudOffset.y);
+        cloudLayer.setCloudZOffset(cloudOffset.z);
+        cloudLayers.add(cloudLayer);
+      }
     } else {
-      cloudColor.set(1, 1, 1);
+      JsonArray jsonCloudLayers = json.get("cloudLayers").asArray();
+      cloudLayers.clear();
+      for (JsonValue layer : jsonCloudLayers) {
+        JsonObject layerObject = layer.asObject();
+        CloudLayer cloudLayer = new CloudLayer();
+        cloudLayer.importFromJson(layerObject);
+        cloudLayers.add(cloudLayer);
+      }
     }
-    volumetricClouds = json.get("volumetricClouds").boolValue(false);
-    cloudDensity = json.get("cloudDensity").doubleValue(cloudDensity);
 
     if (json.get("gradient").isArray()) {
       List<Vector4> theGradient = gradientFromJson(json.get("gradient").array());
@@ -740,10 +718,7 @@ public void importFromJson(JsonObject json) {
     }
 
     if (json.get("color").isObject()) {
-      JsonObject colorObj = json.get("color").object();
-      color.x = colorObj.get("red").doubleValue(color.x);
-      color.y = colorObj.get("green").doubleValue(color.y);
-      color.z = colorObj.get("blue").doubleValue(color.z);
+      color.set(ColorUtil.jsonToRGB(json.get("color").asObject()));
     } else {
       // Maintain backwards-compatibility with scenes saved in older Chunky versions
       color.set(JsonUtil.vec3FromJsonArray(json.get("color")));
@@ -943,459 +918,183 @@ public double getHorizonOffset() {
     return horizonOffset;
   }
 
-  public void setCloudSizeX(double newValue) {
-    if (newValue != cloudSize.x) {
-      cloudSize.x = newValue;
-      if (cloudsEnabled) {
-        scene.refresh();
-      }
-    }
+  public void setColor(Vector3 color) {
+    this.color.set(color);
+    scene.refresh();
   }
 
-  public double getCloudSizeX() {
-    return cloudSize.x;
+  public Vector3 getColor() {
+    return color;
   }
 
-  public void setCloudSizeY(double newValue) {
-    if (newValue != cloudSize.y) {
-      cloudSize.y = newValue;
-      if (cloudsEnabled) {
-        scene.refresh();
-      }
-    }
+  public Vector3 getCloudLayerColor(int index) {
+    return cloudLayers.get(index).getCloudColor();
   }
 
-  public double getCloudSizeY() {
-    return cloudSize.y;
+  public void setCloudLayerColor(int index, Vector3 color) {
+    cloudLayers.get(index).setCloudColor(color);
+    scene.refresh();
   }
 
-  public void setCloudSizeZ(double newValue) {
-    if (newValue != cloudSize.z) {
-      cloudSize.z = newValue;
-      if (cloudsEnabled) {
-        scene.refresh();
-      }
-    }
+
+  public boolean getCloudLayerVolumetricClouds(int index) {
+    return cloudLayers.get(index).getVolumetricClouds();
   }
 
-  public double getCloudSizeZ() {
-    return cloudSize.z;
+  public void setCloudLayerVolumetricClouds(int index, boolean value) {
+    cloudLayers.get(index).setVolumetricClouds(value);
+    scene.refresh();
   }
 
-  public void setCloudXOffset(double newValue) {
-    if (newValue != cloudOffset.x) {
-      cloudOffset.x = newValue;
-      if (cloudsEnabled) {
-        scene.refresh();
-      }
-    }
+
+  public double getCloudLayerDensity(int index) {
+    return cloudLayers.get(index).getCloudDensity();
   }
 
-  /**
-   * Change the cloud height
-   */
-  public void setCloudYOffset(double newValue) {
-    if (newValue != cloudOffset.y) {
-      cloudOffset.y = newValue;
-      if (cloudsEnabled) {
-        scene.refresh();
-      }
-    }
+  public void setCloudLayerDensity(int index, double value) {
+    cloudLayers.get(index).setCloudDensity(value);
+    scene.refresh();
   }
 
-  public void setCloudZOffset(double newValue) {
-    if (newValue != cloudOffset.z) {
-      cloudOffset.z = newValue;
-      if (cloudsEnabled) {
-        scene.refresh();
-      }
-    }
+
+  public double getCloudLayerSizeX(int index) {
+    return cloudLayers.get(index).getCloudSizeX();
   }
 
-  public double cloudXOffset() {
-    return cloudOffset.x;
+  public void setCloudLayerSizeX(int index, double newValue) {
+    cloudLayers.get(index).setCloudSizeX(newValue);
+    scene.refresh();
   }
 
-  /**
-   * @return The current cloud height
-   */
-  public double cloudYOffset() {
-    return cloudOffset.y;
+
+  public double getCloudLayerSizeY(int index) {
+    return cloudLayers.get(index).getCloudSizeY();
+  }
+
+  public void setCloudLayerSizeY(int index, double newValue) {
+    cloudLayers.get(index).setCloudSizeY(newValue);
+    scene.refresh();
+  }
+
+
+  public double getCloudLayerSizeZ(int index) {
+    return cloudLayers.get(index).getCloudSizeZ();
   }
 
-  public double cloudZOffset() {
-    return cloudOffset.z;
+  public void setCloudLayerSizeZ(int index, double newValue) {
+    cloudLayers.get(index).setCloudSizeZ(newValue);
+    scene.refresh();
+  }
+
+
+  public double getCloudLayerXOffset(int index) {
+    return cloudLayers.get(index).getCloudXOffset();
+  }
+
+  public void setCloudLayerXOffset(int index, double newValue) {
+    cloudLayers.get(index).setCloudXOffset(newValue);
+    scene.refresh();
   }
 
 
   /**
-   * Enable/disable clouds rendering.
+   * @return The current cloud height
    */
-  public void setCloudsEnabled(boolean newValue) {
-    if (newValue != cloudsEnabled) {
-      cloudsEnabled = newValue;
-      scene.refresh();
-    }
+  public double getCloudLayerYOffset(int index) {
+    return cloudLayers.get(index).getCloudYOffset();
   }
 
   /**
-   * @return <code>true</code> if cloud rendering is enabled
+   * Change the cloud height
    */
-  public boolean cloudsEnabled() {
-    return cloudsEnabled;
+  public void setCloudLayerYOffset(int index, double newValue) {
+    cloudLayers.get(index).setCloudYOffset(newValue);
+    scene.refresh();
   }
 
-  public Vector3 getCloudColor() {
-    return new Vector3(cloudColor);
+
+  public double getCloudLayerZOffset(int index) {
+    return cloudLayers.get(index).getCloudZOffset();
   }
 
-  public void setCloudColor(Vector3 color) {
-    cloudColor.set(color);
+  public void setCloudLayerZOffset(int index, double newValue) {
+    cloudLayers.get(index).setCloudZOffset(newValue);
     scene.refresh();
   }
 
-  public boolean getVolumetricClouds() {
-    return volumetricClouds;
+  public float getCloudLayerEmittance(int index) {
+    return cloudLayers.get(index).getEmittance();
   }
 
-  public void setVolumetricClouds(boolean value) {
-    volumetricClouds = value;
+  public void setCloudLayerEmittance(int index, float value) {
+    cloudLayers.get(index).setEmittance(value);
     scene.refresh();
   }
 
-  public double getCloudDensity() {
-    return cloudDensity;
+  public float getCloudLayerSpecular(int index) {
+    return cloudLayers.get(index).getSpecular();
   }
 
-  public void setCloudDensity(double value) {
-    cloudDensity = value;
+  public void setCloudLayerSpecular(int index, float value) {
+    cloudLayers.get(index).setSpecular(value);
     scene.refresh();
   }
 
-  private Pair<Double, Double> getCloudDistance(Scene scene, Ray ray) {
-    Pair<Boolean, Boolean> cloudIntersectionTest = cloudIntersection(scene, ray);
-    boolean hitCloud = cloudIntersectionTest.thing1;
-    boolean insideCloud = cloudIntersectionTest.thing2;
-    if (!hitCloud) {
-      return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
-    } else {
-      if (!volumetricClouds) {
-        double t = ray.t;
-        double tExit;
-        if (insideCloud) {
-          tExit = 1d;
-        } else {
-          tExit = 0d;
-        }
-        return new Pair<>(t, tExit);
-      } else {
-        if (insideCloud) {
-          double t;
-          double tExit;
-          t = 0;
-          tExit = ray.t;
-          return new Pair<>(t, tExit);
-        } else {
-          double t = ray.t;
-          double tExit;
-          double depth = 0;
-          while (true) {
-            if (depth >= 1000) {
-              return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
-            }
-            Ray nextIntersection = new Ray(ray);
-            nextIntersection.t = Double.POSITIVE_INFINITY;
-            nextIntersection.o.scaleAdd(t + Ray.OFFSET, ray.d);
-            Pair<Boolean, Boolean> testSecondIntersection = cloudIntersection(scene, nextIntersection);
-            if (!testSecondIntersection.thing1) {
-              return new Pair<>(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
-            } else {
-              if (testSecondIntersection.thing2) {
-                tExit = t + Ray.OFFSET + nextIntersection.t;
-                break;
-              } else {
-                t += Ray.OFFSET + nextIntersection.t;
-                depth++;
-              }
-            }
-          }
-          return new Pair<>(t, tExit);
-        }
-      }
-    }
+  public float getCloudLayerSmoothness(int index) {
+    return cloudLayers.get(index).getSmoothness();
   }
 
-  public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
-    if (random == null && volumetricClouds) {
-      return false;
-    }
-    Ray test = new Ray(ray);
-    test.t = ray.t;
-    Pair<Double, Double> cloudDistance = getCloudDistance(scene, test);
-    double firstIntersection = cloudDistance.thing1;
-    if (firstIntersection == Double.POSITIVE_INFINITY) {
-      return false;
-    }
-    double secondIntersection = cloudDistance.thing2;
-    double t;
-    if (volumetricClouds) {
-      double testFirstIntersection = firstIntersection;
-      double testSecondIntersection = secondIntersection;
-      int depth = 0;
-      while (true) {
-        if (depth >= 1000) {
-          return false;
-        }
-        double fogPenetrated = -FastMath.log(1 - random.nextDouble());
-        double fogDistance = fogPenetrated / cloudDensity;
-        if (testFirstIntersection + fogDistance < testSecondIntersection) {
-          t = testFirstIntersection + fogDistance;
+  public void setCloudLayerSmoothness(int index, float value) {
+    cloudLayers.get(index).setSmoothness(value);
+    scene.refresh();
+  }
 
-          if (t >= ray.t) {
-            return false;
-          }
+  public float getCloudLayerIor(int index) {
+    return cloudLayers.get(index).getIor();
+  }
 
-          // Set a random normal
-          Vector3 a1 = new Vector3();
-          a1.cross(ray.d, new Vector3(0, 1, 0));
-          a1.normalize();
-          Vector3 a2 = new Vector3();
-          a2.cross(ray.d, a1);
-          // get random point on unit disk
-          double x1 = random.nextDouble();
-          double x2 = random.nextDouble();
-          double r = FastMath.sqrt(x1);
-          double theta = 2 * Math.PI * x2;
-          double t1 = r * FastMath.cos(theta);
-          double t2 = r * FastMath.sin(theta);
-          a1.scale(t1);
-          a1.scaleAdd(t2, a2);
-          a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
-          ray.setNormal(a1);
-
-          ray.setCurrentMaterial(VolumeCloudMaterial.INSTANCE);
-          ray.specular = false;
-          break;
-        } else {
-          Ray test2 = new Ray(ray);
-          test2.t = Double.POSITIVE_INFINITY;
-          test2.o.scaleAdd(testSecondIntersection + Ray.OFFSET, ray.d);
-          Pair<Double, Double> testCloudDistance = getCloudDistance(scene, test2);
-          if (testCloudDistance.thing1 == Double.POSITIVE_INFINITY) {
-            return false;
-          }
-          testFirstIntersection += (testSecondIntersection - testFirstIntersection) + Ray.OFFSET + testCloudDistance.thing1;
-          testSecondIntersection += Ray.OFFSET + testCloudDistance.thing2;
-          depth++;
-        }
-      }
-    } else {
-      t = firstIntersection;
-      if (t >= ray.t) {
-        return false;
-      }
-      ray.setNormal(test.getNormal());
-      if (secondIntersection == 1) {
-        ray.setCurrentMaterial(Air.INSTANCE);
-      } else {
-        ray.setCurrentMaterial(CloudMaterial.INSTANCE);
-      }
-    }
-    ray.t = t;
-    ray.color.set(cloudColor.x, cloudColor.y, cloudColor.z, 1);
-    return true;
+  public void setCloudLayerIor(int index, float value) {
+    cloudLayers.get(index).setIor(value);
+    scene.refresh();
   }
 
-  /**
-   * Test for a cloud intersection. If the ray intersects a cloud,
-   * the distance to the intersection is stored in <code>ray.t</code>.
-   * @return {@link se.llbit.util.Pair} of Booleans.
-   * @param ray Ray with which to test for cloud intersection.
-   * <code>pair.thing1</code>: <code>true</code> if the ray intersected a cloud.
-   * <code>pair.thing2</code>: <code>true</code> if the ray origin is inside a cloud.
-   */
-  private Pair<Boolean, Boolean> cloudIntersection(Scene scene, Ray ray) {
-    double ox = ray.o.x + scene.origin.x;
-    double oy = ray.o.y + scene.origin.y;
-    double oz = ray.o.z + scene.origin.z;
-    double offsetX = cloudOffset.x;
-    double offsetY = cloudOffset.y;
-    double offsetZ = cloudOffset.z;
-    double invSizeX = 1 / cloudSize.x;
-    double invSizeZ = 1 / cloudSize.z;
-    double cloudTop = offsetY + cloudSize.y;
-    int target = 1;
-    double t_offset = 0;
-    if (oy < offsetY || oy > cloudTop) {
-      if (ray.d.y > 0) {
-        t_offset = (offsetY - oy) / ray.d.y;
-      } else {
-        t_offset = (cloudTop - oy) / ray.d.y;
-      }
-      if (t_offset < 0) {
-        return new Pair<>(false, false);
-      }
-      // Ray is entering cloud.
-      if (inCloud((ray.d.x * t_offset + ox) * invSizeX + offsetX,
-          (ray.d.z * t_offset + oz) * invSizeZ + offsetZ)) {
-        ray.setNormal(0, -Math.signum(ray.d.y), 0);
-        ray.t = t_offset;
-        return new Pair<>(true, false);
-      }
-    } else if (inCloud(ox * invSizeX + offsetX, oz * invSizeZ + offsetZ)) {
-      target = 0;
-    }
-    double tExit;
-    if (ray.d.y > 0) {
-      tExit = (cloudTop - oy) / ray.d.y - t_offset;
-    } else {
-      tExit = (offsetY - oy) / ray.d.y - t_offset;
-    }
-    if (ray.t < tExit) {
-      tExit = ray.t;
-    }
-    double x0 = (ox + ray.d.x * t_offset) * invSizeX + offsetX;
-    double z0 = (oz + ray.d.z * t_offset) * invSizeZ + offsetZ;
-    double xp = x0;
-    double zp = z0;
-    int ix = (int) Math.floor(xp);
-    int iz = (int) Math.floor(zp);
-    int xmod = (int) Math.signum(ray.d.x), zmod = (int) Math.signum(ray.d.z);
-    int xo = (1 + xmod) / 2, zo = (1 + zmod) / 2;
-    double dx = Math.abs(ray.d.x) * invSizeX;
-    double dz = Math.abs(ray.d.z) * invSizeZ;
-    double t = 0;
-    int i = 0;
-    int nx = 0, nz = 0;
-    if (dx > dz) {
-      double m = dz / dx;
-      double xrem = xmod * (ix + xo - xp);
-      double zlimit = xrem * m;
-      while (t < tExit) {
-        double zrem = zmod * (iz + zo - zp);
-        if (zrem < zlimit) {
-          iz += zmod;
-          if (Clouds.getCloud(ix, iz) == target) {
-            t = i / dx + zrem / dz;
-            nx = 0;
-            nz = -zmod;
-            break;
-          }
-          ix += xmod;
-          if (Clouds.getCloud(ix, iz) == target) {
-            t = (i + xrem) / dx;
-            nx = -xmod;
-            nz = 0;
-            break;
-          }
-        } else {
-          ix += xmod;
-          if (Clouds.getCloud(ix, iz) == target) {
-            t = (i + xrem) / dx;
-            nx = -xmod;
-            nz = 0;
-            break;
-          }
-          if (zrem <= m) {
-            iz += zmod;
-            if (Clouds.getCloud(ix, iz) == target) {
-              t = i / dx + zrem / dz;
-              nx = 0;
-              nz = -zmod;
-              break;
-            }
-          }
-        }
-        t = i / dx;
-        i += 1;
-        zp = z0 + zmod * i * m;
-      }
-    } else {
-      double m = dx / dz;
-      double zrem = zmod * (iz + zo - zp);
-      double xlimit = zrem * m;
-      while (t < tExit) {
-        double xrem = xmod * (ix + xo - xp);
-        if (xrem < xlimit) {
-          ix += xmod;
-          if (Clouds.getCloud(ix, iz) == target) {
-            t = i / dz + xrem / dx;
-            nx = -xmod;
-            nz = 0;
-            break;
-          }
-          iz += zmod;
-          if (Clouds.getCloud(ix, iz) == target) {
-            t = (i + zrem) / dz;
-            nx = 0;
-            nz = -zmod;
-            break;
-          }
-        } else {
-          iz += zmod;
-          if (Clouds.getCloud(ix, iz) == target) {
-            t = (i + zrem) / dz;
-            nx = 0;
-            nz = -zmod;
-            break;
-          }
-          if (xrem <= m) {
-            ix += xmod;
-            if (Clouds.getCloud(ix, iz) == target) {
-              t = i / dz + xrem / dx;
-              nx = -xmod;
-              nz = 0;
-              break;
-            }
-          }
-        }
-        t = i / dz;
-        i += 1;
-        xp = x0 + xmod * i * m;
-      }
-    }
-    int ny = 0;
-    if (target == 1) {
-      if (t > tExit) {
-        return new Pair<>(false, false);
-      }
-      if (nx == 0 && ny == 0 && nz == 0) {
-        // fix ray.n being set to zero (issue #643)
-        return new Pair<>(false, false);
-      }
-      ray.setNormal(nx, ny, nz);
-      ray.t = t + t_offset;
-      return new Pair<>(true, false);
-    } else {
-      if (t > tExit) {
-        nx = 0;
-        ny = (int) Math.signum(ray.d.y);
-        nz = 0;
-        t = tExit;
-      } else {
-        nx = -nx;
-        nz = -nz;
-      }
-      if (nx == 0 && ny == 0 && nz == 0) {
-        // fix ray.n being set to zero (issue #643)
-        return new Pair<>(false, false);
-      }
-      ray.setNormal(nx, ny, nz);
-      ray.t = t;
-      return new Pair<>(true, true);
-    }
+  public float getCloudLayerMetalness(int index) {
+    return cloudLayers.get(index).getMetalness();
   }
 
-  private static boolean inCloud(double x, double z) {
-    return Clouds.getCloud((int) Math.floor(x), (int) Math.floor(z)) == 1;
+  public void setCloudLayerMetalness(int index, float value) {
+    cloudLayers.get(index).setMetalness(value);
+    scene.refresh();
   }
 
-  public void setColor(Vector3 color) {
-    this.color.set(color);
+  public float getCloudLayerAnisotropy(int index) {
+    return cloudLayers.get(index).getAnisotropy();
+  }
+
+  public void setCloudLayerAnisotropy(int index, float value) {
+    cloudLayers.get(index).setAnisotropy(value);
     scene.refresh();
   }
 
-  public Vector3 getColor() {
-    return color;
+  public void addCloudLayer() {
+    cloudLayers.add(new CloudLayer());
+    scene.refresh();
+  }
+
+  public void removeCloudLayer(int index) {
+    cloudLayers.remove(index);
+    scene.refresh();
+  }
+
+  public int getNumCloudLayers() {
+    return cloudLayers.size();
+  }
+
+  public boolean cloudIntersection(Scene scene, Ray ray, Random random) {
+    boolean hit = false;
+    for (CloudLayer layer : cloudLayers) {
+      hit |= layer.intersect(scene, ray, random);
+    }
+    return hit;
   }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
index 84ade06077..d8d3313937 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/SphericalFogVolume.java
@@ -15,7 +15,7 @@ public class SphericalFogVolume extends FogVolume {
   private Sphere sphere;
 
   @Override
-  public boolean intersect(Ray ray, Scene scene, Random random) {
+  public boolean intersect(Scene scene, Ray ray, Random random) {
     double distance;
     double fogPenetrated = -Math.log(1 - random.nextDouble());
     double fogDistance = fogPenetrated / density;
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java b/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
index c969757aca..277f4140c4 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/Sun.java
@@ -24,6 +24,7 @@
 import se.llbit.chunky.renderer.Refreshable;
 import se.llbit.chunky.resources.Texture;
 import se.llbit.json.JsonObject;
+import se.llbit.math.ColorUtil;
 import se.llbit.math.QuickMath;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
@@ -500,16 +501,8 @@ public void getRandomSunDirection(Ray reflected, Random random) {
     sun.add("apparentBrightness", apparentBrightness);
     sun.add("radius", radius);
     sun.add("modifySunTexture", enableTextureModification);
-    JsonObject colorObj = new JsonObject();
-    colorObj.add("red", color.x);
-    colorObj.add("green", color.y);
-    colorObj.add("blue", color.z);
-    sun.add("color", colorObj);
-    JsonObject apparentColorObj = new JsonObject();
-    apparentColorObj.add("red", apparentColor.x);
-    apparentColorObj.add("green", apparentColor.y);
-    apparentColorObj.add("blue", apparentColor.z);
-    sun.add("apparentColor", apparentColorObj);
+    sun.add("color", ColorUtil.rgbToJson(color));
+    sun.add("apparentColor", ColorUtil.rgbToJson(apparentColor));
     JsonObject diffuseSamplingObj = new JsonObject();
     diffuseSamplingObj.add("chance", diffuseSampleChance);
     diffuseSamplingObj.add("radius", diffuseSampleRadius);
@@ -528,17 +521,11 @@ public void importFromJson(JsonObject json) {
     enableTextureModification = json.get("modifySunTexture").boolValue(enableTextureModification);
 
     if (json.get("color").isObject()) {
-      JsonObject colorObj = json.get("color").object();
-      color.x = colorObj.get("red").doubleValue(1);
-      color.y = colorObj.get("green").doubleValue(1);
-      color.z = colorObj.get("blue").doubleValue(1);
+      color.set(ColorUtil.jsonToRGB(json.get("color").asObject()));
     }
 
     if (json.get("apparentColor").isObject()) {
-      JsonObject apparentColorObj = json.get("apparentColor").object();
-      apparentColor.x = apparentColorObj.get("red").doubleValue(1);
-      apparentColor.y = apparentColorObj.get("green").doubleValue(1);
-      apparentColor.z = apparentColorObj.get("blue").doubleValue(1);
+      apparentColor.set(ColorUtil.jsonToRGB(json.get("apparentColor").asObject()));
     }
 
     if(json.get("diffuseSampling").isObject()) {
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
index 996bdd797b..95b42422ce 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/SkyTab.java
@@ -25,8 +25,10 @@
 import javafx.fxml.Initializable;
 import javafx.geometry.Pos;
 import javafx.scene.Node;
+import javafx.scene.control.Button;
 import javafx.scene.control.CheckBox;
 import javafx.scene.control.ChoiceBox;
+import javafx.scene.control.ComboBox;
 import javafx.scene.control.Label;
 import javafx.scene.control.ScrollPane;
 import javafx.scene.control.TitledPane;
@@ -59,7 +61,9 @@ public class SkyTab extends ScrollPane implements RenderControlsTab, Initializab
   @FXML private TitledPane detailsPane;
   @FXML private VBox skyModeSettings;
   @FXML private CheckBox transparentSkyEnabled;
-  @FXML private CheckBox cloudsEnabled;
+  @FXML private ComboBox<String> cloudLayers;
+  @FXML private Button addCloudLayer;
+  @FXML private Button removeCloudLayer;
   @FXML private TitledPane cloudDetailsPane;
   @FXML private DoubleAdjuster cloudSizeX;
   @FXML private DoubleAdjuster cloudSizeY;
@@ -70,6 +74,12 @@ public class SkyTab extends ScrollPane implements RenderControlsTab, Initializab
   @FXML private LuxColorPicker cloudColor;
   @FXML private CheckBox enableVolumetricClouds;
   @FXML private DoubleAdjuster cloudDensity;
+  @FXML private DoubleAdjuster emittance;
+  @FXML private DoubleAdjuster specular;
+  @FXML private DoubleAdjuster smoothness;
+  @FXML private DoubleAdjuster ior;
+  @FXML private DoubleAdjuster metalness;
+  @FXML private DoubleAdjuster anisotropy;
   private final VBox simulatedSettings = new VBox();
   private DoubleAdjuster horizonOffset = new DoubleAdjuster();
   private ChoiceBox<SimulatedSky> simulatedSky = new ChoiceBox<>();
@@ -83,7 +93,10 @@ public class SkyTab extends ScrollPane implements RenderControlsTab, Initializab
       (observable, oldValue, newValue) -> scene.sky().setColor(ColorUtil.fromFx(newValue));
 
   private ChangeListener<? super javafx.scene.paint.Color> cloudColorListener =
-    (observable, oldValue, newValue) -> scene.sky().setCloudColor(ColorUtil.fromFx(newValue));
+    (observable, oldValue, newValue) -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerColor(index, ColorUtil.fromFx(newValue));
+    };
   private EventHandler<ActionEvent> simSkyListener = event -> {
     int selected = simulatedSky.getSelectionModel().getSelectedIndex();
     scene.sky().setSimulatedSkyMode(selected);
@@ -135,68 +148,151 @@ public SimulatedSky fromString(String string) {
     simulatedSky.setOnAction(simSkyListener);
     simulatedSky.setTooltip(new Tooltip(skiesTooltip(Sky.skies)));
 
-    cloudsEnabled.setTooltip(new Tooltip("Toggle visibility of Minecraft-style clouds."));
-    cloudsEnabled.selectedProperty().addListener((observable, oldValue, newValue) -> {
-      scene.sky().setCloudsEnabled(newValue);
-      cloudDetailsPane.setVisible(newValue);
-      cloudDetailsPane.setExpanded(newValue);
-      cloudDetailsPane.setManaged(newValue);
+    cloudLayers.getSelectionModel().selectedItemProperty().addListener((observable, oldValue, newValue) ->
+      updateControls()
+    );
+
+    addCloudLayer.setText("Add cloud layer");
+    addCloudLayer.setOnAction(event -> {
+      scene.sky().addCloudLayer();
+      disableControls();
+      if (updateLayersList()) {
+        updateControls();
+      }
+      cloudLayers.getSelectionModel().selectLast();
     });
 
-    cloudDetailsPane.setVisible(false);
-    cloudDetailsPane.setExpanded(false);
-    cloudDetailsPane.setManaged(false);
+    removeCloudLayer.setText("Remove cloud layer");
+    removeCloudLayer.setOnAction(event -> {
+      if (scene.sky().getNumCloudLayers() > 0) {
+        scene.sky().removeCloudLayer(cloudLayers.getSelectionModel().getSelectedIndex());
+        disableControls();
+        if (updateLayersList()) {
+          updateControls();
+        }
+      }
+    });
 
     cloudSizeX.setName("Cloud X scale");
     cloudSizeX.setTooltip("Scale of the X-dimension of the clouds, measured in blocks per pixel of clouds.png texture");
     cloudSizeX.setRange(0.01, 128);
     cloudSizeX.clampMin();
     cloudSizeX.makeLogarithmic();
-    cloudSizeX.onValueChange(value -> scene.sky().setCloudSizeX(value));
+    cloudSizeX.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerSizeX(index, value);
+    });
 
     cloudSizeY.setName("Cloud Y scale");
     cloudSizeY.setTooltip("Scale of the Y-dimension of the clouds, measured in blocks per pixel of clouds.png texture");
     cloudSizeY.setRange(0.01, 128);
     cloudSizeY.clampMin();
     cloudSizeY.makeLogarithmic();
-    cloudSizeY.onValueChange(value -> scene.sky().setCloudSizeY(value));
+    cloudSizeY.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerSizeY(index, value);
+    });
 
     cloudSizeZ.setName("Cloud Z scale");
     cloudSizeZ.setTooltip("Scale of the Z-dimension of the clouds, measured in blocks per pixel of clouds.png texture");
     cloudSizeZ.setRange(0.01, 128);
     cloudSizeZ.clampMin();
     cloudSizeZ.makeLogarithmic();
-    cloudSizeZ.onValueChange(value -> scene.sky().setCloudSizeZ(value));
+    cloudSizeZ.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerSizeZ(index, value);
+    });
 
     cloudOffsetX.setName("Cloud X offset");
     cloudOffsetX.setTooltip("Changes the X-offset of the clouds.");
     cloudOffsetX.setRange(-256, 256);
-    cloudOffsetX.onValueChange(value -> scene.sky().setCloudXOffset(value));
+    cloudOffsetX.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerXOffset(index, value);
+    });
 
     cloudOffsetY.setName("Cloud Y offset");
     cloudOffsetY.setTooltip("Changes the altitude of the clouds.");
     cloudOffsetY.setRange(-64, 320);
-    cloudOffsetY.onValueChange(value -> scene.sky().setCloudYOffset(value));
+    cloudOffsetY.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerYOffset(index, value);
+    });
 
     cloudOffsetZ.setName("Cloud Z offset");
     cloudOffsetZ.setTooltip("Changes the Z-offset of the clouds.");
     cloudOffsetZ.setRange(-256, 256);
-    cloudOffsetZ.onValueChange(value -> scene.sky().setCloudZOffset(value));
+    cloudOffsetZ.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerZOffset(index, value);
+    });
 
     cloudColor.colorProperty().addListener(cloudColorListener);
 
     enableVolumetricClouds.setTooltip(new Tooltip("Use a volume scatter for the cloud material."));
     enableVolumetricClouds.selectedProperty().addListener((observable, oldValue, newValue) -> {
-      scene.sky().setVolumetricClouds(newValue);
-      cloudDensity.setDisable(!newValue);
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerVolumetricClouds(index, newValue);
+      disableControls();
+      enableControls(newValue);
     });
 
     cloudDensity.setName("Volumetric cloud density");
     cloudDensity.setRange(0.000001, 1);
     cloudDensity.clampMin();
     cloudDensity.setMaximumFractionDigits(6);
-    cloudDensity.onValueChange(value -> scene.sky().setCloudDensity(value));
-    cloudDensity.setDisable(true);
+    cloudDensity.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerDensity(index, value);
+    });
+
+    emittance.setName("Emittance");
+    emittance.setRange(0, 100);
+    emittance.clampMin();
+    emittance.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerEmittance(index, value.floatValue());
+    });
+
+    specular.setName("Specular");
+    specular.setRange(0, 1);
+    specular.clampBoth();
+    specular.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerSpecular(index, value.floatValue());
+    });
+
+    smoothness.setName("Smoothness");
+    smoothness.setRange(0, 1);
+    smoothness.clampBoth();
+    smoothness.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerSmoothness(index, value.floatValue());
+    });
+
+    ior.setName("IoR");
+    ior.setRange(0, 5);
+    ior.clampMin();
+    ior.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerIor(index, value.floatValue());
+    });
+
+    metalness.setName("Metalness");
+    metalness.setRange(0, 1);
+    metalness.clampBoth();
+    metalness.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerMetalness(index, value.floatValue());
+    });
+
+    anisotropy.setName("Anisotropy");
+    anisotropy.setRange(-1, 1);
+    anisotropy.clampBoth();
+    anisotropy.onValueChange(value -> {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      scene.sky().setCloudLayerAnisotropy(index, value.floatValue());
+    });
 
     skyMode.setTooltip(new Tooltip("Set the type of sky to be used in the scene."));
     skyMode.getItems().addAll(Sky.SkyMode.values());
@@ -240,24 +336,93 @@ public SimulatedSky fromString(String string) {
     colorPicker.colorProperty().addListener(skyColorListener);
   }
 
+  private void disableControls() {
+    cloudSizeX.setDisable(true);
+    cloudSizeY.setDisable(true);
+    cloudSizeZ.setDisable(true);
+    cloudOffsetX.setDisable(true);
+    cloudOffsetY.setDisable(true);
+    cloudOffsetZ.setDisable(true);
+    cloudColor.setDisable(true);
+    enableVolumetricClouds.setDisable(true);
+    cloudDensity.setDisable(true);
+    emittance.setDisable(true);
+    specular.setDisable(true);
+    smoothness.setDisable(true);
+    ior.setDisable(true);
+    metalness.setDisable(true);
+    anisotropy.setDisable(true);
+  }
+
+  private void enableControls(boolean volumetricClouds) {
+    cloudSizeX.setDisable(false);
+    cloudSizeY.setDisable(false);
+    cloudSizeZ.setDisable(false);
+    cloudOffsetX.setDisable(false);
+    cloudOffsetY.setDisable(false);
+    cloudOffsetZ.setDisable(false);
+    cloudColor.setDisable(false);
+    enableVolumetricClouds.setDisable(false);
+    emittance.setDisable(false);
+    if (!volumetricClouds) {
+      specular.setDisable(false);
+      smoothness.setDisable(false);
+      ior.setDisable(false);
+      metalness.setDisable(false);
+    } else {
+      cloudDensity.setDisable(false);
+      anisotropy.setDisable(false);
+    }
+  }
+
+  private boolean updateLayersList() {
+    cloudLayers.getSelectionModel().clearSelection();
+    cloudLayers.getItems().clear();
+    int numLayers = scene.sky().getNumCloudLayers();
+    boolean emptyLayers = !(numLayers > 0);
+    if (!emptyLayers) {
+      for (int i = 0; i < numLayers; i++) {
+        cloudLayers.getItems().add(String.format("Layer %d", i + 1));
+      }
+    }
+    return emptyLayers;
+  }
+
+  private void updateControls() {
+    if (!cloudLayers.getSelectionModel().isEmpty()) {
+      int index = cloudLayers.getSelectionModel().getSelectedIndex();
+      cloudSizeX.set(scene.sky().getCloudLayerSizeX(index));
+      cloudSizeY.set(scene.sky().getCloudLayerSizeY(index));
+      cloudSizeZ.set(scene.sky().getCloudLayerSizeZ(index));
+      cloudOffsetX.set(scene.sky().getCloudLayerXOffset(index));
+      cloudOffsetY.set(scene.sky().getCloudLayerYOffset(index));
+      cloudOffsetZ.set(scene.sky().getCloudLayerZOffset(index));
+      cloudColor.colorProperty().removeListener(cloudColorListener);
+      cloudColor.setColor(ColorUtil.toFx(scene.sky().getCloudLayerColor(index)));
+      cloudColor.colorProperty().addListener(cloudColorListener);
+      boolean volumetricClouds = scene.sky().getCloudLayerVolumetricClouds(index);
+      enableVolumetricClouds.setSelected(volumetricClouds);
+      cloudDensity.set(scene.sky().getCloudLayerDensity(index));
+      emittance.set(scene.sky().getCloudLayerEmittance(index));
+      specular.set(scene.sky().getCloudLayerSpecular(index));
+      smoothness.set(scene.sky().getCloudLayerSmoothness(index));
+      ior.set(scene.sky().getCloudLayerIor(index));
+      metalness.set(scene.sky().getCloudLayerMetalness(index));
+      anisotropy.set(scene.sky().getCloudLayerAnisotropy(index));
+      enableControls(volumetricClouds);
+    }
+  }
+
   @Override public void update(Scene scene) {
     skyMode.getSelectionModel().select(scene.sky().getSkyMode());
     simulatedSky.setOnAction(null);
     simulatedSky.getSelectionModel().select(scene.sky().getSimulatedSky());
     simulatedSky.setOnAction(simSkyListener);
-    cloudsEnabled.setSelected(scene.sky().cloudsEnabled());
+    disableControls();
+    if (updateLayersList()) {
+      updateControls();
+    }
     transparentSkyEnabled.setSelected(scene.transparentSky());
-    cloudSizeX.set(scene.sky().getCloudSizeX());
-    cloudSizeY.set(scene.sky().getCloudSizeY());
-    cloudSizeZ.set(scene.sky().getCloudSizeZ());
-    cloudOffsetX.set(scene.sky().cloudXOffset());
-    cloudOffsetY.set(scene.sky().cloudYOffset());
-    cloudOffsetZ.set(scene.sky().cloudZOffset());
-    cloudColor.colorProperty().removeListener(cloudColorListener);
-    cloudColor.setColor(ColorUtil.toFx(scene.sky().getCloudColor()));
-    cloudColor.colorProperty().addListener(cloudColorListener);
-    enableVolumetricClouds.setSelected(scene.sky().getVolumetricClouds());
-    cloudDensity.set(scene.sky().getCloudDensity());
     horizonOffset.set(scene.sky().getHorizonOffset());
     simulatedSky.setValue(scene.sky().getSimulatedSky());
     gradientEditor.setGradient(scene.sky().getGradient());
diff --git a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
index d0fd052535..25b1bf3e05 100644
--- a/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
+++ b/chunky/src/java/se/llbit/chunky/world/ExtraMaterials.java
@@ -19,8 +19,6 @@
 import se.llbit.chunky.block.minecraft.Candle;
 import se.llbit.chunky.entity.CalibratedSculkSensorAmethyst;
 import se.llbit.chunky.entity.Campfire;
-import se.llbit.chunky.world.material.CloudMaterial;
-import se.llbit.chunky.world.material.VolumeCloudMaterial;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -31,8 +29,6 @@ public class ExtraMaterials {
   public static final Map<String, Material> idMap = new HashMap<>();
 
   static {
-    idMap.put("cloud", CloudMaterial.INSTANCE);
-    idMap.put("volume_cloud", VolumeCloudMaterial.INSTANCE);
     idMap.put("candle_flame", Candle.flameMaterial);
     idMap.put("campfire_flame", Campfire.flameMaterial);
     idMap.put("soul_campfire_flame", Campfire.soulFlameMaterial);
@@ -41,8 +37,6 @@ public class ExtraMaterials {
   }
 
   public static void loadDefaultMaterialProperties() {
-    CloudMaterial.INSTANCE.restoreDefaults();
-
     Candle.flameMaterial.restoreDefaults();
     Candle.flameMaterial.emittance = 1.0f;
 
diff --git a/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java b/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
index b1f9ebb5e5..fcf82668dc 100644
--- a/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
@@ -1,9 +1,34 @@
 package se.llbit.chunky.world;
 
+import org.apache.commons.math3.util.FastMath;
 import se.llbit.chunky.resources.Texture;
+import se.llbit.math.Ray;
+import se.llbit.math.Vector3;
+
+import java.util.Random;
 
 public class VolumeMaterial extends Material {
   public VolumeMaterial(String name, Texture texture) {
     super(name, texture);
   }
+
+  public void setRandomSphericalNormal(Ray ray, Random random) {
+    // Set a random normal
+    Vector3 a1 = new Vector3();
+    a1.cross(ray.d, new Vector3(0, 1, 0));
+    a1.normalize();
+    Vector3 a2 = new Vector3();
+    a2.cross(ray.d, a1);
+    // get random point on unit disk
+    double x1 = random.nextDouble();
+    double x2 = random.nextDouble();
+    double r = FastMath.sqrt(x1);
+    double theta = 2 * Math.PI * x2;
+    double t1 = r * FastMath.cos(theta);
+    double t2 = r * FastMath.sin(theta);
+    a1.scale(t1);
+    a1.scaleAdd(t2, a2);
+    a1.scaleAdd(-Math.sqrt(1 - a1.lengthSquared()), ray.d);
+    ray.setNormal(a1);
+  }
 }
diff --git a/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java
index 5ec2ca32dd..863000bccf 100644
--- a/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/material/CloudMaterial.java
@@ -20,9 +20,7 @@
 import se.llbit.chunky.world.Material;
 
 public class CloudMaterial extends Material {
-  public static final CloudMaterial INSTANCE = new CloudMaterial();
-
-  private CloudMaterial() {
+  public CloudMaterial() {
     super("cloud", Texture.air);
   }
 }
diff --git a/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
index 3187f9bedb..8fee5a036e 100644
--- a/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/material/ParticleFogMaterial.java
@@ -4,8 +4,6 @@
 import se.llbit.chunky.world.VolumeMaterial;
 
 public class ParticleFogMaterial extends VolumeMaterial {
-  public static final ParticleFogMaterial INSTANCE = new ParticleFogMaterial();
-
   public ParticleFogMaterial() {
     super("particle_fog", Texture.air);
   }
diff --git a/chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java b/chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java
index d916035d1e..5f2e4367cc 100644
--- a/chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/material/VolumeCloudMaterial.java
@@ -20,9 +20,7 @@
 import se.llbit.chunky.world.VolumeMaterial;
 
 public class VolumeCloudMaterial extends VolumeMaterial {
-  public static final VolumeCloudMaterial INSTANCE = new VolumeCloudMaterial();
-
-  private VolumeCloudMaterial() {
+  public VolumeCloudMaterial() {
     super("volume_cloud", Texture.air);
   }
 }
diff --git a/chunky/src/java/se/llbit/math/ColorUtil.java b/chunky/src/java/se/llbit/math/ColorUtil.java
index 9d1d01ccd3..0b3e82b2cb 100644
--- a/chunky/src/java/se/llbit/math/ColorUtil.java
+++ b/chunky/src/java/se/llbit/math/ColorUtil.java
@@ -21,6 +21,7 @@
 import org.apache.commons.math3.util.FastMath;
 
 import se.llbit.chunky.renderer.scene.Scene;
+import se.llbit.json.JsonObject;
 
 /**
  * Collection of utility methods for converting between different color representations.
@@ -406,4 +407,20 @@ public static byte RGBComponentFromLinear(float linearValue) {
   public static float RGBComponentToLinear(byte value) {
     return toLinearLut[value & 0xFF];
   }
+
+  public static JsonObject rgbToJson(Vector3 color) {
+    JsonObject jsonObject = new JsonObject();
+    jsonObject.add("red", color.x);
+    jsonObject.add("green", color.y);
+    jsonObject.add("blue", color.z);
+    return jsonObject;
+  }
+
+  public static Vector3 jsonToRGB(JsonObject json) {
+    Vector3 color = new Vector3();
+    color.x = json.get("red").doubleValue(1);
+    color.y = json.get("green").doubleValue(1);
+    color.z = json.get("blue").doubleValue(1);
+    return color;
+  }
 }
diff --git a/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml b/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
index 7901b882ef..2439c43689 100644
--- a/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
+++ b/chunky/src/res/se/llbit/chunky/ui/render/tabs/SkyTab.fxml
@@ -12,6 +12,8 @@
 <?import se.llbit.chunky.ui.DoubleAdjuster?>
 <?import se.llbit.fx.LuxColorPicker?>
 
+<?import javafx.scene.control.ComboBox?>
+<?import javafx.scene.control.Button?>
 <fx:root type="javafx.scene.control.ScrollPane" xmlns="http://javafx.com/javafx/8.0.40" xmlns:fx="http://javafx.com/fxml/1">
   <VBox spacing="10.0">
     <HBox alignment="CENTER_LEFT" prefWidth="200.0" spacing="10.0">
@@ -31,7 +33,11 @@
     </TitledPane>
     <CheckBox fx:id="transparentSkyEnabled" mnemonicParsing="false" text="Transparent sky" />
     <Separator />
-    <CheckBox fx:id="cloudsEnabled" mnemonicParsing="false" text="Enable clouds" />
+    <HBox alignment="CENTER_LEFT" spacing="10.0">
+      <ComboBox fx:id="cloudLayers" prefWidth="150.0" />
+      <Button fx:id="addCloudLayer" mnemonicParsing="false" />
+      <Button fx:id="removeCloudLayer" mnemonicParsing="false" />
+    </HBox>
     <TitledPane fx:id="cloudDetailsPane" animated="false" text="Cloud settings">
       <VBox spacing="10.0">
         <padding>
@@ -49,6 +55,14 @@
         </HBox>
         <CheckBox fx:id="enableVolumetricClouds" mnemonicParsing="false" text="Volumetric clouds"/>
         <DoubleAdjuster fx:id="cloudDensity" />
+        <Separator />
+        <Label text="Material properties" />
+        <DoubleAdjuster fx:id="emittance" />
+        <DoubleAdjuster fx:id="specular" />
+        <DoubleAdjuster fx:id="smoothness" />
+        <DoubleAdjuster fx:id="ior" />
+        <DoubleAdjuster fx:id="metalness" />
+        <DoubleAdjuster fx:id="anisotropy" />
       </VBox>
     </TitledPane>
     <padding>

From e83219ad4e0c83b3e0bfa4b355a2ab2bb4e43452 Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Sun, 22 Oct 2023 22:46:22 +0200
Subject: [PATCH 33/38] Remove `Anisotropy` from `Materials` tab

---
 .../llbit/chunky/renderer/scene/CloudLayer.java   |  4 ++--
 .../llbit/chunky/renderer/scene/PathTracer.java   | 10 +++++-----
 .../llbit/chunky/ui/render/tabs/MaterialsTab.java | 15 +--------------
 .../src/java/se/llbit/chunky/world/Material.java  |  4 ----
 .../se/llbit/chunky/world/VolumeMaterial.java     |  2 ++
 5 files changed, 10 insertions(+), 25 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java
index e37f3a4097..8c38e12f79 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/CloudLayer.java
@@ -536,7 +536,7 @@ private void importFlatMaterial(JsonObject json) {
   }
 
   private void importVolumeMaterial(JsonObject json) {
-    volumeMaterial.emittance = json.get("emittance").floatValue(material.emittance);
-    volumeMaterial.anisotropy = json.get("anisotropy").floatValue(material.anisotropy);
+    volumeMaterial.emittance = json.get("emittance").floatValue(volumeMaterial.emittance);
+    volumeMaterial.anisotropy = json.get("anisotropy").floatValue(volumeMaterial.anisotropy);
   }
 }
diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 39e7ea7f0b..a5642ef704 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -141,7 +141,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
         boolean doMetal = pMetal > Ray.EPSILON && random.nextFloat() < pMetal;
 
         if (currentMat instanceof VolumeMaterial) {
-          hit |= doParticleFogReflection(ray, next, currentMat, cumulativeColor, random, state, scene);
+          hit |= doParticleFogReflection(ray, next, (VolumeMaterial) currentMat, cumulativeColor, random, state, scene);
         } else if (doMetal || (pSpecular > Ray.EPSILON && random.nextFloat() < pSpecular)) {
           hit |= doSpecularReflection(ray, next, cumulativeColor, doMetal, random, state, scene);
         } else if(random.nextFloat() < pDiffuse) {
@@ -205,7 +205,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
     return hit;
   }
 
-  private static boolean doParticleFogReflection(Ray ray, Ray next, Material currentMat, Vector4 cumulativeColor, Random random, WorkerState state, Scene scene) {
+  private static boolean doParticleFogReflection(Ray ray, Ray next, VolumeMaterial currentMat, Vector4 cumulativeColor, Random random, WorkerState state, Scene scene) {
     boolean hit = false;
     Vector3 emittance = new Vector3();
     next.set(ray);
@@ -234,7 +234,7 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, Material curre
 
       Vector4 attenuation = state.attenuation;
       if (attenuation.w > 0) {
-        double mult = phaseHG(cosTheta, ray.getCurrentMaterial().anisotropy) * (scene.getSunSamplingStrategy().isSunLuminosity() ? scene.sun().getLuminosityPdf() : 1);
+        double mult = phaseHG(cosTheta, currentMat.anisotropy) * (scene.getSunSamplingStrategy().isSunLuminosity() ? scene.sun().getLuminosityPdf() : 1);
         directLightR = attenuation.x * attenuation.w * mult;
         directLightG = attenuation.y * attenuation.w * mult;
         directLightB = attenuation.z * attenuation.w * mult;
@@ -245,7 +245,7 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, Material curre
       Vector3 outboundDirection = new Vector3();
       double x1 = random.nextDouble();
       double x2 = random.nextDouble();
-      henyeyGreensteinSampleP(ray.getCurrentMaterial().anisotropy, inboundDirection, outboundDirection, x1, x2);
+      henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
       next.d.set(outboundDirection);
       next.d.normalize();
 
@@ -261,7 +261,7 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, Material curre
       Vector3 outboundDirection = new Vector3();
       double x1 = random.nextDouble();
       double x2 = random.nextDouble();
-      henyeyGreensteinSampleP(ray.getCurrentMaterial().anisotropy, inboundDirection, outboundDirection, x1, x2);
+      henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
       next.d.set(outboundDirection);
       next.d.normalize();
 
diff --git a/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java b/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
index ec87aed459..10a4e1efd6 100644
--- a/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
+++ b/chunky/src/java/se/llbit/chunky/ui/render/tabs/MaterialsTab.java
@@ -54,7 +54,6 @@ public class MaterialsTab extends HBox implements RenderControlsTab, Initializab
   private final DoubleAdjuster ior = new DoubleAdjuster();
   private final DoubleAdjuster perceptualSmoothness = new DoubleAdjuster();
   private final DoubleAdjuster metalness = new DoubleAdjuster();
-  private final DoubleAdjuster anisotropy = new DoubleAdjuster();
   private final ListView<String> listView;
 
   public MaterialsTab() {
@@ -73,9 +72,6 @@ public MaterialsTab() {
     metalness.setName("Metalness");
     metalness.setRange(0, 1);
     metalness.setTooltip("Metalness (texture-tinted reflectivity) of the selected material.");
-    anisotropy.setName("Anisotropy");
-    anisotropy.setRange(-1, 1);
-    anisotropy.clampBoth();
     ObservableList<String> blockIds = FXCollections.observableArrayList();
     blockIds.addAll(MaterialStore.collections.keySet());
     blockIds.addAll(ExtraMaterials.idMap.keySet());
@@ -91,9 +87,7 @@ public MaterialsTab() {
     settings.setSpacing(10);
     settings.getChildren().addAll(
         new Label("Material Properties"),
-        emittance, specular, perceptualSmoothness, ior, metalness, anisotropy,
-        new Label("(set to zero to disable)\n" +
-          "'Anisotropy' is effective only on the 'volume_cloud' material."));
+        emittance, specular, perceptualSmoothness, ior, metalness);
     setPadding(new Insets(10));
     setSpacing(15);
     TextField filterField = new TextField();
@@ -122,7 +116,6 @@ private void updateSelectedMaterial(String materialName) {
       double iorAcc = 0;
       double perceptualSmoothnessAcc = 0;
       double metalnessAcc = 0;
-      double anisotropyAcc = 0;
       Collection<Block> blocks = MaterialStore.collections.get(materialName);
       for (Block block : blocks) {
         emAcc += block.emittance;
@@ -130,14 +123,12 @@ private void updateSelectedMaterial(String materialName) {
         iorAcc += block.ior;
         perceptualSmoothnessAcc += block.getPerceptualSmoothness();
         metalnessAcc += block.metalness;
-        anisotropyAcc += block.anisotropy;
       }
       emittance.set(emAcc / blocks.size());
       specular.set(specAcc / blocks.size());
       ior.set(iorAcc / blocks.size());
       perceptualSmoothness.set(perceptualSmoothnessAcc / blocks.size());
       metalness.set(metalnessAcc / blocks.size());
-      anisotropy.set(anisotropyAcc / blocks.size());
       materialExists = true;
     } else if (ExtraMaterials.idMap.containsKey(materialName)) {
       Material material = ExtraMaterials.idMap.get(materialName);
@@ -147,7 +138,6 @@ private void updateSelectedMaterial(String materialName) {
         ior.set(material.ior);
         perceptualSmoothness.set(material.getPerceptualSmoothness());
         metalness.set(material.metalness);
-        anisotropy.set(material.anisotropy);
         materialExists = true;
       }
     } else if (MaterialStore.blockIds.contains(materialName)) {
@@ -158,7 +148,6 @@ private void updateSelectedMaterial(String materialName) {
       ior.set(block.ior);
       perceptualSmoothness.set(block.getPerceptualSmoothness());
       metalness.set(block.metalness);
-      anisotropy.set(block.anisotropy);
       materialExists = true;
     }
     if (materialExists) {
@@ -167,14 +156,12 @@ private void updateSelectedMaterial(String materialName) {
       ior.onValueChange(value -> scene.setIor(materialName, value.floatValue()));
       perceptualSmoothness.onValueChange(value -> scene.setPerceptualSmoothness(materialName, value.floatValue()));
       metalness.onValueChange(value -> scene.setMetalness(materialName, value.floatValue()));
-      anisotropy.onValueChange(value -> scene.setAnisotropy(materialName, value.floatValue()));
     } else {
       emittance.onValueChange(value -> {});
       specular.onValueChange(value -> {});
       ior.onValueChange(value -> {});
       perceptualSmoothness.onValueChange(value -> {});
       metalness.onValueChange(value -> {});
-      anisotropy.onValueChange(value -> {});
     }
   }
 
diff --git a/chunky/src/java/se/llbit/chunky/world/Material.java b/chunky/src/java/se/llbit/chunky/world/Material.java
index 24f064b409..572af56774 100644
--- a/chunky/src/java/se/llbit/chunky/world/Material.java
+++ b/chunky/src/java/se/llbit/chunky/world/Material.java
@@ -75,8 +75,6 @@ public abstract class Material {
    */
   public float metalness = 0;
 
-  public float anisotropy = 0;
-
   /**
    * Subsurface scattering property.
    */
@@ -106,7 +104,6 @@ public void restoreDefaults() {
     specular = 0;
     emittance = 0;
     roughness = 0;
-    anisotropy = 0;
     subSurfaceScattering = false;
   }
 
@@ -128,7 +125,6 @@ public void loadMaterialProperties(JsonObject json) {
     emittance = json.get("emittance").floatValue(emittance);
     roughness = json.get("roughness").floatValue(roughness);
     metalness = json.get("metalness").floatValue(metalness);
-    anisotropy = json.get("anisotropy").floatValue(anisotropy);
   }
 
   public boolean isWater() {
diff --git a/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java b/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
index fcf82668dc..41bd1e4be4 100644
--- a/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
+++ b/chunky/src/java/se/llbit/chunky/world/VolumeMaterial.java
@@ -8,6 +8,8 @@
 import java.util.Random;
 
 public class VolumeMaterial extends Material {
+  public float anisotropy = 0;
+
   public VolumeMaterial(String name, Texture texture) {
     super(name, texture);
   }

From 3efe39084c615225bdfd4bd3b4456fb169e19138 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Mon, 30 Oct 2023 02:56:23 -0400
Subject: [PATCH 34/38] non-sun sampling

---
 .../chunky/renderer/scene/PathTracer.java     | 47 +++++++++++++------
 1 file changed, 33 insertions(+), 14 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index a5642ef704..37528309e7 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -256,22 +256,41 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, VolumeMaterial
         cumulativeColor.z += emittance.z + ray.color.z * (directLightB * scene.sun.emittance.z + next.color.z);
       }
     } else {
-      Vector4 rayColor = new Vector4(ray.color);
-
-      Vector3 outboundDirection = new Vector3();
-      double x1 = random.nextDouble();
-      double x2 = random.nextDouble();
-      henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
-      next.d.set(outboundDirection);
-      next.d.normalize();
+      double sun_az = scene.sun().getAzimuth();
+      double sun_alt = scene.sun().getAltitude();
+      Vector3 sun_dir = new Vector3(FastMath.cos(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_alt));
+      double circle_radius = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
+      double sample_chance = scene.sun().getDiffuseSampleChance();
+      if(Math.abs(currentMat.anisotropy) > 0.99 || !scene.getSunSamplingStrategy().isDiffuseSampling()) {
+        sample_chance = 0;
+      }
+      if(random.nextDouble() < sample_chance) {
+        Vector3 outboundDirection = new Vector3();
+        double x1 = random.nextDouble();
+        double x2 = random.nextDouble();
 
-      hit |= pathTrace(scene, next, state, false);
-      if (hit) {
-        cumulativeColor.x += emittance.x + ray.color.x * (next.color.x);
-        cumulativeColor.y += emittance.y + ray.color.y * (next.color.y);
-        cumulativeColor.z += emittance.z + ray.color.z * (next.color.z);
+      } else {
+        Vector4 rayColor = new Vector4(ray.color);
+        while(true) {
+          Vector3 outboundDirection = new Vector3();
+          double x1 = random.nextDouble();
+          double x2 = random.nextDouble();
+          henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
+          next.d.set(outboundDirection);
+          next.d.normalize();
+          if(next.d.dot(sun_dir) > FastMath.cos(circle_radius)) {
+            continue;
+          }
+          hit |= pathTrace(scene, next, state, false);
+          if (hit) {
+            cumulativeColor.x += (emittance.x + ray.color.x * (next.color.x)) / (1 - sample_chance);
+            cumulativeColor.y += (emittance.y + ray.color.y * (next.color.y)) / (1 - sample_chance);
+            cumulativeColor.z += (emittance.z + ray.color.z * (next.color.z)) / (1 - sample_chance);
+          }
+          break;
+        }
+        ray.color.set(rayColor);
       }
-      ray.color.set(rayColor);
 
     }
     return hit;

From 3effb15ea3b2f676345a03990de7e696deef1d75 Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Mon, 30 Oct 2023 21:58:11 -0400
Subject: [PATCH 35/38] possibly working implementation

---
 .../chunky/renderer/scene/PathTracer.java     | 75 ++++++++++++-------
 1 file changed, 50 insertions(+), 25 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 37528309e7..44ba735d67 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -261,37 +261,62 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, VolumeMaterial
       Vector3 sun_dir = new Vector3(FastMath.cos(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_alt));
       double circle_radius = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
       double sample_chance = scene.sun().getDiffuseSampleChance();
-      if(Math.abs(currentMat.anisotropy) > 0.99 || !scene.getSunSamplingStrategy().isDiffuseSampling()) {
-        sample_chance = 0;
-      }
-      if(random.nextDouble() < sample_chance) {
-        Vector3 outboundDirection = new Vector3();
-        double x1 = random.nextDouble();
-        double x2 = random.nextDouble();
-
-      } else {
-        Vector4 rayColor = new Vector4(ray.color);
-        while(true) {
-          Vector3 outboundDirection = new Vector3();
-          double x1 = random.nextDouble();
-          double x2 = random.nextDouble();
-          henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
-          next.d.set(outboundDirection);
-          next.d.normalize();
-          if(next.d.dot(sun_dir) > FastMath.cos(circle_radius)) {
-            continue;
-          }
+      double sample_area = (1 - FastMath.cos(circle_radius))*2*Math.PI;
+      if(Math.abs(currentMat.anisotropy) < 0.99 && scene.getSunSamplingStrategy().isDiffuseSampling()) {
+        if(random.nextDouble() < sample_chance) {
+          // Generate random sun direction assuming sun is directly overhead
+          double ay = random.nextDouble(FastMath.cos(circle_radius), 1);
+          double phi = random.nextDouble(2*Math.PI);
+          double ax = FastMath.sqrt(1 - ay * ay)*FastMath.sin(phi);
+          double az = FastMath.sqrt(1 - ay * ay)*FastMath.cos(phi);
+          // Transform to actual sun position
+          double bx = ax * FastMath.sin(sun_alt) + ay * FastMath.cos(sun_alt);
+          double by = -ax * FastMath.cos(sun_alt) + ay * FastMath.sin(sun_alt);
+          double cx = bx * FastMath.cos(sun_az) - az * FastMath.sin(sun_az);
+          double cz = bx * FastMath.sin(sun_az) + az * FastMath.cos(sun_az);
+          next.d.set(cx, by, cz);
+          double pdf = phaseHG(inboundDirection.dot(next.d), currentMat.anisotropy);
           hit |= pathTrace(scene, next, state, false);
           if (hit) {
-            cumulativeColor.x += (emittance.x + ray.color.x * (next.color.x)) / (1 - sample_chance);
-            cumulativeColor.y += (emittance.y + ray.color.y * (next.color.y)) / (1 - sample_chance);
-            cumulativeColor.z += (emittance.z + ray.color.z * (next.color.z)) / (1 - sample_chance);
+            cumulativeColor.x += (emittance.x + ray.color.x * (next.color.x)) * pdf * sample_area / sample_chance;
+            cumulativeColor.y += (emittance.y + ray.color.y * (next.color.y)) * pdf * sample_area / sample_chance;
+            cumulativeColor.z += (emittance.z + ray.color.z * (next.color.z)) * pdf * sample_area / sample_chance;
+          }
+        } else {
+          while(true) {
+            double z = random.nextDouble(-1, 1);
+            double rho = FastMath.sqrt(1 - z * z);
+            double phi = random.nextDouble(2*Math.PI);
+            next.d.set(rho*FastMath.cos(phi), rho*FastMath.sin(phi), z);
+            if(next.d.dot(sun_dir) > FastMath.cos(circle_radius)) {
+              continue;
+            }
+            double pdf = phaseHG(inboundDirection.dot(next.d), currentMat.anisotropy);
+            hit |= pathTrace(scene, next, state, false);
+            if (hit) {
+              cumulativeColor.x += (emittance.x + ray.color.x * (next.color.x)) * pdf * (4*Math.PI - sample_area) / (1 - sample_chance);
+              cumulativeColor.y += (emittance.y + ray.color.y * (next.color.y)) * pdf * (4*Math.PI - sample_area) / (1 - sample_chance);
+              cumulativeColor.z += (emittance.z + ray.color.z * (next.color.z)) * pdf * (4*Math.PI - sample_area) / (1 - sample_chance);
+            }
+            break;
           }
-          break;
+        }
+      } else {
+        Vector4 rayColor = new Vector4(ray.color);
+        Vector3 outboundDirection = new Vector3();
+        double x1 = random.nextDouble();
+        double x2 = random.nextDouble();
+        henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
+        next.d.set(outboundDirection);
+        next.d.normalize();
+        hit |= pathTrace(scene, next, state, false);
+        if (hit) {
+          cumulativeColor.x += emittance.x + ray.color.x * (next.color.x);
+          cumulativeColor.y += emittance.y + ray.color.y * (next.color.y);
+          cumulativeColor.z += emittance.z + ray.color.z * (next.color.z);
         }
         ray.color.set(rayColor);
       }
-
     }
     return hit;
   }

From f5e8c9136a9aa7206c042e61a05ceae27fbf910b Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Tue, 31 Oct 2023 11:24:58 -0400
Subject: [PATCH 36/38] fix sun direction

---
 .../src/java/se/llbit/chunky/renderer/scene/PathTracer.java   | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 44ba735d67..924f219f2e 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -258,7 +258,7 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, VolumeMaterial
     } else {
       double sun_az = scene.sun().getAzimuth();
       double sun_alt = scene.sun().getAltitude();
-      Vector3 sun_dir = new Vector3(FastMath.cos(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_alt));
+      Vector3 sun_dir = new Vector3(FastMath.cos(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_alt), FastMath.sin(sun_az)*FastMath.cos(sun_alt));
       double circle_radius = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
       double sample_chance = scene.sun().getDiffuseSampleChance();
       double sample_area = (1 - FastMath.cos(circle_radius))*2*Math.PI;
@@ -302,7 +302,6 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, VolumeMaterial
           }
         }
       } else {
-        Vector4 rayColor = new Vector4(ray.color);
         Vector3 outboundDirection = new Vector3();
         double x1 = random.nextDouble();
         double x2 = random.nextDouble();
@@ -315,7 +314,6 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, VolumeMaterial
           cumulativeColor.y += emittance.y + ray.color.y * (next.color.y);
           cumulativeColor.z += emittance.z + ray.color.z * (next.color.z);
         }
-        ray.color.set(rayColor);
       }
     }
     return hit;

From e3b8a01231d97930b8061b868538f9948445648b Mon Sep 17 00:00:00 2001
From: Peregrine05 <92183530+Peregrine05@users.noreply.github.com>
Date: Mon, 6 Nov 2023 01:04:47 +0100
Subject: [PATCH 37/38] Revert "Diffuse sampling fog"

---
 .../chunky/renderer/scene/PathTracer.java     | 74 ++++---------------
 1 file changed, 16 insertions(+), 58 deletions(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index 924f219f2e..a5642ef704 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -256,65 +256,23 @@ private static boolean doParticleFogReflection(Ray ray, Ray next, VolumeMaterial
         cumulativeColor.z += emittance.z + ray.color.z * (directLightB * scene.sun.emittance.z + next.color.z);
       }
     } else {
-      double sun_az = scene.sun().getAzimuth();
-      double sun_alt = scene.sun().getAltitude();
-      Vector3 sun_dir = new Vector3(FastMath.cos(sun_az)*FastMath.cos(sun_alt), FastMath.sin(sun_alt), FastMath.sin(sun_az)*FastMath.cos(sun_alt));
-      double circle_radius = scene.sun().getSunRadius() * scene.sun().getDiffuseSampleRadius();
-      double sample_chance = scene.sun().getDiffuseSampleChance();
-      double sample_area = (1 - FastMath.cos(circle_radius))*2*Math.PI;
-      if(Math.abs(currentMat.anisotropy) < 0.99 && scene.getSunSamplingStrategy().isDiffuseSampling()) {
-        if(random.nextDouble() < sample_chance) {
-          // Generate random sun direction assuming sun is directly overhead
-          double ay = random.nextDouble(FastMath.cos(circle_radius), 1);
-          double phi = random.nextDouble(2*Math.PI);
-          double ax = FastMath.sqrt(1 - ay * ay)*FastMath.sin(phi);
-          double az = FastMath.sqrt(1 - ay * ay)*FastMath.cos(phi);
-          // Transform to actual sun position
-          double bx = ax * FastMath.sin(sun_alt) + ay * FastMath.cos(sun_alt);
-          double by = -ax * FastMath.cos(sun_alt) + ay * FastMath.sin(sun_alt);
-          double cx = bx * FastMath.cos(sun_az) - az * FastMath.sin(sun_az);
-          double cz = bx * FastMath.sin(sun_az) + az * FastMath.cos(sun_az);
-          next.d.set(cx, by, cz);
-          double pdf = phaseHG(inboundDirection.dot(next.d), currentMat.anisotropy);
-          hit |= pathTrace(scene, next, state, false);
-          if (hit) {
-            cumulativeColor.x += (emittance.x + ray.color.x * (next.color.x)) * pdf * sample_area / sample_chance;
-            cumulativeColor.y += (emittance.y + ray.color.y * (next.color.y)) * pdf * sample_area / sample_chance;
-            cumulativeColor.z += (emittance.z + ray.color.z * (next.color.z)) * pdf * sample_area / sample_chance;
-          }
-        } else {
-          while(true) {
-            double z = random.nextDouble(-1, 1);
-            double rho = FastMath.sqrt(1 - z * z);
-            double phi = random.nextDouble(2*Math.PI);
-            next.d.set(rho*FastMath.cos(phi), rho*FastMath.sin(phi), z);
-            if(next.d.dot(sun_dir) > FastMath.cos(circle_radius)) {
-              continue;
-            }
-            double pdf = phaseHG(inboundDirection.dot(next.d), currentMat.anisotropy);
-            hit |= pathTrace(scene, next, state, false);
-            if (hit) {
-              cumulativeColor.x += (emittance.x + ray.color.x * (next.color.x)) * pdf * (4*Math.PI - sample_area) / (1 - sample_chance);
-              cumulativeColor.y += (emittance.y + ray.color.y * (next.color.y)) * pdf * (4*Math.PI - sample_area) / (1 - sample_chance);
-              cumulativeColor.z += (emittance.z + ray.color.z * (next.color.z)) * pdf * (4*Math.PI - sample_area) / (1 - sample_chance);
-            }
-            break;
-          }
-        }
-      } else {
-        Vector3 outboundDirection = new Vector3();
-        double x1 = random.nextDouble();
-        double x2 = random.nextDouble();
-        henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
-        next.d.set(outboundDirection);
-        next.d.normalize();
-        hit |= pathTrace(scene, next, state, false);
-        if (hit) {
-          cumulativeColor.x += emittance.x + ray.color.x * (next.color.x);
-          cumulativeColor.y += emittance.y + ray.color.y * (next.color.y);
-          cumulativeColor.z += emittance.z + ray.color.z * (next.color.z);
-        }
+      Vector4 rayColor = new Vector4(ray.color);
+
+      Vector3 outboundDirection = new Vector3();
+      double x1 = random.nextDouble();
+      double x2 = random.nextDouble();
+      henyeyGreensteinSampleP(currentMat.anisotropy, inboundDirection, outboundDirection, x1, x2);
+      next.d.set(outboundDirection);
+      next.d.normalize();
+
+      hit |= pathTrace(scene, next, state, false);
+      if (hit) {
+        cumulativeColor.x += emittance.x + ray.color.x * (next.color.x);
+        cumulativeColor.y += emittance.y + ray.color.y * (next.color.y);
+        cumulativeColor.z += emittance.z + ray.color.z * (next.color.z);
       }
+      ray.color.set(rayColor);
+
     }
     return hit;
   }

From 455bf99ae8e13387215a1236a4808e9f7acd396c Mon Sep 17 00:00:00 2001
From: JustinTimeCuber <justintimecuber@gmail.com>
Date: Tue, 21 Nov 2023 15:57:15 -0500
Subject: [PATCH 38/38] fix coordinateSystem()

---
 chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
index a5642ef704..58a91641d7 100644
--- a/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
+++ b/chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java
@@ -698,7 +698,7 @@ private static void coordinateSystem(Vector3 v1, Vector3 v2, Vector3 v3) {
       x.scale(1 / FastMath.sqrt(v1.x * v1.x + v1.z * v1.z));
     } else {
       x = new Vector3(0, v1.z, -v1.y);
-      x.scale(FastMath.sqrt(v1.y * v1.y + v1.z * v1.z));
+      x.scale(1 / FastMath.sqrt(v1.y * v1.y + v1.z * v1.z));
     }
     v2.set(x);
     v3.cross(v1, v2);