ResourcePtr DynamicLibraryLoader::loadResource(const String& filename)
{
DynamicLibrary* dynlib = AProNew(DynamicLibrary, filename);
if(dynlib->isLoaded())
return ResourcePtr(dynlib);
else
return ResourcePtr();
}
void ResourcesPage::onItemChanged( wxTreeEvent& event )
{
wxTreeItemId oldId = event.GetOldItem();
wxTreeItemId newId = event.GetItem();
const ResourceHandle& oldResource = getResourceFromTreeId( oldId );
const ResourceHandle& newResource = getResourceFromTreeId( newId );
EventManager* events = GetEditor().getEventManager();
if( oldResource )
events->onResourceUnselect(ResourcePtr(oldResource.Resolve()));
if( newResource )
events->onResourceSelect(ResourcePtr(newResource.Resolve()));
}
ResourcePtr ResourceManager::ResourceTypeManager::get(ResourceId resId) const {
Metadatas::const_iterator pos = resources.find(resId);
if (pos != resources.end()) {
return pos->second->get();
} else {
return ResourcePtr();
}
}
ResourcePtr ResourceProvider::find( const ResourceInfo& resource_infos )
{
auto resource_it = m_resources_registry.find( resource_infos );
if( resource_it != end(m_resources_registry) )
{
return resource_it->second;
}
return ResourcePtr();
}
ResourcePtr Statement::asResource() const
{
const shared_ptr<Model::ModelPrivate> m = d ? d->model.lock() : shared_ptr<Model::ModelPrivate>();
if (isNull() || !m || !m->nodeByID(d->objectID)->isResource())
return ResourcePtr(new Resource);
return m->resourceByID(d->objectID);
}
//-----------------------------------------------------------------------
ResourcePtr ResourceManager::getResourceByName(const String& name, const String& groupName /* = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME */)
{
OGRE_LOCK_AUTO_MUTEX;
// resource should be in global pool
bool isGlobal = ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(groupName);
if(isGlobal)
{
ResourceMap::iterator it = mResources.find(name);
if( it != mResources.end())
{
return it->second;
}
}
// look in all grouped pools
if (groupName == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
{
ResourceWithGroupMap::iterator iter = mResourcesWithGroup.begin();
ResourceWithGroupMap::iterator iterE = mResourcesWithGroup.end();
for ( ; iter != iterE ; ++iter )
{
ResourceMap::iterator resMapIt = iter->second.find(name);
if( resMapIt != iter->second.end())
{
return resMapIt->second;
}
}
}
else if (!isGlobal)
{
// look in the grouped pool
ResourceWithGroupMap::iterator itGroup = mResourcesWithGroup.find(groupName);
if( itGroup != mResourcesWithGroup.end())
{
ResourceMap::iterator it = itGroup->second.find(name);
if( it != itGroup->second.end())
{
return it->second;
}
}
#if !OGRE_RESOURCEMANAGER_STRICT
// fall back to global
ResourceMap::iterator it = mResources.find(name);
if( it != mResources.end())
{
return it->second;
}
#endif
}
return ResourcePtr();
}
RDFVocab::RDFVocab() : d(new RDFVocabPrivate)
{
QString ns = QLatin1String("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
d->namespaceURI = ns;
d->seq = ResourcePtr(new Resource(ns + QLatin1String("Seq")));
d->type = PropertyPtr(new Property(ns + QLatin1String("type")));
d->li = PropertyPtr(new Property(ns + QLatin1String("li")));
}
//---------------------------------------------------------------------------
ResourcePtr GpuProgramManager::create(const String& name, const String& group,
GpuProgramType gptype, const String& syntaxCode, bool isManual,
ManualResourceLoader* loader)
{
// Call creation implementation
ResourcePtr ret = ResourcePtr(
createImpl(name, getNextHandle(), group, isManual, loader, gptype, syntaxCode));
addImpl(ret);
// Tell resource group manager
ResourceGroupManager::getSingleton()._notifyResourceCreated(ret);
return ret;
}
//-----------------------------------------------------------------------
ResourcePtr ResourceManager::getByHandle(ResourceHandle handle)
{
OGRE_LOCK_AUTO_MUTEX;
ResourceHandleMap::iterator it = mResourcesByHandle.find(handle);
if (it == mResourcesByHandle.end())
{
return ResourcePtr();
}
else
{
return it->second;
}
}
//-----------------------------------------------------------------------
ResourcePtr ResourceManager::getByName(const String& name)
{
OGRE_LOCK_AUTO_MUTEX
ResourceMap::iterator it = mResources.find(name);
if( it == mResources.end())
{
return ResourcePtr();
}
else
{
return it->second;
}
}
//-----------------------------------------------------------------------
ResourcePtr ResourceManager::create(const String& name, const String& group,
bool isManual, ManualResourceLoader* loader, const NameValuePairList* params)
{
// Call creation implementation
ResourcePtr ret = ResourcePtr(
createImpl(name, getNextHandle(), group, isManual, loader, params));
if (params)
ret->setParameterList(*params);
addImpl(ret);
// Tell resource group manager
ResourceGroupManager::getSingleton()._notifyResourceCreated(ret);
return ret;
}
//---------------------------------------------------------------------------
HighLevelGpuProgramPtr HighLevelGpuProgramManager::createProgram(
const String& name, const String& groupName,
const String& language, GpuProgramType gptype)
{
ResourcePtr ret = ResourcePtr(
getFactory(language)->create(this, name, getNextHandle(),
groupName, false, 0));
HighLevelGpuProgramPtr prg = ret;
prg->setType(gptype);
prg->setSyntaxCode(language);
addImpl(ret);
// Tell resource group manager
ResourceGroupManager::getSingleton()._notifyResourceCreated(ret);
return prg;
}
ResourcePtr Statement::subject() const
{
const shared_ptr<Model::ModelPrivate> m = d ? d->model.lock() : shared_ptr<Model::ModelPrivate>();
return m ? m->resourceByID(d->subjectID) : ResourcePtr(new Resource);
}
ResourceWrapper::ResourceWrapper() : d(new ResourceWrapperPrivate)
{
d->resource = ResourcePtr( new Resource() );
}
ResourcePtr HardwareFactory::CreateFrontPanelInterruptResource()
{
return ResourcePtr(new NamedPipeResource(
FRONT_PANEL_INTERRUPT_READ_PIPE, 1));
}
ResourcePtr HardwareFactory::CreateMotorControllerInterruptResource()
{
return ResourcePtr(new NamedPipeResource(
MOTOR_CONTROLLER_INTERRUPT_READ_PIPE, 1));
}
//-----------------------------------------------------------------------
WorkQueue::Response* ResourceBackgroundQueue::handleRequest(const WorkQueue::Request* req, const WorkQueue* srcQ)
{
ResourceRequest resreq = any_cast<ResourceRequest>(req->getData());
if( req->getAborted() )
{
if( resreq.type == RT_PREPARE_RESOURCE || resreq.type == RT_LOAD_RESOURCE )
{
OGRE_DELETE_T(resreq.loadParams, NameValuePairList, MEMCATEGORY_GENERAL);
resreq.loadParams = 0;
}
resreq.result.error = false;
ResourceResponse resresp(ResourcePtr(), resreq);
return OGRE_NEW WorkQueue::Response(req, true, Any(resresp));
}
ResourceManager* rm = 0;
ResourcePtr resource;
try
{
switch (resreq.type)
{
case RT_INITIALISE_GROUP:
ResourceGroupManager::getSingleton().initialiseResourceGroup(
resreq.groupName);
break;
case RT_INITIALISE_ALL_GROUPS:
ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
break;
case RT_PREPARE_GROUP:
ResourceGroupManager::getSingleton().prepareResourceGroup(
resreq.groupName);
break;
case RT_LOAD_GROUP:
#if OGRE_THREAD_SUPPORT == 2
ResourceGroupManager::getSingleton().prepareResourceGroup(
resreq.groupName);
#else
ResourceGroupManager::getSingleton().loadResourceGroup(
resreq.groupName);
#endif
break;
case RT_UNLOAD_GROUP:
ResourceGroupManager::getSingleton().unloadResourceGroup(
resreq.groupName);
break;
case RT_PREPARE_RESOURCE:
rm = ResourceGroupManager::getSingleton()._getResourceManager(
resreq.resourceType);
resource = rm->prepare(resreq.resourceName, resreq.groupName, resreq.isManual,
resreq.loader, resreq.loadParams, true);
break;
case RT_LOAD_RESOURCE:
rm = ResourceGroupManager::getSingleton()._getResourceManager(
resreq.resourceType);
#if OGRE_THREAD_SUPPORT == 2
resource = rm->prepare(resreq.resourceName, resreq.groupName, resreq.isManual,
resreq.loader, resreq.loadParams, true);
#else
resource = rm->load(resreq.resourceName, resreq.groupName, resreq.isManual,
resreq.loader, resreq.loadParams, true);
#endif
break;
case RT_UNLOAD_RESOURCE:
rm = ResourceGroupManager::getSingleton()._getResourceManager(
resreq.resourceType);
if (resreq.resourceName.empty())
rm->unload(resreq.resourceHandle);
else
rm->unload(resreq.resourceName);
break;
};
}
catch (Exception& e)
{
if( resreq.type == RT_PREPARE_RESOURCE || resreq.type == RT_LOAD_RESOURCE )
{
OGRE_DELETE_T(resreq.loadParams, NameValuePairList, MEMCATEGORY_GENERAL);
resreq.loadParams = 0;
}
resreq.result.error = true;
resreq.result.message = e.getFullDescription();
// return error response
ResourceResponse resresp(resource, resreq);
return OGRE_NEW WorkQueue::Response(req, false, Any(resresp), e.getFullDescription());
}
// success
if( resreq.type == RT_PREPARE_RESOURCE || resreq.type == RT_LOAD_RESOURCE )
{
OGRE_DELETE_T(resreq.loadParams, NameValuePairList, MEMCATEGORY_GENERAL);
resreq.loadParams = 0;
}
resreq.result.error = false;
ResourceResponse resresp(resource, resreq);
return OGRE_NEW WorkQueue::Response(req, true, Any(resresp));
}
ResourceWrapper::ResourceWrapper(ResourcePtr resource) : d(new ResourceWrapperPrivate)
{
// if a null pointer is passed, we create a null resource
d->resource = !resource ? ResourcePtr( new Resource() ) : resource;
d->model = d->resource->model();
}
ResourcePtr IResourceManager::GrabUnusedResource()
{
if( m_sUnusedResources.size() > 0 )
return m_sUnusedResources.top_pop();
return ResourcePtr();
}
ResourceWeakPtr CMeshManager::CloneResource(const Resources::IResource* pSrcRes, xst_castring& strNewName /* = XST::StringUtil::EmptyAString */, bool bFullClone /* = true */)
{
XSTSimpleProfiler();
const Resources::CMesh* pSrcMesh = (const Resources::CMesh*)pSrcRes;
ul32 ulID = XST::CTime::GetQPerfTickCount();
if( strNewName.empty() )
{
//this->m_ssTmpName.str( XST::StringUtil::EmptyAString );
//this->m_ssTmpName << "xse_mesh_clone_" << ulID;
xst_sprintf( g_astrName, 128, "xse_mesh_clone_%d", ulID );
g_strName.assign( g_astrName );
}
ResourceWeakPtr pNewRes( this->CreateMesh( g_strName/*this->m_ssTmpName.str()*/, this->GetGroup( pSrcMesh->GetResourceGroupHandle() ) ) );
if( pNewRes == xst_null )
{
return pNewRes;
}
if( XST_FAILED( PrepareResource( &pNewRes ) ) )
{
this->DestroyResource( pNewRes );
return ResourcePtr();
}
{ XSTSimpleProfiler2( "clone mesh: set data" );
Resources::CMesh* pNewMesh = (Resources::CMesh*)pNewRes.GetPtr();
//if( bFullClone )
{
for(int i = 0; i < pSrcMesh->m_vLODs.size(); ++i)
{
/*SMeshLOD* pCurrLOD = pSrcMesh->m_vLODs[ i ];
SMeshLOD* pNewLOD = pNewMesh->CreateLOD();
pNewLOD->byID = pCurrLOD->byID;
pNewLOD->fDistance = pCurrLOD->fDistance;
pNewLOD->pIndexBuffer = pCurrLOD->pIndexBuffer;
pNewLOD->pMaterial = pCurrLOD->pMaterial;
pNewLOD->pVertexBuffer = pCurrLOD->pVertexBuffer;
pNewLOD->ulBeginIndexId = pCurrLOD->ulBeginIndexId;
pNewLOD->ulBeginVertexId = pCurrLOD->ulBeginVertexId;
pNewLOD->ulEndIndexId = pCurrLOD->ulEndIndexId;
pNewLOD->ulEndVertexId = pCurrLOD->ulEndVertexId;
pNewMesh->AddLOD( pNewLOD );*/
const SMeshLOD* pCurrLOD = &pSrcMesh->m_vLODs[ i ];
SMeshLOD& NewLOD = pNewMesh->AddLOD();
NewLOD.byID = pCurrLOD->byID;
NewLOD.fDistance = pCurrLOD->fDistance;
NewLOD.pIndexBuffer = pCurrLOD->pIndexBuffer;
NewLOD.pMaterial = pCurrLOD->pMaterial;
NewLOD.pVertexBuffer = pCurrLOD->pVertexBuffer;
NewLOD.ulBeginIndexId = pCurrLOD->ulBeginIndexId;
NewLOD.ulBeginVertexId = pCurrLOD->ulBeginVertexId;
NewLOD.ulEndIndexId = pCurrLOD->ulEndIndexId;
NewLOD.ulEndVertexId = pCurrLOD->ulEndVertexId;
}
}
/*else
{
SMeshLOD& LOD = pNewMesh->AddLOD();
}*/
pNewMesh->m_ulCloneId = ulID;
pNewMesh->m_bIsCloned = true;
pNewMesh->m_bIndexedGeometry = pSrcMesh->m_bIndexedGeometry;
pNewMesh->SetLOD( pSrcMesh->GetCurrentLODID() );
pNewMesh->SetResource( pSrcMesh );
pNewMesh->SetRenderableObject( pSrcMesh );
}
return pNewRes;
}
