Tugas Softskill

    Bab 6

        Milkshape

                  3D

Seperti buku bergerak maju ke bab ini, format mulai muncul dalam bab ini. Ini adalah format yang pertma dari format yang lebih rumit. Berakhirlah sudah hari-hari yang sederhana ”beban-dan-siklus” format, seperti format MD2 yang terkenal dan telah dibahas sebelumnya dalam buku ini. Bab ini berisi tentang semua yang anda perlu tau tentang MS3D. Format yang ditampilkan oleh paket, pemodelan sangat bagus dan murah dan dikenal sebagai Milkshape 3D. Milkshape 3D diciptakan oleh chUmbaLum sOft, sebuah perusahan software kecil yang terdiri dari seorsng pendiri yaitu Mete Ciragan. Mete membuat Milksahpe untuk memungkinkan individu untuk membuat model baru untuk Software Valve Half-Life (http:// www.valvesoftware.com) tanpa menggunakan alat permodelan mahal dan profesional.

Sejak pembentukannya, Milkshape teah menjadi salah satu alat pemodelan yang paling populer diantara para pengembang independen ”mods-smaller” permainan dibangun diatas permainan yang sama komersialnya. Sekarang Milkshape mendukung untuk mengimpor dan mengekspor format untuk beberapa permainan populer dan juga mesinnya. Saya sarankan bahwa setiap pengembang permainan pada anggaran singkat lihat program indah ini. Anda dapat memeriksa percobaan 30-hari pada CD. Anada dapat menemukan file setup pada direktori program. Untuk kesenangan anda dapat lihat, gambar 6.1yang menunjukan  editor 3D milkshape dengan model yang akan gunakan sebagai contoh dalam halaman –halaman selanjutnya.

Cara Mendapatkan Data

        Seperti biasa, anda mulai dengan mendapatkan data dari file. Tidak seperti kebanyakan model format MS3D tidak mengandung informasi tentang jumlah simpul, segitiga, atau apapun pada awal file. Sekarang semua ini adalah header sederhana untuk memverifikasi bahwa file Milkshape tersebut memang valid. Panjang header tepat 14 byte dan berisi identifikasi 10 karakter string dan sebuah nomor versi. Yang 10 byte pertama berisi string “MS3D000000”. String ini mengindentifikasi file sebagai file Milkshape.

Gambar 6.1 Editor 3D Milkshape lengkap dengan model contoh.

            Perlu diingat bahwa null dalam string ID karakter tidak memiliki nilai. Pastikan anda mengingat saat anda memuat file. Yang kedua 4 byte berisi bilangan bulat tunggal. Ini adalah nomor versi dari file dan harus berisi nilai 3 atau 4. Format rinci disini adalah untuk kedua versi saja. Sebagai kemajuan dan fersi baru Milkshape yang dirilis, saya akan menempatkan tambahan dan perubahan pada buku situs web.

Simpul

            Langsung setelah header maka kita membahas simpul. Seperti bagian lain dari file. Sepotong titik diawali oleh sebuah integer 2 byte yang tidak memiliki tanda yang berisi jumlah simpul yang hadir di dalam model. Simpul yang sedikit berbeda dari apa yang anda gunakan sebelumnya. Bukan hanya  X,Y,Z koordinat latar, simpul Milkshape juga mengandung satu byte, integer yang memiliki nomor didalam simpul tersebut ”tulang ”. Nilai -1 berarti titik tidak memiliki tulang yang melekat padanya dan tidak terpengaruh selama animasi.

Berikut adalah struktur simpul yang digunakan untuk loader MS3D :

//----------------------------------------------

//- SMs3dVertex

//- A single vertex

struct SMs3dVertex

{

unsigned char m_ucFlags; //Editor flags, unused for the loader

CVector3 m_vVert; //X,Y,Z coordinates

char m_cBone; //Bone ID (-1 = no bone)

unsigned char m_ucUnused;

};

Ditengah kedua variabel dalam struktur yang dijelaskan sebelumnya, yang hanya menyisakan dua dari satu byte variabel kiri yang tidak diketahui. Yang pertama berisi berbagai flag untuk editor untuk menggunakan titik. Variabel ini sebuah variabel tidak bertanda karakter yang memegang status verteks dalam editor. Jika nilai adalah 0, verteks terlihat, tetapi tidak dipilih. Jika nilai adalah 1, simpulsimpul dipilih dalam editor, dan jika niali adalah 2, verteks tersembunyi dari pandangan di jendela editor . Nilai 3 berarti verteks adalah baik tersembunyi dan dipilih. Meskipun variabel ini tidak diperlukan untuk loading model ke dalam mesin anda, mungkin membantu jika anada menulis importir lain program pemodelan, seperti 3D Studio Max (www.discreet.com) atau Maya (www.aliaswavefront.com). Yang kedua variabel tidak berisi apa-apa, anda dapat melewatinya. Setelah simpul membaca, file tersebut segera bergerak untuk mendapatkan informasi.

Wajah

Wajah untuk format khusus berisi banyak informasi. Tapi, sebelum anda khawatir tentang pemuatan segitiga, anda perlu mencari tahu berapa banyak dari mereka. Seperti dengan potongan titik, wajah atau segitiga dimulai  dengan sebuah integer dua byte. Bilangan bulat ini datang setelah titik terakhir adalah membaca dan sebelum data segitiga disimpan. Bilangan dua byte ini berisi jumlah struktur SM3DTriangel untuk membaca dari file. Tepat setelah dua byte senilai data yang menentukan jumlah wajah untuk membaca wajah mereka sendiri. Struktur wajah atau segitiga berisi bendera editor, indeks titik, koordinat tekstur, pengelompokan info dan bahkan informasi yang normal. Mari kita lihat pada struktur SMs3dTriangel untuk melihat apa yang memperkuat model memerlukan :

//--------------------------------------------

//- SMs3dTriangle

//- Triangle data structure

struct SMs3dTriangle

{

unsigned short m_usFlags; //Editor flags

unsigned short m_usVertIndices[3]; //Vertex indexes

CVector3 m_vNormals[3]; //Vertex normals;

float m_fTexCoords[2][3]; //Texture coordinates

unsigned char m_ucSmoothing; //Smoothing group

unsigned char m_ucGroup; //Group index

};

Baik, itu tidak terlalu buruk. Sebanyak enam variabel yang digunakan untuk setiap segitiga dalam model 3D MilkShape. Yang pertama seperti struktur titik, hanya sebuah bendera editor. Seperti simpul, 0 adalah regular, wajah tidak dipilih, 1 berarti wajah dipilih dan 2 berarti wajah yang tersembunyi dari pandangan. Sekali lagi, wajah dapat dipilih dan tersembunyi jika nilainya 3. Perhatikan bahwa variabel bendera disini adalah dua byte, bukan hanya dari 1 seperti dalam struktur simpul. Berikutnya terdapat tiga dari dua byte integer yang tidak bertanda. Ketiga bilangan bulat adalah indeks kedalam array dari simpul yang tercangkup kedalam bagian terakhir. Tiga simpul membentuk segitiga tunggal dalam model. Dan hanya menggunakan data yang dipelajari sejauh ini, adalah mungkin untuk membuat model yang solid. Namun jenis tersebut akan membosankan tanpa tekstur dan pencahayaan. Pindah ke bawah garis, anda datang ke titik normal. Sebuah simpil biasa digunakan untuk pernerangan. Setiap simpul yang normal adalah rata-rata dari semua titik wajah normal. Sebuah wajah yang normal tegak lurus terhadap arah yang terletak pada wajah, titik normal adalah rata-rata dari semua vektor yang tegak lurus. Seorang yang normal, apakah itu sebuah verteks atau sebuah wajah, harus menjadi vektor satuan dengan besarnya 1. Ini disimpan dalam kelas CVektor3. CVektor3 ini dibuat untuk vektor yang terdiri dari tiga variabel floating point, yang mengambil total 12 byte. Keuntungan utama dari menggunakan CVektor3 untuk setiap normal kesetimbang array sederhana mengapung adalah bahwa kelas CVektor3 berisi segudang fungsi. Fungsi ini membuat anda lebih mudah dikemudian hari ketika anda mulai menghidupkan model. Ada tiga normals, satu untuk setiap index verteks.

Berikutnya adalah koordinat tekstur. Koordinat u dan v disimpan di dalam jenis MilkShape. Ada total enam mengapung sepasang koordinat untuk masing-masing tiga simpul yang membentuk wajah. Namun, bukanya disimpan didalam u1,u2,v1,v2dan v3. Jika anda tidak ingat memesan ini, maka akan datang kembali untuk bagian anda. Saya menghabiskan beberapa jam debugging program hanya untuk menemukan ketika saya menggunakan koordinat tekstur yang salah. Dua variable terakhir dengan kelompok milik wajah. Variabel ini tidak terlalu penting karena anda akan melihat di bagian yang akan datang. Kelompok atau jerat dalam mengurus model untuk mengetahui mana wajah masing-masing kelompok.

Jerat

Untuk fleksibilitas maksimum, segitiga Milkshape 3D dikelompokkan menjadi
jerat atau kelompok. Hal ini memungkinkan bagian yang berbeda dari model untuk menggunakan tekstur yang berbeda, bahan, dan bahkan membuat hanya bagian tertentu dari model. Bagian mesh file mengikuti segitiga atau wajah bagian, dan seperti bagian lain didahului oleh sebuah integer dua-byte mengatakan berapa banyak jerat ada. Segera berikut adalah kelompok. Ada 35 byte informasi umum, diikuti dengan nomor dua-byte indeks segitiga. Jumlah indeks tidak konstan; beberapa kelompok mungkin memiliki lebih dari yang lain. Untuk mengkompensasiperbedaan ini,
Anda harus mampu untuk secara dinamis mengalokasikan memori di setiap kelompok untuk menahan indeks ini. Berikut adalah apa yang terlihat seperti struktur.

//------------------------------------------------------------

//- SMs3dMesh

//- Group of triangles in the ms3d file

struct SMs3dMesh

{

unsigned char m_ucFlags; //Editor flags again

char m_cName[32]; //Name of the mesh

unsigned short m_usNumTris;//Number of triangles in the group

unsigned short * m_uspIndices; //Triangle indexes

char m_cMaterial; //Material index, -1 = no material

//Let it clean up after itself like usual

SMs3dMesh()

{

m_uspIndices = 0;

}

~SMs3dMesh()

{

if(m_uspIndices)

{

delete [] m_uspIndices;

m_uspIndices = 0;

}

}

};

Struktur ini membutuhkan sedikit perawatan ketika sedang dibaca masuk m_uspIndices
variabel pointer, yang berarti Anda tidak bisa membaca dalam NumberOfMeshes *
sizeof (SMs3dMesh). Untuk mesh setiap, Anda harus membaca 35 byte pertama yang
terdiri dari beberapa editor bendera-bendera yang sama yang simpul dan
segitiga menggunakan-0 untuk tidak dipilih, 1 untuk dipilih, dan 2 untuk tersembunyi. Anda juga harus membaca 32-karakter nama mesh dan sebuah integer dua-byte yang berisi jumlah segitiga mesh. Menggunakan variabel terakhir,
Anda harus mengalokasikan memori untuk indeks segitiga. M_uspVariable sekarang siap untuk menampung semua dari dua-byte integer diperlukan untuk menunjukkan yang digunakan dalam segitiga mesh. setiap elemen dari array adalah indeks ke dalam array segitiga yang diciptakan dan diisi sebelumnya di urutan beban.
Tepat setelah Anda membaca semua indeks segitiga, ada, tunggal single-byte
variabel yang memegang indeks ke dalam array bahan (yang akan Anda
akan mendapatkan dalam satu detik). Variabel ditandatangani, dan nilai -1
berarti mesh berisi materi tidak ada. Terakhir dari semua, seperti yang Anda lihat, struktur mengurus menghapus sendiri memori, berarti Anda tidak perlu  khawatir tentang mengingat untuk jelas itu ketika Anda selesai menggunakannya. Menghapus array dari jerat akan otomatis menghapus segala sesuatu di dalamnya.

Bahan-bahan

Untuk benar-benar membuat model menonjol dan menambahkan banyak kustomisasi, Anda dapat menggunakan bahan-bahan. Bahan mengontrol cara menangani penyaji.

Para texturing dan pencahayaan model. Dari tekstur, warna, untuk
transparansi, bahan melakukan semuanya.
Struktur bahan yang cukup besar dan berisi banyak data, jadi beruang
dengan saya di sini.
Ingatlah untuk membaca dalam dua-byte variabel Anda yang memberitahu Anda berapa banyak
bahan ada sebelum Anda melompat ke membaca data materi.
Berikut adalah struktur materi:

//------------------------------------------------

//- SMs3dMaterial

//- Material information for the mesh

struct SMs3dMaterial

{

char m_cName[32]; //Material name

float m_fAmbient[4]; //Ambient values

float m_fDiffuse[4]; //Diffuse values

float m_fSpecular[4]; //Specular values

float m_fEmissive[4]; //Emissive values

float m_fShininess; //0 - 128

float m_fTransparency; //0 - 1

char m_cMode; //unused

char m_cTexture[128]; //Texture map file

char m_cAlpha[128]; //Alpha map file

CImage m_Texture;

};

Anda perlu berhati-hati ketika Anda mulai membaca data dari file tersebut.

Alih-alih membaca seluruh kelompok material dalam sekaligus, Anda harus

loop dan membacanya dalam satu waktu. Alasan untuk ini adalah yang terakhir

variabel dalam m_Texture, struktur. m_Texture adalah kelas gambar yang

digunakan untuk menyimpan tekstur untuk materi. Ini menghilangkan mencoba untuk mengurutkan

keluar tekstur nanti saat Anda perlu menggunakan mereka selama program.

Catatan bahwa ini bagian dari struktur sebenarnya tidak terkandung dalam

file, membuat ukuran sebenarnya dari struktur dalam byte file yang 361. para

Variabel CImage adalah kelas khusus yang berada di basecode umum di

file (image.cpp dan image.h). Anda dengan mudah dapat menghapus variabel ini

dan menggantinya dengan sistem anda sendiri gambar-loading.

Variabel pertama dalam struktur adalah 32-karakter array memegang

nama bahan. Ini adalah tidak semua yang penting jika Anda hanya

membuat loader, tapi itu bagus untuk memiliki ketika bekerja dengan model dalam

Milkshape sendiri.

Selanjutnya enam variabel mengandung sifat-sifat bahan. properti ini

menentukan cara pencahayaan adegan akan mempengaruhi model.

■ Para m_fAmbient dan m_fDiffuse setiap toko empat floating-point

nilai-nilai yang mewakili, merah, hijau, biru, dan alpha (RGBA)

nilai-nilai warna. Warna-warna ini membantu menentukan warna

material dan menentukan bagaimana poligon menggunakan bahan ini

akan bereaksi terhadap pencahayaan dalam adegan.

■ Variabel berikutnya, m_fSpecular, juga mengandung warna RGBA.

Sifat material specular menentukan warna specular

menyoroti atau "tempat mengkilap" pada mesh menggunakan materi.

■ Array terakhir mengapung adalah himpunan m_fEmissive. Variabel ini juga

berisi empat mengapung. Properti memancarkan menentukan bagaimana intens

material akan memancarkan cahaya. Semakin tinggi nilai, "terang"

materi akan.

■ Properti material akhir adalah shininess material. para

variabel m_fShininess berisi mengapung tunggal. Variabel ini menentukan

betapa mengkilap yang specular highlights yang. Semakin rendah

nilai, lebih gelap dan kusam menyoroti akan-hanya

berlawanan dengan meningkatnya nilai. Menyoroti lebih gelap dan kusam yang

digunakan untuk bahan seperti kayu dan aspal, sedangkan cerah,

menyoroti shinier yang terbaik untuk logam mengkilap dan bahan buatan.

Setelah semua sifat material datang satu lebih-transparansi
material, yang disimpan dalam m_fTransparency. Meskipun lainnya
materi variabel berurusan dengan warna, transparansi set bagaimana buram atau
"Tembus" mesh. Nilai 1 adalah benar-benar buram dan
Nilai 0 adalah complitely transparan, atau tak terlihat. Karena cara
OpenGL menangani bahan, cara termudah untuk menangani ini adalah untuk mengambil ini
nilai dan hubungkan ke elemen terakhir dari properti menyebar. ini
metode menciptakan mesh transparan cukup bagus.
Setelah ini semua diambil dari perawatan, Anda harus melewatkan byte untuk mengkompensasi
untuk variabel, kecil yang tidak digunakan dalam informasi material. single ini
m_ucMode variabel byte tidak digunakan oleh format untuk saat ini. Hal ini di sana untuk
digunakan dalam versi kemudian.
Kemudian Anda sampai ke tekstur. Nama tekstur disimpan dalam 128-byte
string. Setelah Anda mendapatkan itu, Anda dapat mengirim langsung ke fungsi beban

dari kelas CImage termasuk dalam struktur. Ini akan mengambil tekstur

dan mengurus loading sehingga siap untuk digunakan ketika Anda mendapatkan ke

render panggung. Nama file yang disimpan dalam file dapat dikirimkan langsung ke

yang CImage:: Load () fungsi atau untuk Anda sendiri tekstur-loading fungsi.

Variabel terakhir memegang nama file dari peta alfa. Karena fakta

bahwa saya tidak dapat menemukan informasi tentang ini pada saat ini ditulis,

penggunaan peta alpha pada model saat ini tidak didukung. Namun,

tetap memeriksa situs Web untuk buku dan segera setelah informasi

tersedia saya akan memperbarui kode dan teks dan posting di sana.

Wah, itu banyak informasi. Namun, Anda sekarang memiliki cukup untuk

membuat model dalam apa yang saya sebut "posisi awal" nya. Ini adalah posisi yang

sebelum setiap animasi diterapkan. Secara umum, posisi ini dioptimalkan

untuk kemudahan mengedit dan mungkin tidak muncul dalam aktual

animasi urutan.

Gambar 6.2 menunjukkan apa model akan terlihat seperti diberikan.

Gambar 6.2 Model diberikan dalam posisi awal dengan tekstur, bahan,dan pencahayaan diaktifkan.

Cukup keren ya? Rendering model ini tidak terlalu keras. Ini pada dasarnya melibatkan
gambar jerat satu per satu, pastikan untuk mengatur sesuai
material dan pencahayaan sifat sebelumnya. Seperti biasa, untuk membuat
kode lebih mudah dibaca dan dikonversi ke bahasa lain dan API, saya menggunakan
langsung modus panggilan yang cukup jelas dalam apa yang mereka lakukan.
Hal pertama yang harus dilakukan adalah informasi material. dalam
OpenGL ini dapat dilakukan dengan menggunakan panggilan glMaterialf dan glMaterialfv.

for(int x = 0; x < m_usNumMeshes; x++)

{

//Set up materials

if(m_pMeshes[x].m_cMaterial >= 0)

{

SMs3dMaterial * pCurMat = &m_pMaterials[m_pMeshes[x].m_cMaterial];

//Set the alpha for transparency

pCurMat->m_fDiffuse[3] = pCurMat->m_fTransparency;

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pCurMat->m_fAmbient);

glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pCurMat->m_fDiffuse);

glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pCurMat->m_fSpecular);

glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, pCurMat->m_fEmissive);

glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, pCurMat->m_fShininess);

glEnable(GL_BLEND);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

//Texture map

pCurMat->m_Texture.Bind();

}

else

glDisable(GL_BLEND);

Ini sedikit kode harus mudah untuk mengikuti. Karena setiap model
dipecah menjadi jerat, Anda harus loop melalui mereka dan menarik mereka satu
pada suatu waktu. Hal pertama yang harus dilakukan adalah memeriksa untuk melihat apakah mesh tidak
memang memiliki material yang melekat padanya. Jika indeks material mesh
bukan -1, sebuah pointer ke materi yang sesuai diperoleh. sekarang Anda
hampir siap untuk mengirim informasi material ke OpenGL, namun,
Anda harus terlebih dahulu mengurus transparansi. Hal ini dilakukan dengan mengambil
variabel transparansi dan menggunakannya untuk menggantikan nilai alpha dari
menyebar properti. Setelah itu selesai operasi sederhana, Anda dapat mengatur sifat material. Setiap properti kecuali shininess menggunakan
glMaterialfv. Hal ini karena semua nilai-nilai lain adalah array dari nilai-nilai,
sedangkan shininess hanyalah sebuah mengapung tunggal.
Bagian berikutnya hanya menyala pencampuran dan set yang sesuai
blending mode. Hal ini menjamin transparansi yang akan bekerja dengan benar dan
akan meminimalkan artefak visual lucu.
Terakhir, menggunakan kelas CImage yang Anda gunakan untuk memuat kulitsebelumnya, Anda
mengikat tekstur untuk mesh.
Jika tidak ada bahan untuk kelompok, Anda harus memastikan untuk mematikan
pencampuran. Kegagalan untuk melakukannya dapat menyebabkan artefak visual yang sangat aneh dan
yang tidak diinginkan grafis Glitches. Anda juga dapat menggunakan glMaterial untuk mengatur
bahan kembali ke default. Nilai default untuk ambient, diffuse,
specular, bahan memancarkan adalah (0,2, 0,2, 0,2, 1,0), (0.8,0.8,0.8,1.0),
(0.0,0.0,0.0,1.0), dan (0.0,0.0,0.0,1.0), masing-masing. shininess yang
material juga set ke 0.
Kode yang mengirim simpul ke sistem rendering berikut:

//Draw mesh

glBegin(GL_TRIANGLES);

for(int y = 0; y < m_pMeshes[x].m_usNumTris; y++)

{

//Get a pointer to the current triangle

SMs3dTriangle * pCurTri = &m_pTriangles[m_pMeshes[x].m_uspIndices[y]];

//Send the normal

glNormal3fv(pCurTri->m_vNormals[0].Get());

//Send texture coords

glTexCoord2f(pCurTri->m_fTexCoords[0][0], pCurTri->m_fTexCoords[1][0]);

//Send vertex position

glVertex3fv(m_pVertices[pCurTri->m_usVertIndices[0]].m_vVert.Get());

glNormal3fv(pCurTri->m_vNormals[1].Get());

glTexCoord2f(pCurTri->m_fTexCoords[0][1], pCurTri->m_fTexCoords[1][1]);

glVertex3fv(m_pVertices[pCurTri->m_usVertIndices[1]].m_vVert.Get());

glNormal3fv(pCurTri->m_vNormals[2].Get());

glTexCoord2f(pCurTri->m_fTexCoords[0][2], pCurTri->m_fTexCoords[1][2]);

glVertex3fv(m_pVertices[pCurTri->m_usVertIndices[2]].m_vVert.Get());

}

glEnd();

}

}

Sama seperti Anda loop melalui jaring masing-masing, Anda harus loop melalui masing-masing segitiga dalam jaring itu sendiri. Setelah mendapatkan pointer ke yang sesuai
struktur segitiga dalam array wajah, Anda dapat mengirim normalvektor, koordinat tekstur, dan posisi vertex ke OpenGL. ini harus dilakukan tiga kali untuk setiap segitiga dan sekali untuk setiap vertex.

Animasi

Ini adalah bagian Anda memiliki semua telah menunggu. Bagian pertama yang menggunakan
apa yang Anda pelajari pada Bab 5, "Pengantar Animasi rangka"
(Anda tidak membaca yang tidak Anda?)
Hal pertama yang harus Anda lakukan adalah menyelesaikan loading model. sisanya
bagian dari model berisi (tulang) Data gabungan, termasuk mereka
nama, posisi awal, dan keyframes.
Seperti bagian lain dari file ms3d, struktur sendi didahului
oleh sebuah integer dua-byte yang memberitahu berapa banyak sendi file berisi. lalu
datang data. Sendi dan struktur yang menyertainya cukup
rumit, jadi beruang dengan saya.
Pertama, struktur sederhana. Struktur ini digunakan untuk menyimpan rotasi
dan terjemahan dari keyframes:

//------------------------------------------------------

//- SMs3dKeyFrame

//- Rotation/Translation information for joints

struct SMs3dKeyFrame

{

float m_fTime;

float m_fParam[3];

};

Ini adalah struktur yang cukup sederhana. Struktur keyframe menyimpan

satu "titik berhenti" atau tengara model. Variabel pertama, fTime,

menyimpan waktu dalam detik keyframe ini akan digunakan untuk mengatur

posisi sendi tertentu. Variabel kedua adalah array dari tiga

mengapung. Mereka menyimpan rotasi di sekitar X, Y, dan sumbu Z, atau mereka mengandung X, Y, dan Z penerjemahan nilai-nilai. Bersama masing-masing berisi satu set
keyframes ini untuk kedua rotasi dan nilai-nilai penerjemahan.
Sekarang, pada struktur sendi. Ini adalah struktur yang cukup besar yang berisi
banyak data. Beberapa itu harus diambil dari file; beberapa itu
diciptakan dari nilai-nilai ini bukannya dimuat langsung dari file tersebut.
Di sini sekali lagi, struktur dalam kode bervariasi dari struktur dalam
file. File berisi bendera editor, nama sendi, sendi orang tua
nama, posisi dan rotasi awal, jumlah keyframes untuk
rotasi dan translasi, dan terjemahan aktual dan rotasi
keyframes. Seperti kasus kembali dalam struktur kelompok bila Anda
dibutuhkan untuk menggunakan sebuah array dinamis dialokasikan untuk menahanindeks, Anda
perlu mengalokasikan memori untuk keyframes sebelum membaca mereka masuk
Brace sendiri. Berikut adalah kode untuk SMs3dJoint, struktur sendi.

//------------------------------------------------------

//- SMs3dJoint

//- Bone Joints for animation

struct SMs3dJoint

{

//Data from file

unsigned char m_ucpFlags; //Editor flags

char m_cName[32]; //Bone name

char m_cParent[32]; //Parent name

float m_fRotation[3]; //Starting rotation

float m_fPosition[3]; //Starting position

unsigned short m_usNumRotFrames; //Number of rotation frames

unsigned short m_usNumTransFrames; //Number of translation frames

SMs3dKeyFrame * m_RotKeyFrames; //Rotation keyframes

SMs3dKeyFrame * m_TransKeyFrames; //Translation keyframes

//Data not loaded from file

short m_sParent; //Parent joint index

CMatrix4X4 m_matLocal;

CMatrix4X4 m_matAbs;

CMatrix4X4 m_matFinal;

unsigned short m_usCurRotFrame;

unsigned short m_usCurTransFrame;

};

Mari kita berjalan melalui langkah demi langkah. Seperti semua struktur data dari
MS3D, yang satu ini memiliki nilai satu byte dari bendera editor yang dapat diabaikan.
Setelah itu ada dua karakter 32-string. string ini
terus nama sendi dan nama orang tua sendi itu. Kemudian, Anda akan
pertandingan setiap sendi ke induknya sehingga Anda tidak harus membandingkansemua
string setiap kali posisi sendi perlu menghitung ulang.
Berikutnya datang rotasi awal dan terjemahan sendi. enam
nilai-nilai tiga untuk rotasi dan tiga untuk terjemahan-memberikan awal
posisi sendi.
Lalu datang dua dua-byte bilangan bulat, satu untuk jumlah rotasi
keyframes dan satu untuk jumlah keyframes penerjemahan. ini adalah
digunakan untuk mengalokasikan memori untuk dua variabel berikutnya yang terus aktual
rotasi dan translasi data, masing-masing.
Setelah mengalokasikan memori, Anda dapat membaca data dari file ke dalam
yang baru dibuat array. Ini adalah semua data yang perlu datang dari
file. Anda dapat menutup file dan menyingkirkan setiap buffer sementara yang anda
mungkin telah menciptakan atau dialokasikan.

Menemukan Orangtua Hilang

Setiap sendi menyimpan nama induknya. Meskipun nama ini dapat

digunakan, itu adalah sakit untuk menjalankan banyak dari string membandingkan operasi dan pencarian

melalui setiap bersama untuk menemukan yang tepat. Lebih baik bahwa perbandingan ini

dilakukan hanya sekali, selama pemuatan model. itu

mana variabel m_sParent masuk Variabel ini merupakan indeks ke dalam

array sendi. Pada indeks ini adalah orangtua sendi saat ini. Jika sendi adalah

bersama akar, yang berarti telah ada orang tua, ini diatur dengan -1 untuk menghindari kebingungan.

Untuk menghitung variabel ini untuk bersama saat ini, Anda mulai dari awal

dari array dan loop melalui sendi sampai salah satu dari sendi

nama sesuai dengan nama orang tua sendi saat ini ini. Pastikan untuk menentukan

apakah nama orang tua yang kosong pertama. Sebuah nama kosong orangtua

menandakan bahwa bersama telah tidak ada orang tua, dan itu akan membuang-buang waktu untuk

mencari satu.

Persiapan Awal

Sebelum Anda dapat mulai menjiwai, Anda harus melakukan setup sedikit lebih. Setiap

matriks sendi harus diatur dengan rotasi awal dan terjemahan, dan

simpul dan normals menempel pada tulang masing-masing harus diubah

oleh matriks. Lihatlah di CMs3d:: Setup () fungsi. (Karena

fungsi ini terlalu besar untuk dipajang di sini, Anda mungkin ingin merujuk pada

kode. CMs3d:: Setup dapat ditemukan di direktori Code/Chapter6 di

ms3d.cpp. Fungsi dimulai sekitar garis 490.)

Fungsi Pengaturan terdiri dari tiga bagian. Bagian pertama loop melalui

sendi dan menciptakan matriks. Matriks pertama dibuat adalah

relatif matriks, disimpan dalam variabel m_matLocal. Ini adalah rotasi

dan terjemahan dari sendi dengan sendirinya. Menggunakan m_fRotation dan

m_fTranslation array dalam sendi, matriks m_matLocal dapat dibuat

dengan SetRotation dan fungsi SetTranslation anggota

matriks kelas.

Berikutnya datang matriks mutlak. Matriks mutlak hanyalah

relatif matriks (m_matLocal) dikalikan dengan relatif tua itu sendi

matriks. Matriks yang dihasilkan disimpan dalam variabel m_matAbs. Jika

bersama telah tua tidak, matriks mutlak adalah sama dengan relatif atau

lokal matriks.

Matriks variabel ketiga (m_matFinal) adalah transformasi akhir

matriks yang digunakan selama animasi. Untuk saat ini, hanya dapat diatur untuk sama

nilai sebagai matriks mutlak.

Bagian kedua dari fungsi pengaturan melibatkan mengubah

simpul ke dalam apa yang saya sebut "animasi posisi awal". Awal

Posisi animasi hanya posisi diasumsikan oleh model saat

sendi-set menggunakan rotasi menatap dan nilai-terjemahan

nilai-untuk m_fRotation dan m_fTranslation setiap sendi. Posisi ini

mungkin tidak termasuk dalam animasi pertama.

Untuk melakukan transformasi ini, semua yang perlu Anda lakukan adalah mengambil final

matriks dari sendi verteks saat ini terpasang. Simpul

harus diubah oleh invers dari matriks ini. Invers dari

matriks rotasi akan memutar arah berlawanan dari matriks awal. Ini

dapat dilakukan dengan menggunakan fungsi InvRotateVec dan InvTranslateVec

termasuk dalam kelas matriks (matrix.inl).

Terakhir dari semua, Anda harus mengatur normals lanjut untuk memastikan pencahayaan yang tepat.

Karena normals disimpan dalam struktur wajah, Anda mempunyai loop melalui wajah bukan simpul. Untuk mendapatkan yang sesuai

matriks untuk mengubah normals, Anda harus menggunakan indeks titik

struktur wajah untuk mengambil sendi dan matriks digunakan untuk mengubah

puncak, yang normal milik. Setelah Anda memiliki matriks ini,

normal bisa diputar. Seperti simpul, Anda menggunakan InvRotateVec

fungsi. Namun, karena normals pencahayaan vektor-vektor satuan, ada

tidak perlu untuk menerjemahkan mereka juga.

Sekarang, semuanya sudah diatur dan siap untuk menghidupkan.

Animasi dan Interpolasi

Akhirnya Anda sampai ke hal yang baik. Semua simpul di kanan mulai

tempat, semua sendi ditetapkan, dan semua data lainnya dimuat dan

diambil dari perawatan. Sekarang Anda dapat menghidupkan model.

Fungsi Animate dari kelas CMs3d mengambil empat parameter. yang pertama

adalah kecepatan. Kecepatan adalah nilai floating-point yang menetapkan bagaimana

cepat model harus bernyawa. Nilai 1.0f berarti model

harus menghidupkan persis secepat itu dimaksudkan untuk ketika diciptakan. Sebuah

nilai 2.0f akan menghidupkan dua kali lebih cepat seperti aslinya, dan 0.5f akan

Model menghidupkan setengah secepat asli dan sebagainya.

Dua berikutnya parameter, fStartTime dan fEndTime, memberitahu fungsi

bagian mana dari animasi untuk digunakan. Karena setiap sendi dapat memiliki

berbagai jumlah keyframes dan keyframes dari gabungan tidak perlu

terjadi pada interval waktu yang sama, adalah tidak praktis untuk menggunakan memulai dan

akhir keyframe. Para fStartTime dan fEndTime memberikan awal dan akhir

saat segmen animasi. Jika fStartTime adalah 0.3f dan fEndTime adalah 0.9f,

hanya enam persepuluh senilai kedua dari animasi antara dua

kali diambil. Karena tidak ada di file MS3D yang memberitahu Anda

mana animasi terpisah mulai dan berhenti, Anda mungkin merekam memulai

dan waktu akhir dari animasi tertentu. Sebagai contoh, 0,0-0,5 detik

berisi animasi berjalan dan 0,5-1,3 berisi animasi melompat. dengan

memasukkan nilai-nilai ini ke dalam fungsi Animate (), Anda dapat menampilkan hanya

atau hanya menjalankan animasi melompat.

Sekarang Anda perlu menentukan apa bagian dari animasi untuk menampilkan

pada saat saat ini. Tidaklah cukup untuk hanya memilih keyframe dengan

waktu paling dekat dengan waktu saat ini. Melakukan hal ini akan menghasilkan dendeng,

gerak wajar karena jarak antara keyframes dapat

besar dan waktu yang dibutuhkan untuk berpindah dari satu ke yang lain dapat cukup panjang. Sebuah keyframe mungkin hanya ada di awal dan akhir kaki

gerakan, dan hanya bergantian antara dua frame untuk mewakili

berjalan akan terlihat mengerikan. Sebaliknya, Anda perlu interpolasi antara

keyframes.

Menggunakan kelas Timer disertakan dengan kelas CMs3d, Anda mendapatkan waktu

yang telah berlalu dalam hitungan detik sejak frame terakhir. Menambahkan waktu ini untuk

waktu berlalu sejak terakhir kali animasi dimulai kembali, dan

menambahkan hasilnya ke awal waktu yang ditentukan dalam parameter

fungsi harus memberikan nilai waktu untuk digunakan saat menemukan

posisi model.

Berbekal nilai waktu, Anda dapat menemukan "saat ini" dan "sebelumnya"

frame untuk setiap frame. Nilai waktu Anda dihitung dalam sebelumnya

langkah harus jatuh di suatu tempat antara keyframe sebelumnya dan saat ini,

tanpa keyframes di antara mereka. Jika waktu jatuh antara frame 5 dan

6 bingkai, frame sebelumnya adalah 5 dan frame adalah 6.

Mari kita mulai dengan terjemahannya.

Terjemahan

Hal pertama yang Anda lakukan adalah menemukan keyframe saat ini. Hal ini dilakukan dengan menggunakan

loop untuk kenaikan konter bingkai, mulai dari 0, sementara ada

masih keyframes terjemahan, dan sementara nilai waktu untuk itu saat ini

keyframe kurang dari waktu Anda berlalu dihitung.

Ada tiga kemungkinan nilai counter frame, sebagai

berikut:

■ Yang pertama adalah 0. Ini berarti bahwa Anda hanya perlu menyalin

terjemahan nilai untuk terjemahan pertama keyframe ke

variabel temporer memegang terjemahan saat ini.

■ Kemungkinan kedua untuk counter frame yang memegang

jumlah keyframe terakhir. Dalam hal ini, Anda lakukan seperti yang Anda lakukan untuk 0,

kecuali Anda menggunakan frame terakhir dalam array keyframes penerjemahan.

■ Nilai akhir dan kemungkinan besar adalah jumlah keyframe di

tengah dari dua ekstrem. Jika ini terjadi, Anda perlu interpolasi

antara nilai ini terjemahan dari keyframe dan

terjemahan nilai sebelumnya keyframe (framecounter - 1).

Jadi bagaimana Anda melakukan ini? Ingat interpolasi linier dari ketika

Anda bekerja dengan format seperti md2? Konsep yang sama berlaku di sini.

Yang Anda butuhkan adalah perubahan waktu antara dua frame (At). menggunakan

nilai ini, Anda dapat menghitung nilai interpolasi untuk digunakan ketika Anda

melakukan interpolasi linier. Hal ini dilakukan dengan menggunakan rumus berikut:

(CurrentTime – TimeOfPrevFrame)/ Δt

Anda mengurangi waktu dari frame sebelumnya dari arus

waktu dan kemudian membaginya dengan perubahan waktu antara dua frame.

Menggunakan nilai yang dihasilkan, Anda dapat dengan mudah Anda interpolasi antara X, Y,

dan Z penerjemahan nilai-nilai.

Rotasi

Sekarang untuk rotasi. Rotasi hampir proses yang sama. arus

dan frame sebelumnya dihitung dengan cara yang sama, dan Anda ikuti

hampir proses yang sama jika model pada ekstrem. Jika model ini

di salah satu ekstrem, yang berarti keyframe saat ini adalah sama dengan

pertama atau yang terakhir keyframe model, rotasi nilai-nilai

keyframe terakhir ditempatkan dalam matriks sementara menggunakan SetRotation yang

fungsi dari kelas CMatrix4X4.

Perbedaan utama muncul ketika Anda perlu interpolasi antara

rotasi. Meskipun Anda bisa menggunakan metode yang sama seperti yang Anda lakukan untuk

terjemahan, metode yang menyenangkan jauh lebih baik dan lebih grafis

melibatkan menggunakan quaternions. Jika Anda melompati Bab 2, sekarang

menjadi saat yang baik untuk membaca (atau baca ulang) itu.

Karena model toko sudut rotasi sebagai tiga sudut Euler,

Hal pertama yang dilakukan adalah membuat dua quaternions menggunakan fungsi FromEulers.

Anda perlu membuat dua quaternions terpisah dari saat ini dan

sebelumnya rotasi keyframes. Kedua quaternions mewakili

rotasi dari masing-masing frame. Sekarang, Anda harus menghitung angka empat yang

yang mewakili rotasi pada posisi saat ini. setelah

interpolasi nilai dihitung (hal itu dilakukan dengan cara yang sama seperti untuk terjemahan),

yang quaternions dapat dimasukkan ke dalam fungsi SLERP, bersama dengan

nilai interpolasi, untuk membuat angka empat baru yang berisi

benar rotasi untuk waktu sekarang.

Karena OpenGL menggunakan matriks, perlu untuk mengkonversi angka empat tersebut.

Sebuah angka empat kemudian dapat berubah kembali menjadi matriks menggunakan

ToMatrix4 fungsi dari kelas CQuaternion.

Setelah matriks rotasi dibangun, Anda perlu menambahkan terjemahan untuk itu.

Menggunakan matriks suhu yang sama yang digunakan untuk rotasi, Anda dapat menghubungi SetTranslation fungsi dengan penerjemahan nilai-nilai Anda dihitung

sebelumnya untuk menyelesaikannya. Hanya ada satu langkah tersisa sebelum Anda dapat mulai menggambar model lagi. Untuk menemukan matriks akhir sendi, Anda perlu mengalikan sendi lokal matriks (m_matLocal) dengan matriks sementara yang anda buat. Ini Hasilnya dapat disimpan dalam m_matFinal, dan merupakan matriks yang akan digunakan untuk mengubah simpul dan normals kemudian.

Jika Anda ingin, Anda sebenarnya dapat menarik tulang saja sekarang. X, Y, dan Posisi Z tulang disimpan dalam elemen 12, 13, dan 14 joint akhir matriks. Menggambar garis dari titik ini untuk elemen 12, 13, dan 14 dari matriks akhir induk sendi akan memberikan Anda sebuah animasi "Kerangka" untuk model, seperti Gambar 6.3 menunjukkan. Gambar 6.3

Gambar 6.3 Kerangka animasi dari model semua dengan sendirinya.

Sekarang bahwa Anda memiliki informasi patungan baru, Anda harus mengubah semua simpul dan simpul normals. Untuk kejelasan, semua kode untuk mengubah dan menampilkan model dalam Cmas3d:: RenderT () fungsi. Fungsi ini disebut matriks langsung setelah final bagi semua sendi dihitung. Seperti dengan fungsi membuat lama, jerat diambil satu per satu. Untuk mesh setiap bahan yang pertama didirikan. Kemudian, Anda pindah ke mengubah simpul dan normals. Anda dapat memulai render yang tepat

pergi. Seperti wajah-wajah yang dilingkarkan melalui, orang-orang yang tidak memiliki tulang terlampir diambil seperti biasa, tanpa modifikasi apapun.

Sisanya dari mereka, di sisi lain, adalah cerita yang berbeda. Sebuah sementara

vektor dibentuk untuk memegang kedua normal baru dan simpul baru. pertama

normal harus diambil dari perawatan. Karena matriks transformasi

benar-benar memodifikasi vektor yang diberikan kepada mereka, hal pertama yang dilakukan adalah

menempatkan normal saat ini menjadi pemegang sementara. setelah menentukan

yang bersama vertex normal terpasang, Anda dapat menggunakan Transform3 yang

fungsi untuk memodifikasi normal sementara, hanya menggunakan rotasi

bagian dari matriks.

Simpul dapat diubah dalam banyak cara yang sama. Satu-satunya utama

Perbedaannya adalah bahwa fungsi Transform4 harus digunakan, bukan

dari Transform3. Transform4 menambahkan terjemahan dalam juga, memberikan

titik posisi yang tepat.

Semuanya sekarang dapat dikirim ke API render. Jangan lupa untuk mengirimkan

koordinat tekstur serta normal dan titik-pastikan

mereka dikirim dalam urutan yang benar!

Gambar 6.4 menunjukkan model dalam kemuliaan menghidupkan penuh.

Gambar 6.4 Model berubah pada pertengahan animasi. Perhatikan tulang yang telah

telah ditarik dari atas sebagai referensi.

Seperti yang Anda perhatikan pada Gambar 6.4, Anda dapat melihat tulang-tulang di bagian atas model. Dalam demo ini dilakukan dengan menonaktifkan pengujian kedalaman dan menggambar tulang menggunakan teknik yang diajukan sebelumnya. Hanya pastikan anda mengaktifkan kembali pengujian mendalam ketika Anda selesai.

Nah, di sana Anda memilikinya. Anda sekarang dapat memuat format poligon rendah, yang adalah favorit pribadi saya. (Sebuah format poligon rendah berarti bahwa

menghasilkan model dengan jumlah poligon rendah. Karena Anda berurusan

dengan permainan yang harus diberikan secara real-time, model poligon rendah

adalah suatu keharusan. Menggunakan model poligon yang tinggi akan memperlambat permainan Anda ke titik yang tidak dapat dimainkan.) Saya pasti menyarankan memeriksa editor dan format tahu apakah Anda adalah pengembangan independen atau uang-kekurangan tim. Hal ini sangat bagus, dan datang pada harga yang besar.

Semoga Anda menikmati bab ini. Ingat, jika Anda memiliki komentar,

pertanyaan, atau saran, jangan ragu untuk menghubungi saya di evan@codershq.com.

Kesimpulan

Bab ini menandakan selesainya pertama Anda skeletally animasi format. Anda sekarang harus dapat memuat dan menggunakan format yang sangat berguna bahwa hampir tampaknya dibuat hanya untuk permainan. Anda telah belajar bagaimana menghidupkan tulang oleh interpolasi antara rotasi dan translasi. Anda juga telah melihat penggunaan paling umum dari quaternions dalam 3D permainan pemrograman, disisipkan antara rotasi. Akhirnya, bab ini mengikat semua bersama-sama untuk menciptakan MS3D sepenuhnya bekerja loader, lengkap dengan animasi kerangka. Pastikan untuk memeriksa

Milkshape di situs di http://www.milkshape3d.com dan check out demo

Milkshape 3D di CD (dalam direktori Software/MilkShape3d). Bab berikutnya mencakup salah satu format yang paling populer, 3DS. Anda akan belajar bagaimana untuk memuat dan membuat format ini cukup rumit. Anda akan belajar bagaimana menggunakan "potongan-berbasis" format. Anda juga akan menangkap sekilas dari beberapa informasi yang bisa Anda simpan di file.

              Bab 7

Milkshape

3d

Saat aku menelusuri berbagai forum internet, baca mailing list, dan bahkan hanya berbicara dengan berbagai orang tentang model 3Ds, format ini tampaknya datang banyak. Pertanyaan "Bagaimana cara memuat model 3ds?" Dan "Bagaimana saya menggunakan model 3ds dalam program saya "muncul di semua tempat? Sayangnya, sampai sekarang, tidak ada referensi yang sangat bagus ini format yang tersedia. Referensi luar sana jatuh ke salah satu dari tiga kategori: perpustakaan yang menawarkan Anda kontrol sedikit lebih dari apa yang Anda bisa lakukan, kode dan program yang tidak mungkin untuk menguraikan, dan membingungkan, dokumen yang sangat teknis. Meskipun tulisan ini tidak berarti meliputi semuanya harus dilakukan dengan format 3ds, tujuan saya di sini adalah untuk Anda mulai dalam arah yang benar. Bab ini memandu Anda melalui loading dan menampilkan model 3d diekspor langsung dari format 3ds Autodesk (http://www.autodesk.com). Ada ton informasi yang terkandung dalam file 3ds. Bab ini

ekstrak data yang akan paling berguna untuk Anda dalam permainan Anda atau lainnya

Program 3D. Data ini mencakup data mesh dan informasi material, mengabaikan bendera editor, lampu, dan potongan lainnya. Namun, jika Anda lakukan merasa membutuhkan tambahan ini, ini masalah sederhana untuk menambahkan mereka setelah Anda mendapatkan melalui bab ini.

Memahami Chunky 3ds File

Format dari file 3ds sudah diatur dalam cara yang sangat menarik. setiap bagian dari file sendiri "sepotong". Potongan masing-masing berisi identifier, yang panjang, dan sekelompok byte yang menyimpan data untuk sepotong itu. Meskipun file lain memiliki potongan, mereka baik termasuk satu header memberitahu Anda di mana Anda akan menemukan potongan masing-masing atau memiliki potongan mengatur

dalam urutan tertentu. Sebuah file 3ds tidak melakukan keduanya ini. File-file 3ds dapat

memiliki potongan dalam urutan apapun dan tidak ada header yang memberitahu Anda di mana mereka berada di file atau bahkan berapa banyak dari setiap potongan yang ada.

Ide ini ditampilkan dalam Gambar 7.1, yang mengilustrasikan sebuah file tunggal, terbuat dari beberapa potongan up.

 

Gambar 7.1 Sebuah file yang terbuat dari potongan data.

Ini bagus dan keren sampai Anda melihat sedikit lebih mendalam. Setup dari sebuah file 3ds bisa sangat membingungkan pada pandangan pertama. Tidak hanya itu dibagi menjadi potongan kecil banyak, tapi masing-masing potongan yang lebih kecil dapat memiliki sub-potongan, yang mungkin bahkan lebih sub-potongan. Terburuk dari semua, untuk sebagian besar, potongan tidak perlu dalam urutan tertentu dalam file.

Struktur dari file 3ds diatur lebih seperti Gambar 7.2, bukan format yang ditampilkan pada Gambar 7.1. Gambar 7.1 Sebuah file yang terbuat dari potongan data.

 

Gambar 7.2 Sebuah representasi grafis dari sebuah file dengan menggunakan struktur yang mirip dengan 3ds.

Jadi bagaimana Anda menangani itu? Cara termudah saya telah menemukan adalah untuk pertama baca di header chunk tersebut. Setiap potongan dalam file 3ds memiliki enam byte header yang memegang identifier dan panjang potongan tersebut. Kemudian, berdasarkan jenis potongan dan panjang, bagian tertentu dari program ini dapat

dipanggil untuk memanipulasi dan memproses data. Potongan dapat mewakili

jerat atau segitiga dari sebuah objek, sedangkan sub-potongan potongan ini terus

simpul, koordinat tekstur, dan informasi material untuk mesh itu. Potongan lainnya dapat menahan bahan dengan sub-potongan untuk menyebar, specular, dan bahan ambien, dengan sub-potongan untuk setiap warna. Ada banyak manfaat untuk menangani dengan cara ini. Pertama-tama, hal itu memungkinkan Anda hanya proses potongan tertentu. Jika sepotong berisi data yang tidak dibutuhkan, Anda hanya dapat membaca benar melewatinya. Dalam 3ds file data, untuk misalnya, Anda mungkin akan ingin melewatkan potongan yang berisi data yang relevan dengan editor. Kedua, itu membuat sangat mudah untuk bekerja dengan file seperti model 3ds mana potongan tidak dalam urutan yang ditetapkan. Karena header dibaca pertama, jenis potongan dapat ditentukan,

dan tindakan tepat dapat diambil oleh kode. Terakhir, pendekatan ini mengarah pada program yang sangat modular. Jika Anda perlu mengubah spesifikasi sepotong atau Anda menambahkan kode untuk potongan baru, itu adalah proses yang cukup sederhana. Hal ini sangat mudah untuk menemukan bagian yang membahas dengan bagian-bagian tertentu dari kode. Menambahkan kode untuk menangani jenis baru hanya memerlukan memaku potongan kode tambahan ke akhir. Ini contoh program menggunakan vektor STL cukup sedikit. Jika Anda membutuhkan informasi pada vektor, periksa Lampiran B, "STL Primer Vector," untuk singkat pengenalan atau penyegaran.

Mulai 3ds Chunk Header

Setiap potongan dalam file 3ds dimulai dengan struktur S3dsChunkHeader.

//----------------------------------------------

//- S3dsChunkHeader

//- Header for each chunk

struct S3dsChunkHeader

{

unsigned short m_usID;

unsigned int m_uiLength;

};

Variabel pertama adalah identifier potongan dua-byte. Ini memberitahu Anda apa yang

Jenis data sepotong berisi. Hal ini dapat berupa data titik, data wajah, animasi data, data informasi bahkan tidak berguna. Variabel panjang adalah panjang sepotong keseluruhan, termasuk header. Hal ini dapat sedikit menyesatkan namun; nilai panjang meliputi potongan saat ini ditambah panjang dari semua sub-potongan mengandung, jadi hati-hati. Tabel 7.1 daftar ID potongan yang paling umum bersama dengan menggunakan mereka.

File Data 3ds

File 3ds terdiri dari potongan banyak, beberapa yang penting

untuk permainan, banyak yang tidak. Dalam bagian berikut, Anda akan belajar

tentang potongan yang paling penting dalam sebuah file 3ds. Menggunakan potongan

Anda dapat memuat, membuat, dan tekstur file 3ds. Meskipun pertama

potongan dijamin berada di awal file, sisanya mungkin

muncul di mana saja di file tersebut, sebagian besar dari mereka beberapa kali.

Header 0x4Dx4D

Sekarang Anda siap untuk menggali ke dalam file itu sendiri. Enam byte pertama dari

file harus berisi header sepotong utama. ID dari ini header 0x4d4d dan panjang variabel harus berisi total panjang file. Potongan ini berisi semua sub-potongan yang membuat file. Tidak ada tindakan yang diperlukan pada titik ini, Anda hanya dapat bergerak melewati header dan mulai membaca potongan. Setiap 3ds Model hanya berisi satu potongan tersebut.

Chunck 0x0002

Di suatu tempat dalam file, umumnya potongan sub-pertama (potongan 0x4D4D), adalah

potongan ini. Sebanyak 10 byte panjangnya, data terdiri dari fourbyte tunggal

bilangan bulat yang berisi versi format. Ini harus lebih besar dari 3. Versi 3ds Max berbeda dari versi yang lebih baru dalam cara file diatur, yang berarti bahwa program ini tidak mungkin beban mereka dengan benar.

Objek dalam Chunk 0x4000

Potongan 0x4000 berisi data tentang obyek-obyek. Sebuah objek dapat menjadi

segitiga mesh, cahaya, kamera, atau bahkan untuk pengaturan jendela editor. untuk

pemrograman game, biasanya Anda ingin mengabaikan segalanya.

Tabel 7.1 3ds chunks umum dan Menggunakan Gunakan Nomor ID

0x4Dx4D        Digunakan pada awal file untuk menandakan bahwa file tersebut adalah file 3ds.

  0x0002            Menyimpan nomor versi dari file.

0x4000              "objek" seperti mesh, kamera, atau cahaya.

Setiap potongan 0x4000 berisi sub-potongan dengan verteks,

tekstur koordinat, dan informasi lainnya

0x4100              Sebuah sub-0x4100 potongan 0x4000. Sebuah potongan 0x4100 berisi semua

dibutuhkan untuk membangun sebuah segitiga mesh.

Berisi 0x4110 simpul untuk objek. Ini adalah serangkaian sub-

0x4100.

  0x4120          Juga sepotong sub-0x4100, 0x4120 sepotong berisi

Wajah informasi, termasuk indeks titik yang menceritakan

simpul yang membentuk wajah masing-masing.

0x4130            ain sub-sepotong 0x4100, 0x4130 berisi informasi

bahan yang harus diterapkan untuk yang menghadap.

0x4140            Bahkan potongan lain sub-0x4100, bongkahan ini berisi

koordinat tekstur wajah yang memungkinkan untuk menjadi tekstur yang dipetakan.

0xAFFF          Definisi material ditemukan di dalam 0xAFFF, warna untuk

ambien, bahan menyebar, dan specular, serta

shininess dan transparansi dalam sepotong ini.

0xA000           sepotong 0xAFFF yang berisi nama material.

0xA010           Sebuah potongan sub-0xAFFF juga, berisi ambien

warna untuk materi.

0xA020           potongan sub-0xAFF, 0xA020 berisi meredakan

warna bahan.

0xA030           keempat sub-sepotong 0xAFF, ini berisi specular

sorot warna untuk bahan tertentu.

0xA040           Namun lain sub-potongan 0xAFFF, kali ini berisi

shininess material.

0xA050           Sekali lagi, sub-sepotong 0xAFFF yang mengontrol seberapa transparan

atau buram suatu material.

0xA200           juga sepotong sub-potongan 0xAFFF. ini

potongan menyimpan nama file dari peta tekstur atau kulit untuk

bahan saat ini.

Loading dan lampu kamera dapat mengganggu dengan bagian lain dari

Anda permainan dan menyebabkan beberapa artefak visual yang tampak sangat aneh. Namun, Anda mungkin ingin melihat ke dalam loading dan menggunakan lampu jika Anda tertarik menggunakan format 3ds untuk format tingkat atau dunia.

Potongan 0x4000 mengandung sedikit data dengan sendirinya, sisanya adalah dibungkus dalam sub-potongan. Ini berisi string diakhiri dengan null yang menyimpan nama mesh. Karena panjang string yang tidak diatur, maka harus null diakhiri. Menggunakan strcpy pada buffer data dapat mengekstrak nama ini. Namun, jika Anda menggunakan pointer sementara untuk bergerak melalui array, pastikan Anda memindahkannya strlen (m_cName) + 1 byte untuk account untuk terminator null pada akhir string. setelah

string adalah membaca, sisa panjang data penuh sub-potongan. Perlu pikiran mungkin ada banyak jerat dalam file yang sama, jadi pastikan untuk menjaga melacak di mana Anda berada.

//pseudocode to begin reading the 0x4000 chunk

if chunkID is 0x4000

read null terminated string (strcpy)

advance pointer past string and null pointer (strlen+1)

Segitiga Mesh 0x4100

Ini adalah dimana data yang Anda inginkan adalah. Sebuah potongan jala segitiga

memegang hanya itu, segitiga yang berisi mesh. Jala adalah sekelompok

poligon yang membentuk permukaan; mesh segitiga adalah sama kecuali

itu terdiri dari segitiga saja. Dalam potongan 0x4100 adalah simpul, wajah,

dan tekstur koordinat, serta informasi material wajah. Sebelum Anda khawatir tentang membaca dalam data ini, Anda butuh tempat untuk menyimpan itu. Itu adalah di mana struktur S3dsMesh masuk Setiap struktur S3dsMesh memegang satu jala segitiga. Karena file tersebut tidak mengungkapkan bagaimana jerat banyak ada total, Anda dapat memanggil kekuatan STL dan std:: vector untuk membuat sebuah tempat untuk menyimpan sejumlah jerat. Berikut adalah struktur mesh:

//------------------------------------------------

//- S3dsMesh

//- Group Mesh Data

struct S3dsMesh

{

char m_cName[256];

vector<S3dsVertex *> m_vVertices;

vector<S3dsTexCoord *> m_vTexCoords;

vector<S3dsFace *> m_vFaces;

vector<S3dsObjMat *> m_vMaterials;

unsigned short m_usNumFaces;

};

Variabel pertama (m_cName) adalah nama mesh. Ini harus ditetapkan saat anda terlebih dahulu masukkan potongan 0x4000, karena di situlah nama string terletak. Anda perlu berhati-hati di sini. String dalam 3ds model terbatas, bisa panjang apapun. Namun, dalam struktur Anda hanya ada 256 byte penyimpanan. Mudah-mudahan, ini akan cukup untuk

tahan salah satu nama mesh, tetapi pastikan untuk memeriksa terlebih dahulu. Jika panjang string dalam file melebihi 256 karakter, Anda akan perlu untuk memotong

sebelum menyimpan. Sisa data yang terkandung di sub-potongan potongan 0x4100.

(Ya, Anda dapat memiliki sub-sub-potongan potongan!) Karena Anda tidak tahu berapa banyak simpul, wajah, atau bahan akan ada, Anda mungkin ingin untuk menggunakan std:: vector. Ini pada dasarnya adalah sebuah array resizable. Menggunakan std:: vektor, Anda dapat menambahkan objek ke array sebanyak sesuka Anda tanpa mengalokasikan atau mengubah ukuran itu. Jika Anda tidak yakin tentang cara menggunakan std:: vektor, saya sarankan anda melompat ke Lampiran B. Pada bagian berikutnya, Anda belajar tentang sub-potongan dari 0x4100 sepotong. Potongan ini menyimpan informasi tentang simpul, koordinat tekstur, wajah, dan bahan. Sebuah objek tertentu dapat memiliki semua ini sub-potongan, atau hanya beberapa. Sebuah objek tidak harus mengandung tekstur mengkoordinasikan dan informasi material.

Simpul 0x4110

Potongan sub-0x4110 dari bongkahan 0x4100 berisi semua simpul informasi untuk mesh. Ini termasuk X, Y, dan Z koordinat untuk setiap vertex. (Untungnya, tidak mengandung tingkat lain subchunks.) Simpul disimpan dalam struktur mesh dalam

m_vVertices vektor array. Setiap vektor hanya tiga floating-point nilai, dibungkus dalam suatu struktur untuk kejelasan. Berikut adalah struktur, sangat sederhana S3dsVertex cukup membosankan. Anda mungkin memperhatikan bahwa kelas berisi tiga titik di sini mengapung, bukan CVector3 kelas seperti simpul MS3D lakukan. Saya memilih untuk melakukan hal ini karena suatu alasan. Karena simpul tidak perlu diubah seperti yang dari MS3D, tidak ada gunanya membebani program anda dengan file tambahan. Dalam hal ini, array sederhana dari tiga mengapung akan melakukannya dengan baik.

/------------------------------------------------

//- S3dsVertex

//- Vertex structure for 3ds models

struct S3dsVertex

{

float m_fVert[3];

};

Dua byte pertama dalam sepotong 0x4110 menentukan jumlah simpul di mesh. Segera setelah kedua byte banyak set floating-point tiga kali lipat-posisi X, Y, dan Z untuk setiap vertex, yang dibaca dan disimpan sebagai struktur S3dsVertex.

Sekarang, jika Anda ingin untuk memeriksa kemajuan Anda, Anda dapat menggunakan rendering fungsi (C3ds:: Render ()) untuk membuat semua simpul sebagai titik. untuk melakukan ini, Anda harus loop melalui jala-jala satu per satu, dan untuk setiap mesh, menggambar setiap sudut sebagai titik dalam ruang.

Wajah 0x4120

Potongan lain yang sangat penting adalah sepotong 0x4120, atau wajah sepotong. Potongan ini berisi indeks titik untuk semua segitiga dalam jala saat ini; sangat penting jika Anda ingin model yang solid. wajah-wajah disimpan dalam struktur mesh saat ini juga. Struktur S3dsFace merupakan struktur cukup sederhana:

//------------------------------------------------

//- S3dsFace

//- Face of a 3ds model

struct S3dsFace

{

unsigned short m_usIndices[3]; //Vertex indices

CVector3 m_vecNormal; //Face Normal

};

Sekarang, Anda harus mendapatkan komponen-komponen wajah keluar dari file dan ke memori. Seperti simpul, dua byte pertama dari sepotong 0x4120 yang didedikasikan untuk memegang jumlah wajah untuk mesh (dalam hal ini,tiga). Setelah itu, ada indeks titik. Ada tiga indeks untuk setiap segitiga, satu untuk setiap sudut. Itu berarti ada tiga kali jumlah indeks wajah. Bagian m_vecNormal dari struktur wajah tidak disimpan dalam file; itu harus dihitung. Hal ini dilakukan dengan menggunakan CalcFaceNormal fungsi didefinisikan dalam model.h. Perhitungan ini akan memberikan Anda vektor satuan tegak lurus terhadap bidang segitiga terletak masuk Nilai ini diperlukan untuk penerangan dan bahan saat rendering. Fungsi CalcFaceNormal menghasilkan normal wajah menggunakan poin segitiga. Pertama, dua vektor yang dibuat dari titik menggunakan titik awal titik pertama dan titik akhir sebagai titik kedua untuk vektor pertama, dan titik ketiga untuk vektor kedua. Salib produk dari vektor-vektor ini kemudian dihitung. Vektor yang dihasilkan tegak lurus segitiga, persis seperti vektor normal. hanya

hal yang tersisa untuk dilakukan adalah menormalkan vektor yang dihasilkan sehingga dapat dikirim ke render API. Normals ini hanya wajah per. Untuk melakukan shading halus Anda akan perlu per-vertex normals. Sebuah titik yang normal dapat dihitung untuk tertentu simpul dengan rata-rata normals menghadapi semua wajah saham bahwa

simpul tertentu. Anda sekarang dapat membuat model sebagai benda padat hanya menggunakan simpul indeks. Anda bahkan dapat mengirim vektor normal Anda dihitung untuk setiap segitiga dan cahaya model juga.

Info Bahan Wajah 0x4130

Namun tingkat lain sub-potongan. Informasi Bahan wajah adalah suatu subchunk

dari sepotong wajah (0x4120). Satu hal baik tentang jala-jala di file 3ds adalah bahwa Anda tidak hanya dapat menempatkan bahan yang berbeda pada yang berbeda jerat seperti Anda bisa ketika menggunakan format 3D Milkshape, namun anda bahkan dapat menempatkan bahan yang berbeda pada bagian yang berbeda yang sama

mesh. Sebagai contoh, sebuah kapal ruang angkasa terbuat dari mesh tunggal mungkin perlu tekstur yang berbeda di atas kapal daripada di bagian bawah. Itu apa potongan 0x4130 adalah semua tentang. Para S3dsObjMat menyimpan informasi yang mendefinisikan muka yang akan ditutupi dengan yang bahan. Potongan 0x4130 hanya berisi indeks ke dalam array materi, itu tidak menyimpan informasi material.

Sekali lagi, ada vektor dari struktur dalam struktur mesh karena fakta bahwa mungkin ada lebih dari satu dari mereka. para S3dsObjMesh struktur berisi indeks ke dalam array bahan (yang Anda akan mendapatkan dalam menit), serta daftar indeks wajah yang menggunakan bahan ini.

//------------------------------------------------

//- S3ds Objmat

//- Structure that holds which faces go to a material

struct S3dsObjMat

{

unsigned short m_usMatIdx;

vector<unsigned short> m_vFaceIndices;

};

Data dalam potongan 0x4130 adalah dalam urutan sebagai berikut:
1. Pertama, Anda melihat string diakhiri dengan null yang berisi nama bahan untuk digunakan. Anda dapat membandingkan string dengan nama bahan diambil dari potongan bahan (0xAFFF, didefinisikan berikutnya). Ketika pertandingan string, Anda dapat mengatur m_uiMatIdx yang variabel ke indeks dari materi itu. Ini akan menghemat banyak waktu selama rendering karena Anda tidak perlu mencari materi yang tepat.
2. Sekarang-akrab dua-byte integer yang memberitahu Anda jumlah wajah yang menggunakan bahan ini di samping.
3. Jumlah dua-byte bilangan bulat, masing-masing mewakili wajah, yang lalu. Setiap nomor indeks ke dalam array wajah. Sebuah "0" sesuai dengan wajah 0, dengan wajah 1 "1", dan seterusnya. Sekarang, saat rendering model,
Anda harus terlebih dahulu mengatur materi sifat-sifat material pertama,
membuat semua wajah yang menggunakan materi, beralih ke yang berikutnya
materi, dan ulangi rendering proses sampai semua wajah diambil.

Tekstur koordinat Chunck 0x4140

Bagian penting terakhir dari mesh dan potongan 0x4000 adalah 0x4140 sub-sepotong. Ini potongan sub-memegang pemetaan u dan v koordinat tekstur untuk setiap vertex mesh. Posisi ini nilai-nilai tekstur pada segitiga. Mereka umumnya berkisar 0,0-1,0, tetapi dapat pergi lebih tinggi jika tekstur yang akan diulang atau keramik pada segitiga. Dua byte pertama dari data memberikan Anda jumlah simpul. Ada kemudian dua floatingpoint

nilai untuk setiap vertex. Ini disimpan dalam struktur S3dsTexCoord, yang mirip dengan struktur S3dsVertex, tetapi berisi hanya dua mengapung

bukan tiga.

Di sana, semua geometri sekarang dimuat. Sebuah lega bukan? Tunggu, yang

hanya setengah pertempuran. Anda masih perlu untuk memuat semua bahan dan tekstur

informasi sehingga Anda dapat membuat model Anda terlihat jauh lebih menarik

dari gambar, putih datar yang diarsir.

Bahan 0xAFFF

Untuk membuat model Anda lebih menarik dan memberikan warna, highlight, dan tekstur, Anda harus memuat dalam sepotong bahan. Bahan potongan menyimpan informasi tentang ambien,, menyebar dan warna specular, serta tekstur informasi dan shininess. Wajah jala potongan yang berisi indeks ke dalam array dari bahan yang menentukan bahan apa yang digunakan untuk wajah model. Potongan bahan lain konglomerat potongan, seperti potongan jala 0x4000. bahkan meskipun memiliki banyak sub-potongan, aku janji itu tidak seburuk sepotong mesh. Mari kita melihat struktur materi segera:

//------------------------------------------------

//- S3dsMaterial

//- Material structure

struct S3dsMaterial

{

char m_cName[256]; //Name of material

float m_fAmbient[4]; //Ambient color

float m_fDiffuse[4]; //Diffuse color

float m_fSpecular[4]; //Specular color

float m_fShininess; //Matl shininess

CImage m_Texture; //Texturemap

};

Jika Anda melihat di kelas C3ds, ada vektor struktur S3dsMaterial, dengan cara yang sama ada vektor dari jerat. Ini berarti ada bisa lebih dari satu materi dalam file 3ds, sehingga sekali lagi, seperti dengan jerat, akan pastikan untuk melacak material Anda berada. Potongan bahan 0xAFFF tidak mengandung data apapun sendiri, hanya

sub-potongan, yang didefinisikan dalam bagian berikut.

Nama Bahan 0xA000

Potongan 0xA000 berisi nama material. Ini hanya nullterminated string, sama seperti nama mesh. Hal ini dapat disalin ke dalam m_cName variabel dari bahan saat ini. Sekali lagi, berhati-hatilah bahwa anda nama materi tidak melebihi 256 karakter. Jika tidak, anda harus memotong itu dari sebelum Anda menyimpannya atau Anda akan menimpa array dan risiko menabrak program anda.

Warna Ambient 0xA010

Potongan ini berisi warna ambien dari bahan saat ini. Sebuah subchunk 0x0011 mengandung warna dalam bentuk RGB, dengan satu byte untuk setiap nilai warna, untuk total tiga byte. Sebelum disimpan dalam Array m_fAmbient, setiap elemen warna RGB harus dikonversi ke floating-point nilai antara 0,0 dan 1,0 sehingga mereka dapat dikirim

langsung ke API render. Hal ini dapat dengan mudah dilakukan dengan menggunakan rumus (255 - R) / 255, dimana R adalah nilai untuk merah, hijau, atau biru

komponen warna. Nilai keempat adalah selalu diatur untuk 1.0f dalam hal ini

kasus, karena nilai tidak ditentukan sebaliknya. Nilai keempat adalah termasuk dalam array sehingga dapat dikirim langsung ke penyaji, seperti OpenGL. Pseudo kode berikut membaca warna ambien, serta specular dan menyebar warna.

//pseudocode to read colors for materials

read in three bytes of information, one for each red, green, and blue

convert each value to a floating point value between 0 and 1

store the new values in the first three appropriate array (m_fAmbient

for ambient color)

set the fourth value of the array to 1.0 so that the whole array can

be sent to the rendering API

Diffuse 0xA020 dan specular 0xA030 Warna

Warna difus dan specular bekerja dengan cara yang sama seperti ambien warna, kecuali mereka disimpan dalam variabel mereka sendiri. Keduanya memiliki sama jenis potongan warna dan nilai-nilai.

Shininess 0xA040 dan Transparansi 0xA050

Sebuah persentase sub-potongan memberikan kedua nilai. Potongan sub-0x0030 berisi sebuah integer dua-byte tunggal yang berkisar dari 0 sampai 100 (persentase). Membaginya dengan 100 mengembalikan nilai floating-point untuk antara 0 dan 1. Persentase shininess (0 persen menjadi kusam, 100 persen menjadi sebagai mengkilap mungkin) masuk ke dalam variabel m_fShininess; transparansi adalah nilai keempat dalam array m_fDiffuse.

//pseudo code to read shininess and transparency

Read shininess chunk

Convert shininess to a value between 0 and 1 by dividing by 100

Set shininess parameter equal this value

Read the transparency value

Convert shininess into a value from 0 to 1 in the same way as transparency

Set the fourth value in the diffuse color array equal to the resulting value

Peta Tekstur 0xA200 dan 0xA300

Potongan yang terakhir dan mungkin paling penting dari bahan ini adalah tekstur. Tekstur adalah "kulit" yang meliputi model dan berisi terlalu sulit untuk menciptakan hanya dengan segitiga dan warna detail. Hal ini memberikan model tampilan yang pasti, meningkatkan kepercayaan dan realisme. Struktur peta tekstur dimulai dengan sepotong jenis 0xA200. Ini 0xA200 atau tekstur potongan peta mengandung sub-potongan juga, meskipun hanya sub-potongan yang Anda butuhkan adalah 0xA300. Ini berisi null diakhiri string yang menentukan nama file tekstur itu. String ini dapat diberi makan

langsung ke fungsi beban dari kelas CImage terkandung dalam materi struktur. Jika Anda tidak menggunakan kelas CImage termasuk dalam basecode, Anda dapat mengekstrak string ini dengan strcpy dan menyimpannya dalam buffer sementara untuk lulus untuk Anda sendiri gambar-loading fungsi.

//Reading and loading the texture filename

Set a pointer (char *) equal to the start of the data in the 0xA300

chunk.

Pass this pointer to the CImage::Load() function.

Wah, sekarang Anda memiliki semua data yang statis Anda harus setidaknya render

model dengan cahaya dan tekstur.

Rendering File 3ds Anda

Mari kita lihat bagaimana untuk menarik semua data yang Anda telah dimuat bersama-sama dan memasukkannya ke layar. Anda harus berurusan dengan banyak masalah sementara render. Beberapa jerat memiliki informasi material yang disimpan di dalamnya; beberapa jerat tidak memiliki bahan sama sekali. Beberapa jerat tidak mungkin berisi setiap segitiga, karena fakta mereka dibuat untuk kamera dan lampu. Anda harus mempertimbangkan dan menangani semua keadaan ini. Cara terbaik untuk memvisualisasikan bagaimana file-file yang diberikan adalah untuk melihat flow chart. Aliran render ditunjukkan pada Gambar 7.3. Lihatlah itu sebelum Anda membaca.

 

                                                No

 

Rende all face

END

Render Approite Faces

Bind Texture

Setup materials

Is there material info?

                         Yes

                                                No

                          Yes

More materials?

Yes                    No

Fungsi render anda harus berisi sebuah loop yang loop melalui masing-masing

dari jerat dan menarik mereka jika diperlukan.Hal pertama yang Anda harus menentukan adalah apakah mesh saat ini berisi informasi wajah. Hal ini dapat dilakukan dengan memeriksa ukuran dari array wajah. Jika itu adalah 0, hanya melewatkan mesh sama sekali dan melanjutkan. Jika tidak mengandung segitiga, itu bukan segitiga mesh-yang valid. Anda berikutnya harus menentukan bagaimana bagian-bagian yang berbeda dari model yang diberikan. Jika ada informasi dalam variabel m_vObjMat, mesh

berisi informasi material dan itu harus diatur terlebih dahulu. Jika cabang ini

diambil, loop baru harus dibentuk untuk loop melalui semua ObjMat yang benda sehingga bahan yang tepat diterapkan pada wajah yang tepat. Kemudian, dengan menggunakan indeks materi, Anda harus mengatur sifat material. Pastikan untuk mengaktifkan pencampuran, pencahayaan, dan tekstur mengikat sebagai baik. Jika Anda menggunakan OpenGL, bahan-bahan yang ditentukan dengan menggunakan glMaterialf fungsi, dan pencampuran diaktifkan menggunakan glEnable fungsi dengan parameter GL_BLEND. Pastikan untuk mengatur pencampuran anda fungsi menggunakan kode ini:

glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

Sedangkan untuk tekstur, Anda dapat menggunakan CImage:: Bind () fungsi jika Anda menggunakan kelas CImage, atau glBindTexture jika Anda menggunakan lain imageloading rutin. Kemudian, anda dapat membuat wajah-wajah yang ditentukan oleh bahan saat ini informasi. Jika tidak ada bahan untuk objek tertentu, Anda sekarang dapat membuat wajah-wajah. Karena meninggalkan diaktifkan pencampuran dapat menyebabkan terdefinisi hasil, yang terbaik adalah untuk menonaktifkan ketika Anda mengambil rute ini. Anda juga harus menonaktifkan texturing juga. Dalam C3ds:: fungsi Render, saya menggunakan modus langsung untuk mengirim verteks, koordinat tekstur, dan informasi normal untuk OpenGL. Ada lebih baik cara untuk melakukan ini, misalnya menggunakan array vertex. Saya memutuskan untuk tinggalkan cara ini untuk membuatnya lebih mudah untuk mengerti, terutama jika anda tidak tahu OpenGL dengan baik.

Kesimpulan

Bab ini harus berisi banyak informasi untuk membuat Anda pergi. Anda sekarang dapat memuat dan membuat model 3ds, lengkap dengan tekstur dan bahan. Anda juga telah diperkenalkan ke format yang menggunakan sistem potongan independen untuk membuat file. Sekarang Anda harus dapat melihat format 3ds penuh, yang dapat diperoleh dari situs seperti http://www.wotsit.org, dan dapat memuat dan memanfaatkan salah satu tambahan potongan yang disimpan dalam file yang tidak dibahas di sini. 3ds Format toko satu ton informasi dan memegang kemungkinan tak terbatas. Berikutnya bab menunjukkan Anda bagaimana untuk membuat loader untuk format MDL Half-Life

menggunakan basecode dirilis oleh Valve Software. Bab yang menggunakan yang sudah ada basecode daripada menciptakan seluruh loader dari awal karena kompleksitas format. Baca terus untuk mengetahui bagaimana beban ini populer, Format kuat.

        LAMPIRAN B

        STL Vektor

        cat dasar

Seperti yang Anda telah membaca melalui buku ini, Anda tidak ragu mendengar banyak tentang membangun matematika yang dikenal sebagai vektor. Nah, di sini Anda akan diperkenalkan dengan jenis lain dari vektor, yang penyimpanan data vektor. Standard Template Library (STL) adalah kumpulan dari wadah kelas, iterator kelas, dan kelas utilitas dan fungsi lainnya. Sebuah kontainer hanya itu, berisi data dari tipe yang ditentukan pengguna. yang bagus hal tentang kontainer STL adalah bahwa mereka membersihkan diri mereka sendiri, yang berarti bahwa mereka mengalokasikan memori apapun, mereka juga bebas. Namun, hal ini tidak termasuk memori yang Anda dialokasikan. Iterator adalah jenis kelas yang menunjuk ke data yang terdapat dalam kelas kontainer. Iterator memiliki kemampuan untuk bergerak melalui elemen-elemen dalam wadah, memberikan Anda akses ke elemen-elemen yang menunjuk ke iterator .

STL Vektor

Vektor STL kelas (mulai sekarang hanya disebut vektor) adalah wadah objek yang menyimpan unsur-unsur dalam susunan linear, memungkinkan untuk cepat sisipan dan penghapusan pada akhir vektor, dan insersi lebih lambat dan penghapusan di tengah atau di awal. Bila menggunakan fungsi vektor <>:: akhir, nilai kembali akan menjadi elemen setelah elemen terakhir dalam vektor. Anda akan menemukan bahwa "masa lalu akhir "tema yang diulang seluruh STL.

Dasar-dasar Menggunakan Vektor

Hal pertama yang perlu Anda lakukan untuk menggunakan vektor adalah untuk menyertakan header file yang terkandung dalam:

# include <vector>

Anda akan melihat bahwa tidak ada perpanjangan jam di atasnya., Yang tidak salah ketik.

Header STL di semua implementasi yang saya digunakan tidak memiliki ekstensi. Hal berikutnya yang perlu Anda lakukan adalah untuk menyatakan suatu vektor, dalam hal ini, Anda menyatakan vektor bilangan bulat: std:: vector <int> vec; / / Mendeklarasikan sebuah vektor yang akan berisi bilangan bulat. Jadi apa dengan std ini:: hal? Nah, std adalah namespace, yang saya tidak akan masuk ke banyak, selain mengatakan bahwa untuk program C + +, semua yang anda perlu dilakukan untuk menghindari menggunakan std ini:: adalah menambahkan baris ini setelah meliputi: menggunakan namespace std; Namun, dalam program C + + di mana Anda memiliki beberapa file, termasuk header dan seperti itu, umumnya merupakan ide yang baik untuk hanya menempel dengan menggunakan std:: ekstensi untuk mencegah termasuk ruang nama tidak sengaja. Baiklah, sejauh ini Anda telah disertakan dan dinyatakan sebagai vektor yang akan mengandung bilangan bulat. Sekarang Anda akan memasukkan beberapa data ke dalamnya. Memasukkan data pada akhir vektor adalah mudah, Anda hanya menggunakan fungsi push_back. Para kode berikut akan menyisipkan angka 0-9 pada akhir vektor:

for (int i = 0; i <10; i + +)

vec.push_back (i); / / Sisipan saya ke ujung vektor

Untuk menghapus data dari ujung vektor, Anda hanya menggunakan pop_back yang

fungsi. Fungsi pop_back tidak membutuhkan argumen, dan mengembalikan void.

Jadi, jika Anda ingin menghapus bahwa sembilan terakhir dari vektor, Anda akan

lakukan hal berikut:

vec.pop_back (); / / Menghapus 9 dari ujung vektor

Sekarang bahwa Anda memiliki beberapa data yang disimpan dalam vektor Anda, Anda perlu belajar bagaimana untuk mengakses data. Untuk melakukannya, Anda menggunakan hal kecil disebut iterator. Sebuah iterator pada bentuk yang paling dasar adalah sebuah kelas yang memberi anda akses ke data yang disimpan dalam sebuah wadah pada elemen-elemen dengan dasar. Anda dapat menggunakan iterator untuk memasukkan, menghapus, mencari, dan menyortir data yang tersimpan dalam kata kontainer. Jadi mari kita buat sebuah iterator dalam rangka untuk berjalan melalui data Anda dan mencetak:

std::vector<int>::iterator l, endi;

endi = vec.end(); // Returns the element "Past the end" of the

// last element

for(l = vec.begin(); // Returns the first element in the vector

l != endi; // Checks to make sure that we are not at the end

++l) // Moves l to the next element, using ++l instead of l++ is

// faster because you don't create a copy

{

cout<<"Vector vec contains [ "

<<*l // the * operator returns a reference to the element l points to

<<endl;

}

Tidak sulit, ya? Untuk menyisipkan data ke dalam vektor pada titik tertentu, anda harus menggunakan vektor <>:: insert () fungsi. Sebuah peringatan, meskipun: Jika anda menemukan bahwa anda melakukan banyak sisipan dan penghapusan mana saja kecuali pada akhir vektor, disarankan bahwa Anda melihat ke salah satu kelas wadah lain sebagai gantinya. Dikirim pada titik-titik lain selain akhir vektor lebih mahal daripada di akhir. Untuk menyisipkan, katakanlah, awal dari sebuah vektor, anda harus terlebih dahulu mendapatkan sebuah iterator yang menunjuk ke awal, dan kemudian anda hanya memanggil fungsi insert dengan iterator, serta data yang ingin anda masukkan.

std::vector<int>::iterator l = vec.end();

while(l != vec.begin())

{

--l;

vec.insert(vec.begin(), *l) // Insert at the beginning

// the element contained in l

}

Ada dua cara untuk menghapus data dari sebuah vektor pada titik-titik lain selain akhir. Salah satu adalah dengan menggunakan vektor <>:: menghapus fungsi dan yang lain adalah untuk menggunakan fungsi menghapus. Perbedaan antara mereka adalah menghapus yang akan menghapus dan mengubah ukuran vektor, sedangkan menghapus akan mempertahankan relatif penempatan elemen, tetapi akan menghapus elemen yang ditentukan.

// Using remove:

std::vector<int>::iterator newend;

// Searches the vector for all 7's and removes them

newend = std::remove ( vec.begin( ), vec.end( ), 7 );

cout << "Vector vec with value 7 removed is [ " ;

for ( l = vec.begin( ) ; l != vec.end( ) ; l++ )

cout << *l << " ";

cout << "]." << endl;

// To change the sequence size, use erase

vec.erase (newend, vec.end( ) );

cout << "Vector vec resized with value 7 removed is [ " ;

for ( l = vec.begin( ) ; Iter1 != l.end( ) ; l++ )

cout << *l << " ";

cout << "]." << endl;

Bagian berikutnya dari kode menghapus semua kejadian dari 7 dan mengubah ukuran

vektor.

// Using just erase:

vec.erase(vec.begin(), vec.end(), 7);

Set lengkap dari fungsi menghapus termasuk remove_if, remove_copy, dan remove_copy_if. Para remove_copy dan remove_copy_if fungsi menciptakan berbagai nilai baru, hanya menyalin nilai-nilai yang bukan bagian dari nilai yang ditentukan. Para remove_copy_if dan remove_if fungsi mengambil argumen fungsi yang disebut predikat biner, yang fungsi benar-salah yang akan mengembalikan true untuk elemen-elemen yang cocok predikat, dan salah untuk semua orang lain. Fungsi-fungsi ini kemudian menghapus semua elemen yang memenuhi predikat biner.

bool gt6( int val )

{

return (val > 6); //returns true if greater than 6

}

.

.

.

std::vector<int> v2;

newend = std::remove_copy_if ( vec.begin( ), vec.end( ),

v2.begin( ), gt6 ); // copies to a new vector containing all values

// less than or equal 6

Penyortiran

Pada titik tertentu, anda mungkin akan ingin menyortir vektor anda sehingga anda dapat

hal-hal yang keren seperti menggunakan pencarian biner untuk menemukan elemen. Penyortiran vektor adalah proses yang cukup sederhana, Anda hanya menggunakan fungsi semacam. Mengurutkan fungsi yang disertakan menggunakan header algoritma.

#include <algorithm>

.

.

.

// The following code will sort your vector of ints in ascending order

std::sort(vec.begin(), vec.end());

Algoritma semacam juga dapat mengambil argumen fungsi yang akan digunakan untuk menentukan apakah item harus dipindahkan. STL memiliki beberapa fungsi-fungsi ini sudah, Anda hanya perlu untuk memasukkan <functional> yang header.

#include <functional>

#include <algorithm>

.

.

.

//sorts using the greater function object ( descending order )

std::sort(vec.begin(), vec.end(), greater<int>());

Para <int> besar () bagian sebenarnya adalah obyek fungsi, yang pada dasarnya

kelebihan beban operator () yang terkandung dalam struktur atau kelas.

Pencarian

Ada beberapa metode untuk mencari vektor, namun, bagian ini hanya mencakup penggunaan menemukan fungsi serta pencarian biner fungsi. Menemukan fungsi bekerja pada kedua disortir dan dipilah vektor. Mereka bekerja dengan membandingkan setiap elemen dengan nilai yang dicari. Fungsi pencarian biner memerlukan vektor diurutkan, namun mereka mengambil waktu kurang signifikan untuk menemukan elemen.

Fungsi menemukan memiliki empat versi. Mereka menemukan, find_end, find_first_of, dan find_if. Fungsi menemukan menemukan kejadian pertama dari suatu elemen. Fungsi find_if menemukan kejadian pertama dari sebuah elemen yang memenuhi kondisi tertentu. Dua lainnya fungsi, find_end dan find_first_of, tidak dibahas di sini.

Untuk menggunakan menemukan, cukup menyebutnya dengan jangkauan yang ingin anda cari dan elemen yang ingin Anda temukan. Jadi, untuk menemukan nomor dalam vektor bilangan bulat, anda akan melakukan hal berikut:

#include <algorithm>

.

.

.

// Starts at the beginning of the vector, and proceeds to the end

// Till it finds a 7, or returns the element past the end if it doesn't

std::vector<int>::iterator i;

i = find(vec.begin(), vec.end(), 7);

if(i != vec.end()) // We found it

.

.

.

To use the find_if function, you simply do the following:

#include <algorithm>

.

.

.

bool IsGreaterThan5( int val )

{

return (val > 5);

}

.

.

.

std::vector<int>::iterator i;

//Will find the first element that is greater than five

i = find_if(vec.begin(), vec.end(), IsGreaterThan5);

if(i != vec.end()) // if we found it

.

. // Do stuff

.

Fungsi pencarian biner memerlukan vektor diurutkan, namun dapat mengambil secara signifikan lebih sedikit waktu untuk menemukan elemen yang anda cari. Para fungsi pencarian biner yang binary_search, lower_bound, upper_bound, dan equal_range. Fungsi binary_search mengembalikan nilai true jika eleme mencari ada. Fungsi lower_bound menemukan kejadian pertama sebuah elemen dalam vektor, atau posisi itu akan berada di jika ada. Fungsi upper_bound menemukan elemen masa lalu kejadian terakhir elemen dalam vektor mencari, atau di mana ia akan jika elemen mencari ada. Fungsi equal_range hanya kombinasi dari fungsi lower_bound dan upper_bound.

Untuk menggunakan fungsi pencarian biner, anda hanya lulus kisaran

diurutkan elemen yang anda ingin mencari dan elemen yang ingin anda temukan.

#include <algorithm>

.

.

.

std::vector<int> vec;

for(int j = 0; j < 10; j++)

{

vec.push_back(j); // Insert 2 copies of the number at the end.

vec.push_back(j);

}

sort(vec.begin(), vec.end()); // Sort the vector

bool found = binary_search(vec.begin(), vec.end(), 7); //Is there a 7?

assert(found == true); //should be

std::vector<int>::iterator k, l;

k = lower_bound(vec.begin(), vec.end(), 5); // Find the first five

l = upper_bound(vec.begin(), vec.end(), 5); // Find the item past the five

assert(*k == 5); // should be the first five

assert(*l == 6); // Should equal the element after the last five

Menggunakan Objek Sendiri

Sejauh ini, anda baru saja menggunakan vektor yang mengandung bilangan bulat. Meskipun integer yang bagus dan keren, anda mungkin akan ingin anda gunakan sendiri

tipe user-defined dengan vektor. Bagian ini mencakup beberapa isu tentang menggunakan benda anda sendiri dengan vektor. Hal pertama yang perlu anda lakukan sebelum anda dapat menyimpan obyek dalam vektor adalah mendefinisikan objek. Sebuah objek yang akan disimpan dalam vektor harus mencakup copy constructor, karena konstruktor salinan digunakan ketika benda bergerak di sekitar. Tugas overload Operator juga dapat membantu.

class MyObject {

int age

int height; //in CM

public:

MyObject() {}

MyObject( int a, int h) : age(a), height(h) {}

// Copy Constructor

MyObject(const MyObject& a) : age(a.age), height(a.height) {}

void SetAge(int a) { age = a; }

void SetHeight(int a) { height = a; }

int GetAge() { return age; }

int GetHeight() { return height; }

//Overloaded assignment operator

MyObject& operator=(const MyObject& r) {

age = r.age; height = r.height; return *this; }

};

Ada objek dasar. Untuk memberitahu vektor untuk menggunakannya, anda cukup mengganti

bagian int vektor dengan MyObject:

std::vector<MyObject> vec; //vector to hold MyObject types

Sekarang sampai pada bagian-menyimpan rumit di dalam MyObject vektor.

Untuk melakukannya, Anda menelepon push_back dengan MyObject suatu, seperti:

.

.

.

// Stick 10 random MyObject's into the vector

for(int j = 0; j < 10; j++)

{

vec.push_back(MyObject(rand()%20+1, rand()%120 + 1));

}

Untuk mengurutkan objek, anda harus baik overload operator <atau pasokan semacam fungsi dengan fungsi lain. anda akan melihat dalam contoh kode bahwa anda melewati semuanya dengan referensi. Hal ini untuk menghindari copy dan dengan demikian

menghemat memori dan waktu. Contoh ini macam vektor berdasarkan umur:

#include <algorithm>

.

.

.

bool LesserAge( MyObject& l, MyObject &r)

{

return (l.GetAge() < r.GetAge());

}

//or:

bool operator<( MyObject& l, MyObject &r)

{

return (l.GetAge() < r.GetAge());

}

.

.

.

sort(vec.begin(), vec.end(), LesserAge); // Sorts by age

sort(vec.begin(), vec.end()); // Sorts by age using <

Karena fungsi menemukan menggunakan operator ==, anda harus overload untuk

bekerja dengan kelas anda. Ini adalah operasi sederhana:

#include <algorithm>

.

.

.

bool operator==(MyObject l, MyObject r)

{

if(l.GetAge() != r.GetAge())

return false;

if(l.GetHeight() != r.GetHeight())

return false;

return true;

}

.

.

.

std::vector<MyObject>::iterator j;

j = std::find(vec.begin(), vec.end(), MyObject(10, 120));

if(j != vec.end()) //We found it

.

.

.

Operator kesetaraan (== Operator) digunakan dalam perbandingan untuk menentukan apakah salah satu elemen sama lain. Namun, itu hanya akan bekerja

pada C + + didefinisikan jenis. Untuk menyiasati keterbatasan ini, anda dapat membebani

untuk menerima jenis lainnya. Dalam hal ini, kelebihan beban untuk menerima MyObject jenis dan membandingkan mereka berdasarkan usia dan tinggi badan. Namun, anda bisa dengan mudah membandingkan berdasarkan usia saja, sehingga memungkinkan untuk

tingkat kesetaraan.

Pointer

Salah satu kelemahan menyimpan suatu objek dalam vektor adalah bahwa kapan itu akan pindah, ia harus menyalin seluruh objek untuk baru lokasi. Untuk vektor kecil, ini mungkin mungkin, tapi ketika anda mulai mendapatkan vektor yang lebih besar, menjadi tidak dapat diterima. Cara untuk menghindari ini adalah dengan menggunakan pointer. Pointer adalah sedikit lebih kecil dari objek yang paling, sehingga memindahkan mereka sekitar membutuhkan waktu jauh lebih sedikit. Namun, karena pointer menggunakan memori anda telah dialokasikan, anda juga harus ingat untuk gratis yang memori ketika anda selesai. Mendeklarasikan sebuah vektor untuk menyimpan pointer ke objek ini cukup sederhana, anda hanya mengganti bagian MyObject dengan konversi yang sesuai:

std:: vector <MyObject*> vec;

Untuk meletakkan sesuatu ke vektor, semua anda benar-benar harus lakukan, dari

kode terakhir, adalah menambahkan operator baru:

.

.

.

// Stick 10 random MyObject's into the vector

for(int j = 0; j < 10; j++)

{

vec.push_back( new MyObject(rand()%20+1, rand()%120 + 1));

}

Sortasi vektor adalah sedikit berbeda, karena operator akan menggunakan semacam biner predikat yang anda tentukan atau operator <secara default. Karena pointer hanya integer, operator <akan mengurutkan oleh memori alamat dan bukan isi dari MyObject.

#include <algorithm>

.

.

.

bool operator==(MyObject *l, MyObject r)

{

if(l->GetAge() != r.GetAge())

return false;

if(l->GetHeight() != r.GetHeight())

return false;

return true;

}

.

.

.

std::vector<MyObject>::iterator j;

j = std::find(vec.begin(), vec.end(), MyObject(10, 120));

if(j != vec.end()) //We found it

.

.

.

Sekali lagi, anda overloading operator kesetaraan (==) seperti yang anda lakukan sebelumnya. Namun, kali ini, dapat membandingkan pointer ke MyObject suatu

objek dan membandingkan objek MyObject untuk dirinya sendiri. Setelah Anda selesai dengan vektor anda dari pointer, anda harus membebaskan memori yang dialokasikan anda. Ini adalah proses yang cukup sederhana:

#include<algorithm>

.

.

.

template<typename T>

class DeletePtr

{

public:

void operator()(T *elem)

{

delete elem;

}

};

.

.

.

std::for_each(vec.begin(), vec.end(), DeletePtr<MyObject>());

DeletePtr kelas dengan operator fungsi anggota () disebut fungsi objek. Semua hal ini adalah pointer menghapus MyObject. Jika anda ingin, anda bisa membuatnya menghapus pointer bulat dengan hanya mengubah baris ini:

for_each(vec.begin(), vec.end(), DeletePtr<MyObject>());

to:

for_each(vec.begin(), vec.end(), DeletePtr<int>());

Sederhana dan mudah (dan berguna juga).

Kesimpulan

Jika anda bertanya-tanya tentang beberapa aplikasi vektor dalam game, aku punya ide. Ide saya adalah untuk adegan-grafik sederhana. Jika anda memperoleh semua benda anda dari beberapa objek dasar, anda bisa menggunakan vektor dari pointer ke objek dasar. Ini akan memungkinkan anda untuk dengan mudah melakukan update, tabrakan, dan rendering. Karena anda akan tahu bahwa semua objek sebelum objek saat ini sudah pindah dan telah tabrakan diuji, anda tidak perlu uji terhadap mereka untuk anda saat ini

objek. Juga, anda bisa menggunakan kembali elemen vektor, seperti ketika makhluk mati, sehingga anda mengatur elemen vektor ke obyek kosong, dan ketika anda membutuhkan objek baru, hanya menggunakan kembali yang kosong. Akhirnya, saya akan merekomendasikan bahwa anda melakukan penelitian lebih lanjut ke Template pemrograman, terutama yang berkaitan dengan Standard Template Perpustakaan. Ini memiliki banyak jenis kontainer, termasuk deques, daftar, set, multisets, dan peta. Setiap kontainer memiliki kelebihan dan kekurangan, sehingga memilih orang yang tepat tidak selalu mudah. Ada biasanya satu wadah yang akan lebih cocok untuk sebuah aplikasi tertentu daripada yang lain.