void GraphicsResourceMesh::setMaterialNames(GraphicsResourceMesh* resourcePtr)
{
Ogre::ResourcePtr meshResource = Ogre::MeshManager::getSingleton().getByName(resourcePtr->getID());
Ogre::Mesh* meshPtr = static_cast<Ogre::Mesh *>(&*meshResource);
Ogre::Mesh::SubMeshIterator currSubMeshIter = meshPtr->getSubMeshIterator();
while (currSubMeshIter.hasMoreElements()) {
Ogre::SubMesh *curSubMesh = currSubMeshIter.getNext();
if (!OPTION_ENABLE_TEXTURES->as<bool>()) {
curSubMesh->setMaterialName("BaseWhiteTexture");
}
else {
const Ogre::String& curMatName = curSubMesh->getMaterialName();
int pos = curMatName.find_last_of(':');
if (pos != -1) {
String start = curMatName.substr(0, pos);
String ending = curMatName.substr(pos);
std::map<String, String>::iterator itr = resourcePtr->mMaterialNames.find(start);
if (itr != resourcePtr->mMaterialNames.end())
curSubMesh->setMaterialName(itr->second + ending);
}
}
}
}
unsigned GfxBody::getSubMeshByOriginalMaterialName (const std::string &n)
{
for (unsigned i=0 ; i<mesh->getNumSubMeshes() ; ++i) {
Ogre::SubMesh *sm = mesh->getSubMesh(i);
if (sm->getMaterialName() == n) {
return i;
}
}
CERR << "Mesh did not contain material \""<<n<<"\"" <<std::endl;
return 0;
}
// unload all about this mesh. The mesh itself and the textures.
// BETWEEN FRAME OPERATION
void VisCalcFrustDist::unloadTheMesh(Ogre::MeshPtr meshP) {
if (m_shouldCullTextures) {
Ogre::Mesh::SubMeshIterator smi = meshP->getSubMeshIterator();
while (smi.hasMoreElements()) {
Ogre::SubMesh* oneSubMesh = smi.getNext();
Ogre::String subMeshMaterialName = oneSubMesh->getMaterialName();
Ogre::MaterialPtr subMeshMaterial = (Ogre::MaterialPtr)Ogre::MaterialManager::getSingleton().getByName(subMeshMaterialName);
if (!subMeshMaterial.isNull()) {
Ogre::Material::TechniqueIterator techIter = subMeshMaterial->getTechniqueIterator();
while (techIter.hasMoreElements()) {
Ogre::Technique* oneTech = techIter.getNext();
Ogre::Technique::PassIterator passIter = oneTech->getPassIterator();
while (passIter.hasMoreElements()) {
Ogre::Pass* onePass = passIter.getNext();
Ogre::Pass::TextureUnitStateIterator tusIter = onePass->getTextureUnitStateIterator();
while (tusIter.hasMoreElements()) {
Ogre::TextureUnitState* oneTus = tusIter.getNext();
Ogre::String texName = oneTus->getTextureName();
Ogre::TexturePtr texP = (Ogre::TexturePtr)Ogre::TextureManager::getSingleton().getByName(texName);
if (!texP.isNull()) {
// if (texP.useCount() <= 1) {
texP->unload();
LG::IncStat(LG::StatCullTexturesUnloaded);
// LG::Log("unloadTheMesh: unloading texture %s", texName.c_str());
// }
}
}
}
}
}
}
}
if (m_shouldCullMeshes) {
LG::OLMeshTracker::Instance()->MakeUnLoaded(meshP->getName(), Ogre::String(), NULL);
LG::IncStat(LG::StatCullMeshesUnloaded);
// LG::Log("unloadTheMesh: unloading mesh %s", mshName.c_str());
}
}
void GfxBody::reinitialise (void)
{
APP_ASSERT(mesh->isLoaded());
destroyGraphics();
for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i) {
Ogre::SubMesh *sm = mesh->getSubMesh(i);
Sub* sub = new Sub(this, sm);
subList.push_back(sub);
GFX_MAT_SYNC;
std::string matname = apply_map(initialMaterialMap, sm->getMaterialName());
if (!gfx_material_has(matname)) {
CERR << "Mesh \"/"<<mesh->getName()<<"\" references non-existing material "
<< "\""<<matname<<"\""<<std::endl;
matname = "/system/FallbackMaterial";
}
sub->material = gfx_material_get(matname);
}
if (!mesh->getSkeleton().isNull()) {
skeleton = OGRE_NEW Ogre::SkeletonInstance(mesh->getSkeleton());
skeleton->load();
numBoneMatrixes = skeleton->getNumBones();
boneMatrixes = static_cast<Ogre::Matrix4*>(OGRE_MALLOC_SIMD(sizeof(Ogre::Matrix4) * numBoneMatrixes, Ogre::MEMCATEGORY_ANIMATION));
boneWorldMatrixes = static_cast<Ogre::Matrix4*>(OGRE_MALLOC_SIMD(sizeof(Ogre::Matrix4) * numBoneMatrixes, Ogre::MEMCATEGORY_ANIMATION));
mesh->_initAnimationState(&animationState);
} else {
skeleton = NULL;
numBoneMatrixes = 0;
boneMatrixes = NULL;
boneWorldMatrixes = NULL;
}
updateBones();
}
bool OgreMeshResource::SetData(Foundation::AssetPtr source)
{
if (!source)
{
OgreRenderingModule::LogError("Null source asset data pointer");
return false;
}
if (!source->GetSize())
{
OgreRenderingModule::LogError("Zero sized mesh asset");
return false;
}
try
{
if (ogre_mesh_.isNull())
{
ogre_mesh_ = Ogre::MeshManager::getSingleton().createManual(
id_, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
if (ogre_mesh_.isNull())
{
OgreRenderingModule::LogError("Failed to create mesh " + id_);
return false;
}
ogre_mesh_->setAutoBuildEdgeLists(false);
}
Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream((void*)source->GetData(), source->GetSize(), false));
Ogre::MeshSerializer serializer;
serializer.importMesh(stream, ogre_mesh_.getPointer());
// Generate tangents to mesh
try
{
unsigned short src, dest;
if (!ogre_mesh_->suggestTangentVectorBuildParams(Ogre::VES_TANGENT, src, dest))
ogre_mesh_->buildTangentVectors(Ogre::VES_TANGENT, src, dest);
}
catch (...) {}
// Generate extremity points to submeshes, 1 should be enough
try
{
for(uint i = 0; i < ogre_mesh_->getNumSubMeshes(); ++i)
{
Ogre::SubMesh *smesh = ogre_mesh_->getSubMesh(i);
if (smesh)
smesh->generateExtremes(1);
}
}
catch (...) {}
// Assign default materials that won't complain
original_materials_.clear();
for (uint i = 0; i < ogre_mesh_->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = ogre_mesh_->getSubMesh(i);
if (submesh)
{
original_materials_.push_back(submesh->getMaterialName());
submesh->setMaterialName("UnlitTextured");
}
}
}
catch (Ogre::Exception &e)
{
OgreRenderingModule::LogError("Failed to create mesh " + id_ + ": " + std::string(e.what()));
RemoveMesh();
return false;
}
OgreRenderingModule::LogDebug("Ogre mesh " + id_ + " created");
return true;
}
void LIRenAttachmentEntity::update (float secs)
{
/* Check if background loading has finished. */
if (loaded)
return;
lisys_assert (entity == NULL);
/* Wait for the mesh to load. */
if (!mesh->isLoaded ())
{
if (loading_mesh)
return;
loading_mesh = true;
#ifdef LIREN_BACKGROUND_LOADING
Ogre::ResourceBackgroundQueue::getSingleton ().load (
"Mesh", mesh->getName (), mesh->getGroup ());
#else
mesh->load ();
#endif
return;
}
/* Start loading dependencies. */
if (!loading_deps)
{
loading_deps = true;
for (size_t i = 0 ; i < mesh->getNumSubMeshes () ; i++)
{
Ogre::SubMesh* sub = mesh->getSubMesh (i);
if (sub->isMatInitialised ())
{
Ogre::MaterialManager& mgr = Ogre::MaterialManager::getSingleton ();
Ogre::MaterialPtr material = mgr.getByName (sub->getMaterialName (), mesh->getGroup ());
if (!material.isNull ())
{
resources.push_back (material);
#ifdef LIREN_BACKGROUND_LOADING
Ogre::ResourceBackgroundQueue::getSingleton ().load (
"Material", material->getName (), material->getGroup ());
#else
material->load (true);
#endif
}
}
}
return;
}
// Wait for the dependencies to load.
for (size_t i = 0 ; i < resources.size () ; i++)
{
Ogre::ResourcePtr& resource = resources[i];
if (!resource->isLoaded ())
return;
}
// Create the entity.
Ogre::String e_name = render->id.next ();
entity = render->scene_manager->createEntity (e_name, mesh->getName (), LIREN_RESOURCES_TEMPORARY);
object->node->attachObject (entity);
// Create the skeleton and its pose buffer.
if (create_skeleton ())
{
LIRenModelData* model = get_model ();
lisys_assert (pose_buffer == NULL);
if (model != NULL)
{
pose_buffer = limdl_pose_buffer_new_copy (model->rest_pose_buffer);
lisys_assert (pose_buffer != NULL);
lisys_assert (pose_buffer->bones.count == entity->getSkeleton ()->getNumBones ());
}
}
// Set the entity flags.
entity->setCastShadows (object->get_shadow_casting ());
// Trigger queued texture replacements.
//
// This needs to be done before showing the entity in order to avoid
// the textures flickering for a few frames.
for (size_t i = 0 ; i < queued_texture_replaces.size () ; ++i)
{
LIRenTextureReplace& repl = queued_texture_replaces[i];
replace_texture_now (repl.name, repl.texture);
}
queued_texture_replaces.clear();
// Set entity visibility.
//
// If a visible entity is added to a hidden scene node, the entity is
// still rendered. Hence, newly added entities needs to be explicitly
// hidden or Ogre will render our invisible objects. */
entity->setVisible (object->get_visible ());
// Apply queued settings.
update_settings ();
// Clear the now useless dependency list.
resources.clear ();
loading_mesh = false;
loading_deps = false;
loaded = true;
}
void SceneObject::GetMeshInformation(
const Ogre::MeshPtr mesh,
size_t& vertex_count,
Ogre::Vector3* &vertices,
size_t& index_count,
unsigned long* &indices,
Ogre::Vector2* &coords,
const Ogre::Vector3& position,
const Ogre::Quaternion& orient,
const Ogre::Vector3& scale,
const std::string& _material)
{
bool added_shared = false;
size_t current_offset = 0;
//size_t shared_offset = 0;
size_t next_offset = 0;
size_t index_offset = 0;
vertex_count = index_count = 0;
// Calculate how many vertices and indices we're going to need
for (unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = mesh->getSubMesh( i );
if (submesh->getMaterialName() != _material)
continue;
// We only need to add the shared vertices once
if (submesh->useSharedVertices)
{
if ( !added_shared )
{
vertex_count += mesh->sharedVertexData->vertexCount;
added_shared = true;
}
}
else
{
vertex_count += submesh->vertexData->vertexCount;
}
// Add the indices
index_count += submesh->indexData->indexCount;
}
// Allocate space for the vertices and indices
vertices = new Ogre::Vector3[vertex_count];
indices = new unsigned long[index_count];
coords = new Ogre::Vector2[vertex_count];
added_shared = false;
// Run through the submeshes again, adding the data into the arrays
for ( unsigned short i = 0; i < mesh->getNumSubMeshes(); ++i)
{
Ogre::SubMesh* submesh = mesh->getSubMesh(i);
if (submesh->getMaterialName() != _material)
continue;
Ogre::VertexData* vertex_data = submesh->useSharedVertices ? mesh->sharedVertexData : submesh->vertexData;
if ((!submesh->useSharedVertices) || (submesh->useSharedVertices && !added_shared))
{
if (submesh->useSharedVertices)
{
added_shared = true;
//shared_offset = current_offset;
}
const Ogre::VertexElement* coordElem =
vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES);
const Ogre::VertexElement* posElem =
vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
Ogre::HardwareVertexBufferSharedPtr vbuf =
vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
unsigned char* vertex =
static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
// There is _no_ baseVertexPointerToElement() which takes an Ogre::Real or a double
// as second argument. So make it float, to avoid trouble when Ogre::Real will
// be comiled/typedefed as double:
// Ogre::Real* pReal;
float* pReal;
for ( size_t j = 0; j < vertex_data->vertexCount; ++j, vertex += vbuf->getVertexSize())
{
posElem->baseVertexPointerToElement(vertex, &pReal);
Ogre::Vector3 pt(pReal[0], pReal[1], pReal[2]);
vertices[current_offset + j] = (orient * (pt * scale)) + position;
posElem->baseVertexPointerToElement(vertex + coordElem->getOffset() - posElem->getOffset(), &pReal);
Ogre::Vector2 coord(pReal[0], pReal[1]);
coords[current_offset + j] = coord;
}
vbuf->unlock();
next_offset += vertex_data->vertexCount;
}
Ogre::IndexData* index_data = submesh->indexData;
size_t numTris = index_data->indexCount / 3;
Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
bool use32bitindexes = (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT);
unsigned long* pLong = static_cast<unsigned long*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
unsigned short* pShort = reinterpret_cast<unsigned short*>(pLong);
//size_t offset = (submesh->useSharedVertices)? shared_offset : current_offset;
// Ogre 1.6 patch (commenting the static_cast...) - index offsets start from 0 for each submesh
if ( use32bitindexes )
{
for ( size_t k = 0; k < numTris * 3; ++k)
{
indices[index_offset++] = pLong[k];/*+ static_cast<unsigned long>(offset)*/
}
}
else
{
for ( size_t k = 0; k < numTris * 3; ++k)
{
indices[index_offset++] = static_cast<unsigned long>(pShort[k]);/*+
static_cast<unsigned long>(offset)*/
}
}
ibuf->unlock();
current_offset = next_offset;
}
}