스피로그래프 그리기 9가지 — 톱니비율로 그리는 기하 무늬
톱니바퀴 두 개의 이빨 수가 서로 소수일 때 곡선은 닫히고, 비율이 어긋나는 순간 종잇장은 끝없이 헤맨다 — 03번은 그 비율로 무늬 대칭 축 수를 계산한다. 스피로그래프 그리기를 캔버스 2d 좌표 계산으로 옮긴 아홉 장면이고, 파일을 내려받으면 그대로 켜진다.
톱니 곡선 아홉 무늬를 화면에서 바로 확인한다
01 spiro-scene-hypotrochoid-basic
02 spiro-scene-epitrochoid-outer-roll
03 spiro-scene-tooth-ratio-symmetry
04 spiro-scene-multi-pen-rainbow
05 spiro-scene-trail-fade-draw
06 spiro-scene-gear-visual-guide
07 spiro-scene-pointer-ratio-morph
08 spiro-scene-curve-turn-table
09 spiro-scene-hero-gallery-wall
자동 재생 · 눌러서 해당 항목으로 · 전부 한 zip
- 01 안쪽 톱니를 따라 도는 기본 스피로그래프 곡선
- 02 바깥으로 굴러가는 톱니가 그리는 바깥 곡선
- 03 이빨 수 비율로 대칭 축 수가 정해지는 무늬
- 04 구멍 여러 개가 동시에 그리는 무지개 톱니 무늬
- 05 궤적이 서서히 사라지며 계속 그리는 장면
- 06 톱니와 펜이 곡선 위에 같이 보이는 가이드
- 07 포인터 거리로 이빨 비율이 바뀌는 무늬
- 08 완성 무늬가 도는 회전 판 장면
- 09 비율·펜·잔상을 한 화면에 모은 히어로 갤러리
스피로그래프 그리기 9가지 — 이빨 수 비율이 무늬 전체를 결정한다
아홉 장면의 순서는 계산이 한 겹씩 쌓이는 순서다. 01 과 02 가 안쪽·바깥쪽 좌표식을 보여 주고, 03 이 이빨 수의 최대공약수로 대칭 축 수를 뽑고, 04 가 펜 구멍을 네 개로 늘리고, 05 가 지난 궤적을 옅게 지우고, 06 이 톱니 원을 곡선 위에 함께 그리고, 07 이 포인터 거리를 이빨 수로 바꾸고, 08 이 완성된 도형을 통째로 돌리고, 09 가 이빨 수 쌍이 다른 네 곡선을 한 화면에 모은다. 어느 장면이든 곡선을 정하는 것은 굴러가는 톱니와 링의 이빨 수 비율이다.
기법별 코드로 보는 톱니 곡선 계산
스피로그래프 사이클로이드 계열 곡선은 큰 링의 안쪽이나 바깥을 굴러가는 작은 톱니 위의 한 점이 남기는 궤적이고, 안쪽이면 하이포트로코이드, 바깥이면 에피트로코이드라고 부른다. 아래 코드는 각 데모 index.html 의 연속된 줄을 그대로 옮겼으며, 항목마다 이빨 수 상수와 gcd 로 얻은 바퀴 수가 곡선 한 점을 정하는 식에 어떻게 들어가는지 따라가면 된다.
01안쪽 톱니를 따라 도는 기본 스피로그래프 곡선
point(t) 가 링 반지름 R 과 굴러가는 톱니 반지름 r 의 차를 팔 길이로 삼고, 펜 구멍 거리 d 를 r 의 0.6 배로 둔 하이포트로코이드 좌표를 한 점씩 돌려준다. gcd(72, 27) 이 9 라서 TURNS 는 3 이 되어 곡선이 3 바퀴째에 출발점으로 돌아와 닫히며, 곡선 안쪽 반투명 채움과 펜 끝을 따라가는 배경 그라디언트는 계산이 아니라 그 위에 얹은 표현 층이다. 이 장면은 누적면적 65.7%·평균 강도 22.7·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp1 is-demo" id="sp1Root" tabindex="0">
<canvas class="sp1__canvas" id="sp1Canvas" width="480" height="300"></canvas>
<p class="sp1__caption">작은 톱니가 큰 링 안쪽을 미끄러지며 도는 동안 펜 위치를 링 중심 기준 각도로 계산해, 안쪽으로 말리는 궤적을 선으로 쌓는다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-ink);
.sp1 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-ink;
}
.sp1__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp1__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp1__caption { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp1 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #17141a;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp1 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #17141a;
}
.sp1__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp1__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp1__caption {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp1 {
cursor: default;
}
}(function () {
// 기법: 하이포트로코이드(내접 톱니) 파라메트릭 좌표를 매 프레임 각도 t 만큼 전진시켜 점진적으로
// 이어 그린다. R = 링 반지름, r = 안쪽 톱니 반지름, d = 펜 구멍이 톱니 중심에서 떨어진 거리.
// x(t) = (R-r)cos(t) + d cos(((R-r)/r) t) · y(t) = (R-r)sin(t) - d sin(((R-r)/r) t)
var root = document.getElementById('sp1Root');
var canvas = document.getElementById('sp1Canvas');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var CALC_DIM = 200;
var GEAR_RING_TEETH = 72;
var GEAR_ROLL_TEETH = 27;
var PEN_TIP_RATIO = 0.6;
var TOOTH_UNIT = 1.4;
var SEGMENTS_PER_TURN = 220;
function gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { var t = b; b = a % b; a = t; } return a; }
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var TOTAL_T = TURNS * Math.PI * 2;
var CYCLE_SECONDS = 6;
var SPEED = TOTAL_T / CYCLE_SECONDS;
function point(t) {
var k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p) { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawFull(tMax) {
ctx.clearRect(0, 0, cw, ch);
var tipW = toScreen(point(tMax));
var wash = ctx.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.85);
wash.addColorStop(0, 'rgba(255,214,200,.55)');
wash.addColorStop(0.5, 'rgba(200,190,255,.28)');
wash.addColorStop(1, 'rgba(160,230,220,.10)');
ctx.fillStyle = wash;
ctx.fillRect(0, 0, cw, ch);
var fillSteps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var fi = 0; fi <= fillSteps; fi += 1) {
var fs = toScreen(point((fi / fillSteps) * tMax));
if (fi === 0) ctx.moveTo(fs.x, fs.y); else ctx.lineTo(fs.x, fs.y);
}
ctx.closePath();
ctx.fillStyle = 'rgba(255,247,230,.16)';
ctx.fill('evenodd');
ctx.lineWidth = Math.max(3, scale * 0.04);
ctx.strokeStyle = 'rgba(255,247,230,.94)';
ctx.shadowColor = 'rgba(255,247,230,.55)';
ctx.shadowBlur = Math.max(8, scale * 0.12);
ctx.lineJoin = 'round';
ctx.lineCap = 'round';
var steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var i = 0; i <= steps; i += 1) {
var t = (i / steps) * tMax;
var s = toScreen(point(t));
if (i === 0) ctx.moveTo(s.x, s.y); else ctx.lineTo(s.x, s.y);
}
ctx.stroke();
ctx.shadowBlur = 0;
if (tMax > 0.001) {
var tip = toScreen(point(tMax));
ctx.fillStyle = 'rgba(255,247,230,1)';
ctx.beginPath();
ctx.arc(tip.x, tip.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx.fill();
}
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (reduce) root.classList.remove('is-demo');
fit();
if (reduce) {
drawFull(TOTAL_T);
} else {
var elapsed = 0.35;
var lastTs = null;
function tick(ts) {
if (lastTs === null) lastTs = ts;
var dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
var t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener('resize', function () { fit(); drawFull(elapsed * SPEED); });
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneHypotrochoidBasic.module.scss";
type Pt = { x: number; y: number };
export default function SpiroSceneHypotrochoidBasic() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
if (!root || !canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const CALC_DIM = 200;
const GEAR_RING_TEETH = 72;
const GEAR_ROLL_TEETH = 27;
const PEN_TIP_RATIO = 0.6;
const TOOTH_UNIT = 1.4;
const SEGMENTS_PER_TURN = 220;
function gcd(a: number, b: number): number {
a = Math.abs(a); b = Math.abs(b);
while (b) { const t = b; b = a % b; a = t; }
return a;
}
const R = GEAR_RING_TEETH * TOOTH_UNIT;
const r = GEAR_ROLL_TEETH * TOOTH_UNIT;
const d = r * PEN_TIP_RATIO;
const g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
const TURNS = GEAR_ROLL_TEETH / g;
const TOTAL_T = TURNS * Math.PI * 2;
const CYCLE_SECONDS = 6;
const SPEED = TOTAL_T / CYCLE_SECONDS;
function point(t: number): Pt {
const k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p: Pt): Pt { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawFull(tMax: number) {
ctx!.clearRect(0, 0, cw, ch);
const tipW = toScreen(point(tMax));
const wash = ctx!.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.85);
wash.addColorStop(0, "rgba(255,214,200,.55)");
wash.addColorStop(0.5, "rgba(200,190,255,.28)");
wash.addColorStop(1, "rgba(160,230,220,.10)");
ctx!.fillStyle = wash;
ctx!.fillRect(0, 0, cw, ch);
const fillSteps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx!.beginPath();
for (let fi = 0; fi <= fillSteps; fi += 1) {
const fs = toScreen(point((fi / fillSteps) * tMax));
if (fi === 0) ctx!.moveTo(fs.x, fs.y); else ctx!.lineTo(fs.x, fs.y);
}
ctx!.closePath();
ctx!.fillStyle = "rgba(255,247,230,.16)";
ctx!.fill("evenodd");
ctx!.lineWidth = Math.max(3, scale * 0.04);
ctx!.strokeStyle = "rgba(255,247,230,.94)";
ctx!.shadowColor = "rgba(255,247,230,.55)";
ctx!.shadowBlur = Math.max(8, scale * 0.12);
ctx!.lineJoin = "round";
ctx!.lineCap = "round";
const steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx!.beginPath();
for (let i = 0; i <= steps; i += 1) {
const t = (i / steps) * tMax;
const s = toScreen(point(t));
if (i === 0) ctx!.moveTo(s.x, s.y); else ctx!.lineTo(s.x, s.y);
}
ctx!.stroke();
ctx!.shadowBlur = 0;
if (tMax > 0.001) {
const tip = toScreen(point(tMax));
ctx!.fillStyle = "rgba(255,247,230,1)";
ctx!.beginPath();
ctx!.arc(tip.x, tip.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx!.fill();
}
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
if (reduce) root.classList.remove("is-demo");
fit();
let raf = 0;
if (reduce) {
drawFull(TOTAL_T);
} else {
let elapsed = 0.35;
let lastTs: number | null = null;
const onResize = () => { fit(); drawFull(elapsed * SPEED); };
function tick(ts: number) {
if (lastTs === null) lastTs = ts;
const dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
let t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
raf = requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp1} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp1__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp1__caption}>작은 톱니가 큰 링 안쪽을 미끄러지며 도는 동안 펜 위치를 링 중심 기준 각도로 계산해, 안쪽으로 말리는 궤적을 선으로 쌓는다</p>
</div>
</main>
);
}01 · 안쪽 톱니를 따라 도는 기본 스피로그래프 곡선 — 측정 누적면적 65.706% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { var t = b; b = a % b; a = t; } return a; }
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var TOTAL_T = TURNS * Math.PI * 2;
var CYCLE_SECONDS = 6;
var SPEED = TOTAL_T / CYCLE_SECONDS;
function point(t) {
var k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
02바깥으로 굴러가는 톱니가 그리는 바깥 곡선
같은 구조에서 R - r 이 R + r 로, k 도 (R + r) / r 로 바뀌고 펜 항의 부호까지 달라져, 안쪽으로 말리던 곡선이 바깥으로 꽃잎을 뻗는다. gcd(96, 36) 이 12 라서 TURNS 는 3 이고, TOOTH_UNIT 을 0.6 으로 줄여 최대 반경이 92.2 로 CALC_DIM 200 의 반폭 100 안에 들어온다. 이 장면은 누적면적 66.2%·평균 강도 26.3·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp2 is-demo" id="sp2Root" tabindex="0">
<canvas class="sp2__canvas" id="sp2Canvas" width="480" height="300"></canvas>
<p class="sp2__caption">작은 톱니가 링 바깥을 돌 때의 접점 각도를 매 프레임 다시 계산해, 안쪽 곡선과 반대로 바깥으로 뻗는 꽃잎 모양 궤적을 그린다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-yellow);
.sp2 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-yellow;
}
.sp2__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp2__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp2__caption { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp2 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffd23f;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp2 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #ffd23f;
}
.sp2__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp2__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp2__caption {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp2 {
cursor: default;
}
}(function () {
// 기법: 에피트로코이드(외접 톱니) — 톱니가 고정된 링 바깥을 미끄러지지 않고 굴러갈 때
// 펜 구멍이 그리는 좌표를 매 프레임 각도 t 로 다시 계산한다.
// x(t) = (R+r)cos(t) - d cos(((R+r)/r) t) · y(t) = (R+r)sin(t) - d sin(((R+r)/r) t)
var root = document.getElementById('sp2Root');
var canvas = document.getElementById('sp2Canvas');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var CALC_DIM = 200;
var GEAR_TEETH_OUTER = 96;
var GEAR_ROLL_TEETH = 36;
var PEN_TIP_RATIO = 0.6;
var TOOTH_UNIT = 0.6;
var SEGMENTS_PER_TURN = 240;
function gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { var t = b; b = a % b; a = t; } return a; }
var R = GEAR_TEETH_OUTER * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var g = gcd(GEAR_TEETH_OUTER, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var TOTAL_T = TURNS * Math.PI * 2;
var CYCLE_SECONDS = 6;
var SPEED = TOTAL_T / CYCLE_SECONDS;
function point(t) {
var k = (R + r) / r;
return {
x: (R + r) * Math.cos(t) - d * Math.cos(k * t),
y: (R + r) * Math.sin(t) - d * Math.sin(k * t)
};
}
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p) { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawFull(tMax) {
ctx.clearRect(0, 0, cw, ch);
var tipW = toScreen(point(tMax));
var wash = ctx.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,255,255,.60)');
wash.addColorStop(0.5, 'rgba(255,190,215,.32)');
wash.addColorStop(1, 'rgba(190,225,255,.14)');
ctx.fillStyle = wash;
ctx.fillRect(0, 0, cw, ch);
var fillSteps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var fi = 0; fi <= fillSteps; fi += 1) {
var fs = toScreen(point((fi / fillSteps) * tMax));
if (fi === 0) ctx.moveTo(fs.x, fs.y); else ctx.lineTo(fs.x, fs.y);
}
ctx.closePath();
ctx.fillStyle = 'rgba(23,20,26,.12)';
ctx.fill('evenodd');
ctx.beginPath();
ctx.strokeStyle = 'rgba(23,20,26,.16)';
ctx.lineWidth = Math.max(1, scale * 0.012);
ctx.arc(cx, cy, R * scale, 0, Math.PI * 2);
ctx.stroke();
ctx.lineWidth = Math.max(3, scale * 0.04);
ctx.strokeStyle = 'rgba(23,20,26,.92)';
ctx.lineJoin = 'round';
ctx.lineCap = 'round';
var steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var i = 0; i <= steps; i += 1) {
var t = (i / steps) * tMax;
var s = toScreen(point(t));
if (i === 0) ctx.moveTo(s.x, s.y); else ctx.lineTo(s.x, s.y);
}
ctx.stroke();
if (tMax > 0.001) {
var tip = toScreen(point(tMax));
ctx.fillStyle = 'rgba(23,20,26,1)';
ctx.beginPath();
ctx.arc(tip.x, tip.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx.fill();
}
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (reduce) root.classList.remove('is-demo');
fit();
if (reduce) {
drawFull(TOTAL_T);
} else {
var elapsed = 0.3;
var lastTs = null;
function tick(ts) {
if (lastTs === null) lastTs = ts;
var dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
var t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener('resize', function () { fit(); drawFull(elapsed * SPEED); });
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneEpitrochoidOuterRoll.module.scss";
type Pt = { x: number; y: number };
export default function SpiroSceneEpitrochoidOuterRoll() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
if (!root || !canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const CALC_DIM = 200;
const GEAR_TEETH_OUTER = 96;
const GEAR_ROLL_TEETH = 36;
const PEN_TIP_RATIO = 0.6;
const TOOTH_UNIT = 0.6;
const SEGMENTS_PER_TURN = 240;
function gcd(a: number, b: number): number {
a = Math.abs(a); b = Math.abs(b);
while (b) { const t = b; b = a % b; a = t; }
return a;
}
const R = GEAR_TEETH_OUTER * TOOTH_UNIT;
const r = GEAR_ROLL_TEETH * TOOTH_UNIT;
const d = r * PEN_TIP_RATIO;
const g = gcd(GEAR_TEETH_OUTER, GEAR_ROLL_TEETH);
const TURNS = GEAR_ROLL_TEETH / g;
const TOTAL_T = TURNS * Math.PI * 2;
const CYCLE_SECONDS = 6;
const SPEED = TOTAL_T / CYCLE_SECONDS;
function point(t: number): Pt {
const k = (R + r) / r;
return {
x: (R + r) * Math.cos(t) - d * Math.cos(k * t),
y: (R + r) * Math.sin(t) - d * Math.sin(k * t)
};
}
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p: Pt): Pt { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawFull(tMax: number) {
ctx!.clearRect(0, 0, cw, ch);
const tipW = toScreen(point(tMax));
const wash = ctx!.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,255,255,.60)');
wash.addColorStop(0.5, 'rgba(255,190,215,.32)');
wash.addColorStop(1, 'rgba(190,225,255,.14)');
ctx!.fillStyle = wash;
ctx!.fillRect(0, 0, cw, ch);
const fillSteps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx!.beginPath();
for (let fi = 0; fi <= fillSteps; fi += 1) {
const fs = toScreen(point((fi / fillSteps) * tMax));
if (fi === 0) ctx!.moveTo(fs.x, fs.y); else ctx!.lineTo(fs.x, fs.y);
}
ctx!.closePath();
ctx!.fillStyle = 'rgba(23,20,26,.12)';
ctx!.fill('evenodd');
ctx!.beginPath();
ctx!.strokeStyle = "rgba(23,20,26,.16)";
ctx!.lineWidth = Math.max(1, scale * 0.012);
ctx!.arc(cx, cy, R * scale, 0, Math.PI * 2);
ctx!.stroke();
ctx!.lineWidth = Math.max(3, scale * 0.04);
ctx!.strokeStyle = "rgba(23,20,26,.92)";
ctx!.lineJoin = "round";
ctx!.lineCap = "round";
const steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx!.beginPath();
for (let i = 0; i <= steps; i += 1) {
const t = (i / steps) * tMax;
const s = toScreen(point(t));
if (i === 0) ctx!.moveTo(s.x, s.y); else ctx!.lineTo(s.x, s.y);
}
ctx!.stroke();
if (tMax > 0.001) {
const tip = toScreen(point(tMax));
ctx!.fillStyle = "rgba(23,20,26,1)";
ctx!.beginPath();
ctx!.arc(tip.x, tip.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx!.fill();
}
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
if (reduce) root.classList.remove("is-demo");
fit();
let raf = 0;
if (reduce) {
drawFull(TOTAL_T);
} else {
let elapsed = 0.3;
let lastTs: number | null = null;
const onResize = () => { fit(); drawFull(elapsed * SPEED); };
function tick(ts: number) {
if (lastTs === null) lastTs = ts;
const dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
let t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
raf = requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp2} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp2__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp2__caption}>작은 톱니가 링 바깥을 돌 때의 접점 각도를 매 프레임 다시 계산해, 안쪽 곡선과 반대로 바깥으로 뻗는 꽃잎 모양 궤적을 그린다</p>
</div>
</main>
);
}02 · 바깥으로 굴러가는 톱니가 그리는 바깥 곡선 — 측정 누적면적 66.216% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { var t = b; b = a % b; a = t; } return a; }
var R = GEAR_TEETH_OUTER * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var g = gcd(GEAR_TEETH_OUTER, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var TOTAL_T = TURNS * Math.PI * 2;
var CYCLE_SECONDS = 6;
var SPEED = TOTAL_T / CYCLE_SECONDS;
function point(t) {
var k = (R + r) / r;
return {
x: (R + r) * Math.cos(t) - d * Math.cos(k * t),
y: (R + r) * Math.sin(t) - d * Math.sin(k * t)
};
}
03이빨 수 비율로 대칭 축 수가 정해지는 무늬
gcd(90, 24) 가 6 이라서 AXIS_COUNT 는 90 / 6 으로 15, TURN_COUNT 는 24 / 6 으로 4 가 되고, 화면 위 배지가 대칭 축 15개와 4바퀴 닫힘으로 그 값을 그대로 보여 준다. 스피로그래프 최소공배수로 풀면 90 과 24 의 최소공배수 360 을 90 으로 나눈 4 가 닫힘 바퀴 수이고 24 로 나눈 15 가 대칭 축 수다. 이 장면은 누적면적 59.4%·평균 강도 19.5·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp3 is-demo" id="sp3Root" tabindex="0">
<canvas class="sp3__canvas" id="sp3Canvas" width="480" height="300"></canvas>
<p class="sp3__badge" id="sp3Badge"></p>
<p class="sp3__caption">두 톱니 이빨 수의 최대공약수로 무늬의 꽃잎 수를 계산해, 비율이 바뀌면 대칭 축 수가 그 값에 맞춰 다시 정해지고 곡선이 닫히는 바퀴 수도 함께 바뀐다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-orange);
.sp3 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-orange;
}
.sp3__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp3__badge {
position: absolute;
left: $sp-3;
top: $sp-3;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .9);
color: $subject-ink;
font-weight: 600;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
.sp3__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp3__caption { font-size: 10px; padding: $sp-1 $sp-2; }
.sp3__badge { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp3 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ff4d1f;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp3 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #ff4d1f;
}
.sp3__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp3__badge {
position: absolute;
left: 12px;
top: 12px;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.9);
color: #17141a;
font-weight: 600;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
.sp3__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp3__caption {
font-size: 10px;
padding: 4px 8px;
}
.sp3__badge {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp3 {
cursor: default;
}
}(function () {
// 기법: 하이포트로코이드 + 최대공약수(gcd) 계산 — 링 이빨 수와 톱니 이빨 수의 gcd 로
// 꽃잎(대칭 축) 수와 곡선이 닫히기까지 도는 바퀴 수를 구해 배지에 그대로 표시한다.
var root = document.getElementById('sp3Root');
var canvas = document.getElementById('sp3Canvas');
var badge = document.getElementById('sp3Badge');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var CALC_DIM = 200;
var GEAR_RING_TEETH = 90;
var GEAR_ROLL_TEETH = 24;
var PEN_RADIUS_RATIO = 0.6;
var TOOTH_UNIT = 0.8;
var SEGMENTS_PER_TURN = 220;
function gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { var t = b; b = a % b; a = t; } return a; }
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_RADIUS_RATIO;
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var AXIS_COUNT = GEAR_RING_TEETH / g;
var TURN_COUNT = GEAR_ROLL_TEETH / g;
var TOTAL_T = TURN_COUNT * Math.PI * 2;
var CYCLE_SECONDS = 6;
var SPEED = TOTAL_T / CYCLE_SECONDS;
badge.textContent = '대칭 축 ' + AXIS_COUNT + '개 · ' + TURN_COUNT + '바퀴 닫힘';
function point(t) {
var k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p) { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawFull(tMax) {
ctx.clearRect(0, 0, cw, ch);
var tipW = toScreen(point(tMax));
var wash = ctx.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,255,255,.60)');
wash.addColorStop(0.5, 'rgba(255,225,170,.32)');
wash.addColorStop(1, 'rgba(200,190,255,.16)');
ctx.fillStyle = wash;
ctx.fillRect(0, 0, cw, ch);
var fillSteps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var fi = 0; fi <= fillSteps; fi += 1) {
var fs = toScreen(point((fi / fillSteps) * tMax));
if (fi === 0) ctx.moveTo(fs.x, fs.y); else ctx.lineTo(fs.x, fs.y);
}
ctx.closePath();
ctx.fillStyle = 'rgba(255,247,230,.18)';
ctx.fill('evenodd');
ctx.lineWidth = Math.max(3, scale * 0.04);
ctx.strokeStyle = 'rgba(255,247,230,.94)';
ctx.lineJoin = 'round';
ctx.lineCap = 'round';
var steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var i = 0; i <= steps; i += 1) {
var t = (i / steps) * tMax;
var s = toScreen(point(t));
if (i === 0) ctx.moveTo(s.x, s.y); else ctx.lineTo(s.x, s.y);
}
ctx.stroke();
if (tMax > 0.001) {
var tip = toScreen(point(tMax));
ctx.fillStyle = 'rgba(255,247,230,1)';
ctx.beginPath();
ctx.arc(tip.x, tip.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx.fill();
}
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (reduce) root.classList.remove('is-demo');
fit();
if (reduce) {
drawFull(TOTAL_T);
} else {
var elapsed = 0.3;
var lastTs = null;
function tick(ts) {
if (lastTs === null) lastTs = ts;
var dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
var t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener('resize', function () { fit(); drawFull(elapsed * SPEED); });
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneToothRatioSymmetry.module.scss";
type Pt = { x: number; y: number };
export default function SpiroSceneToothRatioSymmetry() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
const badgeRef = useRef<HTMLParagraphElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
const badge = badgeRef.current;
if (!root || !canvas || !badge) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const CALC_DIM = 200;
const GEAR_RING_TEETH = 90;
const GEAR_ROLL_TEETH = 24;
const PEN_RADIUS_RATIO = 0.6;
const TOOTH_UNIT = 0.8;
const SEGMENTS_PER_TURN = 220;
function gcd(a: number, b: number): number {
a = Math.abs(a); b = Math.abs(b);
while (b) { const t = b; b = a % b; a = t; }
return a;
}
const R = GEAR_RING_TEETH * TOOTH_UNIT;
const r = GEAR_ROLL_TEETH * TOOTH_UNIT;
const d = r * PEN_RADIUS_RATIO;
const g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
const AXIS_COUNT = GEAR_RING_TEETH / g;
const TURN_COUNT = GEAR_ROLL_TEETH / g;
const TOTAL_T = TURN_COUNT * Math.PI * 2;
const CYCLE_SECONDS = 6;
const SPEED = TOTAL_T / CYCLE_SECONDS;
badge.textContent = "대칭 축 " + AXIS_COUNT + "개 · " + TURN_COUNT + "바퀴 닫힘";
function point(t: number): Pt {
const k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p: Pt): Pt { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawFull(tMax: number) {
ctx!.clearRect(0, 0, cw, ch);
const tipW = toScreen(point(tMax));
const wash = ctx!.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,255,255,.60)');
wash.addColorStop(0.5, 'rgba(255,225,170,.32)');
wash.addColorStop(1, 'rgba(200,190,255,.16)');
ctx!.fillStyle = wash;
ctx!.fillRect(0, 0, cw, ch);
const fillSteps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx!.beginPath();
for (let fi = 0; fi <= fillSteps; fi += 1) {
const fs = toScreen(point((fi / fillSteps) * tMax));
if (fi === 0) ctx!.moveTo(fs.x, fs.y); else ctx!.lineTo(fs.x, fs.y);
}
ctx!.closePath();
ctx!.fillStyle = 'rgba(255,247,230,.18)';
ctx!.fill('evenodd');
ctx!.lineWidth = Math.max(3, scale * 0.04);
ctx!.strokeStyle = "rgba(255,247,230,.94)";
ctx!.lineJoin = "round";
ctx!.lineCap = "round";
const steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx!.beginPath();
for (let i = 0; i <= steps; i += 1) {
const t = (i / steps) * tMax;
const s = toScreen(point(t));
if (i === 0) ctx!.moveTo(s.x, s.y); else ctx!.lineTo(s.x, s.y);
}
ctx!.stroke();
if (tMax > 0.001) {
const tip = toScreen(point(tMax));
ctx!.fillStyle = "rgba(255,247,230,1)";
ctx!.beginPath();
ctx!.arc(tip.x, tip.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx!.fill();
}
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
if (reduce) root.classList.remove("is-demo");
fit();
let raf = 0;
if (reduce) {
drawFull(TOTAL_T);
} else {
let elapsed = 0.3;
let lastTs: number | null = null;
const onResize = () => { fit(); drawFull(elapsed * SPEED); };
function tick(ts: number) {
if (lastTs === null) lastTs = ts;
const dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
let t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
raf = requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp3} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp3__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp3__badge} ref={badgeRef} />
<p className={styles.sp3__caption}>두 톱니 이빨 수의 최대공약수로 무늬의 꽃잎 수를 계산해, 비율이 바뀌면 대칭 축 수가 그 값에 맞춰 다시 정해지고 곡선이 닫히는 바퀴 수도 함께 바뀐다</p>
</div>
</main>
);
}03 · 이빨 수 비율로 대칭 축 수가 정해지는 무늬 — 측정 누적면적 59.435% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { var t = b; b = a % b; a = t; } return a; }
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_RADIUS_RATIO;
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var AXIS_COUNT = GEAR_RING_TEETH / g;
var TURN_COUNT = GEAR_ROLL_TEETH / g;
var TOTAL_T = TURN_COUNT * Math.PI * 2;
var CYCLE_SECONDS = 6;
var SPEED = TOTAL_T / CYCLE_SECONDS;
badge.textContent = '대칭 축 ' + AXIS_COUNT + '개 · ' + TURN_COUNT + '바퀴 닫힘';
function point(t) {
var k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
04구멍 여러 개가 동시에 그리는 파스텔 톱니 무늬
PEN_RATIOS 네 값(0.35·0.5·0.65·0.8)이 같은 톱니의 펜 구멍 네 곳이 되어 drawPen(idx, tMax) 에서 각자 d = r * PEN_RATIOS[idx] 로 좌표를 따로 계산하고, 색은 PEN_COLORS 에서 하나씩 받는다. 시작 각도는 seedRand(43304) 로 고정한 PEN_PHASE 가 펜마다 다르게 밀어서 네 곡선이 겹치되 포개지지는 않는다. 이 장면은 누적면적 10.1%·평균 강도 38.2·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp4 is-demo" id="sp4Root" tabindex="0">
<canvas class="sp4__canvas" id="sp4Canvas" width="480" height="300"></canvas>
<p class="sp4__caption">같은 톱니의 펜 구멍 여러 개에 저마다 다른 색을 배정하고 각 구멍의 좌표를 따로 계산해, 한 번의 회전으로 색이 어긋나 겹치는 여러 겹의 무늬를 동시에 그린다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.sp4 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-paper;
}
.sp4__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp4__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp4__caption { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp4 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp4 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #ffffff;
}
.sp4__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp4__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp4__caption {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp4 {
cursor: default;
}
}(function () {
// 기법: 같은 링·톱니 조합에서 펜 구멍마다 반지름 비율(d)과 시작 위상을 달리해
// 좌표를 따로 계산한다. 위상은 seedRand(결정적 LCG) 로 고정해 매번 같은 그림이 나온다.
var root = document.getElementById('sp4Root');
var canvas = document.getElementById('sp4Canvas');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
function seedRand(seed) {
var s = seed >>> 0;
return function () { s = (s * 1664525 + 1013904223) >>> 0; return s / 4294967296; };
}
var CALC_DIM = 200;
var GEAR_RING_TEETH = 78;
var GEAR_ROLL_TEETH = 21;
var TOOTH_UNIT = 0.7;
var SEGMENTS_PER_TURN = 260;
var PEN_RATIOS = [0.35, 0.5, 0.65, 0.8];
var PEN_COLORS = ['rgba(230,90,120,.85)', 'rgba(50,175,135,.85)', 'rgba(70,130,230,.85)', 'rgba(228,150,45,.85)'];
function gcd(a, b) { a = Math.abs(a); b = Math.abs(b); while (b) { var t = b; b = a % b; a = t; } return a; }
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var TOTAL_T = TURNS * Math.PI * 2;
var CYCLE_SECONDS = 7;
var SPEED = TOTAL_T / CYCLE_SECONDS;
var phaseRand = seedRand(43304);
var PEN_PHASE = PEN_RATIOS.map(function () { return phaseRand() * Math.PI * 2; });
function point(t, d) {
var k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p) { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawPen(idx, tMax) {
var d = r * PEN_RATIOS[idx];
var phase = PEN_PHASE[idx];
ctx.strokeStyle = PEN_COLORS[idx];
ctx.lineWidth = Math.max(2.4, scale * 0.032);
ctx.lineJoin = 'round';
ctx.lineCap = 'round';
var steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var i = 0; i <= steps; i += 1) {
var t = (i / steps) * tMax;
var s = toScreen(point(t + phase, d));
if (i === 0) ctx.moveTo(s.x, s.y); else ctx.lineTo(s.x, s.y);
}
ctx.stroke();
ctx.save();
ctx.fillStyle = PEN_COLORS[idx].replace('.85', '.13');
ctx.fill('evenodd');
ctx.restore();
if (tMax > 0.001) {
var tip = toScreen(point(tMax + phase, d));
ctx.fillStyle = PEN_COLORS[idx];
ctx.beginPath();
ctx.arc(tip.x, tip.y, Math.max(2.6, scale * 0.042), 0, Math.PI * 2);
ctx.fill();
}
}
function drawFull(tMax) {
ctx.clearRect(0, 0, cw, ch);
var tipW = toScreen(point(tMax + PEN_PHASE[0], r * PEN_RATIOS[0]));
var wash = ctx.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,200,215,.55)');
wash.addColorStop(0.5, 'rgba(190,225,255,.32)');
wash.addColorStop(1, 'rgba(200,240,215,.16)');
ctx.fillStyle = wash;
ctx.fillRect(0, 0, cw, ch);
for (var i = 0; i < PEN_RATIOS.length; i += 1) drawPen(i, tMax);
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (reduce) root.classList.remove('is-demo');
fit();
if (reduce) {
drawFull(TOTAL_T);
} else {
var elapsed = 0.3;
var lastTs = null;
function tick(ts) {
if (lastTs === null) lastTs = ts;
var dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
var t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener('resize', function () { fit(); drawFull(elapsed * SPEED); });
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneMultiPenRainbow.module.scss";
type Pt = { x: number; y: number };
export default function SpiroSceneMultiPenRainbow() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
if (!root || !canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
function seedRand(seed: number) {
let s = seed >>> 0;
return function () { s = (s * 1664525 + 1013904223) >>> 0; return s / 4294967296; };
}
const CALC_DIM = 200;
const GEAR_RING_TEETH = 78;
const GEAR_ROLL_TEETH = 21;
const TOOTH_UNIT = 0.7;
const SEGMENTS_PER_TURN = 260;
const PEN_RATIOS = [0.35, 0.5, 0.65, 0.8];
const PEN_COLORS = ["rgba(230,90,120,.85)", "rgba(50,175,135,.85)", "rgba(70,130,230,.85)", "rgba(228,150,45,.85)"];
function gcd(a: number, b: number): number {
a = Math.abs(a); b = Math.abs(b);
while (b) { const t = b; b = a % b; a = t; }
return a;
}
const R = GEAR_RING_TEETH * TOOTH_UNIT;
const r = GEAR_ROLL_TEETH * TOOTH_UNIT;
const g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
const TURNS = GEAR_ROLL_TEETH / g;
const TOTAL_T = TURNS * Math.PI * 2;
const CYCLE_SECONDS = 7;
const SPEED = TOTAL_T / CYCLE_SECONDS;
const phaseRand = seedRand(43304);
const PEN_PHASE = PEN_RATIOS.map(function () { return phaseRand() * Math.PI * 2; });
function point(t: number, d: number): Pt {
const k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p: Pt): Pt { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
function drawPen(idx: number, tMax: number) {
const d = r * PEN_RATIOS[idx];
const phase = PEN_PHASE[idx];
ctx!.strokeStyle = PEN_COLORS[idx];
ctx!.lineWidth = Math.max(2.4, scale * 0.032);
ctx!.lineJoin = "round";
ctx!.lineCap = "round";
const steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx!.beginPath();
for (let i = 0; i <= steps; i += 1) {
const t = (i / steps) * tMax;
const s = toScreen(point(t + phase, d));
if (i === 0) ctx!.moveTo(s.x, s.y); else ctx!.lineTo(s.x, s.y);
}
ctx!.stroke();
ctx!.save();
ctx!.fillStyle = PEN_COLORS[idx].replace('.85', '.13');
ctx!.fill('evenodd');
ctx!.restore();
if (tMax > 0.001) {
const tip = toScreen(point(tMax + phase, d));
ctx!.fillStyle = PEN_COLORS[idx];
ctx!.beginPath();
ctx!.arc(tip.x, tip.y, Math.max(2.6, scale * 0.042), 0, Math.PI * 2);
ctx!.fill();
}
}
function drawFull(tMax: number) {
ctx!.clearRect(0, 0, cw, ch);
const tipW = toScreen(point(tMax + PEN_PHASE[0], r * PEN_RATIOS[0]));
const wash = ctx!.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,200,215,.55)');
wash.addColorStop(0.5, 'rgba(190,225,255,.32)');
wash.addColorStop(1, 'rgba(200,240,215,.16)');
ctx!.fillStyle = wash;
ctx!.fillRect(0, 0, cw, ch);
for (let i = 0; i < PEN_RATIOS.length; i += 1) drawPen(i, tMax);
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
if (reduce) root.classList.remove("is-demo");
fit();
let raf = 0;
if (reduce) {
drawFull(TOTAL_T);
} else {
let elapsed = 0.3;
let lastTs: number | null = null;
const onResize = () => { fit(); drawFull(elapsed * SPEED); };
function tick(ts: number) {
if (lastTs === null) lastTs = ts;
const dt = Math.min(ts - lastTs, 48);
lastTs = ts;
elapsed += dt / 1000;
let t = elapsed * SPEED;
if (t > TOTAL_T) { elapsed = 0; t = 0; }
drawFull(t);
raf = requestAnimationFrame(tick);
}
drawFull(elapsed * SPEED);
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp4} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp4__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp4__caption}>같은 톱니의 펜 구멍 여러 개에 저마다 다른 색을 배정하고 각 구멍의 좌표를 따로 계산해, 한 번의 회전으로 색이 어긋나 겹치는 여러 겹의 무늬를 동시에 그린다</p>
</div>
</main>
);
}04 · 구멍 여러 개가 동시에 그리는 무지개 톱니 무늬 — 측정 누적면적 10.149% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function drawPen(idx, tMax) {
var d = r * PEN_RATIOS[idx];
var phase = PEN_PHASE[idx];
ctx.strokeStyle = PEN_COLORS[idx];
ctx.lineWidth = Math.max(2.4, scale * 0.032);
ctx.lineJoin = 'round';
ctx.lineCap = 'round';
var steps = Math.max(2, Math.round((tMax / (Math.PI * 2)) * SEGMENTS_PER_TURN));
ctx.beginPath();
for (var i = 0; i <= steps; i += 1) {
var t = (i / steps) * tMax;
var s = toScreen(point(t + phase, d));
if (i === 0) ctx.moveTo(s.x, s.y); else ctx.lineTo(s.x, s.y);
}
ctx.stroke();
ctx.save();
ctx.fillStyle = PEN_COLORS[idx].replace('.85', '.13');
ctx.fill('evenodd');
ctx.restore();
05궤적이 서서히 사라지며 계속 그리는 장면
simStep() 이 프레임마다 배경색 사각형을 FADE_ALPHA 만큼 덮어 지난 선을 옅게 만든 다음, 이전 점 prev 에서 새 점까지 선 한 토막만 새로 긋는다. FADE_ALPHA 는 3.0 / TRAIL_FADE_FRAMES 이므로 240 일 때 0.0125 이고, 곡선 전체를 다시 계산하지 않고도 궤적이 서서히 사라진다. 이 장면은 누적면적 49.9%·평균 강도 18.8·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp5 is-demo" id="sp5Root" tabindex="0">
<canvas class="sp5__canvas" id="sp5Canvas" width="480" height="300"></canvas>
<p class="sp5__caption">지난 프레임의 선을 프레임마다 조금씩 투명하게 덮어쓰고 새 궤적을 맨 앞에 얹어, 펜이 지나간 자리가 시간에 따라 옅어지는 그리기 장면을 만든다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-ink);
.sp5 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-ink;
}
.sp5__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp5__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp5__caption { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp5 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #17141a;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp5 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #17141a;
}
.sp5__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp5__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp5__caption {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp5 {
cursor: default;
}
}(function () {
// 기법: 고정 시간 스텝(STEP_MS)마다 캔버스 전체를 반투명 무대색으로 덮어써 지난 궤적을
// 서서히 지우고, 그 위에 새 구간만 불투명하게 얹는다. TRAIL_FADE_FRAMES 스텝이 지나면
// 한 지점의 흔적이 실질적으로 사라지도록 감쇠 알파를 그 값에서 역산한다.
var root = document.getElementById('sp5Root');
var canvas = document.getElementById('sp5Canvas');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var CALC_DIM = 200;
var GEAR_RING_TEETH = 54;
var GEAR_ROLL_TEETH = 20;
var PEN_TIP_RATIO = 0.6;
var TOOTH_UNIT = 0.9;
var TRAIL_FADE_FRAMES = 240;
var STEP_MS = 1000 / 60;
var ANGLE_SPEED = 4.2;
var FADE_ALPHA = Math.min(1, 3.0 / TRAIL_FADE_FRAMES);
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
function point(t) {
var k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p) { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
var t = 0;
var prev = null;
function resetCanvas() {
ctx.fillStyle = '#17141a';
ctx.fillRect(0, 0, cw, ch);
prev = toScreen(point(t));
}
function simStep() {
ctx.fillStyle = 'rgba(23,20,26,' + FADE_ALPHA + ')';
ctx.fillRect(0, 0, cw, ch);
t += ANGLE_SPEED * (STEP_MS / 1000);
var p = toScreen(point(t));
ctx.strokeStyle = 'rgba(255,247,230,.95)';
ctx.shadowColor = 'rgba(255,214,200,.7)';
ctx.shadowBlur = Math.max(8, scale * 0.14);
ctx.lineWidth = Math.max(3, scale * 0.045);
ctx.lineJoin = 'round';
ctx.lineCap = 'round';
ctx.beginPath();
ctx.moveTo(prev.x, prev.y);
ctx.lineTo(p.x, p.y);
ctx.stroke();
ctx.shadowBlur = 0;
var halo = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, Math.max(cw, ch) * 0.34);
halo.addColorStop(0, 'rgba(255,200,215,.075)');
halo.addColorStop(0.5, 'rgba(190,225,255,.04)');
halo.addColorStop(1, 'rgba(190,225,255,0)');
ctx.fillStyle = halo;
ctx.fillRect(0, 0, cw, ch);
prev = p;
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (reduce) root.classList.remove('is-demo');
fit();
resetCanvas();
if (reduce) {
var warm = TRAIL_FADE_FRAMES * 2.4;
for (var w = 0; w < warm; w += 1) simStep();
} else {
var acc = 0;
var lastTs = null;
function tick(ts) {
if (lastTs === null) lastTs = ts;
var dt = Math.min(ts - lastTs, 48);
lastTs = ts;
acc += dt;
var guard = 0;
while (acc >= STEP_MS && guard < 6) {
simStep();
acc -= STEP_MS;
guard += 1;
}
requestAnimationFrame(tick);
}
window.addEventListener('resize', function () { fit(); resetCanvas(); });
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneTrailFadeDraw.module.scss";
type Pt = { x: number; y: number };
export default function SpiroSceneTrailFadeDraw() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
if (!root || !canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const CALC_DIM = 200;
const GEAR_RING_TEETH = 54;
const GEAR_ROLL_TEETH = 20;
const PEN_TIP_RATIO = 0.6;
const TOOTH_UNIT = 0.9;
const TRAIL_FADE_FRAMES = 240;
const STEP_MS = 1000 / 60;
const ANGLE_SPEED = 4.2;
const FADE_ALPHA = Math.min(1, 3.0 / TRAIL_FADE_FRAMES);
const R = GEAR_RING_TEETH * TOOTH_UNIT;
const r = GEAR_ROLL_TEETH * TOOTH_UNIT;
const d = r * PEN_TIP_RATIO;
function point(t: number): Pt {
const k = (R - r) / r;
return {
x: (R - r) * Math.cos(t) + d * Math.cos(k * t),
y: (R - r) * Math.sin(t) - d * Math.sin(k * t)
};
}
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.92;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p: Pt): Pt { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
let t = 0;
let prev: Pt = { x: cx, y: cy };
function resetCanvas() {
ctx!.fillStyle = "#17141a";
ctx!.fillRect(0, 0, cw, ch);
prev = toScreen(point(t));
}
function simStep() {
ctx!.fillStyle = "rgba(23,20,26," + FADE_ALPHA + ")";
ctx!.fillRect(0, 0, cw, ch);
t += ANGLE_SPEED * (STEP_MS / 1000);
const p = toScreen(point(t));
ctx!.strokeStyle = "rgba(255,247,230,.95)";
ctx!.shadowColor = 'rgba(255,214,200,.7)';
ctx!.shadowBlur = Math.max(8, scale * 0.14);
ctx!.lineWidth = Math.max(3, scale * 0.045);
ctx!.lineJoin = "round";
ctx!.lineCap = "round";
ctx!.beginPath();
ctx!.moveTo(prev.x, prev.y);
ctx!.lineTo(p.x, p.y);
ctx!.stroke();
ctx!.shadowBlur = 0;
const halo = ctx!.createRadialGradient(p.x, p.y, 0, p.x, p.y, Math.max(cw, ch) * 0.34);
halo.addColorStop(0, 'rgba(255,200,215,.075)');
halo.addColorStop(0.5, 'rgba(190,225,255,.04)');
halo.addColorStop(1, 'rgba(190,225,255,0)');
ctx!.fillStyle = halo;
ctx!.fillRect(0, 0, cw, ch);
prev = p;
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
if (reduce) root.classList.remove("is-demo");
fit();
resetCanvas();
let raf = 0;
if (reduce) {
const warm = TRAIL_FADE_FRAMES * 2.4;
for (let w = 0; w < warm; w += 1) simStep();
} else {
let acc = 0;
let lastTs: number | null = null;
const onResize = () => { fit(); resetCanvas(); };
function tick(ts: number) {
if (lastTs === null) lastTs = ts;
const dt = Math.min(ts - lastTs, 48);
lastTs = ts;
acc += dt;
let guard = 0;
while (acc >= STEP_MS && guard < 6) {
simStep();
acc -= STEP_MS;
guard += 1;
}
raf = requestAnimationFrame(tick);
}
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp5} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp5__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp5__caption}>지난 프레임의 선을 프레임마다 조금씩 투명하게 덮어쓰고 새 궤적을 맨 앞에 얹어, 펜이 지나간 자리가 시간에 따라 옅어지는 그리기 장면을 만든다</p>
</div>
</main>
);
}05 · 궤적이 서서히 사라지며 계속 그리는 장면 — 측정 누적면적 49.931% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function simStep() {
ctx.fillStyle = 'rgba(23,20,26,' + FADE_ALPHA + ')';
ctx.fillRect(0, 0, cw, ch);
t += ANGLE_SPEED * (STEP_MS / 1000);
var p = toScreen(point(t));
ctx.strokeStyle = 'rgba(255,247,230,.95)';
ctx.shadowColor = 'rgba(255,214,200,.7)';
ctx.shadowBlur = Math.max(8, scale * 0.14);
ctx.lineWidth = Math.max(3, scale * 0.045);
ctx.lineJoin = 'round';
ctx.lineCap = 'round';
ctx.beginPath();
ctx.moveTo(prev.x, prev.y);
ctx.lineTo(p.x, p.y);
ctx.stroke();
ctx.shadowBlur = 0;
var halo = ctx.createRadialGradient(p.x, p.y, 0, p.x, p.y, Math.max(cw, ch) * 0.34);
halo.addColorStop(0, 'rgba(255,200,215,.075)');
halo.addColorStop(0.5, 'rgba(190,225,255,.04)');
halo.addColorStop(1, 'rgba(190,225,255,0)');
ctx.fillStyle = halo;
ctx.fillRect(0, 0, cw, ch);
prev = p;
}
06톱니와 펜이 곡선 위에 같이 보이는 가이드
penAt(t) 가 펜 끝을, rollCenterAt(t) 가 굴러가는 톱니의 중심을 같은 각도 t 로 돌려주어, 톱니 원과 중심에서 펜까지 잇는 선이 곡선 위에 함께 그려진다. gcd(60, 24) 가 12 라서 TURNS 는 2, AXIS_COUNT 는 5 이고, HOLD_FRACTION 0.84 지점에서 곡선이 완성되어 잠시 멈춘다. 이 장면은 누적면적 59.2%·평균 강도 62.8·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp6 is-demo" id="sp6Root" tabindex="0">
<canvas class="sp6__canvas" id="sp6Canvas" width="480" height="300"></canvas>
<p class="sp6__badge" id="sp6Badge"></p>
<p class="sp6__caption">굴러가는 톱니바퀴와 펜 위치를 곡선 위에 함께 그려 지금의 각도와 접점을 계속 보여주고, 톱니가 도는 방향과 궤적이 이어지는 관계를 한눈에 따라갈 수 있게 한다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-yellow);
.sp6 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-yellow;
}
.sp6__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp6__badge {
position: absolute;
left: $sp-3;
top: $sp-3;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
.sp6__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp6__caption, .sp6__badge { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp6 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffd23f;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp6 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #ffd23f;
}
.sp6__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp6__badge {
position: absolute;
left: 12px;
top: 12px;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
.sp6__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp6__caption, .sp6__badge {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp6 {
cursor: default;
}
}(function () {
// 기법: 링 톱니·구름 톱니 두 원과 펜 스포크를 매 프레임 현재 각도로 다시 그려,
// 곡선이 자라나는 동안에도 "지금 어디를 굴러가는지"가 항상 화면에 남아 있게 한다.
var root = document.getElementById('sp6Root');
var canvas = document.getElementById('sp6Canvas');
var badge = document.getElementById('sp6Badge');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var CALC_DIM = 200;
var GEAR_RING_TEETH = 60;
var GEAR_ROLL_TEETH = 24;
var PEN_TIP_RATIO = 0.62;
var TOOTH_UNIT = 1.3;
var SEGMENTS_PER_TURN = 200;
var CYCLE_SECONDS = 6;
var HOLD_FRACTION = 0.84;
function gcd(a, b) { while (b) { var t = b; b = a % b; a = t; } return a; }
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var AXIS_COUNT = GEAR_RING_TEETH / g;
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var K = (R - r) / r;
function penAt(t) {
return {
x: (R - r) * Math.cos(t) + d * Math.cos(K * t),
y: (R - r) * Math.sin(t) - d * Math.sin(K * t)
};
}
function rollCenterAt(t) {
return { x: (R - r) * Math.cos(t), y: (R - r) * Math.sin(t) };
}
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.82;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p) { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
var maxT = 2 * Math.PI * TURNS;
var dtSample = (2 * Math.PI) / SEGMENTS_PER_TURN;
function render(progress) {
var t = maxT * Math.min(progress / HOLD_FRACTION, 1);
ctx.fillStyle = '#ffd23f';
ctx.fillRect(0, 0, cw, ch);
var tipW = toScreen(penAt(t));
var wash = ctx.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,255,255,.62)');
wash.addColorStop(0.5, 'rgba(255,190,215,.32)');
wash.addColorStop(1, 'rgba(190,225,255,.14)');
ctx.fillStyle = wash;
ctx.fillRect(0, 0, cw, ch);
var rcW = toScreen(rollCenterAt(t));
ctx.beginPath();
ctx.arc(rcW.x, rcW.y, r * scale, 0, Math.PI * 2);
ctx.fillStyle = 'rgba(190,225,255,.38)';
ctx.fill();
var ringCenter = toScreen({ x: 0, y: 0 });
ctx.beginPath();
ctx.arc(ringCenter.x, ringCenter.y, R * scale, 0, Math.PI * 2);
ctx.strokeStyle = 'rgba(23,20,26,.22)';
ctx.lineWidth = Math.max(1.4, scale * 0.02);
ctx.stroke();
ctx.beginPath();
var first = true;
for (var tt = 0; tt <= t; tt += dtSample) {
var p = toScreen(penAt(tt));
if (first) { ctx.moveTo(p.x, p.y); first = false; } else { ctx.lineTo(p.x, p.y); }
}
ctx.save();
ctx.fillStyle = 'rgba(23,20,26,.10)';
ctx.fill('evenodd');
ctx.restore();
ctx.strokeStyle = 'rgba(23,20,26,.9)';
ctx.lineWidth = Math.max(3, scale * 0.04);
ctx.lineJoin = 'round'; ctx.lineCap = 'round';
ctx.stroke();
var rc = rollCenterAt(t);
var rcS = toScreen(rc);
ctx.beginPath();
ctx.arc(rcS.x, rcS.y, r * scale, 0, Math.PI * 2);
ctx.strokeStyle = 'rgba(10,79,232,.75)';
ctx.lineWidth = Math.max(1.6, scale * 0.024);
ctx.stroke();
var pen = toScreen(penAt(t));
ctx.beginPath();
ctx.moveTo(rcS.x, rcS.y);
ctx.lineTo(pen.x, pen.y);
ctx.strokeStyle = 'rgba(10,79,232,.75)';
ctx.lineWidth = Math.max(1.4, scale * 0.018);
ctx.stroke();
ctx.beginPath();
ctx.arc(pen.x, pen.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx.fillStyle = 'rgba(23,20,26,.92)';
ctx.fill();
var deg = Math.round((((t * 180 / Math.PI) % 360) + 360) % 360);
badge.textContent = '접점 각도 ' + deg + '° · 대칭 축 ' + AXIS_COUNT + '개';
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
fit();
if (reduce) {
root.classList.remove('is-demo');
render(HOLD_FRACTION);
} else {
var startTs = null;
function tick(ts) {
if (startTs === null) startTs = ts;
var elapsed = (ts - startTs) / 1000;
var progress = (elapsed % CYCLE_SECONDS) / CYCLE_SECONDS;
render(progress);
requestAnimationFrame(tick);
}
window.addEventListener('resize', function () { fit(); });
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneGearVisualGuide.module.scss";
type Pt = { x: number; y: number };
export default function SpiroSceneGearVisualGuide() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
const badgeRef = useRef<HTMLParagraphElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
const badge = badgeRef.current;
if (!root || !canvas || !badge) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const CALC_DIM = 200;
const GEAR_RING_TEETH = 60;
const GEAR_ROLL_TEETH = 24;
const PEN_TIP_RATIO = 0.62;
const TOOTH_UNIT = 1.3;
const SEGMENTS_PER_TURN = 200;
const CYCLE_SECONDS = 6;
const HOLD_FRACTION = 0.84;
function gcd(a: number, b: number): number { while (b) { const t = b; b = a % b; a = t; } return a; }
const g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
const TURNS = GEAR_ROLL_TEETH / g;
const AXIS_COUNT = GEAR_RING_TEETH / g;
const R = GEAR_RING_TEETH * TOOTH_UNIT;
const r = GEAR_ROLL_TEETH * TOOTH_UNIT;
const d = r * PEN_TIP_RATIO;
const K = (R - r) / r;
function penAt(t: number): Pt {
return {
x: (R - r) * Math.cos(t) + d * Math.cos(K * t),
y: (R - r) * Math.sin(t) - d * Math.sin(K * t)
};
}
function rollCenterAt(t: number): Pt {
return { x: (R - r) * Math.cos(t), y: (R - r) * Math.sin(t) };
}
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.82;
cx = cw / 2; cy = ch / 2;
}
function toScreen(p: Pt): Pt { return { x: cx + p.x * scale, y: cy + p.y * scale }; }
const maxT = 2 * Math.PI * TURNS;
const dtSample = (2 * Math.PI) / SEGMENTS_PER_TURN;
function render(progress: number) {
const t = maxT * Math.min(progress / HOLD_FRACTION, 1);
ctx!.fillStyle = "#ffd23f";
ctx!.fillRect(0, 0, cw, ch);
const tipW = toScreen(penAt(t));
const wash = ctx!.createRadialGradient(tipW.x, tipW.y, 0, tipW.x, tipW.y, Math.max(cw, ch) * 0.9);
wash.addColorStop(0, 'rgba(255,255,255,.62)');
wash.addColorStop(0.5, 'rgba(255,190,215,.32)');
wash.addColorStop(1, 'rgba(190,225,255,.14)');
ctx!.fillStyle = wash;
ctx!.fillRect(0, 0, cw, ch);
const rcW = toScreen(rollCenterAt(t));
ctx!.beginPath();
ctx!.arc(rcW.x, rcW.y, r * scale, 0, Math.PI * 2);
ctx!.fillStyle = 'rgba(190,225,255,.38)';
ctx!.fill();
const ringCenter = toScreen({ x: 0, y: 0 });
ctx!.beginPath();
ctx!.arc(ringCenter.x, ringCenter.y, R * scale, 0, Math.PI * 2);
ctx!.strokeStyle = "rgba(23,20,26,.22)";
ctx!.lineWidth = Math.max(1.4, scale * 0.02);
ctx!.stroke();
ctx!.beginPath();
let first = true;
for (let tt = 0; tt <= t; tt += dtSample) {
const p = toScreen(penAt(tt));
if (first) { ctx!.moveTo(p.x, p.y); first = false; } else { ctx!.lineTo(p.x, p.y); }
}
ctx!.save();
ctx!.fillStyle = "rgba(23,20,26,.10)";
ctx!.fill("evenodd");
ctx!.restore();
ctx!.strokeStyle = "rgba(23,20,26,.9)";
ctx!.lineWidth = Math.max(3, scale * 0.04);
ctx!.lineJoin = "round"; ctx!.lineCap = "round";
ctx!.stroke();
const rc = rollCenterAt(t);
const rcS = toScreen(rc);
ctx!.beginPath();
ctx!.arc(rcS.x, rcS.y, r * scale, 0, Math.PI * 2);
ctx!.strokeStyle = "rgba(10,79,232,.75)";
ctx!.lineWidth = Math.max(1.6, scale * 0.024);
ctx!.stroke();
const pen = toScreen(penAt(t));
ctx!.beginPath();
ctx!.moveTo(rcS.x, rcS.y);
ctx!.lineTo(pen.x, pen.y);
ctx!.strokeStyle = "rgba(10,79,232,.75)";
ctx!.lineWidth = Math.max(1.4, scale * 0.018);
ctx!.stroke();
ctx!.beginPath();
ctx!.arc(pen.x, pen.y, Math.max(3, scale * 0.05), 0, Math.PI * 2);
ctx!.fillStyle = "rgba(23,20,26,.92)";
ctx!.fill();
const deg = Math.round((((t * 180 / Math.PI) % 360) + 360) % 360);
badge!.textContent = "접점 각도 " + deg + "° · 대칭 축 " + AXIS_COUNT + "개";
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
fit();
let raf = 0;
if (reduce) {
root.classList.remove("is-demo");
render(HOLD_FRACTION);
} else {
let startTs: number | null = null;
const onResize = () => { fit(); };
function tick(ts: number) {
if (startTs === null) startTs = ts;
const elapsed = (ts - startTs) / 1000;
const progress = (elapsed % CYCLE_SECONDS) / CYCLE_SECONDS;
render(progress);
raf = requestAnimationFrame(tick);
}
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp6} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp6__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp6__badge} ref={badgeRef} />
<p className={styles.sp6__caption}>굴러가는 톱니바퀴와 펜 위치를 곡선 위에 함께 그려 지금의 각도와 접점을 계속 보여주고, 톱니가 도는 방향과 궤적이 이어지는 관계를 한눈에 따라갈 수 있게 한다</p>
</div>
</main>
);
}06 · 톱니와 펜이 곡선 위에 같이 보이는 가이드 — 측정 누적면적 59.176% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function gcd(a, b) { while (b) { var t = b; b = a % b; a = t; } return a; }
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var AXIS_COUNT = GEAR_RING_TEETH / g;
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var K = (R - r) / r;
function penAt(t) {
return {
x: (R - r) * Math.cos(t) + d * Math.cos(K * t),
y: (R - r) * Math.sin(t) - d * Math.sin(K * t)
};
}
function rollCenterAt(t) {
return { x: (R - r) * Math.cos(t), y: (R - r) * Math.sin(t) };
}
07포인터 거리로 이빨 비율이 바뀌는 무늬
포인터와 화면 중심 사이 거리를 POINTER_MAX_DIST 90 으로 나눈 값이 rebuildForRatio() 로 들어가 굴러가는 톱니 이빨 수를 14 에서 34 사이 정수로 정하고, 값이 바뀔 때만 computePath() 가 곡선 점 배열을 새로 만든다. 포인터가 없어도 방향키 왼쪽·오른쪽이 KEY_STEP 0.08 씩 같은 비율을 움직이므로 키보드만으로도 무늬가 바뀐다. 이 장면은 누적면적 11.3%·평균 강도 103.6·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp7 is-demo" id="sp7Root" tabindex="0">
<canvas class="sp7__canvas" id="sp7Canvas" width="480" height="300"></canvas>
<p class="sp7__hint" id="sp7Hint">← →</p>
<p class="sp7__caption">포인터가 화면 중심에서 멀어지는 만큼 톱니 이빨 수 값을 다시 계산해, 포인터를 움직이는 동안 무늬의 꽃잎 수와 촘촘함이 그 값에 따라 함께 바뀐다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-orange);
.sp7 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-orange;
outline: none;
cursor: crosshair;
}
.sp7__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp7__hint {
position: absolute;
right: $sp-3;
top: $sp-3;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
.sp7__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp7__caption, .sp7__hint { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp7 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ff4d1f;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp7 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #ff4d1f;
outline: none;
cursor: crosshair;
}
.sp7__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp7__hint {
position: absolute;
right: 12px;
top: 12px;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
.sp7__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp7__caption, .sp7__hint {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp7 {
cursor: default;
}
}(function () {
// 기법: 포인터·화살표 키가 공유하는 하나의 handlePointer(비율)로 톱니 수를 다시 계산해
// 패턴 전체를 즉시 다시 그린다. 자동 시연도 가상 좌표를 만들어 같은 함수를 부른다.
var root = document.getElementById('sp7Root');
var canvas = document.getElementById('sp7Canvas');
var hint = document.getElementById('sp7Hint');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var CALC_DIM = 200;
var RING_TEETH = 60;
var ROLL_TEETH_MIN = 14;
var ROLL_TEETH_MAX = 34;
var PEN_TIP_RATIO = 0.6;
var TOOTH_UNIT = 1.2;
var SEGMENTS_PER_TURN = 170;
var POINTER_MAX_DIST = 90;
var ROTATE_SPEED = 0.15;
var DEMO_CYCLE = 10;
var KEY_STEP = 0.08;
function gcd(a, b) { while (b) { var t = b; b = a % b; a = t; } return a; }
function computePath(rollTeeth) {
var R = RING_TEETH * TOOTH_UNIT;
var r = rollTeeth * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var K = (R - r) / r;
var g = gcd(RING_TEETH, rollTeeth);
var turns = rollTeeth / g;
var maxT = 2 * Math.PI * turns;
var step = (2 * Math.PI) / SEGMENTS_PER_TURN;
var pts = [];
for (var t = 0; t <= maxT; t += step) {
pts.push({
x: (R - r) * Math.cos(t) + d * Math.cos(K * t),
y: (R - r) * Math.sin(t) - d * Math.sin(K * t)
});
}
return pts;
}
var ratioParam = 0.5;
var currentRoll = -1;
var pathData = [];
var markerAngle = -Math.PI / 2;
var markerDist = POINTER_MAX_DIST * 0.5;
function rebuildForRatio(ratio) {
ratioParam = Math.max(0, Math.min(1, ratio));
var newRoll = Math.round(ROLL_TEETH_MIN + ratioParam * (ROLL_TEETH_MAX - ROLL_TEETH_MIN));
if (newRoll !== currentRoll) {
currentRoll = newRoll;
pathData = computePath(currentRoll);
}
}
function handlePointer(px, py) {
var dist = Math.hypot(px, py);
markerAngle = Math.atan2(py, px);
markerDist = Math.min(POINTER_MAX_DIST, dist);
rebuildForRatio(dist / POINTER_MAX_DIST);
}
rebuildForRatio(ratioParam);
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.86;
cx = cw / 2; cy = ch / 2;
}
var rot = 0;
function render() {
ctx.fillStyle = '#ff4d1f';
ctx.fillRect(0, 0, cw, ch);
ctx.beginPath();
ctx.arc(cx, cy, POINTER_MAX_DIST * scale, 0, Math.PI * 2);
ctx.strokeStyle = 'rgba(255,247,230,.28)';
ctx.lineWidth = Math.max(1, scale * 0.014);
ctx.setLineDash([scale * 0.05, scale * 0.06]);
ctx.stroke();
ctx.setLineDash([]);
var cosR = Math.cos(rot), sinR = Math.sin(rot);
ctx.beginPath();
for (var i = 0; i < pathData.length; i += 1) {
var p = pathData[i];
var rx = p.x * cosR - p.y * sinR;
var ry = p.x * sinR + p.y * cosR;
var sx = cx + rx * scale, sy = cy + ry * scale;
if (i === 0) { ctx.moveTo(sx, sy); } else { ctx.lineTo(sx, sy); }
}
ctx.strokeStyle = 'rgba(255,247,230,.95)';
ctx.lineWidth = Math.max(2, scale * 0.026);
ctx.lineJoin = 'round'; ctx.lineCap = 'round';
ctx.stroke();
var mx = cx + Math.cos(markerAngle) * markerDist * scale;
var my = cy + Math.sin(markerAngle) * markerDist * scale;
ctx.beginPath();
ctx.arc(mx, my, Math.max(4, scale * 0.06), 0, Math.PI * 2);
ctx.fillStyle = 'rgba(23,20,26,.9)';
ctx.fill();
}
function onPointerMove(e) {
root.classList.remove('is-demo');
var rect = canvas.getBoundingClientRect();
var localX = (e.clientX - rect.left) - cw / 2;
var localY = (e.clientY - rect.top) - ch / 2;
handlePointer(localX / scale, localY / scale);
if (reduce) render();
}
canvas.addEventListener('pointermove', onPointerMove);
canvas.addEventListener('pointerdown', onPointerMove);
root.addEventListener('keydown', function (e) {
if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') {
root.classList.remove('is-demo');
e.preventDefault();
var next = ratioParam + (e.key === 'ArrowRight' ? KEY_STEP : -KEY_STEP);
rebuildForRatio(next);
markerDist = ratioParam * POINTER_MAX_DIST;
if (reduce) render();
}
});
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
fit();
if (reduce) {
root.classList.remove('is-demo');
render();
} else {
var startTs = null;
var lastTs = null;
function tick(ts) {
if (startTs === null) { startTs = ts; lastTs = ts; }
var dt = Math.min(ts - lastTs, 48);
lastTs = ts;
rot += ROTATE_SPEED * (dt / 1000);
if (root.classList.contains('is-demo')) {
var elapsed = (ts - startTs) / 1000;
var theta = elapsed * (2 * Math.PI / DEMO_CYCLE);
var wave = (Math.sin(elapsed * (2 * Math.PI / (DEMO_CYCLE * 0.5))) + 1) / 2;
var vx = Math.cos(theta) * wave * POINTER_MAX_DIST;
var vy = Math.sin(theta) * wave * POINTER_MAX_DIST;
handlePointer(vx, vy);
}
render();
requestAnimationFrame(tick);
}
window.addEventListener('resize', fit);
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroScenePointerRatioMorph.module.scss";
type Pt = { x: number; y: number };
export default function SpiroScenePointerRatioMorph() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
if (!root || !canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const CALC_DIM = 200;
const RING_TEETH = 60;
const ROLL_TEETH_MIN = 14;
const ROLL_TEETH_MAX = 34;
const PEN_TIP_RATIO = 0.6;
const TOOTH_UNIT = 1.2;
const SEGMENTS_PER_TURN = 170;
const POINTER_MAX_DIST = 90;
const ROTATE_SPEED = 0.15;
const DEMO_CYCLE = 10;
const KEY_STEP = 0.08;
function gcd(a: number, b: number): number { while (b) { const t = b; b = a % b; a = t; } return a; }
function computePath(rollTeeth: number): Pt[] {
const R = RING_TEETH * TOOTH_UNIT;
const r = rollTeeth * TOOTH_UNIT;
const d = r * PEN_TIP_RATIO;
const K = (R - r) / r;
const g = gcd(RING_TEETH, rollTeeth);
const turns = rollTeeth / g;
const maxT = 2 * Math.PI * turns;
const step = (2 * Math.PI) / SEGMENTS_PER_TURN;
const pts: Pt[] = [];
for (let t = 0; t <= maxT; t += step) {
pts.push({
x: (R - r) * Math.cos(t) + d * Math.cos(K * t),
y: (R - r) * Math.sin(t) - d * Math.sin(K * t)
});
}
return pts;
}
let ratioParam = 0.5;
let currentRoll = -1;
let pathData: Pt[] = [];
let markerAngle = -Math.PI / 2;
let markerDist = POINTER_MAX_DIST * 0.5;
function rebuildForRatio(ratio: number) {
ratioParam = Math.max(0, Math.min(1, ratio));
const newRoll = Math.round(ROLL_TEETH_MIN + ratioParam * (ROLL_TEETH_MAX - ROLL_TEETH_MIN));
if (newRoll !== currentRoll) {
currentRoll = newRoll;
pathData = computePath(currentRoll);
}
}
function handlePointer(px: number, py: number) {
const dist = Math.hypot(px, py);
markerAngle = Math.atan2(py, px);
markerDist = Math.min(POINTER_MAX_DIST, dist);
rebuildForRatio(dist / POINTER_MAX_DIST);
}
rebuildForRatio(ratioParam);
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
scale = Math.min(cw, ch) / CALC_DIM * 0.86;
cx = cw / 2; cy = ch / 2;
}
let rot = 0;
function render() {
ctx!.fillStyle = "#ff4d1f";
ctx!.fillRect(0, 0, cw, ch);
ctx!.beginPath();
ctx!.arc(cx, cy, POINTER_MAX_DIST * scale, 0, Math.PI * 2);
ctx!.strokeStyle = "rgba(255,247,230,.28)";
ctx!.lineWidth = Math.max(1, scale * 0.014);
ctx!.setLineDash([scale * 0.05, scale * 0.06]);
ctx!.stroke();
ctx!.setLineDash([]);
const cosR = Math.cos(rot), sinR = Math.sin(rot);
ctx!.beginPath();
for (let i = 0; i < pathData.length; i += 1) {
const p = pathData[i];
const rx = p.x * cosR - p.y * sinR;
const ry = p.x * sinR + p.y * cosR;
const sx = cx + rx * scale, sy = cy + ry * scale;
if (i === 0) { ctx!.moveTo(sx, sy); } else { ctx!.lineTo(sx, sy); }
}
ctx!.strokeStyle = "rgba(255,247,230,.95)";
ctx!.lineWidth = Math.max(2, scale * 0.026);
ctx!.lineJoin = "round"; ctx!.lineCap = "round";
ctx!.stroke();
const mx = cx + Math.cos(markerAngle) * markerDist * scale;
const my = cy + Math.sin(markerAngle) * markerDist * scale;
ctx!.beginPath();
ctx!.arc(mx, my, Math.max(4, scale * 0.06), 0, Math.PI * 2);
ctx!.fillStyle = "rgba(23,20,26,.9)";
ctx!.fill();
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
function onPointerMove(e: PointerEvent) {
root!.classList.remove("is-demo");
const rect = canvas!.getBoundingClientRect();
const localX = (e.clientX - rect.left) - cw / 2;
const localY = (e.clientY - rect.top) - ch / 2;
handlePointer(localX / scale, localY / scale);
if (reduce) render();
}
canvas.addEventListener("pointermove", onPointerMove);
canvas.addEventListener("pointerdown", onPointerMove);
function onKeyDown(e: KeyboardEvent) {
if (e.key === "ArrowLeft" || e.key === "ArrowRight") {
root!.classList.remove("is-demo");
e.preventDefault();
const next = ratioParam + (e.key === "ArrowRight" ? KEY_STEP : -KEY_STEP);
rebuildForRatio(next);
markerDist = ratioParam * POINTER_MAX_DIST;
if (reduce) render();
}
}
root.addEventListener("keydown", onKeyDown);
fit();
let raf = 0;
if (reduce) {
root.classList.remove("is-demo");
render();
} else {
let startTs: number | null = null;
let lastTs = 0;
const onResize = () => { fit(); };
function tick(ts: number) {
if (startTs === null) { startTs = ts; lastTs = ts; }
const dt = Math.min(ts - lastTs, 48);
lastTs = ts;
rot += ROTATE_SPEED * (dt / 1000);
if (root!.classList.contains("is-demo")) {
const elapsed = (ts - startTs) / 1000;
const theta = elapsed * (2 * Math.PI / DEMO_CYCLE);
const wave = (Math.sin(elapsed * (2 * Math.PI / (DEMO_CYCLE * 0.5))) + 1) / 2;
const vx = Math.cos(theta) * wave * POINTER_MAX_DIST;
const vy = Math.sin(theta) * wave * POINTER_MAX_DIST;
handlePointer(vx, vy);
}
render();
raf = requestAnimationFrame(tick);
}
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
canvas!.removeEventListener("pointermove", onPointerMove);
canvas!.removeEventListener("pointerdown", onPointerMove);
root!.removeEventListener("keydown", onKeyDown);
};
}
return () => {
cancelAnimationFrame(raf);
canvas!.removeEventListener("pointermove", onPointerMove);
canvas!.removeEventListener("pointerdown", onPointerMove);
root!.removeEventListener("keydown", onKeyDown);
};
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp7} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp7__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp7__hint}>← →</p>
<p className={styles.sp7__caption}>포인터가 화면 중심에서 멀어지는 만큼 톱니 이빨 수 값을 다시 계산해, 포인터를 움직이는 동안 무늬의 꽃잎 수와 촘촘함이 그 값에 따라 함께 바뀐다</p>
</div>
</main>
);
}07 · 포인터 거리로 이빨 비율이 바뀌는 무늬 — 측정 누적면적 11.26% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function rebuildForRatio(ratio) {
ratioParam = Math.max(0, Math.min(1, ratio));
var newRoll = Math.round(ROLL_TEETH_MIN + ratioParam * (ROLL_TEETH_MAX - ROLL_TEETH_MIN));
if (newRoll !== currentRoll) {
currentRoll = newRoll;
pathData = computePath(currentRoll);
}
}
function handlePointer(px, py) {
var dist = Math.hypot(px, py);
markerAngle = Math.atan2(py, px);
markerDist = Math.min(POINTER_MAX_DIST, dist);
rebuildForRatio(dist / POINTER_MAX_DIST);
}
08완성 무늬가 도는 회전 판 장면
곡선 좌표는 pathData 에 한 번만 담고, 프레임마다 ctx.rotate(rot) 로 캔버스 좌표계를 돌려 같은 점 배열을 그대로 다시 긋는다. gcd(48, 18) 이 6 이라 AXIS_COUNT 는 8 이고, ROTATE_SPEED 로 9초에 한 바퀴 도는 동안 접시 위로 GLOSS_SWEEP_SECONDS 3.4초 주기의 광택 띠가 쓸고 지나간다. 이 장면은 누적면적 14.8%·평균 강도 96.2·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp8 is-demo" id="sp8Root" tabindex="0">
<canvas class="sp8__canvas" id="sp8Canvas" width="480" height="300"></canvas>
<p class="sp8__caption">곡선이 다 그려진 뒤 캔버스 전체를 회전 변환으로 천천히 돌려 무늬의 대칭 축을 지나가는 순간마다 겹쳐 보이는 착시가 생기고, 회전 각도 값이 그 리듬을 정한다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.sp8 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-paper;
}
.sp8__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp8__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp8__caption { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp8 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp8 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #ffffff;
}
.sp8__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp8__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp8__caption {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp8 {
cursor: default;
}
}(function () {
// 기법: 완성된 무늬는 한 번만 계산해 배열에 담아두고, 매 프레임 회전 각도만 바꿔 다시
// 그린다. 그 위에 독립된 타이머로 광택 띠를 원판 클립 안에서 쓸어 지나가게 겹친다.
var root = document.getElementById('sp8Root');
var canvas = document.getElementById('sp8Canvas');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var CALC_DIM = 200;
var GEAR_RING_TEETH = 48;
var GEAR_ROLL_TEETH = 18;
var PEN_TIP_RATIO = 0.58;
var TOOTH_UNIT = 1.6;
var SEGMENTS_PER_TURN = 180;
var ROTATE_SPEED = (2 * Math.PI) / 9;
var GLOSS_SWEEP_SECONDS = 3.4;
var DISC_RATIO = 0.82;
function gcd(a, b) { while (b) { var t = b; b = a % b; a = t; } return a; }
var g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
var TURNS = GEAR_ROLL_TEETH / g;
var AXIS_COUNT = GEAR_RING_TEETH / g;
var R = GEAR_RING_TEETH * TOOTH_UNIT;
var r = GEAR_ROLL_TEETH * TOOTH_UNIT;
var d = r * PEN_TIP_RATIO;
var K = (R - r) / r;
var pathData = (function () {
var maxT = 2 * Math.PI * TURNS;
var step = (2 * Math.PI) / SEGMENTS_PER_TURN;
var pts = [];
for (var t = 0; t <= maxT; t += step) {
pts.push({
x: (R - r) * Math.cos(t) + d * Math.cos(K * t),
y: (R - r) * Math.sin(t) - d * Math.sin(K * t)
});
}
return pts;
})();
var patternRadius = R + d;
var cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
var targetDiscPx = Math.min(cw, ch) / 2 * DISC_RATIO;
scale = targetDiscPx / (patternRadius * 1.08);
cx = cw / 2; cy = ch / 2;
}
function render(rot, sweepProgress) {
ctx.fillStyle = '#ffffff';
ctx.fillRect(0, 0, cw, ch);
var discR = patternRadius * scale * 1.08;
var plate = ctx.createRadialGradient(cx, cy, discR * 0.15, cx, cy, discR);
plate.addColorStop(0, '#fff7e6');
plate.addColorStop(0.75, '#f4ead4');
plate.addColorStop(1, '#e6d8ba');
ctx.beginPath();
ctx.arc(cx, cy, discR, 0, Math.PI * 2);
ctx.fillStyle = plate;
ctx.fill();
ctx.save();
ctx.translate(cx, cy);
ctx.rotate(rot);
ctx.beginPath();
for (var i = 0; i < pathData.length; i += 1) {
var p = pathData[i];
var sx = p.x * scale, sy = p.y * scale;
if (i === 0) { ctx.moveTo(sx, sy); } else { ctx.lineTo(sx, sy); }
}
ctx.closePath();
ctx.strokeStyle = 'rgba(10,79,232,.82)';
ctx.lineWidth = Math.max(1.6, scale * 0.022);
ctx.lineJoin = 'round';
ctx.stroke();
ctx.restore();
ctx.save();
ctx.beginPath();
ctx.arc(cx, cy, discR, 0, Math.PI * 2);
ctx.clip();
var bandCenter = (sweepProgress * 2 - 0.5) * discR * 2.2;
ctx.translate(cx, cy);
ctx.rotate(-0.5);
var glossGrad = ctx.createLinearGradient(bandCenter - discR * 0.35, 0, bandCenter + discR * 0.35, 0);
glossGrad.addColorStop(0, 'rgba(255,255,255,0)');
glossGrad.addColorStop(0.5, 'rgba(255,255,255,.32)');
glossGrad.addColorStop(1, 'rgba(255,255,255,0)');
ctx.fillStyle = glossGrad;
ctx.fillRect(bandCenter - discR * 0.4, -discR * 1.5, discR * 0.8, discR * 3);
ctx.restore();
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
fit();
if (reduce) {
root.classList.remove('is-demo');
render(0, 0.5);
} else {
var startTs = null;
function tick(ts) {
if (startTs === null) startTs = ts;
var elapsed = (ts - startTs) / 1000;
var rot = elapsed * ROTATE_SPEED;
var sweepProgress = (elapsed % GLOSS_SWEEP_SECONDS) / GLOSS_SWEEP_SECONDS;
render(rot, sweepProgress);
requestAnimationFrame(tick);
}
window.addEventListener('resize', fit);
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneCurveTurnTable.module.scss";
type Pt = { x: number; y: number };
export default function SpiroSceneCurveTurnTable() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
if (!root || !canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const CALC_DIM = 200;
const GEAR_RING_TEETH = 48;
const GEAR_ROLL_TEETH = 18;
const PEN_TIP_RATIO = 0.58;
const TOOTH_UNIT = 1.6;
const SEGMENTS_PER_TURN = 180;
const ROTATE_SPEED = (2 * Math.PI) / 9;
const GLOSS_SWEEP_SECONDS = 3.4;
const DISC_RATIO = 0.82;
function gcd(a: number, b: number): number { while (b) { const t = b; b = a % b; a = t; } return a; }
const g = gcd(GEAR_RING_TEETH, GEAR_ROLL_TEETH);
const TURNS = GEAR_ROLL_TEETH / g;
const R = GEAR_RING_TEETH * TOOTH_UNIT;
const r = GEAR_ROLL_TEETH * TOOTH_UNIT;
const d = r * PEN_TIP_RATIO;
const K = (R - r) / r;
const pathData: Pt[] = (function () {
const maxT = 2 * Math.PI * TURNS;
const step = (2 * Math.PI) / SEGMENTS_PER_TURN;
const pts: Pt[] = [];
for (let t = 0; t <= maxT; t += step) {
pts.push({
x: (R - r) * Math.cos(t) + d * Math.cos(K * t),
y: (R - r) * Math.sin(t) - d * Math.sin(K * t)
});
}
return pts;
})();
const patternRadius = R + d;
let cw = 480, ch = 300, scale = 1, cx = 240, cy = 150;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
const targetDiscPx = Math.min(cw, ch) / 2 * DISC_RATIO;
scale = targetDiscPx / (patternRadius * 1.08);
cx = cw / 2; cy = ch / 2;
}
function render(rot: number, sweepProgress: number) {
ctx!.fillStyle = "#ffffff";
ctx!.fillRect(0, 0, cw, ch);
const discR = patternRadius * scale * 1.08;
const plate = ctx!.createRadialGradient(cx, cy, discR * 0.15, cx, cy, discR);
plate.addColorStop(0, "#fff7e6");
plate.addColorStop(0.75, "#f4ead4");
plate.addColorStop(1, "#e6d8ba");
ctx!.beginPath();
ctx!.arc(cx, cy, discR, 0, Math.PI * 2);
ctx!.fillStyle = plate;
ctx!.fill();
ctx!.save();
ctx!.translate(cx, cy);
ctx!.rotate(rot);
ctx!.beginPath();
for (let i = 0; i < pathData.length; i += 1) {
const p = pathData[i];
const sx = p.x * scale, sy = p.y * scale;
if (i === 0) { ctx!.moveTo(sx, sy); } else { ctx!.lineTo(sx, sy); }
}
ctx!.closePath();
ctx!.strokeStyle = "rgba(10,79,232,.82)";
ctx!.lineWidth = Math.max(1.6, scale * 0.022);
ctx!.lineJoin = "round";
ctx!.stroke();
ctx!.restore();
ctx!.save();
ctx!.beginPath();
ctx!.arc(cx, cy, discR, 0, Math.PI * 2);
ctx!.clip();
const bandCenter = (sweepProgress * 2 - 0.5) * discR * 2.2;
ctx!.translate(cx, cy);
ctx!.rotate(-0.5);
const glossGrad = ctx!.createLinearGradient(bandCenter - discR * 0.35, 0, bandCenter + discR * 0.35, 0);
glossGrad.addColorStop(0, "rgba(255,255,255,0)");
glossGrad.addColorStop(0.5, "rgba(255,255,255,.32)");
glossGrad.addColorStop(1, "rgba(255,255,255,0)");
ctx!.fillStyle = glossGrad;
ctx!.fillRect(bandCenter - discR * 0.4, -discR * 1.5, discR * 0.8, discR * 3);
ctx!.restore();
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
fit();
let raf = 0;
if (reduce) {
root.classList.remove("is-demo");
render(0, 0.5);
} else {
let startTs: number | null = null;
const onResize = () => { fit(); };
function tick(ts: number) {
if (startTs === null) startTs = ts;
const elapsed = (ts - startTs) / 1000;
const rot = elapsed * ROTATE_SPEED;
const sweepProgress = (elapsed % GLOSS_SWEEP_SECONDS) / GLOSS_SWEEP_SECONDS;
render(rot, sweepProgress);
raf = requestAnimationFrame(tick);
}
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp8} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp8__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp8__caption}>곡선이 다 그려진 뒤 캔버스 전체를 회전 변환으로 천천히 돌려 무늬의 대칭 축을 지나가는 순간마다 겹쳐 보이는 착시가 생기고, 회전 각도 값이 그 리듬을 정한다</p>
</div>
</main>
);
}08 · 완성 무늬가 도는 회전 판 장면 — 측정 누적면적 14.838% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
ctx.save();
ctx.translate(cx, cy);
ctx.rotate(rot);
ctx.beginPath();
for (var i = 0; i < pathData.length; i += 1) {
var p = pathData[i];
var sx = p.x * scale, sy = p.y * scale;
if (i === 0) { ctx.moveTo(sx, sy); } else { ctx.lineTo(sx, sy); }
}
ctx.closePath();
ctx.strokeStyle = 'rgba(10,79,232,.82)';
ctx.lineWidth = Math.max(1.6, scale * 0.022);
ctx.lineJoin = 'round';
ctx.stroke();
ctx.restore();
09비율·펜·잔상을 한 화면에 모은 히어로 갤러리
makeCurve(ringTeeth, rollTeeth, penRatio) 가 R·r·d·K 와 닫힘 바퀴 수를 객체 하나로 묶고 pointOn(curve, t) 가 그 객체로 좌표를 계산해서, 이빨 수 쌍 (60, 23)·(54, 19)·(48, 17)·(66, 25) 네 곡선을 같은 함수로 그린다. 네 쌍 모두 최대공약수가 1 이라 바퀴 수가 굴러가는 톱니 이빨 수와 같은 23·19·17·25 이고, HERO_SPEED 도 곡선마다 달라 네 칸이 서로 다른 박자로 채워진다. 이 장면은 누적면적 48.7%·평균 강도 21.7·23/23 프레임이 움직인다.

<main class="stage">
<div class="sp9 is-demo" id="sp9Root" tabindex="0">
<canvas class="sp9__canvas" id="sp9Canvas" width="480" height="300"></canvas>
<p class="sp9__caption">이빨 비율이 다른 곡선 여러 개를 같은 화면 격자에 놓고 각자 다른 속도로 그리게 해, 한눈에 무늬 사이의 차이를 비교하는 히어로 장면을 만든다</p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-ink);
.sp9 {
position: relative;
width: min(92vw, calc(160vh - 12.8vw));
aspect-ratio: 480 / 300;
margin: 0 auto;
border-radius: $r-card;
overflow: hidden;
box-shadow: $shadow-raised;
background: $stage-ink;
}
.sp9__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp9__caption {
position: absolute;
left: $sp-3;
bottom: $sp-3;
max-width: 78%;
margin: 0;
padding: $sp-1 $sp-3;
border-radius: $r-pill;
background: rgba(255, 247, 230, .85);
color: $subject-ink;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp9__caption { font-size: 10px; padding: $sp-1 $sp-2; }
}
@media (prefers-reduced-motion: reduce) {
.sp9 { cursor: default; }
}html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #17141a;
font-family: -apple-system, "Segoe UI", "Noto Sans KR", sans-serif;
padding: clamp(8px, 4vw, 24px);
}
.sp9 {
position: relative;
width: min(92vw, 160vh - 12.8vw);
aspect-ratio: 480/300;
margin: 0 auto;
border-radius: 16px;
overflow: hidden;
box-shadow: 0 14px 24px rgba(23, 20, 26, 0.32);
background: #17141a;
}
.sp9__canvas {
display: block;
width: 100%;
height: 100%;
}
.sp9__caption {
position: absolute;
left: 12px;
bottom: 12px;
max-width: 78%;
margin: 0;
padding: 4px 12px;
border-radius: 999px;
background: rgba(255, 247, 230, 0.85);
color: #17141a;
font-weight: 500;
font-size: 12px;
line-height: 1.4;
pointer-events: none;
}
@media (max-width: 340px) {
.sp9__caption {
font-size: 10px;
padding: 4px 8px;
}
}
@media (prefers-reduced-motion: reduce) {
.sp9 {
cursor: default;
}
}(function () {
// 기법: 항목 01(단일 진행 곡선)·04(다중 펜 색 어긋남)·05(잔상 페이드)를 한 격자의
// 네 칸에 나눠 배정하고, 칸마다 다른 속도로 동시에 그려 비교 갤러리를 만든다.
var root = document.getElementById('sp9Root');
var canvas = document.getElementById('sp9Canvas');
var ctx = canvas.getContext('2d');
var wrap = canvas.parentElement;
var HERO_CELL_COUNT = 4;
var HERO_RING_TEETH = [60, 54, 48, 66];
var HERO_ROLL_TEETH = [23, 19, 17, 25];
var HERO_PEN_RATIO = 0.6;
var HERO_TOOTH_UNIT = 0.62;
var HERO_SPEED = [2.8, 3.4, 3.2, 3.8];
var HERO_TRAIL_FADE_FRAMES = 180;
var HERO_PEN_RATIOS = [0.35, 0.5, 0.65, 0.8];
var HERO_PEN_COLORS = ['rgba(230,90,120,.85)', 'rgba(50,175,135,.85)', 'rgba(70,130,230,.85)', 'rgba(228,150,45,.85)'];
var HERO_STEP_MS = 1000 / 60;
var HERO_FADE_ALPHA = Math.min(1, 3.0 / HERO_TRAIL_FADE_FRAMES);
var HERO_GAP_FRACTION = 0.03;
function gcd(a, b) { while (b) { var t = b; b = a % b; a = t; } return a; }
function makeCurve(ringTeeth, rollTeeth, penRatio) {
var R = ringTeeth * HERO_TOOTH_UNIT;
var r = rollTeeth * HERO_TOOTH_UNIT;
var d = r * penRatio;
var K = (R - r) / r;
var g = gcd(ringTeeth, rollTeeth);
var turns = rollTeeth / g;
return { R: R, r: r, d: d, K: K, turns: turns, maxT: 2 * Math.PI * turns, patternRadius: R + d };
}
function pointOn(curve, t) {
return {
x: (curve.R - curve.r) * Math.cos(t) + curve.d * Math.cos(curve.K * t),
y: (curve.R - curve.r) * Math.sin(t) - curve.d * Math.sin(curve.K * t)
};
}
var curveA = makeCurve(HERO_RING_TEETH[0], HERO_ROLL_TEETH[0], HERO_PEN_RATIO);
var curveB = makeCurve(HERO_RING_TEETH[1], HERO_ROLL_TEETH[1], HERO_PEN_RATIO);
var curveC = makeCurve(HERO_RING_TEETH[2], HERO_ROLL_TEETH[2], HERO_PEN_RATIO);
var curveD = makeCurve(HERO_RING_TEETH[3], HERO_ROLL_TEETH[3], HERO_PEN_RATIO);
function seedRand(seed) {
var s = seed >>> 0;
return function () { s = (s * 1664525 + 1013904223) >>> 0; return s / 4294967296; };
}
var randB = seedRand(43309);
var penPhasesB = [];
for (var pb = 0; pb < 4; pb += 1) penPhasesB.push(randB() * Math.PI * 2);
var cw = 480, ch = 300;
var cellW = 240, cellH = 150, gap = 6;
var cellPix = [];
var trailCanvas = document.createElement('canvas');
var trailCtx = trailCanvas.getContext('2d');
function fit() {
var rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas.width = cw; canvas.height = ch;
cellW = cw / 2; cellH = ch / 2;
gap = Math.min(cw, ch) * HERO_GAP_FRACTION;
cellPix = [];
var curves = [curveA, curveB, curveC, curveD];
for (var k = 0; k < HERO_CELL_COUNT; k += 1) {
var col = k % 2, row = Math.floor(k / 2);
var pw = cellW - gap * 2, ph = cellH - gap * 2;
var target = Math.min(pw, ph) / 2 * 0.88;
var sc = target / (curves[k].patternRadius * 1.05);
cellPix.push({
x: col * cellW + cellW / 2,
y: row * cellH + cellH / 2,
w: pw, h: ph,
scale: sc
});
}
trailCanvas.width = Math.max(1, Math.round(cellPix[2].w));
trailCanvas.height = Math.max(1, Math.round(cellPix[2].h));
trailCtx.fillStyle = '#17141a';
trailCtx.fillRect(0, 0, trailCanvas.width, trailCanvas.height);
}
function drawProgressive(curve, cell, t, strokeStyle) {
ctx.save();
ctx.translate(cell.x, cell.y);
ctx.beginPath();
var step = (2 * Math.PI) / 140;
var first = true;
for (var tt = 0; tt <= t; tt += step) {
var p = pointOn(curve, tt);
var sx = p.x * cell.scale, sy = p.y * cell.scale;
if (first) { ctx.moveTo(sx, sy); first = false; } else { ctx.lineTo(sx, sy); }
}
var tipP = pointOn(curve, t);
var wg = ctx.createRadialGradient(tipP.x * cell.scale, tipP.y * cell.scale, 0, tipP.x * cell.scale, tipP.y * cell.scale, Math.max(cell.w, cell.h) * 0.8);
wg.addColorStop(0, 'rgba(255,200,215,.42)');
wg.addColorStop(0.5, 'rgba(190,225,255,.24)');
wg.addColorStop(1, 'rgba(190,225,255,.06)');
ctx.save();
ctx.fillStyle = wg;
ctx.fillRect(-cell.w / 2, -cell.h / 2, cell.w, cell.h);
ctx.fillStyle = 'rgba(255,247,230,.14)';
ctx.fill('evenodd');
ctx.restore();
ctx.strokeStyle = strokeStyle;
ctx.lineWidth = Math.max(2.4, cell.scale * 0.045);
ctx.lineJoin = 'round'; ctx.lineCap = 'round';
ctx.stroke();
ctx.restore();
}
function drawMultiPen(curve, cell, t) {
ctx.save();
ctx.translate(cell.x, cell.y);
var step = (2 * Math.PI) / 140;
var wb = ctx.createRadialGradient(0, 0, 0, 0, 0, Math.max(cellPix[1].w, cellPix[1].h) * (0.45 + 0.2 * Math.sin(t * 0.9)));
wb.addColorStop(0, 'rgba(255,200,215,.40)');
wb.addColorStop(1, 'rgba(190,225,255,.08)');
ctx.fillStyle = wb;
ctx.fillRect(-cellPix[1].w / 2, -cellPix[1].h / 2, cellPix[1].w, cellPix[1].h);
for (var pIdx = 0; pIdx < HERO_PEN_RATIOS.length; pIdx += 1) {
var localCurve = { R: curve.R, r: curve.r, d: curve.r * HERO_PEN_RATIOS[pIdx], K: curve.K };
var phase = penPhasesB[pIdx];
ctx.beginPath();
var first = true;
for (var tt = 0; tt <= t; tt += step) {
var tp = tt + phase;
var px = (localCurve.R - localCurve.r) * Math.cos(tp) + localCurve.d * Math.cos(localCurve.K * tp);
var py = (localCurve.R - localCurve.r) * Math.sin(tp) - localCurve.d * Math.sin(localCurve.K * tp);
var sx = px * cell.scale, sy = py * cell.scale;
if (first) { ctx.moveTo(sx, sy); first = false; } else { ctx.lineTo(sx, sy); }
}
ctx.strokeStyle = HERO_PEN_COLORS[pIdx];
ctx.lineWidth = Math.max(2.2, cell.scale * 0.04);
ctx.lineJoin = 'round'; ctx.lineCap = 'round';
ctx.stroke();
}
ctx.restore();
}
var trailAngle = 0;
function trailStep() {
trailCtx.fillStyle = 'rgba(23,20,26,' + HERO_FADE_ALPHA + ')';
trailCtx.fillRect(0, 0, trailCanvas.width, trailCanvas.height);
trailAngle += HERO_SPEED[2] * (HERO_STEP_MS / 1000);
var p = pointOn(curveC, trailAngle);
var cell = cellPix[2];
var sx = trailCanvas.width / 2 + p.x * cell.scale;
var sy = trailCanvas.height / 2 + p.y * cell.scale;
if (!trailStep.prev) trailStep.prev = { x: sx, y: sy };
trailCtx.strokeStyle = 'rgba(255,247,230,.95)';
trailCtx.lineWidth = Math.max(2.6, cell.scale * 0.05);
trailCtx.lineJoin = 'round'; trailCtx.lineCap = 'round';
trailCtx.beginPath();
trailCtx.moveTo(trailStep.prev.x, trailStep.prev.y);
trailCtx.lineTo(sx, sy);
trailCtx.stroke();
var th = trailCtx.createRadialGradient(sx, sy, 0, sx, sy, Math.max(trailCanvas.width, trailCanvas.height) * 0.4);
th.addColorStop(0, 'rgba(255,200,215,.09)');
th.addColorStop(1, 'rgba(190,225,255,0)');
trailCtx.fillStyle = th;
trailCtx.fillRect(0, 0, trailCanvas.width, trailCanvas.height);
trailStep.prev = { x: sx, y: sy };
}
function render(elapsed, dtMs) {
ctx.fillStyle = '#17141a';
ctx.fillRect(0, 0, cw, ch);
var tA = (elapsed * HERO_SPEED[0]) % curveA.maxT;
drawProgressive(curveA, cellPix[0], tA, 'rgba(255,247,230,.95)');
var tB = (elapsed * HERO_SPEED[1]) % curveB.maxT;
drawMultiPen(curveB, cellPix[1], tB);
if (dtMs !== null) {
var acc = render.acc || 0;
acc += dtMs;
var guard = 0;
while (acc >= HERO_STEP_MS && guard < 6) { trailStep(); acc -= HERO_STEP_MS; guard += 1; }
render.acc = acc;
}
ctx.drawImage(trailCanvas, cellPix[2].x - cellPix[2].w / 2, cellPix[2].y - cellPix[2].h / 2, cellPix[2].w, cellPix[2].h);
var tD = (elapsed * HERO_SPEED[3]) % curveD.maxT;
drawProgressive(curveD, cellPix[3], tD, 'rgba(91,140,248,.95)');
}
var reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
fit();
if (reduce) {
root.classList.remove('is-demo');
for (var warm = 0; warm < HERO_TRAIL_FADE_FRAMES * 1.4; warm += 1) trailStep();
render(curveA.maxT * 0.94, null);
} else {
var startTs = null;
var lastTs = null;
function tick(ts) {
if (startTs === null) { startTs = ts; lastTs = ts; }
var dt = Math.min(ts - lastTs, 48);
lastTs = ts;
var elapsed = (ts - startTs) / 1000;
render(elapsed, dt);
requestAnimationFrame(tick);
}
window.addEventListener('resize', fit);
requestAnimationFrame(tick);
}
})();import { useEffect, useRef } from "react";
import styles from "./SpiroSceneHeroGalleryWall.module.scss";
type Pt = { x: number; y: number };
type Curve = { R: number; r: number; d: number; K: number; turns: number; maxT: number; patternRadius: number };
type Cell = { x: number; y: number; w: number; h: number; scale: number };
export default function SpiroSceneHeroGalleryWall() {
const rootRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);
useEffect(() => {
const root = rootRef.current;
const canvas = canvasRef.current;
if (!root || !canvas) return;
const ctx = canvas.getContext("2d");
if (!ctx) return;
const wrap = canvas.parentElement as HTMLElement;
const HERO_CELL_COUNT = 4;
const HERO_RING_TEETH = [60, 54, 48, 66];
const HERO_ROLL_TEETH = [23, 19, 17, 25];
const HERO_PEN_RATIO = 0.6;
const HERO_TOOTH_UNIT = 0.62;
const HERO_SPEED = [2.8, 3.4, 3.2, 3.8];
const HERO_TRAIL_FADE_FRAMES = 180;
const HERO_PEN_RATIOS = [0.35, 0.5, 0.65, 0.8];
const HERO_PEN_COLORS = ["rgba(230,90,120,.85)", "rgba(50,175,135,.85)", "rgba(70,130,230,.85)", "rgba(228,150,45,.85)"];
const HERO_STEP_MS = 1000 / 60;
const HERO_FADE_ALPHA = Math.min(1, 3.0 / HERO_TRAIL_FADE_FRAMES);
const HERO_GAP_FRACTION = 0.03;
function gcd(a: number, b: number): number { while (b) { const t = b; b = a % b; a = t; } return a; }
function makeCurve(ringTeeth: number, rollTeeth: number, penRatio: number): Curve {
const R = ringTeeth * HERO_TOOTH_UNIT;
const r = rollTeeth * HERO_TOOTH_UNIT;
const d = r * penRatio;
const K = (R - r) / r;
const g = gcd(ringTeeth, rollTeeth);
const turns = rollTeeth / g;
return { R, r, d, K, turns, maxT: 2 * Math.PI * turns, patternRadius: R + d };
}
function pointOn(curve: Curve, t: number): Pt {
return {
x: (curve.R - curve.r) * Math.cos(t) + curve.d * Math.cos(curve.K * t),
y: (curve.R - curve.r) * Math.sin(t) - curve.d * Math.sin(curve.K * t)
};
}
const curveA = makeCurve(HERO_RING_TEETH[0], HERO_ROLL_TEETH[0], HERO_PEN_RATIO);
const curveB = makeCurve(HERO_RING_TEETH[1], HERO_ROLL_TEETH[1], HERO_PEN_RATIO);
const curveC = makeCurve(HERO_RING_TEETH[2], HERO_ROLL_TEETH[2], HERO_PEN_RATIO);
const curveD = makeCurve(HERO_RING_TEETH[3], HERO_ROLL_TEETH[3], HERO_PEN_RATIO);
function seedRand(seed: number) {
let s = seed >>> 0;
return function () { s = (s * 1664525 + 1013904223) >>> 0; return s / 4294967296; };
}
const randB = seedRand(43309);
const penPhasesB: number[] = [];
for (let pb = 0; pb < 4; pb += 1) penPhasesB.push(randB() * Math.PI * 2);
let cw = 480, ch = 300;
let cellW = 240, cellH = 150, gap = 6;
let cellPix: Cell[] = [];
const trailCanvas = document.createElement("canvas");
const trailCtx = trailCanvas.getContext("2d")!;
function fit() {
const rect = wrap.getBoundingClientRect();
cw = Math.max(1, Math.round(rect.width));
ch = Math.max(1, Math.round(rect.height));
canvas!.width = cw; canvas!.height = ch;
cellW = cw / 2; cellH = ch / 2;
gap = Math.min(cw, ch) * HERO_GAP_FRACTION;
cellPix = [];
const curves = [curveA, curveB, curveC, curveD];
for (let k = 0; k < HERO_CELL_COUNT; k += 1) {
const col = k % 2, row = Math.floor(k / 2);
const pw = cellW - gap * 2, ph = cellH - gap * 2;
const target = Math.min(pw, ph) / 2 * 0.88;
const sc = target / (curves[k].patternRadius * 1.05);
cellPix.push({ x: col * cellW + cellW / 2, y: row * cellH + cellH / 2, w: pw, h: ph, scale: sc });
}
trailCanvas.width = Math.max(1, Math.round(cellPix[2].w));
trailCanvas.height = Math.max(1, Math.round(cellPix[2].h));
trailCtx.fillStyle = "#17141a";
trailCtx.fillRect(0, 0, trailCanvas.width, trailCanvas.height);
}
function drawProgressive(curve: Curve, cell: Cell, t: number, strokeStyle: string) {
ctx!.save();
ctx!.translate(cell.x, cell.y);
ctx!.beginPath();
const step = (2 * Math.PI) / 140;
let first = true;
for (let tt = 0; tt <= t; tt += step) {
const p = pointOn(curve, tt);
const sx = p.x * cell.scale, sy = p.y * cell.scale;
if (first) { ctx!.moveTo(sx, sy); first = false; } else { ctx!.lineTo(sx, sy); }
}
const tipP = pointOn(curve, t);
const wg = ctx!.createRadialGradient(tipP.x * cell.scale, tipP.y * cell.scale, 0, tipP.x * cell.scale, tipP.y * cell.scale, Math.max(cell.w, cell.h) * 0.8);
wg.addColorStop(0, 'rgba(255,200,215,.42)');
wg.addColorStop(0.5, 'rgba(190,225,255,.24)');
wg.addColorStop(1, 'rgba(190,225,255,.06)');
ctx!.save();
ctx!.fillStyle = wg;
ctx!.fillRect(-cell.w / 2, -cell.h / 2, cell.w, cell.h);
ctx!.fillStyle = 'rgba(255,247,230,.14)';
ctx!.fill('evenodd');
ctx!.restore();
ctx!.strokeStyle = strokeStyle;
ctx!.lineWidth = Math.max(2.4, cell.scale * 0.045);
ctx!.lineJoin = "round"; ctx!.lineCap = "round";
ctx!.stroke();
ctx!.restore();
}
function drawMultiPen(curve: Curve, cell: Cell, t: number) {
ctx!.save();
ctx!.translate(cell.x, cell.y);
const step = (2 * Math.PI) / 140;
const wb = ctx!.createRadialGradient(0, 0, 0, 0, 0, Math.max(cellPix[1].w, cellPix[1].h) * (0.45 + 0.2 * Math.sin(t * 0.9)));
wb.addColorStop(0, 'rgba(255,200,215,.40)');
wb.addColorStop(1, 'rgba(190,225,255,.08)');
ctx!.fillStyle = wb;
ctx!.fillRect(-cellPix[1].w / 2, -cellPix[1].h / 2, cellPix[1].w, cellPix[1].h);
for (let pIdx = 0; pIdx < HERO_PEN_RATIOS.length; pIdx += 1) {
const localCurve = { R: curve.R, r: curve.r, d: curve.r * HERO_PEN_RATIOS[pIdx], K: curve.K };
const phase = penPhasesB[pIdx];
ctx!.beginPath();
let first = true;
for (let tt = 0; tt <= t; tt += step) {
const tp = tt + phase;
const px = (localCurve.R - localCurve.r) * Math.cos(tp) + localCurve.d * Math.cos(localCurve.K * tp);
const py = (localCurve.R - localCurve.r) * Math.sin(tp) - localCurve.d * Math.sin(localCurve.K * tp);
const sx = px * cell.scale, sy = py * cell.scale;
if (first) { ctx!.moveTo(sx, sy); first = false; } else { ctx!.lineTo(sx, sy); }
}
ctx!.strokeStyle = HERO_PEN_COLORS[pIdx];
ctx!.lineWidth = Math.max(2.2, cell.scale * 0.04);
ctx!.lineJoin = "round"; ctx!.lineCap = "round";
ctx!.stroke();
}
ctx!.restore();
}
let trailAngle = 0;
let trailPrev: Pt | null = null;
function trailStep() {
trailCtx.fillStyle = "rgba(23,20,26," + HERO_FADE_ALPHA + ")";
trailCtx.fillRect(0, 0, trailCanvas.width, trailCanvas.height);
trailAngle += HERO_SPEED[2] * (HERO_STEP_MS / 1000);
const p = pointOn(curveC, trailAngle);
const cell = cellPix[2];
const sx = trailCanvas.width / 2 + p.x * cell.scale;
const sy = trailCanvas.height / 2 + p.y * cell.scale;
if (!trailPrev) trailPrev = { x: sx, y: sy };
trailCtx.strokeStyle = "rgba(255,247,230,.95)";
trailCtx.lineWidth = Math.max(2.6, cell.scale * 0.05);
trailCtx.lineJoin = "round"; trailCtx.lineCap = "round";
trailCtx.beginPath();
trailCtx.moveTo(trailPrev.x, trailPrev.y);
trailCtx.lineTo(sx, sy);
trailCtx.stroke();
const th = trailCtx.createRadialGradient(sx, sy, 0, sx, sy, Math.max(trailCanvas.width, trailCanvas.height) * 0.4);
th.addColorStop(0, "rgba(255,200,215,.09)");
th.addColorStop(1, "rgba(190,225,255,0)");
trailCtx.fillStyle = th;
trailCtx.fillRect(0, 0, trailCanvas.width, trailCanvas.height);
trailPrev = { x: sx, y: sy };
}
let accMs = 0;
function render(elapsed: number, dtMs: number | null) {
ctx!.fillStyle = "#17141a";
ctx!.fillRect(0, 0, cw, ch);
const tA = (elapsed * HERO_SPEED[0]) % curveA.maxT;
drawProgressive(curveA, cellPix[0], tA, "rgba(255,247,230,.95)");
const tB = (elapsed * HERO_SPEED[1]) % curveB.maxT;
drawMultiPen(curveB, cellPix[1], tB);
if (dtMs !== null) {
accMs += dtMs;
let guard = 0;
while (accMs >= HERO_STEP_MS && guard < 6) { trailStep(); accMs -= HERO_STEP_MS; guard += 1; }
}
ctx!.drawImage(trailCanvas, cellPix[2].x - cellPix[2].w / 2, cellPix[2].y - cellPix[2].h / 2, cellPix[2].w, cellPix[2].h);
const tD = (elapsed * HERO_SPEED[3]) % curveD.maxT;
drawProgressive(curveD, cellPix[3], tD, "rgba(91,140,248,.95)");
}
const reduce = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
fit();
let raf = 0;
if (reduce) {
root.classList.remove("is-demo");
for (let warm = 0; warm < HERO_TRAIL_FADE_FRAMES * 1.4; warm += 1) trailStep();
render(curveA.maxT * 0.94, null);
} else {
let startTs: number | null = null;
let lastTs = 0;
const onResize = () => { fit(); };
function tick(ts: number) {
if (startTs === null) { startTs = ts; lastTs = ts; }
const dt = Math.min(ts - lastTs, 48);
lastTs = ts;
const elapsed = (ts - startTs) / 1000;
render(elapsed, dt);
raf = requestAnimationFrame(tick);
}
window.addEventListener("resize", onResize);
raf = requestAnimationFrame(tick);
return () => {
cancelAnimationFrame(raf);
window.removeEventListener("resize", onResize);
};
}
return () => { cancelAnimationFrame(raf); };
}, []);
return (
<main className={styles.stage}>
<div className={`${styles.sp9} is-demo`} ref={rootRef} tabIndex={0}>
<canvas className={styles.sp9__canvas} ref={canvasRef} width={480} height={300} />
<p className={styles.sp9__caption}>이빨 비율이 다른 곡선 여러 개를 같은 화면 격자에 놓고 각자 다른 속도로 그리게 해, 한눈에 무늬 사이의 차이를 비교하는 히어로 장면을 만든다</p>
</div>
</main>
);
}09 · 비율·펜·잔상을 한 화면에 모은 히어로 갤러리 — 측정 누적면적 48.697% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
function makeCurve(ringTeeth, rollTeeth, penRatio) {
var R = ringTeeth * HERO_TOOTH_UNIT;
var r = rollTeeth * HERO_TOOTH_UNIT;
var d = r * penRatio;
var K = (R - r) / r;
var g = gcd(ringTeeth, rollTeeth);
var turns = rollTeeth / g;
return { R: R, r: r, d: d, K: K, turns: turns, maxT: 2 * Math.PI * turns, patternRadius: R + d };
}
function pointOn(curve, t) {
return {
x: (curve.R - curve.r) * Math.cos(t) + curve.d * Math.cos(curve.K * t),
y: (curve.R - curve.r) * Math.sin(t) - curve.d * Math.sin(curve.K * t)
};
}
아홉 장면을 실측하면 이런 값이 나온다
누적면적은 곡선 선 한 가닥의 넓이가 아니라 움직임이 닿은 화면 영역의 비율이라, 펜 끝을 따라 배경이 함께 움직이는 장면은 값이 크게 나온다. 가장 낮은 값은 04 의 10.1% 와 07 의 11.3% 이고, 아홉 장면 모두 23/23 프레임이 움직였다.
| 항목 | 누적면적 | 평균 강도 | 움직인 프레임 |
|---|---|---|---|
| 01 하이포트로코이드 | 65.7% | 22.7 | 23/23 |
| 02 에피트로코이드 | 66.2% | 26.3 | 23/23 |
| 03 대칭 축 계산 | 59.4% | 19.5 | 23/23 |
| 04 펜 네 개 | 10.1% | 38.2 | 23/23 |
| 05 잔상 페이드 | 49.9% | 18.8 | 23/23 |
| 06 톱니 가이드 | 59.2% | 62.8 | 23/23 |
| 07 포인터 비율 | 11.3% | 103.6 | 23/23 |
| 08 회전 판 | 14.8% | 96.2 | 23/23 |
| 09 히어로 갤러리 | 48.7% | 21.7 | 23/23 |
값이 무늬를 바꾸는 곳 — 이빨 수·펜 위치·회전 속도
무늬에 눈에 띄게 영향을 주는 값은 다섯 개로 좁혀진다. 02 의 GEAR_TEETH_OUTER 는 링 이빨 수라 곡선 크기와 꽃잎 수를 바꾸고(굴러가는 톱니와의 gcd 가 그대로면 바퀴 수는 그대로다), 03 의 PEN_RADIUS_RATIO 는 펜이 톱니 중심에서 얼마나 떨어져 있는지를 정해 꽃잎이 둥근지 뾰족한지를 가른다. 05 의 TRAIL_FADE_FRAMES 는 선이 지워지는 속도를, 07 의 POINTER_MAX_DIST 는 포인터가 얼마나 멀리 가야 이빨 수 상한에 닿는지를, 08 의 ROTATE_SPEED 는 완성된 도형이 도는 속도를 정한다. 값은 하나만 바꾸고, 이빨 수를 건드릴 때는 03 의 배지가 보여 주는 대칭 축 수와 바퀴 수가 어떻게 움직이는지 같이 읽으면 어느 값이 무엇을 움직였는지 가장 빨리 보인다.
어디서 깨지는가 — 곡선이 닫히지 않을 때·좁은 화면·선이 겹칠 때
이빨 수를 최대공약수가 큰 쌍으로 고르면 TURNS 가 줄어 곡선이 일찍 닫히고, 반대로 서로소에 가까울수록 바퀴 수가 늘어 같은 시간에 훨씬 촘촘한 선을 그어야 한다. SEGMENTS_PER_TURN 을 지나치게 낮추면 한 바퀴를 몇 개 선분으로만 이어 곡선이 각져 보이고, 07 은 이빨 수가 정수로만 바뀌어서 포인터를 천천히 움직여도 무늬가 부드럽게 변하지 않고 한 칸씩 바뀐다. 선이 여러 가닥 겹치는 04·09 는 좁은 화면에서 가닥끼리 구분하기 어려워지고, 아홉 장면 모두 @media (max-width: 340px) 에서 캡션(03 은 배지 포함) 글자만 줄일 뿐 캔버스 안 계산은 그대로다. 곡선 안 반투명 채움과 펜 끝을 따라가는 파스텔 그라디언트는 보기 좋게 얹은 표현 층이라 지워도 곡선은 같고, 계산이 들어간 것은 좌표식과 이빨 수의 최대공약수뿐이다. 원본 소스는 압축 파일로 묶여 있고, 여는 비밀번호는 899p5t2j 이다.
변형 세 가지와 접근성
| 이름 | 값 | 느낌 |
|---|---|---|
| 톱니 이빨 수 비율 조정 | 02 GEAR_TEETH_OUTER 96 → 60 | 값을 96에서 60으로 바꾸면 굴러가는 톱니(36개)와의 최대공약수는 12로 그대로라 닫힐 때까지 도는 바퀴 수는 3으로 같지만, 꽃잎 수가 8개에서 5개로 줄어 무늬가 성글어진다. 최대공약수가 작아지는 값을 고르면 바퀴 수가 늘며 더 촘촘한 무늬가 된다. |
| 펜 구멍 위치 비율 조정 | 03 PEN_RADIUS_RATIO 0.6 → 0.95 | 값을 줄이면 펜이 작은 톱니 중심 가까이를 돌아 무늬가 둥글고 온화해지고, 값을 늘리면 펜이 톱니 가장자리에 붙어 곡선이 날카롭게 꺾이며 바깥으로 크게 뻗는 무늬가 된다. |
| 궤적 잔상 길이 조정 | 05 TRAIL_FADE_FRAMES 240 → 60 | 값을 줄이면 그려진 선이 빠르게 사라져 펜이 지나가는 순간의 궤적만 보이고, 값을 늘리면 완성된 무늬가 오래 남아 한 화면에 여러 바퀴의 흔적이 겹쳐 쌓인다. |
아홉 장면은 전부 matchMedia('(prefers-reduced-motion: reduce)') 를 읽는다. 01~04 는 완성된 곡선 한 장(drawFull(TOTAL_T))을 그리고 멈추고, 05 와 09 는 잔상 계산을 미리 돌려 둔 정지 화면을, 06 과 08 은 render() 한 번으로 정해 둔 장면을 남긴다. 키보드와 포인터 입력이 있는 항목은 07 하나뿐이고(방향키 왼쪽·오른쪽과 pointermove), 나머지 여덟 장면은 입력 없이 시간만으로 흐른다. prefers-reduced-motion 이 켜져 있으면 07 도 입력이 들어올 때만 다시 그린다.
스피로그래프 수학 원리는 코드에서 무엇을 계산하는가?
스피로그래프 수학 원리를 코드로 줄이면 링 이빨 수와 굴러가는 톱니 이빨 수를 gcd 로 나눈 몫 두 개가 전부다. 하나는 대칭 축 수, 다른 하나는 곡선이 닫히기까지 각도 t 를 돌려야 하는 바퀴 수이고, 그 바퀴 수만큼만 돌리면 선이 정확히 출발점에서 끝난다. 같은 원 위의 점을 다루더라도 푸리에 변환으로 그림 그리기 9종 — 원이 도는 방식으로 별·하트를 되살리는 캔버스 는 원을 이어 붙여 임의의 윤곽을 따라가고, 리사주 곡선 만들기 9종 — 파동 간섭으로 그리는 캔버스 는 가로·세로 진동수의 비로 닫힘을 정하며, 만화경 그리기 — 대칭 반사 각도로 그리는 캔버스 9종 은 이미 그린 선을 대칭 반사해 무늬를 늘린다. 픽셀을 직접 읽고 쓰는 쪽이 궁금하다면 html5 canvas 애니메이션 9종 — 물방울·블랙홀 특수효과 가 같은 캔버스 2d 로 굴절과 중력렌즈를 계산한 사례다.
스피로그래프 무늬를 쓰기 전에 자주 묻는 질문
스피로그래프 작품으로 저장하려면 어떻게 하나?
이 아홉 데모에는 캔버스를 이미지로 내보내는 코드가 없다. 01 의 drawFull(TOTAL_T) 처럼 곡선이 완성된 상태를 한 번 그리는 함수가 있으니, 그 호출 뒤에 저장 코드를 직접 붙이는 것이 가장 짧은 길이다.
이빨 수는 아무 숫자나 넣어도 되나?
된다. 다만 최대공약수가 1 이면 TURNS 가 굴러가는 톱니 이빨 수와 같아져 09 처럼 17~25 바퀴를 돌아야 곡선이 닫히고, 그만큼 한 곡선을 끝까지 긋는 데 각도를 더 돌려야 한다.
화면이 느려지면 어디를 줄이나?
SEGMENTS_PER_TURN 이 있는 01~04·06~08 에서는 이 값을 줄이면 프레임마다 긋는 선분 수가 줄어든다. 동작 줄임 설정을 켜면 아홉 장면 모두 requestAnimationFrame 루프를 시작하지 않으므로 그것이 가장 확실한 감속이다.









