cs237-application.hpp

Go to the documentation of this file.

 
/*
 * COPYRIGHT (c) 2023 John Reppy (http://cs.uchicago.edu/~jhr)
 * All rights reserved.
 */
 
#ifndef _CS237_APPLICATION_HPP_
#define _CS237_APPLICATION_HPP_
 
#ifndef _CS237_HPP_
#error "cs237-application.hpp should not be included directly"
#endif
 
namespace cs237 {
 
namespace __detail { class TextureBase; }
 
class Application {
 
friend class Window;
friend class Buffer;
friend class MemoryObj;
friend class __detail::TextureBase;
friend class Texture1D;
friend class Texture2D;
friend class DepthBuffer;
 
public:
 
    Application (std::vector<std::string> const &args, std::string const &name = "CS237 App");
 
    virtual ~Application ();
 
    virtual void run () = 0;
 
    std::string name () const { return this->_name; }
 
    bool debug () const { return this->_debug; }
    bool verbose () const
    {
        return (this->_messages & vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose)
            == vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose;
    }
 
    static std::vector<vk::ExtensionProperties> supportedExtensions ()
    {
        return vk::enumerateInstanceExtensionProperties(nullptr);
    }
 
    std::vector<vk::ExtensionProperties> supportedDeviceExtensions ()
    {
        return this->_gpu.enumerateDeviceExtensionProperties();
    }
 
    static std::vector<vk::LayerProperties> supportedLayers ()
    {
        return vk::enumerateInstanceLayerProperties();
    }
 
    struct SamplerInfo {
        vk::Filter magFilter;
        vk::Filter minFilter;
        vk::SamplerMipmapMode mipmapMode;
        vk::SamplerAddressMode addressModeU;
        vk::SamplerAddressMode addressModeV;
        vk::SamplerAddressMode addressModeW;
        vk::BorderColor borderColor;
 
        SamplerInfo ()
          : magFilter(vk::Filter::eLinear), minFilter(vk::Filter::eLinear),
            mipmapMode(vk::SamplerMipmapMode::eLinear),
            addressModeU(vk::SamplerAddressMode::eRepeat),
            addressModeV(vk::SamplerAddressMode::eRepeat),
            addressModeW(vk::SamplerAddressMode::eRepeat),
            borderColor(vk::BorderColor::eIntOpaqueBlack)
        { }
 
        SamplerInfo (
            vk::Filter magF, vk::Filter minF, vk::SamplerMipmapMode mm,
            vk::SamplerAddressMode am, vk::BorderColor color)
          : magFilter(magF), minFilter(minF), mipmapMode(mm),
            addressModeU(am), addressModeV(vk::SamplerAddressMode::eRepeat),
            addressModeW(vk::SamplerAddressMode::eRepeat), borderColor(color)
        { }
 
        SamplerInfo (
            vk::Filter magF, vk::Filter minF, vk::SamplerMipmapMode mm,
            vk::SamplerAddressMode am1, vk::SamplerAddressMode am2,
            vk::BorderColor color)
          : magFilter(magF), minFilter(minF), mipmapMode(mm),
            addressModeU(am1), addressModeV(am2),
            addressModeW(vk::SamplerAddressMode::eRepeat), borderColor(color)
        { }
 
    };
 
    vk::Sampler createSampler (SamplerInfo const &info);
 
    vk::Sampler createDepthSampler (SamplerInfo const &info);
 
    vk::Device device () const { return this->_device; }
 
    const vk::PhysicalDeviceProperties *props () const
    {
        if (this->_propsCache == nullptr) {
            this->_getPhysicalDeviceProperties();
        }
        return this->_propsCache;
    }
 
    const vk::PhysicalDeviceLimits *limits () const { return &this->props()->limits; }
 
    const vk::PhysicalDeviceFeatures *features () const
    {
        if (this->_featuresCache == nullptr) {
            this->_getPhysicalDeviceFeatures();
        }
        return this->_featuresCache;
    }
 
    vk::FormatProperties formatProps (vk::Format fmt) const
    {
        return this->_gpu.getFormatProperties(fmt);
    }
 
    vk::PipelineLayout createPipelineLayout (
        std::vector<vk::DescriptorSetLayout> descSets,
        std::vector<vk::PushConstantRange> pcrs)
    {
        vk::PipelineLayoutCreateInfo layoutInfo(
            {}, /* flags */
            descSets, /* set layouts */
            pcrs); /* push-constant ranges */
 
        return this->_device.createPipelineLayout(layoutInfo);
    }
 
    vk::PipelineLayout createPipelineLayout (vk::DescriptorSetLayout descSet)
    {
        vk::PipelineLayoutCreateInfo layoutInfo(
            {}, /* flags */
            descSet, /* set layouts */
            {}); /* push-constant ranges */
 
        return this->_device.createPipelineLayout(layoutInfo);
    }
 
    vk::Pipeline createPipeline (
        cs237::Shaders *shaders,
        vk::PipelineVertexInputStateCreateInfo const &vertexInfo,
        vk::PrimitiveTopology prim,
        bool primRestart,
        vk::ArrayProxy<vk::Viewport> const &viewports,
        vk::ArrayProxy<vk::Rect2D> const &scissors,
        bool depthClamp,
        vk::PolygonMode polyMode,
        vk::CullModeFlags cullMode,
        vk::FrontFace front,
        vk::PipelineLayout layout,
        vk::RenderPass renderPass,
        uint32_t subPass,
        vk::ArrayProxy<vk::DynamicState> const &dynamic);
 
    vk::Pipeline createPipeline (
        cs237::Shaders *shaders,
        vk::PipelineVertexInputStateCreateInfo const &vertexInfo,
        vk::PrimitiveTopology prim,
        vk::ArrayProxy<vk::Viewport> const &viewports,
        vk::ArrayProxy<vk::Rect2D> const &scissors,
        vk::PolygonMode polyMode,
        vk::CullModeFlags cullMode,
        vk::FrontFace front,
        vk::PipelineLayout layout,
        vk::RenderPass renderPass,
        uint32_t subPass,
        vk::ArrayProxy<vk::DynamicState> const &dynamic)
    {
        return this->createPipeline(
            shaders,
            vertexInfo,
            prim,
            false,
            viewports,
            scissors,
            false,
            polyMode,
            cullMode,
            front,
            layout,
            renderPass,
            subPass,
            dynamic);
    }
 
    vk::CommandBuffer newCommandBuf ()
    {
        vk::CommandBufferAllocateInfo allocInfo(
            this->_cmdPool,
            vk::CommandBufferLevel::ePrimary,
            1); /* buffer count */
 
        return (this->_device.allocateCommandBuffers(allocInfo))[0];
    }
 
    void beginCommands (vk::CommandBuffer cmdBuf, bool oneTime = false)
    {
        vk::CommandBufferBeginInfo beginInfo(
            oneTime
              ? vk::CommandBufferUsageFlagBits::eOneTimeSubmit
              : vk::CommandBufferUsageFlags());
        cmdBuf.begin(beginInfo);
    }
 
    void endCommands (vk::CommandBuffer cmdBuf) { cmdBuf.end(); }
 
    void submitCommands (vk::CommandBuffer cmdBuf)
    {
        vk::CommandBuffer cmdBufs[1] = { cmdBuf };
        vk::SubmitInfo submitInfo(
            {},
            {},
            vk::ArrayProxyNoTemporaries<const vk::CommandBuffer>(1, cmdBufs),
            {});
        this->_queues.graphics.submit ({submitInfo});
        this->_queues.graphics.waitIdle();
    }
 
    void freeCommandBuf (vk::CommandBuffer & cmdBuf)
    {
        this->_device.freeCommandBuffers (this->_cmdPool, cmdBuf);
    }
 
protected:
    template <typename T>
    struct Queues {
        T graphics;             
        T present;              
    };
 
    // information about swap-chain support
    struct SwapChainDetails {
        vk::SurfaceCapabilitiesKHR capabilities;
        std::vector<vk::SurfaceFormatKHR> formats;
        std::vector<vk::PresentModeKHR> presentModes;
    };
 
    std::string _name;          
    vk::DebugUtilsMessageSeverityFlagsEXT _messages;
    bool _debug;                
    vk::Instance _instance;     
    vk::PhysicalDevice _gpu;    
    mutable vk::PhysicalDeviceProperties *_propsCache;
    mutable vk::PhysicalDeviceFeatures *_featuresCache;
    vk::Device _device;         
    Queues<uint32_t> _qIdxs;    
    Queues<vk::Queue> _queues;  
    vk::CommandPool _cmdPool;   
 
    void _createInstance ();
 
    void _getPhysicalDeviceProperties () const;
 
    void _getPhysicalDeviceFeatures () const;
 
    void _selectDevice (vk::PhysicalDeviceFeatures *reqFeatures = nullptr);
 
    int32_t _findMemory (uint32_t reqTypeBits, vk::MemoryPropertyFlags reqProps) const;
 
    vk::Format _findBestFormat (
        std::vector<vk::Format> candidates,
        vk::ImageTiling tiling,
        vk::FormatFeatureFlags features);
 
    void _initCommandPool ();
 
    vk::Format _depthStencilBufferFormat (bool depth, bool stencil);
 
    bool _getQIndices (vk::PhysicalDevice dev);
 
    void _createLogicalDevice ();
 
    vk::Image _createImage (
        uint32_t wid,
        uint32_t ht,
        vk::Format format,
        vk::ImageTiling tiling,
        vk::ImageUsageFlags usage,
        vk::ImageLayout layout,
        uint32_t mipLvls = 1);
 
    vk::Image _createImage (
        uint32_t wid,
        uint32_t ht,
        vk::Format format,
        vk::ImageTiling tiling,
        vk::ImageUsageFlags usage,
        uint32_t mipLvls = 1)
    {
        return this->_createImage (
            wid, ht, format, tiling, usage,
            vk::ImageLayout::eUndefined,
            mipLvls);
    }
 
    vk::DeviceMemory _allocImageMemory (vk::Image img, vk::MemoryPropertyFlags props);
 
    vk::ImageView _createImageView (
        vk::Image image, vk::Format format, vk::ImageAspectFlags aspectFlags);
 
    void _transitionImageLayout (
        vk::Image image,
        vk::Format format,
        vk::ImageLayout oldLayout,
        vk::ImageLayout newLayout);
 
    vk::Buffer _createBuffer (size_t size, vk::BufferUsageFlags usage);
 
    vk::DeviceMemory _allocBufferMemory (vk::Buffer buf, vk::MemoryPropertyFlags props);
 
    void _copyBuffer (vk::Buffer dstBuf, vk::Buffer srcBuf, size_t offset, size_t size);
 
    void _copyBufferToImage (
        vk::Image dstImg, vk::Buffer srcBuf, size_t size,
        uint32_t wid, uint32_t ht=1, uint32_t depth=1);
 
    /* debug-message support */
    VkDebugUtilsMessengerEXT _debugMessenger;
    void _initDebug ();
    void _cleanupDebug ();
};
 
} // namespace cs237
 
#endif // !_CS237_APPLICATION_HPP_