1// Copyright 2016 The SwiftShader Authors. All Rights Reserved. 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15// ResourceManager.cpp: Implements the ResourceManager class, which tracks and 16// retrieves objects which may be shared by multiple Contexts. 17 18#include "ResourceManager.h" 19 20#include "Buffer.h" 21#include "Renderbuffer.h" 22#include "Texture.h" 23 24namespace es1 25{ 26ResourceManager::ResourceManager() 27{ 28 mRefCount = 1; 29} 30 31ResourceManager::~ResourceManager() 32{ 33 while(!mBufferNameSpace.empty()) 34 { 35 deleteBuffer(mBufferNameSpace.firstName()); 36 } 37 38 while(!mRenderbufferNameSpace.empty()) 39 { 40 deleteRenderbuffer(mRenderbufferNameSpace.firstName()); 41 } 42 43 while(!mTextureNameSpace.empty()) 44 { 45 deleteTexture(mTextureNameSpace.firstName()); 46 } 47} 48 49void ResourceManager::addRef() 50{ 51 mRefCount++; 52} 53 54void ResourceManager::release() 55{ 56 if(--mRefCount == 0) 57 { 58 delete this; 59 } 60} 61 62// Returns an unused buffer name 63GLuint ResourceManager::createBuffer() 64{ 65 return mBufferNameSpace.allocate(); 66} 67 68// Returns an unused texture name 69GLuint ResourceManager::createTexture() 70{ 71 return mTextureNameSpace.allocate(); 72} 73 74// Returns an unused renderbuffer name 75GLuint ResourceManager::createRenderbuffer() 76{ 77 return mRenderbufferNameSpace.allocate(); 78} 79 80void ResourceManager::deleteBuffer(GLuint buffer) 81{ 82 Buffer *bufferObject = mBufferNameSpace.remove(buffer); 83 84 if(bufferObject) 85 { 86 bufferObject->release(); 87 } 88} 89 90void ResourceManager::deleteTexture(GLuint texture) 91{ 92 Texture *textureObject = mTextureNameSpace.remove(texture); 93 94 if(textureObject) 95 { 96 textureObject->release(); 97 } 98} 99 100void ResourceManager::deleteRenderbuffer(GLuint renderbuffer) 101{ 102 Renderbuffer *renderbufferObject = mRenderbufferNameSpace.remove(renderbuffer); 103 104 if(renderbufferObject) 105 { 106 renderbufferObject->release(); 107 } 108} 109 110Buffer *ResourceManager::getBuffer(unsigned int handle) 111{ 112 return mBufferNameSpace.find(handle); 113} 114 115Texture *ResourceManager::getTexture(unsigned int handle) 116{ 117 return mTextureNameSpace.find(handle); 118} 119 120Renderbuffer *ResourceManager::getRenderbuffer(unsigned int handle) 121{ 122 return mRenderbufferNameSpace.find(handle); 123} 124 125void ResourceManager::checkBufferAllocation(unsigned int buffer) 126{ 127 if(buffer != 0 && !getBuffer(buffer)) 128 { 129 Buffer *bufferObject = new Buffer(buffer); 130 bufferObject->addRef(); 131 132 mBufferNameSpace.insert(buffer, bufferObject); 133 } 134} 135 136void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type) 137{ 138 if(!getTexture(texture) && texture != 0) 139 { 140 Texture *textureObject; 141 142 if(type == TEXTURE_2D) 143 { 144 textureObject = new Texture2D(texture); 145 } 146 else if(type == TEXTURE_EXTERNAL) 147 { 148 textureObject = new TextureExternal(texture); 149 } 150 else 151 { 152 UNREACHABLE(type); 153 return; 154 } 155 156 textureObject->addRef(); 157 158 mTextureNameSpace.insert(texture, textureObject); 159 } 160} 161 162void ResourceManager::checkRenderbufferAllocation(GLuint handle) 163{ 164 if(handle != 0 && !getRenderbuffer(handle)) 165 { 166 Renderbuffer *renderbufferObject = new Renderbuffer(handle, new Colorbuffer(0, 0, GL_RGBA4_OES, 0)); 167 renderbufferObject->addRef(); 168 169 mRenderbufferNameSpace.insert(handle, renderbufferObject); 170 } 171} 172 173} 174