Ogre::ResourcePtr ResourceManager::loadResource( const ResourceInfo& rResource, const ResourceCallback& rCallbackSlot ) { Ogre::ResourcePtr resource = ResourceManager::getResource( rResource, true ); if( !resource.isNull() && resource->isLoaded() ) { CLOGD << "Resource " << rResource << " already loaded."; // If the resource is already loaded, callback immediately. rCallbackSlot( resource ); } else if( !resource.isNull() && mHandleTickets.count( std::make_pair( resource->getCreator()->getResourceType(), resource->getHandle() ) ) ) { // If the resource is loading, add a callback. HandleTickets::iterator i = mHandleTickets.find( std::make_pair( resource->getCreator()->getResourceType(), resource->getHandle() ) ); if( i != mHandleTickets.end() ) { mTicketCallbacks.insert( TicketCallbacks::value_type( i->second, rCallbackSlot ) ); CLOGD << "Resource " << rResource << " is loading, ticket callback: " << i->second; } else { DIVERSIA_EXCEPT( Exception::ERR_INTERNAL_ERROR, "Could not find ticket for resource that is loading in the background.", "ResourceManager::loadResource" ); } } else if( !resource.isNull() ) { // Load the resource in the background and register the callback. resource = ResourceManager::getResource( rResource, true ); Ogre::BackgroundProcessTicket ticket = mRBQ.load( ResourceManager::getResourceManagerName( rResource.mType ), rResource.mFile.string(), mGroup, false, 0, 0, this ); mTicketCallbacks.insert( TicketCallbacks::value_type( ticket, rCallbackSlot ) ); mHandleTickets.insert( std::make_pair( std::make_pair( resource->getCreator()->getResourceType(), resource->getHandle() ), ticket ) ); mTicketResources.insert( std::make_pair( ticket, resource ) ); CLOGD << "Resource " << rResource << " will be loaded, ticket: " << ticket; } else { DIVERSIA_EXCEPT( Exception::ERR_FILE_NOT_FOUND, "Cannot load resource " + rResource.mFile.string() + ", file does not exist.", "ResourceManager::loadResource" ); } return resource; }
void UnloadResource(Ogre::ResourceManager* resMgr, const std::string& resourceName) { Ogre::ResourcePtr rPtr = resMgr->getResourceByName(resourceName); if (rPtr.isNull()) { StringUtil::StrStreamType msg; msg << "Resource no longer exists: " << resourceName; Ogre::LogManager::getSingleton().logMessage(msg.str()); return; } rPtr->unload(); if (rPtr->isLoaded()) { StringUtil::StrStreamType msg; msg << "Resource was not unloaded: " << resourceName; Ogre::LogManager::getSingleton().logMessage(msg.str()); } else { StringUtil::StrStreamType msg; msg << "Resource was unloaded: " << resourceName; Ogre::LogManager::getSingleton().logMessage(msg.str()); } resMgr->remove(resourceName); rPtr = resMgr->getResourceByName(resourceName); if (rPtr.isNull()) { StringUtil::StrStreamType msg; msg << "Resource was removed: " << resourceName; Ogre::LogManager::getSingleton().logMessage(msg.str()); } else { StringUtil::StrStreamType msg; msg << "Resource was not removed: " << resourceName; Ogre::LogManager::getSingleton().logMessage(msg.str()); } if (resMgr->resourceExists(resourceName)) { StringUtil::StrStreamType msg; msg << "Resource still exists: " << resourceName; Ogre::LogManager::getSingleton().logMessage(msg.str()); } else { StringUtil::StrStreamType msg; msg << "Resource no longer exists: " << resourceName; Ogre::LogManager::getSingleton().logMessage(msg.str()); } }
void GUIManager::runCommand(const std::string &command, const std::string &args) { if (command == ToggleInputMode.getCommand()) { getInput().toggleInputMode(); } else if (command == ToggleGui.getCommand()) { S_LOG_VERBOSE("Toggle Gui Initiated -- " << getInput().getInputMode()); if (mEnabled) { S_LOG_INFO("Disabling GUI"); mEnabled = false; getInput().removeAdapter(mCEGUIAdapter); } else { S_LOG_INFO("Enabling GUI"); mEnabled = true; getInput().addAdapter(mCEGUIAdapter); } } else if (command == ReloadGui.getCommand()) { Ogre::TextureManager* texMgr = Ogre::TextureManager::getSingletonPtr(); Ogre::ResourcePtr resource = texMgr->getByName("cegui/" + getDefaultScheme() + ".png"); if (!resource.isNull()) { resource->reload(); } } }
Ogre::ResourcePtr loadCorrelativeResource(const Ogre::String& resourceName, const Ogre::String& groupName, const Ogre::String& baseResourceName, const Ogre::String& baseGroupName, Ogre::ResourceManager& resourceManager) { Ogre::ResourcePtr res; Ogre::String name, path; Ogre::StringUtil::splitFilename(resourceName, name, path); bool existsPath = !path.empty(); // First, load in correlatived group and path if resource name doesn't exists path if (!existsPath) { Ogre::StringUtil::splitFilename(baseResourceName, name, path); if (!path.empty()) { name = path + resourceName; res = tryLoadResource(resourceManager, name, baseGroupName); if (!res.isNull()) return res; } } // Second, load in correlatived group res = tryLoadResource(resourceManager, resourceName, baseGroupName); if (!res.isNull()) return res; // Three, load in user given group if (!groupName.empty()) { res = tryLoadResource(resourceManager, resourceName, groupName); if (!res.isNull()) return res; } // Four, load in global default group if (groupName != DEFAULT_RESOURCE_GROUP_NAME) { res = tryLoadResource(resourceManager, resourceName, groupName); if (!res.isNull()) return res; } return res; }
void ManualBulletShapeLoader::load(const std::string &name,const std::string &group) { // Check if the resource already exists Ogre::ResourcePtr ptr = BulletShapeManager::getSingleton().getByName(name, group); if (!ptr.isNull()) return; BulletShapeManager::getSingleton().create(name,group,true,this); }
void ResourceManager::unloadResource(Ogre::ResourceManager* resMgr, const std::string& resourceName) { Ogre::ResourcePtr rPtr = resMgr->getByName(resourceName); if (rPtr.isNull()) return rPtr->unload(); if (rPtr->isLoaded()) LOG_META(FORMAT("The resource '%1%' wasn`t unloaded!", resourceName)); else LOG_META(FORMAT("The resource '%1%' was unloaded!", resourceName)); resMgr->remove(resourceName); rPtr = resMgr->getByName(resourceName); if (!rPtr.isNull()) LOG_META(FORMAT("The resource '%1%' wasn`t removed!", resourceName)); else LOG_META(FORMAT("The resource '%1%' was removed!", resourceName)); }
Ogre::ResourcePtr EntityRecipeManager::create(const Ogre::String& name, const Ogre::String& group, bool isManual, Ogre::ManualResourceLoader* loader, const Ogre::NameValuePairList* createParams) { Ogre::ResourcePtr ret = getByName(name); if (ret.isNull()) { return Ogre::ResourceManager::create(name, group, isManual, loader, createParams); } S_LOG_WARNING("EntityRecipe with name " << name << " already exists."); return Ogre::ResourcePtr(); }
Icon* IconManager::getIcon(int, EmberEntity* entity) { std::string key = "entity_" + entity->getId(); if (mIconStore.hasIcon(key)) { return mIconStore.getIcon(key); } else { IconActionCreator actionCreator(*entity); std::unique_ptr<EntityMapping::EntityMapping> modelMapping(Mapping::EmberEntityMappingManager::getSingleton().getManager().createMapping(*entity, actionCreator, &EmberOgre::getSingleton().getWorld()->getView())); std::string modelName; if (modelMapping.get()) { modelMapping->initialize(); modelName = actionCreator.getModelName(); } //if there's no model defined for this use the placeholder model if (modelName == "") { modelName = "placeholder"; } Ogre::ResourcePtr modelDefPtr = Model::ModelDefinitionManager::getSingleton().getByName(modelName); if (!modelDefPtr.isNull()) { Model::ModelDefinition* modelDef = static_cast<Model::ModelDefinition*> (modelDefPtr.get()); const std::string& iconPath(modelDef->getIconPath()); if (iconPath != "") { Ogre::TexturePtr texPtr; try { if (Ogre::TextureManager::getSingleton().resourceExists(iconPath)) { texPtr = static_cast<Ogre::TexturePtr> (Ogre::TextureManager::getSingleton().getByName(iconPath)); //try to load it to make sure that's it a working image texPtr->load(); } if (texPtr.isNull()) { texPtr = Ogre::TextureManager::getSingleton().load(iconPath, "Gui"); } } catch (...) { S_LOG_WARNING("Error when trying to load the icon " << iconPath <<". The icon will be rendered dynamically."); texPtr.setNull(); } if (!texPtr.isNull()) { Icon* icon = mIconStore.createIcon(key, texPtr); return icon; } } } Icon* icon = mIconStore.createIcon(key); if (icon) { //update the model preview window // Model::Model* model = Model::Model::createModel(mIconRenderer.getRenderContext()->getSceneManager(), modelName); render(*icon, modelName); // mIconRenderer.getRenderContext()->getSceneManager()->destroyMovableObject(model); } return icon; } return 0; }
void ResourceManager::reloadResource(Ogre::ResourceManager* resMgr, const std::string& resourceName, const std::string& resourceGroup) { Ogre::ResourcePtr rPtr = resMgr->load(resourceName, resourceGroup); if (rPtr.isNull()) LOG_META(FORMAT("The resource '%1%' no longer exists!", resourceName)); rPtr->reload(); if (rPtr->isLoaded()) LOG_META(FORMAT("The resource '%1%' wasn`t unloaded!", resourceName)); else LOG_META(FORMAT("The resource '%1%' was unloaded!", resourceName)); }
void ResourceManager::loadResources( const ResourceList& rResources, const SimpleResourceCallback& rCallbackSlot ) { // Convert to set to remove duplicates. ResourceSet resources = ResourceInfo::toResourceSet( rResources ); if( resources.empty() ) { // If there are no resources to be loaded, call the slot and return immediately. rCallbackSlot(); return; } ResourceManager::ResourcesLoader* resourceLoader = ResourceManager::ResourcesLoader::create( rCallbackSlot ); unsigned short loaded = 0; for( ResourceSet::const_iterator i = resources.begin(); i != resources.end(); ++i ) { // Add resources to resource loader. Ogre::ResourcePtr resource = ResourceManager::getResource( *i, true ); if( resource.isNull() ) { DIVERSIA_EXCEPT( Exception::ERR_FILE_NOT_FOUND, "Cannot load resource " + (*i).mFile.string() + ", file does not exist.", "ResourceManager::loadResource" ); } if( resource->isLoaded() ) loaded++; else resourceLoader->addResource( resource ); } // All resources are already loaded. if( loaded == resources.size() ) { rCallbackSlot(); delete resourceLoader; return; } for( ResourceSet::const_iterator j = resources.begin(); j != resources.end(); ++j ) { // Load all resources and callback to the resource loader. If all resources are loaded // the rCallbackSlot will be called and the resource loader will be destroyed. ResourceManager::loadResource( *j, sigc::mem_fun( resourceLoader, &ResourceManager::ResourcesLoader::loadingComplete ) ); } }
Ogre::ResourcePtr ModelDefinitionManager::create(const Ogre::String& name, const Ogre::String& group, bool isManual, Ogre::ManualResourceLoader* loader, const Ogre::NameValuePairList* createParams) { Ogre::ResourcePtr ret = getByName(name); if (ret.isNull()) { return Ogre::ResourceManager::create(name, group, isManual, loader, createParams); } //Report this. We count on this happening a lot (user media overriding shared media for example), so we will not consider it a failure. S_LOG_INFO("ModelDefinition with name " << name << " already exists."); return Ogre::ResourcePtr(); }
void run() { Meru::ResourceLoadingQueue *queue = &ResourceLoadingQueue::getSingleton(); Ogre::ResourcePtr skeletonPtr = Ogre::SkeletonManager::getSingleton().getByName(mName); if (skeletonPtr.isNull() || !skeletonPtr->isLoaded()) { SILOG(resource,insane, "Skeleton Load Task run(), waiting for " << mName << " To queue"); SILOG(resource,debug,"Queueing " << mName << " for OGRE load "); queue->load(Ogre::SkeletonManager::getSingleton().getResourceType(), mName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, false, NULL, NULL, this); } else { SILOG(resource,insane, "Skeleton Load Task run() AND complete, waited for " << mName << " To queue"); signalCompletion(); } }
/* bool MeshUnloadTask::mainThreadUnload(String name) { Ogre::MeshManager::getSingleton().unload(name); // operationCompleted(Ogre::BackgroundProcessTicket(), Ogre::BackgroundProcessResult()); return false; } */ void MeshUnloadTask::doRun() { /*I REALLY wish this were true*/ // SequentialWorkQueue::getSingleton().queueWork(std::tr1::bind(&MeshUnloadTask::mainThreadUnload, this, mHash)); String hash = mHash; //CDNArchive::canonicalMhashName(mHash); Ogre::MeshManager* meshManager = Ogre::MeshManager::getSingletonPtr(); meshManager->remove(hash); Ogre::ResourcePtr meshResource = meshManager->getByName(hash); assert(meshResource.isNull()); SharedResourcePtr resource = mResource.lock(); if (resource) resource->unloaded(true, mEpoch); }
Ogre::ResourcePtr ResourceManager::getResource( const ResourceInfo& rResource, bool create /*= false*/ ) const { Ogre::ResourcePtr resource = mRGM._getResourceManager( ResourceManager::getResourceManagerName( rResource.mType ) )->getByName( rResource.mFile.string(), mGroup ); if( !create ) return resource; if( resource.isNull() ) { if( !mRGM.findResourceNames( mGroup, rResource.mFile.string() )->size() ) return resource; resource = mRGM._getResourceManager( ResourceManager::getResourceManagerName( rResource.mType ) )->create( rResource.mFile.string(), mGroup ); } return resource; }
Ogre::MaterialPtr IntersectGrid::_createIntersectGridMaterial(void) { String name = "IntersectGridMaterial"; Ogre::ResourcePtr res = Ogre::MaterialManager::getSingleton().getByName(name); if (!res.isNull()) return res; Ogre::MaterialPtr material = Ogre::MaterialManager::getSingleton().create(name, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); material->setLightingEnabled(false); material->setSceneBlending(Ogre::SBF_SOURCE_ALPHA, Ogre::SBF_ONE_MINUS_SOURCE_ALPHA); material->setDepthWriteEnabled(false); // Use wireframe polygon mode material->getTechnique(0)->getPass(0)->setPolygonMode(Ogre::PM_WIREFRAME); return material; }
SoundTrackPtr::SoundTrackPtr(const Ogre::ResourcePtr &resourcePtr) { Log *errorLog = OGF::LogFactory::getSingletonPtr()->get(OGF::LOG_ERR); if (resourcePtr.isNull()) { return; } OGRE_LOCK_MUTEX(*resourcePtr.OGRE_AUTO_MUTEX_NAME) OGRE_COPY_AUTO_SHARED_MUTEX(resourcePtr.OGRE_AUTO_MUTEX_NAME) pRep = static_cast<SoundTrack *>(resourcePtr.getPointer()); pUseCount = resourcePtr.useCountPointer(); useFreeMethod = resourcePtr.freeMethod(); // Incremento del contador de referencias. if (pUseCount) ++(*pUseCount); }
Ogre::ResourcePtr SkeletonDebug::GetAxesMesh() { Ogre::ResourcePtr axesMeshPtr = Ogre::MeshManager::getSingleton().getByName(axesMeshName); if (axesMeshPtr.isNull()) { Ogre::ManualObject mo("tmp"); mo.begin(GetAxesMaterial()->getName()); /* 3 axes, each made up of 2 of these (base plane = XY) * .------------|\ * '------------|/ */ mo.estimateVertexCount(7 * 2 * 3); mo.estimateIndexCount(3 * 2 * 3); Ogre::Quaternion quat[6]; Ogre::ColourValue col[3]; // x-axis quat[0] = Ogre::Quaternion::IDENTITY; quat[1].FromAxes(Ogre::Vector3::UNIT_X, Ogre::Vector3::NEGATIVE_UNIT_Z, Ogre::Vector3::UNIT_Y); col[0] = Ogre::ColourValue::Red; col[0].a = 0.3f; // y-axis quat[2].FromAxes(Ogre::Vector3::UNIT_Y, Ogre::Vector3::NEGATIVE_UNIT_X, Ogre::Vector3::UNIT_Z); quat[3].FromAxes(Ogre::Vector3::UNIT_Y, Ogre::Vector3::UNIT_Z, Ogre::Vector3::UNIT_X); col[1] = Ogre::ColourValue::Green; col[1].a = 0.3f; // z-axis quat[4].FromAxes(Ogre::Vector3::UNIT_Z, Ogre::Vector3::UNIT_Y, Ogre::Vector3::NEGATIVE_UNIT_X); quat[5].FromAxes(Ogre::Vector3::UNIT_Z, Ogre::Vector3::UNIT_X, Ogre::Vector3::UNIT_Y); col[2] = Ogre::ColourValue::Blue; col[2].a = 0.3f; Ogre::Vector3 basepos[7] = { // stalk Ogre::Vector3(0.0f, 0.05f, 0.0f), Ogre::Vector3(0.0f, -0.05f, 0.0f), Ogre::Vector3(0.7f, -0.05f, 0.0f), Ogre::Vector3(0.7f, 0.05f, 0.0f), // head Ogre::Vector3(0.7f, -0.15f, 0.0f), Ogre::Vector3(1.0f, 0.0f, 0.0f), Ogre::Vector3(0.7f, 0.15f, 0.0f) }; // vertices // 6 arrows for (size_t i = 0; i < 6; ++i) { // 7 points for (size_t p = 0; p < 7; ++p) { Ogre::Vector3 pos = quat[i] * basepos[p]; mo.position(pos); mo.colour(col[i / 2]); } } // indices // 6 arrows for (size_t i = 0; i < 6; ++i) { int base = static_cast<int>(i) * 7; mo.triangle(base + 0, base + 1, base + 2); mo.triangle(base + 0, base + 2, base + 3); mo.triangle(base + 4, base + 5, base + 6); } mo.end(); axesMeshPtr = mo.convertToMesh( axesMeshName, Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME); } return axesMeshPtr; }
void run(){ boost::unique_lock<boost::mutex> lock(OgreFramework::getSingletonPtr()->mutex); OgreFramework::getSingletonPtr()->m_pLog->logMessage("Start main loop..."); //float fps_limit = 70.0; double timeSinceLastFrame = 0; double startTime = 0; OgreFramework::getSingletonPtr()->m_pRenderWnd->resetStatistics(); lock.unlock(); while(!m_bShutdown && !OgreFramework::getSingletonPtr()->isOgreToBeShutDown()) { boost::unique_lock<boost::mutex> lock(OgreFramework::getSingletonPtr()->mutex); if(OgreFramework::getSingletonPtr()->m_pRenderWnd->isClosed())m_bShutdown = true; Ogre::WindowEventUtilities::messagePump(); if(OgreFramework::getSingletonPtr()->m_pRenderWnd->isActive()) { startTime = OgreFramework::getSingletonPtr()->m_pTimer->getMillisecondsCPU(); OgreFramework::getSingletonPtr()->m_pKeyboard->capture(); OgreFramework::getSingletonPtr()->m_pMouse->capture(); OgreFramework::getSingletonPtr()->updateCaption(); //update mouse selection to shaders Ogre::ResourcePtr r = Ogre::MaterialManager::getSingletonPtr()->getByName("MultiTextureEditor"); if(!r.isNull()){ float mx=OgreFramework::getSingletonPtr()->cursor_x+OgreFramework::getSingletonPtr()->m_pCamera->getPosition().x; float my=OgreFramework::getSingletonPtr()->cursor_y+OgreFramework::getSingletonPtr()->m_pCamera->getPosition().z; //float my=OgreFramework::getSingletonPtr()->cursor_y+sqrt(OgreFramework::getSingletonPtr()->m_pCamera->getPosition().z); /*//std::cout<<((Ogre::Material*)r.get())->getTechnique(0)->getPass(0)->getVertexProgramParameters()->getSharedParameters().size()<<"\n";//->setNamedConstant("pointer", Ogre::Vector3(OgreFramework::getSingletonPtr()->cursor_x,OgreFramework::getSingletonPtr()->cursor_y,OgreFramework::getSingletonPtr()->cursor_r)); float mx=(OgreFramework::getSingletonPtr()->cursor_x-OgreFramework::getSingletonPtr()->cursror_e_w/2.0)/OgreFramework::getSingletonPtr()->cursror_e_w; float my=(-OgreFramework::getSingletonPtr()->cursor_y+OgreFramework::getSingletonPtr()->cursror_e_h/2.0)/OgreFramework::getSingletonPtr()->cursror_e_h; Ogre::Ray ray=OgreFramework::getSingletonPtr()->m_pCamera->getCameraToViewportRay(mx,my); Ogre::Vector3 cam = OgreFramework::getSingletonPtr()->m_pCamera->getDirection(); float factor = ray.getDirection().dotProduct(cam) / (cam.length() * ray.getDirection().length()); Ogre::Vector3 point = ray.getPoint(OgreFramework::getSingletonPtr()->m_pCamera->getPosition().y*factor); */ switch(OgreFramework::getSingletonPtr()->mode){ case 0: ((Ogre::Material*)r.get())->getTechnique(0)->getPass(0)->getVertexProgramParameters()->setNamedConstant("pointer", Ogre::Vector4(mx,my,OgreFramework::getSingletonPtr()->cursor_r,OgreFramework::getSingletonPtr()->cursor_rb)); break; case 1: ((Ogre::Material*)r.get())->getTechnique(0)->getPass(0)->getVertexProgramParameters()->setNamedConstant("pointer", Ogre::Vector4(mx,my,OgreFramework::getSingletonPtr()->cursor_r,0)); break; case 2: ((Ogre::Material*)r.get())->getTechnique(0)->getPass(0)->getVertexProgramParameters()->setNamedConstant("pointer", Ogre::Vector4(mx,my,2,0)); break; default: ((Ogre::Material*)r.get())->getTechnique(0)->getPass(0)->getVertexProgramParameters()->setNamedConstant("pointer", Ogre::Vector4(-20,-20,0,0)); } } else{ //TODO error! } OgreFramework::getSingletonPtr()->updateOgre(timeSinceLastFrame); OgreFramework::getSingletonPtr()->m_pRoot->renderOneFrame(); /* while(OgreFramework::getSingletonPtr()->chunksToAdd.size()>0){//adding chunks ChunkAdding* ch = OgreFramework::getSingletonPtr()->chunksToAdd.front(); OgreFramework::getSingletonPtr()->chunksToAdd.pop(); Ogre::ManualObject* ogreMesh = OgreFramework::getSingletonPtr()->m_pSceneMgr->createManualObject(std::string("Chunk")+(char)ch->x+(char)ch->y+(char)ch->z); ogreMesh->setDynamic(true); ogreMesh->setCastShadows(true); ogreMesh->begin("MultiTexture", Ogre::RenderOperation::OT_TRIANGLE_LIST); { for(int i=0;i<ch->size;++i){ ogreMesh->position(ch->pos[i]); ogreMesh->normal(ch->normal[i]); ogreMesh->colour(ch->color[i]); } } ogreMesh->end(); Ogre::SceneNode* ogreNode = OgreFramework::getSingletonPtr()->m_pSceneMgr->getRootSceneNode()->createChildSceneNode(std::string("NChunk")+(char)ch->x+(char)ch->y+(char)ch->z, Ogre::Vector3(0, 0, 0)); ogreNode->setVisible(true); ogreNode->attachObject(ogreMesh); ogreNode->setPosition(ch->x*CHUNK_SIZE,ch->z*(CHUNK_SIZE),ch->y*CHUNK_SIZE); delete ch; }*/ //update chunks /*Pos* pos=NULL; unsigned int chunksUpdated=0; float cx=OgreFramework::getSingletonPtr()->m_pCamera->getPosition().x,cy=OgreFramework::getSingletonPtr()->m_pCamera->getPosition().z; while(chunksUpdated<8 and (pos=OgreFramework::getSingletonPtr()->map->getNextUpdatedChunk())!=NULL){ int xx=pos->x*128-cx; int yy=pos->y*128-cy; if(xx*xx+yy*yy<1280){ std::cout<<"Updating chunk\n"; chunksUpdated++; try{ OgreFramework::getSingletonPtr()->m_pSceneMgr->getSceneNode(std::string("NChunk")+(char)pos->x+(char)pos->y)->removeAndDestroyAllChildren(); } catch(...){} OgreFramework::getSingletonPtr()->map->getChunk(pos->x,pos->y); delete pos; } else{ OgreFramework::getSingletonPtr()->map->chunks_q.push(pos); } }*/ float cx=OgreFramework::getSingletonPtr()->m_pCamera->getPosition().x,cy=OgreFramework::getSingletonPtr()->m_pCamera->getPosition().z; int lod = OgreFramework::getSingletonPtr()->m_pCamera->getPosition().y/OgreFramework::getSingletonPtr()->lodFactor; if(lod>4) lod=4; else if(lod<0) lod=0; int showY = tan(OgreFramework::getSingletonPtr()->m_pCamera->getFOVy().valueRadians()) * OgreFramework::getSingletonPtr()->m_pCamera->getPosition().y/256.0+1; if(showY>7) showY=7; int showX=showY*4.0/3.0; try{ for(int xx=cx/128-showX;xx<=cx/128+showX;xx++){ for(int yy=cy/128-showY;yy<=cy/128+showY;yy++){ if(xx>=0 and yy>=0 and xx<OgreFramework::getSingletonPtr()->map->x and yy<OgreFramework::getSingletonPtr()->map->y and !OgreFramework::getSingletonPtr()->map->fresh[lod][xx][yy]){ /*try{ OgreFramework::getSingletonPtr()->m_pSceneMgr->getSceneNode(std::string("NChunk")+Map::getPos(xx,yy))->removeAndDestroyAllChildren(); } catch(...){ // std::cout<<"Chunk didnt exist\n"; }*/ OgreFramework::getSingletonPtr()->map->getChunk(xx,yy,lod); //std::cout<<"Updating chunk\n"; throw (int)0; } } } } catch(int){}//exit from loop lock.unlock(); boost::this_thread::sleep(boost::posix_time::milliseconds(1)); timeSinceLastFrame = OgreFramework::getSingletonPtr()->m_pTimer->getMillisecondsCPU() - startTime; } else { #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 Sleep(1000); #else sleep(1); #endif } } OgreFramework::getSingletonPtr()->m_pLog->logMessage("Autosaving..."); OgreFramework::getSingletonPtr()->map->save("autosave.map"); OgreFramework::getSingletonPtr()->m_pLog->logMessage("Main loop quit"); OgreFramework::getSingletonPtr()->m_pLog->logMessage("Shutdown OGRE..."); }