게임 프로그래밍

고정 타임스텝 루프, 한 번 제대로 이해하기

·9분·English
목차dt를 곱해도 결과가 달라지는 이유누적기: 시간을 모았다가 같은 크기로 퍼내기밀린 시간과 남은 시간따라잡을수록 더 밀리는 죽음의 나선과 시간 상한남은 시간으로 하는 보간엔진에서는시뮬레이션의 시간과 화면의 시간을 떼어 놓기참고 자료

게임 캐릭터의 점프는 보통 이런 두 줄로 시작합니다. 매 프레임 중력만큼 속도를 줄이고 그 속도만큼 위치를 옮깁니다. 프레임마다 걸린 시간 dt를 곱해 두었으니 프레임레이트와 상관없이 똑같이 움직일 것 같습니다.

velocity -= GRAVITY * dt;
y += velocity * dt;

그런데 이 코드를 초속 8m로 뛰어올라 중력 20m/s²를 받는 점프에 그대로 써서 30fps, 60fps, 144fps로 돌려 보면 최고점이 각각 1.47m, 1.53m, 1.57m로 나옵니다. 같은 맵의 같은 턱을 어떤 사람은 넘고 어떤 사람은 못 넘는다는 뜻입니다.

누적기 물탱크Interactive
0000
국자: 한 번에 정확히 dt(1/60초)만큼 퍼 가고, 쏟을 때마다 톱니가 한 칸, 물리 업데이트가 한 번 돕니다수조 수위 = 누적기: 눈금 한 칸이 dt, 굵은 첫 칸이 국자 하나만큼입니다렌더 프레임마다 수도꼭지는 실제로 흐른 시간만큼 물을 헤드 박스에 붓습니다. 0.25초를 넘는 물은 둑을 넘어 배수 통으로 버려지고 수조에 들어가지 않습니다. 수조의 물이 눈금 한 칸(dt) 이상이면 국자가 내려가 dt만큼 퍼 오고, 계수탑에 쏟을 때마다 톱니바퀴가 한 칸 돌며 물리 업데이트가 한 번 진행됩니다. 한 칸이 안 되는 나머지는 수조에 남아 다음 프레임으로 넘어가고, 나머지÷dt가 alpha 눈금판에 나타납니다. 오른쪽 기둥의 두 탭은 마지막 두 스텝의 점프 높이, 슬라이더는 그 사이를 alpha만큼 보간해 화면에 그리는 위치입니다. 실제로는 한 프레임이 몇 밀리초라 아주 느리게 재생합니다(60 fps에서 한 프레임이 약 1.6초).

고정 타임스텝 루프를 물 기계로 본 그림: 수도꼭지가 렌더 프레임마다 실제로 흐른 시간만큼 물을 헤드 박스에 붓고, 0.25초를 넘는 물은 둑을 넘어 배수 통으로 버려집니다(최대 프레임 시간 제한). 헤드 박스의 물은 단면으로 자른 수조, 곧 누적기로 내려가고 수조 벽에는 dt 단위 눈금이 있습니다. 수조에 dt 이상 차 있는 동안 정확히 dt만큼 담는 국자가 물을 퍼서 계수탑에 쏟고, 그때마다 톱니바퀴가 한 칸 돌아 물리 업데이트가 한 번 진행됩니다. dt에 못 미치는 나머지는 수조에 남고, 나머지를 dt로 나눈 alpha가 눈금판 바늘로, 마지막 두 스텝 사이를 alpha만큼 보간한 점프 높이가 기둥의 슬라이더로 나타납니다. 30 fps에서는 프레임마다 두 번, 60 fps에서는 한 번, 144 fps에서는 대개 한 번도 퍼지 않습니다.

이 문제를 푸는 표준 해법인 고정 타임스텝 루프를 짧게 먼저 적으면 이렇습니다. 실제로 흐른 시간을 통에 모아 두고 그 통에서 언제나 같은 크기(dt)의 조각만 퍼내 물리를 한 번씩 돌립니다. 다 퍼내지 못한 자투리는 다음 프레임으로 넘기고 화면에는 그 자투리 비율만큼 직전 상태와 지금 상태를 섞어 그립니다. 위 그림은 이 과정을 물탱크로 옮겼습니다. 수도꼭지가 프레임마다 흘려보내는 물이 실제로 흐른 시간, 수조의 수위가 누적기, 국자 한 번이 물리 업데이트 한 번입니다. 국자를 쏟을 때마다 톱니바퀴가 한 칸 돌고 바닥에 남은 물의 비율이 오른쪽 alpha 눈금판에 나타납니다. 실제로는 한 프레임이 몇 밀리초라서 아주 느리게 재생합니다.

기본 뼈대는 Glenn Fiedler가 2004년에 쓴 Fix Your Timestep!과 Robert Nystrom의 Game Programming Patterns의 Game Loop 장을 따랐습니다. 이 글의 데모와 그림은 모두 같은 작은 시뮬레이션 코드(초속 8m 점프, 중력 20m/s², 물리 간격 1/60초)에서 나옵니다. 글에 나오는 코드는 설명을 위해 단순화한 예제입니다.

dt를 곱해도 결과가 달라지는 이유

위 두 줄은 수치 적분입니다. 실제로는 속도가 매 순간 조금씩 줄어드는데 코드는 한 프레임 동안 속도가 그대로라고 보고 한 번에 위치를 옮깁니다. 이렇게 잘라서 더하는 근사는 자르는 간격, 곧 dt가 클수록 정답에서 멀어집니다. 정확한 최고점은 이렇습니다.

h=v022g=822×20=1.6 mh = \frac{v_0^2}{2g} = \frac{8^2}{2 \times 20} = 1.6\,\mathrm{m}

위 코드처럼 속도를 먼저 바꾸고 바뀐 속도로 위치를 옮기는 방식(semi-implicit Euler)은 매 프레임 조금씩 덜 올라가므로 프레임이 굵을수록 점프가 낮아집니다. 순서를 반대로 쓰면 반대로 높아집니다. 어느 쪽이든 결과가 dt에 묶여 있다는 점은 같습니다.

같은 점프를 30, 60, 144fps로 계산한 점들과 정확한 포물선을 겹친 그래프입니다. 꼭대기가 각각 1.4667, 1.5333, 1.5723m로 정확한 값 1.6m보다 낮고, 30fps와 144fps 사이가 10.6cm입니다. 세로축은 1.3m 아래를 생략했습니다.

같은 코드도 프레임레이트마다 꼭대기가 다릅니다. 점 하나가 프레임 하나입니다.

아래 데모는 같은 코드를 세 프레임레이트로 나란히 돌립니다. 캐릭터 옆의 흐린 점은 그 캐릭터가 그려진 프레임입니다. 위쪽 루프 토글을 고정 타임스텝으로 바꾸면 세 캐릭터가 모두 1.53m를 뜁니다. 정답인 1.6m가 되는 것이 아니라 셋의 오차가 같아진다는 점이 중요합니다.

프레임레이트별 점프 실험실Interactive
루프
30 fps dt 33.3 ms · 최고점 1.47 m60 fps dt 16.7 ms · 최고점 1.53 m144 fps dt 6.9 ms · 최고점 1.57 m정확한 값 1.60 m

프레임마다 dt: 각 캐릭터가 자기 프레임 간격(30 fps는 33.3 ms, 144 fps는 6.9 ms)을 dt로 써서 한 번씩 적분합니다. 프레임이 성길수록 최고점이 낮아집니다.

똑같은 캐릭터 셋이 30 fps, 60 fps, 144 fps로 나란히 점프합니다. 왼쪽에는 미터 눈금자가 있고, 정확한 최고점 1.6 m에 점선이, 캐릭터마다 실제로 닿은 최고점에 실선이 그어집니다. 캐릭터 옆의 작은 점은 그 캐릭터가 화면에 그려진 순간들이라 30 fps 쪽이 가장 성깁니다. 프레임마다 dt로 적분하면 최고점이 1.47 m, 1.53 m, 1.57 m로 갈리고, 고정 타임스텝으로 바꾸면 셋 다 1.53 m로 같아집니다. 다시 점프 단추와 멈춤 단추가 있습니다.

점프 높이는 눈에 보이는 문제일 뿐입니다. 프레임 시간은 실제로는 매 프레임 조금씩 흔들리므로 같은 컴퓨터에서 같은 입력을 넣어도 결과가 매번 미묘하게 달라집니다. 입력만 저장해 다시 돌리는 리플레이나, 입력만 주고받고 각자 시뮬레이션하는 네트워크 동기화는 이런 루프 위에서 만들기 어렵습니다. 프레임마다 dt까지 기록해 두지 않으면 같은 결과가 다시 나오지 않습니다. 컴퓨터끼리는 dt가 서로 달라서 기록해도 맞출 수 없습니다.

누적기: 시간을 모았다가 같은 크기로 퍼내기

가장 쉽게 하려면 dt를 상수로 박으면 됩니다. 실제로 얼마가 흘렀든 매 프레임 update(1 / 60)을 부릅니다. 이제 결과는 어느 컴퓨터에서나 똑같습니다.

대신 게임 속 시간이 화면 갱신 속도에 묶입니다. 30fps밖에 안 나오는 컴퓨터에서는 1초에 업데이트가 30번만 돌아 게임 전체가 절반 속도로 느려지고 144fps 모니터에서는 2.4배 빨라집니다. 고정 주사율로 돌아가는 콘솔이나 오래된 게임기에서는 이것으로 충분했지만, 사양과 주사율이 제각각인 PC와 모바일에서는 쓸 수 없습니다.

결국 바라는 것은 두 가지입니다. 물리는 언제나 같은 크기의 dt로 돌고 게임 속 시간은 실제 시간을 따라가야 합니다.

두 조건을 모두 만족시키는 방법이 누적기(accumulator)입니다. 매 프레임 실제로 흐른 시간을 변수 하나에 더해 두고 그 값이 dt 이상인 동안 물리를 dt만큼 돌리고 dt를 뺍니다.

let acc = 0;
let last = performance.now() / 1000;

function tick() {
  const now = performance.now() / 1000;
  acc += now - last;
  last = now;

  while (acc >= DT) {
    update(DT);
    acc -= DT;
  }

  render();
  requestAnimationFrame(tick);
}

물리 간격을 1/60초로 두면 30fps 컴퓨터에서는 프레임마다 업데이트가 두 번, 60fps에서는 한 번 돕니다. 144fps에서는 대부분의 프레임에서 한 번도 돌지 않다가 자투리가 쌓여 dt를 넘는 프레임에서만 한 번 돕니다.

약 100ms의 실제 시간 축 위에 12, 33, 7, 25, 6, 18ms 길이의 렌더 프레임과 16.7ms마다 오는 물리 틱을 나란히 그린 도식입니다. 프레임마다 돌린 틱 수는 0, 2, 1, 1, 0, 2이고, 남은 시간의 비율 α는 .72, .70, .12, .62, .98, .06입니다.

프레임 길이가 들쑥날쑥해도 틱은 16.7ms 간격 그대로입니다. 프레임마다 돌리는 틱 수가 달라지고 남은 시간은 다음 프레임으로 넘어갑니다.

맨 위 물탱크 그림의 30 fps, 60 fps, 144 fps 버튼을 눌러 보면 이 차이가 국자 횟수로 보입니다. 어느 경우든 국자의 크기는 같습니다. 그래서 점프 높이도 같습니다.

밀린 시간과 남은 시간

따라잡을수록 더 밀리는 죽음의 나선과 시간 상한

누적기에는 함정이 하나 있습니다. 물리 한 번을 계산하는 데 걸리는 시간이 dt보다 길어지면 어떻게 될까요? 밀린 시간을 따라잡으려고 업데이트를 더 돌리면 그 프레임이 더 오래 걸리고 다음 프레임에는 더 많이 밀립니다.

틱 하나에 25ms, 렌더에 5ms가 든다고 가정하고 프레임당 물리 틱 수를 10프레임 동안 그린 그래프입니다. 클램프가 없으면 1, 1, 2, 3, 5, 8, 12, 19, 28, 43으로 치솟고, 0.25초 클램프가 있으면 15에서 멈춥니다.

틱 하나에 25ms가 걸린다고 가정한 계산입니다. 1/60초 안에 끝나지 않는 틱을 따라잡으려 할수록 틱 수가 불어납니다.

Fiedler는 먼저 물리 계산에 넉넉한 여유를 두라고 권하고 그게 안 되면 한 프레임에 돌릴 스텝 수에 상한을 두라고 적습니다. 그의 최종 코드는 같은 일을 시간 쪽에서 합니다. 프레임 시간이 0.25초를 넘으면 0.25초로 자릅니다. 물리 간격이 1/60초라면 한 프레임에 업데이트가 아무리 많아도 15번에서 멈춥니다. 그 대가로 그 순간 게임 속 시간은 실제 시간보다 느리게 흐릅니다. 멈춰 버리는 것보다 잠깐 느려지는 쪽을 고릅니다.

물탱크 그림의 0.5초 끊김 넣기 버튼은 0.5초짜리 프레임 하나를 흘려보냅니다. 0.25초를 넘는 물은 둑을 넘어 배수 통으로 버려지고 국자는 15번만 움직입니다.

남은 시간으로 하는 보간

누적기 루프를 돌리고 나면 프레임마다 dt보다 작은 자투리가 acc에 남습니다. 이 자투리를 무시하고 마지막 물리 상태를 그대로 그리면, 물리와 화면의 박자가 맞지 않을 때 물체가 계단을 밟듯 움직입니다. 물리가 20Hz이고 모니터가 144Hz라면 같은 위치를 일곱 프레임쯤 연달아 보여 주다가 한 번에 건너뜁니다. Godot 문서는 이 현상을 물리 틱과 렌더 프레임의 시간 차이에서 생기는 계단 효과, 곧 지터(jitter)라고 설명합니다.

Fiedler는 마지막 단계에서 이 자투리를 씁니다. 자투리를 dt로 나누면 지금이 다음 물리 상태까지 얼마나 와 있는지를 나타내는 0과 1 사이의 비율이 나옵니다.

α=accdt\alpha = \frac{\mathrm{acc}}{dt}
drawn=prev⋅(1−α)+curr⋅α\mathrm{drawn} = \mathrm{prev} \cdot (1 - \alpha) + \mathrm{curr} \cdot \alpha

물리를 돌릴 때마다 직전 상태 prev를 남겨 두고 그릴 때는 prev와 지금 상태 curr를 alpha만큼 섞습니다. 아래 데모에서 물리 갱신을 10Hz에 두고 보간을 껐다 켜 보세요. 점선 원이 물리 상태 prev와 curr이고 채워진 공이 화면에 그려지는 위치입니다. 보간을 끄면 공이 curr에 붙어 있다가 한 칸씩 건너뛰고, 켜면 두 원 사이를 미끄러집니다. 아래쪽 막대는 프레임마다의 alpha입니다.

보간 실험실Interactive
물리 갱신
보간
화면에 그린 공물리 상태 (직전 prev · 현재 curr)지난 물리 상태

보간 끔: 공을 마지막 물리 상태(curr)에 그립니다. 다음 물리 갱신이 올 때까지 공이 제자리에 서 있다가 한 칸씩 건너뜁니다. 물리 갱신이 드물수록 더 뚝뚝 끊깁니다.

파란 공 하나가 무대를 왔다 갔다 하며 통통 튑니다. 화면은 모니터 주사율대로 그리지만, 공의 물리는 고른 빈도(10, 20, 30, 60 Hz)로만 갱신됩니다. 점선 원 두 개는 직전(prev)과 현재(curr) 물리 상태, 작은 점은 지난 물리 상태들이고, 아래 띠는 프레임마다의 alpha(남은 시간 ÷ dt)를 막대로 보여 줍니다. 보간을 끄면 공이 curr에 붙어 있다가 한 칸씩 건너뛰어 뚝뚝 끊기고, 켜면 prev와 curr 사이를 alpha만큼 섞어 매끄럽게 움직입니다.

공짜는 아닙니다. 보간한 위치는 언제나 prev와 curr 사이에 있으므로 화면은 물리보다 한 틱 늦게 따라갑니다. 물리가 1/60초 간격이면 약 16.7ms, 아래 그림처럼 20Hz면 50ms입니다. 그래서 매끈한 파란 선이 계단보다 오른쪽 아래에 있습니다. Nystrom의 장은 같은 자투리를 반대 방향으로 씁니다. 현재 속도로 조금 앞을 내다보고 그리는 외삽입니다. 이 경우 지연은 없지만 그의 말대로 the extrapolation is a bit of a guess and sometimes ends up wrong. 벽에 부딪히기 직전의 공이 벽 안쪽에 한 프레임 그려지는 식입니다. 그는 이런 어긋남이 보통 눈에 띄지 않는다고 덧붙입니다.

물리 20Hz, 화면 144Hz에서 일정한 속도로 움직이는 물체의 그려진 위치 그래프입니다. 보간이 없으면 회색 점이 계단처럼 머물다 뛰고, 보간하면 파란 점이 매끈한 직선을 이루지만 실제 위치보다 50ms 늦습니다. 125ms 프레임에는 남은 시간 25ms, α 0.5가 표시돼 있습니다.

물리 20Hz, 화면 144Hz. 보간하면 계단이 사라지는 대신 화면이 한 틱(여기서는 50ms) 늦습니다.

엔진에서는

엔진을 쓰면 이 루프를 직접 짤 일은 드뭅니다. 대신 이 글의 부품들이 설정 이름으로 나타납니다.

이 글의 부품UnityGodot
고정 dt 안에서 도는 코드FixedUpdate_physics_process
물리 간격Fixed TimestepPhysics Ticks per Second (기본 60)
따라잡기 상한Maximum Allowed Timestep (시간 상한, 기본 0.333초)Max Physics Steps per Frame (스텝 수 상한, 기본 8)
남은 시간 보간Rigidbody.interpolation (기본 꺼짐)Physics Interpolation (기본 꺼짐, 4.3에서 2D, 4.4에서 3D)

Unity 문서는 Rigidbody.interpolation을 기본으로 꺼 두고 It is recommended to turn on interpolation for the main character but disable it for everything else라고 권합니다.

상한을 두는 방식은 조금 다릅니다. Unity는 한 프레임에 더할 시간을 자르고 Godot은 한 프레임에 돌릴 스텝 수를 자릅니다. 기본값 8에 초당 60틱이면 렌더링이 7.5fps 아래로 떨어질 때부터 게임이 느려지기 시작합니다.

자주 나오는 실수도 이 표로 설명됩니다. 물리로 움직이는 물체를 Update(프레임마다)에서 직접 옮기면 누적기 밖에서 가변 dt로 움직이는 것과 같아서 이 글의 첫 문제로 돌아갑니다. 반대로 입력을 FixedUpdate에서만 읽으면 물리가 돌지 않은 프레임의 입력을 놓칠 수 있습니다. 입력은 프레임마다 읽어 두고 물리 스텝에서 소비하는 편이 안전합니다.

시뮬레이션의 시간과 화면의 시간을 떼어 놓기

전체 루프를 한 번에 적으면 이렇습니다. Fiedler의 최종 코드와 같은 구조입니다.

const DT = 1 / 60;
const MAX_FRAME = 0.25;

let acc = 0;
let last = performance.now() / 1000;
let prev = initialState();
let curr = prev;

function tick() {
  const now = performance.now() / 1000;
  const frameTime = Math.min(now - last, MAX_FRAME); // 죽음의 나선 방지
  last = now;
  acc += frameTime;

  while (acc >= DT) {
    prev = curr;
    curr = step(curr, DT); // 언제나 같은 크기
    acc -= DT;
  }

  const alpha = acc / DT; // 다음 상태까지 온 비율
  render(lerp(prev, curr, alpha));
  requestAnimationFrame(tick);
}

고정 타임스텝 루프는 시뮬레이션의 시간과 화면의 시간을 떼어 놓습니다. 시뮬레이션은 언제나 같은 박자로 걸어서 어느 컴퓨터에서나 같은 결과를 내고 화면은 그 걸음 사이를 메워 매끈하게 보여 줍니다. 다만 같은 dt로 돌린다고 해서 완전히 같은 결과가 보장되지는 않습니다. 부동소수점 연산 순서나 플랫폼 차이까지 맞춰야 하는 결정론은 그다음 문제이고 고정 타임스텝은 그 출발점입니다.

참고 자료

원전

엔진 문서