Draft: Add support for PBR maps (specular, normal, metalness, roughness, emittance)

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

@@ -4,6 +4,7 @@
 import se.llbit.chunky.model.TexturedBlockModel;
 import se.llbit.chunky.renderer.scene.Scene;
 import se.llbit.chunky.resources.Texture;
+import se.llbit.chunky.resources.pbr.NormalMap;
 import se.llbit.chunky.world.Material;
 import se.llbit.json.JsonString;
 import se.llbit.json.JsonValue;
@@ -74,7 +75,24 @@ public boolean intersect(Ray ray, Scene scene) {
     if (block.intersect(ray)) {
       float[] color = texture.getColor(ray.u, ray.v);
       if (color[3] > Ray.EPSILON) {
+        if (ray.getNormal().y > 0) {
+          NormalMap.apply(ray, NormalMap.tbnCubeTop, texture);
+        } else if (ray.getNormal().y < 0) {
+          NormalMap.apply(ray, NormalMap.tbnCubeBottom, texture);
+        } else if (ray.getNormal().x > 0) {
+          NormalMap.apply(ray, NormalMap.tbnCubeEast, texture);
+        } else if (ray.getNormal().x < 0) {
+          NormalMap.apply(ray, NormalMap.tbnCubeWest, texture);
+        } else if (ray.getNormal().z > 0) {
+          NormalMap.apply(ray, NormalMap.tbnCubeSouth, texture);
+        } else if (ray.getNormal().z < 0) {
+          NormalMap.apply(ray, NormalMap.tbnCubeNorth, texture);
+        }
         ray.color.set(color);
+        ray.emittanceValue = texture.getEmittanceAt(ray.u, ray.v);
+        ray.reflectanceValue = texture.getReflectanceAt(ray.u, ray.v);
+        ray.roughnessValue = texture.getRoughnessAt(ray.u, ray.v);
+        ray.metalnessValue = texture.getMetalnessAt(ray.u, ray.v);
         ray.distance += ray.tNext;
         ray.o.scaleAdd(ray.tNext, ray.d);
         return true;

chunky/src/java/se/llbit/chunky/model/AABBModel.java

@@ -1,9 +1,12 @@
 package se.llbit.chunky.model;
 
+import org.apache.commons.math3.util.FastMath;
 import se.llbit.chunky.plugin.PluginApi;
 import se.llbit.chunky.renderer.scene.Scene;
 import se.llbit.chunky.resources.Texture;
+import se.llbit.chunky.resources.pbr.NormalMap;
 import se.llbit.math.AABB;
+import se.llbit.math.Matrix3;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
 
@@ -38,6 +41,15 @@ public enum UVMapping {
     FLIP_V
   }
 
+  protected final static Matrix3[] tbnMatrices = {
+      NormalMap.tbnCubeNorth,
+      NormalMap.tbnCubeEast,
+      NormalMap.tbnCubeSouth,
+      NormalMap.tbnCubeWest,
+      NormalMap.tbnCubeTop,
+      NormalMap.tbnCubeBottom
+  };
+
   @PluginApi
   public abstract AABB[] getBoxes();
 
@@ -78,67 +90,89 @@ public boolean intersect(Ray ray, Scene scene) {
 
     boolean hit = false;
     Tint tint = Tint.NONE;
+    Texture hitTexture = null;
+    int hitSide = 0;
+
     ray.t = Double.POSITIVE_INFINITY;
     for (int i = 0; i < boxes.length; ++i) {
       if (boxes[i].intersect(ray)) {
         Tint[] tintedFacesBox = tintedFaces != null ? tintedFaces[i] : null;
         Vector3 n = ray.getNormal();
+
+        int side = -1;
         if (n.y > 0) { // top
           ray.v = 1 - ray.v;
           if (intersectFace(ray, scene, textures[i][4],
             mapping != null ? mapping[i][4] : null
           )) {
             tint = tintedFacesBox != null ? tintedFacesBox[4] : Tint.NONE;
             hit = true;
+            side = 4;
           }
         } else if (n.y < 0) { // bottom
           if (intersectFace(ray, scene, textures[i][5],
             mapping != null ? mapping[i][5] : null)) {
             hit = true;
             tint = tintedFacesBox != null ? tintedFacesBox[5] : Tint.NONE;
+            side = 5;
           }
         } else if (n.z < 0) { // north
           if (intersectFace(ray, scene, textures[i][0],
             mapping != null ? mapping[i][0] : null
           )) {
             hit = true;
             tint = tintedFacesBox != null ? tintedFacesBox[0] : Tint.NONE;
+            side = 0;
           }
         } else if (n.z > 0) { // south
           if (intersectFace(ray, scene, textures[i][2],
             mapping != null ? mapping[i][2] : null
           )) {
             hit = true;
             tint = tintedFacesBox != null ? tintedFacesBox[2] : Tint.NONE;
+            side = 2;
           }
         } else if (n.x < 0) { // west
           if (intersectFace(ray, scene, textures[i][3],
             mapping != null ? mapping[i][3] : null)) {
             hit = true;
             tint = tintedFacesBox != null ? tintedFacesBox[3] : Tint.NONE;
+            side = 3;
           }
         } else if (n.x > 0) { // east
           if (intersectFace(ray, scene, textures[i][1],
             mapping != null ? mapping[i][1] : null)) {
             hit = true;
             tint = tintedFacesBox != null ? tintedFacesBox[1] : Tint.NONE;
+            side = 1;
           }
         }
+
         if (hit) {
           ray.t = ray.tNext;
+          hitTexture = textures[i][side];
+          hitSide = side;
         }
       }
     }
-    if (hit) {
+
+    if (hitTexture != null) {
       if (ray.getCurrentMaterial().opaque) {
         ray.color.w = 1;
       }
-
       tint.tint(ray.color, ray, scene);
+
+      NormalMap.apply(ray, tbnMatrices[hitSide], hitTexture);
+      ray.emittanceValue = hitTexture.getEmittanceAt(ray.u, ray.v);
+      ray.reflectanceValue = hitTexture.getReflectanceAt(ray.u, ray.v);
+      ray.roughnessValue = hitTexture.getRoughnessAt(ray.u, ray.v);
+      ray.metalnessValue = hitTexture.getMetalnessAt(ray.u, ray.v);
+
       ray.distance += ray.t;
       ray.o.scaleAdd(ray.t, ray.d);
     }
-    return hit;
+
+    return hitTexture != null;
   }
 
   private boolean intersectFace(Ray ray, Scene scene, Texture texture, UVMapping mapping) {

chunky/src/java/se/llbit/chunky/model/QuadModel.java

@@ -23,6 +23,7 @@
 import se.llbit.chunky.plugin.PluginApi;
 import se.llbit.chunky.renderer.scene.Scene;
 import se.llbit.chunky.resources.Texture;
+import se.llbit.chunky.resources.pbr.NormalMap;
 import se.llbit.math.Quad;
 import se.llbit.math.Ray;
 import se.llbit.math.Vector3;
@@ -117,6 +118,9 @@ public boolean intersect(Ray ray, Scene scene) {
 
     float[] color = null;
     Tint tint = Tint.NONE;
+    Quad hitQuad = null;
+    Texture hitTexture = null;
+
     for (int i = 0; i < quads.length; ++i) {
       Quad quad = quads[i];
       if (quad.intersect(ray)) {
@@ -129,6 +133,9 @@ public boolean intersect(Ray ray, Scene scene) {
             ray.orientNormal(quad.n);
           else
             ray.setNormal(quad.n);
+
+          hitQuad = quad;
+          hitTexture = textures[i];
           hit = true;
         }
       }
@@ -143,11 +150,17 @@ public boolean intersect(Ray ray, Scene scene) {
         return false;
       }
 
+      NormalMap.apply(ray, hitQuad, hitTexture);
       ray.color.set(color);
       tint.tint(ray.color, ray, scene);
+      ray.emittanceValue = hitTexture.getEmittanceAt(ray.u, ray.v);
+      ray.reflectanceValue = hitTexture.getReflectanceAt(ray.u, ray.v);
+      ray.roughnessValue = hitTexture.getRoughnessAt(ray.u, ray.v);
+      ray.metalnessValue = hitTexture.getMetalnessAt(ray.u, ray.v);
       ray.distance += ray.t;
       ray.o.scaleAdd(ray.t, ray.d);
     }
+
     return hit;
   }
 

chunky/src/java/se/llbit/chunky/model/TexturedBlockModel.java

@@ -18,6 +18,7 @@
 
 import se.llbit.chunky.block.minecraft.Air;
 import se.llbit.chunky.resources.Texture;
+import se.llbit.chunky.resources.pbr.NormalMap;
 import se.llbit.math.AABB;
 import se.llbit.math.QuickMath;
 import se.llbit.math.Ray;
@@ -63,7 +64,25 @@ public static void getIntersectionColor(Ray ray) {
       return;
     }
     getTextureCoordinates(ray);
-    ray.getCurrentMaterial().getColor(ray);
+    Texture texture = ray.getCurrentMaterial().texture;
+    if (ray.getNormal().y > 0) {
+      NormalMap.apply(ray, NormalMap.tbnCubeTop, texture);
+    } else if (ray.getNormal().y < 0) {
+      NormalMap.apply(ray, NormalMap.tbnCubeBottom, texture);
+    } else if (ray.getNormal().x > 0) {
+      NormalMap.apply(ray, NormalMap.tbnCubeEast, texture);
+    } else if (ray.getNormal().x < 0) {
+      NormalMap.apply(ray, NormalMap.tbnCubeWest, texture);
+    } else if (ray.getNormal().z > 0) {
+      NormalMap.apply(ray, NormalMap.tbnCubeSouth, texture);
+    } else if (ray.getNormal().z < 0) {
+      NormalMap.apply(ray, NormalMap.tbnCubeNorth, texture);
+    }
+    texture.getColor(ray);
+    ray.emittanceValue = texture.getEmittanceAt(ray.u, ray.v);
+    ray.reflectanceValue = texture.getReflectanceAt(ray.u, ray.v);
+    ray.roughnessValue = texture.getRoughnessAt(ray.u, ray.v);
+    ray.metalnessValue = texture.getMetalnessAt(ray.u, ray.v);
   }
 
   /**

chunky/src/java/se/llbit/chunky/renderer/scene/PathTracer.java

@@ -68,6 +68,10 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
       if (!PreviewRayTracer.nextIntersection(scene, ray)) {
         if (ray.getPrevMaterial().isWater()) {
           ray.color.set(0, 0, 0, 1);
+          ray.emittanceValue = 0;
+          ray.reflectanceValue = 0;
+          ray.roughnessValue = 0;
+          ray.metalnessValue = 0;
           hit = true;
         } else if (ray.depth == 0) {
           // Direct sky hit.
@@ -102,7 +106,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
         }
       }
 
-      float pSpecular = currentMat.specular;
+      float pSpecular = (float) (currentMat.specular * ray.reflectanceValue);
 
       double pDiffuse = scene.fancierTranslucency ? 1 - Math.pow(1 - ray.color.w, Math.max(ray.color.x, Math.max(ray.color.y, ray.color.z))) : ray.color.w;
       double pAbsorb = scene.fancierTranslucency ? 1 - (1 - ray.color.w)/(1 - pDiffuse + Ray.EPSILON) : ray.color.w;
@@ -129,7 +133,7 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
       ray.depth += 1;
       Vector4 cumulativeColor = new Vector4(0, 0, 0, 0);
       Ray next = new Ray();
-      float pMetal = currentMat.metalness;
+      float pMetal = currentMat.metalness * ray.metalnessValue;
       // Reusing first rays - a simplified form of "branched path tracing" (what Blender used to call it before they implemented something fancier)
       // The initial rays cast into the scene are very similar between each sample, since they are almost entirely a function of the pixel coordinates
       // Because of that, casting those initial rays on every sample is redundant and can be skipped
@@ -168,6 +172,10 @@ public static boolean pathTrace(Scene scene, Ray ray, WorkerState state,
     }
     if (!hit) {
       ray.color.set(0, 0, 0, 1);
+      ray.emittanceValue = 0;
+      ray.reflectanceValue = 0;
+      ray.roughnessValue = 0;
+      ray.metalnessValue = 0;
       if (firstReflection) {
         airDistance = ray.distance;
       }
@@ -228,12 +236,12 @@ private static boolean doDiffuseReflection(Ray ray, Ray next, Material currentMa
     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) {
+    if (scene.emittersEnabled && (!scene.isPreventNormalEmitterWithSampling() || scene.getEmitterSamplingStrategy() == EmitterSamplingStrategy.NONE || ray.depth == 0) && currentMat.emittance * ray.emittanceValue > 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);
+      emittance.scale(currentMat.emittance * ray.emittanceValue * scene.emitterIntensity);
 
       hit = true;
     } else if (scene.emittersEnabled && scene.emitterSamplingStrategy != EmitterSamplingStrategy.NONE && scene.getEmitterGrid() != null) {
@@ -512,6 +520,7 @@ private static void sampleEmitterFace(Scene scene, Ray ray, Grid.EmitterPosition
         e /= Math.max(distance * distance, 1);
         e *= pos.block.surfaceArea(face);
         e *= emitterRay.getCurrentMaterial().emittance;
+        e *= emitterRay.emittanceValue;
         e *= scene.emitterIntensity;
         e *= scaler;
 

chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java

@@ -701,6 +701,10 @@ private boolean worldIntersection(Ray ray) {
       ray.t = r.distance;
       ray.setNormal(r.getNormal());
       ray.color.set(r.color);
+      ray.emittanceValue = r.emittanceValue;
+      ray.reflectanceValue = r.reflectanceValue;
+      ray.roughnessValue = r.roughnessValue;
+      ray.metalnessValue = r.metalnessValue;
       ray.setPrevMaterial(r.getPrevMaterial(), r.getPrevData());
       ray.setCurrentMaterial(r.getCurrentMaterial(), r.getCurrentData());
       hit = true;
@@ -712,6 +716,10 @@ private boolean worldIntersection(Ray ray) {
         ray.t = r.distance;
         ray.setNormal(r.getNormal());
         ray.color.set(r.color);
+        ray.emittanceValue = r.emittanceValue;
+        ray.reflectanceValue = r.reflectanceValue;
+        ray.roughnessValue = r.roughnessValue;
+        ray.metalnessValue = r.metalnessValue;
         ray.setPrevMaterial(r.getPrevMaterial(), r.getPrevData());
         ray.setCurrentMaterial(r.getCurrentMaterial(), r.getCurrentData());
         hit = true;
@@ -725,6 +733,10 @@ private boolean worldIntersection(Ray ray) {
         ray.t = r.distance;
         ray.setNormal(r.getNormal());
         ray.color.set(r.color);
+        ray.emittanceValue = r.emittanceValue;
+        ray.reflectanceValue = r.reflectanceValue;
+        ray.roughnessValue = r.roughnessValue;
+        ray.metalnessValue = r.metalnessValue;
         ray.setPrevMaterial(r.getPrevMaterial(), r.getPrevData());
         ray.setCurrentMaterial(r.getCurrentMaterial(), r.getCurrentData());
         hit = true;

chunky/src/java/se/llbit/chunky/resources/ResourcePackLoader.java

@@ -64,12 +64,8 @@ default boolean hasUnloaded() {
     /**
      * Reset everything this loader has loaded previously. For example if this loader loads biomes, this should reset
      * the biomes as if this loader had never run.
-     * <p/>
-     * Some pack loaders, eg. the {@link ResourcePackTextureLoader}, don't support this and will do nothing. Resetting
-     * the loaded resources might take a restart of Chunky in that case.
      */
-    default void resetLoadedResources() {
-    }
+    void resetLoadedResources();
   }
 
   interface PackLoaderFactory {

chunky/src/java/se/llbit/chunky/resources/ResourcePackTextureLoader.java

@@ -70,6 +70,13 @@ public Collection<String> notLoaded() {
     return Collections.unmodifiableCollection(texturesToLoad.keySet());
   }
 
+  @Override
+  public void resetLoadedResources() {
+    for (TextureLoader loader : texturesToLoad.values()) {
+      loader.reset();
+    }
+  }
+
   private void loadTerrainTextures(LayeredResourcePacks root, ArrayList<String> toRemove) {
     Optional<InputStream> in = Optional.empty();
     try {