canvas.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_BGFX_CANVAS_H
#define VCL_BGFX_CANVAS_H
 
#include <vclib/base.h>
#include <vclib/bgfx/context.h>
#include <vclib/bgfx/read_framebuffer_request.h>
#include <vclib/bgfx/system/native_window_handle.h>
#include <vclib/io/image.h>
#include <vclib/render/concepts/render_app.h>
#include <vclib/render/input.h>
#include <vclib/render/read_buffer_types.h>
 
#include <optional>
 
namespace vcl {
 
// TODO: write documentation here
template<typename DerivedRenderApp>
class CanvasBGFX
{
    using ReadFramebufferRequest = detail::ReadFramebufferRequest;
 
protected:
    using FloatData = ReadBufferTypes::FloatData;
    using ByteData  = ReadBufferTypes::ByteData;
    using ReadData  = ReadBufferTypes::ReadData;
 
public:
    using CallbackReadBuffer = ReadBufferTypes::CallbackReadBuffer;
 
private:
    void* mWinId = nullptr;
 
    // frame buffer for drawing the canvas
    // BGFX_INVALID_HANDLE represents the default frame buffer of the window
    bgfx::ViewId            mViewId = BGFX_INVALID_VIEW;
    bgfx::FrameBufferHandle mFbh    = BGFX_INVALID_HANDLE;
 
    // size of the canvas
    Point2<uint> mSize = {0, 0};
 
    vcl::Color mDefaultClearColor = vcl::Color::Black;
 
    // current frame
    uint32_t mCurrFrame = 0;
 
    // offscreen readback request
    std::optional<ReadFramebufferRequest> mReadRequest = std::nullopt;
 
public:
    CanvasBGFX(
        void* winId,
        uint  width,
        uint  height,
        void* displayId = nullptr) : mWinId(winId)
    {
        static_assert(
            RenderAppConcept<DerivedRenderApp>,
            "The DerivedRenderApp must satisfy the RenderAppConcept.");
 
        // on screen framebuffer
        mViewId = Context::instance(mWinId, displayId).requestViewId();
 
        // (re)create the framebuffers
        onResize(width, height);
    }
 
    ~CanvasBGFX()
    {
        // deallocate the framebuffers
        if (bgfx::isValid(mFbh))
            bgfx::destroy(mFbh);
 
        // release the view id
        auto& ctx = Context::instance();
        if (ctx.isValidViewId(mViewId))
            ctx.releaseViewId(mViewId);
    }
 
    Point2<uint> size() const { return mSize; }
 
    bgfx::ViewId viewId() const { return mViewId; }
 
    bgfx::FrameBufferHandle frameBuffer() const { return mFbh; }
 
    void setDefaultClearColor(const Color& color)
    {
        mDefaultClearColor = color;
        bgfx::setViewClear(
            mViewId,
            BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH | BGFX_CLEAR_STENCIL,
            color.rgba());
    }
 
    bool screenshot(const std::string& filename, uint multiplier = 1)
    {
        return onScreenshot(filename, multiplier);
    }
 
    void onInit() {}
 
    void onResize(uint width, uint height)
    {
        mSize = {width, height};
 
        // create window backbuffer
        if (bgfx::isValid(mFbh))
            bgfx::destroy(mFbh);
 
        auto& ctx = Context::instance();
        mFbh      = ctx.createFramebufferAndInitView(
            mWinId, mViewId, width, height, true, mDefaultClearColor.rgba());
        // the canvas framebuffer is non valid for the default window
        assert(ctx.isDefaultWindow(mWinId) == !bgfx::isValid(mFbh));
    }
 
    void onPaint()
    {
        bgfx::setViewFrameBuffer(mViewId, mFbh);
        bgfx::touch(mViewId);
 
        // ask the derived frame to draw all the drawer objects:
        DerivedRenderApp::CNV::draw(derived());
        DerivedRenderApp::CNV::postDraw(derived());
 
        const bool newReadRequested =
            (mReadRequest != std::nullopt && !mReadRequest->isSubmitted());
 
        if (newReadRequested) {
            // draw offscreen frame
            offscreenFrame();
            mCurrFrame = bgfx::frame();
            // submit the calls for blitting the offscreen depth buffer
            if (mReadRequest->submit()) {
                // solicit new frame
                derived()->update();
            }
        }
        else {
            mCurrFrame = bgfx::frame();
        }
 
        if (mReadRequest != std::nullopt) {
            // read depth data if available
            const bool done = mReadRequest->performRead(mCurrFrame);
            if (done)
                mReadRequest = std::nullopt;
            // solicit new frame
            derived()->update();
        }
 
        // this is required only when using Qt in macOS
#if defined(__APPLE__)
        bgfx::frame();
#endif // __APPLE__
    }
 
    [[nodiscard]] bool onReadDepth(
        const Point2i&     point,
        CallbackReadBuffer callback = nullptr)
    {
        if (!Context::instance().supportsReadback() // feature unsupported
            || mReadRequest != std::nullopt         // read already requested
            || point.x() < 0 || point.y() < 0       // point out of bounds
            || point.x() >= mSize.x() || point.y() >= mSize.y()) {
            return false;
        }
 
        mReadRequest.emplace(point, mSize, callback);
        return true;
    }
 
    bool onScreenshot(const std::string& filename, uint multiplier = 1)
    {
        if (!Context::instance().supportsReadback() // feature unsupported
            || mReadRequest != std::nullopt) {      // read already requested
            return false;
        }
 
        // get size
        auto size = mSize * multiplier;
 
        // color data callback
        CallbackReadBuffer callback = [=](const ReadData& data) {
            assert(
                std::holds_alternative<ReadFramebufferRequest::ByteData>(data));
            const auto& d = std::get<ReadFramebufferRequest::ByteData>(data);
 
            // save rgb image data into file using stb depending on file
            // TODO: maybe useful to save it asynchronously
            try {
                vcl::saveImageData(filename, size.x(), size.y(), d.data());
            }
            catch (const std::exception& e) {
                std::cerr << "Error saving image: " << e.what() << std::endl;
            }
        };
 
        mReadRequest.emplace(size, callback, mDefaultClearColor);
        return true;
    }
 
    [[nodiscard]] bool onReadId(
        const Point2i&     point,
        CallbackReadBuffer callback = nullptr)
    {
        if (!Context::instance().supportsReadback() // feature unsupported
            || mReadRequest != std::nullopt         // read already requested
            || point.x() < 0 || point.y() < 0       // point out of bounds
            || point.x() >= mSize.x() || point.y() >= mSize.y()) {
            return false;
        }
 
        mReadRequest.emplace(point, mSize, true, callback);
        return true;
    }
 
private:
    // draw offscreen frame
    void offscreenFrame()
    {
        assert(mReadRequest != std::nullopt && !mReadRequest->isSubmitted());
 
        // render offscren
        bgfx::setViewFrameBuffer(
            mReadRequest->viewId(), mReadRequest->frameBuffer());
        bgfx::touch(mReadRequest->viewId());
 
        // render changing the view
        auto tmpId = mViewId;
        mViewId    = mReadRequest->viewId();
        switch (mReadRequest->type()) {
        case ReadFramebufferRequest::Type::COLOR:
        case ReadFramebufferRequest::Type::DEPTH:
            DerivedRenderApp::CNV::drawContent(derived());
            break;
        case ReadFramebufferRequest::Type::ID:
            DerivedRenderApp::CNV::drawId(derived());
            break;
        default: assert(false && "unsupported readback type"); break;
        }
        mViewId = tmpId;
    }
 
    auto* derived() { return static_cast<DerivedRenderApp*>(this); }
 
    const auto* derived() const
    {
        return static_cast<const DerivedRenderApp*>(this);
    }
};
 
} // namespace vcl
 
#endif // VCL_BGFX_CANVAS_H