libcruft-vk/traits.hpp

/*
 * 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 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 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);

    #undef DEFINE_CREATE_INFO


    //-------------------------------------------------------------------------
    template <typename T>
    using create_info_t = typename create_info<T>::type;


    ///////////////////////////////////////////////////////////////////////////
    /// describes the native type that corresponds to a given vk-cruft type.
    template <typename> struct id_traits { };


    //-------------------------------------------------------------------------
    template <> struct id_traits<instance> { using type = VkInstance; };
    template <> struct id_traits<physical_device> { using type = VkPhysicalDevice; };
    template <> struct id_traits<device> { using type = VkDevice; };
    template <> struct id_traits<queue> { using type = VkQueue; };
    template <> struct id_traits<command_pool> { using type = VkCommandPool; };
    template <> struct id_traits<command_buffer> { using type = VkCommandBuffer; };
    template <> struct id_traits<fence> { using type = VkFence; };
    template <> struct id_traits<semaphore> { using type = VkSemaphore; };
    template <> struct id_traits<event> { using type = VkEvent; };
    template <> struct id_traits<render_pass> { using type = VkRenderPass; };
    template <> struct id_traits<framebuffer> { using type = VkFramebuffer; };
    template <> struct id_traits<shader_module> { using type = VkShaderModule; };
    template <> struct id_traits<pipeline> { using type = VkPipeline; };
    template <> struct id_traits<pipeline_cache> { using type = VkPipelineCache; };
    template <> struct id_traits<device_memory> { using type = VkDeviceMemory; };
    template <> struct id_traits<buffer> { using type = VkBuffer; };
    template <> struct id_traits<buffer_view> { using type = VkBufferView; };
    template <> struct id_traits<surface> { using type = VkSurfaceKHR; };


    //-------------------------------------------------------------------------
    template <typename T>
    using id_t = typename id_traits<T>::type;


    ///////////////////////////////////////////////////////////////////////////
    /// 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<queue> { using type = device; };
    template <> struct owner_traits<surface> { using type = instance; };

    template <typename T>
    using owner_t = typename owner_traits<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.
    template <typename>
    struct life_traits { };


    //-------------------------------------------------------------------------
    template <> struct life_traits<instance> {
        static constexpr auto create  = vkCreateInstance;
        static constexpr auto destroy = vkDestroyInstance;
    };

    template <> struct life_traits<device> {
        static constexpr auto create = vkCreateDevice;
        static constexpr auto destroy = vkDestroyDevice;
    };

    template <> struct life_traits<command_pool> {
        static constexpr auto create = vkCreateCommandPool;
        static constexpr auto destroy = vkDestroyCommandPool;
    };

    template <> struct life_traits<fence> {
        static constexpr auto create = vkCreateFence;
        static constexpr auto destroy = vkDestroyFence;
    };

    template <> struct life_traits<semaphore> {
        static constexpr auto create = vkCreateSemaphore;
        static constexpr auto destroy = vkDestroySemaphore;
    };

    template <> struct life_traits<event> {
        static constexpr auto create = vkCreateEvent;
        static constexpr auto destroy = vkDestroyEvent;
    };

    template <> struct life_traits<render_pass> {
        static constexpr auto create = vkCreateRenderPass;
        static constexpr auto destroy = vkDestroyRenderPass;
    };

    template <> struct life_traits<framebuffer> {
        static constexpr auto create = vkCreateFramebuffer;
        static constexpr auto destroy = vkDestroyFramebuffer;
    };

    template <> struct life_traits<shader_module> {
        static constexpr auto create = vkCreateShaderModule;
        static constexpr auto destroy = vkDestroyShaderModule;
    };

    template <> struct life_traits<surface> {
        static constexpr auto destroy = vkDestroySurfaceKHR;
    };

    template <>
    struct life_traits<queue> {
        // clang#18781: we work around an ODR bug in clang which causes
        // undefined references by explicitly using a temporary here. ideally
        // this causes minimal difference in the generated output.
        using create_t = decltype(vkGetDeviceQueue);
        static constexpr create_t& create = vkGetDeviceQueue;

        static constexpr auto destroy = ::util::tuple::ignore<
            id_t<owner_t<queue>>,
            id_t<queue>,
            const VkAllocationCallbacks*
        >;
    };

    template <VkPipelineBindPoint> struct create_traits { };
    template <> struct create_traits<VK_PIPELINE_BIND_POINT_COMPUTE> {
        static constexpr auto func = vkCreateComputePipelines;
    };
    template <> struct create_traits<VK_PIPELINE_BIND_POINT_GRAPHICS> {
        static constexpr auto func = vkCreateGraphicsPipelines;
    };

    // XXX: Currently causes a segfault under gcc-5.3.0 when stabs debgging is
    // enabled. See gcc#71058
    //
    //template <> struct life_traits<pipeline> {
    //    template <VkPipelineBindPoint P>
    //    static constexpr auto create = create_traits<P>::func;
    //    static constexpr auto destroy = vkDestroyPipeline;
    //};

    template <> struct life_traits<pipeline_cache> {
        static constexpr auto create = vkCreatePipelineCache;
        static constexpr auto destroy = vkDestroyPipelineCache;
    };

    template <> struct life_traits<device_memory> {
        static constexpr auto create = vkAllocateMemory;
        static constexpr auto destroy = vkFreeMemory;
    };

    template <> struct life_traits<buffer> {
        static constexpr auto create = vkCreateBuffer;
        static constexpr auto destroy = vkDestroyBuffer;
    };

    template <> struct life_traits<buffer_view> {
        static constexpr auto create = vkCreateBufferView;
    };


    ///////////////////////////////////////////////////////////////////////////
    /// describes the functions required to enumerate native types
    template <typename> struct enum_traits { };

    template <> struct enum_traits<physical_device> {
        static constexpr auto enumerate = vkEnumeratePhysicalDevices;
    };
}

#endif