Godot XR Multiplayer: Spatial Sync 및 Time-Rewind Netcode의 내부 동작 원리

godot xr multiplayer 게임을 빌드할 때, spatial synchronization이 단 한 프레임이라도 뒤처지면 플레이어에게 심각한 멀미(motion sickness)를 유발하는 지름길이 됩니다. 플레이어가 네이티브 90Hz 주사율로 머리나 손을 움직일 때, 네트워크 jitter나 뒤늦은 상태 동기화(late-state synchronization)가 발생하면 플레이어의 실제 신체와 가상 세계 사이에 심각한 괴리감이 생깁니다. 이러한 spatial latency를 해결하려면 전통적인 flat-screen netcode 패러다임을 우회하고 커스텀 predictive tracking buffers를 구현해야 합니다.

고급 temporal mechanics와 커스텀 netcode 패턴을 살펴보면, server bandwidth를 과부하하지 않고도 클라이언트 카메라와 physics entities를 완벽한 동기화 상태로 유지할 수 있습니다.

Under the Hood: VR Multiplayer에서 Spatial Sync가 직면한 극적인 도전 과제

일반적인 flat-screen multiplayer 게임에서는 3D position vector(12바이트)와 1D rotation float(4바이트)로 구성된 단일 캐릭터 캡슐 collider를 동기화합니다. 이 16바이트 payload를 30Hz로 전송하면 초당 약 480바이트의 raw 데이터가 생성됩니다. 하지만 godot xr multiplayer 환경에서는 head-mounted display(HMD)와 두 개의 모션 컨트롤러 등 세 개의 고주파 tracked components를 동시에 동기화해야 합니다. 각각의 tracked point는 3D position vector(12바이트)와 3D orientation quaternion(16바이트)을 필요로 하므로 포인트당 총 28바이트가 소요됩니다.

이 세 포인트를 모두 동기화하려면 프레임당 84바이트가 필요합니다. 표준 90Hz 주사율에서는 초당 7,560바이트(7.56 KB)의 raw payload가 요구됩니다. 여기에 표준 UDP packet overhead(헤더당 28바이트)를 더하면, 단일 클라이언트가 최대 10.08 KB/s를 점유하게 됩니다. 8인 로비의 경우, 서버는 최대 564 KB/s의 고주파 데이터를 처리하고 broadcast해야 하므로, 막대한 다운스트림 병목 현상과 packet queue 지연이 발생합니다.

표준 flat-screen 게임은 how to fix player location desync in Unreal Engine multiplayer 가이드에서 다룬 것처럼 약간의 오차를 허용할 수 있지만, VR 게임은 전혀 자비가 없습니다. 단 3프레임의 spatial desync조차 급격한 전정기관 불일치(vestibular mismatch)를 유발하여 플레이어에게 직접적인 멀미를 일으킬 수 있습니다. 이를 해결하기 위해 개발자는 엄격한 server-authoritative replication 방식에서 벗어나 historical delta reconciliation을 결합한 client-side prediction 방식으로 전환해야 합니다.

Godot XR Community Game Jam V 출품작에서 얻은 5가지 Spatial 교훈

다섯 번째 Godot XR Community Game Jam V에는 "Rewind"라는 주제 아래 98명의 참가자가 23개의 게임을 출품했습니다. 이 프로젝트들은 Godot 4의 spatial architecture의 한계를 넓히며, 몰입형 공간에서 시간 조작을 창의적으로 적용하는 방법을 보여주었습니다. 다음은 이번 잼의 상위 5개 출품작에서 추출한 핵심 spatial synchronization 및 netcode 교훈입니다.

1. Tactile Physics와 Interaction States (Rewind Tower에서 얻은 영감)

이번 대회 우승작인 Rewind Tower는 플레이어가 코인 작동식 보드에서 기계 유닛의 태엽을 감고(wind up) 이를 되돌려(rewind) 전투를 유지하는 tactile 타워 디펜스 시스템을 특징으로 합니다. multiplayer 시나리오에서 물리적인 grab과 아날로그 spring-winding 상태를 동기화하는 것은 심각한 race condition을 유발합니다.

두 플레이어가 동시에 동일한 유닛을 잡으려고 시도할 때, 단순한 replication 시스템을 사용하면 두 플레이어가 네트워크 권한(network authority)을 차지하기 위해 다투는 과정에서 오브젝트가 두 플레이어 사이를 빠르게 순간이동(teleport)하게 됩니다. 이를 해결하기 위해 개발자는 서버에 deterministic priority queue를 구현하여 한 클라이언트를 임시 물리적 권한 소유자로 지정하고, 해당 오브젝트가 해제될 때까지 외부 grab 입력을 차단해야 합니다.

2. Hand-Held Analog Controls와 Continuous Input Sync (Chrono Crank에서 얻은 영감)

2위를 차지한 Chrono Crank는 시간의 흐름을 조작하는 데 사용되는 대형 물리 크랭크가 장착된 스팀펑크 스타일의 휴대용 장치에 의존합니다. 물리적인 크랭크 회전을 복제하려면 연결된 모든 플레이어 간에 정밀도가 높은 continuous float 값을 동기화해야 합니다.

아날로그 레버와 노브는 바이너리 상태 트리거가 아닌 지속적인 위치 업데이트가 필요합니다. 고주파 RPC를 사용하여 이러한 대화형 물리 좌표를 동기화하려는 시도는 개발자들이 fixing the multiplayer RPC replication issues that break world states에서 겪는 문제와 동일한 전형적인 함정입니다.

대신, 다이얼의 로컬 회전 각도를 압축된 float 변수로 동기화하고, 수신 클라이언트에서 Hermite spline interpolation을 사용하여 상태를 보간(interpolate)해야 합니다.

3. Spatial Recording 및 Scrubbing (NeuroCorp Training Demo에서 얻은 영감)

3위 작품인 NeuroCorp Training Demo에서는 플레이어가 과거 물리적 사건의 몰입형 기록 속으로 순간이동하여, 태스크를 완료하기 위해 시간을 앞뒤로 탐색(scrub)할 수 있습니다. 공유 로비에서 이러한 temporal scrub 이벤트를 동기화하려면 글로벌 상태 버퍼(global state buffer)가 필요합니다.

플레이어가 기록을 scrub할 때 시스템은 모든 클라이언트 간에 재생 타임스탬프(playback timestamp)를 동기화해야 합니다. 전체 룸의 물리적 기록을 프레임별로 로드하는 것은 상당한 메모리를 소비하므로, 네트워크 레이어는 인덱스 기반 keyframe 구조를 사용해 프레임 데이터를 serialize해야 합니다. 이를 통해 클라이언트는 연속적인 transform 프레임을 스트리밍하는 대신 불연속적인 위치 샘플 사이를 로컬에서 보간(interpolate)할 수 있습니다.

4. Parallel Spatial Timelines (Last Minute에서 얻은 영감)

4위로 마친 Last Minute은 플레이어가 실시간으로 퍼즐을 풀기 위해 시간을 조작하는 방탈출 게임입니다. multiplayer 게임 룸 내에서 비동기 시간 상태를 관리하는 것은 아키텍처 측면에서 엄청난 난제입니다.

플레이어 A가 퍼즐 박스를 10초 전의 상태로 되돌리는(rewind) 동안 플레이어 B가 현재 그 박스에서 나온 열쇠를 쥐고 있다면, 서버는 박스의 spatial timeline을 글로벌 플레이어 timeline으로부터 분리(decouple)해야 합니다. 이를 위해 게임 월드는 독립적인 temporal zones로 구조화되어야 하며, 활성 플레이어들을 현재 시스템 tick rate에 고정해 둔 채로 개별 spatial nodes가 자체 history buffers를 독립적으로 처리할 수 있도록 해야 합니다.

5. Multi-Entity Prediction 및 Platform Synced Motion (ScrewTheTime에서 얻은 영감)

5위를 확보한 ScrewTheTime은 플레이어가 자신의 캐릭터와 움직이는 플랫폼의 temporal 상태를 모두 제어하는 VR 플랫포머 게임입니다. VR에서 움직이고 되감기는 플랫폼 위에 서 있는 플레이어를 동기화하려면 parent-child coordinate space transforms가 필요합니다.

서버가 절대적인 글로벌 좌표만 동기화하면 플랫폼의 움직임과 플레이어 HMD 업데이트 간의 미세한 latency 차이로 인해 플레이어가 플랫폼에서 미끄러지거나 심하게 흔들리게 됩니다. 이를 해결하려면 클라이언트 측에서 플레이어의 spatial origin point를 움직이는 플랫폼 노드의 자식(child)으로 설정하고, 서버에 업데이트를 broadcast하기 전에 플랫폼의 로컬 basis를 기준으로 모든 로컬 머리 움직임 계산을 변환(translate)해야 합니다.

Deep Dive: Godot 4에서 Delta-Compressed Spatial Recording System 구축하기

되감기(rewind) 기능이 포함된 반응성 높은 godot xr multiplayer 경험을 구축하려면 tracked positions를 압축하는 spatial recording buffer를 구현해야 합니다. 다음의 프로덕션 등급 GDScript 4 클래스는 로컬 tracking 데이터(HMD 및 컨트롤러)를 ring buffer에 기록하고, 네트워크 트래픽을 최소화하기 위해 delta compression을 수행하며, 원격 클라이언트에서 부드럽게 재생되도록 spherical linear interpolation(SLERP)을 적용합니다.

# xr_spatial_sync_manager.gd
extends Node
class_name XRSpatialSyncManager

# Inner class to store high-frequency spatial tracking data for a single frame
class TrackingFrame extends RefCounted:
	var timestamp: float = 0.0
	var head_pos: Vector3 = Vector3.ZERO
	var head_rot: Quaternion = Quaternion.IDENTITY
	var left_hand_pos: Vector3 = Vector3.ZERO
	var left_hand_rot: Quaternion = Quaternion.IDENTITY
	var right_hand_pos: Vector3 = Vector3.ZERO
	var right_hand_rot: Quaternion = Quaternion.IDENTITY

	# Compress the frame into a lightweight dictionary for network serialization
	func serialize() -> Dictionary:
		return {
			"t": timestamp,
			"hp": [head_pos.x, head_pos.y, head_pos.z],
			"hr": [head_rot.x, head_rot.y, head_rot.z, head_rot.w],
			"lp": [left_hand_pos.x, left_hand_pos.y, left_hand_pos.z],
			"lr": [left_hand_rot.x, left_hand_rot.y, left_hand_rot.z, left_hand_rot.w],
			"rp": [right_hand_pos.x, right_hand_pos.y, right_hand_pos.z],
			"rr": [right_hand_rot.x, right_hand_rot.y, right_hand_rot.z, right_hand_rot.w]
		}

	# Decompress a network dictionary back into a fully typed frame
	static func deserialize(data: Dictionary) -> TrackingFrame:
		var frame = TrackingFrame.new()
		frame.timestamp = data["t"]
		frame.head_pos = Vector3(data["hp"][0], data["hp"][1], data["hp"][2])
		frame.head_rot = Quaternion(data["hr"][0], data["hr"][1], data["hr"][2], data["hr"][3])
		frame.left_hand_pos = Vector3(data["lp"][0], data["lp"][1], data["lp"][2])
		frame.left_hand_rot = Quaternion(data["lr"][0], data["lr"][1], data["lr"][2], data["lr"][3])
		frame.right_hand_pos = Vector3(data["rp"][0], data["rp"][1], data["rp"][2])
		frame.right_hand_rot = Quaternion(data["rr"][0], data["rr"][1], data["rr"][2], data["rr"][3])
		return frame

# --- Configuration Properties ---
@export var sync_threshold_position: float = 0.005 # 5mm threshold for delta-compression
@export var sync_threshold_rotation: float = 0.02  # ~1.15 degrees threshold for angular changes
@export var buffer_max_time: float = 2.0           # Store up to 2 seconds of local history
@export var playback_interpolation_delay: float = 0.033 # 33ms interpolation window

# --- Node References ---
@export var xr_origin: XROrigin3D
@export var xr_camera: XRCamera3D
@export var left_controller: XRController3D
@export var right_controller: XRController3D

# --- Internal Buffers ---
var history_buffer: Array[TrackingFrame] = []
var last_sent_frame: TrackingFrame = null

func _ready() -> void:
	if not xr_origin or not xr_camera or not left_controller or not right_controller:
		push_warning("XRSpatialSyncManager: Tracked nodes are not fully assigned!")

# Record the current spatial state of the VR user
func capture_current_frame() -> TrackingFrame:
	var frame = TrackingFrame.new()
	frame.timestamp = Time.get_ticks_msec() / 1000.0
	
	# Capture relative transforms inside the XR origin space
	frame.head_pos = xr_camera.transform.origin
	frame.head_rot = xr_camera.transform.basis.get_rotation_quaternion()
	frame.left_hand_pos = left_controller.transform.origin
	frame.left_hand_rot = left_controller.transform.basis.get_rotation_quaternion()
	frame.right_hand_pos = right_controller.transform.origin
	frame.right_hand_rot = right_controller.transform.basis.get_rotation_quaternion()
	
	return frame

# Push a captured frame into our sliding history ring buffer
func store_frame(frame: TrackingFrame) -> void:
	history_buffer.append(frame)
	
	# Prune frames older than the maximum buffer timeline window
	var expiration_time = frame.timestamp - buffer_max_time
	while history_buffer.size() > 0 and history_buffer[0].timestamp < expiration_time:
		history_buffer.remove_at(0)

# Evaluate if the current frame differs enough from the last sync frame to justify sending a network packet
func check_delta_compression(current: TrackingFrame) -> bool:
	if last_sent_frame == null:
		return true # Always send the initial setup frame
	
	# Check spatial distance changes
	var head_pos_diff = current.head_pos.distance_squared_to(last_sent_frame.head_pos)
	var left_pos_diff = current.left_hand_pos.distance_squared_to(last_sent_frame.left_hand_pos)
	var right_pos_diff = current.right_hand_pos.distance_squared_to(last_sent_frame.right_hand_pos)
	
	if head_pos_diff > (sync_threshold_position * sync_threshold_position) or \
	   left_pos_diff > (sync_threshold_position * sync_threshold_position) or \
	   right_pos_diff > (sync_threshold_position * sync_threshold_position):
		return true
		
	# Check angular orientation changes
	var head_rot_diff = current.head_rot.angle_to(last_sent_frame.head_rot)
	var left_rot_diff = current.left_hand_rot.angle_to(last_sent_frame.left_hand_rot)
	var right_rot_diff = current.right_hand_rot.angle_to(last_sent_frame.right_hand_rot)
	
	if head_rot_diff > sync_threshold_rotation or \
	   left_rot_diff > sync_threshold_rotation or \
	   right_rot_diff > sync_threshold_rotation:
		return true
		
	return false

# Rewind or playback history buffer: interpolates between tracked frame states at a specific timestamp
func get_interpolated_state(target_time: float) -> TrackingFrame:
	if history_buffer.is_empty():
		return null
		
	# Clamp target time to available history
	if target_time <= history_buffer[0].timestamp:
		return history_buffer[0]
	if target_time >= history_buffer[-1].timestamp:
		return history_buffer[-1]
		
	# Find surrounding frames
	var prev_frame = history_buffer[0]
	var next_frame = history_buffer[-1]
	
	for i in range(history_buffer.size() - 1):
		if history_buffer[i].timestamp <= target_time and history_buffer[i + 1].timestamp >= target_time:
			prev_frame = history_buffer[i]
			next_frame = history_buffer[i + 1]
			break
			
	var span = next_frame.timestamp - prev_frame.timestamp
	var factor = 0.0
	if span > 0.0001:
		factor = (target_time - prev_frame.timestamp) / span
		
	# Perform linear and spherical linear interpolation
	var interpolated = TrackingFrame.new()
	interpolated.timestamp = target_time
	interpolated.head_pos = prev_frame.head_pos.lerp(next_frame.head_pos, factor)
	interpolated.head_rot = prev_frame.head_rot.slerp(next_frame.head_rot, factor)
	interpolated.left_hand_pos = prev_frame.left_hand_pos.lerp(next_frame.left_hand_pos, factor)
	interpolated.left_hand_rot = prev_frame.left_hand_rot.slerp(next_frame.left_hand_rot, factor)
	interpolated.right_hand_pos = prev_frame.right_hand_pos.lerp(next_frame.right_hand_pos, factor)
	interpolated.right_hand_rot = prev_frame.right_hand_rot.slerp(next_frame.right_hand_rot, factor)
	
	return interpolated

이 시스템을 구현하면 프레임 유실이나 네트워크 레이턴시 편차가 발생하더라도 과거의 트랜스폼을 정확하게 재구성할 수 있습니다. 원격 클라이언트는 과거의 tracking 상태를 매끄럽게 보간(interpolate)하여 VR 수신 제스처와 상호작용을 믿을 수 없을 만큼 부드럽게 표현할 수 있게 됩니다.

Multiplayer에서 Time-Rewind 구현하기: 직접 구현의 악몽

이 전체 시스템을 직접 처음부터 작성하기로 선택한다면 상당한 인프라 오버헤드에 직면하게 됩니다. 룸 오케스트레이터(room orchestrators)를 설정하고, Linux 환경에서 커스텀 authoritative server 인스턴스를 호스팅해야 하며, ENetMultiplayerPeer를 통해 raw UDP 소켓을 구성해야 합니다. 홈 네트워크에서의 플레이어 연결 끊김을 방지하려면 Carrier-Grade NAT(CGNAT) 방화벽을 우회하는 커스텀 STUN/TURN traversal 서버도 구축해야 합니다.

또한 초당 수천 개의 고주파 레코드를 처리할 수 있는 영구적인 글로벌 상태 데이터베이스를 유지하려면 특수한 클러스터링 구성이 필요합니다. 게임을 디자인하는 대신 백엔드 인프라를 작성하는 데만 4~6주의 전담 엔지니어링 시간을 소비하게 될 것입니다.

이것들을 직접 빌드하려면 load balancers, database sharding, 그리고 SSL 인증서 관리를 설정해야 하며, 이는 쉽게 4~6주의 작업이 소요됩니다. horizOn을 사용하면 이러한 backend 서비스가 사전 구성되어 제공되므로, 인프라가 아닌 게임 자체를 바로 릴리스할 수 있습니다.

horizOn으로 Godot XR Multiplayer 단순화하기

복잡한 저수준 네트워킹 및 서버 프로비저닝에 개발 주기를 낭비하는 대신, horizOn을 프로젝트에 직접 통합할 수 있습니다. 이 플랫폼의 실시간 룸 엔진은 고주파 VR 데이터 serialization을 위해 명확하게 설계된 최적화된 WebRTC 및 저지연 UDP 파이프라인을 제공합니다.

horizOn의 사전 구성된 룸 구조를 활용하면, 게임에서 리전별 레이턴시 지표를 기반으로 사용자를 자동으로 매칭(pair)하여 spatial synchronization을 긴밀하게 유지할 수 있습니다. 모든 backend 라우팅, 보안 토큰, 플레이어 matchmaking이 간편한 SDK를 통해 관리되므로, 단 몇 분 만에 확장 가능한 다중 리전 VR 경험을 배포할 수 있습니다.

Godot XR Multiplayer를 위한 4가지 Netcode Best Practices

적절한 netcode 규칙을 적용하면 개별 클라이언트의 네트워크 품질에 관계없이 게임이 깔끔하게 작동합니다. 다음 네 가지 기술을 여러분의 다음 spatial 레이아웃에 통합해 보세요.

1. Decouple Network Tick Rate from Physics Frame Rate: 네트워크 복제 tick rate를 클라이언트의 HMD 주사율에 직접 고정하지 마세요. 게임 로직과 transform 동기화를 안정적인 30Hz 또는 45Hz에서 실행하고, 클라이언트 측 선형 및 spherical linear interpolation을 사용하여 네이티브 90Hz/120Hz 프레임을 로컬에서 재구성하십시오.
2. Prioritize HMD Tracking Updates Over Controllers: 머리 tracking은 VR 시뮬레이터 멀미(simulator sickness)를 유발하는 가장 주된 요인입니다. 사용자의 카메라 transform에 더 높은 네트워크 우선순위와 더 큰 패킷 대역폭 슬라이스를 할당하는 반면, 손 transform에는 더 강력한 delta compression과 더 낮은 우선순위 제한을 적용하십시오.
3. Enforce Distance and Orientation Thresholds: 플레이어의 spatial 변화가 미미하다면 패킷을 broadcast하지 마세요. 불필요한 업데이트를 제거하고 대역폭을 보존하기 위해 명시적인 delta-compression 가드 밴드(예: 5mm의 위치 이동 또는 0.02 라디안의 회전)를 설정하십시오.
4. Employ Client-Side Authority for Physical Grabs: 플레이어가 상호작용 오브젝트를 잡을(grab) 때, 노드의 네트워크 권한(network authority)을 잡은 클라이언트로 즉시 전환하십시오. 이를 통해 로컬 lag로 인해 컨트롤러와 잡고 있는 아이템 사이에 눈에 보이는 이격이 발생하는 것을 방지하고, 서버가 최종 오브젝트 배치를 비동기적으로 검증할 수 있도록 합니다.

Next Steps: 여러분의 XR Multiplayer 경험을 출시하세요

VR에서 고주파 multiplayer 환경을 개발하려면 시각적 안정성과 엄격한 대역폭 관리 사이의 세심한 균형이 필요합니다. delta compression, 로컬 역사적 버퍼링(local historical buffering), 그리고 client-side authority를 결합하여 플레이어가 안정적이고 연결된 상태를 유지할 수 있는 몰입형 환경을 구축할 수 있습니다.

multiplayer backend를 확장할 준비가 되셨나요? horizOn을 무료로 사용해 보거나 API docs를 확인해 보세요.

---

출처: Godot XR Community Game Jam V