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 #include <dali/graphics/vulkan/vulkan-command-pool.h>
  27 #include <dali/graphics/vulkan/vulkan-sampler.h>
  28
  29 #include <algorithm>
  30
  31 namespace Dali
  32 {
  33 namespace Graphics
  34 {
  35 namespace Vulkan
  36 {
  37
  38 ResourceCache& ResourceCache::AddBuffer( BufferRef buffer )
  39 {
  40   mBuffers.push_back( buffer );
  41   return *this;
  42 }
  43
  44 ResourceCache& ResourceCache::AddImage( ImageRef image )
  45 {
  46   mImages.push_back( image );
  47   return *this;
  48 }
  49
  50 ResourceCache& ResourceCache::AddPipeline( PipelineRef pipeline )
  51 {
  52   mPipelines.push_back( pipeline );
  53   return *this;
  54 }
  55
  56 ResourceCache& ResourceCache::AddShader( ShaderRef shader )
  57 {
  58   mShaders.push_back( shader );
  59   return *this;
  60 }
  61
  62 ResourceCache& ResourceCache::AddCommandPool( CommandPoolRef pool )
  63 {
  64   mCommandPools.push_back( pool );
  65   return *this;
  66 }
  67
  68 ResourceCache& ResourceCache::AddDescriptorPool( DescriptorPoolRef pool )
  69 {
  70   mDescriptorPools.push_back( pool );
  71   return *this;
  72 }
  73
  74 ResourceCache& ResourceCache::AddFramebuffer( FramebufferRef framebuffer )
  75 {
  76   mFramebuffers.push_back( framebuffer );
  77   return *this;
  78 }
  79
  80 ResourceCache& ResourceCache::AddSampler( SamplerRef sampler )
  81 {
  82   mSamplers.push_back(sampler);
  83   return *this;
  84 }
  85
  86 PipelineRef ResourceCache::FindPipeline( vk::Pipeline pipeline )
  87 {
  88   auto iterator = std::find_if(mPipelines.begin(),
  89                                mPipelines.end(),
  90                                [&](const PipelineRef entry) { return entry->GetVkHandle() == pipeline; });
  91
  92   return iterator == mPipelines.end() ? PipelineRef() : PipelineRef(&**iterator);
  93 }
  94
  95 ShaderRef ResourceCache::FindShader( vk::ShaderModule shaderModule )
  96 {
  97   auto iterator = std::find_if(mShaders.begin(),
  98                                mShaders.end(),
  99                                [&](const ShaderRef entry) { return entry->GetVkHandle() == shaderModule; });
 100
 101   return iterator == mShaders.end() ? ShaderRef() : ShaderRef(&**iterator);
 102 }
 103
 104 CommandPoolRef ResourceCache::FindCommandPool( vk::CommandPool commandPool )
 105 {
 106   auto iterator = std::find_if(mCommandPools.begin(),
 107                                mCommandPools.end(),
 108                                [&](const CommandPoolRef entry) { return entry->GetVkHandle() == commandPool; });
 109
 110   return iterator == mCommandPools.end() ? CommandPoolRef() : CommandPoolRef(&**iterator);
 111 }
 112
 113 DescriptorPoolRef ResourceCache::FindDescriptorPool( vk::DescriptorPool descriptorPool )
 114 {
 115   auto iterator = std::find_if(mDescriptorPools.begin(),
 116                                mDescriptorPools.end(),
 117                                [&](const DescriptorPoolRef entry) { return entry->GetVkHandle() == descriptorPool; });
 118
 119   return iterator == mDescriptorPools.end() ? DescriptorPoolRef() : DescriptorPoolRef(&**iterator);
 120 }
 121
 122 FramebufferRef ResourceCache::FindFramebuffer( vk::Framebuffer framebuffer )
 123 {
 124   auto iterator = std::find_if(mFramebuffers.begin(),
 125                                mFramebuffers.end(),
 126                                [&](const FramebufferRef entry) { return entry->GetVkHandle() == framebuffer; });
 127
 128   return iterator == mFramebuffers.end() ? FramebufferRef() : FramebufferRef(&**iterator);
 129 }
 130
 131 SamplerRef ResourceCache::FindSampler( vk::Sampler sampler )
 132 {
 133   auto iterator = std::find_if(mSamplers.begin(),
 134                                mSamplers.end(),
 135                                [&](const SamplerRef entry) { return entry->GetVkHandle() == sampler; });
 136
 137   return iterator == mSamplers.end() ? SamplerRef() : SamplerRef(&**iterator);
 138 }
 139
 140 BufferRef ResourceCache::FindBuffer( vk::Buffer buffer )
 141 {
 142   auto iterator = std::find_if(mBuffers.begin(),
 143                                mBuffers.end(),
 144                                [&](const BufferRef entry) { return entry->GetVkHandle() == buffer; });
 145
 146   return iterator == mBuffers.end() ? BufferRef() : BufferRef(&**iterator);
 147 }
 148
 149 ImageRef ResourceCache::FindImage( vk::Image image )
 150 {
 151   auto iterator = std::find_if(mImages.begin(),
 152                                mImages.end(),
 153                                [&](const ImageRef entry) { return entry->GetVkHandle() == image; });
 154
 155   return iterator == mImages.end() ? ImageRef() : ImageRef(&**iterator);
 156 }
 157
 158 ResourceCache& ResourceCache::RemoveBuffer( Buffer& buffer )
 159 {
 160   if( !mBuffers.empty() )
 161   {
 162     auto found = std::find_if(mBuffers.begin(),
 163                               mBuffers.end(),
 164                               [&](const BufferRef entry) { return &(*entry) == &buffer; });
 165
 166     std::iter_swap(found, std::prev(mBuffers.end()));
 167     mBuffers.back().Reset();
 168     mBuffers.pop_back();
 169   }
 170   return *this;
 171 }
 172
 173 ResourceCache& ResourceCache::RemoveImage( Image& image )
 174 {
 175   if( !mImages.empty() )
 176   {
 177     auto found = std::find_if(mImages.begin(),
 178                               mImages.end(),
 179                               [&](const ImageRef entry) { return &(*entry) == &image; });
 180
 181     std::iter_swap(found, std::prev(mImages.end()));
 182     mImages.back().Reset();
 183     mImages.pop_back();
 184   }
 185   return *this;
 186 }
 187
 188 ResourceCache& ResourceCache::RemovePipeline( Pipeline &pipeline )
 189 {
 190   if( !mPipelines.empty() )
 191   {
 192     auto found = std::find_if(mPipelines.begin(),
 193                               mPipelines.end(),
 194                               [&](const PipelineRef entry) { return &(*entry) == &pipeline; });
 195
 196     std::iter_swap(found, std::prev(mPipelines.end()));
 197     mPipelines.back().Reset();
 198     mPipelines.pop_back();
 199   }
 200   return *this;
 201 }
 202
 203 ResourceCache& ResourceCache::RemoveShader( Shader& shader )
 204 {
 205   if( !mShaders.empty() )
 206   {
 207     auto iterator = std::find_if(mShaders.begin(),
 208                                  mShaders.end(),
 209                                  [&](const ShaderRef entry) { return &*entry == &shader; });
 210
 211     std::iter_swap(iterator, std::prev(mShaders.end()));
 212     mShaders.back().Reset();
 213     mShaders.pop_back();
 214   }
 215   return *this;
 216 }
 217
 218 ResourceCache& ResourceCache::RemoveCommandPool( CommandPool& commandPool )
 219 {
 220   if( !mCommandPools.empty() )
 221   {
 222     auto iterator = std::find_if(mCommandPools.begin(),
 223                                  mCommandPools.end(),
 224                                  [&](const CommandPoolRef entry) { return &*entry == &commandPool; });
 225
 226     std::iter_swap(iterator, std::prev(mCommandPools.end()));
 227     mCommandPools.back().Reset();
 228     mCommandPools.pop_back();
 229   }
 230   return *this;
 231 }
 232
 233 ResourceCache& ResourceCache::RemoveDescriptorPool( DescriptorPool& descriptorPool )
 234 {
 235   if( !mDescriptorPools.empty() )
 236   {
 237     auto iterator = std::find_if(mDescriptorPools.begin(),
 238                                  mDescriptorPools.end(),
 239                                  [&](const DescriptorPoolRef entry) { return &*entry == &descriptorPool; });
 240
 241     std::iter_swap(iterator, std::prev(mDescriptorPools.end()));
 242     mDescriptorPools.back().Reset();
 243     mDescriptorPools.pop_back();
 244   }
 245   return *this;
 246 }
 247
 248 ResourceCache& ResourceCache::RemoveFramebuffer( Framebuffer &framebuffer )
 249 {
 250   if( !mFramebuffers.empty() )
 251   {
 252     auto iterator = std::find_if(mFramebuffers.begin(),
 253                                  mFramebuffers.end(),
 254                                  [&](const FramebufferRef entry) { return &*entry == &framebuffer; });
 255
 256     std::iter_swap(iterator, std::prev(mFramebuffers.end()));
 257     mFramebuffers.back().Reset();
 258     mFramebuffers.pop_back();
 259   }
 260   return *this;
 261 }
 262
 263 ResourceCache& ResourceCache::RemoveSampler( Sampler &sampler )
 264 {
 265   if( !mSamplers.empty() )
 266   {
 267     auto iterator = std::find_if(mSamplers.begin(),
 268                                  mSamplers.end(),
 269                                  [&](const SamplerRef entry) { return &*entry == &sampler; });
 270
 271     std::iter_swap(iterator, std::prev(mSamplers.end()));
 272     mSamplers.back().Reset();
 273     mSamplers.pop_back();
 274   }
 275   return *this;
 276 }
 277
 278 } //namespace Vulkan
 279 } //namespace Graphics
 280 } //namespace Dali