Semua efek partikel dapat dilakukan melalui PSE, dan dimasukkan dalam model. Saat ini, kontrol yang tersedia hanya untuk menghidupkan dan mematikan emitor. Mengendalikan partikel, memungkinkan pengguna untuk merasa lebih tenggelam dalam permainan atau simulasi. Seperti kecepatan angin, suhu, bahkan kehadiran suara bisa memicu suatu peristiwa yang menyebabkan partikel tersebut bertindak secara berbeda. Tutorial ini akan membantu anda melakukan itu, seperti mengubah warna, kecepatannya, masa hidup, massa, dan masih banyak lagi.
Untuk demonstrasi, kita akan mengubah partikel kecil yang berada di belakang tank sesuai dengan kecepatan tank. Ini akan membuat debu partikel tinggal di udara lebih lama ketika anda mengemudi dengan cepat, seperti dalam kehidupan nyata! Ini adalah partikel editor yang digunakan untuk menciptakan efek.
Bagaimana mendapatkan data partikel?
Catatan: Kode berikut ini sudah ada di dtCore:: fungsi ParticleSystem SetupLayers. Ini menunjukkan bagaimana mengaksesnya dan memberikan pengertian yang lebih baik dari apa yang kita peroleh. Setelah partikel diinisialisasi, pengguna akan berhadapan dengan setiap lapisan yang terpisah melalui GetSingleLayer ("Layer 0"), pemanggilan fungsi.
Untuk memperoleh data partikel mengharuskan kita untuk bekerja secara langsung dengan kode OpenSceneGraph (OSG). Mungkin lebih mudah mengatakan daripada dilakukan, jadi mari kita lakukan!
Pertama kita akan mendeklarasikan sebuah kelas yang akan memiliki semua informasi tentang partikel, untuk setiap layer dari setiap sistem partikel. Kelas akan mengikuti anggota variabel yang berisi kelas sistem partikel. Kelas ini akan disebut dengan ParticleLayer.
From dtCore::ParticleSystem (h and cpp)
/**
* geode yang memiliki sistem partikel dapat ditarik,
* dan diberi nama layer.
*/
RefPtr mGeode;
/**
* Sistem partikel aktif.
*/
RefPtr mParticleSystem;
/**
* Transformasi yang mengontrol posisi dari emitter.
*/
RefPtr mEmitterTransform;
/**
* Emitter aktif.
*/
RefPtr mModularEmitter;
/**
* Program aktif.
* Dapat membuat modular dan cairan
*/
RefPtr mProgram;
/**
* nama layer
*/
std::string mstrLayerName;
Semua variabel di atas digunakan di fungsi SetupParticleLayers. Mereka masing-masing mempunyai tujuan yang dapat memanipulasi dan mengatur efek partikel. Pengisian kelas ini dari luar tidak sulit, tetapi kode ini tidak diatur dalam bentuk hirarki yang anda inginkan.
Metode berikut ini dipanggil saat anda membuat sistem partikel dengan metode LoadFile, dan tidak perlu dipanggil secara langsung. Setelah LoadFile selesai, Anda dapat menggunakan kelas ParticleLayer untuk mengubah nilai yang berbeda. Anda tidak perlu menulis kode ini, namun disediakan untuk membantu anda memahami isi sistem partikel OSG.
dtCore::ParticleSystem (h and cpp)
/**
* Memanggil fungsi LoadFile(), sebaiknya tidak memanggilnya
* dari user
*/
void ParticleSystem::SetupParticleLayers()
{
osg::Group* newParticleSystemGroup = (osg::Group*)mLoadedFile.get();
osg::Node* searchingNode = NULL;
unsigned int i = 0;
Catatan: kita akan melakukan looping melalui semua children sebanyak dua kali, yang pertama dilakukan untuk setup sistem partikel awal, dan yang kedua untuk mengatur variabel lain, kemudian disatukan. Hal ini dilakukan, sejak kita mendapatkan perintah children yang lain, tapi perlu mengetahui variabel layer sistem partikel yang lain.
for(i=0;igetNumChildren();i++)
{
searchingNode = newParticleSystemGroup->getChild(i);
ParticleLayer layer;
if(dynamic_cast(searchingNode))
{
//Ini terjadi ketika mengimpor beberapa file osg dalam satu sistem.
// Satu untuk setiap file dapat diambil, untuk memberitahu sistem //segala sesuatu yang lain ada di sini.
}
// Jika ini adalah sistem partikel yang geode if(dynamic_cast(searchingNode))
{
// sebuah geometrinya node.
layer.mGeode = (osg::Geode*)searchingNode;
for(unsigned int j=0;jgetNumDrawables();j++)
{
osg::Drawable* drawable = layer.mGeode->getDrawable(j);
// Tampak seperti kami menemukan sistem partikel, lanjutkan! if(dynamic_cast(drawable))
{
layer.mParticleSystem = (osgParticle::ParticleSystem*)drawable;
layer.mstrLayerName = layer.mGeode->getName();
// We're done setting values up, push it onto the list
mlLayers.push_back(layer);
}
}
} // akhir if
}// akhir dari perulangan for
for(i=0;igetNumChildren();i++)
{
searchingNode = newParticleSystemGroup->getChild(i);
if(dynamic_cast(searchingNode))
{
osg::MatrixTransform* newEmitterTransform =
(osg::MatrixTransform*)searchingNode;
for(unsigned int j=0;jgetNumChildren();j++)
{
osg::Node* childNode = newEmitterTransform->getChild(j);
if(dynamic_cast(childNode))
{
osgParticle::ModularEmitter* newModularEmitter =
(osgParticle::ModularEmitter*)childNode;
for(std::list::iterator layerIter = mlLayers.begin();
layerIter != mlLayers.end(); layerIter++)
{
if(layerIter->mParticleSystem == newModularEmitter->getParticleSystem())
{
// mengatur data dalam layer
layerIter->mEmitterTransform = newEmitterTransform;
layerIter->mModularEmitter = newModularEmitter;
}
}
}
} // akhir dari perulangan for
} // akhir dari perintah if
else if(dynamic_cast(searchingNode))
{
osgParticle::ModularProgram* newModularProgram = (osgParticle::ModularProgram*)searchingNode;
for(std::list::iterator layerIter = mlLayers.begin();
layerIter != mlLayers.end(); layerIter++)
{
if(layerIter->mParticleSystem == newModularProgram->getParticleSystem())
{
// mengatur data di layer
layerIter->SetModoluarProgram(true);
layerIter->mProgram = newModularProgram;
break;
}
} // akhir dari perulangan loop
} // akhir dari perintah if
// memeriksa dan melihat apakah ini adalah sebuah program fluida else if(dynamic_cast(searchingNode))
{
osgParticle::FluidProgram* newFluidProgram = (osgParticle::FluidProgram*)searchingNode;
for(std::list::iterator layerIter = mlLayers.begin();
layerIter != mlLayers.end(); layerIter++)
{
if(layerIter->mParticleSystem == newFluidProgram->getParticleSystem())
{
// mengatur data di layer
layerIter->SetFluidProgram(true);
layerIter->mProgram = newFluidProgram;
break;
}
} // akhir dari perulangan for
} // akhir dari perintah if
} // akhir dari perulangan for
}// akhir dari pemanggilan fungsi
Dari sini, kita memiliki semua daftar partikel layer yang dimuat di file OSG. Setiap efek dalam file pada ParticleLayer dengan di std::list berbeda. Untuk mendapatkan layer kembali dan mengubah semua efek yang dimasukkan, sama sederhananya seperti memanggil GetSingleLayer() dan mengirim sebuah string dari nama yang Anda inginkan.
Ini akan mengembalikan sebuah referensi ke ParticleLayer, yang pada gilirannya akan memberikan Anda akses untuk mengubah apa pun yang Anda inginkan dengan efek partikel. Yang kami inginkan adalah default partikel.
Ikhtisar Hierarchal:
Sebagian besar, segala sesuatu dalam kelas berada di bagian bawah Processor Partikel. Ini adalah dasar bagi antarmuka kelas yang melakukan sesuatu pada partikel. Contoh kelas yang untuk emitor contoh (generasi partikel) dan program (animasi partikel). Kela
s ini memiliki beberapa sifat, seperti bingkai referensi dan referensi ke ParticleSystem; partikel harus di proses dengan kelas-kelas turunan dengan mempertimbangkan kerangka acuan, komputasi transformasi yang tepat bila diperlukan.
OpenScene Graph Documentation For the Overview
Sistem Partikel OSG:
sistem partikel osg sebagian besar adalah kelas utilitas. Kelas ini dapat memberitahu Anda untuk membekukan seluruh sistem, mengembalikan jumlah partikel, menentukan apa jenis permukaan, dll. Memanfaatkan sistem yang akan bekerja keras pada sebuah permainan dengan menggunakan frame membekukan / menghentikan animasi, dan Anda dapat membekukan sistem partikel Anda untuk memberikan efek yang baik.
OpenScene Graph Documentation For the particle system
Partikel Default:
Semua Partikel terbuat dari partikel Template.
Artinya, pengaturan yang pertama kali dimuat di file, membuat default Template Partikel. OSG Template Default sama seperti Partikel lain, kecuali digunakan sebagai template untuk membuat partikel baru. Sekarang mari kita lanjutkan.
Untuk mendapatkan akses ke partikel default kita harus melalui Sistem Partikel dan mendapatkannya di sana. Akibatnya ketika Anda selesai, Anda harus menempatkan partikel default kembali ke dalam Sistem Partikel dan semua partikel baru mengambil keuntungan dari perubahan. Karena kita akan kembali. Namun, dalam situasi ini, Anda tidak akan kembali ke dalam sistem.
Berikut ini daftar beberapa anggota yang dapat mengubah partikel Default:
void setLifeTime (double t) mengatur waktu hidup partikel.
void setSizeRange (const rangef &r) mengatur angka minimum dan maksimum ukuran polygon.
void setAlphaRange (const rangef &r) mengatur angka minimum dan maksimum alpha.
void setColorRange (const rangev4 &r) mengatur nilai minimum dan maksimum warna.
void setSizeInterpolator (Interpolator *ri) mengatur interpolator untuk komputasi nilai-nilai ukuran.
void setAlphaInterpolator (Interpolator *ai) mengatur interpolator untuk komputasi nilai alpha.
void setColorInterpolator (Interpolator *ci) mengatur interpolator untuk komputasi nilai-nilai warna
void setRadius (float r) Atur radius fisik partike
l.
void setMass (float m) Mengatur massa partikel.
void setPosition (const osg::Vec3 &p) Mengatur posisi vektor.
void setVelocity (const osg::Vec3 &v) Mengatur vektor kecepatan.
Untuk daftar lengkap sebuah partikel, ikuti link ini:
OpenScene Graph Documentation for a particle class
Setelah Anda selesai mengubah nilai, masukkan kembali ke dalam partikel Template Default, dan semua partikel baru yang dibuat dari template / emitor yang memiliki efek yang diinginkan. Catatan ini tidak akan mengubah partikel saat ini. Biasanya, partikel lama dan baru berbaur bersama-sama secara alami.
Modular Emitter:
modular emitor digunakan untuk menentukan jumlah partikel yang bisa dibuat. Mengubah jumlah partikel ini akan memberikan pengaruh pemijahan partikel kurang ataun lebih. Hal ini akan menjadi besar untuk digunakan pada api dan meredakan dari waktu ke waktu.
Emitor ini memiliki Shooter dan Placer objek di dal
amnya. Placers adalah di mana partikel-partikel tersebut dilakukan dengan menembakan kontrol di mana mereka pergi setelah mereka telah "Ditempatkan".
OpenScene Graph Documentation for a modular emitter
Emitter Transform:
Emitor Transformasi digunakan untuk memindahkan emitor sekitar dan dari posisinya. Cara agar bisa menggunakannya, adalah jika Anda memiliki kapal berlayar menyusuri sungai dan ingin menciptakan efek gelombang yang berbeda dari offset kapal.
OpenScene Graph Documentation for a transform
Mengatur layer:
Ketika kami menangkap variabel melalui GetSingleLayer() semua perubahan akan dibuat tanpa memanggil metode yang ditetapkan. Namun, jika dalam kode, Anda merasa perlu untuk mengatur kembali layer, anda dapat memanggil SetSingleLayer ().
Berinteraksi dengan simulasi tangki:
Melalui program simulasi tangki, kita akan menguba
h jejak asap berdebu yang melekat pada tangki, untuk memberikan kenyataan lebih didasarkan pada kecepatan tangki. Singkatnya, kita akan membuat Seumur Hidup dari partikel pendek atau didasarkan pada kecepatan tangki.
Pada fungsi MoveTheTank tangki, saya menambahkan sebagai berikut:
if(mDust.valid() && mIsEngineRunning && mVelocity != 0)
{
// Mendapatkan layer yang diinginkan
dtCore::ParticleLayer& pLayerToSet = *mDust->GetSingleLayer("Layer 0");
osgParticle::Particle& defaultParticle = pLayerToSet.GetParticleSystem().getDefaultParticleTemplate();
// melakukan perubahan funky
float lifetime = max(2.0f, abs(mVelocity) * .4f);
defaultParticle.setLifeTime(lifetime);
pLayerToSet.GetModularEmitter().setNumParticlesToCreateMovementCompenstationRatio(abs(mVelocity) * 0.10f);
}
Sekarang ketika Anda memindahkan tangki yang memiliki partikel, maka partikel tersebut akan berubah sesuai dengan kecepatan kendaraan Anda. Keren!
Referensi:
http://www.delta3d.org/article.php?story=20060622140124995&topic=tutorials
