window.hpp

Go to the documentation of this file.

 
/*
 * COPYRIGHT (c) 2024 John Reppy (https://cs.uchicago.edu/~jhr)
 * All rights reserved.
 */
 
#ifndef _CS237_WINDOW_HPP_
#define _CS237_WINDOW_HPP_
 
#ifndef _CS237_HPP_
#error "cs237/window.hpp should not be included directly"
#endif
 
#include <optional>
 
namespace cs237 {
 
#ifdef CS237_MAX_FRAMES_IN_FLIGHT
#  define MAX_FRAMES CS237_MAX_FRAMES_IN_FLIGHT
#else
#  define MAX_FRAMES 2
#endif
 
constexpr int kMaxFrames = MAX_FRAMES;
 
//
struct CreateWindowInfo {
    int wid;            
    int ht;             
    std::string title;  
    bool resizable;     
    bool depth;         
    bool stencil;       
 
    CreateWindowInfo (int w, int h, std::string const &t, bool r, bool d, bool s)
        : wid(w), ht(h), title(t), resizable(r), depth(d), stencil(s)
    { }
 
    CreateWindowInfo (int w, int h)
        : wid(w), ht(h), title(""), resizable(false), depth(false), stencil(false)
    { }
 
    bool needsDepthBuf () const { return this->depth || this->stencil; }
};
 
//
class Window {
public:
 
    virtual ~Window ();
 
    void initialize ();
 
    Application *app () { return this->_app; }
 
    vk::Device device () const { return this->_app->_device; }
 
    vk::Queue graphicsQ () const { return this->_app->_queues.graphics; }
 
    vk::Queue presentationQ () const { return this->_app->_queues.present; }
 
    vk::Queue computeQ () const { return this->_app->_queues.compute; }
 
    void refresh ()
    {
        if (this->_isVis) {
            this->draw();
        }
    }
 
    void hide ()
    {
        glfwHideWindow (this->_win);
        this->_isVis = false;
    }
 
    void show ()
    {
        glfwShowWindow (this->_win);
        this->_isVis = true;
    }
 
    virtual void draw () = 0;
 
    virtual void reshape (int wid, int ht);
 
    virtual void iconify (bool iconified);
 
    bool windowShouldClose ()
    {
        return glfwWindowShouldClose (this->_win);
    }
 
    virtual void key (int key, int scancode, int action, int mods);
    virtual void cursorPos (double xpos, double ypos);
    virtual void cursorEnter (bool entered);
    virtual void mouseButton (int button, int action, int mods);
    virtual void scroll (double xoffset, double yoffset);
    //}
 
    void enableKeyEvent (bool enable);
    void setCursorMode (int mode);
    void enableCursorPosEvent (bool enable);
    void enableCursorEnterEvent (bool enable);
    void enableMouseButtonEvent (bool enable);
    void enableScrollEvent (bool enable);
    //}
 
protected:
    struct SwapChainDetails {
        vk::SurfaceCapabilitiesKHR capabilities;
        std::vector<vk::SurfaceFormatKHR> formats;
        std::vector<vk::PresentModeKHR> presentModes;
 
        vk::SurfaceFormatKHR chooseSurfaceFormat ();
        vk::PresentModeKHR choosePresentMode ();
        vk::Extent2D chooseExtent (GLFWwindow *win);
    };
 
    struct DepthStencilBuffer {
        bool depth;                     
        bool stencil;                   
        vk::Format format;              
        vk::Image image;                
        vk::DeviceMemory imageMem;      
        vk::ImageView view;             
    };
 
    struct SwapChain {
        vk::Device device;              
        vk::SwapchainKHR chain;         
        vk::Format imageFormat;         
        vk::Extent2D extent;            
        int numAttachments;             
        // the following vectors hold the state for each of the buffers in the
        // swap chain.
        std::vector<vk::Image> images;  
        std::vector<vk::ImageView> views; 
        std::optional<DepthStencilBuffer> dsBuf; 
        std::vector<vk::Framebuffer> fBufs; 
 
        SwapChain (vk::Device dev)
          : device(dev), dsBuf(std::nullopt)
        { }
 
        int size () const { return this->images.size(); }
 
        void initFramebuffers (vk::RenderPass renderPass);
 
        bool hasDepthBuffer () const
        {
            return this->dsBuf.has_value() && this->dsBuf->depth;
        }
 
        bool hasStencilBuffer () const
        {
            return this->dsBuf.has_value() && this->dsBuf->stencil;
        }
 
        std::optional<vk::ImageView> depthImageView ()
        {
            if (this->dsBuf.has_value()) {
                return dsBuf->view;
            } else {
                // no depth buffer
                return std::optional<vk::ImageView>();
            }
        }
 
        void cleanup ();
    };
 
    struct FrameData {
        Window *win;                    
        vk::CommandBuffer cmdBuf;       
        vk::Semaphore imageAvail;       
        vk::Semaphore finished;         
        vk::Fence inFlight;             
        uint32_t index;                 
 
        //
        FrameData (Window *win);
 
        FrameData () = delete;
        FrameData (FrameData &) = delete;
        FrameData (FrameData const &) = delete;
        FrameData (FrameData &&) = delete;
 
        //
        virtual ~FrameData ();
 
        void waitForFence ()
        {
            auto sts = this->win->device().waitForFences(this->inFlight, VK_TRUE, UINT64_MAX);
            if (sts != vk::Result::eSuccess) {
                ERROR("Synchronization error");
            }
        }
 
        void resetFence ()
        {
            this->win->device().resetFences(this->inFlight);
        }
 
        void submitDrawingCommands ();
 
        vk::Result present ()
        {
            vk::PresentInfoKHR presentInfo(
                this->finished,
                this->win->_swap.chain,
                this->index,
                nullptr);
 
            return this->win->presentationQ().presentKHR(presentInfo);
        }
 
    }; // struct FrameData
 
    Application *_app;                  
    GLFWwindow *_win;                   
    int _wid, _ht;                  
    bool _isVis;                        
    bool _keyEnabled;                   
    bool _cursorPosEnabled;             
    bool _cursorEnterEnabled;           
    bool _mouseButtonEnabled;           
    bool _scrollEnabled;                
    // Vulkan state for rendering
    vk::SurfaceKHR _surf;               
    SwapChain _swap;                    
    FrameData *_frames[kMaxFrames];     
    uint32_t _curFrameIdx;              
 
    Window (Application *app, CreateWindowInfo const &info);
 
    virtual void _init ();
 
    SwapChainDetails _getSwapChainDetails ();
 
    void _createSwapChain (bool depth, bool stencil);
 
    void _recreateSwapChain ();
 
    virtual FrameData *_allocFrameData (Window *w);
 
    FrameData *_currentFrame () { return this->_frames[this->_curFrameIdx]; }
 
    FrameData *_prevFrame ()
    {
        if (this->_curFrameIdx == 0) {
            return this->_frames[kMaxFrames - 1];
        } else {
            return this->_frames[this->_curFrameIdx - 1];
        }
    }
 
    FrameData *_nextFrame ()
    {
        return this->_frames[(this->_curFrameIdx + 1) % kMaxFrames];
    }
 
    void _advanceFrame () { this->_curFrameIdx = (this->_curFrameIdx + 1) % kMaxFrames; }
 
    vk::Result _acquireNextImage ();
 
    void _initAttachments (
        std::vector<vk::AttachmentDescription> &descs,
        std::vector<vk::AttachmentReference> &refs);
 
    uint32_t _graphicsQIdx () const { return this->_app->_qIdxs.graphics; }
 
    uint32_t _presentationQIdx () const { return this->_app->_qIdxs.present; }
 
    uint32_t _computeQIdx () const { return this->_app->_qIdxs.compute; }
 
    vk::Viewport _getViewport (bool oglView = false)
    {
        if (oglView) {
            // to get the OpenGL-style viewport, we set the origin at Y = height
            // and use a negative height
            return vk::Viewport(
                0.0f,
                float(this->_swap.extent.width),
                float(this->_swap.extent.width),
                -float(this->_swap.extent.height),
                0.0f, /* min depth */
                1.0f);
        } else {
            return vk::Viewport(
                0.0f, 0.0f,
                float(this->_swap.extent.width),
                float(this->_swap.extent.height),
                0.0f, /* min depth */
                1.0f); /* max depth */
        }
    }
 
    vk::Rect2D _getScissorsRect ()
    {
        return vk::Rect2D(
            {0, 0},
            {this->_swap.extent.width, this->_swap.extent.height});
    }
 
    void _setViewportCmd (vk::CommandBuffer cmdBuf, bool oglView = false)
    {
        if (oglView) {
            /* NOTE: we negate the height and set the Y origin to ht because Vulkan's
             * viewport coordinates are from top-left down, instead of from
             * bottom-left up. See
             * https://www.saschawillems.de/blog/2019/03/29/flipping-the-vulkan-viewport
             */
            this->_setViewportCmd(cmdBuf,
                0, this->_swap.extent.height,
                this->_swap.extent.width, -(int32_t)this->_swap.extent.height);
        } else {
            this->_setViewportCmd(cmdBuf,
                0, 0,
                this->_swap.extent.width, this->_swap.extent.height);
        }
    }
 
    void _setViewportCmd (vk::CommandBuffer cmdBuf,
        int32_t x, int32_t y,
        int32_t wid, int32_t ht);
 
    vk::DeviceMemory _allocImageMemory (vk::Image img, vk::MemoryPropertyFlags props)
    {
        return this->_app->_allocImageMemory (img, props);
    }
 
    vk::ImageView _createImageView (
        vk::Image img, vk::Format fmt, vk::ImageAspectFlags aspectFlags)
    {
        return this->_app->_createImageView (img, fmt, aspectFlags);
    }
 
    void _transitionImageLayout (
        vk::Image img,
        vk::Format fmt,
        vk::ImageLayout oldLayout,
        vk::ImageLayout newLayout)
    {
        this->_app->_transitionImageLayout(img, fmt, oldLayout, newLayout);
    }
 
public:
 
    int width () const { return this->_swap.extent.width; }
 
    int height () const { return this->_swap.extent.height; }
 
};
 
} // namespace cs237
 
#endif // !_CS237_WINDOW_HPP_