cs237-window.hpp

Go to the documentation of this file.

 
/*
 * COPYRIGHT (c) 2023 John Reppy (http://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 {
 
//
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 ();
 
    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; }
 
    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;
        }
 
        void cleanup ();
    };
 
    struct SyncObjs {
        Window *win;                    
        vk::Semaphore imageAvailable;   
        vk::Semaphore renderFinished;   
        vk::Fence inFlight;             
 
        explicit SyncObjs (Window *w)
          : win(w),
            imageAvailable(nullptr),
            renderFinished(nullptr),
            inFlight(nullptr)
        {
            this->allocate();
        }
        SyncObjs () = delete;
        SyncObjs (SyncObjs &) = delete;
        SyncObjs (SyncObjs const &) = delete;
        SyncObjs (SyncObjs &&) = delete;
 
        ~SyncObjs ();
 
        void allocate ();
 
        vk::ResultValue<uint32_t> acquireNextImage ();
 
        void reset ();
 
        void submitCommands (vk::Queue q, vk::CommandBuffer const &cmdBuf);
 
        vk::Result present (vk::Queue q, uint32_t imageIndex);
    };
 
    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;                    
 
    Window (Application *app, CreateWindowInfo const &info);
 
    SwapChainDetails _getSwapChainDetails ();
 
    void _createSwapChain (bool depth, bool stencil);
 
    void _recreateSwapChain ();
 
    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; }
 
    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);
 
public:
 
    int width () const { return this->_swap.extent.width; }
 
    int height () const { return this->_swap.extent.height; }
 
};
 
} // namespace cs237
 
#endif // !_CS237_WINDOW_HPP_