requestAnimationFrame 사용법 — delta time 으로 움직이는 9장면
requestAnimationFrame 사용법은 콜백 안에서 다음 호출을 다시 걸고, 움직임의 양을 프레임 횟수가 아니라 콜백이 받은 시간의 차로 정하는 것이다.
requestAnimationFrame 은 다음 화면 갱신 직전에 함수를 한 번 부른다
01 raf-delta-compare
02 raf-fixed-step
03 raf-timestamp-spring
04 raf-visibility-jump
05 raf-vs-interval
06 raf-frame-budget
07 raf-particle-limit
08 raf-timescale
09 raf-lerp-decay
- 01 델타 타임 — 30Hz·144Hz 두 환경에서 같은 거리 가기
- 02 고정 단계와 보간 — 공전체를 안정적으로 돌리기
- 03 타임스탬프 스프링 — 콜백 인자로 만든 감쇠 진동
- 04 탭 숨김 — 복귀 순간의 시계 점프 막기
- 05 타이머 드리프트 — setInterval 눈금과 rAF 눈금 비교
- 06 프레임 예산 막대 — 작업량을 올리며 16.7ms 지키기
- 07 입자 루프 — 요소 수가 한계를 만나는 지점
- 08 일시정지·배속 시계 — timeScale 로 시간 다루기
- 09 프레임 독립 감쇠 — 스크롤 관성 lerp 보정
requestAnimationFrame(이하 rAF)이란 「다음 화면을 그리기 직전에 이 함수를 불러 달라」고 브라우저에 맡기는 함수다. 한 번만 불리므로 움직임을 이으려면 콜백이 끝나기 전에 같은 함수를 다시 요청해야 하고, 그렇게 이어 붙인 것이 requestAnimationFrame loop 다.
콜백이 받는 timestamp
콜백은 인자로 timestamp 하나를 받는다. 화면 갱신 시각을 밀리초로 적은 숫자라서, 연달아 받은 두 값의 차가 곧 한 프레임의 길이이고 이 글에서 말하는 delta time 이다.
이 값을 쓰지 않고 「한 번 불릴 때마다 3px」 처럼 횟수에 곱하면 모니터 주사율이 속도가 된다. 01 장면부터 이 차이를 숫자로 보인다.
루프 한 바퀴가 하는 일
아홉 데모는 모두 같은 뼈대의 루프를 실제로 돌린다. 캔버스 계산으로 흉내 낸 그림이 아니라 frame 이 끝나기 전에 window.requestAnimationFrame(frame) 을 다시 부르는 구조이고, 라이브러리·WebGL·외부 파일은 쓰지 않았다.
function frame(ts) {
rafId = 0;
if (still || paused || document.hidden) {
return;
}
rawGap = lastTs < 0 ? 0 : ts - lastTs;
const dt = lastTs < 0 ? 0 : Math.min(rawGap / 1000, DT_MAX);
lastTs = ts;
sceneT += dt;
if (sceneT >= LAP_S) {
lap += 1;
resetScene();
}
advance(ts, dt);
redraw();
if (!holdFlag) {
rafId = window.requestAnimationFrame(frame);
}
}
rawGap 이 콜백 사이의 실제 간격이고 dt 는 그것을 DT_MAX 0.05초로 자른 값이다. 일시정지나 숨은 탭에서는 return 으로 다음 요청을 걸지 않아 루프가 멈춘다.
프레임 속도가 달라도 같은 속도로 움직이려면 어떻게 할까?
델타 타임 한 줄
답은 한 줄이다. 이동량을 속도에 지난 시간을 곱한 값으로 두면 되고, 이것이 requestAnimationFrame delta time 계산의 전부다. 30Hz 에서는 한 번에 크게, 144Hz 에서는 한 번에 작게 움직여 같은 시간 뒤에 같은 자리에 선다.
복잡해지는 곳은 그 시간 차를 어디까지 믿느냐다. 탭이 숨었다 돌아오거나 한 프레임이 오래 걸린 순간의 큰 값을 그대로 쓰면 오히려 튄다. 04 와 08 에서 그 경우를 따로 본다.
측정 방법과 값의 성격
아홉 장면의 숫자는 성격이 두 가지라서 섞어 읽으면 안 된다. 01·02·03·09 는 가상 눈금 시계를 주입한 모델로, 실제 rAF 가 한 번 불릴 때마다 30Hz(33.33ms)·144Hz(6.94ms) 같은 눈금을 차례로 계산하므로 실행마다 값이 같다. 실제 30Hz·144Hz 모니터에서 잰 값이 아니다. 03·09 는 목표를 0.4·2.2·4.0초에 세 번 옮기고 라벨에는 가장 최근 이동 뒤의 값만 나온다. 그래서 이 글의 933ms·951ms 같은 값은 마지막 이동 뒤의 것이고, 포스터나 라이브 화면의 967ms·947ms(03), 867ms·836ms(09) 는 1번째·2번째 이동 뒤에 찍힌 중간 시점 스냅샷이라 수십 ms 다르다. 어느 쪽도 가상 눈금 시각만으로 정해져 같은 이동 뒤라면 실행마다 같다.
04·05·06·07 은 실제 rAF 타임스탬프와 performance.now 로 잰 실측이라 기기와 부하에 따라 달라진다. 08 은 시간표가 배율을 정하고 거리는 실제 콜백 시각으로 계산해 두 성격이 섞였다. 실측 항목은 수치보다 순서와 구조를 읽는 것이 맞다.
확인하지 못한 것도 있다. 헤드리스 크롬은 rAF 가 60Hz 에 묶여 30Hz·144Hz 실기기 값은 미확인이고, 실제 탭 숨김 이벤트도 만들지 못해 04 는 cancelAnimationFrame 으로 루프를 멈췄다 다시 거는 흉내다. 렌더 환경은 Chrome 157.0.8103.40 이고 32코어 PC 다.
아홉 장면의 측정값
표의 면적·강도·프레임은 도구/demo.py 가 480×300 캔버스를 2초 동안 24장 찍고 이웃한 두 장의 차 23개를 비교해 얻었다. 누적면적은 24장 중 한 번이라도 첫 장과 달라진 픽셀의 비율이고, 강도는 그 픽셀의 색 차이 평균(0~255)이며, 움직인 프레임은 직전 장과 달라진 장의 수다.
| 장면 | 누적면적 | 움직인 프레임 | 강도 평균 | 값의 성격 |
|---|---|---|---|---|
| 01 델타 타임 | 11.8% | 23/23 | 81.9 | 모델 |
| 02 고정 단계 | 8.8% | 23/23 | 88.9 | 모델 |
| 03 타임스탬프 스프링 | 14.8% | 22/23 | 75.8 | 모델 |
| 04 탭 숨김 | 68.3% | 23/23 | 121.7 | 실측 |
| 05 타이머 드리프트 | 4.6% | 23/23 | 100.3 | 실측 |
| 06 프레임 예산 | 27.9% | 23/23 | 104.9 | 실측 |
| 07 입자 루프 | 38.5% | 23/23 | 71.4 | 실측 |
| 08 일시정지·배속 | 10.9% | 23/23 | 110.8 | 시간표와 실측 |
| 09 프레임 독립 감쇠 | 17.4% | 22/23 | 82.6 | 모델 |
누적면적이 가장 넓은 장면은 04 이고 가장 좁은 장면은 05 다. 03 과 09 만 22/23 이고 나머지 일곱 장면은 23/23 이다. 이 값은 캔버스 안 그림의 변화이지 실제 페이지의 성능이 아니다.
01델타 타임 — 30Hz·144Hz 두 환경에서 같은 거리 가기
데모와 설명
시계를 주입해 30Hz 와 144Hz 두 줄을 흉내 내고, 한 줄은 프레임마다 STEP_PX 3px 씩 더하고 다른 줄은 SPEED 110px 에 지난 시간을 곱해 더한다.
프레임 수로 더하면 초속이 30Hz 에서 90px, 144Hz 에서 432px 로 갈려 끝에 닿는 시각이 3.80초와 0.79초가 되고, 시간 차로 더하면 두 줄 모두 초속 110px 로 3.10초에 닿는다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터, 왼쪽·오른쪽 방향키로 두 번째 줄의 주사율을 바꾼다">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="30Hz 와 고른 주사율에서 프레임 수로 더하는 판과 시간 차로 더하는 판이 같은 거리를 가는 데 걸리는 시간을 나란히 보는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 439줄 — 아래 「전체 코드」에서 원문 전체)// DeltaCompare - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./DeltaCompare.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 420줄 — 아래 「전체 코드」에서 원문 전체)01 · 델타 타임 — 30Hz·144Hz 두 환경에서 같은 거리 가기 — 측정 누적면적 11.767% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
runLane 안쪽이 두 판이 갈리는 곳으로, r.fc 는 간격을 모른 채 3px 을 더하고 r.dd 는 gap 을 읽어 초속에 곱한다.
runLane(r.l, nowMs, function (gap, vt) {
// 프레임 수 판 — 간격을 모르고 한 번에 STEP_PX
if (r.fc < TW) {
r.fc = Math.min(TW, r.fc + STEP_PX);
if (r.fc >= TW) {
r.fcAt = vt / 1000;
}
}
// 시간 차 판 — 초속 × 지난 시간
if (r.dd < TW) {
r.dd = Math.min(TW, r.dd + SPEED * gap / 1000);
if (r.dd >= TW) {
r.ddAt = vt / 1000;
}
}
r.ticks.push(vt);
});
02고정 단계와 보간 — 공전체를 안정적으로 돌리기
데모와 설명
누적기 acc 에 프레임 간격을 쌓아 STEP_S 1/120초 단위로만 상태를 갱신하고, 남은 비율로 그리는 위치를 보간한 판을, 간격이 16~130ms 로 들쭉날쭉한 GAPS 표 위에서 간격을 그대로 한 단계로 쓰는 판과 겹쳐 돌린다.
시간에 맞는 해석해와의 최대 위치 오차는 가변 판이 85.3px 이고 고정 단계와 보간 판이 3.7px 이라 물리 시뮬레이션과 궤도 연출에는 쓸 만하지만, 간격 하나로 끝나는 단순 이동에는 필요 없다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="들쭉날쭉한 프레임 간격에서 가변 단계 판과 고정 단계 보간 판의 공전 위치가 시간에 맞는 자리에서 얼마나 벗어나는지 보는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 465줄 — 아래 「전체 코드」에서 원문 전체)// FixedStep - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./FixedStep.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 458줄 — 아래 「전체 코드」에서 원문 전체)02 · 고정 단계와 보간 — 공전체를 안정적으로 돌리기 — 측정 누적면적 8.839% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
while (acc >= STEP_S) 안쪽이 고정 단계가 일어나는 곳이고, 바로 위 stepBody(vBody, gap / 1000) 은 같은 간격을 한 번에 쓰는 비교 판이다.
while (vNext <= nowMs && frames < 60) {
const gap = GAPS[gapIdx % GAPS.length];
vt = vNext;
// 가변 단계 — 프레임 간격을 그대로 한 단계로 쓴다
stepBody(vBody, gap / 1000);
// 고정 단계 — 간격을 누적기에 쌓고 120분의 1초씩만 갱신한다
acc += gap / 1000;
while (acc >= STEP_S) {
stepBody(fBody, STEP_S);
acc -= STEP_S;
fSteps += 1;
}
gapIdx += 1;
vNext += GAPS[gapIdx % GAPS.length];
frames += 1;
}
03타임스탬프 스프링 — 콜백 인자로 만든 감쇠 진동
데모와 설명
콜백이 받는 timestamp 의 차 h 로 감쇠 진동의 닫힌 식을 풀면 STIFFNESS 200·ZETA 0.45 인 스프링이 프레임 간격과 상관없이 같은 곡선 위에 놓인다.
정착(오차 1.2px 미만·속도 8 미만)까지 걸린 시간은 마지막 목표 이동 뒤 기준으로 시간 차 판이 30Hz 933ms·144Hz 951ms 로 거의 같고 프레임마다 1/60초라고 가정한 판은 1800ms 와 375ms 로 갈리니, 카드가 따라오는 UI 에는 시간 차 판이 알맞다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="30Hz 와 144Hz 에서 프레임마다 60분의 1초로 가정한 스프링과 시간 차로 푼 스프링이 정착하는 시간을 네 줄로 비교하는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 439줄 — 아래 「전체 코드」에서 원문 전체)// TimestampSpring - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./TimestampSpring.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 429줄 — 아래 「전체 코드」에서 원문 전체)03 · 타임스탬프 스프링 — 콜백 인자로 만든 감쇠 진동 — 측정 누적면적 14.802% · 움직인 프레임 22/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
exactStep 은 h 에 Math.exp 와 Math.cos 를 걸어 한 번에 풀고, 아래 guessStep 은 h = 1 / 60 으로 못 박아 두어 두 판의 차이가 이 두 함수에서 갈린다.
// 시간 차 h(초) 만큼 감쇠 진동의 닫힌 식으로 한 번에 나아간다 — h 가 얼마든 같은 곡선 위에 있다
function exactStep(s, h) {
const e = s.x - s.target;
const d = Math.exp(-ZETA * W0 * h);
const cs = Math.cos(WD * h);
const sn = Math.sin(WD * h);
const b = (s.v + ZETA * W0 * e) / WD;
s.x = s.target + d * (e * cs + b * sn);
s.v = d * (s.v * cs - ((ZETA * W0 * s.v + W0 * W0 * e) / WD) * sn);
}
// 간격을 모르고 프레임마다 60분의 1초라고 가정한 단계
function guessStep(s) {
const h = 1 / 60;
s.v += (-STIFFNESS * (s.x - s.target) - 2 * ZETA * W0 * s.v) * h;
s.x += s.v * h;
04탭 숨김 — 복귀 순간의 시계 점프 막기
데모와 설명
탭이 숨으면 rAF 콜백이 멈추고 돌아온 첫 콜백의 ts 가 크게 뛰므로, 데모는 cancelAnimationFrame 으로 두 루프를 멈췄다가 HIDDEN_MS 1200ms 뒤 다시 거는 흉내를 낸다.
제한 없는 판은 복귀 첫 프레임에 120px 를 한 번에 건너뛰고, DT_MAX 로 자르고 시계를 지금으로 맞춘 판은 점프가 0px 이며, 오래 열어 둔 대시보드나 게임에 필요한 방어다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터, A 키로 탭 숨김을 다시 흉내 낸다">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="탭이 숨었다 돌아올 때 제한 없는 루프는 한 프레임에 크게 건너뛰고 간격을 제한한 루프는 건너뛰지 않는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
<button class="ez__pause" data-role="act" type="button">탭 숨김 흉내</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
… (총 13줄 — 아래 「전체 코드」에서 원문 전체)@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 529줄 — 아래 「전체 코드」에서 원문 전체)// VisibilityJump - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./VisibilityJump.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 503줄 — 아래 「전체 코드」에서 원문 전체)04 · 탭 숨김 — 복귀 순간의 시계 점프 막기 — 측정 누적면적 68.296% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
dG 줄이 최대 간격 제한이고 resumed 분기가 복귀 첫 프레임의 기준 시각을 지금으로 바꾸는 시계 재설정이며, dN 이 두 방어를 모두 쓰지 않은 값이다.
if (resumed) {
// 시계 재설정 — 돌아온 첫 프레임의 기준 시각을 지금으로
guard.last = ts;
resumed = false;
}
const dN = (ts - naive.last) / 1000;
const dG = Math.min((ts - guard.last) / 1000, DT_MAX);
naive.last = ts;
guard.last = ts;
if (dN > 0.3) {
naive.from = naive.x;
naive.jump = SP * dN;
naive.x = wrap(naive.x + SP * dN);
naive.to = naive.x;
maxJump = Math.max(maxJump, naive.jump);
}
else {
naive.x = wrap(naive.x + SP * dN);
}
guard.x = wrap(guard.x + SP * dG);
05타이머 드리프트 — setInterval 눈금과 rAF 눈금 비교
데모와 설명
같은 눈금 위에 setInterval(16) 간격과 rAF 콜백 간격을 겹쳐 그리고, 이웃한 두 화면 사이에 타이머가 0번이거나 2번 이상 불린 프레임을 miss 로 센다.
헤드리스 크롬(60Hz 고정)에서 잰 rAF 간격은 평균 16.904ms 이고 setInterval(16) 은 평균 16.001ms 라서 두 시계가 조금씩 어긋나고 라이브 miss 는 60~244프레임 가운데 3~10번이었으니, 타이머로 애니메이션을 돌리던 코드를 점검할 때 먼저 본다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="setInterval 16ms 와 requestAnimationFrame 이 찍는 프레임 간격을 같은 눈금에 겹쳐 평균과 p95 를 비교하는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 488줄 — 아래 「전체 코드」에서 원문 전체)// TimerDrift - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./TimerDrift.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 460줄 — 아래 「전체 코드」에서 원문 전체)05 · 타이머 드리프트 — setInterval 눈금과 rAF 눈금 비교 — 측정 누적면적 4.587% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
ticksSince !== 1 조건이 어긋난 프레임을 세는 곳이고, 타이머 콜백은 따로 ticksSince 를 올리기만 한다.
if (rawGap > 0) {
gapsR.push(rawGap);
if (gapsR.length > N) {
gapsR.shift();
}
frames += 1;
// 이번 프레임 사이에 타이머가 0번이거나 2번 이상 불렸으면 화면과 어긋난 것
if (frames > 2 && ticksSince !== 1) {
miss += 1;
}
}
ticksSince = 0;
06프레임 예산 막대 — 작업량을 올리며 16.7ms 지키기
데모와 설명
시작할 때 Math.sin·Math.cos 반복의 속도를 재 이 기기의 perMs 를 구하고, 단계마다 목표 작업 시간(1·3·6·10·14·19·26·34ms)에 맞는 반복 수로 프레임마다 실제 일을 시켜 rAF 간격이 어떻게 변하는지 본다.
이 환경의 라이브 값은 작업 9.4ms 에서 예산 BUDGET_MS 16.7ms 초과가 0번, 18.3ms 에서 17번이었고 40.9ms 에서는 간격이 49.9ms 로 늘었으니, 무거운 화면의 병목을 찾는 첫 단계다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터, 왼쪽·오른쪽 방향키로 계산량 단계를 직접 고른다">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="프레임마다 하는 계산량을 올리며 한 프레임에 쓴 시간 막대가 16.7ms 예산선을 넘는 지점을 보는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 485줄 — 아래 「전체 코드」에서 원문 전체)// FrameBudget - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./FrameBudget.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 455줄 — 아래 「전체 코드」에서 원문 전체)06 · 프레임 예산 막대 — 작업량을 올리며 16.7ms 지키기 — 측정 누적면적 27.918% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
else 안쪽이 프레임마다 busy(workN) 으로 일한 시간 w 와 콜백 간격 g 를 함께 기록하는 곳이고, 그 위의 settling 분기는 줄임 모드에서만 쓰는 정해 둔 값이다.
else {
workN = Math.round(LEVELS[level] * perMs);
const t0 = performance.now();
busy(workN);
w = performance.now() - t0;
g = rawGap > 0 ? rawGap : BUDGET_MS;
}
work.push(w);
gap.push(g);
07입자 루프 — 요소 수가 한계를 만나는 지점
데모와 설명
Float32Array 로 미리 잡아 둔 입자를 500개에서 160000개까지 올리며, 입자는 시간 차 h 만큼만 움직이게 해 간격이 늘어도 낙하 속도를 같게 두고 평균 간격과 25ms 를 넘긴 프레임 LONG_MS 를 막대로 읽는다.
이 기기에서는 30000개까지 16.7ms 를 지키다가 100000개에서 평균 20.8ms, 160000개에서 33.5~48.8ms 로 늘었고, 기기마다 달라 이 숫자를 그대로 다른 곳에 쓰지 않고 입자 개수를 정할 때 상대 비교로만 쓴다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터, 왼쪽·오른쪽 방향키로 입자 단계를 직접 고른다">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="입자 수를 단계적으로 늘리며 단계별 평균 프레임 간격과 끊긴 프레임 수를 막대로 보는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 479줄 — 아래 「전체 코드」에서 원문 전체)// ParticleLimit - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./ParticleLimit.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 452줄 — 아래 「전체 코드」에서 원문 전체)07 · 입자 루프 — 요소 수가 한계를 만나는 지점 — 측정 누적면적 38.51% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
h 줄이 프레임 간격을 0.1초로 자른 시간 차이고, 그 아래 for 문이 입자 수 n 만큼 위치를 갱신하며 화면 밖으로 나가면 반대편으로 되돌린다.
const h = settling ? 1 / 60 : Math.min(rawGap > 0 ? rawGap / 1000 : dt, 0.1);
for (let i = 0; i < n; i += 1) {
py[i] += pv[i] * h;
px[i] += pd[i] * h;
if (py[i] > FH) {
py[i] -= FH;
}
if (px[i] < 0) {
px[i] += FW;
}
else if (px[i] > FW) {
px[i] -= FW;
}
}
08일시정지·배속 시계 — timeScale 로 시간 다루기
데모와 설명
scaleAt 시간표가 1배·0.5배·정지·2배·1배를 정하고, timeScale 판은 시간 차에 배율을 곱해 SP 90px/s 로 움직이는 반면 정지 판은 멈춘 동안 기준 시각을 갱신하지 않는다.
정지가 풀린 첫 프레임에 정지 판은 쌓인 약 0.7초를 한 번에 써서 129px 를 건너뛰고(시간표 끝 거리 330px 대 323px), timeScale 판은 점프가 없으니 일시정지 버튼이 있는 게임과 튜토리얼에 맞다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터, A 키로 배율을 0 으로 붙잡거나 푼다">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="배율을 1배·0.5배·정지·2배로 바꿀 때 복귀 첫 프레임에 튀는 판과 튀지 않는 판의 이동 거리를 비교하는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
<button class="ez__pause" data-role="act" type="button">정지 붙잡기</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
… (총 13줄 — 아래 「전체 코드」에서 원문 전체)@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 471줄 — 아래 「전체 코드」에서 원문 전체)// TimeScale - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./TimeScale.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 459줄 — 아래 「전체 코드」에서 원문 전체)08 · 일시정지·배속 시계 — timeScale 로 시간 다루기 — 측정 누적면적 10.905% · 움직인 프레임 23/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
curScale > 0 조건이 정지 판의 기준 시각을 얼리는 곳이고, 위쪽 scaled 판은 dB 에 curScale 을 곱하는 한 줄로 끝난다.
// timeScale 판 — 기준 시각은 늘 갱신하고, 시간 차에 배율을 곱한다
const dB = Math.min((ts - scaled.last) / 1000, DT_MAX);
scaled.last = ts;
scaled.x = Math.min(TW, scaled.x + SP * curScale * dB);
// 정지 판 — 멈춘 동안은 기준 시각을 갱신하지 않고 그냥 건너뛴다
if (curScale > 0) {
const dA = (ts - naive.last) / 1000;
naive.last = ts;
const before = naive.x;
naive.x = Math.min(TW, naive.x + SP * curScale * dA);
if (dA > 0.3) {
naive.jump = naive.x - before;
resumeJump = Math.max(resumeJump, naive.jump);
}
}
09프레임 독립 감쇠 — 스크롤 관성 lerp 보정
데모와 설명
목표가 옮겨 갈 때 매 프레임 같은 계수 K_FRAME 0.12 로 따라가는 판은 남은 거리가 1px 아래가 되는 수렴이 마지막 목표 이동 뒤 기준으로 30Hz 에서 1533ms, 144Hz 에서 319ms 로 갈린다.
1 - Math.exp(-LERP_K * gap / 1000) 로 계수를 만든 판은 833ms 와 840ms 로 거의 같아, 부드러운 스크롤과 마우스 따라가기를 모니터에 상관없이 같은 느낌으로 만든다.

<main class="stage">
<div class="ez is-demo" id="ez">
<div class="ez__pad" data-role="pad" tabindex="0" role="application" aria-label="시연 무대 — Space 또는 Enter 로 일시정지, R 로 처음부터">
<canvas class="ez__canvas" data-role="canvas" width="480" height="300" role="img" aria-label="30Hz 와 144Hz 에서 계수를 고정한 lerp 와 1-exp(-k·dt) 로 보정한 lerp 가 목표에 수렴하는 시간을 네 줄로 비교하는 장면"></canvas>
</div>
<p class="ez__status" data-role="status" aria-live="off">장면 준비</p>
<div class="ez__ctrl">
<button class="ez__pause" data-role="pause" type="button" aria-pressed="false">일시정지</button>
</div>
<p class="ez__done" data-role="done" role="status" aria-live="polite"></p>
</div>
</main>@use "../../../../site/static/demo-tokens" as *;
@include stage($stage-paper);
.ez {
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: $subject-ink;
… (총 122줄 — 아래 「전체 코드」에서 원문 전체)html, body {
margin: 0;
overflow: hidden;
}
.stage {
box-sizing: border-box;
min-height: 100vh;
display: grid;
place-items: center;
margin: 0;
background: #ffffff;
… (총 134줄 — 아래 「전체 코드」에서 원문 전체)(function () {
const rootEl = document.getElementById("ez");
if (!rootEl) return;
main(rootEl);
function main(root) {
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
function clamp(v, lo, hi) { return v < lo ? lo : (v > hi ? hi : v); }
function lerp(a, b, k) { return a + (b - a) * k; }
// 파스텔 팔레트 — 바탕은 짙은 자두색, 상자는 연한 색, 글자는 연한 색 또는 짙은 잉크
… (총 417줄 — 아래 「전체 코드」에서 원문 전체)// LerpDecay - 같은 항목 vanilla index.html 의 React 판. 같은 계산을 useEffect 안에서 돌린다
import { useEffect, useRef } from "react";
import styles from "./LerpDecay.module.scss";
const cx = (s: string): string => s.split(" ").map((n) => styles[n] ?? n).join(" ");
function main(root: HTMLElement): () => void {
type RGB = [number, number, number];
// 무대 좌표 — 캔버스 안 계산은 늘 480×300. 화면에 보이는 크기와 상관없다
const W = 480;
const H = 300;
const TAU = Math.PI * 2;
… (총 412줄 — 아래 「전체 코드」에서 원문 전체)09 · 프레임 독립 감쇠 — 스크롤 관성 lerp 보정 — 측정 누적면적 17.401% · 움직인 프레임 22/23GODRICH 원작 · zip 에 SCSS·React 포함 · 비밀번호 보기
코드에서 볼 곳
const k 줄의 삼항식이 두 판을 가르는 부분이며, 보정 판은 gap 으로 계수를 만들고 고정 판은 상수 K_FRAME 을 그대로 쓴다.
}
// 보정 판은 프레임 간격(초)으로 계수를 만들고, 고정 판은 프레임마다 같은 계수를 쓴다
const k = c.corr ? 1 - Math.exp(-LERP_K * gap / 1000) : K_FRAME;
c.x += (c.target - c.x) * k;
if (!c.done && Math.abs(c.x - c.target) < 1) {
c.done = true;
c.convMs = vtm - c.t0;
고정 시간 단계와 가변 시간 단계는 어떻게 다른가
가변 단계는 간격을 그대로 쓴다
가변 단계는 프레임 간격 전체를 한 번의 계산에 넣는다. 구현이 가장 짧고 위치를 곱하기 하나로 구하는 이동에는 충분하지만, 속도가 위치에 다시 영향을 주는 적분에서는 간격이 길수록 오차가 크게 쌓인다.
02 의 간격표에는 130ms 짜리 프레임이 끼어 있고, 이렇게 긴 간격이 한 단계로 통째로 들어갈수록 궤도는 시간에 맞는 자리에서 멀어진다.
고정 단계는 누적기로 나눈다
고정 단계는 간격을 누적기에 쌓고 일정한 단위가 찰 때마다 상태를 갱신한다. 1/120초 단위라면 16ms 프레임에서는 한두 번, 130ms 프레임에서는 열다섯 번 안팎 갱신하므로 프레임이 길어도 한 단계의 크기는 같다.
남은 시간은 누적기에 두었다가 alpha 로 이전·현재 상태를 보간해 그린다. 그리는 위치는 마지막 갱신보다 한 단계 앞이라서 화면이 갱신 단위에 끌려 끊겨 보이지 않는다.
어느 쪽을 고를까
닫힌 식이 있으면 03 처럼 시간 차 하나로 한 번에 풀면 되고, 식이 없는 물리 계산이면 02 처럼 고정 단계에 보간을 얹는다. 단순한 이동은 01 의 곱셈으로 끝내고, 고정 단계에 드는 누적기와 보간 코드는 그만큼 필요할 때만 들인다.
탭이 숨겨지면 루프는 어떻게 되는가 — 복귀 순간의 시계 점프
숨은 탭에서는 콜백이 멈춘다
탭이 가려지면 브라우저는 rAF 콜백을 부르지 않는다. 루프가 멈추는 것은 배터리 면에서 바람직하지만, 시계는 멈추지 않으므로 돌아온 첫 콜백의 timestamp 는 숨어 있던 시간만큼 커져 있다.
복귀 첫 프레임을 다루는 두 방어
방어는 둘이다. 하나는 시간 차의 상한이고, 다른 하나는 복귀할 때 마지막 시각을 지금으로 다시 맞추는 시계 재설정이다. 04 데모의 상한은 0.05초라서 100px/s 로 움직이는 막대가 한 프레임에 갈 수 있는 거리는 5px 로 묶인다.
숨김·복귀는 visibilitychange 이벤트로 알 수 있다. 데모는 숨는 순간 루프를 멈추고, 돌아오면 startLoop 안에서 lastTs 를 -1 로 되돌려 첫 프레임의 간격을 0 으로 만든다.
document.addEventListener('visibilitychange', function () {
if (document.hidden) {
stopLoop();
}
else if (!paused && !still) {
startLoop();
}
}, { signal: off.signal });
일시정지도 같은 병이다
사용자가 직접 누르는 일시정지도 숨은 탭과 같은 구조다. 멈춘 동안 기준 시각을 갱신하지 않으면 풀리는 순간 한꺼번에 몰리고, 이것이 08 의 정지 판이 129px 를 건너뛴 이유다. 같은 두 방어로 막는다.
setTimeout·setInterval·CSS 애니메이션과 무엇이 다른가
타이머는 화면 갱신과 따로 돈다
setTimeout 과 setInterval 은 정해진 시간이 지났을 때 부르는 장치이고 화면을 언제 그리는지는 모른다. 05 에서 setInterval(16) 이 평균 16.001ms 로 불리는 동안 화면은 16.7ms 간격으로 갱신되어, 화면 한 번 사이에 타이머가 한 번도 불리지 않거나 두 번 불리는 프레임이 생겼다.
rAF 는 반대로 화면 갱신에 맞춰 불리므로 그리는 일을 콜백에 모으면 낭비되는 호출이 없다. 대신 숨은 탭에서는 멎으니 그 시간에도 돌아가야 하는 로직은 타이머나 시계 차이 계산으로 따로 둔다.
세 방식을 한 표에서 비교
| 방식 | 부르는 때 | 숨은 탭 | 알맞은 쓰임 |
|---|---|---|---|
setTimeout·setInterval |
정해 둔 시간이 지났을 때 | 계속 불리되 브라우저가 빈도를 낮출 수 있음 | 화면과 무관한 주기 작업 |
| requestAnimationFrame | 다음 화면 갱신 직전 | 멈춤 | 매 프레임 값을 계산하는 캔버스·물리 |
| CSS 애니메이션·전환 | 브라우저가 직접 진행 | 스크립트 없이 브라우저가 처리 | 두 상태 사이를 오가는 UI |
어느 것을 먼저 고를까
값이 두 상태 사이를 오가는 것뿐이면 CSS 로 충분하고 스크립트 루프를 만들 이유가 없다. 합성 비용과 will-change 의 영향은 CSS 애니메이션 성능 가이드에서 장면별로 다뤘다.
매 프레임 입력이나 계산이 끼면 rAF 를 쓰고, 부드러운 시작과 끝은 CSS 이징 함수 가이드의 곡선을 같은 시간 차 위에 얹으면 된다.
한 프레임 16.7ms 예산을 어떻게 나누어 쓰는가
16.7ms 는 60Hz 의 한 칸이다
1초를 60으로 나눈 16.7ms 가 60Hz 화면의 한 프레임이고, 이 안에 스크립트 계산과 브라우저의 스타일·배치·그리기가 함께 들어가야 한다. 콜백 하나가 16.7ms 를 다 쓰면 브라우저가 쓸 시간이 없다.
| 주사율 | 한 프레임 길이 |
|---|---|
| 30Hz | 33.33ms |
| 60Hz | 16.67ms |
| 144Hz | 6.94ms |
작업이 예산을 넘으면 간격이 계단으로 늘어난다
작업이 예산을 넘는다고 간격이 조금씩 늘지 않는다. 06 에서 보듯 다음 화면 갱신까지 기다렸다 그리므로 간격은 16.7에서 33.3, 49.9ms 처럼 화면 갱신 칸의 배수로 뛴다.
그래서 막대가 예산선을 한 번 넘기는 순간 체감 프레임 수가 반으로 줄고, 조금 덜 하는 것이 아니라 한 칸 아래 계단으로 내려간다.
개수는 이 기기에서 재서 정한다
입자 같은 반복 요소의 개수는 07 처럼 늘려 가며 평균 간격이 예산 칸을 넘기기 직전에서 멈춘다. 같은 숫자가 다른 기기에서 같은 간격을 낸다는 보장은 없어, 개수를 고정으로 박기보다 시작할 때 재거나 낮은 사양용 단계를 따로 둔다.
시간 차를 곱해 두면 개수가 한계를 넘어도 낙하 속도 자체는 지켜지고 끊김만 남는다. 이 둘을 따로 보는 것이 07 의 표시 이유다.
루프가 새거나 겹치는 함정 — 중복 루프와 값 누적 오차
루프를 두 번 걸면 속도가 두 배로 보인다
가장 흔한 깨짐은 루프가 겹치는 경우다. 이미 도는 루프가 있는데 시작 함수를 다시 부르면 frame 이 매번 두 번씩 요청되어 한 프레임에 이동이 두 번 일어난다. 데모는 요청 id rafId 를 보관하고 이미 있으면 바로 돌아가도록 막는다.
function startLoop() {
if (rafId || holdFlag) {
return;
}
// 멈췄던 사이의 시간을 첫 프레임 간격으로 넘기지 않는다
lastTs = -1;
rafId = window.requestAnimationFrame(frame);
}
function stopLoop() {
if (rafId) {
window.cancelAnimationFrame(rafId);
rafId = 0;
}
}
정지할 때 요청을 취소하지 않으면 다음 프레임 하나가 더 불리고, 컴포넌트가 사라진 뒤에도 콜백이 돌아 이미 없는 요소를 건드린다. 요청 id 를 저장하고 정리 단계에서 cancelAnimationFrame 하는 것이 원칙이다.
프레임마다 같은 계수는 기기마다 다른 속도가 된다
값을 조금씩 따라가게 하는 lerp 에서 계수를 상수로 두면 주사율이 곧 속도다. 09 는 같은 0.12 가 30Hz 와 144Hz 에서 수렴 시간이 다섯 배 가까이 벌어지는 것을 보였고, 03 의 가정 판도 같은 병이다. 계수나 가속도를 만들 때는 반드시 시간 차를 거친다.
값을 바꿔 본 차이
값 하나만 달리해 전과 후를 나란히 놓은 표다. 앞 절에서 쓴 숫자는 이 표에서 다시 적지 않았다.
| 이름 | 바꾼 값 | 느낌 |
|---|---|---|
| 두 번째 줄 주사율을 올려 | 01 ←→ 키로 144 → 240Hz | 프레임 수 판의 초속이 432px 에서 720px 로 오르고 도착이 0.79초에서 0.48초로 앞당겨지지만, 시간 차 판은 3.10초 그대로다 |
| 고정 계수를 보정 계수로 | 09 K_FRAME 0.12 → LERP_K 7 |
144Hz 고정 판 319ms 와 30Hz 판 1533ms 의 4.8배 차가 보정 판에서는 840ms 대 833ms, 1% 차로 줄어든다 |
| 프레임 작업을 늘려 | 06 ←→ 키로 10ms → 34ms | 작업이 예산 16.7ms 를 넘는 순간 간격이 16.7ms 에서 33.3~49.9ms 로 계단을 오른다 |
바꾼 값이 하나라서 어느 값이 느낌을 바꿨는지 바로 읽힌다. 시간 차를 곱하는 쪽은 값을 바꿔도 결과가 변하지 않고, 곱하지 않는 쪽만 흔들리는 것이 이 편의 요점이다.
장면 아홉 개의 소스와 react 판, 예제 파일을 한데 담은 zip 은 아래 상자에서 내려받으며, 압축을 풀 때 쓰는 암호는 68sk3uyw 이다.
브라우저 호환과 접근성 — 움직임 줄이기 설정과 일시정지
어느 브라우저부터 쓸 수 있나
caniuse 에서 직접 확인한 값으로 requestAnimationFrame 과 Page Visibility 모두 전역 지원 97.57% 다. 접두사 없이 처음 지원한 버전은 Chrome 24·Firefox 23·Safari 6.1·Edge 12·IE 10 이고, 접두 지원은 Chrome 10 과 Firefox 4 부터다.
| 기능 | Chrome | Firefox | Safari | Edge |
|---|---|---|---|---|
| requestAnimationFrame (접두사 없음) | 24 | 23 | 6.1 | 12 |
| requestAnimationFrame (접두 지원 시작) | 10 | 4 | 미확인 | 미확인 |
Page Visibility visibilitychange |
14 | 10 | 6.1 | 12 |
각주: caniuse 의 주석에 따르면 일부 구버전은 cancelAnimationFrame 이 없고 webkitCancelRequestAnimationFrame 만 있어 부분 지원으로 분류된다. 접두 지원의 Safari·Edge 칸은 이 글에서 확인하지 못해 미확인으로 두었다.
출처: MDN requestAnimationFrame · MDN cancelAnimationFrame · MDN visibilitychange · caniuse requestAnimationFrame
어느 행을 보고 쓸까
표에서 가장 늦은 칸은 Safari 6.1 과 Firefox 23 이다. 이보다 낮은 버전까지 지원해야 하는 프로젝트는 드물고, 그런 경우에만 접두 이름인 webkitRequestAnimationFrame 을 확인하거나 setTimeout 으로 대신 부르는 폴백을 둔다.
전역 지원이 97.57% 라는 것은 나머지 2.43% 의 환경에서는 이 함수가 없거나 확인되지 않았다는 뜻이다. 방문자 로그에서 그 비율이 얼마나 되는지 본 뒤에 폴백 한 줄을 둘 값어치가 있는지 정하면 된다.
줄이기가 켜지면 루프를 만들지 않는다
움직임 줄이기 설정이 켜져 있으면 아홉 데모 모두 frame 이 곧바로 돌아가 rAF 를 한 번도 요청하지 않는다. 대신 finalState 가 60분의 1초 단계로 시간표 끝의 상태를 계산만 해서 한 장 그리고, 설정이 바뀌면 change 리스너가 다시 읽는다.
독자 코드도 구조는 같다. 아래는 데모 소스가 아니라 그대로 붙여 쓸 수 있는 틀로, 설정이 켜지면 요청을 걸지 않고 끝 모양만 한 번 그린다.
const reduce = window.matchMedia('(prefers-reduced-motion: reduce)');
function start() {
if (reduce.matches) {
drawFinal();
return;
}
requestAnimationFrame(tick);
}
reduce.addEventListener('change', start);
CSS 쪽 애니메이션은 아래 두 규칙이 함께 있어야 같은 설정에서 멈춘다.
@media (prefers-reduced-motion: reduce) {
.scene {
animation: none;
transition: none;
}
}
설정 전반을 장면별로 고르는 기준은 prefers-reduced-motion 적용 가이드에 따로 정리했다.
자동 시연이 한 바퀴 도는 시간
아홉 장면은 모두 시간표로 한 바퀴를 자동 시연하고 끝나면 처음부터 다시 돈다. 한 바퀴의 길이는 01 이 4.6초, 02 가 6초, 03 이 5.4초, 04 가 4.4초, 05 가 5초, 06·07 이 3.6초, 08 이 4초, 09 가 5.4초다.
그래서 키보드를 쓰지 못해도 조작 없이 모든 값을 볼 수 있고, 아래의 키는 어디까지나 보조 수단이다.
일시정지와 키보드
모든 장면에 일시정지 버튼이 있고 aria-pressed 로 상태를 알린다. Space·Enter·P 가 일시정지, R 이 처음부터이고 04·08 은 A 키가 동작 버튼이며 01·06·07 은 ←→ 로 값을 고른다.
낭독 문장은 role="status" 와 aria-live="polite" 영역에 모드가 바뀔 때만 쓰므로 시연 중 매 프레임 읽히지 않는다. 탭이 숨으면 루프가 멈추는 것도 접근성에는 이득이다.
requestAnimationFrame FAQ — 초당 몇 번 불리고 React 에서는 어떻게 쓰나
requestAnimationFrame 은 초당 몇 번 불리나요
화면 주사율과 같다. 60Hz 화면이면 초당 약 60번, 144Hz 면 약 144번이고 그 사이 간격이 delta time 이다. 이 글의 헤드리스 크롬은 60Hz 에 묶여 간격이 16.7ms 안팎이었고, 30Hz·144Hz 실기기 값은 미확인이다.
requestanimationframe react 에서는 어디에 루프를 만드나요
useEffect 안에서 요청을 시작하고 정리 함수에서 cancelAnimationFrame 으로 끊는다. 요청 id 와 매 프레임 바뀌는 값은 useRef 에 두어야 하고, 매 프레임 setState 를 부르면 그때마다 컴포넌트가 다시 그려져 비용이 커진다. zip 의 react 판이 같은 구조다.
숨은 탭에서도 시간을 이어 가야 하면 어떻게 하나요
rAF 는 멈추므로 화면 쪽 값과 시간 쪽 값을 나눈다. 화면에 그리는 이동은 복귀 때 시간 차 상한으로 자르고, 카운트다운처럼 실제 시간이 흘러야 하는 값은 performance.now 차이로 복귀 순간에 한 번에 다시 계산한다.
둘을 섞으면 04 의 점프가 그대로 나온다. 어떤 값이 시계를 따라가야 하고 어떤 값이 화면만 따라가면 되는지부터 구분해 두는 것이 이 질문의 답이다.









