350 lines
14 KiB
C++
350 lines
14 KiB
C++
/*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* Copyright:
|
|
* 2016-2017, Danny Robson <danny@nerdcruft.net>
|
|
*/
|
|
|
|
#ifndef CRUFT_VK_TRAITS_HPP
|
|
#define CRUFT_VK_TRAITS_HPP
|
|
|
|
#include "./fwd.hpp"
|
|
#include "./vk.hpp"
|
|
|
|
#include <cruft/util/tuple.hpp>
|
|
|
|
#include <type_traits>
|
|
|
|
|
|
namespace cruft::vk {
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// describes the native type that corresponds to a given vk-cruft type.
|
|
template <typename> struct native_traits { };
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <> struct native_traits<buffer> { using type = VkBuffer; };
|
|
template <> struct native_traits<buffer_view> { using type = VkBufferView; };
|
|
template <> struct native_traits<command_buffer> { using type = VkCommandBuffer; };
|
|
template <> struct native_traits<command_pool> { using type = VkCommandPool; };
|
|
template <> struct native_traits<device_memory> { using type = VkDeviceMemory; };
|
|
template <> struct native_traits<device> { using type = VkDevice; };
|
|
template <> struct native_traits<event> { using type = VkEvent; };
|
|
template <> struct native_traits<fence> { using type = VkFence; };
|
|
template <> struct native_traits<framebuffer> { using type = VkFramebuffer; };
|
|
template <> struct native_traits<image_view> { using type = VkImageView; };
|
|
template <> struct native_traits<instance> { using type = VkInstance; };
|
|
template <> struct native_traits<physical_device> { using type = VkPhysicalDevice; };
|
|
template <> struct native_traits<pipeline_cache> { using type = VkPipelineCache; };
|
|
template <> struct native_traits<pipeline_layout> { using type = VkPipelineLayout; };
|
|
|
|
template <> struct native_traits<queue> { using type = VkQueue; };
|
|
template <> struct native_traits<render_pass> { using type = VkRenderPass; };
|
|
template <> struct native_traits<semaphore> { using type = VkSemaphore; };
|
|
template <> struct native_traits<shader_module> { using type = VkShaderModule; };
|
|
template <> struct native_traits<surface> { using type = VkSurfaceKHR; };
|
|
template <> struct native_traits<swapchain> { using type = VkSwapchainKHR; };
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <>
|
|
struct native_traits<pipeline<bindpoint::GRAPHICS>>
|
|
{ using type = VkPipeline; };
|
|
|
|
template <>
|
|
struct native_traits<pipeline<bindpoint::COMPUTE>>
|
|
{ using type = VkPipeline; };
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <typename T>
|
|
using native_t = typename native_traits<T>::type;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// defines whether a type is a native vulkan object.
|
|
///
|
|
/// note that this only returns true for handle types, not parameter types.
|
|
/// eg, VkDevice will return true, but VkDeviceCreateInfo will not.
|
|
template <typename>
|
|
struct is_native : public std::false_type { };
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
#define DEFINE_IS_HANDLE(KLASS) \
|
|
template <> \
|
|
struct is_native<KLASS> : \
|
|
public std::true_type \
|
|
{ };
|
|
|
|
VK_NATIVE_TYPE_MAP (DEFINE_IS_HANDLE)
|
|
#undef DEFINE_IS_HANDLE
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <typename T>
|
|
static constexpr auto is_native_v = is_native<T>::value;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
template <typename>
|
|
struct is_wrapper : public std::false_type { };
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
#define IS_WRAPPER(KLASS) \
|
|
template <> \
|
|
struct is_wrapper<KLASS> : \
|
|
public std::true_type \
|
|
{ };
|
|
|
|
VK_TYPE_MAP(IS_WRAPPER)
|
|
#undef IS_WRAPPER
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <typename T>
|
|
static constexpr auto is_wrapper_v = is_wrapper<T>::value;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// describes the corresponding value for sType in native structures
|
|
template <typename>
|
|
struct structure_type {};
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
#define DEFINE_STRUCTURE_TYPE(KLASS,VALUE) \
|
|
template <> \
|
|
struct structure_type<KLASS> : \
|
|
public std::integral_constant< \
|
|
VkStructureType, \
|
|
PASTE(VK_STRUCTURE_TYPE_,VALUE) \
|
|
> \
|
|
{ }
|
|
|
|
DEFINE_STRUCTURE_TYPE (VkInstanceCreateInfo, INSTANCE_CREATE_INFO);
|
|
DEFINE_STRUCTURE_TYPE (VkApplicationInfo, APPLICATION_INFO);
|
|
DEFINE_STRUCTURE_TYPE (VkDeviceQueueCreateInfo, DEVICE_QUEUE_CREATE_INFO);
|
|
DEFINE_STRUCTURE_TYPE (VkDeviceCreateInfo, DEVICE_CREATE_INFO);
|
|
DEFINE_STRUCTURE_TYPE (VkSwapchainCreateInfoKHR, SWAPCHAIN_CREATE_INFO_KHR);
|
|
DEFINE_STRUCTURE_TYPE (VkImageViewCreateInfo, IMAGE_VIEW_CREATE_INFO);
|
|
DEFINE_STRUCTURE_TYPE (VkShaderModuleCreateInfo, SHADER_MODULE_CREATE_INFO);
|
|
DEFINE_STRUCTURE_TYPE (VkPipelineShaderStageCreateInfo, PIPELINE_SHADER_STAGE_CREATE_INFO);
|
|
DEFINE_STRUCTURE_TYPE (VkDebugReportCallbackCreateInfoEXT,
|
|
DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT);
|
|
|
|
#undef DEFINE_STRUCTURE_TYPE
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <typename T>
|
|
constexpr auto structure_type_v = structure_type<T>::value;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// describes the native type that owns a given native type, and hence
|
|
/// forms part of the create/destroy process.
|
|
///
|
|
/// undefined for types that aren't `owned' types.
|
|
template <typename> struct owner_traits {};
|
|
|
|
template <> struct owner_traits<buffer> { using type = device; };
|
|
template <> struct owner_traits<command_pool> { using type = device; };
|
|
template <> struct owner_traits<device_memory> { using type = device; };
|
|
template <> struct owner_traits<framebuffer> { using type = device; };
|
|
template <> struct owner_traits<image_view> { using type = device; };
|
|
template <> struct owner_traits<pipeline_layout> { using type = device; };
|
|
template <> struct owner_traits<queue> { using type = device; };
|
|
template <> struct owner_traits<render_pass> { using type = device; };
|
|
template <> struct owner_traits<semaphore> { using type = device; };
|
|
template <> struct owner_traits<shader_module> { using type = device; };
|
|
template <> struct owner_traits<surface> { using type = instance; };
|
|
template <> struct owner_traits<swapchain> { using type = device; };
|
|
template <> struct owner_traits<pipeline<bindpoint::GRAPHICS>> { using type = device; };
|
|
template <> struct owner_traits<pipeline<bindpoint::COMPUTE>> { using type = device; };
|
|
|
|
template <typename T>
|
|
using owner_t = typename owner_traits<T>::type;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// describes the parameter struct used to create a given vulkan type.
|
|
///
|
|
/// explicitly does not operate on vk-cruft types, only native types.
|
|
template <typename>
|
|
struct create_info { };
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
#define DEFINE_CREATE_INFO(TARGET,INFO) \
|
|
template <> \
|
|
struct create_info<TARGET> \
|
|
{ using type = INFO; }
|
|
|
|
DEFINE_CREATE_INFO (VkImageViewCreateInfo, VkImageViewCreateInfo);
|
|
DEFINE_CREATE_INFO (VkShaderModule, VkShaderModuleCreateInfo);
|
|
DEFINE_CREATE_INFO (VkPipelineLayout, VkPipelineLayoutCreateInfo);
|
|
|
|
#undef DEFINE_CREATE_INFO
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <typename T>
|
|
using create_info_t = typename create_info<T>::type;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// lists the `create' and `destroy' methods for a given native type.
|
|
///
|
|
/// XXX: if such a function does not exist anywhere then we currently use
|
|
/// tuple::ignore to simplify implementation elsewhere. we should probably
|
|
/// investigate std::is_detected for these cases though.
|
|
///
|
|
/// clang#18781: we make use of references types extensively here to
|
|
/// workaround a potential ODR bug in clang which results in undefined
|
|
/// references.
|
|
/// or potentially i'm being too clever for my own good, but it works fine
|
|
/// in gcc...
|
|
template <typename>
|
|
struct life_traits { };
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <> struct life_traits<VkInstance> {
|
|
static constexpr auto& create = vkCreateInstance;
|
|
static constexpr auto& destroy = vkDestroyInstance;
|
|
};
|
|
|
|
template <> struct life_traits<VkDevice> {
|
|
static constexpr auto& create = vkCreateDevice;
|
|
static constexpr auto& destroy = vkDestroyDevice;
|
|
};
|
|
|
|
template <> struct life_traits<VkImageView> {
|
|
static constexpr auto& create = vkCreateImageView;
|
|
static constexpr auto& destroy = vkDestroyImageView;
|
|
};
|
|
|
|
template <> struct life_traits<VkCommandPool> {
|
|
static constexpr auto& create = vkCreateCommandPool;
|
|
static constexpr auto& destroy = vkDestroyCommandPool;
|
|
};
|
|
|
|
template <> struct life_traits<VkFence> {
|
|
static constexpr auto& create = vkCreateFence;
|
|
static constexpr auto& destroy = vkDestroyFence;
|
|
};
|
|
|
|
template <> struct life_traits<VkSemaphore> {
|
|
static constexpr auto& create = vkCreateSemaphore;
|
|
static constexpr auto& destroy = vkDestroySemaphore;
|
|
};
|
|
|
|
template <> struct life_traits<VkEvent> {
|
|
static constexpr auto& create = vkCreateEvent;
|
|
static constexpr auto& destroy = vkDestroyEvent;
|
|
};
|
|
|
|
template <> struct life_traits<VkRenderPass> {
|
|
static constexpr auto& create = vkCreateRenderPass;
|
|
static constexpr auto& destroy = vkDestroyRenderPass;
|
|
};
|
|
|
|
template <> struct life_traits<VkFramebuffer> {
|
|
static constexpr auto& create = vkCreateFramebuffer;
|
|
static constexpr auto& destroy = vkDestroyFramebuffer;
|
|
};
|
|
|
|
template <> struct life_traits<VkShaderModule> {
|
|
static constexpr auto& create = vkCreateShaderModule;
|
|
static constexpr auto& destroy = vkDestroyShaderModule;
|
|
};
|
|
|
|
template <> struct life_traits<VkSurfaceKHR> {
|
|
static constexpr auto& destroy = vkDestroySurfaceKHR;
|
|
};
|
|
|
|
template <>
|
|
struct life_traits<VkQueue> {
|
|
static constexpr auto& create = vkGetDeviceQueue;
|
|
|
|
static constexpr auto destroy = ::util::tuple::ignore<
|
|
native_t<owner_t<queue>>,
|
|
native_t<queue>,
|
|
const VkAllocationCallbacks*
|
|
>;
|
|
};
|
|
|
|
template <> struct life_traits<VkPipelineLayout> {
|
|
static constexpr auto& create = vkCreatePipelineLayout;
|
|
static constexpr auto& destroy = vkDestroyPipelineLayout;
|
|
};
|
|
|
|
template <> struct life_traits<VkPipelineCache> {
|
|
static constexpr auto& create = vkCreatePipelineCache;
|
|
static constexpr auto& destroy = vkDestroyPipelineCache;
|
|
};
|
|
|
|
template <> struct life_traits<VkDeviceMemory> {
|
|
static constexpr auto& create = vkAllocateMemory;
|
|
static constexpr auto& destroy = vkFreeMemory;
|
|
};
|
|
|
|
template <> struct life_traits<VkBuffer> {
|
|
static constexpr auto& create = vkCreateBuffer;
|
|
static constexpr auto& destroy = vkDestroyBuffer;
|
|
};
|
|
|
|
template <> struct life_traits<VkBufferView> {
|
|
static constexpr auto& create = vkCreateBufferView;
|
|
};
|
|
|
|
|
|
template <> struct life_traits<VkSwapchainKHR> {
|
|
static constexpr auto& create = vkCreateSwapchainKHR;
|
|
static constexpr auto& destroy = vkDestroySwapchainKHR;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
template <typename T>
|
|
struct wrapper_traits : public life_traits<native_t<T>> { };
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <>
|
|
struct wrapper_traits<pipeline<bindpoint::GRAPHICS>> {
|
|
static constexpr auto &create = vkCreateGraphicsPipelines;
|
|
static constexpr auto &destroy = vkDestroyPipeline;
|
|
};
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
template <>
|
|
struct wrapper_traits<pipeline<bindpoint::COMPUTE>> {
|
|
static constexpr auto &create = vkCreateComputePipelines;
|
|
static constexpr auto &destroy = vkDestroyPipeline;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// describes the functions required to enumerate native types
|
|
template <typename> struct enum_traits { };
|
|
|
|
template <> struct enum_traits<VkPhysicalDevice> {
|
|
static constexpr auto &enumerate = vkEnumeratePhysicalDevices;
|
|
};
|
|
}
|
|
|
|
#endif
|