Refactor the path tracer

build.gradle

@@ -41,9 +41,9 @@ subprojects {
     }
 
     javafx {
-        version = '11.0.2'
+        version = '17.0.13'
         configuration = 'implementation'
-        modules = ['javafx.base', 'javafx.controls', 'javafx.fxml']
+        modules = ['javafx.base', 'javafx.controls', 'javafx.fxml', 'javafx.media']
     }
 
     javadoc {

chunky/build.gradle

@@ -15,6 +15,7 @@ dependencies {
   implementation 'it.unimi.dsi:fastutil:8.4.4'
   implementation 'org.apache.commons:commons-math3:3.2'
   implementation 'com.google.code.gson:gson:2.9.0'
+  implementation 'org.controlsfx:controlsfx:11.2.1'
   implementation project(':lib')
 
   testImplementation 'com.google.truth:truth:1.1.3'

chunky/src/java/se/llbit/chunky/block/AbstractModelBlock.java

@@ -1,11 +1,13 @@
 package se.llbit.chunky.block;
 
+import se.llbit.chunky.block.minecraft.Air;
+import se.llbit.chunky.block.minecraft.Water;
 import se.llbit.chunky.model.BlockModel;
+import se.llbit.chunky.model.minecraft.WaterModel;
 import se.llbit.chunky.plugin.PluginApi;
 import se.llbit.chunky.renderer.scene.Scene;
 import se.llbit.chunky.resources.Texture;
-import se.llbit.math.Ray;
-import se.llbit.math.Vector3;
+import se.llbit.math.*;
 
 import java.util.Random;
 
@@ -41,8 +43,149 @@ public BlockModel getModel() {
     return model;
   }
 
+  public static boolean onEdge(Vector3 o, Vector3 d, IntersectionRecord intersectionRecord) {
+    o.scaleAdd(intersectionRecord.distance, d);
+    double ix = o.x - QuickMath.floor(o.x);
+    double iy = o.y - QuickMath.floor(o.y);
+    double iz = o.z - QuickMath.floor(o.z);
+    return !(Constants.EPSILON < ix && ix < 1 - Constants.EPSILON &&
+      Constants.EPSILON < iy && iy < 1 - Constants.EPSILON &&
+      Constants.EPSILON < iz && iz < 1 - Constants.EPSILON);
+  }
+
+  @Override
+  public boolean intersect(Ray ray, IntersectionRecord intersectionRecord, Scene scene) {
+    Intersectable waterModel = null;
+
+    // TODO this shouldn't be checked at intersection time, but rather when loading chunks.
+    boolean isWaterloggedFull = false;
+    if (waterlogged) {
+      int x = (int) QuickMath.floor(ray.o.x + ray.d.x * Constants.OFFSET);
+      int y = (int) QuickMath.floor(ray.o.y + ray.d.y * Constants.OFFSET);
+      int z = (int) QuickMath.floor(ray.o.z + ray.d.z * Constants.OFFSET);
+      isWaterloggedFull = scene.getWorldOctree().getMaterial(x, y + 1, z, scene.getPalette()).isWaterFilled();
+      if (ray.getCurrentMedium().isWater()) {
+        if (!isWaterloggedFull) {
+          waterModel = WaterModel.WATER_TOP;
+        }
+      } else {
+        waterModel = (isWaterloggedFull) ? Block.FULL_BLOCK : WaterModel.NOT_FULL_BLOCK;
+      }
+    }
+
+    IntersectionRecord modelIntersect = new IntersectionRecord();
+    IntersectionRecord waterIntersect = new IntersectionRecord();
+
+    boolean modelHit = model.intersect(ray, modelIntersect, scene);
+    boolean waterHit = false;
+    if (waterModel != null) {
+      waterHit = waterModel.closestIntersection(ray, waterIntersect, scene);
+    }
+
+    boolean hitTop = waterHit && !isWaterloggedFull && waterIntersect.n.y > 0 && ray.d.dot(waterIntersect.n) > 0;
+
+    if (ray.getCurrentMedium() == this) {
+      if (modelHit) {
+        intersectionRecord.setNormal(modelIntersect);
+        if (ray.d.dot(intersectionRecord.n) > 0) {
+          Vector3 o = new Vector3(ray.o);
+          if (onEdge(o, ray.d, modelIntersect)) {
+            return false;
+          }
+          intersectionRecord.n.scale(-1);
+          intersectionRecord.shadeN.scale(-1);
+
+          Block waterPlaneMaterial = scene.waterPlaneMaterial(ray.o.rScaleAdd(intersectionRecord.distance, ray.d));
+          if (waterlogged) {
+            if (isWaterloggedFull || o.y < 1 - WaterModel.TOP_BLOCK_GAP) {
+              intersectionRecord.material = scene.getPalette().water;
+              Water.INSTANCE.getColor(intersectionRecord);
+            } else {
+              intersectionRecord.material = waterPlaneMaterial;
+              waterPlaneMaterial.getColor(intersectionRecord);
+            }
+          } else {
+            intersectionRecord.material = waterPlaneMaterial;
+            waterPlaneMaterial.getColor(intersectionRecord);
+          }
+        } else {
+          intersectionRecord.color.set(modelIntersect.color);
+        }
+        intersectionRecord.distance = modelIntersect.distance;
+        intersectionRecord.flags = modelIntersect.flags;
+        return true;
+      } else {
+        return false;
+      }
+    } else if (ray.getCurrentMedium().isWater()) {
+      if (!waterlogged && (!modelHit || modelIntersect.distance > Constants.EPSILON)) {
+        intersectionRecord.distance = 0;
+        intersectionRecord.material = Air.INSTANCE;
+        Air.INSTANCE.getColor(intersectionRecord);
+        return true;
+      }
+      if (modelHit && modelIntersect.distance < waterIntersect.distance - Constants.EPSILON) {
+        intersectionRecord.distance = modelIntersect.distance;
+        intersectionRecord.setNormal(modelIntersect);
+        intersectionRecord.color.set(modelIntersect.color);
+        intersectionRecord.flags = modelIntersect.flags;
+        return true;
+      } else if (hitTop) {
+        intersectionRecord.distance = waterIntersect.distance;
+        intersectionRecord.setNormal(waterIntersect);
+
+        Ray testRay = new Ray(ray);
+        testRay.o.scaleAdd(intersectionRecord.distance, testRay.d);
+        intersectionRecord.material = scene.waterPlaneMaterial(testRay.o);
+        intersectionRecord.material.getColor(intersectionRecord);
+
+        Vector3 shadeNormal = scene.getCurrentWaterShader().doWaterShading(testRay, intersectionRecord, scene.getAnimationTime());
+        intersectionRecord.shadeN.set(shadeNormal);
+
+        intersectionRecord.n.scale(-1);
+        intersectionRecord.shadeN.scale(-1);
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      if (!waterlogged && (!modelHit || modelIntersect.distance > Constants.EPSILON)) {
+        Block waterPlaneMaterial;
+        if (ray.getCurrentMedium() != (waterPlaneMaterial = scene.waterPlaneMaterial(ray.o))) {
+          intersectionRecord.distance = 0;
+          intersectionRecord.material = waterPlaneMaterial;
+          waterPlaneMaterial.getColor(intersectionRecord);
+          return true;
+        }
+      }
+      if (modelHit && modelIntersect.distance < waterIntersect.distance + Constants.EPSILON) {
+        intersectionRecord.distance = modelIntersect.distance;
+        intersectionRecord.setNormal(modelIntersect);
+        intersectionRecord.color.set(modelIntersect.color);
+        intersectionRecord.flags = modelIntersect.flags;
+        return true;
+      } else if (waterHit) {
+        intersectionRecord.distance = waterIntersect.distance;
+        intersectionRecord.setNormal(waterIntersect);
+        Water.INSTANCE.getColor(intersectionRecord);
+        intersectionRecord.material = scene.getPalette().water;
+        intersectionRecord.flags = 0;
+
+        if (intersectionRecord.n.y > 0) {
+          Ray testRay = new Ray(ray);
+          testRay.o.scaleAdd(intersectionRecord.distance, testRay.d);
+          Vector3 shadeNormal = scene.getCurrentWaterShader().doWaterShading(testRay, intersectionRecord, scene.getAnimationTime());
+          intersectionRecord.shadeN.set(shadeNormal);
+        }
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+
   @Override
-  public boolean intersect(Ray ray, Scene scene) {
-    return model.intersect(ray, scene);
+  public boolean isInside(Ray ray) {
+    return model.isInside(ray);
   }
 }

chunky/src/java/se/llbit/chunky/block/Block.java

@@ -1,28 +1,24 @@
 package se.llbit.chunky.block;
 
 import se.llbit.chunky.entity.Entity;
-import se.llbit.chunky.model.TexturedBlockModel;
 import se.llbit.chunky.renderer.scene.Scene;
 import se.llbit.chunky.resources.Texture;
 import se.llbit.chunky.world.Material;
 import se.llbit.json.JsonString;
 import se.llbit.json.JsonValue;
-import se.llbit.math.AABB;
-import se.llbit.math.Ray;
-import se.llbit.math.Vector3;
+import se.llbit.math.*;
 import se.llbit.nbt.CompoundTag;
 import se.llbit.nbt.Tag;
 
-import java.util.List;
 import java.util.Random;
 
 public abstract class Block extends Material {
-  private final static AABB block =  new AABB(0, 1, 0, 1,0, 1);
+  public static final AABB FULL_BLOCK =  new AABB(0, 1, 0, 1,0, 1);
 
   /**
    * Set to true if there is a local intersection model for this block. If this is set to
    * <code>false</code> (default), this block is assumed to be an opaque cube block and {@link
-   * #intersect(Ray, Scene)} will never be called.
+   * #intersect(Ray, IntersectionRecord, Scene)} will never be called.
    */
   public boolean localIntersect = false;
 
@@ -50,14 +46,14 @@ public int faceCount() {
    * @param rand Random number source.
    */
   public void sample(int face, Vector3 loc, Random rand) {
-    block.sampleFace(face, loc, rand);
+    FULL_BLOCK.sampleFace(face, loc, rand);
   }
 
   /**
    * Get the surface area of this face of the block.
    */
   public double surfaceArea(int face) {
-    return block.faceSurfaceArea(face);
+    return FULL_BLOCK.faceSurfaceArea(face);
   }
 
   /**
@@ -69,17 +65,7 @@ public double surfaceArea(int face) {
    * @param scene Scene
    * @return True if the ray hit this block, false if not
    */
-  public boolean intersect(Ray ray, Scene scene) {
-    ray.t = Double.POSITIVE_INFINITY;
-    if (block.intersect(ray)) {
-      float[] color = texture.getColor(ray.u, ray.v);
-      if (color[3] > Ray.EPSILON) {
-        ray.color.set(color);
-        ray.distance += ray.tNext;
-        ray.o.scaleAdd(ray.tNext, ray.d);
-        return true;
-      }
-    }
+  public boolean intersect(Ray ray, IntersectionRecord intersectionRecord, Scene scene) {
     return false;
   }
 
@@ -119,7 +105,7 @@ public boolean isBlockWithEntity() {
     return false;
   }
 
-  public Entity toEntity(Vector3 position) {
+  public Entity[] toEntity(Vector3 position) {
     throw new Error("This block type can not be converted to an entity: "
         + getClass().getSimpleName());
   }
@@ -146,4 +132,11 @@ public boolean isModifiedByBlockEntity() {
   public Tag getNewTagWithBlockEntity(Tag blockTag, CompoundTag entityTag) {
     return null;
   }
+
+  public boolean isInside(Ray ray) {
+    double ix = ray.o.x - QuickMath.floor(ray.o.x);
+    double iy = ray.o.y - QuickMath.floor(ray.o.y);
+    double iz = ray.o.z - QuickMath.floor(ray.o.z);
+    return FULL_BLOCK.inside(new Vector3(ix, iy, iz));
+  }
 }

chunky/src/java/se/llbit/chunky/block/FixedTopBottomRotatableTexturedBlock.java

@@ -13,13 +13,13 @@ public FixedTopBottomRotatableTexturedBlock(String name, String facing, Texture
         this(name, facing, front, side, side, side, top, top);
     }
 
-    public FixedTopBottomRotatableTexturedBlock(String name, String facing, Texture front, Texture side, Texture top, Texture bottom) {
-        this(name, facing, front, side, side, side, top, bottom);
+    public FixedTopBottomRotatableTexturedBlock(String name, String facing, Texture front, Texture side, Texture bottom, Texture top) {
+        this(name, facing, front, side, side, side, bottom, top);
     }
 
-    public FixedTopBottomRotatableTexturedBlock(String name, String facing, Texture front, Texture south, Texture east, Texture west, Texture top, Texture bottom) {
+    public FixedTopBottomRotatableTexturedBlock(String name, String facing, Texture front, Texture south, Texture east, Texture west, Texture bottom, Texture top) {
         super(name, front);
-        this.model = new FixedTopBottomRotatableTexturedBlockModel(facing, front, south, east, west, top, bottom);
+        this.model = new FixedTopBottomRotatableTexturedBlockModel(facing, front, south, east, west, bottom, top);
         solid = true;
         opaque = true;
     }