Spaces:
Paused
Paused
Download src/mv/engine/road3d.ts from Ethscriptions/video: direct link, hf CLI and curl.
- Browser
- Download file 16.9 kB
-
https://huggingface.co/spaces/Ethscriptions/video/resolve/main/src/mv/engine/road3d.ts
- Command line
-
hf download hf://spaces/Ethscriptions/video/src/mv/engine/road3d.ts
-
curl -L -o road3d.ts https://huggingface.co/spaces/Ethscriptions/video/resolve/main/src/mv/engine/road3d.ts
16.9 kB
| // A tiny 3D "film camera" for the highway: perspective projection with yaw, | |
| // near-plane clipping, a road with lamps, and car sprites chosen by viewing | |
| // angle (rear / front / side). Lets us shoot the duels like a director: | |
| // POV through the windscreen, chase cams, a camera that spins with the car. | |
| import { carRear, carSide, heroCarFront, rivalCarFront, roadsterFront, roadsterRear, roadsterSide, truckRear, truckSide, type CarKind } from './cars' | |
| import { PULSE, glowBlob } from './draw' | |
| import type { SceneCtx } from './types' | |
| import { PALETTE, clamp, hash } from './util' | |
| type C2D = CanvasRenderingContext2D | |
| export interface Cam { | |
| x: number | |
| y: number | |
| z: number | |
| yaw: number | |
| f: number | |
| hy: number | |
| roll: number | |
| /** true downward tilt in radians (for aerial / drone shots) */ | |
| tilt: number | |
| } | |
| export function makeCam(s: SceneCtx, x: number, y: number, z: number, yaw: number, pitch = 0, fov = 1, roll = 0, tilt = 0): Cam { | |
| const f = s.W * 0.62 * fov | |
| return { x, y, z, yaw, f, hy: s.H * 0.5 + pitch * f, roll, tilt } | |
| } | |
| interface P3 { | |
| x: number | |
| y: number | |
| z: number | |
| } | |
| function toCam(c: Cam, X: number, Y: number, Z: number): P3 { | |
| const dx = X - c.x | |
| const dz = Z - c.z | |
| const cs = Math.cos(c.yaw) | |
| const sn = Math.sin(c.yaw) | |
| const xr = dx * cs - dz * sn | |
| const zr = dx * sn + dz * cs | |
| const yr = Y - c.y | |
| if (!c.tilt) return { x: xr, y: yr, z: zr } | |
| const ct = Math.cos(c.tilt) | |
| const st = Math.sin(c.tilt) | |
| return { x: xr, y: yr * ct + zr * st, z: -yr * st + zr * ct } | |
| } | |
| export function proj(c: Cam, s: SceneCtx, X: number, Y: number, Z: number) { | |
| const p = toCam(c, X, Y, Z) | |
| if (p.z < 0.3) return null | |
| const k = c.f / p.z | |
| return { x: s.W / 2 + p.x * k, y: c.hy - p.y * k, z: p.z, k } | |
| } | |
| const NEAR = 0.35 | |
| /** fill a world-space polygon with near-plane clipping */ | |
| export function poly3(ctx: C2D, c: Cam, s: SceneCtx, pts: [number, number, number][], fill: string) { | |
| const cam = pts.map(([X, Y, Z]) => toCam(c, X, Y, Z)) | |
| const out: P3[] = [] | |
| for (let i = 0; i < cam.length; i++) { | |
| const a = cam[i] | |
| const b = cam[(i + 1) % cam.length] | |
| const ain = a.z >= NEAR | |
| const bin = b.z >= NEAR | |
| if (ain) out.push(a) | |
| if (ain !== bin) { | |
| const t = (NEAR - a.z) / (b.z - a.z) | |
| out.push({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t, z: NEAR }) | |
| } | |
| } | |
| if (out.length < 3) return | |
| ctx.fillStyle = fill | |
| ctx.beginPath() | |
| out.forEach((p, i) => { | |
| const k = c.f / p.z | |
| const x = s.W / 2 + p.x * k | |
| const y = c.hy - p.y * k | |
| if (i) ctx.lineTo(x, y) | |
| else ctx.moveTo(x, y) | |
| }) | |
| ctx.closePath() | |
| ctx.fill() | |
| } | |
| // ------------------------------------------------------------------ the world | |
| export interface WorldOpts { | |
| /** colour of the sky near the horizon */ | |
| glow?: string | |
| /** police lights far away */ | |
| police?: boolean | |
| } | |
| export function drawHighway(s: SceneCtx, c: Cam, o: WorldOpts = {}) { | |
| const { ctx, W, H, t } = s | |
| ctx.save() | |
| if (c.roll) { | |
| ctx.translate(W / 2, H / 2) | |
| ctx.rotate(c.roll) | |
| ctx.translate(-W / 2, -H / 2) | |
| } | |
| const hy = c.hy - Math.tan(c.tilt || 0) * c.f | |
| // sky | |
| const g = ctx.createLinearGradient(0, hy - H * 0.6, 0, hy) | |
| g.addColorStop(0, '#04050c') | |
| g.addColorStop(0.7, '#141a36') | |
| g.addColorStop(1, o.glow ?? '#3a1530') | |
| ctx.fillStyle = g | |
| ctx.fillRect(-W, -H, W * 3, hy + H) | |
| glowBlob(ctx, W / 2, hy, Math.max(W, H) * 0.55, '#ff4a6a', 0.16) | |
| // city panorama at infinity (rotates correctly with yaw) | |
| const fovH = Math.atan(W / 2 / c.f) + 0.3 | |
| for (let i = 0; i < 240; i++) { | |
| const az = (i / 240) * Math.PI * 2 | |
| let rel = az - c.yaw | |
| rel = Math.atan2(Math.sin(rel), Math.cos(rel)) | |
| if (Math.abs(rel) > fovH) continue | |
| const x = W / 2 + Math.tan(rel) * c.f | |
| const bw = c.f * 0.03 | |
| const band = i % 3 === 0 ? PULSE.low : i % 3 === 1 ? PULSE.mid : PULSE.high | |
| const bh = H * (0.03 + 0.12 * Math.pow(hash(i * 3.1), 2)) * (1 + (0.3 * band + 0.2 * PULSE.kick) * (0.4 + 0.6 * hash(i * 5.3))) | |
| ctx.fillStyle = '#07070e' | |
| ctx.fillRect(x - bw / 2, hy - bh, bw, bh + 2) | |
| ctx.fillStyle = hash(i * 7.7) > 0.5 ? PALETTE.sodium : '#7fc8d8' | |
| ctx.globalAlpha = 0.5 | |
| for (let w = 0; w < 4; w++) if (hash(i * 13 + w) > 0.5) ctx.fillRect(x - bw * 0.3 + (w % 2) * bw * 0.35, hy - bh + bh * (0.2 + 0.18 * Math.floor(w / 2)), bw * 0.15, bh * 0.08) | |
| ctx.globalAlpha = 1 | |
| } | |
| // ground | |
| ctx.fillStyle = '#07080b' | |
| ctx.fillRect(-W, hy, W * 3, H * 2) | |
| // road segments around the camera | |
| const z0 = Math.floor((c.z - 90) / 4) * 4 | |
| for (let z = z0; z < c.z + 260; z += 4) { | |
| poly3(ctx, c, s, [ | |
| [-7.2, 0, z], | |
| [7.2, 0, z], | |
| [7.2, 0, z + 4.05], | |
| [-7.2, 0, z + 4.05], | |
| ], z % 8 === 0 ? '#15171c' : '#17191e') | |
| } | |
| for (let z = z0; z < c.z + 260; z += 4) { | |
| for (const ex of [-5.55, 5.4]) poly3(ctx, c, s, [ | |
| [ex, 0.01, z], | |
| [ex + 0.15, 0.01, z], | |
| [ex + 0.15, 0.01, z + 4.05], | |
| [ex, 0.01, z + 4.05], | |
| ], 'rgba(235,230,215,0.8)') | |
| } | |
| const d0 = Math.floor((c.z - 90) / 12) * 12 | |
| for (let z = d0; z < c.z + 260; z += 12) { | |
| for (const lx of [-1.8, 1.8]) poly3(ctx, c, s, [ | |
| [lx - 0.08, 0.01, z], | |
| [lx + 0.08, 0.01, z], | |
| [lx + 0.08, 0.01, z + 5], | |
| [lx - 0.08, 0.01, z + 5], | |
| ], 'rgba(235,230,215,0.85)') | |
| } | |
| // lamp posts + light pools + guard rails | |
| const l0 = Math.floor((c.z - 90) / 30) * 30 | |
| const lamps: { x: number; y: number; k: number; z: number }[] = [] | |
| for (let z = l0; z < c.z + 260; z += 30) { | |
| for (const sd of [-1, 1]) { | |
| poly3(ctx, c, s, [ | |
| [sd * 2.5, 0.02, z - 7], | |
| [sd * 7.5, 0.02, z - 7], | |
| [sd * 7.5, 0.02, z + 7], | |
| [sd * 2.5, 0.02, z + 7], | |
| ], 'rgba(255,179,92,0.07)') | |
| const base = proj(c, s, sd * 8.2, 0, z) | |
| const top = proj(c, s, sd * 8.2, 8, z) | |
| const head = proj(c, s, sd * 5.8, 8, z) | |
| if (base && top && head) { | |
| ctx.strokeStyle = '#1c1f26' | |
| ctx.lineWidth = Math.max(1, 0.25 * base.k) | |
| ctx.beginPath() | |
| ctx.moveTo(base.x, base.y) | |
| ctx.lineTo(top.x, top.y) | |
| ctx.lineTo(head.x, head.y) | |
| ctx.stroke() | |
| lamps.push({ x: head.x, y: head.y, k: head.k, z: head.z }) | |
| } | |
| } | |
| } | |
| for (const L of lamps) glowBlob(ctx, L.x, L.y, Math.max(4, 2.2 * L.k), PALETTE.sodium, 0.95) | |
| for (const sd of [-1, 1]) { | |
| for (let z = z0; z < c.z + 260; z += 4) | |
| poly3(ctx, c, s, [ | |
| [sd * 7.6, 0.6, z], | |
| [sd * 7.6, 0.85, z], | |
| [sd * 7.6, 0.85, z + 4.05], | |
| [sd * 7.6, 0.6, z + 4.05], | |
| ], '#3a3f48') | |
| } | |
| // police lights far away | |
| if (o.police) policeLights(s, c, t) | |
| ctx.restore() | |
| } | |
| export function policeLights(s: SceneCtx, c: Cam, t: number) { | |
| const { ctx } = s | |
| ctx.save() | |
| ctx.globalCompositeOperation = 'lighter' | |
| for (let i = 0; i < 3; i++) { | |
| const p = proj(c, s, -3.6 + i * 3.6, 1.6, c.z + 220 + i * 25) | |
| if (!p) continue | |
| const ph = Math.floor(t * 6 + i) % 2 | |
| glowBlob(ctx, p.x - p.k * 0.5, p.y, Math.max(6, 5 * p.k), '#ff2040', ph ? 1 : 0.25) | |
| glowBlob(ctx, p.x + p.k * 0.5, p.y, Math.max(6, 5 * p.k), '#2a6aff', ph ? 0.25 : 1) | |
| } | |
| ctx.restore() | |
| } | |
| // ------------------------------------------------------------------ actors | |
| export interface Actor { | |
| kind: CarKind | |
| x: number | |
| y?: number | |
| z: number | |
| h: number | |
| head?: number | |
| high?: number | |
| brake?: number | |
| pop?: number | |
| look?: number | |
| pitch?: number | |
| jet?: { power: number; angle: number } | |
| jetKit?: boolean | |
| shield?: number | |
| lit?: number | |
| } | |
| const LEN: Record<CarKind, number> = { hero: 4.0, rival: 4.5, roadster: 4.3, truck: 16 } | |
| const WID: Record<CarKind, number> = { hero: 1.75, rival: 1.9, roadster: 2.0, truck: 2.5 } | |
| /** headlight beams as light thrown onto the road, along each car's heading */ | |
| export function drawBeams(s: SceneCtx, c: Cam, actors: Actor[]) { | |
| const { ctx } = s | |
| ctx.save() | |
| ctx.globalCompositeOperation = 'lighter' | |
| for (const a of actors) { | |
| const head = a.head ?? 1 | |
| const high = a.high ?? 0 | |
| if (head < 0.05 && high < 0.05) continue | |
| const fx = Math.sin(a.h) | |
| const fz = Math.cos(a.h) | |
| const rx = Math.cos(a.h) | |
| const rz = -Math.sin(a.h) | |
| const half = LEN[a.kind] / 2 | |
| const ox = a.x + fx * half | |
| const oz = a.z + fz * half | |
| const y = Math.max(0.02, (a.y ?? 0) > 0.3 ? -1 : 0.03) | |
| if (y < 0) continue // airborne: no beam on the road | |
| // the beam as light on the asphalt: many short segments, falling off with | |
| // distance from the lamp, and faded out where it passes under the lens | |
| const len = 26 + 48 * high | |
| const segs = 14 | |
| for (let k = 0; k < segs; k++) { | |
| const d0 = (k / segs) * len | |
| const d1 = ((k + 1) / segs) * len | |
| const w0 = 0.8 + (d0 / len) * (3.5 + 3 * high) | |
| const w1 = 0.8 + (d1 / len) * (3.5 + 3 * high) | |
| const fall = 1 / (1 + d0 / (6 + 10 * high)) | |
| const mx = ox + fx * (d0 + d1) / 2 | |
| const mz = oz + fz * (d0 + d1) / 2 | |
| const depth = toCam(c, mx, 0, mz).z | |
| const nearFade = clamp((depth - 2) / 7) | |
| const al = (0.055 * head + 0.11 * high) * fall * nearFade | |
| if (al <= 0.003) continue | |
| poly3(ctx, c, s, [ | |
| [ox + fx * d0 - rx * w0, y, oz + fz * d0 - rz * w0], | |
| [ox + fx * d0 + rx * w0, y, oz + fz * d0 + rz * w0], | |
| [ox + fx * d1 + rx * w1, y, oz + fz * d1 + rz * w1], | |
| [ox + fx * d1 - rx * w1, y, oz + fz * d1 - rz * w1], | |
| ], `rgba(255,240,210,${al})`) | |
| } | |
| // glare at the lamps when they point roughly at the lens | |
| for (const sd of [-1, 1]) { | |
| const p = proj(c, s, ox + rx * 0.62 * sd, 0.7, oz + rz * 0.62 * sd) | |
| if (!p) continue | |
| const toCamX = c.x - ox | |
| const toCamZ = c.z - oz | |
| const facing = (toCamX * fx + toCamZ * fz) / (Math.hypot(toCamX, toCamZ) || 1) | |
| if (facing > 0.2) glowBlob(ctx, p.x, p.y, Math.min(s.W * 0.1, p.k * (0.5 + 1.2 * high)), '#fff4dc', (0.35 + 0.45 * high) * facing * clamp((p.z - 1.5) / 4)) | |
| } | |
| } | |
| ctx.restore() | |
| } | |
| export function drawActors(s: SceneCtx, c: Cam, actors: Actor[]) { | |
| const { ctx, t } = s | |
| drawBeams(s, c, actors) | |
| const sorted = actors | |
| .map((a) => ({ a, d: toCam(c, a.x, 0, a.z).z })) | |
| .filter((e) => e.d > 0.8) | |
| .sort((p, q) => q.d - p.d) | |
| for (const { a } of sorted) { | |
| const g = proj(c, s, a.x, a.y ?? 0, a.z) | |
| if (!g) continue | |
| const az = Math.atan2(a.x - c.x, a.z - c.z) | |
| let diff = a.h - az | |
| diff = Math.atan2(Math.sin(diff), Math.cos(diff)) | |
| const w = WID[a.kind] * g.k | |
| // ground shadow when airborne | |
| if ((a.y ?? 0) > 0.05) { | |
| const gg = proj(c, s, a.x, 0, a.z) | |
| if (gg) { | |
| ctx.fillStyle = `rgba(0,0,0,${0.45 - Math.min(0.3, (a.y ?? 0) * 0.08)})` | |
| ctx.beginPath() | |
| ctx.ellipse(gg.x, gg.y, WID[a.kind] * gg.k * 0.7, WID[a.kind] * gg.k * 0.15, 0, 0, Math.PI * 2) | |
| ctx.fill() | |
| } | |
| } | |
| if (a.kind === 'roadster' || a.kind === 'truck') { | |
| if (Math.abs(diff) < 0.7) { | |
| if (a.kind === 'roadster') roadsterRear(ctx, g.x, g.y, w, { brake: a.brake, jet: a.jet && a.jet.angle > 2.4 ? a.jet.power : 0, t }) | |
| else truckRear(ctx, g.x, g.y, w) | |
| } else if (Math.abs(diff) > Math.PI - 0.7) { | |
| if (a.kind === 'roadster') roadsterFront(ctx, g.x, g.y, w, { head: a.head ?? 1, t }) | |
| else truckRear(ctx, g.x, g.y, w) | |
| } else { | |
| const L = LEN[a.kind] * g.k | |
| const fs = Math.abs(Math.sin(diff)) | |
| ctx.save() | |
| ctx.translate(g.x, g.y) | |
| ctx.scale((diff > 0 ? 1 : -1) * Math.max(0.25, fs), 1) | |
| if (a.kind === 'roadster') roadsterSide(ctx, 0, 0, L, a.pitch ?? 0, { spin: t * 40, head: a.head ?? 1, brake: a.brake, t, nozzle: a.jetKit ? 1 : 0 }) | |
| else truckSide(ctx, 0, 0, L, t * 20) | |
| ctx.restore() | |
| } | |
| continue | |
| } | |
| if (Math.abs(diff) < 0.7) { | |
| carRear(ctx, a.kind, g.x, g.y, w, { brake: a.brake, pop: a.pop, jet: a.jet && a.jet.angle > 2.4 ? a.jet.power : 0, t }) | |
| } else if (Math.abs(diff) > Math.PI - 0.7) { | |
| if (a.kind === 'hero') heroCarFront(ctx, g.x, g.y, w, { head: a.head ?? 1, high: a.high ?? 0, t }) | |
| else rivalCarFront(ctx, g.x, g.y, w, { head: a.head ?? 1, t, shield: a.shield ?? 0, lit: a.lit ?? 0 }) | |
| } else { | |
| const L = LEN[a.kind] * g.k | |
| const fs = Math.abs(Math.sin(diff)) | |
| ctx.save() | |
| ctx.translate(g.x, g.y) | |
| ctx.scale((diff > 0 ? 1 : -1) * Math.max(0.25, fs), 1) | |
| carSide(ctx, a.kind, 0, 0, L, a.pitch ?? 0, { spin: t * 40, head: a.head ?? 1, brake: a.brake, t, look: a.look, jetKit: a.jetKit, jet: a.jet, noBeam: true }) | |
| ctx.restore() | |
| } | |
| } | |
| } | |
| // ------------------------------------------------------------------ gas / smoke | |
| export interface Puff { | |
| x: number | |
| y: number | |
| z: number | |
| r: number | |
| a: number | |
| col: [number, number, number] | |
| } | |
| export function drawPuffs(s: SceneCtx, c: Cam, puffs: Puff[]) { | |
| const { ctx } = s | |
| const list = puffs | |
| .map((p) => ({ p, q: proj(c, s, p.x, p.y, p.z) })) | |
| .filter((e) => e.q) | |
| .sort((a, b) => b.q!.z - a.q!.z) | |
| for (const { p, q } of list) { | |
| const r = Math.min(p.r * q!.k, s.W * 0.32) | |
| if (r < 0.5) continue | |
| const near = clamp((q!.z - 2) / 6) / (1 + (p.r * q!.k) / (s.W * 0.25)) | |
| if (near <= 0.01) continue | |
| const g = ctx.createRadialGradient(q!.x, q!.y, 0, q!.x, q!.y, r) | |
| const [R, G, B] = p.col | |
| g.addColorStop(0, `rgba(${R},${G},${B},${clamp(p.a * near)})`) | |
| g.addColorStop(1, `rgba(${R},${G},${B},0)`) | |
| ctx.fillStyle = g | |
| ctx.fillRect(q!.x - r, q!.y - r, r * 2, r * 2) | |
| } | |
| } | |
| /** a deterministic stream of puffs from an emitter whose position is a function of time */ | |
| export function emit( | |
| out: Puff[], | |
| tNow: number, | |
| from: number, | |
| to: number, | |
| rate: number, | |
| pos: (te: number) => { x: number; y: number; z: number } | null, | |
| o: { spread: number; rise: number; grow: number; life: number; r0: number; a0: number; col: [number, number, number]; drift?: { x: number; z: number } }, | |
| ) { | |
| const dt = 1 / rate | |
| const start = Math.max(from, tNow - o.life) | |
| const end = Math.min(to, tNow) | |
| for (let te = Math.ceil(start / dt) * dt; te <= end; te += dt) { | |
| const age = tNow - te | |
| const p = pos(te) | |
| if (!p) continue | |
| const hx = hash(te * 91.7) - 0.5 | |
| const hz = hash(te * 37.3) - 0.5 | |
| const k = age / o.life | |
| out.push({ | |
| x: p.x + hx * o.spread * (0.3 + age) + (o.drift?.x ?? 0) * age, | |
| y: p.y + o.rise * age, | |
| z: p.z + hz * o.spread * (0.3 + age) + (o.drift?.z ?? 0) * age, | |
| r: o.r0 + o.grow * age, | |
| a: o.a0 * (1 - k) * (1 - k), | |
| col: o.col, | |
| }) | |
| } | |
| } | |
| /** a jet plume drawn in world space (start point, direction, length) */ | |
| export function plume3(s: SceneCtx, c: Cam, X: number, Y: number, Z: number, dx: number, dy: number, dz: number, len: number, w0: number, t: number) { | |
| const { ctx } = s | |
| const a = proj(c, s, X, Y, Z) | |
| // never let the plume reach into the lens (keeps it readable, avoids blow-out) | |
| let L2 = len | |
| for (let i = 0; i < 10; i++) { | |
| const d = toCam(c, X + dx * L2, Y + dy * L2, Z + dz * L2).z | |
| if (d >= 5) break | |
| L2 *= 0.75 | |
| } | |
| const b = proj(c, s, X + dx * L2, Math.max(0, Y + dy * L2), Z + dz * L2) | |
| ctx.save() | |
| ctx.globalCompositeOperation = 'lighter' | |
| if (a) glowBlob(ctx, a.x, a.y, Math.min(s.W * 0.25, Math.max(6, w0 * 3 * a.k)), '#8fdcff', 0.8 * clamp((a.z - 1.5) / 4)) | |
| if (a && b) { | |
| const flick = 0.85 + 0.15 * Math.sin(t * 53) | |
| ctx.globalAlpha = clamp((b.z - 2) / 8) * 0.7 + 0.3 * clamp(1 - Math.abs(dz)) | |
| for (const [col, wk] of [ | |
| ['rgba(70,150,255,0.45)', 1], | |
| ['rgba(140,225,255,0.65)', 0.6], | |
| ['rgba(255,255,255,0.9)', 0.28], | |
| ] as [string, number][]) { | |
| const wa = w0 * a.k * wk | |
| const wb = w0 * 2.4 * b.k * wk * flick | |
| const ang = Math.atan2(b.y - a.y, b.x - a.x) | |
| const px = Math.cos(ang + Math.PI / 2) | |
| const py = Math.sin(ang + Math.PI / 2) | |
| ctx.fillStyle = col | |
| ctx.beginPath() | |
| ctx.moveTo(a.x + px * wa, a.y + py * wa) | |
| ctx.lineTo(b.x + px * wb, b.y + py * wb) | |
| ctx.arc(b.x, b.y, wb, ang + Math.PI / 2, ang - Math.PI / 2, true) | |
| ctx.lineTo(a.x - px * wa, a.y - py * wa) | |
| ctx.closePath() | |
| ctx.fill() | |
| } | |
| } | |
| ctx.restore() | |
| } | |
| /** render the world again into the rear-view mirror (mirrored, looking backwards) */ | |
| export function rearMirror(s: SceneCtx, c: Cam, actors: Actor[], rect: { x: number; y: number; w: number; h: number }) { | |
| const { ctx, W } = s | |
| ctx.save() | |
| ctx.beginPath() | |
| ctx.roundRect(rect.x, rect.y, rect.w, rect.h, rect.h * 0.25) | |
| ctx.clip() | |
| ctx.translate(rect.x + rect.w / 2, rect.y + rect.h / 2) | |
| const sc = rect.w / W | |
| ctx.scale(-sc, sc) | |
| ctx.translate(-W / 2, -s.H / 2) | |
| const back: Cam = { ...c, yaw: c.yaw + Math.PI, hy: s.H * 0.5 } | |
| drawHighway(s, back) | |
| drawActors(s, back, actors) | |
| ctx.restore() | |
| ctx.strokeStyle = '#0b0c10' | |
| ctx.lineWidth = Math.max(2, rect.h * 0.08) | |
| ctx.beginPath() | |
| ctx.roundRect(rect.x, rect.y, rect.w, rect.h, rect.h * 0.25) | |
| ctx.stroke() | |
| } | |