dali/graphics/vulkan/vulkan-buffer.cpp

   1 /*
   2  * Copyright (c) 2017 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-buffer.h>
  19 #include <dali/graphics/vulkan/vulkan-graphics.h>
  20 #include <dali/graphics/vulkan/gpu-memory/vulkan-gpu-memory-manager.h>
  21 #include <dali/graphics/vulkan/gpu-memory/vulkan-gpu-memory-handle.h>
  22
  23 namespace Dali
  24 {
  25 namespace Graphics
  26 {
  27 namespace Vulkan
  28 {
  29
  30 struct Buffer::Impl final
  31 {
  32   /**
  33    *
  34    * @param graphics
  35    * @param createInfo
  36    */
  37   Impl(Graphics& graphics, Buffer& owner, const vk::BufferCreateInfo& createInfo)
  38   : mGraphics(graphics),
  39     mInterface( owner ),
  40     mDeviceMemory(nullptr),
  41     mInfo(createInfo)
  42   {
  43   }
  44
  45   /**
  46    *
  47    */
  48   ~Impl()
  49   {
  50     mGraphics.GetDevice().destroyBuffer( mBuffer, mGraphics.GetAllocator() );
  51   }
  52
  53   /**
  54    * Initialises Buffer with memory, as host visible ( for write )
  55    * @return
  56    */
  57   bool Initialise()
  58   {
  59     mBuffer = VkAssert(mGraphics.GetDevice().createBuffer( mInfo, mGraphics.GetAllocator()));
  60     return true;
  61   }
  62
  63   /**
  64    *
  65    * @return
  66    */
  67   vk::BufferUsageFlags GetUsage() const
  68   {
  69     return mInfo.usage;
  70   }
  71
  72   /**
  73    *
  74    * @return
  75    */
  76   size_t GetSize() const
  77   {
  78     return static_cast<size_t>(mInfo.size);
  79   }
  80
  81   /**
  82    *
  83    * @return
  84    */
  85   vk::Buffer GetVkBuffer() const
  86   {
  87     return mBuffer;
  88   }
  89
  90   void BindMemory( GpuMemoryBlockHandle handle )
  91   {
  92     assert( mBuffer && "Buffer not initialised!");
  93     VkAssert(mGraphics.GetDevice().bindBufferMemory( mBuffer, (*handle), 0 ));
  94     mDeviceMemory = handle;
  95   }
  96
  97   Vulkan::Graphics&                     mGraphics;
  98   Vulkan::Buffer&                       mInterface;
  99   GpuMemoryBlockHandle                  mDeviceMemory;
 100   vk::BufferCreateInfo                  mInfo;
 101   vk::Buffer                            mBuffer;
 102 };
 103
 104 /**
 105  *
 106  * @param graphics
 107  * @param size
 108  * @return
 109  */
 110 BufferHandle Buffer::New(Graphics& graphics, size_t size, Type type)
 111 {
 112   auto usageFlags = vk::BufferUsageFlags{};
 113
 114   switch( type )
 115   {
 116     case Type::VERTEX: { usageFlags |= vk::BufferUsageFlagBits::eVertexBuffer; break; };
 117     case Type::INDEX: { usageFlags |= vk::BufferUsageFlagBits::eIndexBuffer; break; };
 118     case Type::UNIFORM: { usageFlags |= vk::BufferUsageFlagBits::eUniformBuffer; break; };
 119     case Type::SHADER_STORAGE: { usageFlags |= vk::BufferUsageFlagBits::eStorageBuffer; break; };
 120   }
 121
 122   auto info = vk::BufferCreateInfo{};
 123   info.setSharingMode( vk::SharingMode::eExclusive );
 124   info.setSize( size );
 125   info.setUsage( usageFlags | vk::BufferUsageFlagBits::eTransferDst );
 126   auto buffer = Handle<Buffer>( new Buffer(graphics, info) );
 127
 128   if(buffer && buffer->mImpl->Initialise())
 129   {
 130     graphics.AddBuffer( buffer );
 131   }
 132   return buffer;
 133 }
 134
 135 Buffer::Buffer(Graphics& graphics, const vk::BufferCreateInfo& createInfo)
 136 : VkManaged()
 137 {
 138   mImpl = MakeUnique<Buffer::Impl>(graphics, *this, createInfo);
 139 }
 140
 141 Buffer::~Buffer() = default;
 142
 143 vk::BufferUsageFlags Buffer::GetUsage() const
 144 {
 145   return mImpl->GetUsage();
 146 }
 147
 148 const GpuMemoryBlockHandle& Buffer::GetMemoryHandle() const
 149 {
 150   return mImpl->mDeviceMemory;
 151 }
 152
 153 uint32_t Buffer::GetSize() const
 154 {
 155   return U32(mImpl->GetSize());
 156 }
 157
 158 vk::Buffer Buffer::GetVkBuffer() const
 159 {
 160   return mImpl->GetVkBuffer();
 161 }
 162
 163 void Buffer::BindMemory( const GpuMemoryBlockHandle& handle )
 164 {
 165   mImpl->BindMemory( handle );
 166 }
 167
 168 bool Buffer::OnDestroy()
 169 {
 170   mImpl->mGraphics.RemoveBuffer( *this );
 171   return true;
 172 }
 173
 174
 175 }
 176
 177 }
 178
 179 }