"""Phosphor scan, studio signature and stereo mix for the independent ident.""" from pathlib import Path import math import wave import numpy as np from PIL import Image, ImageDraw, ImageFont, ImageFilter ROOT = Path(__file__).resolve().parents[2] SOURCE = ROOT / "assets/cinematics/blender" # Two traces share a diagonal cut, as on a spliced tape. The centres of the # bends stay open even when the symbol is shown at game-menu scale. TRACES = [ [ (0, 0), (102, 0), (85, 17), (23, 17), (23, 40), (77, 40), (61, 56), (23, 56), (23, 80), (78, 80), (59, 99), (0, 99), ], [ (131, 0), (221, 0), (203, 18), (142, 18), (121, 39), (121, 72), (131, 80), (174, 80), (190, 63), (155, 63), (171, 46), (218, 46), (218, 66), (186, 99), (120, 99), (99, 82), (99, 32), ], ] def ease(a, b, t): u = np.clip((t - a) / (b - a), 0, 1) return u * u * (3 - 2 * u) def signature(): # Lay out in 1280x720 units. Supersample the contours before emitting # the native 1080p title so the long diagonal cuts remain antialiased. scale = 3 w, h = 1280 * scale, 720 * scale mask = Image.new("L", (w, h)) splice = Image.new("L", (w, h)) pen = ImageDraw.Draw(mask) def contour(points): return [(round((435 + x * 1.85) * scale), round((207 + y * 1.85) * scale)) for x, y in points] for points in TRACES: pen.polygon(contour(points), fill=255) # Exposed red leader between the two letterforms, the same splice as the tape. ImageDraw.Draw(splice).polygon(contour([(110, 0), (120, 0), (100, 20), (90, 20)]), fill=255) font = ImageFont.truetype("C:/Windows/Fonts/bahnschrift.ttf", 55 * scale) label = "EBLAN GAMES" tracking = 8 * scale widths = [font.getlength(c) for c in label] start = (w - sum(widths) - tracking * (len(label) - 1)) / 2 for c, width in zip(label, widths): pen.text((round(start), 443 * scale), c, font=font, fill=255, anchor="ls") start += width + tracking return tuple( np.asarray(layer.resize((1920, 1080), Image.Resampling.LANCZOS), dtype=np.float32) / 255 for layer in (mask, splice) ) def identity_frames(): mark, splice = signature() h, w = mark.shape yy, xx = np.mgrid[:h, :w] xx = xx.astype(np.float32) / 1.5 yy = yy.astype(np.float32) / 1.5 tube = SOURCE / "screen-v8" card = SOURCE / "signature-v8" tube.mkdir(exist_ok=True) card.mkdir(exist_ok=True) Image.new("RGB", (w, h)).save(card / "signature_0332.png") dark = Image.new("RGB", (768, 576), (1, 2, 2)) for f in range(1, 385): if f < 264: dark.save(tube / f"screen_{f:04}.png") continue # A cold cathode starts as a point, then a thin line. Vertical # deflection opens only after horizontal sync has settled. half_width = 12 + 465 * ease(264, 275, f) half_height = 1.1 + 272 * ease(275, 296, f) field = np.maximum(0, 1 - (np.abs(xx - 640) / half_width) ** 12) beam = field * np.exp(-(((yy - 360) / half_height) ** 2) * 3) beam *= max(0, 1 - ease(277, 318, f)) * (0.87 if f in (277, 279) else 1) edge = 397 + 510 * ease(280, 330, f) reveal = np.clip((edge - xx - (yy - 340) * 0.24) / 22, 0, 1) trace = mark * reveal heat = mark * np.exp(-(((xx + (yy - 340) * 0.24 - edge) / 28) ** 2)) * ease(280, 290, f) scan = 1 - 0.23 * (1 - np.cos(yy * math.pi)) * (1 - ease(318, 342, f)) ink = trace * scan rgb = np.stack( ( ink * 210 + heat * 91 + beam * 105, ink * 235 + heat * 91 + beam * 225, ink * 196 + heat * 75 + beam * 157, ), axis=-1, ) rgb += splice[:, :, None] * reveal[:, :, None] * np.array([246, 118, 59], dtype=np.float32) frame = Image.fromarray(np.uint8(np.clip(rgb, 0, 255))) halo = frame.filter(ImageFilter.GaussianBlur(5)) optical = Image.fromarray( np.uint8(np.minimum(255, np.asarray(frame, dtype=np.float32) + np.asarray(halo) * 0.22)) ) # CRT and clean slate share one drawing, with independent framing. monitor = Image.new("RGB", (768, 576), (1, 2, 2)) monitor.paste(optical.resize((940, 529), Image.Resampling.LANCZOS), (-86, 24)) monitor.save(tube / f"screen_{f:04}.png") if f >= 333: optical.save(card / f"signature_{f:04}.png") def soundtrack(): base = ROOT / "assets/audio/startup/studio-workshop-v7.wav" with wave.open(str(base), "rb") as src: rate = src.getframerate() mix = np.frombuffer(src.readframes(src.getnframes()), "= (tick - 1) / 24 transient = 0.055 * onset * np.exp(-145 * age) * (np.sin(2 * np.pi * 1520 * age) + hiss) mix[:, 0] += transient * 0.63 mix[:, 1] += transient # Each spring has its own attack and short metallic decay as its letter settles. for i in range(5): sec = (185 + 9 * i + 16 - 1) / 24 dt = np.maximum(0, t - sec) tick = (t >= sec) * np.exp(-40 * dt) * (0.11 * np.sin(2 * np.pi * (570 + 62 * i) * dt) + 0.13 * hiss) mix[:, 0] += tick * (1 - 0.11 * i) mix[:, 1] += tick * (0.55 + 0.11 * i) hum = 0.016 * np.sin(2 * np.pi * 52 * t) * ease(7.2, 7.9, t) * (1 - ease(13.3, 15.8, t)) mix += hum[:, None] for sec, hz, gain, decay in ( (263 / 24, 113, 0.18, 4), (274 / 24, 915, 0.042, 5), (285 / 24, 221, 0.09, 1.5), (309 / 24, 330, 0.078, 1.5), (331 / 24, 442, 0.13, 1.5), (335 / 24, 552, 0.055, 1.5), ): dt = np.maximum(0, t - sec) env = (t >= sec) * (1 - np.exp(-170 * dt)) * np.exp(-decay * dt) tone = gain * env * (np.sin(2 * np.pi * hz * dt) + 0.14 * np.sin(4 * np.pi * hz * dt)) mix += tone[:, None] mix *= np.clip((16 - t) / 0.36, 0, 1)[:, None] with wave.open(str(base.with_name("studio-workshop-v8.wav")), "wb") as dst: dst.setparams((2, 2, rate, 0, "NONE", "not compressed")) dst.writeframes(np.int16(np.clip(mix, -0.94, 0.94) * 32767).tobytes()) if __name__ == "__main__": soundtrack() identity_frames()