Perombakan Animasi Unigine 2.22: State Machines, Layer Blending, dan Workflow Skeletal Baru

Workflow Animasi yang Membuat Developer Meninggalkan Engine

Setiap developer Unigine pasti pernah menabrak dinding yang sama: renderer-nya mampu menampilkan scene PBR yang memukau di 120fps, tapi membuat blend idle-to-run sederhana butuh satu jam scripting hack dan tweaking tulang manual.

Kesenjangan antara fidelitas visual dan perangkat animasi ini sudah menjadi rahasia umum Unigine selama bertahun-tahun, dan inilah alasan sebagian besar tim kecil yang mengevaluasi Unigine akhirnya pergi.

Dengan Unigine 2.22, tim pengembang akhirnya mengatasi kesenjangan ini secara langsung. Rilis ini memperkenalkan editor visual state machine, additive layer blending dengan per-bone masks, pipeline impor FBX yang ditingkatkan dengan avatar skeleton mapping, dan API procedural motion warping yang baru.

Bagi tim yang menggunakan Unigine untuk simulasi, visualisasi arsitektur, atau aplikasi industri yang selama bertahun-tahun merakit logika animasi secara manual di kode — ini mengubah workflow harian secara signifikan.

Panduan ini membahas apa yang sebenarnya berubah, cara migrasi dari pendekatan lama yang sarat scripting ke tools state machine baru, dan di mana saja edge case paling sering muncul.

---

Apa yang Berubah di Sistem Animasi Unigine 2.22

Cara Lama: Logika Animasi Berbasis Script

Sebelum 2.22, memicu transisi animasi di Unigine berarti menulis logikanya sendiri:

// UnigineScript — old pattern, pre-2.22
AnimLayer idle_layer = new AnimLayer();
idle_layer.SetAnimation("idle.anim");
idle_layer.Loop = true;

AnimLayer run_layer = new AnimLayer();
run_layer.SetAnimation("run.anim");
run_layer.Loop = true;

void update(float speed) {
    float blend = clamp(speed / 6.0, 0.0, 1.0);
    if (blend > 0.01f) {
        idle_layer.SetWeight(1.0 - blend);
        run_layer.SetWeight(blend);
    } else {
        idle_layer.SetWeight(1.0);
        run_layer.SetWeight(0.0);
    }
}

Ini berhasil untuk sistem dua-state, tapi menskalakannya ke crouch, jump, aim, sprint, dan 15 variasi serangan dengan cepat menjadi tidak terkelola. Setiap tim akhirnya membuat state machine manual di script, dan setiap tim berakhir berperang melawan transisi dan glitch blending.

Pendekatan 2.22: State Machine Deklaratif

Unigine 2.22 memperkenalkan sistem AnimationGraph — editor state machine berbasis node yang tertanam di Unigine Editor, dipasangkan dengan scripting API untuk kontrol runtime. State memetakan ke animation clips atau blend spaces. Transisi mendefinisikan kondisi dan durasi. Engine menangani interpolasi, interrupt blending, dan komposisi layer secara internal.

Peningkatan utamanya:

• Visual state machine editor — definisikan state, transisi, dan kondisi di editor dengan pratinjau graph
• Layer stacking dengan bone masks — blend aim tubuh atas di atas lokomosi tubuh bawah menggunakan grup tulang bernama
• Dukungan animasi aditif — terapkan lean, head look, dan recoil sebagai offset, bukan pengganti full pose
• Impor FBX yang ditingkatkan — avatar skeleton mapping yang mempertahankan hierarki tulang di berbagai varian karakter
• Motion warping — root motion dapat dialihkan dan di-blend saat runtime untuk climbing, vaulting, dan transisi cover

Menyiapkan Pipeline Animasi Baru Langkah demi Langkah

Langkah 1: Definisikan Avatar Skeleton Anda

Avatar skeleton adalah kunci utama dari workflow 2.22. Ini adalah template tulang bernama yang memetakan skeletal mesh dari tools DCC (Blender, Maya, 3ds Max) ke skeleton kanonik yang direferensikan oleh state machine.

Jika Anda melewatkan langkah ini — dan banyak developer yang baru mempelajari sistem ini melakukannya — animasi akan diputar di tulang yang salah atau tidak diputar sama sekali. Engine tidak akan melempar error; engine diam-diam menggunakan tulang pertama yang ditemukan dengan nama yang cocok, yang menyebabkan artefak rendering yang aneh.

Di panel Skeleton Asset Editor, definisikan avatar Anda:

// Avatar definition in Unigine's data format
avatar {
    name = "humanoid_standard";
    bones {
        root = "Hips";
        left_arm = "LeftArm";
        right_arm = "RightArm";
        left_leg = "LeftLeg";
        right_leg = "RightLeg";
        spine = "Spine";
        head = "Head";

Setiap aset karakter di proyek Anda berbagi definisi avatar ini. Saat Anda mengimpor humanoid baru, Anda memetakan nama tulangnya ke nama avatar sekali saja, dan semua animation clips dari setiap karakter akan berfungsi dengan animasi karakter lainnya. Waktu setup yang umum untuk pemetaan ini adalah 10-15 menit per karakter, dibandingkan pendekatan lama yang menamai anchor point secara manual per animation clip, yang memakan waktu 30-60 menit per karakter dan rusak setiap kali Anda melakukan retarget.

Langkah 2: Bangun State Machine di Editor

Buka editor AnimationGraph dari asset browser Unigine 2.22. Untuk character controller dasar, Anda setidaknya membutuhkan:

1. State Idle — animasi idle looping, entry state
2. Blend space Locomotion — blend 2D walk/jog/run berdasarkan parameter kecepatan dan arah
3. State Jump — jump start non-looping dan transisi di udara
4. State Land — pemulihan bertahap dengan transisi yang bisa diinterupsi kembali ke lokomosi

Setiap state mereferensikan animation clip atau blend space. Transisi menghubungkan state dengan parameter kondisi — float, bool, atau trigger yang Anda atur dari kode saat runtime.

[Idle] --(speed > 0.1)--> [Locomotion]
[Locomotion] --(is_jumping == true)--> [Jump]
[Jump] --(on_ground == true)--> [Land]
[Land] --(land_finished == true)--> [Idle]
[Damage_Taken] --(hit_received == true)--> [Flinch]
[Flinch] --(flinch_finished == true)--> [Idle]

Langkah 3: Jalankan dari Kode

Sisi scripting menjadi jauh lebih sederhana. Alih-alih menghitung bobot blend secara manual, Anda mendorong nilai parameter setiap frame:

// UnigineScript — driving the 2.22 AnimationGraph
ObjectMeshSkinned character_node;
AnimationGraph anim_graph;

int init() {
    character_node = node_cast(engine.editor.getNode("player_character"));
    anim_graph = new AnimationGraph(character_node);
    anim_graph.Load("animations/player_graph.anim");
    return 1;
}

int update() {
    float speed = length(character_node.getPositionVelocity());
    bool is_jumping = character_node.isJumping();

    anim_graph.SetFloat("speed", speed);
    anim_graph.SetBool("is_jumping", is_jumping);
    anim_graph.SetBool("on_ground", character_node.isOnGround());

    if (character_node.isHit()) {
        anim_graph.Trigger("hit_received");
    }

    anim_graph.Update();

Versi lama dari kode ini adalah 120-180 baris manajemen blend manual. Versi barunya di bawah 30 baris karena state machine, blending, dan logika transisi berada di aset graph.

Langkah 4: Konfigurasi Layer Blending untuk Tubuh Atas/Bawah

Untuk karakter yang perlu aim sambil berlari, Anda membutuhkan dua layer animasi yang di-blend dengan bone masks. Di editor AnimationGraph 2.22:

Layer 0 (basis): State machine lokomosi — memengaruhi pinggul, kaki, inti tulang belakang

Layer 1 (override tubuh atas): Blend space aim — memengaruhi tulang belakang, lengan, kepala

Layer 2 (aditif): Animasi recoil — offset aditif di lengan kanan dan tulang belakang

Bone masks menggunakan grup tulang yang Anda definisikan di Langkah 1. Bobot blend mask menentukan seberapa besar layer override menggantikan layer basis untuk tulang-tulang tersebut. Bobot 1.0 berarti penggantian total; 0.7 berarti blending parsial (berguna untuk memadukan pengaruh sudut aim pada tulang belakang atas).

Struktur layering ini adalah alasan inti mengapa animasi dipindahkan ke sistem state machine daripada tetap berbasis script. Mask blending manual akan hancur total saat Anda menambahkan layer ketiga atau keempat. Sistem baru menanganinya dengan memberlakukan urutan evaluasi dan mengomposisikan layer secara berurutan sebelum skinning.

Animasi Prosedural: Motion Warping dan IK

Apa yang Dipecahkan oleh Motion Warping

Motion warping mengalihkan root motion saat runtime. Contoh kanoniknya: animasi vault karakter Anda memiliki root motion yang menggerakkan kapsul 2 meter ke depan, tapi rintangannya berjarak 1,5 meter. Tanpa motion warping, karakter akan melayang di atas celah atau menembus dinding. Dengan motion warping, target root motion diatur ke tepi rintangan, dan lintasan animasi menyesuaikan.

Di Unigine 2.22:

// Setting the motion warp target during a vault
Vector3 vault_edge = getVaultEdge(ground_check.point, obstacle.normal);

// The AnimationGraph exposes a warp target parameter
anim_graph.SetWarpTarget("vault_end_point", vault_edge);
anim_graph.Trigger("start_vault");

Ini juga signifikan bagi pelanggan industri dan simulasi Unigine. Simulator pelatihan dengan karakter humanoid membutuhkan karakter untuk berinteraksi dengan geometri lingkungan secara akurat. Motion warping menyediakan itu tanpa penyesuaian manual penempatan kaki per-animasi.

Integrasi IK untuk Runtime Posing

Unigine 2.22 mengekspos solver IK yang berjalan setelah evaluasi layer animasi. Dua penggunaan paling umum:

Foot IK — lontarkan ray dari setiap sendi kaki ke bawah, sesuaikan tekukan kaki agar sesuai dengan kemiringan tanah. Cegah tampilan "kaki melayang 5cm di atas permukaan tidak rata" yang sering mengganggu sebagian besar proyek Unigine.

Aim IK — lacak arah kamera atau crosshair dengan memutar rantai tulang belakang dan membatasi rotasi kepala. Penting untuk third-person shooter apa pun yang dibangun di Unigine.

// Foot IK setup — called each frame after anim_graph.Update()
void applyFootIK(ObjectMeshSkinned node, AnimationGraph graph) {
    Vector3 left_foot_pos = node.getBonePosition("LeftFoot");
    Vector3 right_foot_pos = node.getBonePosition("RightFoot");

    float left_ground = castRayDown(left_foot_pos); // returns height offset
    float right_ground = castRayDown(right_foot_pos);

    // Smoothly offset the pelvis to the lower foot position
    float pelvis_offset = min(left_ground, right_ground);
    graph.SetFootIKOffset("LeftFoot", left_ground);
    graph.SetFootIKOffset("RightFoot", right_ground);
    graph.SetPelvisOffset(pelvis_offset);
}

Anda juga perlu meneruskan data ground normal ke foot IK — jika kaki berada di lereng 30 derajat, rotasi pergelangan kaki harus menyesuaikan. Lewati itu dan kaki akan diposisikan dengan benar di sumbu Y tapi berotasi datar, terlihat lebih buruk daripada tanpa IK sama sekali.

Perombakan Impor FBX: Yang Perlu Diperhatikan

Avatar Mapping Saat Impor

Importer FBX yang ditingkatkan di 2.22 menyelesaikan masalah historis seputar ketidakcocokan hierarki tulang. Saat Anda menjatuhkan FBX ke asset browser, kini ia menawarkan:

• Deteksi otomatis konvensi penamaan tulang (Humanoid, Mixamo, custom)
• Penetapan avatar — tandai mesh yang diimpor dengan avatar skeleton proyek Anda
• Perbaikan rotasi tulang — mengompensasi Z-up Blender versus sistem koordinat Unigine (ini menyebabkan rotasi 90 derajat pada tulang kepala di importer lama kira-kira setiap impor kedua)
• Ekstraksi animation clip — otomatis memecah file FBX multi-take menjadi clip individual

Perbaikan sistem koordinat saja menghilangkan sesi debugging yang biasanya memakan waktu 2 jam per karakter. Di Unigine pra-2.22, Anda mengimpor humanoid Blender dan menghabiskan waktu berjam-jam bingung mengapa lengan karakter mengarah ke belakang. Sekarang importer menerapkan kompensasi rotasi saat impor.

Kesalahan Umum: Ketidakcocokan Skala

Satu hal yang tidak diperbaiki secara otomatis oleh importer baru adalah skala unit. Blender default ke meter; Unigine default ke meter; tapi Maya dan 3ds Max default ke sentimeter. Jika karakter Anda terimpor 100x dari skala yang diinginkan, periksa pengaturan unit FBX di dialog impor. Atur agar sesuai dengan tools DCC Anda sebelum mengimpor. Ini masih langkah manual, dan masih menjadi error impor paling umum di rilis 2.22.

Ketidakcocokan skala juga memengaruhi pemutaran animation clip. Animasi yang di-bake pada skala 1cm-per-unit akan menghasilkan root motion yang 100x terlalu besar. Animasi memang berjalan, tapi karakter berpindah melintasi scene dalam satu frame. Jika Anda melihat perilaku ini, verifikasi bahwa skala root motion di properti clip cocok dengan skala mesh.

Panduan Migrasi: Mengonversi Kode Animasi Lama

Jika Anda memiliki proyek Unigine yang ada dengan animasi berbasis script, migrasi ke sistem AnimationGraph bisa dilakukan bertahap — Anda tidak perlu menulis ulang semuanya sekaligus.

Langkah 1: Audit Layer Animasi yang Ada [...]

Langkah 2: Petakan Layer ke State

Buat aset AnimationGraph dan tambahkan state yang sesuai dengan nama layer Anda. [...]

Langkah 3: Pertahankan Parameter Berbasis Kode

Kode Anda yang ada sudah menghitung bobot blend, nilai kecepatan, dan kondisi trigger. Refactor ini untuk mendorong nilai parameter ke graph alih-alih mengatur bobot layer secara langsung. Migrasinya terlihat seperti ini: [...]

Setelah state machine menangani transisi dan blending, Anda dapat menghapus kode interpolasi manual, easing, dan weight-clamping. [...]

Logikanya tidak hilang — ia berpindah ke aset graph, yang memiliki versi dan dapat diedit di editor visual. [...]

Definisikan avatar skeleton Anda terlebih dahulu, sebelum membuat aset AnimationGraph apa pun. Migrasi ke avatar yang konsisten setelah membangun 20 aset graph berarti memetakan ulang setiap referensi tulang secara manual — ini bisa dihindari jika Anda merencanakannya dari awal.

Jaga state machine tetap datar jika memungkinkan. AnimationGraph Unigine mendukung sub-state machine bersarang, tapi graph yang bersarang dalam (3+ level) menjadi sulit di-debug secara visual. Jika graph Anda membutuhkan lebih dari 20 state, pecah menjadi graph terpisah untuk bagian tubuh atau konteks tertentu (combat vs. [...]

Gunakan trigger untuk event satu kali, bukan bool. Trigger hit_received menyala sekali dan mereset secara otomatis. Bool is_hit tetap true sampai Anda secara eksplisit mengaturnya ke false, yang sering menyebabkan animasi berulang tanpa henti saat developer lupa meresetnya. [...]

Gunakan untuk mengidentifikasi state yang mahal — aim IK yang berjalan di karakter yang tidak sedang aim adalah pemborosan paling umum.

5. Uji transisi state animasi pada framerate ekstrem. Pada 12-15fps (umum di hardware kelas bawah atau saat GPU penuh), transisi state yang cepat dapat menghasilkan celah evaluasi yang terlihat sebagai T-pose satu frame. Gunakan frame limiter untuk menguji transisi di bawah beban sebelum rilis. [...]

Perombakan animasi Unigine 2.22 tidak membuat engine ini langsung kompetitif dengan Control Rig milik Unreal atau paket Animation Rigging milik Unity dalam semalam. [...]

Tapi yang dilakukan 2.22 adalah menghilangkan alasan utama tim menolak Unigine selama evaluasi teknis. [...]

Jika kode animasi proyek Unigine Anda memiliki lebih dari 500 baris logika blend, tools state machine 2.22 akan menyederhanakannya secara signifikan. Mulailah dengan siklus idle-locomotion-jump karakter utama Anda sebagai migrasi proof-of-concept, lalu terapkan polanya ke animasi NPC dan karakter sekunder. [...]

Unduh Unigine 2.22 dari halaman SDK resmi Unigine dan buka proyek tutorial AnimationGraph yang disertakan dalam sampel SDK. [...]

Tiru pengaturan ini dengan aset karakter Anda sendiri sebelum membangun graph custom dari nol — ini cara tercepat untuk memahami pipeline evaluasi dan melihat di mana kode animasi Anda yang ada cocok dengan sistem baru.

Bagi tim yang mengevaluasi Unigine sebagai target backend di samping engine lain, Anda dapat menghubungkan layer scripting Unigine ke layanan eksternal dengan cara yang sama seperti framework game C++/C# lainnya. Jika proyek Anda membutuhkan autentikasi pemain, data game tersimpan, atau papan peringkat yang bertahan antar sesi, tools seperti horizOn menawarkan API siap pakai yang terhubung ke runtime scripting Unigine melalui panggilan HTTP sederhana — menjaga pipeline animasi Anda tetap bersih dan data pemain dikelola terpisah dari logika engine Anda.

[...]