2nd/10_Wiki/Topics/Frontend/Wonderland Engine.md

---
id: wiki-2026-0508-wonderland-engine
title: Wonderland Engine
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Wonderland, Wonderland Editor]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [wonderland, web3d, webxr, engine, vr, ar]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: JavaScript/TypeScript
  framework: Wonderland Engine
---

# Wonderland Engine

## 매 한 줄
> **"매 WebXR-first 3D — Unity-like editor + WebAssembly runtime"**. Wonderland Engine 매 commercial web 3D engine 의 Unity-style scene editor + WASM-compiled C++ runtime — 매 WebXR (Quest browser / Vision Pro Safari) 의 first-class. 2026 매 web VR/AR studio 의 main alternative 의 Three.js + WebXR boilerplate.

## 매 핵심

### 매 architecture
- **C++ runtime → WASM**: 매 native-grade perf — Three.js JS 보다 2-3x throughput.
- **Editor**: native desktop app (Win/Mac/Linux) — scene / prefab / animation.
- **Component system**: TypeScript/JS components — Unity-like MonoBehaviour 패턴.
- **Renderer**: WebGL2 + WebGPU (rolling out) — PBR / shadow / postprocess.
- **WebXR**: built-in VR/AR session + controllers + hand tracking.

### 매 vs alternatives
- **vs Three.js**: editor + perf + WebXR built-in / Three.js 매 더 flexible + ecosystem.
- **vs PlayCanvas**: similar editor model / Wonderland 매 lighter + WebXR-focused.
- **vs Unity WebGL build**: Wonderland 매 way smaller bundle (1-3MB vs 20MB+) + faster load.
- **vs Babylon.js**: 둘 다 mature — Wonderland editor-driven / Babylon API-driven.

### 매 응용
1. **WebXR VR apps**: Quest / Vision Pro — training / education / social.
2. **Mobile AR**: WebXR AR session — product viz / try-on.
3. **Marketing 3D**: brand experience — fast load + editor productivity.
4. **Web games**: lightweight 3D — itch.io / Crazy Games.

## 💻 패턴

### Component (TS) 매 basic
```typescript
import { Component, Property } from '@wonderlandengine/api';

export class Rotator extends Component {
    static TypeName = 'rotator';
    static Properties = {
        speed: Property.float(1.0),
        axis: Property.enum(['x', 'y', 'z'], 'y'),
    };

    speed!: number;
    axis!: number;

    update(dt: number) {
        const rot: [number, number, number] = [0, 0, 0];
        rot[this.axis] = this.speed * dt;
        this.object.rotateAxisAngleDegLocal(
            [this.axis === 0 ? 1 : 0, this.axis === 1 ? 1 : 0, this.axis === 2 ? 1 : 0],
            this.speed * dt
        );
    }
}
```

### WebXR session
```typescript
import { Component, Property } from '@wonderlandengine/api';
import { CursorTarget } from '@wonderlandengine/components';

export class VRController extends Component {
    static TypeName = 'vr-controller';

    start() {
        this.engine.onXRSessionStart.add((session) => {
            console.log('XR session started:', session.mode);
        });
    }

    onActivate() {
        this.engine.requestXRSession('immersive-vr', ['local-floor', 'hand-tracking']);
    }
}
```

### Hand tracking
```typescript
import { HandTracking } from '@wonderlandengine/components';

// 매 editor 의 component attach — wrist / fingertip joint 의 transform 매 tracked
// runtime 매 joint position / pinch gesture 의 query
```

### Physics (Rapier integration)
```typescript
import { Component } from '@wonderlandengine/api';
import { PhysXComponent } from '@wonderlandengine/components';

export class Spawner extends Component {
    static TypeName = 'spawner';

    spawn() {
        const obj = this.engine.scene.addObject(this.object);
        obj.addComponent('mesh', { mesh: this.cubeMesh, material: this.cubeMat });
        obj.addComponent('physx', {
            shape: 'Box',
            mass: 1.0,
            extents: [0.1, 0.1, 0.1],
        });
    }
}
```

### Mesh streaming + dynamic load
```typescript
import { loadGLTF } from '@wonderlandengine/api';

async function loadAsset(url: string) {
    const { meshes, materials } = await loadGLTF(this.engine, url);
    const obj = this.engine.scene.addObject();
    obj.addComponent('mesh', { mesh: meshes[0], material: materials[0] });
    return obj;
}
```

### Animation player
```typescript
import { AnimationComponent } from '@wonderlandengine/api';

const anim = this.object.getComponent('animation') as AnimationComponent;
anim.play();
anim.speed = 0.5;
anim.onEvent.add((evt) => console.log('anim event', evt));
```

### Networked multiplayer (Wonderland Cloud / custom)
```typescript
// 매 Wonderland Cloud — managed multiplayer
import { CloudClient } from '@wonderlandengine/cloud';

const client = new CloudClient({ projectId: 'abc123' });
await client.connect();
client.onPlayerJoin.add((p) => spawnAvatar(p));
client.sendState({ pos: this.object.getPositionWorld() });
```

## 매 결정 기준
| 상황 | Engine |
|---|---|
| WebXR VR/AR primary | Wonderland Engine |
| 2D UI heavy | Three.js / Babylon (DOM/CSS overlay 매 easier) |
| Editor-driven workflow | Wonderland / PlayCanvas |
| Code-first, max flexibility | Three.js |
| Smallest bundle | Wonderland (WASM-optimized) |
| Existing Unity team transitioning | Wonderland (familiar component model) |

**기본값**: WebXR target 매 Wonderland / general 3D web 매 Three.js.

## 🔗 Graph
- 부모: [[WebXR]]
- 변형: [[Threejs]] · [[Babylon.js]] · [[Wonder]]
- Adjacent: [[WebAssembly]] · [[WebGL API]] · [[WebGPU]]

## 🤖 LLM 활용
**언제**: WebXR-first project / Unity team 의 web migration / lightweight 3D + editor productivity.
**언제 X**: code-first / massive Three.js ecosystem dependency / commercial license 매 issue (free tier limits).

## ❌ 안티패턴
- **Editor scene 의 ignore**: runtime-only entity creation — editor workflow 매 lost.
- **Heavy per-frame allocation**: TypedArray reuse / vec3 pool 의 사용.
- **Mixing Three.js loaders**: glTF 의 Wonderland loader 의 사용 — material / animation binding.
- **No LOD on mobile XR**: Quest 매 vertex / fragment budget 의 strict — LOD + texture compress.

## 🧪 검증 / 중복
- Verified (Wonderland Engine official docs / GitHub).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — architecture, components, WebXR, physics, hand tracking |