RV_Instance.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        RV_Instance.h ( RV Library, C++)
 *
 * COMMENTS:
 *      Main interface to Vulkan
 */
#ifndef RV_Instance_h
#define RV_Instance_h

#include "RV_API.h"

#include "RV_Type.h"

#include "RV_VK.h"

#include <UT/UT_UniquePtr.h>
#include <UT/UT_Array.h>

class rv_InstanceData;

class RV_DescriptorAllocator;
class RV_Render;
class RV_VKQueue;
class RV_VKCommandPool;
class RV_VKCommandBuffer;
class RV_VKCommandBufferAllocator;
class RV_VKExt;
class RV_VKMemAllocator;
class UT_WorkBuffer;

/// Handle to the main interface of Vulkan
class RV_API RV_Instance
{
public:
    /// The global vulkan instance. May be null if it hasn't been created yet.
    static RV_Instance* getInstance();
    /// Destroy the global instance. For system exit.
    static void         destroyInstance();
    /// The exit callback that's called when the vulkan instance is about to be
    /// destroyed.
    static void         exitCallback(void*);

    /// Create the global vulkan instance. Used only at startup.
    static RV_Instance* create();
    
    ~RV_Instance();

    /// Set up Vulkan once the instance is created
    bool                initializeDevice();

    /// Get the raw vulkan device assocated with this instance.
    VkDevice            getDevice();
    /// Get the raw vulkan physical device assocated with this instance.
    VkPhysicalDevice    getPhysicalDevice();
    /// Get the raw vulkan instance.
    VkInstance          getVkInst();

    /// Raw Vulkan memory properties of the physical device
    const VkPhysicalDeviceMemoryProperties* getMemoryProps() const;

    /// Our Vulkan memory allocator implementation
    RV_VKMemAllocator&       getMemAllocator() { return *myAllocator; }
    /// Our Vulkan descriptor set allocator
    RV_DescriptorAllocator&  getDescAllocator(){return *myDescriptorAllocator;}

    /// Get text information about the current driver and device
    void                     fetchDriverInfo(UT_WorkBuffer &info);

    UT_UniquePtr<RV_VKQueue>                myGraphicsQueue;
    UT_UniquePtr<RV_Render>                 myRender;

    static const uint32_t requestedInstanceVersion;
    static uint32_t     getInstanceVersion();

    /// The Vulkan version as implemented by the device driver
    uint32_t            getDeviceVersion();
    /// The vendor of the device (AMD, Intel, NVidia, MoltenVK)
    RV_GraphicsDevice   getDeviceVendor() const;

    /// Maximum supported number of color samples in a multisample framebuffer
    int                 getMaxColorSamples() const;
    /// Maximum supported number of depth samples in a multisample framebuffer
    int                 getMaxDepthSamples() const;

    /// Object containing function pointers to Vulkan extensions
    RV_VKExt*           getExt() { return myExtensions.get(); }

    /// Query if the given Vulkan extension is enabled in the device
    bool                extEnabled( const char* vk_ext_name ) const;

    /// Block until the device has finished all commands (Call with care!)
    void                 waitDeviceIdle();

    /// returns a pointer to a VkPhysicalDevice*Features structure or
    /// a nullptr if feature is not found
    const void* getPhysicalDeviceFeatures(VkStructureType feature_type) const;

private:
    RV_Instance();

    UT_UniquePtr<rv_InstanceData>           myInstance;
    UT_UniquePtr<RV_VKMemAllocator>         myAllocator;
    UT_UniquePtr<RV_DescriptorAllocator>    myDescriptorAllocator;

    UT_UniquePtr<RV_VKExt>                  myExtensions;

    UT_Array<const char*> myEnabledDevExtensions;
    UT_Array<const char*> myEnabledInstExtensions;
};

#endif