src/main/java/eu/jonahbauer/raytracing/Examples.java

@@ -1,11 +1,11 @@
 package eu.jonahbauer.raytracing;
 
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.color.ColorSpaces;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpaces;
-import eu.jonahbauer.raytracing.render.spectrum.RGBAlbedoSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBAlbedoSpectrum;
-import eu.jonahbauer.raytracing.render.spectrum.RGBIlluminantSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBIlluminantSpectrum;
 import eu.jonahbauer.raytracing.render.texture.CheckerTexture;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import eu.jonahbauer.raytracing.render.camera.SimpleCamera;
 import eu.jonahbauer.raytracing.render.material.*;
 import eu.jonahbauer.raytracing.render.texture.ImageTexture;
@@ -55,11 +55,11 @@ public class Examples {
         var cs = ColorSpaces.sRGB;
         return new Example(
                 new Scene(getSkyBox(), List.of(
-                        new Sphere(new Vec3(0, -100.5, -1.0), 100.0, new LambertianMaterial(cs.albedo(0.8, 0.8, 0.0))),
+                        new Sphere(new Vec3(0, -100.5, -1.0), 100.0, new LambertianMaterial(new ColorRGB(0.8, 0.8, 0.0), cs)),
-                        new Sphere(new Vec3(0, 0, -1.2), 0.5, new LambertianMaterial(cs.albedo(0.1, 0.2, 0.5))),
+                        new Sphere(new Vec3(0, 0, -1.2), 0.5, new LambertianMaterial(new ColorRGB(0.1, 0.2, 0.5), cs)),
                         new Sphere(new Vec3(-1.0, 0, -1.2), 0.5, new DielectricMaterial(1.5)),
                         new Sphere(new Vec3(-1.0, 0, -1.2), 0.4, new DielectricMaterial(1 / 1.5)),
-                        new Sphere(new Vec3(1.0, 0, -1.2), 0.5, new MetallicMaterial(cs.albedo(0.8, 0.6, 0.2)))
+                        new Sphere(new Vec3(1.0, 0, -1.2), 0.5, new MetallicMaterial(new ColorRGB(0.8, 0.6, 0.2), cs, 0.0))
                 )),
                 SimpleCamera.builder()
                         .withImage(height * 16 / 9, height)
@@ -92,12 +92,12 @@ public class Examples {
                 if (rnd < 0.8) {
                     // diffuse
                     var albedo = ColorRGB.random(rng).times(ColorRGB.random(rng));
-                    material = new LambertianMaterial(cs.albedo(albedo));
+                    material = new LambertianMaterial(albedo, cs);
                 } else if (rnd < 0.95) {
                     // metal
                     var albedo = ColorRGB.random(rng, 0.5, 1.0);
                     var fuzz = rng.nextDouble() * 0.5;
-                    material = new MetallicMaterial(cs.albedo(albedo), fuzz);
+                    material = new MetallicMaterial(albedo, cs, fuzz);
                 } else {
                     // glass
                     material = new DielectricMaterial(1.5);
@@ -108,8 +108,8 @@ public class Examples {
         }
 
         objects.add(new Sphere(new Vec3(0, 1, 0), 1.0, new DielectricMaterial(1.5)));
-        objects.add(new Sphere(new Vec3(-4, 1, 0), 1.0, new LambertianMaterial(cs.albedo(0.4, 0.2, 0.1))));
+        objects.add(new Sphere(new Vec3(-4, 1, 0), 1.0, new LambertianMaterial(new ColorRGB(0.4, 0.2, 0.1), cs)));
-        objects.add(new Sphere(new Vec3(4, 1, 0), 1.0, new MetallicMaterial(cs.albedo(0.7, 0.6, 0.5))));
+        objects.add(new Sphere(new Vec3(4, 1, 0), 1.0, new MetallicMaterial(new ColorRGB(0.7, 0.6, 0.5), cs)));
 
         var camera = SimpleCamera.builder()
                 .withImage(height * 16 / 9, height)
@@ -128,11 +128,11 @@ public class Examples {
         var cs = ColorSpaces.sRGB;
         return new Example(
                 new Scene(getSkyBox(), List.of(
-                        new Parallelogram(new Vec3(-3, -2, 5), new Vec3(0, 0, -4), new Vec3(0, 4, 0), new LambertianMaterial(cs.albedo(1.0, 0.2, 0.2))),
+                        new Parallelogram(new Vec3(-3, -2, 5), new Vec3(0, 0, -4), new Vec3(0, 4, 0), new LambertianMaterial(new ColorRGB(1.0, 0.2, 0.2), cs)),
-                        new Parallelogram(new Vec3(-2, -2, 0), new Vec3(4, 0, 0), new Vec3(0, 4, 0), new LambertianMaterial(cs.albedo(0.2, 1.0, 0.2))),
+                        new Parallelogram(new Vec3(-2, -2, 0), new Vec3(4, 0, 0), new Vec3(0, 4, 0), new LambertianMaterial(new ColorRGB(0.2, 1.0, 0.2), cs)),
-                        new Parallelogram(new Vec3(3, -2, 1), new Vec3(0, 0, 4), new Vec3(0, 4, 0), new LambertianMaterial(cs.albedo(0.2, 0.2, 1.0))),
+                        new Parallelogram(new Vec3(3, -2, 1), new Vec3(0, 0, 4), new Vec3(0, 4, 0), new LambertianMaterial(new ColorRGB(0.2, 0.2, 1.0), cs)),
-                        new Parallelogram(new Vec3(-2, 3, 1), new Vec3(4, 0, 0), new Vec3(0, 0, 4), new LambertianMaterial(cs.albedo(1.0, 0.5, 0.0))),
+                        new Parallelogram(new Vec3(-2, 3, 1), new Vec3(4, 0, 0), new Vec3(0, 0, 4), new LambertianMaterial(new ColorRGB(1.0, 0.5, 0.0), cs)),
-                        new Parallelogram(new Vec3(-2, -3, 5), new Vec3(4, 0, 0), new Vec3(0, 0, -4), new LambertianMaterial(cs.albedo(0.2, 0.8, 0.8)))
+                        new Parallelogram(new Vec3(-2, -3, 5), new Vec3(4, 0, 0), new Vec3(0, 0, -4), new LambertianMaterial(new ColorRGB(0.2, 0.8, 0.8), cs))
                 )),
                 SimpleCamera.builder()
                         .withImage(height, height)
@@ -148,10 +148,10 @@ public class Examples {
         var cs = ColorSpaces.sRGB;
         return new Example(
                 new Scene(List.of(
-                        new Sphere(new Vec3(0, -1000, 0), 1000, new LambertianMaterial(cs.albedo(0.2, 0.2, 0.2))),
+                        new Sphere(new Vec3(0, -1000, 0), 1000, new LambertianMaterial(new ColorRGB(0.2, 0.2, 0.2), cs)),
-                        new Sphere(new Vec3(0, 2, 0), 2, new LambertianMaterial(cs.albedo(0.2, 0.2, 0.2))),
+                        new Sphere(new Vec3(0, 2, 0), 2, new LambertianMaterial(new ColorRGB(0.2, 0.2, 0.2), cs)),
-                        new Parallelogram(new Vec3(3, 1, -2), new Vec3(2, 0, 0), new Vec3(0, 2, 0), new DiffuseLight(cs.illuminant(4.0))),
+                        new Parallelogram(new Vec3(3, 1, -2), new Vec3(2, 0, 0), new Vec3(0, 2, 0), new DiffuseLight(new ColorRGB(4.0, 4.0, 4.0), cs)),
-                        new Sphere(new Vec3(0, 7, 0), 2, new DiffuseLight(cs.illuminant(4.0)))
+                        new Sphere(new Vec3(0, 7, 0), 2, new DiffuseLight(new ColorRGB(4.0, 4.0, 4.0), cs))
                 )),
                 SimpleCamera.builder()
                         .withImage(height * 16 / 9, height)
@@ -166,10 +166,10 @@ public class Examples {
         if (height <= 0) height = 600;
 
         var cs = ColorSpaces.sRGB;
-        var red = new LambertianMaterial(cs.albedo(.65, .05, .05));
+        var red = new LambertianMaterial(new ColorRGB(.65, .05, .05), cs);
-        var white = new LambertianMaterial(cs.albedo(.73, .73, .73));
+        var white = new LambertianMaterial(new ColorRGB(.73, .73, .73), cs);
-        var green = new LambertianMaterial(cs.albedo(.12, .45, .15));
+        var green = new LambertianMaterial(new ColorRGB(.12, .45, .15), cs);
-        var light = new DiffuseLight(cs.illuminant(15.0));
+        var light = new DiffuseLight(new ColorRGB(15.0, 15.0, 15.0), cs);
 
         return new Example(
                 new Scene(List.of(
@@ -194,10 +194,10 @@ public class Examples {
     public static @NotNull Example getCornellBoxSmoke(int height) {
         if (height <= 0) height = 600;
         var cs = ColorSpaces.sRGB;
-        var red = new LambertianMaterial(cs.albedo(.65, .05, .05));
+        var red = new LambertianMaterial(new ColorRGB(.65, .05, .05), cs);
-        var white = new LambertianMaterial(cs.albedo(.73, .73, .73));
+        var white = new LambertianMaterial(new ColorRGB(.73, .73, .73), cs);
-        var green = new LambertianMaterial(cs.albedo(.12, .45, .15));
+        var green = new LambertianMaterial(new ColorRGB(.12, .45, .15), cs);
-        var light = new DiffuseLight(cs.illuminant(15.0));
+        var light = new DiffuseLight(new ColorRGB(15.0, 15.0, 15.0), cs);
 
         return new Example(
                 new Scene(List.of(
@@ -207,13 +207,13 @@ public class Examples {
                                 new Box(new Vec3(0, 0, 0), new Vec3(165, 330, 165), white)
                                         .rotateY(Math.toRadians(15))
                                         .translate(new Vec3(265, 0, 295)),
-                                0.01, new IsotropicMaterial(cs.albedo(ColorRGB.BLACK))
+                                0.01, new IsotropicMaterial(ColorRGB.BLACK, cs)
                         ),
                         new ConstantMedium(
                                 new Box(new Vec3(0, 0, 0), new Vec3(165, 165, 165), white)
                                         .rotateY(Math.toRadians(-18))
                                         .translate(new Vec3(130, 0, 65)),
-                                0.01, new IsotropicMaterial(cs.albedo(ColorRGB.WHITE))
+                                0.01, new IsotropicMaterial(ColorRGB.WHITE, cs)
                         )
                 )),
                 SimpleCamera.builder()
@@ -229,10 +229,10 @@ public class Examples {
         if (height <= 0) height = 600;
 
         var cs = ColorSpaces.sRGB;
-        var red = new LambertianMaterial(cs.albedo(.65, .05, .05));
+        var red = new LambertianMaterial(new ColorRGB(.65, .05, .05), cs);
-        var white = new LambertianMaterial(cs.albedo(.73, .73, .73));
+        var white = new LambertianMaterial(new ColorRGB(.73, .73, .73), cs);
-        var green = new LambertianMaterial(cs.albedo(.12, .45, .15));
+        var green = new LambertianMaterial(new ColorRGB(.12, .45, .15), cs);
-        var light = new DiffuseLight(cs.illuminant(7.0));
+        var light = new DiffuseLight(new ColorRGB(7.0, 7.0, 7.0), cs);
         var glass = new DielectricMaterial(1.5);
 
         var room = new Box(new Vec3(0, 0, 0), new Vec3(555, 555, 555), white, white, red, green, white, null);
@@ -259,15 +259,15 @@ public class Examples {
         var cs = ColorSpaces.sRGB;
         record Partei(String name, ColorRGB color, double stimmen) { }
         var data = List.of(
-                new Partei("CDU",       new ColorRGB(0x004B76), 18.9),
+                new Partei("CDU", new ColorRGB(0x00, 0x4B, 0x76), 18.9),
-                new Partei("SPD",       new ColorRGB(0xC0003C), 25.7),
+                new Partei("SPD", new ColorRGB(0xC0, 0x00, 0x3C), 25.7),
-                new Partei("AfD",       new ColorRGB(0x80CDEC), 10.3),
+                new Partei("AfD", new ColorRGB(0x80, 0xCD, 0xEC), 10.3),
-                new Partei("FDP",       new ColorRGB(0xF7BB3D), 11.5),
+                new Partei("FDP", new ColorRGB(0xF7, 0xBB, 0x3D), 11.5),
-                new Partei("DIE LINKE", new ColorRGB(0x5F316E), 4.9),
+                new Partei("DIE LINKE", new ColorRGB(0x5F, 0x31, 0x6E), 4.9),
-                new Partei("GRÜNE",     new ColorRGB(0x00854A), 14.8),
+                new Partei("GRÜNE", new ColorRGB(0x00, 0x85, 0x4A), 14.8),
-                new Partei("CSU",       new ColorRGB(0x0077B6), 5.2)
+                new Partei("CSU", new ColorRGB(0x00, 0x77, 0xB6), 5.2)
         );
-        var white = new LambertianMaterial(cs.albedo(.99, .99, .99));
+        var white = new LambertianMaterial(new ColorRGB(.99, .99, .99), cs);
 
         var count = data.size();
         var size = 75d;
@@ -287,7 +287,7 @@ public class Examples {
             objects.add(new Box(
                     new Vec3((i + 1) * spacing +       i * size, 0, spacing),
                     new Vec3((i + 1) * spacing + (i + 1) * size, partei.stimmen() * 15, spacing + size),
-                    new DielectricMaterial(1.5, cs.albedo(partei.color()))
+                    new DielectricMaterial(1.5, partei.color(), cs)
             ));
         }
 
@@ -346,7 +346,7 @@ public class Examples {
 
         // boxes
         var boxes = new ArrayList<Hittable>();
-        var ground = new LambertianMaterial(cs.albedo(0.48, 0.83, 0.53));
+        var ground = new LambertianMaterial(new ColorRGB(0.48, 0.83, 0.53), cs);
         for (int i = 0; i < 20; i++) {
             for (int j = 0; j < 20; j++) {
                 var w = 100.0;
@@ -364,23 +364,23 @@ public class Examples {
         // light
         objects.add(new Parallelogram(
                 new Vec3(123, 554, 147), new Vec3(300, 0, 0), new Vec3(0, 0, 265),
-                new DiffuseLight(cs.illuminant(7.0))
+                new DiffuseLight(new ColorRGB(7., 7., 7.), cs)
         ));
 
         // spheres with different materials
-        objects.add(new Sphere(new Vec3(400, 400, 200), 50, new LambertianMaterial(cs.albedo(0.7, 0.3, 0.1))));
+        objects.add(new Sphere(new Vec3(400, 400, 200), 50, new LambertianMaterial(new ColorRGB(0.7, 0.3, 0.1), cs)));
         objects.add(new Sphere(new Vec3(260, 150, 45), 50, new DielectricMaterial(1.5)));
-        objects.add(new Sphere(new Vec3(0, 150, 145), 50, new MetallicMaterial(cs.albedo(0.8, 0.8, 0.9), 1.0)));
+        objects.add(new Sphere(new Vec3(0, 150, 145), 50, new MetallicMaterial(new ColorRGB(0.8, 0.8, 0.9), cs, 1.0)));
 
         // glass sphere filled with gas
         var boundary = new Sphere(new Vec3(360, 150, 145), 70, new DielectricMaterial(1.5));
         objects.add(boundary);
-        objects.add(new ConstantMedium(boundary, 0.2, new IsotropicMaterial(cs.albedo(0.2, 0.4, 0.9))));
+        objects.add(new ConstantMedium(boundary, 0.2, new IsotropicMaterial(new ColorRGB(0.2, 0.4, 0.9), cs)));
 
         // put the world in a glass sphere
         objects.add(new ConstantMedium(
                 new Sphere(new Vec3(0, 0, 0), 5000, new DielectricMaterial(1.5)),
-                0.0001, new IsotropicMaterial(cs.albedo(1.0, 1.0, 1.0))
+                0.0001, new IsotropicMaterial(new ColorRGB(1., 1., 1.), cs)
         ));
 
         // textures spheres
@@ -388,7 +388,7 @@ public class Examples {
         objects.add(new Sphere(new Vec3(220, 280, 300), 80, new LambertianMaterial(new PerlinTexture(0.2))));
 
         // box from spheres
-        var white = new LambertianMaterial(cs.albedo(.73, .73, .73));
+        var white = new LambertianMaterial(new ColorRGB(.73, .73, .73), cs);
         var spheres = new ArrayList<Hittable>();
         for (int j = 0; j < 1000; j++) {
             spheres.add(new Sphere(new Vec3(random.nextDouble(165), random.nextDouble(165), random.nextDouble(165)), 10, white));

src/main/java/eu/jonahbauer/raytracing/Main.java

@@ -1,11 +1,13 @@
 package eu.jonahbauer.raytracing;
 
+import eu.jonahbauer.raytracing.render.ImageFormat;
 import eu.jonahbauer.raytracing.render.canvas.Canvas;
 import eu.jonahbauer.raytracing.render.canvas.LiveCanvas;
 import eu.jonahbauer.raytracing.render.canvas.XYZCanvas;
-import eu.jonahbauer.raytracing.render.image.PNGImageWriter;
 import eu.jonahbauer.raytracing.render.renderer.SimpleRenderer;
-import eu.jonahbauer.raytracing.render.color.ColorSpaces;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpaces;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBAlbedoSpectrum;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.IOException;
@@ -42,7 +44,7 @@ public class Main {
         renderer.render(camera, scene, canvas);
         System.out.printf("rendering finished after %dms", (System.nanoTime() - time) / 1_000_000);
 
-        PNGImageWriter.sRGB.write(canvas, config.path);
+        ImageFormat.PNG.write(canvas, config.path);
     }
 
     private record Config(@NotNull Example example, @NotNull Path path, boolean preview, boolean iterative, boolean parallel, int samples, int depth) {

src/main/java/eu/jonahbauer/raytracing/math/IVec.java

@@ -1,6 +1,5 @@
 package eu.jonahbauer.raytracing.math;
 
-import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -8,26 +7,15 @@ import org.jetbrains.annotations.NotNull;
  * @param <T> the type
  */
 public interface IVec<T extends IVec<T>> {
-    @Contract(pure = true)
     double get(int i);
 
-    @Contract(pure = true)
     @NotNull T plus(@NotNull T other);
-
-    @Contract(pure = true)
     @NotNull T minus(@NotNull T other);
-
-    @Contract(pure = true)
     @NotNull T times(@NotNull T other);
-
-    @Contract(pure = true)
     @NotNull T times(double d);
-
-    @Contract(pure = true)
     default @NotNull T div(double d) {
         return times(1 / d);
     }
 
-    @Contract(pure = true)
     double @NotNull[] toArray();
 }

src/main/java/eu/jonahbauer/raytracing/math/IVec3.java

@@ -1,6 +1,5 @@
 package eu.jonahbauer.raytracing.math;
 
-import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -8,23 +7,17 @@ import org.jetbrains.annotations.NotNull;
  * @param <T> the type
  */
 public interface IVec3<T extends Record & IVec3<T>> extends IVec<T> {
-    @Contract(pure = true)
     default double component1() {
         return toVec3().x();
     }
-
-    @Contract(pure = true)
     default double component2() {
         return toVec3().y();
     }
-
-    @Contract(pure = true)
     default double component3() {
         return toVec3().z();
     }
 
     @Override
-    @Contract(pure = true)
     default double get(int i) {
         return switch (i) {
             case 0 -> component1();
@@ -34,13 +27,9 @@ public interface IVec3<T extends Record & IVec3<T>> extends IVec<T> {
         };
     }
 
-    @Contract(pure = true)
+    @NotNull Vec3 toVec3();
-    default @NotNull Vec3 toVec3() {
-        return new Vec3(component1(), component2(), component3());
-    }
 
     @Override
-    @Contract(pure = true)
     default double @NotNull [] toArray() {
         return new double[] {component1(), component2(), component3()};
     }

src/main/java/eu/jonahbauer/raytracing/math/Ray.java

@@ -1,6 +1,6 @@
 package eu.jonahbauer.raytracing.math;
 
-import eu.jonahbauer.raytracing.render.spectrum.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Objects;

src/main/java/eu/jonahbauer/raytracing/render/ImageFormat.java

@@ -0,0 +1,135 @@
+package eu.jonahbauer.raytracing.render;
+
+import eu.jonahbauer.raytracing.render.canvas.Canvas;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpaces;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.zip.CRC32;
+import java.util.zip.CheckedOutputStream;
+import java.util.zip.DeflaterOutputStream;
+
+public enum ImageFormat {
+    PPM {
+        @Override
+        public void write(@NotNull Canvas image, @NotNull OutputStream out) throws IOException {
+            try (var writer = new BufferedWriter(new OutputStreamWriter(out, StandardCharsets.US_ASCII))) {
+                writer.write("P3\n");
+                writer.write(String.valueOf(image.getWidth()));
+                writer.write(" ");
+                writer.write(String.valueOf(image.getHeight()));
+                writer.write("\n255\n");
+
+                for (int y = 0; y < image.getHeight(); y++) {
+                    for (int x = 0; x < image.getWidth(); x++) {
+                        var color = image.getRGB(x, y, ColorSpaces.sRGB);
+                        writer.write(String.valueOf(color.red()));
+                        writer.write(" ");
+                        writer.write(String.valueOf(color.green()));
+                        writer.write(" ");
+                        writer.write(String.valueOf(color.blue()));
+                        writer.write("\n");
+                    }
+                }
+            }
+        }
+    },
+    PNG {
+        private static final byte[] MAGIC = new byte[] { (byte) 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
+        private static final int IHDR_LENGTH = 13;
+        private static final int IHDR_TYPE = 0x49484452;
+        private static final int IDAT_TYPE = 0x49444154;
+        private static final int IEND_TYPE = 0x49454E44;
+        private static final int IEND_CRC = 0xAE426082;
+
+        @Override
+        public void write(@NotNull Canvas image, @NotNull OutputStream out) throws IOException {
+            try (var data = new NoCloseDataOutputStream(out); var _ = data.closeable()) {
+                data.write(MAGIC);
+
+                writeIHDR(image, data);
+                writeIDAT(image, data);
+                writeIEND(image, data);
+            }
+        }
+
+        private void writeIHDR(@NotNull Canvas image, @NotNull DataOutputStream data) throws IOException {
+            data.writeInt(IHDR_LENGTH);
+            try (
+                    var crc = new CheckedOutputStream(data, new CRC32());
+                    var ihdr = new DataOutputStream(crc)
+            ) {
+                ihdr.writeInt(IHDR_TYPE);
+                ihdr.writeInt(image.getWidth()); // image width
+                ihdr.writeInt(image.getHeight()); // image height
+                ihdr.writeByte(8); // bit depth
+                ihdr.writeByte(2); // color type
+                ihdr.writeByte(0); // compression method
+                ihdr.writeByte(0); // filter method
+                ihdr.writeByte(0); // interlace method
+                ihdr.flush();
+                data.writeInt((int) crc.getChecksum().getValue());
+            }
+        }
+
+        private void writeIDAT(@NotNull Canvas image, @NotNull DataOutputStream data) throws IOException {
+            try (
+                    var baos = new ByteArrayOutputStream();
+                    var crc = new CheckedOutputStream(baos, new CRC32());
+                    var idat = new DataOutputStream(crc)
+            ) {
+                idat.writeInt(IDAT_TYPE);
+
+                try (var deflate = new DataOutputStream(new DeflaterOutputStream(idat))) {
+                    for (int y = 0; y < image.getHeight(); y++) {
+                        deflate.writeByte(0); // filter type
+                        for (int x = 0; x < image.getWidth(); x++) {
+                            var pixel = image.getRGB(x, y, ColorSpaces.sRGB);
+                            deflate.writeByte(pixel.red());
+                            deflate.writeByte(pixel.green());
+                            deflate.writeByte(pixel.blue());
+                        }
+                    }
+                }
+
+                var bytes = baos.toByteArray();
+                data.writeInt(bytes.length - 4); // don't include type in length
+                data.write(bytes);
+                data.writeInt((int) crc.getChecksum().getValue());
+            }
+        }
+
+        private void writeIEND(@NotNull Canvas image, @NotNull DataOutputStream data) throws IOException {
+            data.writeInt(0);
+            data.writeInt(IEND_TYPE);
+            data.writeInt(IEND_CRC);
+        }
+
+        private static class NoCloseDataOutputStream extends DataOutputStream {
+            public NoCloseDataOutputStream(OutputStream out) {
+                super(out);
+            }
+
+            @Override
+            public void close() {
+                // do nothing
+            }
+
+            public Closeable closeable() {
+                return super::close;
+            }
+        }
+    },
+    ;
+
+    public void write(@NotNull Canvas image, @NotNull Path path) throws IOException {
+        try (var out = Files.newOutputStream(path)) {
+            write(image, out);
+        }
+    }
+
+    public abstract void write(@NotNull Canvas image, @NotNull OutputStream out) throws IOException;
+}

src/main/java/eu/jonahbauer/raytracing/render/camera/SimpleCamera.java

@@ -2,7 +2,7 @@ package eu.jonahbauer.raytracing.render.camera;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 

src/main/java/eu/jonahbauer/raytracing/render/canvas/Canvas.java

@@ -1,9 +1,9 @@
 package eu.jonahbauer.raytracing.render.canvas;
 
-import eu.jonahbauer.raytracing.render.spectrum.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
-import eu.jonahbauer.raytracing.render.spectrum.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
 import org.jetbrains.annotations.NotNull;
 
 public interface Canvas {

src/main/java/eu/jonahbauer/raytracing/render/canvas/LiveCanvas.java

@@ -1,9 +1,9 @@
 package eu.jonahbauer.raytracing.render.canvas;
 
-import eu.jonahbauer.raytracing.render.spectrum.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
-import eu.jonahbauer.raytracing.render.spectrum.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
 import org.jetbrains.annotations.NotNull;
 
 import javax.swing.*;
@@ -36,7 +36,7 @@ public final class LiveCanvas implements Canvas {
     @Override
     public void add(int x, int y, int n, @NotNull SampledSpectrum spectrum, @NotNull SampledWavelengths lambda) {
         delegate.add(x, y, n, spectrum, lambda);
-        var color = cs.encode(delegate.getRGB(x, y, cs));
+        var color = ColorRGB.gamma(delegate.getRGB(x, y, cs));
         var rgb = color.red() << 16 | color.green() << 8 | color.blue();
         image.setRGB(x, y, rgb);
     }

src/main/java/eu/jonahbauer/raytracing/render/canvas/RGBCanvas.java

@@ -1,9 +1,9 @@
 package eu.jonahbauer.raytracing.render.canvas;
 
-import eu.jonahbauer.raytracing.render.spectrum.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
-import eu.jonahbauer.raytracing.render.spectrum.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
 import org.jetbrains.annotations.NotNull;
 
 import java.awt.image.BufferedImage;

src/main/java/eu/jonahbauer/raytracing/render/canvas/XYZCanvas.java

@@ -1,10 +1,10 @@
 package eu.jonahbauer.raytracing.render.canvas;
 
-import eu.jonahbauer.raytracing.render.spectrum.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
-import eu.jonahbauer.raytracing.render.spectrum.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
 import org.jetbrains.annotations.NotNull;
 
 import java.awt.image.BufferedImage;

src/main/java/eu/jonahbauer/raytracing/render/color/TransferFunction.java

@@ -1,8 +0,0 @@
-package eu.jonahbauer.raytracing.render.color;
-
-import org.jetbrains.annotations.NotNull;
-
-public interface TransferFunction {
-    @NotNull ColorRGB decode(@NotNull ColorRGB rgb);
-    @NotNull ColorRGB encode(@NotNull ColorRGB rgb);
-}

src/main/java/eu/jonahbauer/raytracing/render/color/TransferFunctions.java

@@ -1,50 +0,0 @@
-package eu.jonahbauer.raytracing.render.color;
-
-import org.jetbrains.annotations.NotNull;
-
-public final class TransferFunctions {
-    public static final @NotNull TransferFunction sRGB = new ComponentTransferFunction() {
-        @Override
-        protected double encode(double value) {
-            if (value <= 0.0031308) return 12.92 * value;
-            return 1.055 * Math.pow(value, 1. / 2.4) - 0.055;
-        }
-
-        @Override
-        protected double decode(double value) {
-            if (value <= 0.04045) return value / 12.92;
-            return Math.pow((value + 0.055) / 1.055, 2.4d);
-        }
-    };
-
-    public static final @NotNull TransferFunction LINEAR = new TransferFunction() {
-        @Override
-        public @NotNull ColorRGB encode(@NotNull ColorRGB rgb) {
-            return rgb;
-        }
-
-        @Override
-        public @NotNull ColorRGB decode(@NotNull ColorRGB rgb) {
-            return rgb;
-        }
-    };
-
-    private TransferFunctions() {
-        throw new UnsupportedOperationException();
-    }
-
-    private abstract static class ComponentTransferFunction implements TransferFunction {
-        @Override
-        public final @NotNull ColorRGB decode(@NotNull ColorRGB rgb) {
-            return new ColorRGB(decode(rgb.r()), decode(rgb.g()), decode(rgb.b()));
-        }
-
-        @Override
-        public final @NotNull ColorRGB encode(@NotNull ColorRGB rgb) {
-            return new ColorRGB(encode(rgb.r()), encode(rgb.g()), encode(rgb.b()));
-        }
-
-        protected abstract double encode(double value);
-        protected abstract double decode(double value);
-    }
-}

src/main/java/eu/jonahbauer/raytracing/render/image/ImageWriter.java

@@ -1,19 +0,0 @@
-package eu.jonahbauer.raytracing.render.image;
-
-import eu.jonahbauer.raytracing.render.canvas.Canvas;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.IOException;
-import java.io.OutputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-public interface ImageWriter {
-    default void write(@NotNull Canvas image, @NotNull Path path) throws IOException {
-        try (var out = Files.newOutputStream(path)) {
-            write(image, out);
-        }
-    }
-
-    void write(@NotNull Canvas canvas, @NotNull OutputStream out) throws IOException;
-}

src/main/java/eu/jonahbauer/raytracing/render/image/PNGImageWriter.java

@@ -1,107 +0,0 @@
-package eu.jonahbauer.raytracing.render.image;
-
-import eu.jonahbauer.raytracing.render.canvas.Canvas;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.ColorSpaces;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.*;
-import java.util.Objects;
-import java.util.zip.CRC32;
-import java.util.zip.CheckedOutputStream;
-import java.util.zip.DeflaterOutputStream;
-
-public class PNGImageWriter implements ImageWriter {
-    public static final @NotNull PNGImageWriter sRGB = new PNGImageWriter(ColorSpaces.sRGB);
-
-    private static final byte[] MAGIC = new byte[] { (byte) 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A };
-    private static final int IHDR_LENGTH = 13;
-    private static final int IHDR_TYPE = 0x49484452;
-    private static final int IDAT_TYPE = 0x49444154;
-    private static final int IEND_TYPE = 0x49454E44;
-    private static final int IEND_CRC = 0xAE426082;
-
-    private final @NotNull ColorSpace cs;
-
-    public PNGImageWriter(@NotNull ColorSpace cs) {
-        this.cs = Objects.requireNonNull(cs, "cs");
-    }
-
-    @Override
-    public void write(@NotNull Canvas image, @NotNull OutputStream out) throws IOException {
-        try (var data = new NoCloseDataOutputStream(out); var _ = data.closeable()) {
-            data.write(MAGIC);
-
-            writeIHDR(image, data);
-            writeIDAT(image, data);
-            writeIEND(image, data);
-        }
-    }
-
-    private void writeIHDR(@NotNull Canvas image, @NotNull DataOutputStream data) throws IOException {
-        data.writeInt(IHDR_LENGTH);
-        try (
-                var crc = new CheckedOutputStream(data, new CRC32());
-                var ihdr = new DataOutputStream(crc)
-        ) {
-            ihdr.writeInt(IHDR_TYPE);
-            ihdr.writeInt(image.getWidth()); // image width
-            ihdr.writeInt(image.getHeight()); // image height
-            ihdr.writeByte(8); // bit depth
-            ihdr.writeByte(2); // color type
-            ihdr.writeByte(0); // compression method
-            ihdr.writeByte(0); // filter method
-            ihdr.writeByte(0); // interlace method
-            ihdr.flush();
-            data.writeInt((int) crc.getChecksum().getValue());
-        }
-    }
-
-    private void writeIDAT(@NotNull Canvas image, @NotNull DataOutputStream data) throws IOException {
-        try (
-                var baos = new ByteArrayOutputStream();
-                var crc = new CheckedOutputStream(baos, new CRC32());
-                var idat = new DataOutputStream(crc)
-        ) {
-            idat.writeInt(IDAT_TYPE);
-
-            try (var deflate = new DataOutputStream(new DeflaterOutputStream(idat))) {
-                for (int y = 0; y < image.getHeight(); y++) {
-                    deflate.writeByte(0); // filter type
-                    for (int x = 0; x < image.getWidth(); x++) {
-                        var pixel = cs.encode(image.getRGB(x, y, cs));
-                        deflate.writeByte(pixel.red());
-                        deflate.writeByte(pixel.green());
-                        deflate.writeByte(pixel.blue());
-                    }
-                }
-            }
-
-            var bytes = baos.toByteArray();
-            data.writeInt(bytes.length - 4); // don't include type in length
-            data.write(bytes);
-            data.writeInt((int) crc.getChecksum().getValue());
-        }
-    }
-
-    private void writeIEND(@NotNull Canvas image, @NotNull DataOutputStream data) throws IOException {
-        data.writeInt(0);
-        data.writeInt(IEND_TYPE);
-        data.writeInt(IEND_CRC);
-    }
-
-    private static class NoCloseDataOutputStream extends DataOutputStream {
-        public NoCloseDataOutputStream(OutputStream out) {
-            super(out);
-        }
-
-        @Override
-        public void close() {
-            // do nothing
-        }
-
-        public Closeable closeable() {
-            return super::close;
-        }
-    }
-}

src/main/java/eu/jonahbauer/raytracing/render/image/PPMImageWriter.java

@@ -1,46 +0,0 @@
-package eu.jonahbauer.raytracing.render.image;
-
-import eu.jonahbauer.raytracing.render.canvas.Canvas;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.ColorSpaces;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.BufferedWriter;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.nio.charset.StandardCharsets;
-import java.util.Objects;
-
-public class PPMImageWriter implements ImageWriter {
-    public static final PPMImageWriter sRGB = new PPMImageWriter(ColorSpaces.sRGB);
-
-    private final @NotNull ColorSpace cs;
-
-    public PPMImageWriter(@NotNull ColorSpace cs) {
-        this.cs = Objects.requireNonNull(cs, "cs");
-    }
-
-    @Override
-    public void write(@NotNull Canvas image, @NotNull OutputStream out) throws IOException {
-        try (var writer = new BufferedWriter(new OutputStreamWriter(out, StandardCharsets.US_ASCII))) {
-            writer.write("P3\n");
-            writer.write(String.valueOf(image.getWidth()));
-            writer.write(" ");
-            writer.write(String.valueOf(image.getHeight()));
-            writer.write("\n255\n");
-
-            for (int y = 0; y < image.getHeight(); y++) {
-                for (int x = 0; x < image.getWidth(); x++) {
-                    var color = cs.encode(image.getRGB(x, y, cs));
-                    writer.write(String.valueOf(color.red()));
-                    writer.write(" ");
-                    writer.write(String.valueOf(color.green()));
-                    writer.write(" ");
-                    writer.write(String.valueOf(color.blue()));
-                    writer.write("\n");
-                }
-            }
-        }
-    }
-}

src/main/java/eu/jonahbauer/raytracing/render/material/DielectricMaterial.java

@@ -2,7 +2,10 @@ package eu.jonahbauer.raytracing.render.material;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBAlbedoSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;
@@ -11,34 +14,25 @@ import java.util.Objects;
 import java.util.Optional;
 import java.util.random.RandomGenerator;
 
-public record DielectricMaterial(@NotNull RefractiveIndex ri, @NotNull Texture texture) implements Material {
+public record DielectricMaterial(double refractionIndex, @NotNull Texture texture) implements Material {
-    public DielectricMaterial {
+    public DielectricMaterial(double refractionIndex) {
-        Objects.requireNonNull(ri, "ri");
+        this(refractionIndex, Spectra.WHITE);
-        Objects.requireNonNull(texture, "texture");
     }
 
-    public DielectricMaterial(@NotNull RefractiveIndex ri) {
+    public DielectricMaterial {
-        this(ri, Spectra.WHITE);
+        Objects.requireNonNull(texture, "texture");
-    }
-
-    public DielectricMaterial(double ri) {
-        this(new ConstantRefractiveIndex(ri), Spectra.WHITE);
     }
 
-    public DielectricMaterial(double ri, @NotNull Texture texture) {
+    public DielectricMaterial(double refractionIndex, @NotNull ColorRGB color, @NotNull ColorSpace cs) {
-        this(new ConstantRefractiveIndex(ri), texture);
+        this(refractionIndex, new RGBAlbedoSpectrum(cs, color));
     }
 
     @Override
     public @NotNull Optional<ScatterResult> scatter(@NotNull Ray ray, @NotNull HitResult hit, @NotNull RandomGenerator random) {
-        var ri = switch (this.ri) {
+        var ri = hit.isFrontFace() ? (1 / refractionIndex) : refractionIndex;
-            case ConstantRefractiveIndex(var x) -> x;
-            case RefractiveIndex x -> x.get(ray.lambda().collapse());
-        };
-        if (hit.isFrontFace()) ri = 1 / ri;
 
         var cosTheta = Math.min(- ray.direction().unit().dot(hit.normal()), 1.0);
-        var reflectance = reflectance(cosTheta, ri);
+        var reflectance = reflectance(cosTheta);
         var reflect = reflectance > random.nextDouble();
 
         var newDirection = (reflect ? Optional.<Vec3>empty() : Vec3.refract(ray.direction(), hit.normal(), ri))
@@ -48,38 +42,10 @@ public record DielectricMaterial(@NotNull RefractiveIndex ri, @NotNull Texture t
         return Optional.of(new SpecularScatterResult(attenuation, new Ray(hit.position(), newDirection, ray.lambda())));
     }
 
-    private double reflectance(double cos, double ri) {
+    private double reflectance(double cos) {
         // use schlick's approximation for reflectance
-        var r0 = (1 - ri) / (1 + ri);
+        var r0 = (1 - refractionIndex) / (1 + refractionIndex);
         r0 = r0 * r0;
         return r0 + (1 - r0) * (1 - cos) * (1 - cos) * (1 - cos) * (1 - cos) * (1 - cos);
     }
-
-    @FunctionalInterface
-    public interface RefractiveIndex {
-        double get(double lambda);
-    }
-
-    public record ConstantRefractiveIndex(double ri) implements RefractiveIndex {
-
-        @Override
-        public double get(double lambda) {
-            return ri;
-        }
-    }
-
-    public record SellmeierRefractiveIndex(
-            double B1, double B2, double B3,
-            double C1, double C2, double C3
-    ) implements RefractiveIndex {
-
-        @Override
-        public double get(double lambda) {
-            var l2 = lambda * lambda * 1E-6; // square and convert to µm
-            var x = 1 + B1 * l2 / (l2 - C1)
-                      + B2 * l2 / (l2 - C2)
-                      + B3 * l2 / (l2 - C3);
-            return Math.sqrt(x);
-        }
-    }
 }

src/main/java/eu/jonahbauer/raytracing/render/material/DiffuseLight.java

@@ -1,7 +1,10 @@
 package eu.jonahbauer.raytracing.render.material;
 
 import eu.jonahbauer.raytracing.math.Ray;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBIlluminantSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;
@@ -15,6 +18,10 @@ public record DiffuseLight(@NotNull Texture texture) implements Material {
         Objects.requireNonNull(texture, "texture");
     }
 
+    public DiffuseLight(@NotNull ColorRGB color, @NotNull ColorSpace cs) {
+        this(new RGBIlluminantSpectrum(cs, color));
+    }
+
     @Override
     public @NotNull Optional<ScatterResult> scatter(@NotNull Ray ray, @NotNull HitResult hit, @NotNull RandomGenerator random) {
         return Optional.empty();

src/main/java/eu/jonahbauer/raytracing/render/material/DirectionalMaterial.java

@@ -2,8 +2,8 @@ package eu.jonahbauer.raytracing.render.material;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;

src/main/java/eu/jonahbauer/raytracing/render/material/IsotropicMaterial.java

@@ -2,7 +2,10 @@ package eu.jonahbauer.raytracing.render.material;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.render.renderer.pdf.SphereProbabilityDensityFunction;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBAlbedoSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;
@@ -16,6 +19,10 @@ public record IsotropicMaterial(@NotNull Spectrum albedo) implements Material {
         Objects.requireNonNull(albedo, "albedo");
     }
 
+    public IsotropicMaterial(@NotNull ColorRGB color, @NotNull ColorSpace cs) {
+        this(new RGBAlbedoSpectrum(cs, color));
+    }
+
     @Override
     public @NotNull Optional<ScatterResult> scatter(@NotNull Ray ray, @NotNull HitResult hit, @NotNull RandomGenerator random) {
         return Optional.of(new PdfScatterResult(albedo(), new SphereProbabilityDensityFunction()));

src/main/java/eu/jonahbauer/raytracing/render/material/LambertianMaterial.java

@@ -2,6 +2,9 @@ package eu.jonahbauer.raytracing.render.material;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.render.renderer.pdf.CosineProbabilityDensityFunction;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBAlbedoSpectrum;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;
@@ -15,6 +18,10 @@ public record LambertianMaterial(@NotNull Texture texture) implements Material {
         Objects.requireNonNull(texture, "texture");
     }
 
+    public LambertianMaterial(@NotNull ColorRGB color, @NotNull ColorSpace cs) {
+        this(new RGBAlbedoSpectrum(cs, color));
+    }
+
     @Override
     public @NotNull Optional<ScatterResult> scatter(@NotNull Ray ray, @NotNull HitResult hit, @NotNull RandomGenerator random) {
         var attenuation = texture.get(hit);

src/main/java/eu/jonahbauer/raytracing/render/material/Material.java

@@ -2,9 +2,9 @@ package eu.jonahbauer.raytracing.render.material;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.render.renderer.pdf.ProbabilityDensityFunction;
-import eu.jonahbauer.raytracing.render.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;

src/main/java/eu/jonahbauer/raytracing/render/material/Materials.java

@@ -1,25 +0,0 @@
-package eu.jonahbauer.raytracing.render.material;
-
-import eu.jonahbauer.raytracing.render.color.ColorSpaces;
-import eu.jonahbauer.raytracing.render.material.DielectricMaterial.SellmeierRefractiveIndex;
-import eu.jonahbauer.raytracing.render.spectrum.Spectra;
-import eu.jonahbauer.raytracing.render.texture.CheckerTexture;
-import org.jetbrains.annotations.NotNull;
-
-public final class Materials {
-    public static final @NotNull Material GLASS = new DielectricMaterial(new SellmeierRefractiveIndex(
-            1.0361212, 0.231792344, 1.01046945,
-            6.00069867E-3, 2.00179144E-2, 1.03560653E2
-    ));
-
-    public static final @NotNull Material MIRROR = new MetallicMaterial(ColorSpaces.sRGB.albedo(0.7, 0.7, 0.7));
-
-    public static final @NotNull Material DEBUG = new DirectionalMaterial(
-            new LambertianMaterial(new CheckerTexture(50.0, ColorSpaces.sRGB.albedo(1.0, 0.0, 1.0), Spectra.BLACK)),
-            new LambertianMaterial(new CheckerTexture(50.0, ColorSpaces.sRGB.albedo(1.0, 1.0, 1.0), Spectra.BLACK))
-    );
-
-    private Materials() {
-        throw new UnsupportedOperationException();
-    }
-}

src/main/java/eu/jonahbauer/raytracing/render/material/MetallicMaterial.java

@@ -2,6 +2,9 @@ package eu.jonahbauer.raytracing.render.material;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.math.Vec3;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBAlbedoSpectrum;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;
@@ -16,6 +19,14 @@ public record MetallicMaterial(@NotNull Texture texture, double fuzz) implements
         this(texture, 0);
     }
 
+    public MetallicMaterial(@NotNull ColorRGB color, @NotNull ColorSpace cs) {
+        this(color, cs, 0);
+    }
+
+    public MetallicMaterial(@NotNull ColorRGB color, @NotNull ColorSpace cs, double fuzz) {
+        this(new RGBAlbedoSpectrum(cs, color), fuzz);
+    }
+
     public MetallicMaterial {
         Objects.requireNonNull(texture, "texture");
         if (fuzz < 0 || !Double.isFinite(fuzz)) throw new IllegalArgumentException("fuzz must be non-negative");

src/main/java/eu/jonahbauer/raytracing/render/renderer/SimpleRenderer.java

@@ -4,7 +4,7 @@ import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.render.material.Material;
 import eu.jonahbauer.raytracing.render.renderer.pdf.TargetingProbabilityDensityFunction;
 import eu.jonahbauer.raytracing.render.renderer.pdf.MixtureProbabilityDensityFunction;
-import eu.jonahbauer.raytracing.render.spectrum.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
 import eu.jonahbauer.raytracing.render.camera.Camera;
 import eu.jonahbauer.raytracing.render.canvas.Canvas;
 import eu.jonahbauer.raytracing.scene.Scene;

src/main/java/eu/jonahbauer/raytracing/render/spectral/SampledSpectrum.java

@@ -1,9 +1,10 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral;
 
 import eu.jonahbauer.raytracing.math.IVec;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Arrays;

src/main/java/eu/jonahbauer/raytracing/render/spectral/SampledWavelengths.java

@@ -1,7 +1,8 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral;
 
-import eu.jonahbauer.raytracing.render.color.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
-import org.jetbrains.annotations.Contract;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Arrays;
@@ -45,12 +46,10 @@ public final class SampledWavelengths {
         this.pdf = pdf;
     }
 
-    @Contract(pure = true)
     public double get(int index) {
         return lambdas[index];
     }
 
-    @Contract(pure = true)
     public int size() {
         return lambdas.length;
     }
@@ -59,13 +58,12 @@ public final class SampledWavelengths {
      * Terminates the secondary wavelengths. This method should be called after a wavelength-dependent operation like
      * refraction that makes it incorrect to track multiple wavelengths together.
      */
-    @Contract(mutates = "this")
+    public @NotNull SampledWavelengths collapse() {
-    public double collapse() {
+        if (pdf.length < 2 || pdf[1] == 0) return this;
-        if (pdf.length >= 2 || pdf[1] != 0) {
+        var newPdf = Arrays.copyOf(pdf, pdf.length);
-            Arrays.fill(pdf, 1, pdf.length, 0d);
+        Arrays.fill(newPdf, 1, newPdf.length, 0d);
-            pdf[0] /= pdf.length;
+        newPdf[0] /= newPdf.length;
-        }
+        return new SampledWavelengths(lambdas, newPdf);
-        return lambdas[0];
     }
 
     /*

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/Chromaticity.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
 /**
  * A pair of chromaticity coordinates in the xyY color space

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/ColorRGB.java

@@ -1,10 +1,13 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
 import eu.jonahbauer.raytracing.math.IVec3;
+import eu.jonahbauer.raytracing.math.Vec3;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Random;
 
+import static eu.jonahbauer.raytracing.Main.DEBUG;
+
 public record ColorRGB(double r, double g, double b) implements IVec3<ColorRGB> {
     public static final @NotNull ColorRGB BLACK = new ColorRGB(0.0, 0.0, 0.0);
     public static final @NotNull ColorRGB WHITE = new ColorRGB(1.0, 1.0, 1.0);
@@ -23,13 +26,17 @@ public record ColorRGB(double r, double g, double b) implements IVec3<ColorRGB>
     }
 
     public ColorRGB(int rgb) {
-        this(((rgb >> 16) & 0xFF) / 255d, ((rgb >> 8) & 0xFF) / 255d, (rgb & 0xFF) / 255d);
+        this((rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
+    }
+    
+    public ColorRGB(int red, int green, int blue) {
+        this(red / 255f, green / 255f, blue / 255f);
     }
 
     public ColorRGB {
-        assert Double.isFinite(r) : "r must be finite";
+        if (DEBUG && (!Double.isFinite(r) || !Double.isFinite(g) || !Double.isFinite(b))) {
-        assert Double.isFinite(g) : "g must be finite";
+            throw new IllegalArgumentException("r, g and b must be finite");
-        assert Double.isFinite(b) : "b must be finite";
+        }
     }
 
     /*
@@ -58,6 +65,24 @@ public record ColorRGB(double r, double g, double b) implements IVec3<ColorRGB>
         );
     }
 
+    public static @NotNull ColorRGB gamma(@NotNull ColorRGB color) {
+        return new ColorRGB(gamma(color.r), gamma(color.g), gamma(color.b));
+    }
+
+    public static @NotNull ColorRGB inverseGamma(@NotNull ColorRGB color) {
+        return new ColorRGB(inverseGamma(color.r), inverseGamma(color.g), inverseGamma(color.b));
+    }
+
+    private static double gamma(double value) {
+        if (value <= 0.0031308) return 12.92 * value;
+        return 1.055 * Math.pow(value, 1. / 2.4) - 0.055;
+    }
+
+    private static double inverseGamma(double value) {
+        if (value <= 0.04045) return value / 12.92;
+        return Math.pow((value + 0.055) / 1.055, 2.4d);
+    }
+
     @Override
     public @NotNull ColorRGB plus(@NotNull ColorRGB other) {
         return new ColorRGB(r + other.r, g + other.g, b + other.b);
@@ -78,6 +103,19 @@ public record ColorRGB(double r, double g, double b) implements IVec3<ColorRGB>
         return new ColorRGB(r * other.r, g * other.g, b * other.b);
     }
 
+    /*
+     * Vec3
+     */
+
+    @Override
+    public @NotNull Vec3 toVec3() {
+        return new Vec3(r, g, b);
+    }
+
+    public static @NotNull ColorRGB fromVec3(@NotNull Vec3 vec) {
+        return new ColorRGB(vec.x(), vec.y(), vec.z());
+    }
+
     /*
      * Accessors
      */

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/ColorSpace.java

@@ -1,8 +1,9 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
 import eu.jonahbauer.raytracing.math.Matrix3;
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.*;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.DenselySampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Objects;
@@ -25,18 +26,16 @@ public final class ColorSpace {
     private final @NotNull Matrix3 XYZfromRGB;
     private final @NotNull Matrix3 RGBfromXYZ;
     private final @NotNull SpectrumTable RGBtoSpectrumTable;
-    private final @NotNull TransferFunction transferFunction;
 
     public ColorSpace(
             @NotNull Chromaticity r, @NotNull Chromaticity g, @NotNull Chromaticity b,
-            @NotNull Spectrum illuminant, @NotNull SpectrumTable table, @NotNull TransferFunction transferFunction
+            @NotNull Spectrum illuminant, @NotNull SpectrumTable table
     ) {
         this.r = Objects.requireNonNull(r, "r");
         this.g = Objects.requireNonNull(g, "g");
         this.b = Objects.requireNonNull(b, "b");
         this.illuminant = new DenselySampledSpectrum(illuminant);
-        this.RGBtoSpectrumTable = table; // no null-check
+        this.RGBtoSpectrumTable = table;
-        this.transferFunction = transferFunction; // no null-check
 
         this.W = illuminant.toXYZ();
         this.w = W.xy();
@@ -55,10 +54,6 @@ public final class ColorSpace {
         this.RGBfromXYZ = XYZfromRGB.invert();
     }
 
-    /*
-     * Conversions
-     */
-
     public @NotNull ColorRGB toRGB(@NotNull ColorXYZ xyz) {
         var out = RGBfromXYZ.times(xyz.toVec3());
         return new ColorRGB(out.x(), out.y(), out.z());
@@ -66,7 +61,7 @@ public final class ColorSpace {
 
     public @NotNull ColorXYZ toXYZ(@NotNull ColorRGB rgb) {
         var out = XYZfromRGB.times(rgb.toVec3());
-        return new ColorXYZ(out);
+        return ColorXYZ.fromVec3(out);
     }
 
     public @NotNull Vec3 toCIELab(@NotNull ColorRGB rgb) {
@@ -90,19 +85,7 @@ public final class ColorSpace {
         }
     }
 
-    public @NotNull ColorRGB encode(@NotNull ColorRGB rgb) {
+    public @NotNull SigmoidPolynomial toSpectrum(@NotNull ColorRGB rgb) {
-        return transferFunction.encode(rgb);
-    }
-
-    public @NotNull ColorRGB decode(@NotNull ColorRGB rgb) {
-        return transferFunction.decode(rgb);
-    }
-
-    /*
-     * Spectrum
-     */
-
-    public @NotNull SigmoidPolynomial toPolynomial(@NotNull ColorRGB rgb) {
         return RGBtoSpectrumTable.get(new ColorRGB(
                 Math.max(0, rgb.r()),
                 Math.max(0, rgb.g()),
@@ -110,38 +93,6 @@ public final class ColorSpace {
         ));
     }
 
-    public @NotNull Spectrum toSpectrum(@NotNull ColorRGB rgb, @NotNull Spectrum.Type type) {
-        return switch (type) {
-            case ALBEDO -> new RGBAlbedoSpectrum(this, rgb);
-            case ILLUMINANT -> new RGBIlluminantSpectrum(this, rgb);
-            case UNBOUNDED -> new RGBUnboundedSpectrum(this, rgb);
-        };
-    }
-
-    public @NotNull Spectrum albedo(double r, double g, double b) {
-        return albedo(new ColorRGB(r, g, b));
-    }
-
-    public @NotNull Spectrum albedo(@NotNull ColorRGB rgb) {
-        return toSpectrum(rgb, Spectrum.Type.ALBEDO);
-    }
-
-    public @NotNull Spectrum illuminant(double intensity) {
-        return illuminant.scale(intensity);
-    }
-
-    public @NotNull Spectrum illuminant(double r, double g, double b) {
-        return illuminant(new ColorRGB(r, g, b));
-    }
-
-    public @NotNull Spectrum illuminant(@NotNull ColorRGB rgb) {
-        return toSpectrum(rgb, Spectrum.Type.ILLUMINANT);
-    }
-
-    /*
-     * Accessors
-     */
-
     public @NotNull Chromaticity r() {
         return r;
     }

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/ColorSpaces.java

@@ -1,6 +1,6 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
-import eu.jonahbauer.raytracing.render.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.IOException;
@@ -13,21 +13,21 @@ public final class ColorSpaces {
             new Chromaticity(0.6400, 0.3300),
             new Chromaticity(0.3000, 0.6000),
             new Chromaticity(0.1500, 0.0600),
-            Spectra.D65, read("sRGB_spectrum.bin"), TransferFunctions.sRGB
+            Spectra.D65, read("sRGB_spectrum.bin")
     );
     // P3-D65 (display)
     public static final @NotNull ColorSpace DCI_P3 = new ColorSpace(
             new Chromaticity(0.680, 0.320),
             new Chromaticity(0.265, 0.690),
             new Chromaticity(0.150, 0.060),
-            Spectra.D65, read("DCI_P3_spectrum.bin"), TransferFunctions.sRGB
+            Spectra.D65, read("DCI_P3_spectrum.bin")
     );
     // ITU-R Rec BT.2020
     public static final @NotNull ColorSpace Rec2020 = new ColorSpace(
             new Chromaticity(0.708, 0.292),
             new Chromaticity(0.170, 0.797),
             new Chromaticity(0.131, 0.046),
-            Spectra.D65, read("Rec2020_spectrum.bin"), null
+            Spectra.D65, read("Rec2020_spectrum.bin")
     );
 
     private static @NotNull SpectrumTable read(@NotNull String name) {

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/ColorXYZ.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
 import eu.jonahbauer.raytracing.math.IVec3;
 import eu.jonahbauer.raytracing.math.Vec3;
@@ -25,16 +25,6 @@ public record ColorXYZ(double x, double y, double z) implements IVec3<ColorXYZ>
         );
     }
 
-    public ColorXYZ(@NotNull Vec3 vec) {
-        this(vec.x(), vec.y(), vec.z());
-    }
-
-    public ColorXYZ {
-        assert Double.isFinite(x) : "x must be finite";
-        assert Double.isFinite(y) : "y must be finite";
-        assert Double.isFinite(z) : "z must be finite";
-    }
-
     /*
      * Math
      */
@@ -81,6 +71,19 @@ public record ColorXYZ(double x, double y, double z) implements IVec3<ColorXYZ>
         return new ColorXYZ(x * d, y * d, z * d);
     }
 
+    /*
+     * Vec3
+     */
+
+    @Override
+    public @NotNull Vec3 toVec3() {
+        return new Vec3(x, y, z);
+    }
+
+    public static @NotNull ColorXYZ fromVec3(@NotNull Vec3 vec) {
+        return new ColorXYZ(vec.x(), vec.y(), vec.z());
+    }
+
     /*
      * Accessors
      */

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/SigmoidPolynomial.java

@@ -1,6 +1,6 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 
 /**
  * A function of the form {@code s(p(x))} where {@code p} is a polynomial of second degree and {@code s} is the sigmoid

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/SpectrumTable.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
 import org.jetbrains.annotations.NotNull;
 

src/main/java/eu/jonahbauer/raytracing/render/spectral/colors/SpectrumTableGenerator.java

@@ -1,8 +1,8 @@
-package eu.jonahbauer.raytracing.render.color;
+package eu.jonahbauer.raytracing.render.spectral.colors;
 
 import eu.jonahbauer.raytracing.math.Matrix3;
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.IOException;

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/BlackbodySpectrum.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
 public final class BlackbodySpectrum implements Spectrum {
     /**

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/ConstantSpectrum.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
 /**
  * A constant spectrum.

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/DenselySampledSpectrum.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
 import org.jetbrains.annotations.NotNull;
 

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/PiecewiseLinearSpectrum.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
 import java.util.Arrays;
 

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/RGBAlbedoSpectrum.java

@@ -1,8 +1,8 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.SigmoidPolynomial;
+import eu.jonahbauer.raytracing.render.spectral.colors.SigmoidPolynomial;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import org.jetbrains.annotations.NotNull;
 
 public final class RGBAlbedoSpectrum implements Spectrum {
@@ -12,7 +12,7 @@ public final class RGBAlbedoSpectrum implements Spectrum {
         if (rgb.r() < 0 || rgb.r() > 1 || rgb.g() < 0 || rgb.g() > 1 || rgb.b() < 0 || rgb.b() > 1) {
             throw new IllegalArgumentException();
         }
-        this.polynomial = cs.toPolynomial(rgb);
+        this.polynomial = cs.toSpectrum(rgb);
     }
 
     @Override

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/RGBIlluminantSpectrum.java

@@ -1,8 +1,8 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.SigmoidPolynomial;
+import eu.jonahbauer.raytracing.render.spectral.colors.SigmoidPolynomial;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -20,7 +20,7 @@ public final class RGBIlluminantSpectrum implements Spectrum {
         }
         var max = Math.max(rgb.r(), Math.max(rgb.g(), rgb.b()));
         this.scale = 2 * max;
-        this.polynomial = cs.toPolynomial(scale != 0 ? rgb.div(scale) : ColorRGB.BLACK);
+        this.polynomial = cs.toSpectrum(scale != 0 ? rgb.div(scale) : ColorRGB.BLACK);
         this.illuminant = cs.illuminant();
     }
 

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/RGBUnboundedSpectrum.java

@@ -1,8 +1,8 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.SigmoidPolynomial;
+import eu.jonahbauer.raytracing.render.spectral.colors.SigmoidPolynomial;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import org.jetbrains.annotations.NotNull;
 
 public final class RGBUnboundedSpectrum implements Spectrum {
@@ -15,7 +15,7 @@ public final class RGBUnboundedSpectrum implements Spectrum {
         }
         var max = Math.max(rgb.r(), Math.max(rgb.g(), rgb.b()));
         this.scale = 2 * max;
-        this.polynomial = cs.toPolynomial(scale != 0 ? rgb.div(scale) : ColorRGB.BLACK);
+        this.polynomial = cs.toSpectrum(scale == 0 ? rgb.div(scale) : ColorRGB.BLACK);
     }
 
     @Override

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/ScaledSpectrum.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
 import org.jetbrains.annotations.NotNull;
 

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/Spectra.java

@@ -1,6 +1,6 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
-import eu.jonahbauer.raytracing.render.color.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.BufferedReader;

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/Spectrum.java

@@ -1,10 +1,12 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
-import eu.jonahbauer.raytracing.render.color.ColorXYZ;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorXYZ;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledWavelengths;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import eu.jonahbauer.raytracing.render.texture.Texture;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import eu.jonahbauer.raytracing.scene.SkyBox;
@@ -72,8 +74,4 @@ public interface Spectrum extends Texture, SkyBox {
     default @NotNull SampledSpectrum getColor(@NotNull Ray ray) {
         return this.sample(ray.lambda());
     }
-
-    enum Type {
-        ALBEDO, ILLUMINANT, UNBOUNDED
-    }
 }

src/main/java/eu/jonahbauer/raytracing/render/spectral/spectrum/Util.java

@@ -1,4 +1,4 @@
-package eu.jonahbauer.raytracing.render.spectrum;
+package eu.jonahbauer.raytracing.render.spectral.spectrum;
 
 import org.jetbrains.annotations.NotNull;
 

src/main/java/eu/jonahbauer/raytracing/render/texture/CheckerTexture.java

@@ -1,7 +1,7 @@
 package eu.jonahbauer.raytracing.render.texture;
 
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import org.jetbrains.annotations.NotNull;
 
 public record CheckerTexture(double scale, @NotNull Texture even, @NotNull Texture odd) implements Texture {

src/main/java/eu/jonahbauer/raytracing/render/texture/ImageTexture.java

@@ -1,9 +1,11 @@
 package eu.jonahbauer.raytracing.render.texture;
 
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
-import eu.jonahbauer.raytracing.render.color.ColorSpace;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorSpace;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBAlbedoSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.RGBIlluminantSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import org.jetbrains.annotations.NotNull;
 
 import javax.imageio.ImageIO;
@@ -19,21 +21,22 @@ public final class ImageTexture implements Texture {
     private final int height;
     private final @NotNull Spectrum[][] spectra;
 
-    public ImageTexture(@NotNull BufferedImage image, @NotNull ColorSpace cs, @NotNull Spectrum.Type type) {
+    public ImageTexture(@NotNull BufferedImage image, @NotNull ColorSpace cs, @NotNull Type type, boolean gamma) {
         this.width = image.getWidth();
         this.height = image.getHeight();
         this.spectra = new Spectrum[height][width];
 
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
-                var rgb = cs.decode(new ColorRGB(image.getRGB(x, y)));
+                var rgb = new ColorRGB(image.getRGB(x, y));
-                spectra[y][x] = cs.toSpectrum(rgb, type);
+                if (gamma) rgb = ColorRGB.inverseGamma(rgb);
+                spectra[y][x] = type.newSpectrum(cs, rgb);
             }
         }
     }
 
     public ImageTexture(@NotNull String path, @NotNull ColorSpace cs) {
-        this(read(path), cs, Spectrum.Type.ALBEDO);
+        this(read(path), cs, Type.ALBEDO, true);
     }
 
     private static @NotNull BufferedImage read(@NotNull String path) {
@@ -52,4 +55,22 @@ public final class ImageTexture implements Texture {
         int y = (int) (v * (height - 1));
         return spectra[y][x];
     }
+
+    public enum Type {
+        ALBEDO {
+            @Override
+            protected @NotNull Spectrum newSpectrum(@NotNull ColorSpace cs, @NotNull ColorRGB rgb) {
+                return new RGBAlbedoSpectrum(cs, rgb);
+            }
+        },
+        ILLUMINANT {
+            @Override
+            protected @NotNull Spectrum newSpectrum(@NotNull ColorSpace cs, @NotNull ColorRGB rgb) {
+                return new RGBIlluminantSpectrum(cs, rgb);
+            }
+        },
+        ;
+
+        protected abstract @NotNull Spectrum newSpectrum(@NotNull ColorSpace cs, @NotNull ColorRGB rgb);
+    }
 }

src/main/java/eu/jonahbauer/raytracing/render/texture/PerlinTexture.java

@@ -1,8 +1,8 @@
 package eu.jonahbauer.raytracing.render.texture;
 
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Objects;

src/main/java/eu/jonahbauer/raytracing/render/texture/Texture.java

@@ -1,7 +1,7 @@
 package eu.jonahbauer.raytracing.render.texture;
 
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import eu.jonahbauer.raytracing.scene.HitResult;
 import org.jetbrains.annotations.NotNull;
 

src/main/java/eu/jonahbauer/raytracing/scene/Scene.java

@@ -2,8 +2,8 @@ package eu.jonahbauer.raytracing.scene;
 
 import eu.jonahbauer.raytracing.math.AABB;
 import eu.jonahbauer.raytracing.math.Ray;
-import eu.jonahbauer.raytracing.render.spectrum.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
-import eu.jonahbauer.raytracing.render.spectrum.Spectra;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectra;
 import eu.jonahbauer.raytracing.scene.util.HittableBinaryTree;
 import eu.jonahbauer.raytracing.scene.util.HittableCollection;
 import org.jetbrains.annotations.NotNull;

src/main/java/eu/jonahbauer/raytracing/scene/SkyBox.java

@@ -1,8 +1,8 @@
 package eu.jonahbauer.raytracing.scene;
 
 import eu.jonahbauer.raytracing.math.Ray;
-import eu.jonahbauer.raytracing.render.spectrum.SampledSpectrum;
+import eu.jonahbauer.raytracing.render.spectral.SampledSpectrum;
-import eu.jonahbauer.raytracing.render.spectrum.Spectrum;
+import eu.jonahbauer.raytracing.render.spectral.spectrum.Spectrum;
 import org.jetbrains.annotations.NotNull;
 
 @FunctionalInterface

src/test/java/eu/jonahbauer/raytracing/render/canvas/RGBCanvasTest.java

@@ -1,6 +1,6 @@
 package eu.jonahbauer.raytracing.render.canvas;
 
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import eu.jonahbauer.raytracing.render.ImageFormat;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;

src/test/java/eu/jonahbauer/raytracing/scene/hittable3d/SphereTest.java

@@ -3,7 +3,7 @@ package eu.jonahbauer.raytracing.scene.hittable3d;
 import eu.jonahbauer.raytracing.math.Range;
 import eu.jonahbauer.raytracing.math.Ray;
 import eu.jonahbauer.raytracing.math.Vec3;
-import eu.jonahbauer.raytracing.render.color.ColorRGB;
+import eu.jonahbauer.raytracing.render.spectral.colors.ColorRGB;
 import eu.jonahbauer.raytracing.render.material.LambertianMaterial;
 import org.junit.jupiter.api.Test;