-#ifndef DALI_GRAPHICS_VULKAN_TYPES_H
-#define DALI_GRAPHICS_VULKAN_TYPES_H
+#ifndef DALI_GRAPHICS_VULKAN_TYPES
+#define DALI_GRAPHICS_VULKAN_TYPES
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2018 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <unordered_map>
#include <memory>
-#include <dali/graphics/vulkan/vulkan-hpp-wrapper.h>
+#include <dali/integration-api/graphics/vulkan/vulkan-hpp-wrapper.h>
namespace Dali
{
template< typename T, typename... Args >
std::unique_ptr< T > MakeUnique(Args&&... args)
{
- return std::unique_ptr< T >(new T(std::forward< Args >(args)...));
+ return std::unique_ptr< T >(new T(std::forward< Args >(args)...));
}
namespace Vulkan
* Forward class declarations
*/
class Graphics;
-class CommandBuffer;
-class CommandPool;
class Surface;
class Queue;
-class Fence;
-class DeviceMemory;
-class Image;
-class ImageView;
-class Buffer;
/**
* Unique pointers to Vulkan types
*/
-using UniqueSurface = std::unique_ptr< Surface >;
-using UniqueCommandBuffer = std::unique_ptr< CommandBuffer >;
-using UniqueCommandPool = std::unique_ptr< CommandPool >;
using UniqueQueue = std::unique_ptr< Queue >;
-using UniqueFence = std::unique_ptr< Fence >;
-using UniqueDeviceMemory = std::unique_ptr< DeviceMemory >;
-using UniqueBuffer = std::unique_ptr< Buffer >;
-using UniqueImage = std::unique_ptr< Image >;
-using UniqueImageView = std::unique_ptr< ImageView >;
/**
* Reference wrappers
*/
-using CommandBufferRef = std::reference_wrapper< CommandBuffer >;
using QueueRef = std::reference_wrapper< Queue >;
-using FenceRef = std::reference_wrapper< Fence >;
-using SurfaceRef = std::reference_wrapper< Surface >;
-
-
template< typename T >
T VkAssert(const vk::ResultValue< T >& result, vk::Result expected = vk::Result::eSuccess)
return static_cast< uint32_t >(value);
}
-class Resource
+/**
+ * Vulkan object handle
+ * @tparam T
+ */
+template<class T>
+class Handle
{
public:
- Resource() : mUserCount{0u} {}
- virtual ~Resource() = default;
- void IncreaseUserCount()
+ Handle();
+ explicit Handle(T* object );
+ Handle( const Handle& handle);
+ Handle& operator=( const Handle& handle );
+ Handle& operator=( Handle&& handle );
+ Handle( Handle&& handle ) noexcept;
+ ~Handle();
+
+ operator bool() const;
+
+ T* operator->() const
+ {
+ return mObject;
+ }
+
+ uint32_t GetRefCount() const
+ {
+ return mObject->GetRefCount();
+ }
+
+ T& operator*() const
+ {
+ return *mObject;
+ }
+
+ template <class K>
+ Handle<K> StaticCast()
{
- ++mUserCount;
+ return Handle<K>(static_cast<K*>(mObject));
}
- void DecreaseUserCount()
+ template<class K>
+ bool operator==( const Handle<K>& object ) const
{
- --mUserCount;
+ return mObject == &*object;
}
- uint32_t GetUserCount() const
+ template <class K>
+ Handle<K> DynamicCast();
+
+ void Reset()
{
- return mUserCount;
+ if( mObject )
+ {
+ mObject->Release();
+ mObject = nullptr;
+ }
}
private:
- std::atomic<uint32_t> mUserCount;
+ T* mObject { nullptr };
};
-template< typename T>
-class ResourceRef
+template <class K, class T>
+static Handle<K> VkTypeCast( const Handle<T>& inval )
{
-public:
+ return Handle<K>(static_cast<K*>(&*inval));
+}
- ResourceRef( T& object )
- : mObject( &object )
+template<class T>
+Handle<T>::Handle(T* object)
+ : mObject( object )
+{
+ if(mObject)
{
- mObject->IncreaseUserCount();
+ mObject->Retain();
}
+}
+
+template<class T>
+Handle<T>::Handle()
+ : mObject( nullptr )
+{
+}
- ResourceRef( ResourceRef& object )
+template<class T>
+Handle<T>::Handle(const Handle& handle)
+{
+ mObject = handle.mObject;
+ if(mObject)
{
- if(mObject)
- {
- mObject->DecreaseUserCount();
- }
+ mObject->Retain();
+ }
+}
+
+template<class T>
+Handle<T>::Handle( Handle&& handle ) noexcept
+{
+ mObject = handle.mObject;
+ handle.mObject = nullptr;
+}
+
+template<class T>
+Handle<T>::operator bool() const
+{
+ return mObject != nullptr;
+}
+
+template<class T>
+Handle<T>& Handle<T>::operator=( Handle&& handle )
+{
+ mObject = handle.mObject;
+ handle.mObject = nullptr;
+ return *this;
+}
- mObject = object.mObject;
- mObject->IncreaseUserCount();
+template<class T>
+Handle<T>& Handle<T>::operator=( const Handle<T>& handle )
+{
+ mObject = handle.mObject;
+ if(mObject)
+ {
+ mObject->Retain();
}
+ return *this;
+}
- ResourceRef operator=(ResourceRef& object )
+template<class T>
+Handle<T>::~Handle()
+{
+ if(mObject)
{
- if(mObject)
- {
- mObject->DecreaseUserCount();
- }
+ mObject->Release();
+ }
+}
- mObject = object.mObject;
- mObject->IncreaseUserCount();
+template<class T>
+template<class K>
+Handle<K> Handle<T>::DynamicCast()
+{
+ auto val = dynamic_cast<K*>(mObject);
+ if(val)
+ {
+ return Handle<K>(val);
}
+ return Handle<K>();
+}
+
+template< typename T, typename... Args >
+Handle< T > MakeRef(Args&&... args)
+{
+ return Handle< T >(new T(std::forward< Args >(args)...));
+}
+
+template< typename T, typename... Args >
+Handle< T > NewRef(Args&&... args)
+{
+ return Handle< T >(T::New(std::forward< Args >(args)...));
+}
+
- ~ResourceRef()
+template<class T>
+typename T::Impl& GetImpl( Handle<T>& object )
+{
+ return static_cast<typename T::Impl&>(*object->mImpl);
+}
+
+class VkManaged
+{
+public:
+
+ VkManaged() = default;
+ virtual ~VkManaged() = default;
+
+ void Release()
{
- if(mObject)
+ OnRelease(--mRefCount);
+ if(mRefCount == 0)
{
- mObject->DecreaseUserCount();
+ // orphaned
+ if(!Destroy())
+ {
+ delete this;
+ }
}
}
- T& GetResource() const
+ void Retain()
{
- return *mObject;
+ OnRetain(++mRefCount);
}
+ uint32_t GetRefCount()
+ {
+ return mRefCount;
+ }
+
+ bool Destroy()
+ {
+ return OnDestroy();
+ }
+
+ virtual void OnRetain( uint32_t refcount ) {};
+
+ virtual void OnRelease( uint32_t refcount ) {};
+
+ virtual bool OnDestroy() { return false; };
+
private:
- T* mObject;
+ std::atomic_uint mRefCount { 0u };
};
-using FBID = uint32_t;
+using FBID = int32_t;
#define NotImplemented() \
{\
}
/*
+ * Forward declarations of reference types
+ */
+using ShaderRef = Handle<class Shader>;
+using PipelineRef = Handle<class Pipeline>;
+using FenceRef = Handle<class Fence>;
+using BufferRef = Handle<class Buffer>;
+using FramebufferRef = Handle<class Framebuffer>;
+using ImageRef = Handle<class Image>;
+using ImageViewRef = Handle<class ImageView>;
+using DescriptorPoolRef = Handle<class DescriptorPool>;
+using CommandPoolRef = Handle<class CommandPool>;
+using CommandBufferRef = Handle<class CommandBuffer>;
+using GpuMemoryBlockRef = Handle<class GpuMemoryBlock>;
+using DescriptorSetRef = Handle<class DescriptorSet>;
+using SwapchainRef = Handle<class Swapchain>;
+using SurfaceRef = Handle<class Surface>;
+using SamplerRef = Handle<class Sampler>;
+/*
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wframe-larger-than="
#pragma GCC diagnostic pop
} // namespace Graphics
} // namespace Dali
-#endif // DALI_GRAPHICS_VULKAN_TYPES_H
+#endif // DALI_GRAPHICS_VULKAN_TYPES
projects / platform / core / uifw / dali-core.git / blobdiff