daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 1 | // |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 2 | // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 3 | // Use of this source code is governed by a BSD-style license that can be |
| 4 | // found in the LICENSE file. |
| 5 | // |
| 6 | |
| 7 | // ResourceManager.cpp: Implements the gl::ResourceManager class, which tracks and |
| 8 | // retrieves objects which may be shared by multiple Contexts. |
| 9 | |
| 10 | #include "libGLESv2/ResourceManager.h" |
| 11 | |
| 12 | #include "libGLESv2/Buffer.h" |
| 13 | #include "libGLESv2/Program.h" |
daniel@transgaming.com | 29ab952 | 2012-08-27 16:25:37 +0000 | [diff] [blame] | 14 | #include "libGLESv2/Renderbuffer.h" |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 15 | #include "libGLESv2/Shader.h" |
| 16 | #include "libGLESv2/Texture.h" |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 17 | #include "libGLESv2/Sampler.h" |
Jamie Madill | cd055f8 | 2013-07-26 11:55:15 -0400 | [diff] [blame] | 18 | #include "libGLESv2/Fence.h" |
Brandon Jones | d38f926 | 2014-06-18 16:26:45 -0700 | [diff] [blame] | 19 | #include "libGLESv2/renderer/Renderer.h" |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 20 | |
| 21 | namespace gl |
| 22 | { |
daniel@transgaming.com | 370482e | 2012-11-28 19:32:13 +0000 | [diff] [blame] | 23 | ResourceManager::ResourceManager(rx::Renderer *renderer) |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 24 | { |
daniel@transgaming.com | 0d25b00 | 2010-07-28 19:21:07 +0000 | [diff] [blame] | 25 | mRefCount = 1; |
daniel@transgaming.com | 370482e | 2012-11-28 19:32:13 +0000 | [diff] [blame] | 26 | mRenderer = renderer; |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 27 | } |
| 28 | |
| 29 | ResourceManager::~ResourceManager() |
| 30 | { |
| 31 | while (!mBufferMap.empty()) |
| 32 | { |
| 33 | deleteBuffer(mBufferMap.begin()->first); |
| 34 | } |
| 35 | |
| 36 | while (!mProgramMap.empty()) |
| 37 | { |
| 38 | deleteProgram(mProgramMap.begin()->first); |
| 39 | } |
| 40 | |
| 41 | while (!mShaderMap.empty()) |
| 42 | { |
| 43 | deleteShader(mShaderMap.begin()->first); |
| 44 | } |
| 45 | |
| 46 | while (!mRenderbufferMap.empty()) |
| 47 | { |
| 48 | deleteRenderbuffer(mRenderbufferMap.begin()->first); |
| 49 | } |
| 50 | |
| 51 | while (!mTextureMap.empty()) |
| 52 | { |
| 53 | deleteTexture(mTextureMap.begin()->first); |
| 54 | } |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 55 | |
| 56 | while (!mSamplerMap.empty()) |
| 57 | { |
| 58 | deleteSampler(mSamplerMap.begin()->first); |
| 59 | } |
Jamie Madill | cd055f8 | 2013-07-26 11:55:15 -0400 | [diff] [blame] | 60 | |
| 61 | while (!mFenceSyncMap.empty()) |
| 62 | { |
| 63 | deleteFenceSync(mFenceSyncMap.begin()->first); |
| 64 | } |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 65 | } |
| 66 | |
daniel@transgaming.com | 0d25b00 | 2010-07-28 19:21:07 +0000 | [diff] [blame] | 67 | void ResourceManager::addRef() |
| 68 | { |
| 69 | mRefCount++; |
| 70 | } |
| 71 | |
| 72 | void ResourceManager::release() |
| 73 | { |
| 74 | if (--mRefCount == 0) |
| 75 | { |
| 76 | delete this; |
| 77 | } |
| 78 | } |
| 79 | |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 80 | // Returns an unused buffer name |
| 81 | GLuint ResourceManager::createBuffer() |
| 82 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 83 | GLuint handle = mBufferHandleAllocator.allocate(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 84 | |
| 85 | mBufferMap[handle] = NULL; |
| 86 | |
| 87 | return handle; |
| 88 | } |
| 89 | |
| 90 | // Returns an unused shader/program name |
| 91 | GLuint ResourceManager::createShader(GLenum type) |
| 92 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 93 | GLuint handle = mProgramShaderHandleAllocator.allocate(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 94 | |
Brandon Jones | 7162096 | 2014-08-20 14:04:59 -0700 | [diff] [blame] | 95 | if (type == GL_VERTEX_SHADER || type == GL_FRAGMENT_SHADER) |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 96 | { |
Brandon Jones | 7162096 | 2014-08-20 14:04:59 -0700 | [diff] [blame] | 97 | mShaderMap[handle] = new Shader(this, mRenderer->createShader(type), type, handle); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 98 | } |
| 99 | else UNREACHABLE(); |
| 100 | |
| 101 | return handle; |
| 102 | } |
| 103 | |
| 104 | // Returns an unused program/shader name |
| 105 | GLuint ResourceManager::createProgram() |
| 106 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 107 | GLuint handle = mProgramShaderHandleAllocator.allocate(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 108 | |
daniel@transgaming.com | 70062c9 | 2012-11-28 19:32:30 +0000 | [diff] [blame] | 109 | mProgramMap[handle] = new Program(mRenderer, this, handle); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 110 | |
| 111 | return handle; |
| 112 | } |
| 113 | |
| 114 | // Returns an unused texture name |
| 115 | GLuint ResourceManager::createTexture() |
| 116 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 117 | GLuint handle = mTextureHandleAllocator.allocate(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 118 | |
| 119 | mTextureMap[handle] = NULL; |
| 120 | |
| 121 | return handle; |
| 122 | } |
| 123 | |
| 124 | // Returns an unused renderbuffer name |
| 125 | GLuint ResourceManager::createRenderbuffer() |
| 126 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 127 | GLuint handle = mRenderbufferHandleAllocator.allocate(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 128 | |
| 129 | mRenderbufferMap[handle] = NULL; |
| 130 | |
| 131 | return handle; |
| 132 | } |
| 133 | |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 134 | // Returns an unused sampler name |
| 135 | GLuint ResourceManager::createSampler() |
| 136 | { |
| 137 | GLuint handle = mSamplerHandleAllocator.allocate(); |
| 138 | |
| 139 | mSamplerMap[handle] = NULL; |
| 140 | |
| 141 | return handle; |
| 142 | } |
| 143 | |
Jamie Madill | cd055f8 | 2013-07-26 11:55:15 -0400 | [diff] [blame] | 144 | // Returns the next unused fence name, and allocates the fence |
| 145 | GLuint ResourceManager::createFenceSync() |
| 146 | { |
| 147 | GLuint handle = mFenceSyncHandleAllocator.allocate(); |
| 148 | |
Jamie Madill | cfa33e6 | 2014-08-19 15:30:41 -0400 | [diff] [blame] | 149 | FenceSync *fenceSync = new FenceSync(mRenderer, handle); |
| 150 | fenceSync->addRef(); |
| 151 | mFenceSyncMap[handle] = fenceSync; |
Jamie Madill | cd055f8 | 2013-07-26 11:55:15 -0400 | [diff] [blame] | 152 | |
| 153 | return handle; |
| 154 | } |
| 155 | |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 156 | void ResourceManager::deleteBuffer(GLuint buffer) |
| 157 | { |
| 158 | BufferMap::iterator bufferObject = mBufferMap.find(buffer); |
| 159 | |
| 160 | if (bufferObject != mBufferMap.end()) |
| 161 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 162 | mBufferHandleAllocator.release(bufferObject->first); |
apatrick@chromium.org | ff8bdfb | 2010-09-15 17:27:49 +0000 | [diff] [blame] | 163 | if (bufferObject->second) bufferObject->second->release(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 164 | mBufferMap.erase(bufferObject); |
| 165 | } |
| 166 | } |
| 167 | |
| 168 | void ResourceManager::deleteShader(GLuint shader) |
| 169 | { |
| 170 | ShaderMap::iterator shaderObject = mShaderMap.find(shader); |
| 171 | |
| 172 | if (shaderObject != mShaderMap.end()) |
| 173 | { |
| 174 | if (shaderObject->second->getRefCount() == 0) |
| 175 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 176 | mProgramShaderHandleAllocator.release(shaderObject->first); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 177 | delete shaderObject->second; |
| 178 | mShaderMap.erase(shaderObject); |
| 179 | } |
| 180 | else |
| 181 | { |
| 182 | shaderObject->second->flagForDeletion(); |
| 183 | } |
| 184 | } |
| 185 | } |
| 186 | |
| 187 | void ResourceManager::deleteProgram(GLuint program) |
| 188 | { |
| 189 | ProgramMap::iterator programObject = mProgramMap.find(program); |
| 190 | |
| 191 | if (programObject != mProgramMap.end()) |
| 192 | { |
| 193 | if (programObject->second->getRefCount() == 0) |
| 194 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 195 | mProgramShaderHandleAllocator.release(programObject->first); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 196 | delete programObject->second; |
| 197 | mProgramMap.erase(programObject); |
| 198 | } |
| 199 | else |
| 200 | { |
| 201 | programObject->second->flagForDeletion(); |
| 202 | } |
| 203 | } |
| 204 | } |
| 205 | |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 206 | void ResourceManager::deleteTexture(GLuint texture) |
| 207 | { |
| 208 | TextureMap::iterator textureObject = mTextureMap.find(texture); |
| 209 | |
| 210 | if (textureObject != mTextureMap.end()) |
| 211 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 212 | mTextureHandleAllocator.release(textureObject->first); |
apatrick@chromium.org | ff8bdfb | 2010-09-15 17:27:49 +0000 | [diff] [blame] | 213 | if (textureObject->second) textureObject->second->release(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 214 | mTextureMap.erase(textureObject); |
| 215 | } |
| 216 | } |
| 217 | |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 218 | void ResourceManager::deleteRenderbuffer(GLuint renderbuffer) |
| 219 | { |
| 220 | RenderbufferMap::iterator renderbufferObject = mRenderbufferMap.find(renderbuffer); |
| 221 | |
| 222 | if (renderbufferObject != mRenderbufferMap.end()) |
| 223 | { |
benvanik@google.com | 1a23334 | 2011-04-28 19:44:39 +0000 | [diff] [blame] | 224 | mRenderbufferHandleAllocator.release(renderbufferObject->first); |
apatrick@chromium.org | ff8bdfb | 2010-09-15 17:27:49 +0000 | [diff] [blame] | 225 | if (renderbufferObject->second) renderbufferObject->second->release(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 226 | mRenderbufferMap.erase(renderbufferObject); |
| 227 | } |
| 228 | } |
| 229 | |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 230 | void ResourceManager::deleteSampler(GLuint sampler) |
| 231 | { |
| 232 | auto samplerObject = mSamplerMap.find(sampler); |
| 233 | |
| 234 | if (samplerObject != mSamplerMap.end()) |
| 235 | { |
Geoff Lang | 7993190 | 2014-02-03 14:29:42 -0500 | [diff] [blame] | 236 | mSamplerHandleAllocator.release(samplerObject->first); |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 237 | if (samplerObject->second) samplerObject->second->release(); |
| 238 | mSamplerMap.erase(samplerObject); |
| 239 | } |
| 240 | } |
| 241 | |
Jamie Madill | cd055f8 | 2013-07-26 11:55:15 -0400 | [diff] [blame] | 242 | void ResourceManager::deleteFenceSync(GLuint fenceSync) |
| 243 | { |
| 244 | auto fenceObjectIt = mFenceSyncMap.find(fenceSync); |
| 245 | |
| 246 | if (fenceObjectIt != mFenceSyncMap.end()) |
| 247 | { |
| 248 | mFenceSyncHandleAllocator.release(fenceObjectIt->first); |
| 249 | if (fenceObjectIt->second) fenceObjectIt->second->release(); |
| 250 | mFenceSyncMap.erase(fenceObjectIt); |
| 251 | } |
| 252 | } |
| 253 | |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 254 | Buffer *ResourceManager::getBuffer(unsigned int handle) |
| 255 | { |
| 256 | BufferMap::iterator buffer = mBufferMap.find(handle); |
| 257 | |
| 258 | if (buffer == mBufferMap.end()) |
| 259 | { |
| 260 | return NULL; |
| 261 | } |
| 262 | else |
| 263 | { |
| 264 | return buffer->second; |
| 265 | } |
| 266 | } |
| 267 | |
| 268 | Shader *ResourceManager::getShader(unsigned int handle) |
| 269 | { |
| 270 | ShaderMap::iterator shader = mShaderMap.find(handle); |
| 271 | |
| 272 | if (shader == mShaderMap.end()) |
| 273 | { |
| 274 | return NULL; |
| 275 | } |
| 276 | else |
| 277 | { |
| 278 | return shader->second; |
| 279 | } |
| 280 | } |
| 281 | |
| 282 | Texture *ResourceManager::getTexture(unsigned int handle) |
| 283 | { |
| 284 | if (handle == 0) return NULL; |
| 285 | |
| 286 | TextureMap::iterator texture = mTextureMap.find(handle); |
| 287 | |
| 288 | if (texture == mTextureMap.end()) |
| 289 | { |
| 290 | return NULL; |
| 291 | } |
| 292 | else |
| 293 | { |
| 294 | return texture->second; |
| 295 | } |
| 296 | } |
| 297 | |
| 298 | Program *ResourceManager::getProgram(unsigned int handle) |
| 299 | { |
| 300 | ProgramMap::iterator program = mProgramMap.find(handle); |
| 301 | |
| 302 | if (program == mProgramMap.end()) |
| 303 | { |
| 304 | return NULL; |
| 305 | } |
| 306 | else |
| 307 | { |
| 308 | return program->second; |
| 309 | } |
| 310 | } |
| 311 | |
Jamie Madill | 6c7b4ad | 2014-06-16 10:33:59 -0400 | [diff] [blame] | 312 | Renderbuffer *ResourceManager::getRenderbuffer(unsigned int handle) |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 313 | { |
| 314 | RenderbufferMap::iterator renderbuffer = mRenderbufferMap.find(handle); |
| 315 | |
| 316 | if (renderbuffer == mRenderbufferMap.end()) |
| 317 | { |
| 318 | return NULL; |
| 319 | } |
| 320 | else |
| 321 | { |
| 322 | return renderbuffer->second; |
| 323 | } |
| 324 | } |
| 325 | |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 326 | Sampler *ResourceManager::getSampler(unsigned int handle) |
| 327 | { |
| 328 | auto sampler = mSamplerMap.find(handle); |
| 329 | |
| 330 | if (sampler == mSamplerMap.end()) |
| 331 | { |
| 332 | return NULL; |
| 333 | } |
| 334 | else |
| 335 | { |
| 336 | return sampler->second; |
| 337 | } |
| 338 | } |
| 339 | |
Jamie Madill | cd055f8 | 2013-07-26 11:55:15 -0400 | [diff] [blame] | 340 | FenceSync *ResourceManager::getFenceSync(unsigned int handle) |
| 341 | { |
| 342 | auto fenceObjectIt = mFenceSyncMap.find(handle); |
| 343 | |
| 344 | if (fenceObjectIt == mFenceSyncMap.end()) |
| 345 | { |
| 346 | return NULL; |
| 347 | } |
| 348 | else |
| 349 | { |
| 350 | return fenceObjectIt->second; |
| 351 | } |
| 352 | } |
| 353 | |
Jamie Madill | 6c7b4ad | 2014-06-16 10:33:59 -0400 | [diff] [blame] | 354 | void ResourceManager::setRenderbuffer(GLuint handle, Renderbuffer *buffer) |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 355 | { |
| 356 | mRenderbufferMap[handle] = buffer; |
| 357 | } |
| 358 | |
| 359 | void ResourceManager::checkBufferAllocation(unsigned int buffer) |
| 360 | { |
| 361 | if (buffer != 0 && !getBuffer(buffer)) |
| 362 | { |
Brandon Jones | d38f926 | 2014-06-18 16:26:45 -0700 | [diff] [blame] | 363 | Buffer *bufferObject = new Buffer(mRenderer->createBuffer(), buffer); |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 364 | mBufferMap[buffer] = bufferObject; |
| 365 | bufferObject->addRef(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 366 | } |
| 367 | } |
| 368 | |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 369 | void ResourceManager::checkTextureAllocation(GLuint texture, GLenum type) |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 370 | { |
| 371 | if (!getTexture(texture) && texture != 0) |
| 372 | { |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 373 | Texture *textureObject; |
| 374 | |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 375 | if (type == GL_TEXTURE_2D) |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 376 | { |
Brandon Jones | 6053a52 | 2014-07-25 16:22:09 -0700 | [diff] [blame] | 377 | textureObject = new Texture2D(mRenderer->createTexture(GL_TEXTURE_2D), texture); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 378 | } |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 379 | else if (type == GL_TEXTURE_CUBE_MAP) |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 380 | { |
Brandon Jones | 6053a52 | 2014-07-25 16:22:09 -0700 | [diff] [blame] | 381 | textureObject = new TextureCubeMap(mRenderer->createTexture(GL_TEXTURE_CUBE_MAP), texture); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 382 | } |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 383 | else if (type == GL_TEXTURE_3D) |
shannon.woods%transgaming.com@gtempaccount.com | c416e1c | 2013-04-13 03:45:05 +0000 | [diff] [blame] | 384 | { |
Brandon Jones | 6053a52 | 2014-07-25 16:22:09 -0700 | [diff] [blame] | 385 | textureObject = new Texture3D(mRenderer->createTexture(GL_TEXTURE_3D), texture); |
shannon.woods%transgaming.com@gtempaccount.com | c416e1c | 2013-04-13 03:45:05 +0000 | [diff] [blame] | 386 | } |
Geoff Lang | 76b10c9 | 2014-09-05 16:28:14 -0400 | [diff] [blame] | 387 | else if (type == GL_TEXTURE_2D_ARRAY) |
shannon.woods%transgaming.com@gtempaccount.com | 90dbc44 | 2013-04-13 03:46:14 +0000 | [diff] [blame] | 388 | { |
Brandon Jones | 6053a52 | 2014-07-25 16:22:09 -0700 | [diff] [blame] | 389 | textureObject = new Texture2DArray(mRenderer->createTexture(GL_TEXTURE_2D_ARRAY), texture); |
shannon.woods%transgaming.com@gtempaccount.com | 90dbc44 | 2013-04-13 03:46:14 +0000 | [diff] [blame] | 390 | } |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 391 | else |
| 392 | { |
| 393 | UNREACHABLE(); |
| 394 | return; |
| 395 | } |
| 396 | |
| 397 | mTextureMap[texture] = textureObject; |
| 398 | textureObject->addRef(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 399 | } |
| 400 | } |
| 401 | |
| 402 | void ResourceManager::checkRenderbufferAllocation(GLuint renderbuffer) |
| 403 | { |
| 404 | if (renderbuffer != 0 && !getRenderbuffer(renderbuffer)) |
| 405 | { |
Geoff Lang | e4a492b | 2014-06-19 14:14:41 -0400 | [diff] [blame] | 406 | Renderbuffer *renderbufferObject = new Renderbuffer(renderbuffer, new Colorbuffer(mRenderer, 0, 0, GL_RGBA4, 0)); |
daniel@transgaming.com | 9ecb9f9 | 2010-07-28 19:21:12 +0000 | [diff] [blame] | 407 | mRenderbufferMap[renderbuffer] = renderbufferObject; |
| 408 | renderbufferObject->addRef(); |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 409 | } |
| 410 | } |
| 411 | |
Jamie Madill | dc35604 | 2013-07-19 16:36:57 -0400 | [diff] [blame] | 412 | void ResourceManager::checkSamplerAllocation(GLuint sampler) |
| 413 | { |
| 414 | if (sampler != 0 && !getSampler(sampler)) |
| 415 | { |
| 416 | Sampler *samplerObject = new Sampler(sampler); |
| 417 | mSamplerMap[sampler] = samplerObject; |
| 418 | samplerObject->addRef(); |
| 419 | } |
| 420 | } |
| 421 | |
| 422 | bool ResourceManager::isSampler(GLuint sampler) |
| 423 | { |
| 424 | return mSamplerMap.find(sampler) != mSamplerMap.end(); |
| 425 | } |
| 426 | |
daniel@transgaming.com | da13f3e | 2010-07-28 19:20:56 +0000 | [diff] [blame] | 427 | } |