src/Radiance/libRAD/ResourceManager.cpp

   1 // SwiftShader Software Renderer
   2 //
   3 // Copyright(c) 2005-2012 TransGaming Inc.
   4 //
   5 // All rights reserved. No part of this software may be copied, distributed, transmitted,
   6 // transcribed, stored in a retrieval system, translated into any human or computer
   7 // language by any means, or disclosed to third parties without the explicit written
   8 // agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
   9 // or implied, including but not limited to any patent rights, are granted to you.
  10 //
  11
  12 // ResourceManager.cpp: Implements the ResourceManager class, which tracks and
  13 // retrieves objects which may be shared by multiple Contexts.
  14
  15 #include "ResourceManager.h"
  16
  17 #include "Buffer.h"
  18 #include "Program.h"
  19 #include "Renderbuffer.h"
  20 #include "Shader.h"
  21 #include "Texture.h"
  22
  23 namespace rad
  24 {
  25 ResourceManager::ResourceManager()
  26 {
  27     mRefCount = 1;
  28 }
  29
  30 ResourceManager::~ResourceManager()
  31 {
  32     while(!mBufferMap.empty())
  33     {
  34         deleteBuffer(mBufferMap.begin()->first);
  35     }
  36
  37     while(!mProgramMap.empty())
  38     {
  39         deleteProgram(mProgramMap.begin()->first);
  40     }
  41
  42     while(!mShaderMap.empty())
  43     {
  44         deleteShader(mShaderMap.begin()->first);
  45     }
  46
  47     while(!mRenderbufferMap.empty())
  48     {
  49         deleteRenderbuffer(mRenderbufferMap.begin()->first);
  50     }
  51
  52     while(!mTextureMap.empty())
  53     {
  54         deleteTexture(mTextureMap.begin()->first);
  55     }
  56 }
  57
  58 void ResourceManager::addRef()
  59 {
  60     mRefCount++;
  61 }
  62
  63 void ResourceManager::release()
  64 {
  65     if(--mRefCount == 0)
  66     {
  67         delete this;
  68     }
  69 }
  70
  71 // Returns an unused buffer name
  72 GLuint ResourceManager::createBuffer()
  73 {
  74     GLuint handle = mBufferHandleAllocator.allocate();
  75
  76     mBufferMap[handle] = NULL;
  77
  78     return handle;
  79 }
  80
  81 // Returns an unused shader/program name
  82 GLuint ResourceManager::createShader(GLenum type)
  83 {
  84     GLuint handle = mProgramShaderHandleAllocator.allocate();
  85
  86     if(type == GL_VERTEX_SHADER)
  87     {
  88         mShaderMap[handle] = new VertexShader(this, handle);
  89     }
  90     else if(type == GL_FRAGMENT_SHADER)
  91     {
  92         mShaderMap[handle] = new FragmentShader(this, handle);
  93     }
  94     else UNREACHABLE();
  95
  96     return handle;
  97 }
  98
  99 // Returns an unused program/shader name
 100 GLuint ResourceManager::createProgram()
 101 {
 102     GLuint handle = mProgramShaderHandleAllocator.allocate();
 103
 104     mProgramMap[handle] = new Program(this, handle);
 105
 106     return handle;
 107 }
 108
 109 // Returns an unused texture name
 110 GLuint ResourceManager::createTexture()
 111 {
 112     GLuint handle = mTextureHandleAllocator.allocate();
 113
 114     mTextureMap[handle] = NULL;
 115
 116     return handle;
 117 }
 118
 119 // Returns an unused renderbuffer name
 120 GLuint ResourceManager::createRenderbuffer()
 121 {
 122     GLuint handle = mRenderbufferHandleAllocator.allocate();
 123
 124     mRenderbufferMap[handle] = NULL;
 125
 126     return handle;
 127 }
 128
 129 void ResourceManager::deleteBuffer(GLuint buffer)
 130 {
 131     BufferMap::iterator bufferObject = mBufferMap.find(buffer);
 132
 133     if(bufferObject != mBufferMap.end())
 134     {
 135         mBufferHandleAllocator.release(bufferObject->first);
 136         if(bufferObject->second) bufferObject->second->release();
 137         mBufferMap.erase(bufferObject);
 138     }
 139 }
 140
 141 void ResourceManager::deleteShader(GLuint shader)
 142 {
 143     ShaderMap::iterator shaderObject = mShaderMap.find(shader);
 144
 145     if(shaderObject != mShaderMap.end())
 146     {
 147         if(shaderObject->second->getRefCount() == 0)
 148         {
 149             mProgramShaderHandleAllocator.release(shaderObject->first);
 150             delete shaderObject->second;
 151             mShaderMap.erase(shaderObject);
 152         }
 153         else
 154         {
 155             shaderObject->second->flagForDeletion();
 156         }
 157     }
 158 }
 159
 160 void ResourceManager::deleteProgram(GLuint program)
 161 {
 162     ProgramMap::iterator programObject = mProgramMap.find(program);
 163
 164     if(programObject != mProgramMap.end())
 165     {
 166         if(programObject->second->getRefCount() == 0)
 167         {
 168             mProgramShaderHandleAllocator.release(programObject->first);
 169             delete programObject->second;
 170             mProgramMap.erase(programObject);
 171         }
 172         else
 173         {
 174             programObject->second->flagForDeletion();
 175         }
 176     }
 177 }
 178
 179 void ResourceManager::deleteTexture(GLuint texture)
 180 {
 181     TextureMap::iterator textureObject = mTextureMap.find(texture);
 182
 183     if(textureObject != mTextureMap.end())
 184     {
 185         mTextureHandleAllocator.release(textureObject->first);
 186         if(textureObject->second) textureObject->second->release();
 187         mTextureMap.erase(textureObject);
 188     }
 189 }
 190
 191 void ResourceManager::deleteRenderbuffer(GLuint renderbuffer)
 192 {
 193     RenderbufferMap::iterator renderbufferObject = mRenderbufferMap.find(renderbuffer);
 194
 195     if(renderbufferObject != mRenderbufferMap.end())
 196     {
 197         mRenderbufferHandleAllocator.release(renderbufferObject->first);
 198         if(renderbufferObject->second) renderbufferObject->second->release();
 199         mRenderbufferMap.erase(renderbufferObject);
 200     }
 201 }
 202
 203 Buffer *ResourceManager::getBuffer(unsigned int handle)
 204 {
 205     BufferMap::iterator buffer = mBufferMap.find(handle);
 206
 207     if(buffer == mBufferMap.end())
 208     {
 209         return NULL;
 210     }
 211     else
 212     {
 213         return buffer->second;
 214     }
 215 }
 216
 217 Shader *ResourceManager::getShader(unsigned int handle)
 218 {
 219     ShaderMap::iterator shader = mShaderMap.find(handle);
 220
 221     if(shader == mShaderMap.end())
 222     {
 223         return NULL;
 224     }
 225     else
 226     {
 227         return shader->second;
 228     }
 229 }
 230
 231 Texture *ResourceManager::getTexture(unsigned int handle)
 232 {
 233     if(handle == 0) return NULL;
 234
 235     TextureMap::iterator texture = mTextureMap.find(handle);
 236
 237     if(texture == mTextureMap.end())
 238     {
 239         return NULL;
 240     }
 241     else
 242     {
 243         return texture->second;
 244     }
 245 }
 246
 247 Program *ResourceManager::getProgram(unsigned int handle)
 248 {
 249     ProgramMap::iterator program = mProgramMap.find(handle);
 250
 251     if(program == mProgramMap.end())
 252     {
 253         return NULL;
 254     }
 255     else
 256     {
 257         return program->second;
 258     }
 259 }
 260
 261 Renderbuffer *ResourceManager::getRenderbuffer(unsigned int handle)
 262 {
 263     RenderbufferMap::iterator renderbuffer = mRenderbufferMap.find(handle);
 264
 265     if(renderbuffer == mRenderbufferMap.end())
 266     {
 267         return NULL;
 268     }
 269     else
 270     {
 271                 if (!renderbuffer->second)
 272                 {
 273                         Renderbuffer *renderbufferObject = new Renderbuffer(handle, new Colorbuffer(0, 0, GL_RGBA4_OES, 0));
 274                         mRenderbufferMap[handle] = renderbufferObject;
 275                         renderbufferObject->addRef();
 276                 }
 277         return renderbuffer->second;
 278     }
 279 }
 280
 281 void ResourceManager::setRenderbuffer(GLuint handle, Renderbuffer *buffer)
 282 {
 283     mRenderbufferMap[handle] = buffer;
 284 }
 285
 286 void ResourceManager::checkBufferAllocation(unsigned int buffer)
 287 {
 288     if(buffer != 0 && !getBuffer(buffer))
 289     {
 290         Buffer *bufferObject = new Buffer(buffer);
 291         mBufferMap[buffer] = bufferObject;
 292         bufferObject->addRef();
 293     }
 294 }
 295
 296 void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
 297 {
 298     if(!getTexture(texture) && texture != 0)
 299     {
 300         Texture *textureObject;
 301
 302         if(type == TEXTURE_2D)
 303         {
 304             textureObject = new Texture2D(texture);
 305         }
 306         else if(type == TEXTURE_CUBE)
 307         {
 308             textureObject = new TextureCubeMap(texture);
 309         }
 310         else if(type == TEXTURE_EXTERNAL)
 311         {
 312             textureObject = new TextureExternal(texture);
 313         }
 314         else
 315         {
 316             UNREACHABLE();
 317             return;
 318         }
 319
 320         mTextureMap[texture] = textureObject;
 321         textureObject->addRef();
 322     }
 323 }
 324
 325 }