void LodManager::loadLod(Ogre::MeshPtr mesh, const LodDefinition& def)
{
if (def.getUseAutomaticLod()) {
loadAutomaticLod(mesh);
} else if (def.getLodDistanceCount() == 0) {
mesh->removeLodLevels();
return;
} else {
Ogre::LodStrategy* strategy;
if (def.getStrategy() == LodDefinition::LS_DISTANCE) {
strategy = &Ogre::DistanceLodStrategy::getSingleton();
} else {
strategy = &Ogre::PixelCountLodStrategy::getSingleton();
}
mesh->setLodStrategy(strategy);
if (def.getType() == LodDefinition::LT_AUTOMATIC_VERTEX_REDUCTION) {
// Automatic vertex reduction
LodConfig lodConfig;
lodConfig.mesh = mesh;
const LodDefinition::LodDistanceMap& data = def.getManualLodData();
if (def.getStrategy() == LodDefinition::LS_DISTANCE) {
// TODO: Use C++11 lambda, instead of template.
loadAutomaticLodImpl(data.begin(), data.end(), lodConfig);
} else {
loadAutomaticLodImpl(data.rbegin(), data.rend(), lodConfig);
}
// Uncomment the ProgressiveMesh of your choice.
// NOTE: OgreProgressiveMeshExt doesn't support collapse cost based reduction.
// OgreProgressiveMeshExt pm;
// ProgressiveMeshGenerator pm;
QueuedProgressiveMeshGenerator pm;
pm.build(lodConfig);
} else {
// User created Lod
mesh->removeLodLevels();
const LodDefinition::LodDistanceMap& data = def.getManualLodData();
if (def.getStrategy() == LodDefinition::LS_DISTANCE) {
// TODO: Use C++11 lambda, instead of template.
loadUserLodImpl(data.begin(), data.end(), mesh.get());
} else {
loadUserLodImpl(data.rbegin(), data.rend(), mesh.get());
}
}
}
}
//-----------------------------------------------------------------------
CollisionModelPtr CollisionModelManager::getCollisionModel(const Ogre::MeshPtr& mesh)
{
// Find in the cache
CacheItemMap::iterator it = mCacheItemMap.find(mesh.get());
if (it == mCacheItemMap.end())
{
// Free out-of-date collision models first
_checkMemoryUsage();
// Create new collision model
CollisionModelPtr collisionModel(new CollisionModel);
collisionModel->addMesh(mesh);
collisionModel->build(false);
// Add to cache
_add(mesh, collisionModel);
return collisionModel;
}
else
{
CacheItem* item = &it->second;
// Update LRU queue
_moveToFront(item);
return item->collisionModel;
}
}
Ogre::Mesh* EC_Mesh::PrepareMesh(const std::string& mesh_name, bool clone)
{
if (!ViewEnabled())
return 0;
if (renderer_.expired())
return 0;
RendererPtr renderer = renderer_.lock();
Ogre::MeshManager& mesh_mgr = Ogre::MeshManager::getSingleton();
Ogre::MeshPtr mesh = mesh_mgr.getByName(SanitateAssetIdForOgre(mesh_name));
// For local meshes, mesh will not get automatically loaded until used in an entity. Load now if necessary
if (mesh.isNull())
{
try
{
mesh_mgr.load(mesh_name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
mesh = mesh_mgr.getByName(mesh_name);
}
catch (Ogre::Exception& e)
{
LogError("Could not load mesh " + mesh_name + ": " + std::string(e.what()));
return 0;
}
}
// If mesh is still null, must abort
if (mesh.isNull())
{
LogError("Mesh " + mesh_name + " does not exist");
return 0;
}
if (clone)
{
try
{
mesh = mesh->clone(renderer->GetUniqueObjectName("EC_Mesh_clone"));
mesh->setAutoBuildEdgeLists(false);
cloned_mesh_name_ = mesh->getName();
}
catch (Ogre::Exception& e)
{
LogError("Could not clone mesh " + mesh_name + ":" + std::string(e.what()));
return 0;
}
}
if (mesh->hasSkeleton())
{
Ogre::SkeletonPtr skeleton = Ogre::SkeletonManager::getSingleton().getByName(mesh->getSkeletonName());
if (skeleton.isNull() || skeleton->getNumBones() == 0)
{
LogDebug("Mesh " + mesh_name + " has a skeleton with 0 bones. Disabling the skeleton.");
mesh->setSkeletonName("");
}
}
return mesh.get();
}
//-----------------------------------------------------------------------
void CollisionModelManager::_add(const Ogre::MeshPtr& mesh, const CollisionModelPtr& collisionModel)
{
std::pair<CacheItemMap::iterator, bool> inserted =
mCacheItemMap.insert(CacheItemMap::value_type(mesh.get(), CacheItem(mesh, collisionModel)));
assert(inserted.second);
_linkToFront(&inserted.first->second);
mMemoryUsage += collisionModel->getMemoryUsage();
}
OgrePolyvoxInterface::OgrePolyvoxInterface() {
scene = (Ogre::SceneManager*)GraphicsManager::instance()->getInterface()->getScene();
int width, height;
LOG("Creating heightmap");
float* heightmap = CreateHeightmapFromFile("..\\heightmap.png", width, height, 1.f);
LOG("Creating volume");
volume = new PolyVox::Volume<PolyVox::MaterialDensityPair44>(PolyVox::Region(Vector3DInt32(0,0,0), Vector3DInt32(width-1, 63, height-1)));
LOG("Writing heightmap to volume");
createHeightmapInVolume(volume, heightmap, width, height);
mesh = new PolyVox::SurfaceMesh<PositionMaterialNormal>();
SurfaceExtractor<MaterialDensityPair44> surfaceExtractor(volume, volume->getEnclosingRegion(), mesh);
surfaceExtractor.execute();
const std::vector<boost::uint32_t>& indices = mesh->getIndices();
const std::vector<PositionMaterialNormal>& vertices = mesh->getVertices();
node = scene->getRootSceneNode()->createChildSceneNode();
obj = scene->createManualObject();
int vertex_count = mesh->getNoOfVertices();
int index_count = mesh->getNoOfIndices();
obj->estimateVertexCount(vertex_count);
obj->estimateIndexCount(index_count);
LOG("Building manual object");
obj->begin("BaseWhite", Ogre::RenderOperation::OT_TRIANGLE_LIST);
LOG("Building vertex data");
for(std::vector<PositionMaterialNormal>::const_iterator pmn = vertices.begin(); pmn != vertices.end(); pmn++) {
PolyVox::Vector3DFloat position = (*pmn).getPosition();
PolyVox::Vector3DFloat normal = (*pmn).getNormal();
obj->position(position.getX(), position.getY(), position.getZ());
obj->normal(normal.getX(), normal.getY(), normal.getZ());
}
LOG("Building indices");
for(int i=0; i<mesh->getNoOfIndices(); i+=3) {
obj->triangle(indices[i], indices[i+1], indices[i+2]);
}
obj->end();
char mesh_name[32];
sprintf(mesh_name, "%i%i", rand()%1000, rand()%1000, rand()%1000, rand()%1000);
LOG("Converting to mesh");
Ogre::MeshPtr ptr = obj->convertToMesh(mesh_name);
Ogre::Mesh* ogremesh = ptr.get();
Ogre::Entity* entity = scene->createEntity("TilemapEntity", mesh_name);
node->attachObject(entity);
LOG("Done!");
}
int main(int argc, char** argv)
{
static Ogre::String s_strDefault = "";
Ogre::Root* lpRoot = new Ogre::Root(s_strDefault, s_strDefault, s_strDefault);
CFBXLoader loader;
if (argc > 1)
{
Ogre::DefaultHardwareBufferManager* lpBufferManager = new Ogre::DefaultHardwareBufferManager(); // needed because we don't have a rendersystem
Ogre::MeshPtr lpMesh = Ogre::MeshManager::getSingleton().createManual("conversion", Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
loader.convertFbxToMesh(argv[1], lpMesh.get());
Ogre::MeshSerializer nSerializer;
nSerializer.exportMesh(lpMesh.get(), "test.mesh", Ogre::MESH_VERSION_1_8);
delete lpBufferManager;
}
delete lpRoot;
return 0;
}
/* Creates a list of triangles and allocating all the vertexs from a mesh
* Requires:
* @cont The Vertex container where it will been put the vertexs
* @mesh The mesh to extract the triangles
* @triangles The list to be filled with the triangles
* Returns:
* true on success
* false otherwise
*/
bool Util::getTrianglesFromMesh(PolyStructsContainer<sm::Vertex *> &cont,
PolyStructsContainer<Triangle *> &triangles,
Ogre::MeshPtr mesh)
{
ASSERT(!mesh.isNull());
if(!cont.isEmpty()){
debug("Warning: Not an empty container\n");
}
if(!triangles.isEmpty()){
debug("Warning, triangles is not empty\n");
ASSERT(false);
}
size_t vertex_count,index_count;
Ogre::Vector3* vertices = 0;
long unsigned* indices = 0;
getMeshInformation(mesh.get(),vertex_count,vertices,index_count,indices);
// TODO: hacer esta funcion mas rapida, estamos buscando para cada vector
// el vertice asociado. Es lento
// here we will map Ogre::Vector3[i] -> Vertex*
std::vector<sm::Vertex *> vertexMap;
vertexMap.resize(vertex_count);
// fills the map of vertexs
sm::Vertex *v = 0;
for(size_t i = 0; i < vertex_count; ++i){
v = findVertex(cont.getObjs(), vertices[i]);
if(!v){
// create a new vertex and put it in the container
v = new sm::Vertex(vertices[i].x, vertices[i].z);
cont.addObj(v);
}
// associate the vec to the vertex
vertexMap[i] = v;
}
// now we have to create the triangles
for(size_t i = 0; i < index_count; i += 3){
triangles.addObj(new Triangle(vertexMap[indices[i]],
vertexMap[indices[i+1]],
vertexMap[indices[i+2]]));
}
delete []vertices;
delete []indices;
return true;
}
bool AssetsManager::exportMesh(Ogre::MeshPtr mesh, const std::string& filePath)
{
if (filePath != "") {
Ogre::MeshSerializer serializer;
try {
serializer.exportMesh(mesh.get(), filePath);
S_LOG_INFO("Exported mesh " << filePath);
} catch (const Ogre::Exception& ex) {
S_LOG_FAILURE("Error when exporting mesh " << mesh->getName() << "to path " << filePath <<"." << ex);
return false;
}
return true;
}
return false;
}
btTriangleMesh* TriangleMeshFactory::addTriangleMesh(const std::string& _name, Ogre::MeshPtr _fromMesh)
{
Ogre::MeshPtr mesh = Ogre::MeshManager::getSingleton().load(_name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
//Create complex shape
unsigned int vertexCount, indexCount;
Ogre::Vector3* vertices;
unsigned long* indices;
OgreUtils::getMeshInformation(mesh.get(), vertexCount, vertices, indexCount, indices, Ogre::Vector3::ZERO, Ogre::Quaternion::IDENTITY, Ogre::Vector3(1.f, 1.f, 1.f)/* TODO _scale */);
btTriangleMesh* triangleMesh = new btTriangleMesh();
for(unsigned int i = 0; i < indexCount; i += 3)
{
triangleMesh->addTriangle(convert(vertices[indices[i+0]]), convert(vertices[indices[i+1]]), convert(vertices[indices[i+2]]));
}
mTriangleMeshes[_name] = triangleMesh;
return triangleMesh;
}
DecorativeObject::DecorativeObject(Ogre::SceneManager *mgr, Ogre::String _entName, Ogre::String _meshName, Ogre::String _nodeName, Ogre::SceneNode* parentNode,
Physics* _physics,
btVector3 origin, btVector3 scale,
btVector3 velocity, btScalar _mass, btScalar _rest,
btVector3 _localInertia, btQuaternion *rotation)
: GameObject(mgr, _entName, _nodeName, parentNode, _physics, origin, scale, velocity, _mass, _rest, _localInertia, rotation)
{
entity = mgr->createEntity(_entName, _meshName);
entity->setCastShadows(true);
node->attachObject(entity);
Ogre::MeshPtr meshptr = Ogre::Singleton<Ogre::MeshManager>::getSingletonPtr()->load(_meshName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
MeshStrider *strider = new MeshStrider(meshptr.get());
collisionShape = new btBvhTriangleMeshShape(strider,true,true);
addToSimulator(Collisions::CollisionTypes::COL_COLLECTIBLE,
0);
setAmbient(0.5,0.0,0.0);
setSpecular(0.1,0,0,0.4);
if (rotation) rotate(*rotation);
}
bool AssetsManager::exportMesh(Ogre::MeshPtr mesh, const std::string& filePath)
{
if (filePath != "") {
Ogre::MeshSerializer serializer;
try {
std::string dirname(filePath);
size_t end = dirname.find_last_of("/\\");
if (end != std::string::npos) {
dirname = dirname.substr(0, end);
}
oslink::directory osdir(dirname);
if (!osdir.isExisting()) {
oslink::directory::mkdir(dirname.c_str());
}
serializer.exportMesh(mesh.get(), filePath);
S_LOG_INFO("Exported mesh " << filePath);
} catch (const Ogre::Exception& ex) {
S_LOG_FAILURE("Error when exporting mesh " << mesh->getName() << "to path " << filePath <<"." << ex);
return false;
}
return true;
}
return false;
}
void OgreExporter_c::ExportLevel(const WadLevel_c &level, const WadFile_c &file)
{
this->ExportLevelMaterials(level, file);
Ogre::DefaultHardwareBufferManager hardwareBufferManager;
Ogre::ManualObject manualMesh(level.GetName());
const LineDef_s *lineDefs = level.GetLineDefs();
const size_t numLineDefs = level.GetNumLineDefs();
const SideDef_s *sideDefs = level.GetSideDefs();
const Sector_s *sectors = level.GetSectors();
const Vertex_s *vertices = level.GetVertices();
for(size_t i = 0;i < numLineDefs; ++i)
{
if(lineDefs[i].iLeftSideDef >= 0)
{
const SideDef_s &leftSide = sideDefs[lineDefs[i].iLeftSideDef];
const Sector_s &leftSideSector = sectors[leftSide.iSector];
const SideDef_s &rightSide = sideDefs[lineDefs[i].iRightSideDef];
const Sector_s &rightSideSector = sectors[rightSide.iSector];
if(leftSide.uMiddleTexture.uName != '-')
{
this->ExportWallMesh(manualMesh, leftSideSector.iFloorHeight, leftSideSector.iCeilHeight, leftSide.uMiddleTexture, leftSide.iOffsetX, leftSide.iOffsety, vertices, lineDefs[i], file);
}
if(leftSide.uLowerTexture.uName != '-')
{
this->ExportWallMesh(manualMesh, leftSideSector.iFloorHeight, leftSideSector.iFloorHeight, leftSide.uLowerTexture, leftSide.iOffsetX, leftSide.iOffsety, vertices, lineDefs[i], file);
}
if(leftSide.uUpperTexture.uName != '-')
{
this->ExportWallMesh(manualMesh, rightSideSector.iCeilHeight, leftSideSector.iCeilHeight, leftSide.uUpperTexture, leftSide.iOffsetX, leftSide.iOffsety, vertices, lineDefs[i], file);
}
}
if(lineDefs[i].iRightSideDef >= 0)
{
const SideDef_s &rightSide = sideDefs[lineDefs[i].iRightSideDef];
const Sector_s &rightSideSector = sectors[rightSide.iSector];
if(rightSide.uLowerTexture.uName != '-')
{
const SideDef_s &leftSide = sideDefs[lineDefs[i].iLeftSideDef];
const Sector_s &leftSideSector = sectors[leftSide.iSector];
this->ExportWallMesh(manualMesh, rightSideSector.iFloorHeight, leftSideSector.iFloorHeight, rightSide.uLowerTexture, rightSide.iOffsetX, rightSide.iOffsety, vertices, lineDefs[i], file);
}
if(rightSide.uMiddleTexture.uName != '-')
{
this->ExportWallMesh(manualMesh, rightSideSector.iFloorHeight, rightSideSector.iCeilHeight, rightSide.uMiddleTexture, rightSide.iOffsetX, rightSide.iOffsety, vertices, lineDefs[i], file);
}
if(rightSide.uUpperTexture.uName != '-')
{
const SideDef_s &leftSide = sideDefs[lineDefs[i].iLeftSideDef];
const Sector_s &leftSideSector = sectors[leftSide.iSector];
this->ExportWallMesh(manualMesh, leftSideSector.iCeilHeight, rightSideSector.iCeilHeight, rightSide.uUpperTexture, rightSide.iOffsetX, rightSide.iOffsety, vertices, lineDefs[i], file);
}
}
}
namespace fs = boost::filesystem;
fs::path path(strLevelDirectory);
std::string levelName = level.GetName();
levelName += ".mesh";
path /= levelName;
Ogre::LogManager logManager;
logManager.createLog("ogre.log", true, true, false);
Ogre::ResourceGroupManager resourceGroupManager;
Ogre::MeshManager meshManager;
Ogre::LodStrategyManager logStrategyManager;
Ogre::MeshPtr mesh = manualMesh.convertToMesh(level.GetName());
Ogre::MeshSerializer serializer;
serializer.exportMesh(mesh.get(), path.string());
mesh.setNull();
resourceGroupManager.shutdownAll();
this->CreateResourcesCfg();
}
