Skip to content

A
angle
Commit 5f45e7c3 by Jamie Madill Committed by Commit Bot
Options

Refactor ResourceManagers.

This makes ResourceManagers use more common code. It uses static polymorphism to implement the various typed resource managers, and unifies the FramebufferManager into a TypedResourceManager. The lack of virtual calls and inlining in the header should keep performance high. This will make the upcoming refactor to add a destroy hook for Vulkan objects simpler to implement. TEST=manual performance testing of BindingPerf. BUG=angleproject:1684 BUG=angleproject:1639 Change-Id: Ic2f102196020d1005e63a1b2cf0867577fc7c885 Reviewed-on: https://chromium-review.googlesource.com/439488 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org>
parent 875bbba0
Showing with 247 additions and 272 deletions
src/libANGLE/Context.cpp
......@@ -616,7 +616,7 @@ void Context::deleteBuffer(GLuint buffer)
detachBuffer(buffer);
}
mState.mBuffers->deleteBuffer(buffer);
mState.mBuffers->deleteObject(buffer);
}
void Context::deleteShader(GLuint shader)
......@@ -636,7 +636,7 @@ void Context::deleteTexture(GLuint texture)
detachTexture(texture);
}
mState.mTextures->deleteTexture(texture);
mState.mTextures->deleteObject(texture);
}
void Context::deleteRenderbuffer(GLuint renderbuffer)
......@@ -646,7 +646,7 @@ void Context::deleteRenderbuffer(GLuint renderbuffer)
detachRenderbuffer(renderbuffer);
}
mState.mRenderbuffers->deleteRenderbuffer(renderbuffer);
mState.mRenderbuffers->deleteObject(renderbuffer);
}
void Context::deleteFenceSync(GLsync fenceSync)
......@@ -655,8 +655,7 @@ void Context::deleteFenceSync(GLsync fenceSync)
// wait commands finish. However, since the name becomes invalid, we cannot query the fence,
// and since our API is currently designed for being called from a single thread, we can delete
// the fence immediately.
mState.mFenceSyncs->deleteFenceSync(
static_cast<GLuint>(reinterpret_cast<uintptr_t>(fenceSync)));
mState.mFenceSyncs->deleteObject(static_cast<GLuint>(reinterpret_cast<uintptr_t>(fenceSync)));
}
void Context::deletePaths(GLuint first, GLsizei range)
......@@ -773,7 +772,7 @@ void Context::deleteSampler(GLuint sampler)
detachSampler(sampler);
}
mState.mSamplers->deleteSampler(sampler);
mState.mSamplers->deleteObject(sampler);
}
void Context::deleteTransformFeedback(GLuint transformFeedback)
......@@ -800,7 +799,7 @@ void Context::deleteFramebuffer(GLuint framebuffer)
detachFramebuffer(framebuffer);
}
mState.mFramebuffers->deleteFramebuffer(framebuffer);
mState.mFramebuffers->deleteObject(framebuffer);
}
void Context::deleteFenceNV(GLuint fence)
......
src/libANGLE/ResourceManager.cpp
......@@ -33,37 +33,6 @@ GLuint AllocateEmptyObject(HandleAllocator *handleAllocator, ResourceMap<Resourc
return handle;
}
template <typename ResourceType, typename CreationFunction>
GLuint InsertObject(HandleAllocator *handleAllocator,
ResourceMap<ResourceType> *objectMap,
const CreationFunction &func)
{
GLuint handle = handleAllocator->allocate();
(*objectMap)[handle] = func(handle);
return handle;
}
template <typename ResourceType, typename DeletionFunction>
void DeleteObject(HandleAllocator *handleAllocator,
ResourceMap<ResourceType> *objectMap,
GLuint handle,
const DeletionFunction &deletionFunc)
{
auto objectIter = objectMap->find(handle);
if (objectIter == objectMap->end())
{
return;
}
if (objectIter->second != nullptr)
{
deletionFunc(objectIter->second);
}
handleAllocator->release(objectIter->first);
objectMap->erase(objectIter);
}
template <typename ResourceType>
ResourceType *GetObject(const ResourceMap<ResourceType> &objectMap, GLuint handle)
{
......@@ -93,8 +62,8 @@ void ResourceManagerBase<HandleAllocatorType>::release()
}
}
template <typename ResourceType, typename HandleAllocatorType>
TypedResourceManager<ResourceType, HandleAllocatorType>::~TypedResourceManager()
template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::~TypedResourceManager()
{
while (!mObjectMap.empty())
{
......@@ -102,73 +71,114 @@ TypedResourceManager<ResourceType, HandleAllocatorType>::~TypedResourceManager()
}
}
template <typename ResourceType, typename HandleAllocatorType>
void TypedResourceManager<ResourceType, HandleAllocatorType>::deleteObject(GLuint handle)
template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
void TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::deleteObject(GLuint handle)
{
DeleteObject(&this->mHandleAllocator, &mObjectMap, handle,
[](ResourceType *object) { object->release(); });
}
// Instantiations of ResourceManager
template class ResourceManagerBase<HandleAllocator>;
template class ResourceManagerBase<HandleRangeAllocator>;
template class TypedResourceManager<Buffer, HandleAllocator>;
template class TypedResourceManager<Texture, HandleAllocator>;
template class TypedResourceManager<Renderbuffer, HandleAllocator>;
template class TypedResourceManager<Sampler, HandleAllocator>;
template class TypedResourceManager<FenceSync, HandleAllocator>;
GLuint BufferManager::createBuffer()
{
return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
}
void BufferManager::deleteBuffer(GLuint buffer)
{
deleteObject(buffer);
}
Buffer *BufferManager::getBuffer(GLuint handle) const
{
return GetObject(mObjectMap, handle);
}
Buffer *BufferManager::checkBufferAllocation(rx::GLImplFactory *factory, GLuint handle)
{
if (handle == 0)
auto objectIter = mObjectMap.find(handle);
if (objectIter == mObjectMap.end())
{
return nullptr;
return;
}
auto objectMapIter = mObjectMap.find(handle);
bool handleAllocated = (objectMapIter != mObjectMap.end());
if (handleAllocated && objectMapIter->second != nullptr)
if (objectIter->second != nullptr)
{
return objectMapIter->second;
ImplT::DeleteObject(objectIter->second);
}
Buffer *object = new Buffer(factory, handle);
object->addRef();
// Requires an explicit this-> because of C++ template rules.
this->mHandleAllocator.release(objectIter->first);
mObjectMap.erase(objectIter);
}
if (handleAllocated)
template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
template <typename... ArgTypes>
ResourceType *TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::allocateObject(
typename ResourceMap<ResourceType>::iterator &objectMapIter,
rx::GLImplFactory *factory,
GLuint handle,
ArgTypes... args)
{
ResourceType *object = ImplT::AllocateNewObject(factory, handle, args...);
if (objectMapIter != mObjectMap.end())
{
objectMapIter->second = object;
}
else
{
mHandleAllocator.reserve(handle);
this->mHandleAllocator.reserve(handle);
mObjectMap[handle] = object;
}
return object;
}
template class ResourceManagerBase<HandleAllocator>;
template class ResourceManagerBase<HandleRangeAllocator>;
template class TypedResourceManager<Buffer, HandleAllocator, BufferManager>;
template Buffer *TypedResourceManager<Buffer, HandleAllocator, BufferManager>::allocateObject(
ResourceMap<Buffer>::iterator &,
rx::GLImplFactory *,
GLuint);
template class TypedResourceManager<Texture, HandleAllocator, TextureManager>;
template Texture *TypedResourceManager<Texture, HandleAllocator, TextureManager>::allocateObject(
ResourceMap<Texture>::iterator &,
rx::GLImplFactory *,
GLuint,
GLenum);
template class TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>;
template Renderbuffer *
TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>::allocateObject(
ResourceMap<Renderbuffer>::iterator &,
rx::GLImplFactory *,
GLuint);
template class TypedResourceManager<Sampler, HandleAllocator, SamplerManager>;
template Sampler *TypedResourceManager<Sampler, HandleAllocator, SamplerManager>::allocateObject(
ResourceMap<Sampler>::iterator &,
rx::GLImplFactory *,
GLuint);
template class TypedResourceManager<FenceSync, HandleAllocator, FenceSyncManager>;
template class TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>;
template Framebuffer *
TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>::allocateObject(
ResourceMap<Framebuffer>::iterator &,
rx::GLImplFactory *,
GLuint,
const Caps &);
// BufferManager Implementation.
// static
Buffer *BufferManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
{
Buffer *buffer = new Buffer(factory, handle);
buffer->addRef();
return buffer;
}
// static
void BufferManager::DeleteObject(Buffer *buffer)
{
buffer->release();
}
GLuint BufferManager::createBuffer()
{
return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
}
Buffer *BufferManager::getBuffer(GLuint handle) const
{
return GetObject(mObjectMap, handle);
}
bool BufferManager::isBufferGenerated(GLuint buffer) const
{
return buffer == 0 || mObjectMap.find(buffer) != mObjectMap.end();
}
// ShaderProgramManager Implementation.
ShaderProgramManager::~ShaderProgramManager()
{
while (!mPrograms.empty())
......@@ -240,14 +250,25 @@ void ShaderProgramManager::deleteObject(ResourceMap<ObjectType> *objectMap, GLui
}
}
GLuint TextureManager::createTexture()
// TextureManager Implementation.
// static
Texture *TextureManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle, GLenum target)
{
return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
Texture *texture = new Texture(factory, handle, target);
texture->addRef();
return texture;
}
void TextureManager::deleteTexture(GLuint texture)
// static
void TextureManager::DeleteObject(Texture *texture)
{
texture->release();
}
GLuint TextureManager::createTexture()
{
deleteObject(texture);
return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
}
Texture *TextureManager::getTexture(GLuint handle) const
......@@ -256,42 +277,25 @@ Texture *TextureManager::getTexture(GLuint handle) const
return GetObject(mObjectMap, handle);
}
Texture *TextureManager::checkTextureAllocation(rx::GLImplFactory *factory,
GLuint handle,
GLenum type)
bool TextureManager::isTextureGenerated(GLuint texture) const
{
if (handle == 0)
{
return nullptr;
}
auto objectMapIter = mObjectMap.find(handle);
bool handleAllocated = (objectMapIter != mObjectMap.end());
if (handleAllocated && objectMapIter->second != nullptr)
{
return objectMapIter->second;
}
Texture *object = new Texture(factory, handle, type);
object->addRef();
return texture == 0 || mObjectMap.find(texture) != mObjectMap.end();
}
if (handleAllocated)
{
objectMapIter->second = object;
}
else
{
mHandleAllocator.reserve(handle);
mObjectMap[handle] = object;
}
// RenderbufferManager Implementation.
return object;
// static
Renderbuffer *RenderbufferManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
{
Renderbuffer *renderbuffer = new Renderbuffer(factory->createRenderbuffer(), handle);
renderbuffer->addRef();
return renderbuffer;
}
bool TextureManager::isTextureGenerated(GLuint texture) const
// static
void RenderbufferManager::DeleteObject(Renderbuffer *renderbuffer)
{
return texture == 0 || mObjectMap.find(texture) != mObjectMap.end();
renderbuffer->release();
}
GLuint RenderbufferManager::createRenderbuffer()
......@@ -299,51 +303,30 @@ GLuint RenderbufferManager::createRenderbuffer()
return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
}
void RenderbufferManager::deleteRenderbuffer(GLuint renderbuffer)
{
deleteObject(renderbuffer);
}
Renderbuffer *RenderbufferManager::getRenderbuffer(GLuint handle)
{
return GetObject(mObjectMap, handle);
}
Renderbuffer *RenderbufferManager::checkRenderbufferAllocation(rx::GLImplFactory *factory,
GLuint handle)
bool RenderbufferManager::isRenderbufferGenerated(GLuint renderbuffer) const
{
if (handle == 0)
{
return nullptr;
}
auto objectMapIter = mObjectMap.find(handle);
bool handleAllocated = (objectMapIter != mObjectMap.end());
if (handleAllocated && objectMapIter->second != nullptr)
{
return objectMapIter->second;
}
Renderbuffer *object = new Renderbuffer(factory->createRenderbuffer(), handle);
object->addRef();
return renderbuffer == 0 || mObjectMap.find(renderbuffer) != mObjectMap.end();
}
if (handleAllocated)
{
objectMapIter->second = object;
}
else
{
mHandleAllocator.reserve(handle);
mObjectMap[handle] = object;
}
// SamplerManager Implementation.
return object;
// static
Sampler *SamplerManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
{
Sampler *sampler = new Sampler(factory, handle);
sampler->addRef();
return sampler;
}
bool RenderbufferManager::isRenderbufferGenerated(GLuint renderbuffer) const
// static
void SamplerManager::DeleteObject(Sampler *sampler)
{
return renderbuffer == 0 || mObjectMap.find(renderbuffer) != mObjectMap.end();
sampler->release();
}
GLuint SamplerManager::createSampler()
......@@ -351,74 +334,31 @@ GLuint SamplerManager::createSampler()
return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
}
void SamplerManager::deleteSampler(GLuint sampler)
{
deleteObject(sampler);
}
Sampler *SamplerManager::getSampler(GLuint handle)
{
return GetObject(mObjectMap, handle);
}
Sampler *SamplerManager::checkSamplerAllocation(rx::GLImplFactory *factory, GLuint handle)
{
if (handle == 0)
{
return nullptr;
}
auto objectMapIter = mObjectMap.find(handle);
bool handleAllocated = (objectMapIter != mObjectMap.end());
if (handleAllocated && objectMapIter->second != nullptr)
{
return objectMapIter->second;
}
Sampler *object = new Sampler(factory, handle);
object->addRef();
if (handleAllocated)
{
objectMapIter->second = object;
}
else
{
mHandleAllocator.reserve(handle);
mObjectMap[handle] = object;
}
return object;
}
bool SamplerManager::isSampler(GLuint sampler)
{
return mObjectMap.find(sampler) != mObjectMap.end();
}
GLuint FenceSyncManager::createFenceSync(rx::GLImplFactory *factory)
{
struct fenceSyncAllocator
{
fenceSyncAllocator(rx::GLImplFactory *factory) : factory(factory) {}
rx::GLImplFactory *factory;
FenceSync *operator()(GLuint handle) const
{
FenceSync *fenceSync = new FenceSync(factory->createFenceSync(), handle);
fenceSync->addRef();
return fenceSync;
}
};
// FenceSyncManager Implementation.
return InsertObject(&mHandleAllocator, &mObjectMap, fenceSyncAllocator(factory));
// static
void FenceSyncManager::DeleteObject(FenceSync *fenceSync)
{
fenceSync->release();
}
void FenceSyncManager::deleteFenceSync(GLuint fenceSync)
GLuint FenceSyncManager::createFenceSync(rx::GLImplFactory *factory)
{
deleteObject(fenceSync);
GLuint handle = mHandleAllocator.allocate();
FenceSync *fenceSync = new FenceSync(factory->createFenceSync(), handle);
fenceSync->addRef();
mObjectMap[handle] = fenceSync;
return handle;
}
FenceSync *FenceSyncManager::getFenceSync(GLuint handle)
......@@ -426,6 +366,8 @@ FenceSync *FenceSyncManager::getFenceSync(GLuint handle)
return GetObject(mObjectMap, handle);
}
// PathManager Implementation.
ErrorOrResult<GLuint> PathManager::createPaths(rx::GLImplFactory *factory, GLsizei range)
{
// Allocate client side handles.
......@@ -485,70 +427,46 @@ PathManager::~PathManager()
}
}
FramebufferManager::~FramebufferManager()
{
for (auto framebuffer : mFramebuffers)
{
// Default framebuffer are owned by their respective Surface
if (framebuffer.second != nullptr && framebuffer.second->id() != 0)
{
SafeDelete(framebuffer.second);
}
}
}
// FramebufferManager Implementation.
GLuint FramebufferManager::createFramebuffer()
// static
Framebuffer *FramebufferManager::AllocateNewObject(rx::GLImplFactory *factory,
GLuint handle,
const Caps &caps)
{
return AllocateEmptyObject(&mHandleAllocator, &mFramebuffers);
return new Framebuffer(caps, factory, handle);
}
void FramebufferManager::deleteFramebuffer(GLuint framebuffer)
// static
void FramebufferManager::DeleteObject(Framebuffer *framebuffer)
{
DeleteObject(&mHandleAllocator, &mFramebuffers, framebuffer, [](Framebuffer *framebuffer) {
ASSERT(framebuffer->id() != 0);
// Default framebuffer are owned by their respective Surface
if (framebuffer->id() != 0)
{
delete framebuffer;
});
}
}
Framebuffer *FramebufferManager::checkFramebufferAllocation(rx::GLImplFactory *factory,
const Caps &caps,
GLuint handle)
GLuint FramebufferManager::createFramebuffer()
{
// Can be called from Bind without a prior call to Gen.
auto framebufferIt = mFramebuffers.find(handle);
bool neverCreated = framebufferIt == mFramebuffers.end();
if (neverCreated || framebufferIt->second == nullptr)
{
ASSERT(handle != 0);
Framebuffer *newFBO = new Framebuffer(caps, factory, handle);
if (neverCreated)
{
mHandleAllocator.reserve(handle);
mFramebuffers[handle] = newFBO;
return newFBO;
}
framebufferIt->second = newFBO;
}
return framebufferIt->second;
return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
}
Framebuffer *FramebufferManager::getFramebuffer(GLuint handle) const
{
return GetObject(mFramebuffers, handle);
return GetObject(mObjectMap, handle);
}
void FramebufferManager::setDefaultFramebuffer(Framebuffer *framebuffer)
{
ASSERT(framebuffer == nullptr || framebuffer->id() == 0);
mFramebuffers[0] = framebuffer;
mObjectMap[0] = framebuffer;
}
bool FramebufferManager::isFramebufferGenerated(GLuint framebuffer)
{
ASSERT(mFramebuffers.find(0) != mFramebuffers.end());
return mFramebuffers.find(framebuffer) != mFramebuffers.end();
ASSERT(mObjectMap.find(0) != mObjectMap.end());
return mObjectMap.find(framebuffer) != mObjectMap.end();
}
} // namespace gl
src/libANGLE/ResourceManager.h
......@@ -54,29 +54,61 @@ class ResourceManagerBase : angle::NonCopyable
size_t mRefCount;
};
template <typename ResourceType, typename HandleAllocatorType>
template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
class TypedResourceManager : public ResourceManagerBase<HandleAllocatorType>
{
public:
TypedResourceManager() {}
void deleteObject(GLuint handle);
protected:
~TypedResourceManager() override;
void deleteObject(GLuint handle);
// Inlined in the header for performance.
template <typename... ArgTypes>
ResourceType *checkObjectAllocation(rx::GLImplFactory *factory, GLuint handle, ArgTypes... args)
{
auto objectMapIter = mObjectMap.find(handle);
if (objectMapIter != mObjectMap.end() && objectMapIter->second != nullptr)
{
return objectMapIter->second;
}
if (handle == 0)
{
return nullptr;
}
return allocateObject<ArgTypes...>(objectMapIter, factory, handle, args...);
}
template <typename... ArgTypes>
ResourceType *allocateObject(typename ResourceMap<ResourceType>::iterator &objectMapIter,
rx::GLImplFactory *factory,
GLuint handle,
ArgTypes... args);
ResourceMap<ResourceType> mObjectMap;
};
class BufferManager : public TypedResourceManager<Buffer, HandleAllocator>
class BufferManager : public TypedResourceManager<Buffer, HandleAllocator, BufferManager>
{
public:
GLuint createBuffer();
void deleteBuffer(GLuint buffer);
Buffer *getBuffer(GLuint handle) const;
Buffer *checkBufferAllocation(rx::GLImplFactory *factory, GLuint handle);
bool isBufferGenerated(GLuint buffer) const;
Buffer *checkBufferAllocation(rx::GLImplFactory *factory, GLuint handle)
{
return checkObjectAllocation(factory, handle);
}
// TODO(jmadill): Investigate design which doesn't expose these methods publicly.
static Buffer *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle);
static void DeleteObject(Buffer *buffer);
protected:
~BufferManager() override {}
};
......@@ -105,52 +137,72 @@ class ShaderProgramManager : public ResourceManagerBase<HandleAllocator>
ResourceMap<Program> mPrograms;
};
class TextureManager : public TypedResourceManager<Texture, HandleAllocator>
class TextureManager : public TypedResourceManager<Texture, HandleAllocator, TextureManager>
{
public:
GLuint createTexture();
void deleteTexture(GLuint texture);
Texture *getTexture(GLuint handle) const;
Texture *checkTextureAllocation(rx::GLImplFactory *factory, GLuint handle, GLenum type);
bool isTextureGenerated(GLuint texture) const;
Texture *checkTextureAllocation(rx::GLImplFactory *factory, GLuint handle, GLenum target)
{
return checkObjectAllocation(factory, handle, target);
}
static Texture *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle, GLenum target);
static void DeleteObject(Texture *texture);
protected:
~TextureManager() override {}
};
class RenderbufferManager : public TypedResourceManager<Renderbuffer, HandleAllocator>
class RenderbufferManager
: public TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>
{
public:
GLuint createRenderbuffer();
void deleteRenderbuffer(GLuint renderbuffer);
Renderbuffer *getRenderbuffer(GLuint handle);
Renderbuffer *checkRenderbufferAllocation(rx::GLImplFactory *factory, GLuint handle);
bool isRenderbufferGenerated(GLuint renderbuffer) const;
Renderbuffer *checkRenderbufferAllocation(rx::GLImplFactory *factory, GLuint handle)
{
return checkObjectAllocation(factory, handle);
}
static Renderbuffer *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle);
static void DeleteObject(Renderbuffer *renderbuffer);
protected:
~RenderbufferManager() override {}
};
class SamplerManager : public TypedResourceManager<Sampler, HandleAllocator>
class SamplerManager : public TypedResourceManager<Sampler, HandleAllocator, SamplerManager>
{
public:
GLuint createSampler();
void deleteSampler(GLuint sampler);
Sampler *getSampler(GLuint handle);
Sampler *checkSamplerAllocation(rx::GLImplFactory *factory, GLuint handle);
bool isSampler(GLuint sampler);
Sampler *checkSamplerAllocation(rx::GLImplFactory *factory, GLuint handle)
{
return checkObjectAllocation(factory, handle);
}
static Sampler *AllocateNewObject(rx::GLImplFactory *factory, GLuint handle);
static void DeleteObject(Sampler *sampler);
protected:
~SamplerManager() override {}
};
class FenceSyncManager : public TypedResourceManager<FenceSync, HandleAllocator>
class FenceSyncManager : public TypedResourceManager<FenceSync, HandleAllocator, FenceSyncManager>
{
public:
GLuint createFenceSync(rx::GLImplFactory *factory);
void deleteFenceSync(GLuint fenceSync);
FenceSync *getFenceSync(GLuint handle);
static void DeleteObject(FenceSync *fenceSync);
protected:
~FenceSyncManager() override {}
};
......@@ -170,23 +222,29 @@ class PathManager : public ResourceManagerBase<HandleRangeAllocator>
ResourceMap<Path> mPaths;
};
class FramebufferManager : public ResourceManagerBase<HandleAllocator>
class FramebufferManager
: public TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>
{
public:
GLuint createFramebuffer();
void deleteFramebuffer(GLuint framebuffer);
Framebuffer *checkFramebufferAllocation(rx::GLImplFactory *factory,
const Caps &caps,
GLuint handle);
Framebuffer *getFramebuffer(GLuint handle) const;
void setDefaultFramebuffer(Framebuffer *framebuffer);
bool isFramebufferGenerated(GLuint framebuffer);
protected:
~FramebufferManager() override;
Framebuffer *checkFramebufferAllocation(rx::GLImplFactory *factory,
const Caps &caps,
GLuint handle)
{
return checkObjectAllocation<const Caps &>(factory, handle, caps);
}
private:
ResourceMap<Framebuffer> mFramebuffers;
static Framebuffer *AllocateNewObject(rx::GLImplFactory *factory,
GLuint handle,
const Caps &caps);
static void DeleteObject(Framebuffer *framebuffer);
protected:
~FramebufferManager() override {}
};
} // namespace gl
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment