The Tor Browser: comparison gfx/angle/src/libGLESv2/ResourceManager.cpp

--1:000000000000
+:d0afe5d5b635
+#include "precompiled.h"
+//
+// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// ResourceManager.cpp: Implements the gl::ResourceManager class, which tracks and
+// retrieves objects which may be shared by multiple Contexts.
+#include "libGLESv2/ResourceManager.h"
+#include "libGLESv2/Buffer.h"
+#include "libGLESv2/Program.h"
+#include "libGLESv2/Renderbuffer.h"
+#include "libGLESv2/Shader.h"
+#include "libGLESv2/Texture.h"
+namespace gl
+{
+ResourceManager::ResourceManager(rx::Renderer *renderer)
+{
+mRefCount = 1;
+mRenderer = renderer;
+}
+ResourceManager::~ResourceManager()
+{
+while (!mBufferMap.empty())
+{
+deleteBuffer(mBufferMap.begin()->first);
+}
+while (!mProgramMap.empty())
+{
+deleteProgram(mProgramMap.begin()->first);
+}
+while (!mShaderMap.empty())
+{
+deleteShader(mShaderMap.begin()->first);
+}
+while (!mRenderbufferMap.empty())
+{
+deleteRenderbuffer(mRenderbufferMap.begin()->first);
+}
+while (!mTextureMap.empty())
+{
+deleteTexture(mTextureMap.begin()->first);
+}
+}
+void ResourceManager::addRef()
+{
+mRefCount++;
+}
+void ResourceManager::release()
+{
+if (--mRefCount == 0)
+{
+delete this;
+}
+}
+// Returns an unused buffer name
+GLuint ResourceManager::createBuffer()
+{
+GLuint handle = mBufferHandleAllocator.allocate();
+mBufferMap[handle] = NULL;
+return handle;
+}
+// Returns an unused shader/program name
+GLuint ResourceManager::createShader(GLenum type)
+{
+GLuint handle = mProgramShaderHandleAllocator.allocate();
+if (type == GL_VERTEX_SHADER)
+{
+mShaderMap[handle] = new VertexShader(this, mRenderer, handle);
+}
+else if (type == GL_FRAGMENT_SHADER)
+{
+mShaderMap[handle] = new FragmentShader(this, mRenderer, handle);
+}
+else UNREACHABLE();
+return handle;
+}
+// Returns an unused program/shader name
+GLuint ResourceManager::createProgram()
+{
+GLuint handle = mProgramShaderHandleAllocator.allocate();
+mProgramMap[handle] = new Program(mRenderer, this, handle);
+return handle;
+}
+// Returns an unused texture name
+GLuint ResourceManager::createTexture()
+{
+GLuint handle = mTextureHandleAllocator.allocate();
+mTextureMap[handle] = NULL;
+return handle;
+}
+// Returns an unused renderbuffer name
+GLuint ResourceManager::createRenderbuffer()
+{
+GLuint handle = mRenderbufferHandleAllocator.allocate();
+mRenderbufferMap[handle] = NULL;
+return handle;
+}
+void ResourceManager::deleteBuffer(GLuint buffer)
+{
+BufferMap::iterator bufferObject = mBufferMap.find(buffer);
+if (bufferObject != mBufferMap.end())
+{
+mBufferHandleAllocator.release(bufferObject->first);
+if (bufferObject->second) bufferObject->second->release();
+mBufferMap.erase(bufferObject);
+}
+}
+void ResourceManager::deleteShader(GLuint shader)
+{
+ShaderMap::iterator shaderObject = mShaderMap.find(shader);
+if (shaderObject != mShaderMap.end())
+{
+if (shaderObject->second->getRefCount() == 0)
+{
+mProgramShaderHandleAllocator.release(shaderObject->first);
+delete shaderObject->second;
+mShaderMap.erase(shaderObject);
+}
+else
+{
+shaderObject->second->flagForDeletion();
+}
+}
+}
+void ResourceManager::deleteProgram(GLuint program)
+{
+ProgramMap::iterator programObject = mProgramMap.find(program);
+if (programObject != mProgramMap.end())
+{
+if (programObject->second->getRefCount() == 0)
+{
+mProgramShaderHandleAllocator.release(programObject->first);
+delete programObject->second;
+mProgramMap.erase(programObject);
+}
+else
+{
+programObject->second->flagForDeletion();
+}
+}
+}
+void ResourceManager::deleteTexture(GLuint texture)
+{
+TextureMap::iterator textureObject = mTextureMap.find(texture);
+if (textureObject != mTextureMap.end())
+{
+mTextureHandleAllocator.release(textureObject->first);
+if (textureObject->second) textureObject->second->release();
+mTextureMap.erase(textureObject);
+}
+}
+void ResourceManager::deleteRenderbuffer(GLuint renderbuffer)
+{
+RenderbufferMap::iterator renderbufferObject = mRenderbufferMap.find(renderbuffer);
+if (renderbufferObject != mRenderbufferMap.end())
+{
+mRenderbufferHandleAllocator.release(renderbufferObject->first);
+if (renderbufferObject->second) renderbufferObject->second->release();
+mRenderbufferMap.erase(renderbufferObject);
+}
+}
+Buffer *ResourceManager::getBuffer(unsigned int handle)
+{
+BufferMap::iterator buffer = mBufferMap.find(handle);
+if (buffer == mBufferMap.end())
+{
+return NULL;
+}
+else
+{
+return buffer->second;
+}
+}
+Shader *ResourceManager::getShader(unsigned int handle)
+{
+ShaderMap::iterator shader = mShaderMap.find(handle);
+if (shader == mShaderMap.end())
+{
+return NULL;
+}
+else
+{
+return shader->second;
+}
+}
+Texture *ResourceManager::getTexture(unsigned int handle)
+{
+if (handle == 0) return NULL;
+TextureMap::iterator texture = mTextureMap.find(handle);
+if (texture == mTextureMap.end())
+{
+return NULL;
+}
+else
+{
+return texture->second;
+}
+}
+Program *ResourceManager::getProgram(unsigned int handle)
+{
+ProgramMap::iterator program = mProgramMap.find(handle);
+if (program == mProgramMap.end())
+{
+return NULL;
+}
+else
+{
+return program->second;
+}
+}
+Renderbuffer *ResourceManager::getRenderbuffer(unsigned int handle)
+{
+RenderbufferMap::iterator renderbuffer = mRenderbufferMap.find(handle);
+if (renderbuffer == mRenderbufferMap.end())
+{
+return NULL;
+}
+else
+{
+return renderbuffer->second;
+}
+}
+void ResourceManager::setRenderbuffer(GLuint handle, Renderbuffer *buffer)
+{
+mRenderbufferMap[handle] = buffer;
+}
+void ResourceManager::checkBufferAllocation(unsigned int buffer)
+{
+if (buffer != 0 && !getBuffer(buffer))
+{
+Buffer *bufferObject = new Buffer(mRenderer, buffer);
+mBufferMap[buffer] = bufferObject;
+bufferObject->addRef();
+}
+}
+void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
+{
+if (!getTexture(texture) && texture != 0)
+{
+Texture *textureObject;
+if (type == TEXTURE_2D)
+{
+textureObject = new Texture2D(mRenderer, texture);
+}
+else if (type == TEXTURE_CUBE)
+{
+textureObject = new TextureCubeMap(mRenderer, texture);
+}
+else
+{
+UNREACHABLE();
+return;
+}
+mTextureMap[texture] = textureObject;
+textureObject->addRef();
+}
+}
+void ResourceManager::checkRenderbufferAllocation(GLuint renderbuffer)
+{
+if (renderbuffer != 0 && !getRenderbuffer(renderbuffer))
+{
+Renderbuffer *renderbufferObject = new Renderbuffer(mRenderer, renderbuffer, new Colorbuffer(mRenderer, 0, 0, GL_RGBA4, 0));
+mRenderbufferMap[renderbuffer] = renderbufferObject;
+renderbufferObject->addRef();
+}
+}
+}

The Tor Browser / file comparison

comparison: gfx/angle/src/libGLESv2/ResourceManager.cpp

gfx/angle/src/libGLESv2/ResourceManager.cpp