blob: a2e944dd882e9da950731abaaba1cc10263b5990 [file] [log] [blame]
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +00001//
Geoff Lang4ddf5af2016-12-01 14:30:44 -05002// Copyright (c) 2002-2016 The ANGLE Project Authors. All rights reserved.
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +00003// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6
Geoff Lang4ddf5af2016-12-01 14:30:44 -05007// ResourceManager.cpp: Implements the the ResourceManager classes, which handle allocation and
8// lifetime of GL objects.
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +00009
Geoff Lang2b5420c2014-11-19 14:20:15 -050010#include "libANGLE/ResourceManager.h"
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +000011
Geoff Lang2b5420c2014-11-19 14:20:15 -050012#include "libANGLE/Buffer.h"
Jamie Madill53ea9cc2016-05-17 10:12:52 -040013#include "libANGLE/Fence.h"
Sami Väisänene45e53b2016-05-25 10:36:04 +030014#include "libANGLE/Path.h"
Geoff Lang2b5420c2014-11-19 14:20:15 -050015#include "libANGLE/Program.h"
Yunchao Hea336b902017-08-02 16:05:21 +080016#include "libANGLE/ProgramPipeline.h"
Geoff Lang2b5420c2014-11-19 14:20:15 -050017#include "libANGLE/Renderbuffer.h"
Jamie Madill53ea9cc2016-05-17 10:12:52 -040018#include "libANGLE/Sampler.h"
Geoff Lang2b5420c2014-11-19 14:20:15 -050019#include "libANGLE/Shader.h"
20#include "libANGLE/Texture.h"
Jamie Madill53ea9cc2016-05-17 10:12:52 -040021#include "libANGLE/renderer/GLImplFactory.h"
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +000022
23namespace gl
24{
Geoff Lang4ddf5af2016-12-01 14:30:44 -050025
26namespace
27{
28
29template <typename ResourceType>
30GLuint AllocateEmptyObject(HandleAllocator *handleAllocator, ResourceMap<ResourceType> *objectMap)
31{
Jamie Madill96a483b2017-06-27 16:49:21 -040032 GLuint handle = handleAllocator->allocate();
33 objectMap->assign(handle, nullptr);
Geoff Lang4ddf5af2016-12-01 14:30:44 -050034 return handle;
35}
36
Geoff Lang4ddf5af2016-12-01 14:30:44 -050037} // anonymous namespace
38
39template <typename HandleAllocatorType>
40ResourceManagerBase<HandleAllocatorType>::ResourceManagerBase() : mRefCount(1)
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +000041{
42}
43
Geoff Lang4ddf5af2016-12-01 14:30:44 -050044template <typename HandleAllocatorType>
45void ResourceManagerBase<HandleAllocatorType>::addRef()
daniel@transgaming.com0d25b002010-07-28 19:21:07 +000046{
47 mRefCount++;
48}
49
Geoff Lang4ddf5af2016-12-01 14:30:44 -050050template <typename HandleAllocatorType>
Jamie Madill6c1f6712017-02-14 19:08:04 -050051void ResourceManagerBase<HandleAllocatorType>::release(const Context *context)
daniel@transgaming.com0d25b002010-07-28 19:21:07 +000052{
53 if (--mRefCount == 0)
54 {
Jamie Madill6c1f6712017-02-14 19:08:04 -050055 reset(context);
daniel@transgaming.com0d25b002010-07-28 19:21:07 +000056 delete this;
57 }
58}
59
Jamie Madill5f45e7c2017-02-10 15:23:28 -080060template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
61TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::~TypedResourceManager()
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +000062{
Jamie Madill6c1f6712017-02-14 19:08:04 -050063 ASSERT(mObjectMap.empty());
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +000064}
65
Jamie Madill5f45e7c2017-02-10 15:23:28 -080066template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
Jamie Madill6c1f6712017-02-14 19:08:04 -050067void TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::reset(const Context *context)
68{
Jamie Madill96a483b2017-06-27 16:49:21 -040069 this->mHandleAllocator.reset();
70 for (const auto &resource : mObjectMap)
Jamie Madill6c1f6712017-02-14 19:08:04 -050071 {
Jamie Madill96a483b2017-06-27 16:49:21 -040072 if (resource.second)
73 {
74 ImplT::DeleteObject(context, resource.second);
75 }
Jamie Madill6c1f6712017-02-14 19:08:04 -050076 }
77 mObjectMap.clear();
78}
79
80template <typename ResourceType, typename HandleAllocatorType, typename ImplT>
81void TypedResourceManager<ResourceType, HandleAllocatorType, ImplT>::deleteObject(
82 const Context *context,
83 GLuint handle)
Geoff Lang4ddf5af2016-12-01 14:30:44 -050084{
Jamie Madill96a483b2017-06-27 16:49:21 -040085 ResourceType *resource = nullptr;
86 if (!mObjectMap.erase(handle, &resource))
Jamie Madill5f45e7c2017-02-10 15:23:28 -080087 {
88 return;
89 }
90
Jamie Madill5f45e7c2017-02-10 15:23:28 -080091 // Requires an explicit this-> because of C++ template rules.
Jamie Madill96a483b2017-06-27 16:49:21 -040092 this->mHandleAllocator.release(handle);
Geoff Lang4ddf5af2016-12-01 14:30:44 -050093
Jamie Madill96a483b2017-06-27 16:49:21 -040094 if (resource)
Jamie Madill5f45e7c2017-02-10 15:23:28 -080095 {
Jamie Madill96a483b2017-06-27 16:49:21 -040096 ImplT::DeleteObject(context, resource);
Jamie Madill5f45e7c2017-02-10 15:23:28 -080097 }
Jamie Madill5f45e7c2017-02-10 15:23:28 -080098}
99
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500100template class ResourceManagerBase<HandleAllocator>;
101template class ResourceManagerBase<HandleRangeAllocator>;
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800102template class TypedResourceManager<Buffer, HandleAllocator, BufferManager>;
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800103template class TypedResourceManager<Texture, HandleAllocator, TextureManager>;
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800104template class TypedResourceManager<Renderbuffer, HandleAllocator, RenderbufferManager>;
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800105template class TypedResourceManager<Sampler, HandleAllocator, SamplerManager>;
Jamie Madill70b5bb02017-08-28 13:32:37 -0400106template class TypedResourceManager<Sync, HandleAllocator, SyncManager>;
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800107template class TypedResourceManager<Framebuffer, HandleAllocator, FramebufferManager>;
Yunchao Hea336b902017-08-02 16:05:21 +0800108template class TypedResourceManager<ProgramPipeline, HandleAllocator, ProgramPipelineManager>;
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800109
110// BufferManager Implementation.
111
112// static
113Buffer *BufferManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
114{
115 Buffer *buffer = new Buffer(factory, handle);
116 buffer->addRef();
117 return buffer;
118}
119
120// static
Jamie Madill4928b7c2017-06-20 12:57:39 -0400121void BufferManager::DeleteObject(const Context *context, Buffer *buffer)
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800122{
Jamie Madill4928b7c2017-06-20 12:57:39 -0400123 buffer->release(context);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800124}
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500125
126GLuint BufferManager::createBuffer()
127{
128 return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
129}
130
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500131Buffer *BufferManager::getBuffer(GLuint handle) const
132{
Jamie Madill96a483b2017-06-27 16:49:21 -0400133 return mObjectMap.query(handle);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500134}
135
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800136// ShaderProgramManager Implementation.
137
Jamie Madillacf2f3a2017-11-21 19:22:44 -0500138ShaderProgramManager::ShaderProgramManager()
139{
140}
141
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500142ShaderProgramManager::~ShaderProgramManager()
143{
Jamie Madill6c1f6712017-02-14 19:08:04 -0500144 ASSERT(mPrograms.empty());
145 ASSERT(mShaders.empty());
146}
147
148void ShaderProgramManager::reset(const Context *context)
149{
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500150 while (!mPrograms.empty())
151 {
Jamie Madill6c1f6712017-02-14 19:08:04 -0500152 deleteProgram(context, mPrograms.begin()->first);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500153 }
Jamie Madill6c1f6712017-02-14 19:08:04 -0500154 mPrograms.clear();
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500155 while (!mShaders.empty())
156 {
Jamie Madill6c1f6712017-02-14 19:08:04 -0500157 deleteShader(context, mShaders.begin()->first);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500158 }
Jamie Madill6c1f6712017-02-14 19:08:04 -0500159 mShaders.clear();
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500160}
161
162GLuint ShaderProgramManager::createShader(rx::GLImplFactory *factory,
163 const gl::Limitations &rendererLimitations,
Jiawei Shao385b3e02018-03-21 09:43:28 +0800164 ShaderType type)
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000165{
Jiawei Shao385b3e02018-03-21 09:43:28 +0800166 ASSERT(type != ShaderType::InvalidEnum);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500167 GLuint handle = mHandleAllocator.allocate();
Jamie Madill96a483b2017-06-27 16:49:21 -0400168 mShaders.assign(handle, new Shader(this, factory, rendererLimitations, type, handle));
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000169 return handle;
170}
171
Jamie Madill6c1f6712017-02-14 19:08:04 -0500172void ShaderProgramManager::deleteShader(const Context *context, GLuint shader)
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000173{
Jamie Madill6c1f6712017-02-14 19:08:04 -0500174 deleteObject(context, &mShaders, shader);
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000175}
176
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500177Shader *ShaderProgramManager::getShader(GLuint handle) const
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000178{
Jamie Madill96a483b2017-06-27 16:49:21 -0400179 return mShaders.query(handle);
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000180}
181
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500182GLuint ShaderProgramManager::createProgram(rx::GLImplFactory *factory)
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000183{
Jamie Madill96a483b2017-06-27 16:49:21 -0400184 GLuint handle = mHandleAllocator.allocate();
185 mPrograms.assign(handle, new Program(factory, this, handle));
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000186 return handle;
187}
188
Jamie Madill6c1f6712017-02-14 19:08:04 -0500189void ShaderProgramManager::deleteProgram(const gl::Context *context, GLuint program)
Jamie Madilldc356042013-07-19 16:36:57 -0400190{
Jamie Madill6c1f6712017-02-14 19:08:04 -0500191 deleteObject(context, &mPrograms, program);
Jamie Madilldc356042013-07-19 16:36:57 -0400192}
193
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500194Program *ShaderProgramManager::getProgram(GLuint handle) const
Jamie Madillcd055f82013-07-26 11:55:15 -0400195{
Jamie Madill96a483b2017-06-27 16:49:21 -0400196 return mPrograms.query(handle);
Jamie Madillcd055f82013-07-26 11:55:15 -0400197}
198
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500199template <typename ObjectType>
Jamie Madill6c1f6712017-02-14 19:08:04 -0500200void ShaderProgramManager::deleteObject(const Context *context,
201 ResourceMap<ObjectType> *objectMap,
202 GLuint id)
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500203{
Jamie Madill96a483b2017-06-27 16:49:21 -0400204 ObjectType *object = objectMap->query(id);
205 if (!object)
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500206 {
207 return;
208 }
209
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500210 if (object->getRefCount() == 0)
211 {
212 mHandleAllocator.release(id);
Jamie Madill4928b7c2017-06-20 12:57:39 -0400213 object->onDestroy(context);
Jamie Madill96a483b2017-06-27 16:49:21 -0400214 objectMap->erase(id, &object);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500215 }
216 else
217 {
218 object->flagForDeletion();
219 }
220}
221
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800222// TextureManager Implementation.
223
224// static
Corentin Wallez99d492c2018-02-27 15:17:10 -0500225Texture *TextureManager::AllocateNewObject(rx::GLImplFactory *factory,
226 GLuint handle,
227 TextureType type)
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800228{
Corentin Wallez99d492c2018-02-27 15:17:10 -0500229 Texture *texture = new Texture(factory, handle, type);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800230 texture->addRef();
231 return texture;
232}
233
234// static
Jamie Madill4928b7c2017-06-20 12:57:39 -0400235void TextureManager::DeleteObject(const Context *context, Texture *texture)
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800236{
Jamie Madill4928b7c2017-06-20 12:57:39 -0400237 texture->release(context);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800238}
239
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500240GLuint TextureManager::createTexture()
241{
242 return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
243}
244
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500245Texture *TextureManager::getTexture(GLuint handle) const
246{
Jamie Madill96a483b2017-06-27 16:49:21 -0400247 ASSERT(mObjectMap.query(0) == nullptr);
248 return mObjectMap.query(handle);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500249}
250
Jamie Madilld4442552018-02-27 22:03:47 -0500251void TextureManager::signalAllTexturesDirty(const Context *context) const
Geoff Lang9aded172017-04-05 11:07:56 -0400252{
Jamie Madill96a483b2017-06-27 16:49:21 -0400253 for (const auto &texture : mObjectMap)
Geoff Lang9aded172017-04-05 11:07:56 -0400254 {
255 if (texture.second)
256 {
Jamie Madill05b35b22017-10-03 09:01:44 -0400257 // We don't know if the Texture needs init, but that's ok, since it will only force
258 // a re-check, and will not initialize the pixels if it's not needed.
Jamie Madilld4442552018-02-27 22:03:47 -0500259 texture.second->signalDirty(context, InitState::MayNeedInit);
Geoff Lang9aded172017-04-05 11:07:56 -0400260 }
261 }
262}
263
Jamie Madillfc3463d2018-01-03 13:46:21 -0500264void TextureManager::enableHandleAllocatorLogging()
265{
266 mHandleAllocator.enableLogging(true);
267}
268
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800269// RenderbufferManager Implementation.
270
271// static
272Renderbuffer *RenderbufferManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
273{
Jamie Madille703c602018-02-20 10:21:48 -0500274 Renderbuffer *renderbuffer = new Renderbuffer(factory, handle);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800275 renderbuffer->addRef();
276 return renderbuffer;
277}
278
279// static
Jamie Madill4928b7c2017-06-20 12:57:39 -0400280void RenderbufferManager::DeleteObject(const Context *context, Renderbuffer *renderbuffer)
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800281{
Jamie Madill4928b7c2017-06-20 12:57:39 -0400282 renderbuffer->release(context);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800283}
284
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500285GLuint RenderbufferManager::createRenderbuffer()
286{
287 return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
288}
289
Yunchao Hea438f4e2017-08-04 13:42:39 +0800290Renderbuffer *RenderbufferManager::getRenderbuffer(GLuint handle) const
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500291{
Jamie Madill96a483b2017-06-27 16:49:21 -0400292 return mObjectMap.query(handle);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500293}
294
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800295// SamplerManager Implementation.
296
297// static
298Sampler *SamplerManager::AllocateNewObject(rx::GLImplFactory *factory, GLuint handle)
299{
300 Sampler *sampler = new Sampler(factory, handle);
301 sampler->addRef();
302 return sampler;
303}
304
305// static
Jamie Madill4928b7c2017-06-20 12:57:39 -0400306void SamplerManager::DeleteObject(const Context *context, Sampler *sampler)
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800307{
Jamie Madill4928b7c2017-06-20 12:57:39 -0400308 sampler->release(context);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800309}
310
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500311GLuint SamplerManager::createSampler()
312{
313 return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
314}
315
Yunchao Hea438f4e2017-08-04 13:42:39 +0800316Sampler *SamplerManager::getSampler(GLuint handle) const
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500317{
Jamie Madill96a483b2017-06-27 16:49:21 -0400318 return mObjectMap.query(handle);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500319}
320
Yunchao Hea438f4e2017-08-04 13:42:39 +0800321bool SamplerManager::isSampler(GLuint sampler) const
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500322{
Jamie Madill96a483b2017-06-27 16:49:21 -0400323 return mObjectMap.contains(sampler);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500324}
325
Jamie Madill70b5bb02017-08-28 13:32:37 -0400326// SyncManager Implementation.
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800327
328// static
Jamie Madill70b5bb02017-08-28 13:32:37 -0400329void SyncManager::DeleteObject(const Context *context, Sync *sync)
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500330{
Jamie Madill70b5bb02017-08-28 13:32:37 -0400331 sync->release(context);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500332}
333
Jamie Madill70b5bb02017-08-28 13:32:37 -0400334GLuint SyncManager::createSync(rx::GLImplFactory *factory)
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500335{
Jamie Madill70b5bb02017-08-28 13:32:37 -0400336 GLuint handle = mHandleAllocator.allocate();
337 Sync *sync = new Sync(factory->createSync(), handle);
338 sync->addRef();
339 mObjectMap.assign(handle, sync);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800340 return handle;
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500341}
342
Jamie Madill70b5bb02017-08-28 13:32:37 -0400343Sync *SyncManager::getSync(GLuint handle) const
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500344{
Jamie Madill96a483b2017-06-27 16:49:21 -0400345 return mObjectMap.query(handle);
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500346}
347
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800348// PathManager Implementation.
349
Jamie Madillacf2f3a2017-11-21 19:22:44 -0500350PathManager::PathManager()
351{
352}
353
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500354ErrorOrResult<GLuint> PathManager::createPaths(rx::GLImplFactory *factory, GLsizei range)
Sami Väisänene45e53b2016-05-25 10:36:04 +0300355{
356 // Allocate client side handles.
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500357 const GLuint client = mHandleAllocator.allocateRange(static_cast<GLuint>(range));
Sami Väisänene45e53b2016-05-25 10:36:04 +0300358 if (client == HandleRangeAllocator::kInvalidHandle)
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500359 return OutOfMemory() << "Failed to allocate path handle range.";
Sami Väisänene45e53b2016-05-25 10:36:04 +0300360
361 const auto &paths = factory->createPaths(range);
362 if (paths.empty())
363 {
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500364 mHandleAllocator.releaseRange(client, range);
Yuly Novikovc4d18aa2017-03-09 18:45:02 -0500365 return OutOfMemory() << "Failed to allocate path objects.";
Sami Väisänene45e53b2016-05-25 10:36:04 +0300366 }
367
Sami Väisänene45e53b2016-05-25 10:36:04 +0300368 for (GLsizei i = 0; i < range; ++i)
369 {
Jamie Madillacf2f3a2017-11-21 19:22:44 -0500370 rx::PathImpl *impl = paths[static_cast<unsigned>(i)];
Sami Väisänene45e53b2016-05-25 10:36:04 +0300371 const auto id = client + i;
Jamie Madill96a483b2017-06-27 16:49:21 -0400372 mPaths.assign(id, new Path(impl));
Sami Väisänene45e53b2016-05-25 10:36:04 +0300373 }
374 return client;
375}
376
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500377void PathManager::deletePaths(GLuint first, GLsizei range)
Sami Väisänene45e53b2016-05-25 10:36:04 +0300378{
379 for (GLsizei i = 0; i < range; ++i)
380 {
381 const auto id = first + i;
Jamie Madill96a483b2017-06-27 16:49:21 -0400382 Path *p = nullptr;
383 if (!mPaths.erase(id, &p))
Sami Väisänene45e53b2016-05-25 10:36:04 +0300384 continue;
Sami Väisänene45e53b2016-05-25 10:36:04 +0300385 delete p;
Sami Väisänene45e53b2016-05-25 10:36:04 +0300386 }
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500387 mHandleAllocator.releaseRange(first, static_cast<GLuint>(range));
Sami Väisänene45e53b2016-05-25 10:36:04 +0300388}
389
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500390Path *PathManager::getPath(GLuint handle) const
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000391{
Jamie Madill96a483b2017-06-27 16:49:21 -0400392 return mPaths.query(handle);
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000393}
394
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500395bool PathManager::hasPath(GLuint handle) const
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000396{
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500397 return mHandleAllocator.isUsed(handle);
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000398}
399
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500400PathManager::~PathManager()
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000401{
Jamie Madill6c1f6712017-02-14 19:08:04 -0500402 ASSERT(mPaths.empty());
403}
404
405void PathManager::reset(const Context *context)
406{
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500407 for (auto path : mPaths)
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000408 {
Geoff Lang4ddf5af2016-12-01 14:30:44 -0500409 SafeDelete(path.second);
daniel@transgaming.comda13f3e2010-07-28 19:20:56 +0000410 }
Jamie Madill6c1f6712017-02-14 19:08:04 -0500411 mPaths.clear();
Geoff Langf41a7152016-09-19 15:11:17 -0400412}
413
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800414// FramebufferManager Implementation.
415
416// static
417Framebuffer *FramebufferManager::AllocateNewObject(rx::GLImplFactory *factory,
418 GLuint handle,
419 const Caps &caps)
Geoff Lang3bf8e3a2016-12-01 17:28:52 -0500420{
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800421 return new Framebuffer(caps, factory, handle);
422}
423
424// static
Jamie Madill4928b7c2017-06-20 12:57:39 -0400425void FramebufferManager::DeleteObject(const Context *context, Framebuffer *framebuffer)
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800426{
427 // Default framebuffer are owned by their respective Surface
428 if (framebuffer->id() != 0)
Geoff Lang3bf8e3a2016-12-01 17:28:52 -0500429 {
Jamie Madill4928b7c2017-06-20 12:57:39 -0400430 framebuffer->onDestroy(context);
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800431 delete framebuffer;
Geoff Lang3bf8e3a2016-12-01 17:28:52 -0500432 }
433}
434
435GLuint FramebufferManager::createFramebuffer()
436{
Jamie Madill5f45e7c2017-02-10 15:23:28 -0800437 return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
Geoff Lang3bf8e3a2016-12-01 17:28:52 -0500438}
439
440Framebuffer *FramebufferManager::getFramebuffer(GLuint handle) const
441{
Jamie Madill96a483b2017-06-27 16:49:21 -0400442 return mObjectMap.query(handle);
Geoff Lang3bf8e3a2016-12-01 17:28:52 -0500443}
444
445void FramebufferManager::setDefaultFramebuffer(Framebuffer *framebuffer)
446{
447 ASSERT(framebuffer == nullptr || framebuffer->id() == 0);
Jamie Madill96a483b2017-06-27 16:49:21 -0400448 mObjectMap.assign(0, framebuffer);
Geoff Lang3bf8e3a2016-12-01 17:28:52 -0500449}
450
Jamie Madill96a483b2017-06-27 16:49:21 -0400451void FramebufferManager::invalidateFramebufferComplenessCache() const
Geoff Lang9aded172017-04-05 11:07:56 -0400452{
Jamie Madill96a483b2017-06-27 16:49:21 -0400453 for (const auto &framebuffer : mObjectMap)
Geoff Lang9aded172017-04-05 11:07:56 -0400454 {
455 if (framebuffer.second)
456 {
457 framebuffer.second->invalidateCompletenessCache();
458 }
459 }
460}
461
Yunchao Hea336b902017-08-02 16:05:21 +0800462// ProgramPipelineManager Implementation.
463
464// static
465ProgramPipeline *ProgramPipelineManager::AllocateNewObject(rx::GLImplFactory *factory,
466 GLuint handle)
467{
468 ProgramPipeline *pipeline = new ProgramPipeline(factory, handle);
469 pipeline->addRef();
470 return pipeline;
471}
472
473// static
474void ProgramPipelineManager::DeleteObject(const Context *context, ProgramPipeline *pipeline)
475{
476 pipeline->release(context);
477}
478
479GLuint ProgramPipelineManager::createProgramPipeline()
480{
481 return AllocateEmptyObject(&mHandleAllocator, &mObjectMap);
482}
483
484ProgramPipeline *ProgramPipelineManager::getProgramPipeline(GLuint handle) const
485{
486 return mObjectMap.query(handle);
487}
488
Jamie Madill3f01e6c2016-03-08 13:53:02 -0500489} // namespace gl