pengenalan game engine Horde 3d

 Abdul Majid Rija

50411020

3ia24

Horde 3d adalah sebuah open source lintas platform mesin grafis. Untuk membahas lebih dalam tentang HORDE 3D, open source atau sumber terbuka adalah sistem pengembangan yang tidak dikoordinasi oleh suatu individu / lembaga pusat, tetapi oleh para pelaku yang bekerja sama dengan memanfaatkan kode sumber (source-code) yang tersebar dan tersedia bebas (biasanya menggunakan fasilitas komunikasi internet). Pola pengembangan ini mengambil model ala bazaar, sehingga pola Open Source ini memiliki ciri bagi komunitasnya yaitu adanya dorongan yang bersumber dari budaya memberi, yang artinya ketika suatu komunitas menggunakan sebuah program Open Source dan telah menerima sebuah manfaat kemudian akan termotivasi untuk menimbulkan sebuah pertanyaan apa yang bisa pengguna berikan balik kepada orang banyak.

Pola Open Source lahir karena kebebasan berkarya, tanpa intervensi berpikir dan mengungkapkan apa yang diinginkan dengan menggunakan pengetahuan dan produk yang cocok. Kebebasan menjadi pertimbangan utama ketika dilepas ke publik. Komunitas yang lain mendapat kebebasan untuk belajar, mengutak-ngatik, merevisi ulang, membenarkan ataupun bahkan menyalahkan, tetapi kebebasan ini juga datang bersama dengan tanggung jawab, bukan bebas tanpa tanggung jawab.

Tujuan dan desain dari HORDE 3D ini hampir sama dengan OGRE dengan tujuan utama menjadikan beban rendah untuk generasi video game selanjutnya. Mesin ini juga biasanya dicocokkan untuk simulasi tingkat keramaian luas atau biasa disebut large crowd simulations.

Mesin ini juga cocok dengan GLFW, GLFW adalah sebuah beban ringan utility library untuk digunakan dengan OpenGL. Yang menyediakan para pemrogram untuk membuat dan memanage windows dan OpenGL contexts, juga menerima input dari joystick, keyboard, mouse, time dan clipboard.

Bagian utama dari mesin grafis ini pada awalnya ditulis untuk kelompok pyropix indie dan pembangunannya kini dilanjutkan di University of Augsburg.

Mesin ini terutama dirancang untuk pendekatan berorientasi objek untuk scene rendering. Ia juga memiliki Editor Adegan yang dapat merancang shader dengan dukungan untuk plugin termasuk fisika. Mesin ini awalnya dibangun di atas OpenGL 2.0. Sebuah plugin untuk menggunakan mesin dengan Physics Bullet API juga ada.

Fitur - Fitur

1.      Modern, cross-platform , arsitektur berbasis shader ( membutuhkan OpenGL 2.0 + )

-          Ringan, desain non - intrusif dengan sangat sedikit dependensi , menghindari kompleksitas di mana kemungkinan.

-          C -style API untuk penggunaan yang mudah dari hampir semua bahasa pemrograman pengelolaan sumber daya.

2.      Sampah sumber daya dikumpulkan , diambil dari hampir semua jenis aliran data

-          Hot - reload sumber daya untuk lebih meningkatkan produktivitas selama pengembangan.

-          Akses ke data vertex untuk deteksi tabrakan dan interoperabilitas dengan mesin fisika.

3.      Übershader berbasis rendering pipeline disesuaikan.

-          Hot - reload pipa untuk pengujian cepat teknik rendering yang berbeda

-          Dukungan untuk efek pengolahan pasca seperti mekar , DOF atau motion blur

-          Dukungan untuk hampir semua maju , ditangguhkan dan High Dynamic Range teknik rendering

-          Dukungan untuk refleksi real-time dan teknik lain yang memerlukan beberapa kamera

-          Bayangan Real-time menggunakan Paralel Berpisah Bayangan Maps ( PSSM )

-          Sistem partikel yang dapat melemparkan bayangan dan memiliki efek seperti blur

4.      Sistem adegan terpadu

-          Dunia, model dan kerangka node scene bukan objek khusus

-          Frustum pemusnahan berdasarkan grafik spasial

-          Hardware oklusi pemusnahan

-          Tingkat detail untuk model geometri dan bahan

5.      Terpadu , sistem animasi tingkat rendah

-          Key frame animasi untuk sendi dan jerat

-          Animasi Skeletal sampai dengan 4 bobot per titik untuk model diartikulasikan

-          Animasi Layered pencampuran dan pencampuran menggunakan masker dan saluran aditif

-          Morph target untuk animasi wajah dan sinkronisasi bibir

-          Akses ke data bersama untuk animasi dinamis dan fisika Ragdoll

6.      Content Pipeline

-          Campuran format biner dan XML untuk tradeoff terbaik antara kinerja dan produktivitas

·         Pipeline , bahan dan adegan deskripsi adalah XML

·         Model dan animasi biner untuk kinerja maksimum

·         Tekstur adalah format gambar yang umum ( DDS , PNG , JPEG , dll )

-          COLLADA Converter untuk mengimpor aset dari banyak alat DCC umum

·         Perhitungan dasar ruang singgung untuk pemetaan yang normal

·         Optimasi geometri untuk GPU pasca -transform vertex Cache

-          Editor untuk menyusun adegan , pengembangan shader dan teknik rendering

Membangun Kompiler Horde 3D

Untuk membangun compiler Horde 3D, kita perlu memiliki C + + compiler dan CMake 2.4 + terinstall . CMake adalah sistem meta - membangun , misalnya menciptakan Makefiles atau file Visual Studio menggunakan Generator .

Cara utama untuk menggunakan CMake adalah cmake - gui ( Qt Interface) , ccmake ( Kutukan Interface) dan cmake ( Commandline Interface) . Petunjuk untuk generator yang umum digunakan :

-          Qt Creator: CMakeLists.txt terbuka seperti proyek baru , ikuti petunjuk , memukul membangun dan Anda sudah selesai .

-          Visual Studio : mulai cmake - gui , pilih OGDF sebagai jalur sumber , membangun - vs sebagai membangun jalan , tekan menghasilkan , terbuka build - vs \ Horde3D.sln dan mulai kompilasi .

-          Makefiles : membuka terminal , arahkan ke repositori dan menjalankan mkdir membangun - make && cd build - make && cmake - G " Unix Makefiles " .. && make (petunjuk : gunakan JOBS ekspor = MAX untuk mempercepat ) .

-          Ninja : membuka terminal , arahkan ke repositori dan menjalankan mkdir membangun - Ninja && cd build - Ninja && cmake - G " Ninja " .. && Ninja .

Tutorial Sederhana Horde 3D

Pada bagian ini kita akan membuat sebuah aplikasi sederhana yang memuat karakter dan menganimasikannya menggunakan siklus berjalan. Kita akan melihat bagaimana mudahnya dengan menggunakan Horde3D API. Sebagai langkah pertama kita harus membuat sebuah aplikasi yang akan membuka jendela yang dapat digunakan untuk rendering.

Ini adalah tugas yang cukup standar dan jika kita seorang pemula dan memiliki masalah dengan itu pada Anda menggunakan platform yang google untuk menemukan salah satu dari banyak tutorial yang baik di internet atau lihat di sampel yang datang dengan Horde3D SDK.

Langkah berikutnya adalah untuk menginisialisasi konteks OpenGL untuk jendela render kami. Anda dapat melakukannya secara manual atau menggunakan Horde3D Utilitas Library untuk mempermudah pekerjaan kita. Setelah itu dilakukan kita akhirnya bisa sampai ke bagian mesin yang terkait.

Skrip 1:

#include <Horde3D.h>

#include <Horde3DUtils.h>

H3DNode model = 0, cam = 0;

void initGame( int winWidth, int winHeight )

{

    // Initialize engine

    h3dInit();

  

    // Add pipeline resource

    H3DRes pipeRes = h3dAddResource( H3DResTypes::Pipeline, "standard.pipeline.xml", 0 );

    // Add model resource

    H3DRes modelRes = h3dAddResource( H3DResTypes::SceneGraph, "character.scene.xml", 0 );

    // Add animation resource

    H3DRes animRes = h3dAddResource( H3DResTypes::Animation, "walk.anim.xml", 0 );

    // Load added resources

    h3dutLoadResourcesFromDisk( "" );

   

    // Add model to scene

    model = h3dAddNodes( H3DRootNode, modelRes );

    // Apply animation

    h3dSetupModelAnimStage( model, 0, animRes, 0, "", false );

   

    // Add light source

    H3DNode light = h3dAddLightNode( H3DRootNode, "Light1", 0, "LIGHTING", "SHADOWMAP" );

    // Set light position and radius

    h3dSetNodeTransform( light, 0, 20, 0, 0, 0, 0, 1, 1, 1 );

    h3dSetNodeParamF( light, H3DLight::RadiusF, 0, 50.0f );

       

    // Add camera

    H3DNode cam = h3dAddCameraNode( H3DRootNode, "Camera", pipeRes );

    // Setup viewport and render target sizes

    h3dSetNodeParamI( cam, H3DCamera::ViewportXI, 0 );

    h3dSetNodeParamI( cam, H3DCamera::ViewportYI, 0 );

    h3dSetNodeParamI( cam, H3DCamera::ViewportWidthI, winWidth );

    h3dSetNodeParamI( cam, H3DCamera::ViewportHeightI, winHeight );

    h3dSetupCameraView( cam, 45.0f, (float)winWidth / winHeight, 0.5f, 2048.0f );

    h3dResizePipelineBuffers( pipeRes, winWidth, winHeight );

}

Baris pertama dari kode di atas menyatakan dua pegangan global untuk Horde adegan node grafik. Semua benda di Horde dapat diakses melalui menangani, konsep yang mirip dengan pointer. Hal pertama yang perlu kita lakukan dalam fungsi initGame kami untuk menggunakan Horde3D inisialisasi mesin. Hal ini terjadi dengan fungsi h3dInit.

Langkah berikutnya adalah untuk memuat sumber daya yang diperlukan. Dalam sumber Horde adalah file data yang dimuat sekali dan dapat direferensikan oleh beberapa objek untuk rendering . Fungsi h3dAddResource mengambil tipe sumber daya kita ingin menambahkan dan nama sumber daya (biasanya nama file ) sebagai parameter dan mengembalikan pegangan ke objek sumber daya yang diciptakan.

Dalam kasus ini, kita ingin model yang direpresentasikan sebagai file grafik adegan di Horde dan tambahan animasi. Sekarang sumber daya diciptakan tetapi kita masih perlu untuk memuat mereka. Horde mendukung pemuatan dari sumber termasuk arsip dienkripsi atau jaringan tetapi dalam kasus ini kita hanya ingin memuat sumber daya kami dari hard disk lokal yang dilakukan dengan fungsi utilitas h3dutLoadResourcesFromDisk.

Disamping itu model dan animasi ini, kita juga memuat sumber daya pipa. Sebuah pipa mendefinisikan bagaimana adegan yang diberikan dan dapat digunakan untuk mewujudkan efek post-processing atau tinggi kisaran render dinamis. Untuk awal Anda hanya dapat menggunakan file yang datang dengan sampel SDK .

Setelah telah dimuat sumber daya yang diperlukan kita akhirnya dapat membangun grafik adegan. Adegan grafik mewakili benda-benda di dunia maya kita dalam struktur pohon hirarkis. Pertama kita menambahkan model yang telah kita dimuat sebelumnya.

Kita menggunakan h3dAddNodes fungsi untuk melakukan hal ini yang membutuhkan sumber daya grafik adegan dan node induk. Orangtua adalah obyek adegan dimana node baru terpasang, dalam kasus ini hanya simpul akar yang merupakan basis dari dunia maya . Mirip dengan h3dAddResource, fungsi ini juga kembali pegangan untuk adegan grafik dibuat subtree. Setelah itu kita menetapkan animasi dimuat ke node model kami dengan fungsi h3dSetupModelAnimStage .

Horde memungkinkan kita untuk menerapkan beberapa animasi yang berbeda untuk model dan memungkinkan untuk berbaur dan campuran mereka tetapi untuk awal yang harus cukup. Sekarang bahwa menambahkan model selesai kita masih membutuhkan sumber cahaya. Ini akan mungkin untuk memuat file grafik adegan lain yang berisi sumber cahaya tapi kami ingin menambahkannya secara manual dengan menggunakan fungsi h3dAddLightNode . Fungsi ini memerlukan beberapa parameter menentukan shader digunakan untuk rendering.

Informasi lebih lanjut tentang hal ini dapat ditemukan di bagian lain dari manual. Langkah berikutnya adalah untuk mengatur posisi dan orientasi yang dilakukan dengan h3dSetNodeTransform . Setelah itu kita tentukan radius cahaya yang mendefinisikan zona pengaruh menggunakan h3dSetNodeParamF.

Akhirnya kami masih membutuhkan kamera yang mewakili pemirsa . Hal ini ditambah dengan fungsi h3dAddCameraNode dan mengambil sumber daya pipa dimuat kami sebagai parameter . Parameter pandang kamera dan membuat target sumber daya pipa tergantung pada ukuran jendela render . Jadi pada langkah terakhir kita menerapkan pengaturan viewport ke node kamera dan mengubah ukuran buffer output pipa.

Skrip 2:

void gameLoop( float fps )

{

    static float t = 0;

    // Increase animation time

    t = t + 10.0f * (1 / fps);

    // Play animation

    h3dSetModelAnimParams( model, 0, t, 1.0f );

    // Set new model position

    h3dSetNodeTransform( model, t * 10, 0, 0,  // Translation

                         0, 0, 0,              // Rotation

                         1, 1, 1 );            // Scale

    // Render scene

    h3dRender( cam );

    // Finish rendering of frame

    h3dFinalizeFrame();

}

void releaseGame()

{

    // Release engine

    h3dRelease();

}

Fungsi berikutnya dalam sampel ini adalah loop permainan yang dipanggil sekali setiap frame. Di sini kita akan menghidupkan karakter model yang telah dibuat. Untuk melakukan hal ini kita mendefinisikan counter waktu yang meningkat pada setiap frame. Untuk membuat kecepatan animasi independen dari framerate, kita skala langkah waktu oleh kebalikan dari frame per saat ini nilai kedua.

Setelah itu kita memberitahu mesin untuk memperbarui model animasi menggunakan fungsi h3dSetModelAnimParams. Kita juga bisa menentukan berat campuran untuk menggabungkan animasi di sini tapi karena kita hanya memiliki satu animasi kita tidak perlu itu. Sekarang kita dapat menggantikan karakter kita sedikit sehingga bergerak melalui TKP. Hal ini dicapai dengan memperbarui model simpul transformasi.

Akhirnya kita perlu memberitahu mesin untuk membuat adegan dan menghitung ulang model animasi. Hal ini terjadi dengan h3dRender fungsi yang mengharapkan kamera dari mana adegan tersebut dilihat. Langkah terakhir adalah untuk menginformasikan mesin render yang untuk frame selesai sekarang.
Fungsi releaseGame terakhir dipanggil saat aplikasi ditutup . Yang harus kita lakukan di sini adalah membebaskan mesin dengan fungsi h3dRelease .

sumber: google.com

download file selengkapnya di bit.ly/horde3d