Archive *Find(String &filename) {
ResourceGroup* grp = getResourceGroup("General");
if (!grp)
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate a resource group called 'General'", "ResourceGroupManager::openResource");
OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME) // lock group mutex
ResourceLocationIndex::iterator rit = grp->resourceIndexCaseSensitive.find(filename);
if (rit != grp->resourceIndexCaseSensitive.end()) {
// Found in the index
Archive *fileArchive = rit->second;
filename = fileArchive->getName() + "/" + filename;
return fileArchive;
}
return NULL;
}
HardwareVertexBufferSharedPtr
GLESHardwareBufferManagerBase::createVertexBuffer(size_t vertexSize,
size_t numVerts,
HardwareBuffer::Usage usage,
bool useShadowBuffer)
{
// always use shadowBuffer
GLESHardwareVertexBuffer* buf =
OGRE_NEW GLESHardwareVertexBuffer(this, vertexSize, numVerts, usage, true);
{
OGRE_LOCK_MUTEX(mVertexBuffersMutex);
mVertexBuffers.insert(buf);
}
return HardwareVertexBufferSharedPtr(buf);
}
//---------------------------------------------------------------------
void DefaultWorkQueueBase::abortPendingRequestsByChannel(uint16 channel)
{
{
OGRE_LOCK_MUTEX(mRequestMutex);
for (RequestQueue::iterator i = mRequestQueue.begin(); i != mRequestQueue.end(); ++i)
{
if ((*i)->getChannel() == channel)
{
(*i)->abortRequest();
}
}
}
{
OGRE_LOCK_MUTEX(mIdleMutex);
for (RequestQueue::iterator i = mIdleRequestQueue.begin(); i != mIdleRequestQueue.end(); ++i)
{
if ((*i)->getChannel() == channel)
{
(*i)->abortRequest();
}
}
}
}
//-----------------------------------------------------------------------
void Resource::_firePreparingComplete(bool wasBackgroundLoaded)
{
// Lock the listener list
OGRE_LOCK_MUTEX(mListenerListMutex);
for (ListenerList::iterator i = mListenerList.begin();
i != mListenerList.end(); ++i)
{
// deprecated call
if (wasBackgroundLoaded)
(*i)->backgroundPreparingComplete(this);
(*i)->preparingComplete(this);
}
}
//-----------------------------------------------------------------------
HardwareIndexBufferSharedPtr
D3D11HardwareBufferManagerBase::
createIndexBuffer(HardwareIndexBuffer::IndexType itype, size_t numIndexes,
HardwareBuffer::Usage usage, bool useShadowBuffer)
{
assert(numIndexes > 0);
D3D11HardwareIndexBuffer* idx = new D3D11HardwareIndexBuffer(
this, itype, numIndexes, usage, mlpD3DDevice, false, useShadowBuffer);
{
OGRE_LOCK_MUTEX(mIndexBuffersMutex);
mIndexBuffers.insert(idx);
}
return HardwareIndexBufferSharedPtr(idx);
}
void* GL3PlusHardwareBufferManagerBase::allocateScratch(uint32 size)
{
// simple forward link search based on alloc sizes
// not that fast but the list should never get that long since not many
// locks at once (hopefully)
OGRE_LOCK_MUTEX(mScratchMutex);
// Alignment - round up the size to 32 bits
// control blocks are 32 bits too so this packs nicely
if (size % 4 != 0)
{
size += 4 - (size % 4);
}
uint32 bufferPos = 0;
while (bufferPos < SCRATCH_POOL_SIZE)
{
GL3PlusScratchBufferAlloc* pNext = (GL3PlusScratchBufferAlloc*)(mScratchBufferPool + bufferPos);
// Big enough?
if (pNext->free && pNext->size >= size)
{
// split? And enough space for control block
if(pNext->size > size + sizeof(GL3PlusScratchBufferAlloc))
{
uint32 offset = (uint32)sizeof(GL3PlusScratchBufferAlloc) + size;
GL3PlusScratchBufferAlloc* pSplitAlloc = (GL3PlusScratchBufferAlloc*)
(mScratchBufferPool + bufferPos + offset);
pSplitAlloc->free = 1;
// split size is remainder minus new control block
pSplitAlloc->size = pNext->size - size - sizeof(GL3PlusScratchBufferAlloc);
// New size of current
pNext->size = size;
}
// allocate and return
pNext->free = 0;
// return pointer just after this control block (++ will do that for us)
return ++pNext;
}
bufferPos += (uint32)sizeof(GL3PlusScratchBufferAlloc) + pNext->size;
}
// no available alloc
return 0;
}
/**
* @author Blakharaz
* @date 03-14-2005
*/
SoundResourcePtr& SoundResourcePtr::operator =(const ResourcePtr& res)
{
if (pRep == static_cast<SoundResource*>(res.getPointer()))
return *this;
release();
// lock & copy other mutex pointer
OGRE_LOCK_MUTEX(*res.OGRE_AUTO_MUTEX_NAME)
OGRE_COPY_AUTO_SHARED_MUTEX(res.OGRE_AUTO_MUTEX_NAME)
pRep = static_cast<SoundResource*>(res.getPointer());
pUseCount = res.useCountPointer();
if (pUseCount != 0)
++(*pUseCount);
return *this;
}
//----------------------------------------------------------------------------
bool ZenStringInterface::createParamDictionary(const String& _className)
{
OGRE_LOCK_MUTEX( msDictionaryMutex )
ZenDictionaryMap::iterator it = msDictionaryMap.find(_className);
if(it == msDictionaryMap.end())
{
it = msDictionaryMap.insert( std::make_pair( _className, new ZenParamDictionary ) ).first;
mParamDictionary = it->second;
mParamDictionary->mIterator = it;
}
else
{
mParamDictionary = it->second;
}
return (++mParamDictionary->mUseCount) == 1;
}
//---------------------------------------------------------------------
Ogre::HardwareUniformBufferSharedPtr GLES2HardwareBufferManagerBase::createUniformBuffer( size_t sizeBytes, HardwareBuffer::Usage usage, bool useShadowBuffer, const String& name )
{
#if OGRE_NO_GLES3_SUPPORT == 0
GLES2HardwareUniformBuffer* buf =
new GLES2HardwareUniformBuffer(this, sizeBytes, usage, useShadowBuffer, name);
{
OGRE_LOCK_MUTEX(mUniformBuffersMutex);
mUniformBuffers.insert(buf);
}
return HardwareUniformBufferSharedPtr(buf);
#else
OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR,
"GLES2 does not support uniform buffer objects",
"GLES2HardwareBufferManagerBase::createUniformBuffer");
#endif
}
//-----------------------------------------------------------------------
void D3D9ResourceManager::_notifyResourceDestroyed(D3D9Resource* pResource)
{
OGRE_LOCK_MUTEX(mResourcesMutex)
ResourceContainerIterator it = mResources.begin();
while (it != mResources.end())
{
if ((*it) == pResource)
{
mResources.erase(it);
break;
}
++it;
}
}
//-----------------------------------------------------------------------
void HardwareBufferManagerBase::releaseVertexBufferCopy(
const HardwareVertexBufferSharedPtr& bufferCopy)
{
OGRE_LOCK_MUTEX(mTempBuffersMutex);
TemporaryVertexBufferLicenseMap::iterator i =
mTempVertexBufferLicenses.find(bufferCopy.get());
if (i != mTempVertexBufferLicenses.end())
{
const VertexBufferLicense& vbl = i->second;
vbl.licensee->licenseExpired(vbl.buffer.get());
mFreeTempVertexBufferMap.insert(
FreeTemporaryVertexBufferMap::value_type(vbl.originalBufferPtr, vbl.buffer));
mTempVertexBufferLicenses.erase(i);
}
}
HardwareIndexBufferSharedPtr GLES2HardwareBufferManagerBase::createIndexBuffer(HardwareIndexBuffer::IndexType itype,
size_t numIndexes,
HardwareBuffer::Usage usage,
bool useShadowBuffer)
{
GLES2HardwareIndexBuffer* buf = 0;
if(getGLES2SupportRef()->checkExtension("GL_EXT_map_buffer_range") || gleswIsSupported(3, 0))
buf = OGRE_NEW GLES2HardwareIndexBuffer(this, itype, numIndexes, usage, useShadowBuffer);
else
// always use shadowBuffer
buf = OGRE_NEW GLES2HardwareIndexBuffer(this, itype, numIndexes, usage, true);
{
OGRE_LOCK_MUTEX(mIndexBuffersMutex);
mIndexBuffers.insert(buf);
}
return HardwareIndexBufferSharedPtr(buf);
}
//---------------------------------------------------------------------
//---------------------------------------------------------------------
void* GLHardwareBufferManagerBase::allocateScratch(uint32 size)
{
// simple forward link search based on alloc sizes
// not that fast but the list should never get that long since not many
// locks at once (hopefully)
OGRE_LOCK_MUTEX(mScratchMutex);
// Alignment - round up the size to OGRE_SIMD_ALIGNMENT bits
// control blocks are 32 bits which should give enough space.
size += 2*OGRE_SIMD_ALIGNMENT - (size % OGRE_SIMD_ALIGNMENT);
uint32 bufferPos = 0;
while (bufferPos < SCRATCH_POOL_SIZE)
{
GLScratchBufferAlloc* pNext = (GLScratchBufferAlloc*)(mScratchBufferPool + bufferPos);
// Big enough?
if (pNext->free && pNext->size >= size)
{
uint32 offset = size;
GLScratchBufferAlloc* pSplitAlloc = (GLScratchBufferAlloc*)
(mScratchBufferPool + bufferPos + offset);
pSplitAlloc->free = 1;
// split size is remainder minus new control block
pSplitAlloc->size = pNext->size - size;
// New size of current
pNext->size = size;
// allocate and return
pNext->free = 0;
// return pointer just after this control block that is also multiple of alignment
return (char*)(pNext) + OGRE_SIMD_ALIGNMENT;
}
bufferPos += pNext->size;
}
// no available alloc
return 0;
}
//-----------------------------------------------------------------------
Polygon* ConvexBody::allocatePolygon()
{
OGRE_LOCK_MUTEX(msFreePolygonsMutex);
if (msFreePolygons.empty())
{
// if we ran out of polys to use, create a new one
// hopefully this one will return to the pool in due course
return OGRE_NEW_T(Polygon, MEMCATEGORY_SCENE_CONTROL)();
}
else
{
Polygon* ret = msFreePolygons.back();
ret->reset();
msFreePolygons.pop_back();
return ret;
}
}
//-----------------------------------------------------------------------
void Resource::unload(void)
{
// Early-out without lock (mitigate perf cost of ensuring unloaded)
if (mLoadingState != LOADSTATE_LOADED)
return;
// Scope lock for loading status
{
OGRE_LOCK_MUTEX(mLoadingStatusMutex)
if (mLoadingState == LOADSTATE_LOADING)
{
OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
"Cannot unload resource " + mName + " whilst loading is in progress!",
"Resource::unload");
}
if (mLoadingState != LOADSTATE_LOADED)
return; // nothing to do
mLoadingState = LOADSTATE_UNLOADING;
}
// Scope lock for actual unload
{
OGRE_LOCK_AUTO_MUTEX
preUnloadImpl();
unloadImpl();
postUnloadImpl();
}
// Scope lock for loading status
{
OGRE_LOCK_MUTEX(mLoadingStatusMutex)
mLoadingState = LOADSTATE_UNLOADED;
}
// Notify manager
if(mCreator)
mCreator->_notifyResourceUnloaded(this);
}
void PCZSceneManager::_calcZonesAffectedByLights(Camera * cam)
{
MovableObjectCollection* lights =
getMovableObjectCollection(PCZLightFactory::FACTORY_TYPE_NAME);
{
OGRE_LOCK_MUTEX(lights->mutex)
MovableObjectIterator it(lights->map.begin(), lights->map.end());
while(it.hasMoreElements())
{
PCZLight* l = static_cast<PCZLight*>(it.getNext());
if(l->getNeedsUpdate())
{
// only update if necessary
l->updateZones(((PCZSceneNode*)(cam->getParentSceneNode()))->getHomeZone(), mFrameCount);
}
// clear update flag
l->clearNeedsUpdate();
}
}
}
//---------------------------------------------------------------------
AnimationStateSet::AnimationStateSet(const AnimationStateSet& rhs)
: mDirtyFrameNumber(std::numeric_limits<unsigned long>::max())
{
// lock rhs
OGRE_LOCK_MUTEX(rhs.OGRE_AUTO_MUTEX_NAME);
for (AnimationStateMap::const_iterator i = rhs.mAnimationStates.begin();
i != rhs.mAnimationStates.end(); ++i)
{
AnimationState* src = i->second;
mAnimationStates[src->getAnimationName()] =
OGRE_NEW AnimationState(this, *src);
}
// Clone enabled animation state list
for (EnabledAnimationStateList::const_iterator it = rhs.mEnabledAnimationStates.begin();
it != rhs.mEnabledAnimationStates.end(); ++it)
{
const AnimationState* src = *it;
mEnabledAnimationStates.push_back(getAnimationState(src->getAnimationName()));
}
}
//---------------------------------------------------------------------
void DefaultWorkQueueBase::processResponses()
{
unsigned long msStart = Root::getSingleton().getTimer()->getMilliseconds();
unsigned long msCurrent = 0;
// keep going until we run out of responses or out of time
while(true)
{
Response* response = 0;
{
OGRE_LOCK_MUTEX(mResponseMutex);
if (mResponseQueue.empty())
break; // exit loop
else
{
response = mResponseQueue.front();
mResponseQueue.pop_front();
}
}
if (response)
{
processResponse(response);
OGRE_DELETE response;
}
// time limit
if (mResposeTimeLimitMS)
{
msCurrent = Root::getSingleton().getTimer()->getMilliseconds();
if (msCurrent - msStart > mResposeTimeLimitMS)
break;
}
}
}
//---------------------------------------------------------------------
void AnimationStateSet::copyMatchingState(AnimationStateSet* target) const
{
// lock target
OGRE_LOCK_MUTEX(target->OGRE_AUTO_MUTEX_NAME);
// lock source
OGRE_LOCK_AUTO_MUTEX;
AnimationStateMap::iterator i, iend;
iend = target->mAnimationStates.end();
for (i = target->mAnimationStates.begin(); i != iend; ++i) {
AnimationStateMap::const_iterator iother = mAnimationStates.find(i->first);
if (iother == mAnimationStates.end()) {
OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "No animation entry found named " + i->first,
"AnimationStateSet::copyMatchingState");
} else {
i->second->copyStateFrom(*(iother->second));
}
}
// Copy matching enabled animation state list
target->mEnabledAnimationStates.clear();
EnabledAnimationStateList::const_iterator it, itend;
itend = mEnabledAnimationStates.end();
for (it = mEnabledAnimationStates.begin(); it != itend; ++it)
{
const AnimationState* src = *it;
AnimationStateMap::const_iterator itarget = target->mAnimationStates.find(src->getAnimationName());
if (itarget != target->mAnimationStates.end())
{
target->mEnabledAnimationStates.push_back(itarget->second);
}
}
target->mDirtyFrameNumber = mDirtyFrameNumber;
}
//-----------------------------------------------------------------------
HardwareUniformBufferSharedPtr
D3D11HardwareBufferManagerBase::createUniformBuffer(size_t sizeBytes, HardwareBuffer::Usage usage, bool useShadowBuffer, const String& name)
{
assert(sizeBytes > 0);
D3D11HardwareUniformBuffer* uni = 0;
/*
if (name != "")
{
SharedUniformBufferMap::iterator it = mSharedUniformBuffers.find(name);
if (it != mSharedUniformBuffers.end())
{
uni = static_cast<D3D11HardwareUniformBuffer*>(it->second);
assert (uni->getSizeInBytes() == sizeBytes);
assert (uni->getUsage() == usage);
}
else
{
uni = new D3D11HardwareUniformBuffer(this, sizeBytes, usage, useShadowBuffer, name, mlpD3DDevice);
{
OGRE_LOCK_MUTEX(mUniformBuffersMutex)
mUniformBuffers.insert(uni);
//mSharedUniformBuffers.insert(std::make_pair(name, uni));
}
}
}
else
{*/
uni = new D3D11HardwareUniformBuffer(this, sizeBytes, usage, useShadowBuffer, name, mlpD3DDevice);
{
OGRE_LOCK_MUTEX(mUniformBuffersMutex);
mUniformBuffers.insert(uni);
}
//}
return HardwareUniformBufferSharedPtr(uni);
}
//-----------------------------------------------------------------------
void HardwareBufferManagerBase::destroyVertexDeclaration(VertexDeclaration* decl)
{
OGRE_LOCK_MUTEX(mVertexDeclarationsMutex)
mVertexDeclarations.erase(decl);
destroyVertexDeclarationImpl(decl);
}
//-----------------------------------------------------------------------
void HardwareBufferManagerBase::destroyVertexBufferBinding(VertexBufferBinding* binding)
{
OGRE_LOCK_MUTEX(mVertexBufferBindingsMutex)
mVertexBufferBindings.erase(binding);
destroyVertexBufferBindingImpl(binding);
}
//-----------------------------------------------------------------------
void Resource::removeListener(Resource::Listener* lis)
{
// O(n) but not called very often
OGRE_LOCK_MUTEX(mListenerListMutex);
mListenerList.erase(lis);
}
//-----------------------------------------------------------------------
void Resource::addListener(Resource::Listener* lis)
{
OGRE_LOCK_MUTEX(mListenerListMutex);
mListenerList.insert(lis);
}
//---------------------------------------------------------------------
void CgProgram::recurseParams(CGparameter parameter, size_t contextArraySize)
{
while (parameter != 0)
{
// Look for uniform parameters only
// Don't bother enumerating unused parameters, especially since they will
// be optimised out and therefore not in the indexed versions
CGtype paramType = cgGetParameterType(parameter);
if (cgGetParameterVariability(parameter) == CG_UNIFORM &&
paramType != CG_SAMPLER1D &&
paramType != CG_SAMPLER2D &&
paramType != CG_SAMPLER3D &&
paramType != CG_SAMPLERCUBE &&
paramType != CG_SAMPLERRECT &&
cgGetParameterDirection(parameter) != CG_OUT &&
cgIsParameterReferenced(parameter))
{
int arraySize;
switch(paramType)
{
case CG_STRUCT:
recurseParams(cgGetFirstStructParameter(parameter));
break;
case CG_ARRAY:
// Support only 1-dimensional arrays
arraySize = cgGetArraySize(parameter, 0);
recurseParams(cgGetArrayParameter(parameter, 0), (size_t)arraySize);
break;
default:
// Normal path (leaf)
String paramName = cgGetParameterName(parameter);
size_t logicalIndex = cgGetParameterResourceIndex(parameter);
// Get the parameter resource, to calculate the physical index
CGresource res = cgGetParameterResource(parameter);
bool isRegisterCombiner = false;
size_t regCombinerPhysicalIndex = 0;
switch (res)
{
case CG_COMBINER_STAGE_CONST0:
// register combiner, const 0
// the index relates to the texture stage; store this as (stage * 2) + 0
regCombinerPhysicalIndex = logicalIndex * 2;
isRegisterCombiner = true;
break;
case CG_COMBINER_STAGE_CONST1:
// register combiner, const 1
// the index relates to the texture stage; store this as (stage * 2) + 1
regCombinerPhysicalIndex = (logicalIndex * 2) + 1;
isRegisterCombiner = true;
break;
default:
// normal constant
break;
}
// Trim the '[0]' suffix if it exists, we will add our own indexing later
if (StringUtil::endsWith(paramName, "[0]", false))
{
paramName.erase(paramName.size() - 3);
}
GpuConstantDefinition def;
def.arraySize = contextArraySize;
mapTypeAndElementSize(paramType, isRegisterCombiner, def);
if (def.constType == GCT_UNKNOWN)
{
LogManager::getSingleton().logMessage(
"Problem parsing the following Cg Uniform: '"
+ paramName + "' in file " + mName);
// next uniform
parameter = cgGetNextParameter(parameter);
continue;
}
if (isRegisterCombiner)
{
def.physicalIndex = regCombinerPhysicalIndex;
}
else
{
// base position on existing buffer contents
if (def.isFloat())
{
def.physicalIndex = mFloatLogicalToPhysical->bufferSize;
}
else
{
def.physicalIndex = mIntLogicalToPhysical->bufferSize;
}
}
def.logicalIndex = logicalIndex;
if( mParametersMap.find(paramName) == mParametersMap.end())
{
mParametersMap.insert(GpuConstantDefinitionMap::value_type(paramName, def));
mParametersMapSizeAsBuffer += sizeof(size_t);
mParametersMapSizeAsBuffer += paramName.size();
mParametersMapSizeAsBuffer += sizeof(GpuConstantDefinition);
}
// Record logical / physical mapping
if (def.isFloat())
{
OGRE_LOCK_MUTEX(mFloatLogicalToPhysical->mutex);
mFloatLogicalToPhysical->map.insert(
GpuLogicalIndexUseMap::value_type(def.logicalIndex,
GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize, GPV_GLOBAL)));
mFloatLogicalToPhysical->bufferSize += def.arraySize * def.elementSize;
}
else
{
OGRE_LOCK_MUTEX(mIntLogicalToPhysical->mutex);
mIntLogicalToPhysical->map.insert(
GpuLogicalIndexUseMap::value_type(def.logicalIndex,
GpuLogicalIndexUse(def.physicalIndex, def.arraySize * def.elementSize, GPV_GLOBAL)));
mIntLogicalToPhysical->bufferSize += def.arraySize * def.elementSize;
}
break;
}
}
// now handle uniform samplers. This is needed to fix their register positions
// if delegating to a GLSL shader.
if (mDelegate && cgGetParameterVariability(parameter) == CG_UNIFORM && (
paramType == CG_SAMPLER1D ||
paramType == CG_SAMPLER2D ||
paramType == CG_SAMPLER3D ||
paramType == CG_SAMPLERCUBE ||
paramType == CG_SAMPLERRECT) &&
cgGetParameterDirection(parameter) != CG_OUT &&
cgIsParameterReferenced(parameter))
{
String paramName = cgGetParameterName(parameter);
CGresource res = cgGetParameterResource(parameter);
int pos = -1;
switch (res)
{
case CG_TEXUNIT0: pos = 0; break;
case CG_TEXUNIT1: pos = 1; break;
case CG_TEXUNIT2: pos = 2; break;
case CG_TEXUNIT3: pos = 3; break;
case CG_TEXUNIT4: pos = 4; break;
case CG_TEXUNIT5: pos = 5; break;
case CG_TEXUNIT6: pos = 6; break;
case CG_TEXUNIT7: pos = 7; break;
case CG_TEXUNIT8: pos = 8; break;
case CG_TEXUNIT9: pos = 9; break;
case CG_TEXUNIT10: pos = 10; break;
case CG_TEXUNIT11: pos = 11; break;
case CG_TEXUNIT12: pos = 12; break;
case CG_TEXUNIT13: pos = 13; break;
case CG_TEXUNIT14: pos = 14; break;
case CG_TEXUNIT15: pos = 15; break;
#if(CG_VERSION_NUM >= 3000)
case CG_TEXUNIT16: pos = 16; break;
case CG_TEXUNIT17: pos = 17; break;
case CG_TEXUNIT18: pos = 18; break;
case CG_TEXUNIT19: pos = 19; break;
case CG_TEXUNIT20: pos = 20; break;
case CG_TEXUNIT21: pos = 21; break;
case CG_TEXUNIT22: pos = 22; break;
case CG_TEXUNIT23: pos = 23; break;
case CG_TEXUNIT24: pos = 24; break;
case CG_TEXUNIT25: pos = 25; break;
case CG_TEXUNIT26: pos = 26; break;
case CG_TEXUNIT27: pos = 27; break;
case CG_TEXUNIT28: pos = 28; break;
case CG_TEXUNIT29: pos = 29; break;
case CG_TEXUNIT30: pos = 30; break;
case CG_TEXUNIT31: pos = 31; break;
#endif
default:
break;
}
if (pos != -1)
{
mSamplerRegisterMap.insert(std::make_pair(paramName, pos));
}
}
// Get next
parameter = cgGetNextParameter(parameter);
}
}
//---------------------------------------------------------------------
void DefaultWorkQueueBase::processRequestResponse(Request* r, bool synchronous)
{
Response* response = processRequest(r);
OGRE_LOCK_MUTEX(mProcessMutex);
RequestQueue::iterator it;
for( it = mProcessQueue.begin(); it != mProcessQueue.end(); ++it )
{
if( (*it) == r )
{
mProcessQueue.erase( it );
break;
}
}
if( mIdleProcessed == r )
{
mIdleProcessed = 0;
}
if (response)
{
if (!response->succeeded())
{
// Failed, should we retry?
const Request* req = response->getRequest();
if (req->getRetryCount())
{
addRequestWithRID(req->getID(), req->getChannel(), req->getType(), req->getData(),
req->getRetryCount() - 1);
// discard response (this also deletes request)
OGRE_DELETE response;
return;
}
}
if (synchronous)
{
processResponse(response);
OGRE_DELETE response;
}
else
{
if( response->getRequest()->getAborted() )
{
// destroy response user data
response->abortRequest();
}
// Queue response
OGRE_LOCK_MUTEX(mResponseMutex);
mResponseQueue.push_back(response);
// no need to wake thread, this is processed by the main thread
}
}
else
{
// no response, delete request
LogManager::getSingleton().stream() <<
"DefaultWorkQueueBase('" << mName << "') warning: no handler processed request "
<< r->getID() << ", channel " << r->getChannel()
<< ", type " << r->getType();
OGRE_DELETE r;
}
}
//---------------------------------------------------------------------
void DefaultWorkQueueBase::setRequestsAccepted(bool accept)
{
OGRE_LOCK_MUTEX(mRequestMutex);
mAcceptRequests = accept;
}
//---------------------------------------------------------------------
void DefaultWorkQueueBase::setPaused(bool pause)
{
OGRE_LOCK_MUTEX(mRequestMutex);
mPaused = pause;
}
//-----------------------------------------------------------------------
void D3D9ResourceManager::_notifyResourceCreated(D3D9Resource* pResource)
{
OGRE_LOCK_MUTEX(mResourcesMutex)
mResources.push_back(pResource);
}
//-----------------------------------------------------------------------
void StringInterface::cleanupDictionary ()
{
OGRE_LOCK_MUTEX( msDictionaryMutex );
msDictionary.clear();
}
