Animasi di Bevy: Kenapa Rust Game Engine Ini Bikin Pusing?

Kalo kamu pernah main Unity atau Godot, pasti kenal AnimationPlayer atau Animator Controller — drag-drop, set state, done. Bevy? Nggak ada semuanya. Engine ini dibangun di atas Rust dengan arsitektur ECS (Entity Component System) murni, jadi animasi di sini bukan tentang state machine visual, tapi tentang data yang berubah tiap frame. Kamu nggak "mainin" animasi, kamu "mutasiin" komponen. Konsepnya simple: entity punya component `AnimationPlayer` yang refer ke `AnimationClip`, terus sistem `AnimationSystem` jalanin interpolasi value ke target component kayak `Transform` atau `Sprite` tiap tick. Tapi implementasinya? Bikin pusing kalau belum terbiasa pikir ECS.

Bedanya fundamental: di Unity kamu definisi "idle" -> "run" -> "jump" pake graph visual. Di Bevy, kamu definisi clip sebagai sekumpulan keyframe yang modify component tertentu — misalnya `Transform.translation.x` dari 0 ke 10 dalam 0.5 detik. Clip itu cuma data (bisa load dari file `.ron` atau bikin via code), trus kamu spawn entity, attach `AnimationPlayer`, play clip. Sistem animasi bakal query semua entity yang punya `AnimationPlayer` dan `AnimationClip`, terus apply interpolasi ke target component. Artinya, animasi bisa target apa aja: posisi, rotasi, scale, color material, UV offset, bahkan custom component buatan kamu sendiri. Fleksibel banget, tapi kamu harus siap nulis boilerplate lebih banyak.

Kenapa Bevy Pilih ECS untuk Animasi?

Alasannya simple: performa dan komposabilitas. ECS memisahkan data (component) dari behavior (system), jadi sistem animasi bisa jalan paralel dengan sistem lain — physics, rendering, AI — tanpa race condition. Di engine tradisional, animation update sering blocking main thread atau butuh job system manual. Di Bevy, `AnimationSystem` cuma satu system di schedule, jalan bareng `TransformPropagateSystem` dan `RenderSystem` lewat dependency graph otomatis. Plus, karena animasi cuma mutasi component, kamu bisa compose animasi sembarangan: blend dua clip pake weight, layer additive animation di atas base, atau bahkan drive animasi dari physics simulation (misal: ragdoll blend ke get-up animation). Semuanya cuma math di component, nggak butuh state machine khusus.

Tapi ada trade-off: kurva belajar curam. Kamu harus paham Rust ownership, Bevy query system (`Query<(&mut Transform, &AnimationPlayer)>`), dan schedule (`FixedUpdate`, `PostUpdate`). Dokumentasi resmi Bevy 0.14 sudah lumayan lengkap di bagian `bevy_animation` crate, tapi contoh real-world masih jarang. Komunitas sering share snippet di Discord/Reddit, tapi struktur proyek skala besar (misal: RPG dengan ratusan animasi character) masih butuh arsitektur sendiri — misal bikin `AnimationController` component yang manage state machine manual, atau pakai crate third-party kayak `bevy_animation_graph` yang masih eksperimental. Banyak dev Rust yang akhirnya bikin wrapper sendiri biar feel kayak Unity Animator.

Yang Berubah Buat Workflow Artist & Programmer

Buat artist, pipeline jadi beda: nggak ada inspector visual buat preview animasi di editor (Bevy nggak punya editor bawaan). Artist export animasi dari Blender/Maya ke glTF, trus programmer load via `GltfAssetLoader` yang otomatis extract `AnimationClip` ke asset Bevy. Di runtime, programmer harus map bone hierarchy glTF ke entity Bevy — biasanya pake `AnimationTarget` yang refer ke entity bone via `Name` component atau `BoneIndex`. Proses ini manual dan error-prone kalo naming bone di Blender nggak konsisten. Solusi praktis: bikin script Blender Python yang rename bone otomatis match convention Bevy, atau pakai tool community kayak `bevy_gltf_animation_utils`.

Buat programmer, keuntungannya: animasi jadi testable dan deterministic. Karena cuma fungsi murni `fn animate(time: f32, clip: &AnimationClip) -> ComponentValue`, kamu bisa unit test interpolasi tanpa spawn engine penuh. Bisa juga replay animasi dari replay file (input + tick) buat debugging desync multiplayer. Bevy 0.14 nambah `AnimationTransitions` buat crossfade antar clip tanpa bikin system custom, dan `VariableCurve` buat animasi non-linear (elastic, bounce, custom easing). Masih belum ada built-in inverse kinematics (IK) atau procedural animation — itu harus bikin sendiri atau pakai crate `bevy_ik` yang masih early stage.

Praktis: Mulai Dari Mana Kalo Mau Coba?

• Clone repo `bevy_engine/bevy`, jalanin example `animation.rs` di folder `examples/animation` — paling cepat lihat sistem kerja.
• Bikin project baru `cargo new my_game`, tambah `bevy = { version = "0.14", features = ["animation"] }` di Cargo.toml.
• Load model glTF pake `AssetServer::load("models/character.glb#Animation0")` trus insert ke `AnimationPlayer::play(animation_handle)`.
• Debug pake `bevy_inspector_egui` biar lihat component `AnimationPlayer` real-time di UI — gampang banget trace kenapa animasi nggak jalan.

Bottom line: Bevy animasi powerful banget buat yang suka data-driven dan performa, tapi butuh investasi waktu bikin tooling sendiri. Kalo kamu tim kecil yang butuh ship cepat, Godot/Unity masih lebih pragmatis. Tapi kalo kamu bangin engine custom, butuh determinisme multiplayer, atau mau kontrol penuh sampai level math interpolasi — Bevy worth the pain. Komunitas Rust game dev lagi grow cepat, jadi ekspektasi tooling bakal makin enak 1-2 tahun depan.