Retune the watchface to the Dark Side of the Moon album cover

Rework the palette and colour handling to match the original album art.

- Drop the rainbow's cyan band, taking the spectrum from 7 to 6 to match
  the album's six-band prism. Retune the palette to the six colours
  sampled directly from the cover and rename oklch_balanced ->
  dark_side_of_the_moon, now stored as linear-light colours.

- Remove Oklab entirely. The colours round-tripped sRGB -> linear ->
  Oklab -> linear but were always blended in linear space, so Oklab was
  a no-op. Delete lib/Oklab.zig, Linear.toOklab and its tests, and the
  root.zig re-export; Rainbow and Spectrum now use linear colours.

- Shrink the default prism size 0.866 -> 0.618034 (golden ratio) and
  change the default texture from grain to none.

- Introduce Srgb.background / Linear.background = the near-black (9,13,12)
  tone sampled from the cover, and fill the disc background with it
  instead of pure black. Linear.toSrgb fast-paths this tone and Grain
  leaves it (and pure black) untouched so the flat background stays clean.

- Drop --grain from the README logo command and regenerate logo.png.

Author: clebert

README.md

@@ -47,7 +47,7 @@ The texture flags are mutually exclusive; without any, no texture is applied.
 
 ```bash
 zig build png -Doptimize=ReleaseFast && \
-zig-out/bin/png 1024 7 14 logo.png --grain
+zig-out/bin/png 1024 7 14 logo.png
 ```
 
 ```bash

lib/Grain.zig

@@ -22,8 +22,12 @@ pub fn apply(self: Self, band: Image.Band(Srgb)) void {
         const row = band.buffer[local_y * band.width ..][0..band.width];
 
         for (row, 0..) |*srgb, x| {
-            // Skip pure black so the dark background stays clean.
-            if (srgb.r == 0 and srgb.g == 0 and srgb.b == 0) continue;
+            // Leave the flat background untouched so it stays clean.
+            const is_black = srgb.r == 0 and srgb.g == 0 and srgb.b == 0;
+            const is_background = srgb.r == Srgb.background.r and
+                srgb.g == Srgb.background.g and srgb.b == Srgb.background.b;
+
+            if (is_black or is_background) continue;
 
             const offset = noiseAt(x, image_y) * strength;
 
@@ -100,6 +104,20 @@ test "apply skips black pixels" {
     try std.testing.expectEqualSlices(Srgb, &original, &buffer);
 }
 
+test "apply skips background pixels" {
+    const pixel_count = 64 * 64;
+
+    var buffer = [_]Srgb{Srgb.background} ** pixel_count;
+
+    const original = buffer;
+    const band = try (Image.init(64, 64)).band(Srgb, &buffer, 64, 0);
+    const grain = Self{ .normalized_deviation = 0.1 };
+
+    grain.apply(band);
+
+    try std.testing.expectEqualSlices(Srgb, &original, &buffer);
+}
+
 test "multi-band grain matches single-band grain" {
     const width = 16;
     const height = 48;

lib/Linear.zig

@@ -1,6 +1,5 @@
 const std = @import("std");
 
-const Oklab = @import("Oklab.zig");
 const Srgb = @import("Srgb.zig");
 
 const Self = @This();
@@ -9,6 +8,13 @@ pub const black: Self = .{ .vec = .{ 0, 0, 0, 1 } };
 pub const white: Self = .{ .vec = .{ 1, 1, 1, 1 } };
 pub const transparent: Self = .{ .vec = .{ 0, 0, 0, 0 } };
 
+/// Near-black background tone sampled from the original album cover.
+pub const background: Self = blk: {
+    @setEvalBranchQuota(2000);
+
+    break :blk Srgb.background.toLinear();
+};
+
 vec: @Vector(4, f32),
 
 pub fn init(r: f32, g: f32, b: f32, a: f32) Self {
@@ -23,32 +29,9 @@ pub fn lerp(a: Self, b: Self, t: f32) Self {
     return .{ .vec = a.vec + (b.vec - a.vec) * t_vec };
 }
 
-pub fn toOklab(self: Self) Oklab {
-    const r = self.vec[0];
-    const g = self.vec[1];
-    const b = self.vec[2];
-
-    // Linear RGB → LMS
-    const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
-    const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
-    const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
-
-    // LMS → LMS cube roots
-    const lp = cubeRoot(l);
-    const mp = cubeRoot(m);
-    const sp = cubeRoot(s);
-
-    // LMS cube roots → Oklab
-    return .{ .vec = .{
-        0.2104542553 * lp + 0.7936177850 * mp - 0.0040720468 * sp,
-        1.9779984951 * lp - 2.4285922050 * mp + 0.4505937099 * sp,
-        0.0259040371 * lp + 0.7827717662 * mp - 0.8086757660 * sp,
-        self.vec[3],
-    } };
-}
-
 pub fn toSrgb(self: Self) Srgb {
-    // Exact fast path for the common black/transparent background pixels.
+    // Exact fast paths for the flat background pixels that dominate the frame.
+    if (@reduce(.And, self.vec == background.vec)) return .background;
     if (@reduce(.And, self.vec == black.vec)) return .black;
     if (@reduce(.And, self.vec == transparent.vec)) return .transparent;
 
@@ -152,6 +135,15 @@ test "toSrgb converts black correctly" {
     try std.testing.expectEqual(@as(u8, 255), srgb.a);
 }
 
+test "toSrgb fast-paths the background tone" {
+    const srgb = background.toSrgb();
+
+    try std.testing.expectEqual(Srgb.background.r, srgb.r);
+    try std.testing.expectEqual(Srgb.background.g, srgb.g);
+    try std.testing.expectEqual(Srgb.background.b, srgb.b);
+    try std.testing.expectEqual(@as(u8, 255), srgb.a);
+}
+
 test "toSrgb converts white correctly" {
     const srgb = white.toSrgb();
 
@@ -216,21 +208,3 @@ test "cubeRoot computes cube root correctly" {
     try std.testing.expectApproxEqAbs(@as(f32, 0.5), cubeRoot(0.125), 1e-5);
     try std.testing.expectEqual(@as(f32, 0.0), cubeRoot(0.0));
 }
-
-test "toOklab produces expected L for white" {
-    const oklab = white.toOklab();
-
-    try std.testing.expectApproxEqAbs(@as(f32, 1.0), oklab.vec[0], 1e-4);
-    try std.testing.expectApproxEqAbs(@as(f32, 0.0), oklab.vec[1], 1e-4);
-    try std.testing.expectApproxEqAbs(@as(f32, 0.0), oklab.vec[2], 1e-4);
-}
-
-test "round-trip Linear → Oklab → Linear preserves values" {
-    const original = Self.init(0.4, 0.6, 0.2, 1.0);
-    const back = original.toOklab().toLinear();
-
-    try std.testing.expectApproxEqAbs(original.vec[0], back.vec[0], 1e-5);
-    try std.testing.expectApproxEqAbs(original.vec[1], back.vec[1], 1e-5);
-    try std.testing.expectApproxEqAbs(original.vec[2], back.vec[2], 1e-5);
-    try std.testing.expectApproxEqAbs(original.vec[3], back.vec[3], 1e-5);
-}

lib/Oklab.zig

@@ -1,7 +1,6 @@
 const std = @import("std");
 
 const Linear = @import("Linear.zig");
-const Oklab = @import("Oklab.zig");
 const Srgb = @import("Srgb.zig");
 
 const Self = @This();
@@ -11,89 +10,57 @@ pub const ColorId = enum {
     orange,
     yellow,
     green,
-    cyan,
     blue,
     violet,
 };
 
 pub const color_count: usize = @typeInfo(ColorId).@"enum".fields.len;
 
-oklab_colors: [color_count]Oklab,
+colors: [color_count]Linear,
 
 fn init(srgb_colors: [color_count]Srgb) Self {
     @setEvalBranchQuota(10000);
 
-    var oklab_colors: [color_count]Oklab = undefined;
+    var colors: [color_count]Linear = undefined;
 
-    for (srgb_colors, 0..) |srgb, i| {
-        oklab_colors[i] = srgb.toLinear().toOklab();
+    for (srgb_colors, &colors) |srgb, *color| {
+        color.* = srgb.toLinear();
     }
 
-    return .{ .oklab_colors = oklab_colors };
+    return .{ .colors = colors };
 }
 
-pub const oklch_balanced: Self = init(.{
-    .{ .r = 255, .g = 64, .b = 64 },
-    .{ .r = 255, .g = 160, .b = 0 },
-    .{ .r = 220, .g = 220, .b = 0 },
-    .{ .r = 0, .g = 200, .b = 80 },
-    .{ .r = 0, .g = 180, .b = 220 },
-    .{ .r = 80, .g = 100, .b = 255 },
-    .{ .r = 180, .g = 80, .b = 255 },
+/// The six band colours sampled from the original album cover, in spectral order.
+pub const dark_side_of_the_moon: Self = init(.{
+    .{ .r = 210, .g = 36, .b = 46 },
+    .{ .r = 224, .g = 122, .b = 38 },
+    .{ .r = 249, .g = 221, .b = 0 },
+    .{ .r = 87, .g = 162, .b = 67 },
+    .{ .r = 0, .g = 154, .b = 204 },
+    .{ .r = 110, .g = 95, .b = 150 },
 });
 
 pub fn reversed(self: Self) Self {
-    var oklab_colors = self.oklab_colors;
+    var colors = self.colors;
 
-    std.mem.reverse(Oklab, &oklab_colors);
+    std.mem.reverse(Linear, &colors);
 
-    return .{ .oklab_colors = oklab_colors };
+    return .{ .colors = colors };
 }
 
-/// The solid band colours in palette order, converted to linear light. Each equal
-/// 1/N slice of [0, 1] is filled with one of these, blending between neighbours only
-/// across the one-pixel seam at each band boundary.
-pub fn bandColors(self: Self) [color_count]Linear {
-    var colors: [color_count]Linear = undefined;
-
-    for (self.oklab_colors, &colors) |oklab, *color| {
-        color.* = oklab.toLinear();
-    }
+test "init converts sRGB band colours to linear light" {
+    const expected = (Srgb{ .r = 210, .g = 36, .b = 46 }).toLinear();
 
-    return colors;
+    try std.testing.expectEqual(expected.vec, dark_side_of_the_moon.colors[0].vec);
 }
 
-test "init converts sRGB through to Oklab" {
-    // The first palette colour must round-trip its source sRGB through Oklab back to
-    // linear light.
-    const expected = (Srgb{ .r = 255, .g = 64, .b = 64 }).toLinear();
-    const actual = oklch_balanced.oklab_colors[0].toLinear();
-
-    inline for (0..4) |i| {
-        try std.testing.expectApproxEqAbs(expected.vec[i], actual.vec[i], 1e-4);
-    }
-}
+test "reversed mirrors the palette order" {
+    const mirrored = dark_side_of_the_moon.reversed();
 
-test "init sets alpha to 1" {
-    for (oklch_balanced.oklab_colors) |c| {
-        try std.testing.expectApproxEqAbs(@as(f32, 1.0), c.vec[3], 1e-6);
+    for (0..color_count) |i| {
+        try std.testing.expectEqual(
+            dark_side_of_the_moon.colors[i].vec,
+            mirrored.colors[color_count - 1 - i].vec,
+        );
     }
 }
-
-test "reversed swaps first and last colors" {
-    const rainbow = oklch_balanced;
-    const reversed_rainbow = rainbow.reversed();
-
-    try std.testing.expectEqual(rainbow.oklab_colors[0].vec, reversed_rainbow.oklab_colors[6].vec);
-    try std.testing.expectEqual(rainbow.oklab_colors[6].vec, reversed_rainbow.oklab_colors[0].vec);
-    try std.testing.expectEqual(rainbow.oklab_colors[3].vec, reversed_rainbow.oklab_colors[3].vec);
-}
-
-test "bandColors returns each palette colour in linear light" {
-    const colors = oklch_balanced.bandColors();
-
-    try std.testing.expectEqual(color_count, colors.len);
-    try std.testing.expectEqual(oklch_balanced.oklab_colors[0].toLinear().vec, colors[0].vec);
-    try std.testing.expectEqual(oklch_balanced.oklab_colors[3].toLinear().vec, colors[3].vec);
-    try std.testing.expectEqual(oklch_balanced.oklab_colors[6].toLinear().vec, colors[6].vec);
-}

lib/Rainbow.zig

@@ -69,9 +69,7 @@ pub fn render(
 
     if (dot_exact > 0.9999 or dot_exact < -0.9999) return;
 
-    // Solid band colours in palette order, converted once per frame; the per-pixel
-    // path only indexes and blends this small array.
-    const band_colors = rainbow.bandColors();
+    const band_colors = rainbow.colors;
 
     const band_height = band.bandHeight();
     const y_offset: f32 = @floatFromInt(band.y_offset);
@@ -263,7 +261,7 @@ fn antialiasedBand(
 }
 
 test "render produces spectrum with rotated viewport" {
-    const rainbow = Rainbow.oklch_balanced;
+    const rainbow = Rainbow.dark_side_of_the_moon;
     const image = Image.init(48, 64);
     const viewport = image.viewportRotated(.clockwise_90);
     const pixel_count = 48 * 64;
@@ -288,7 +286,7 @@ test "render produces spectrum with rotated viewport" {
 }
 
 test "attenuation reduces brightness near origin" {
-    const rainbow = Rainbow.oklch_balanced;
+    const rainbow = Rainbow.dark_side_of_the_moon;
     const size = 200;
     const image = Image.init(size, size);
     const viewport = image.viewport();
@@ -399,8 +397,8 @@ fn spectrumPositionAt(spectrum: Self, point: @Vector(2, f32)) struct {
 }
 
 test "antialiasedBand blends across a seam but stays solid within a band" {
-    const rainbow = Rainbow.oklch_balanced;
-    const band_colors = rainbow.bandColors();
+    const rainbow = Rainbow.dark_side_of_the_moon;
+    const band_colors = rainbow.colors;
     const scale: f32 = 100.0;
     const count: f32 = @floatFromInt(Rainbow.color_count);
 

lib/Spectrum.zig

@@ -8,6 +8,9 @@ pub const black: Self = .{ .r = 0, .g = 0, .b = 0 };
 pub const white: Self = .{ .r = 255, .g = 255, .b = 255 };
 pub const transparent: Self = .{ .r = 0, .g = 0, .b = 0, .a = 0 };
 
+/// Near-black background tone sampled from the original album cover.
+pub const background: Self = .{ .r = 9, .g = 13, .b = 12 };
+
 r: u8,
 g: u8,
 b: u8,

lib/Srgb.zig

@@ -22,7 +22,7 @@ const prism_tint = Linear.init(0.03, 0.34, 0.52, 1.0);
 
 pub fn render(self: Self, band: Image.Band(Linear), viewport: anytype, clock: Clock) void {
     const right_side = clock.hour_hand.get(.green).end[0] > 0;
-    const rainbow = if (right_side) Rainbow.oklch_balanced.reversed() else Rainbow.oklch_balanced;
+    const rainbow = if (right_side) Rainbow.dark_side_of_the_moon.reversed() else Rainbow.dark_side_of_the_moon;
 
     const hand_glow = Glow{
         .normalized_width = self.hand_glow_normalized_width,

lib/Watchface.zig

@@ -1,9 +1,9 @@
 {
   "background_enabled": true,
-  "prism_normalized_size": 0.866,
+  "prism_normalized_size": 0.618034,
   "prism_glow_normalized_width": 0.07,
   "rainbow_normalized_spread": 0.5,
   "hand_glow_normalized_width": 0.005,
-  "texture": "grain",
+  "texture": "none",
   "grain_normalized_deviation": 0.07
 }

lib/config.json

@@ -60,7 +60,7 @@ pub fn renderBand(
 
     @memset(
         linear_buffer,
-        if (config.background_enabled) Linear.black else Linear.transparent,
+        if (config.background_enabled) Linear.background else Linear.transparent,
     );
 
     const watchface = Watchface{