C++ MeshPtr::get方法代码示例

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();
}