|
| 1 | +"""Generate Pretzel's assets: a trefoil-knot mesh and background wallpapers. |
| 2 | +
|
| 3 | +The generated files are already checked into version control, so you only |
| 4 | +need to run this script if you want to tweak the assets: |
| 5 | +
|
| 6 | +$ uv run make_assets.py |
| 7 | +""" |
| 8 | + |
| 9 | +import math |
| 10 | +import pathlib |
| 11 | +from typing import Final |
| 12 | + |
| 13 | +type Vector = tuple[float, float, float] |
| 14 | +type Face = tuple[int, int, int] |
| 15 | +type Color = tuple[int, int, int] |
| 16 | + |
| 17 | +ASSETS_DIR = pathlib.Path(__file__).parent / "src" / "pretzel" / "assets" |
| 18 | + |
| 19 | +SEGMENTS: Final = 240 |
| 20 | +RING_POINTS: Final = 16 |
| 21 | +TUBE_RADIUS: Final = 0.62 |
| 22 | + |
| 23 | +WALLPAPER_SIZE: Final = 512 |
| 24 | +WALLPAPERS: Final = { |
| 25 | + "bakery_dawn.ppm": ((252, 210, 153), (146, 90, 118), (255, 236, 179)), |
| 26 | + "bakery_noon.ppm": ((214, 235, 251), (245, 232, 201), (255, 255, 224)), |
| 27 | + "bakery_dusk.ppm": ((94, 63, 107), (233, 156, 90), (255, 214, 138)), |
| 28 | +} |
| 29 | + |
| 30 | + |
| 31 | +def main() -> None: |
| 32 | + ASSETS_DIR.mkdir(parents=True, exist_ok=True) |
| 33 | + write_mesh(ASSETS_DIR / "pretzel.mdl") |
| 34 | + for name, (top, bottom, glow) in WALLPAPERS.items(): |
| 35 | + write_wallpaper(ASSETS_DIR / name, top, bottom, glow) |
| 36 | + |
| 37 | + |
| 38 | +def write_mesh(path: pathlib.Path) -> None: |
| 39 | + vertices, faces = sweep_tube() |
| 40 | + with path.open("w", encoding="utf-8") as file: |
| 41 | + file.write(f"# Trefoil-knot pretzel: {len(vertices)} vertices,") |
| 42 | + file.write(f" {len(faces)} faces\n") |
| 43 | + for x, y, z in vertices: |
| 44 | + file.write(f"v {x:.6f} {y:.6f} {z:.6f}\n") |
| 45 | + for a, b, c in faces: |
| 46 | + file.write(f"f {a + 1} {b + 1} {c + 1}\n") |
| 47 | + print(f"Wrote {path} ({len(vertices)} vertices, {len(faces)} faces)") |
| 48 | + |
| 49 | + |
| 50 | +def write_wallpaper( |
| 51 | + path: pathlib.Path, top: Color, bottom: Color, glow: Color |
| 52 | +) -> None: |
| 53 | + size = WALLPAPER_SIZE |
| 54 | + lights = [ |
| 55 | + (size * 0.25, size * 0.3, size * 0.22), |
| 56 | + (size * 0.7, size * 0.55, size * 0.3), |
| 57 | + (size * 0.45, size * 0.8, size * 0.18), |
| 58 | + ] |
| 59 | + rows = bytearray() |
| 60 | + for y in range(size): |
| 61 | + vertical = y / (size - 1) |
| 62 | + base = blend(top, bottom, vertical) |
| 63 | + for x in range(size): |
| 64 | + halo = 0.0 |
| 65 | + for cx, cy, radius in lights: |
| 66 | + distance = math.hypot(x - cx, y - cy) |
| 67 | + halo += max(0.0, 1.0 - distance / radius) ** 2 |
| 68 | + color = blend(base, glow, min(1.0, halo)) |
| 69 | + rows.extend(color) |
| 70 | + with path.open("wb") as file: |
| 71 | + file.write(b"P6\n%d %d\n255\n" % (size, size)) |
| 72 | + file.write(rows) |
| 73 | + print(f"Wrote {path} ({size}x{size})") |
| 74 | + |
| 75 | + |
| 76 | +def sweep_tube() -> tuple[list[Vector], list[Face]]: |
| 77 | + step = 2.0 * math.pi / SEGMENTS |
| 78 | + centers = [trace_trefoil(index * step) for index in range(SEGMENTS)] |
| 79 | + tangents = [ |
| 80 | + normalize(subtract(centers[(i + 1) % SEGMENTS], centers[i - 1])) |
| 81 | + for i in range(SEGMENTS) |
| 82 | + ] |
| 83 | + normal = normalize(cross(tangents[0], (0.0, 0.0, 1.0))) |
| 84 | + vertices = [] |
| 85 | + for center, tangent in zip(centers, tangents): |
| 86 | + projection = dot(normal, tangent) |
| 87 | + normal = normalize( |
| 88 | + ( |
| 89 | + normal[0] - projection * tangent[0], |
| 90 | + normal[1] - projection * tangent[1], |
| 91 | + normal[2] - projection * tangent[2], |
| 92 | + ) |
| 93 | + ) |
| 94 | + binormal = cross(tangent, normal) |
| 95 | + for point in range(RING_POINTS): |
| 96 | + angle = 2.0 * math.pi * point / RING_POINTS |
| 97 | + radial = math.cos(angle), math.sin(angle) |
| 98 | + vertices.append( |
| 99 | + tuple( |
| 100 | + center[axis] |
| 101 | + + TUBE_RADIUS |
| 102 | + * (radial[0] * normal[axis] + radial[1] * binormal[axis]) |
| 103 | + for axis in range(3) |
| 104 | + ) |
| 105 | + ) |
| 106 | + faces = [] |
| 107 | + for segment in range(SEGMENTS): |
| 108 | + next_segment = (segment + 1) % SEGMENTS |
| 109 | + for point in range(RING_POINTS): |
| 110 | + next_point = (point + 1) % RING_POINTS |
| 111 | + a = segment * RING_POINTS + point |
| 112 | + b = segment * RING_POINTS + next_point |
| 113 | + c = next_segment * RING_POINTS + point |
| 114 | + d = next_segment * RING_POINTS + next_point |
| 115 | + faces.append((a, c, b)) |
| 116 | + faces.append((b, c, d)) |
| 117 | + return vertices, faces |
| 118 | + |
| 119 | + |
| 120 | +def blend(low: Color, high: Color, amount: float) -> Color: |
| 121 | + return tuple( |
| 122 | + round(low[channel] + (high[channel] - low[channel]) * amount) |
| 123 | + for channel in range(3) |
| 124 | + ) |
| 125 | + |
| 126 | + |
| 127 | +def trace_trefoil(t: float) -> Vector: |
| 128 | + return ( |
| 129 | + math.sin(t) + 2.0 * math.sin(2.0 * t), |
| 130 | + math.cos(t) - 2.0 * math.cos(2.0 * t), |
| 131 | + -math.sin(3.0 * t) * 1.2, |
| 132 | + ) |
| 133 | + |
| 134 | + |
| 135 | +def subtract(a: Vector, b: Vector) -> Vector: |
| 136 | + return (a[0] - b[0], a[1] - b[1], a[2] - b[2]) |
| 137 | + |
| 138 | + |
| 139 | +def cross(a: Vector, b: Vector) -> Vector: |
| 140 | + return ( |
| 141 | + a[1] * b[2] - a[2] * b[1], |
| 142 | + a[2] * b[0] - a[0] * b[2], |
| 143 | + a[0] * b[1] - a[1] * b[0], |
| 144 | + ) |
| 145 | + |
| 146 | + |
| 147 | +def dot(a: Vector, b: Vector) -> float: |
| 148 | + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] |
| 149 | + |
| 150 | + |
| 151 | +def normalize(vector: Vector) -> Vector: |
| 152 | + length = math.sqrt(dot(vector, vector)) or 1.0 |
| 153 | + return (vector[0] / length, vector[1] / length, vector[2] / length) |
| 154 | + |
| 155 | + |
| 156 | +if __name__ == "__main__": |
| 157 | + main() |
0 commit comments