dali/graphics/vulkan/vulkan-resource-cache.cpp

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <dali/graphics/vulkan/vulkan-resource-cache.h>
  19
  20 #include <dali/graphics/vulkan/vulkan-buffer.h>
  21 #include <dali/graphics/vulkan/vulkan-image.h>
  22 #include <dali/graphics/vulkan/vulkan-pipeline.h>
  23 #include <dali/graphics/vulkan/vulkan-shader.h>
  24 #include <dali/graphics/vulkan/vulkan-descriptor-set.h>
  25 #include <dali/graphics/vulkan/vulkan-framebuffer.h>
  26
  27 #include <algorithm>
  28
  29 namespace Dali
  30 {
  31 namespace Graphics
  32 {
  33 namespace Vulkan
  34 {
  35
  36 ResourceCache& ResourceCache::AddBuffer( BufferRef buffer )
  37 {
  38   mBuffers.push_back( buffer );
  39   return *this;
  40 }
  41
  42 ResourceCache& ResourceCache::AddImage( ImageRef image )
  43 {
  44   mImages.push_back( image );
  45   return *this;
  46 }
  47
  48 ResourceCache& ResourceCache::AddPipeline( PipelineRef pipeline )
  49 {
  50   mPipelines.push_back( pipeline );
  51   return *this;
  52 }
  53
  54 ResourceCache& ResourceCache::AddShader( ShaderRef shader )
  55 {
  56   mShaders.push_back( shader );
  57   return *this;
  58 }
  59
  60 ResourceCache& ResourceCache::AddCommandPool( CommandPoolRef pool )
  61 {
  62   mCommandPools.push_back( pool );
  63   return *this;
  64 }
  65
  66 ResourceCache& ResourceCache::AddDescriptorPool( DescriptorPoolRef pool )
  67 {
  68   mDescriptorPools.push_back( pool );
  69   return *this;
  70 }
  71
  72 ResourceCache& ResourceCache::AddFramebuffer( FramebufferRef framebuffer )
  73 {
  74   mFramebuffers.push_back( framebuffer );
  75   return *this;
  76 }
  77
  78 ResourceCache& ResourceCache::AddSampler( SamplerRef sampler )
  79 {
  80   mSamplers.push_back(sampler);
  81   return *this;
  82 }
  83
  84 PipelineRef ResourceCache::FindPipeline( vk::Pipeline pipeline )
  85 {
  86   auto iterator = std::find_if(mPipelines.begin(),
  87                                mPipelines.end(),
  88                                [&](const PipelineRef entry) { return &*entry == pipeline; });
  89
  90   return iterator == mPipelines.end() ? PipelineRef() : PipelineRef(&**iterator);
  91 }
  92
  93 ShaderRef ResourceCache::FindShader( vk::ShaderModule shaderModule )
  94 {
  95   auto iterator = std::find_if(mShaders.begin(),
  96                                mShaders.end(),
  97                                [&](const ShaderRef entry) { return &*entry == shaderModule; });
  98
  99   return iterator == mShaders.end() ? ShaderRef() : ShaderRef(&**iterator);
 100 }
 101
 102 CommandPoolRef ResourceCache::FindCommandPool( vk::CommandPool commandPool )
 103 {
 104   auto iterator = std::find_if(mCommandPools.begin(),
 105                                mCommandPools.end(),
 106                                [&](const CommandPoolRef entry) { return &*entry == commandPool; });
 107
 108   return iterator == mCommandPools.end() ? CommandPoolRef() : CommandPoolRef(&**iterator);
 109 }
 110
 111 DescriptorPoolRef ResourceCache::FindDescriptorPool( vk::DescriptorPool descriptorPool )
 112 {
 113   auto iterator = std::find_if(mDescriptorPools.begin(),
 114                                mDescriptorPools.end(),
 115                                [&](const DescriptorPoolRef entry) { return &*entry == descriptorPool; });
 116
 117   return iterator == mDescriptorPools.end() ? DescriptorPoolRef() : DescriptorPoolRef(&**iterator);
 118 }
 119
 120 FramebufferRef ResourceCache::FindFramebuffer( vk::Framebuffer framebuffer )
 121 {
 122   auto iterator = std::find_if(mFramebuffers.begin(),
 123                                mFramebuffers.end(),
 124                                [&](const FramebufferRef entry) { return &*entry == framebuffer; });
 125
 126   return iterator == mFramebuffers.end() ? FramebufferRef() : FramebufferRef(&**iterator);
 127 }
 128
 129 SamplerRef ResourceCache::FindSampler( vk::Sampler sampler )
 130 {
 131   auto iterator = std::find_if(mSamplers.begin(),
 132                                mSamplers.end(),
 133                                [&](const SamplerRef entry) { return &*entry == sampler; });
 134
 135   return iterator == mSamplers.end() ? SamplerRef() : SamplerRef(&**iterator);
 136 }
 137
 138 BufferRef ResourceCache::FindBuffer( vk::Buffer buffer )
 139 {
 140   auto iterator = std::find_if(mBuffers.begin(),
 141                                mBuffers.end(),
 142                                [&](const BufferRef entry) { return &*entry == buffer; });
 143
 144   return iterator == mBuffers.end() ? BufferRef() : BufferRef(&**iterator);
 145 }
 146
 147 ImageRef ResourceCache::FindImage( vk::Image image )
 148 {
 149   auto iterator = std::find_if(mImages.begin(),
 150                                mImages.end(),
 151                                [&](const ImageRef entry) { return &*entry == image; });
 152
 153   return iterator == mImages.end() ? ImageRef() : ImageRef(&**iterator);
 154 }
 155
 156 ResourceCache& ResourceCache::RemoveBuffer( Buffer& buffer )
 157 {
 158   if( !mBuffers.empty() )
 159   {
 160     auto found = std::find_if(mBuffers.begin(),
 161                               mBuffers.end(),
 162                               [&](const BufferRef entry) { return &(*entry) == &buffer; });
 163
 164     std::iter_swap(found, std::prev(mBuffers.end()));
 165     mBuffers.back().Reset();
 166     mBuffers.pop_back();
 167   }
 168   return *this;
 169 }
 170
 171 ResourceCache& ResourceCache::RemoveImage( Image& image )
 172 {
 173   if( !mImages.empty() )
 174   {
 175     auto found = std::find_if(mImages.begin(),
 176                               mImages.end(),
 177                               [&](const ImageRef entry) { return &(*entry) == &image; });
 178
 179     std::iter_swap(found, std::prev(mImages.end()));
 180     mImages.back().Reset();
 181     mImages.pop_back();
 182   }
 183   return *this;
 184 }
 185
 186 ResourceCache& ResourceCache::RemovePipeline( Pipeline &pipeline )
 187 {
 188   if( !mPipelines.empty() )
 189   {
 190     auto found = std::find_if(mPipelines.begin(),
 191                               mPipelines.end(),
 192                               [&](const PipelineRef entry) { return &(*entry) == &pipeline; });
 193
 194     std::iter_swap(found, std::prev(mPipelines.end()));
 195     mPipelines.back().Reset();
 196     mPipelines.pop_back();
 197   }
 198   return *this;
 199 }
 200
 201 ResourceCache& ResourceCache::RemoveShader( Shader& shader )
 202 {
 203   if( !mShaders.empty() )
 204   {
 205     auto iterator = std::find_if(mShaders.begin(),
 206                                  mShaders.end(),
 207                                  [&](const ShaderRef entry) { return &*entry == &shader; });
 208
 209     std::iter_swap(iterator, std::prev(mShaders.end());
 210     mShaders.back().Reset();
 211     mShaders.pop_back();
 212   }
 213   return *this;
 214 }
 215
 216 ResourceCache& ResourceCache::RemoveCommandPool( CommandPool& commandPool )
 217 {
 218   if( !mCommandPools.empty() )
 219   {
 220     auto iterator = std::find_if(mCommandPools.begin(),
 221                                  mCommandPools.end(),
 222                                  [&](const CommandPoolRef entry) { return &*entry == &commandPool; });
 223
 224     std::iter_swap(iterator, std::prev(mCommandPools.end()));
 225     mCommandPools.back().Reset();
 226     mCommandPools.pop_back();
 227   }
 228   return *this;
 229 }
 230
 231 ResourceCache& ResourceCache::RemoveDescriptorPool( std::unique_ptr<DescriptorPool> descriptorPool )
 232 {
 233   if( !mDescriptorPools.empty() )
 234   {
 235     auto iterator = std::find_if(mDescriptorPools.begin(),
 236                                  mDescriptorPools.end(),
 237                                  [&](const DescriptorPoolRef entry) { return &*entry == &*descriptorPool; });
 238
 239     std::iter_swap(iterator, std::prev(mDescriptorPools.end()));
 240     mDescriptorPools.back().Reset();
 241     mDescriptorPools.pop_back();
 242   }
 243   return *this;
 244 }
 245
 246 ResourceCache& ResourceCache::RemoveFramebuffer( Framebuffer &framebuffer )
 247 {
 248   if( !mFramebuffers.empty() )
 249   {
 250     auto iterator = std::find_if(mFramebuffers.begin(),
 251                                  mFramebuffers.end(),
 252                                  [&](const FramebufferRef entry) { return &*entry == &framebuffer; });
 253
 254     std::iter_swap(iterator, std::prev(mFramebuffers.end()));
 255     mFramebuffers.back().Reset();
 256     mFramebuffers.pop_back();
 257   }
 258   return *this;
 259 }
 260
 261 ResourceCache& ResourceCache::RemoveSampler( Sampler &sampler )
 262 {
 263   if( !mSamplers.empty() )
 264   {
 265     auto iterator = std::find_if(mSamplers.begin(),
 266                                  mSamplers.end(),
 267                                  [&](const SamplerRef entry) { return &*entry == &sampler; });
 268
 269     std::iter_swap(iterator, std::prev(mSamplers.end()));
 270     mSamplers.back().Reset();
 271     mSamplers.pop_back();
 272   }
 273   return *this;
 274 }
 275
 276 } //namespace Vulkan
 277 } //namespace Graphics
 278 } //namespace Dali