render_window.cpp

Go to the documentation of this file.

#include "render_window.h"
#include <graphics/graphics.h>
 
namespace unravel
{
    
render_window::render_window(os::window&& win) : window_(std::move(win))
{
    prepare_surface();
}
 
render_window::~render_window()
{
    // Flush destruction of swap chain before destroying window!
    destroy_surface(2);
}
 
void render_window::destroy_surface(int frames)
{
    // force internal handle destruction
    if(surface_)
    {
        surface_.reset();
 
 
        // Before we reattach a SwapChain to the window
        // we must actually free up the previous one.
        // The DestroyFrameBuffer command goes in the
        // cmdPost CommandBuffer, which happens after
        // the frame. The CreateFrameBuffer command goes
        // int the cmdPre CommandBuffer, which happens
        // at the beginning of the frame. Without this
        // bgfx::frame() call, the creation would happen
        // before it's destroyed, which would cause
        // the platform window to have two SwapChains
        // associated with it.
        // Ideally, we have an operation of ResizeFrameBuffer.
        gfx::frames(frames);
    }
}
 
void render_window::resize(uint32_t w, uint32_t h)
{
    window_.set_size(w, h);
    prepare_surface();
}
 
void render_window::prepare_surface()
{
    auto size = window_.get_size();
 
    bool needs_recreate = true;
    if(surface_)
    {
        auto surf_size = surface_->get_size();
        needs_recreate = surf_size.width != size.w || surf_size.height != size.h;
    }
 
    if(needs_recreate)
    {
        destroy_surface(0);
        surface_ = std::make_shared<gfx::frame_buffer>(window_.get_native_handle(),
                                                       static_cast<std::uint16_t>(size.w),
                                                       static_cast<std::uint16_t>(size.h));
    }
}
 
auto render_window::get_window() -> os::window&
{
    return window_;
}
auto render_window::get_surface() -> graphics_surface_t&
{
    return surface_;
}
 
auto render_window::begin_present_pass() -> gfx::render_pass&
{
    pass_.reset();
    pass_ = std::make_unique<gfx::render_pass>("Present to Window Pass");
    pass_->bind(surface_.get());
 
    return *pass_;
}
 
auto render_window::get_present_pass() -> gfx::render_pass&
{
    return *pass_;
}
} // namespace unravel