render_app.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2026                                                    *
 * 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_RENDER_RENDER_APP_H
#define VCL_RENDER_RENDER_APP_H
 
#include "concepts/blocker_event_drawer.h"
#include "concepts/canvas.h"
#include "concepts/event_drawer.h"
#include "concepts/window_manager.h"
#include "input.h"
#include "read_buffer_types.h"
 
#include <vclib/space/core/point.h>
 
namespace vcl {
 
template<
    template<typename>
    typename WindowManagerT,
    template<typename>
    typename CanvasT,
    template<typename>
    typename... Drawers>
class RenderApp :
        public WindowManagerT<RenderApp<WindowManagerT, CanvasT, Drawers...>>,
        public CanvasT<RenderApp<WindowManagerT, CanvasT, Drawers...>>,
        public Drawers<RenderApp<WindowManagerT, CanvasT, Drawers...>>...
{
    using WindowManagerType = WindowManagerT<RenderApp>;
    using CanvasType        = CanvasT<RenderApp>;
 
    static_assert(
        WindowManagerConcept<WindowManagerType>,
        "The first template parameter type of the RenderApp class must be a "
        "class that satisfies the WindowManagerConcept.");
 
    static_assert(
        CanvasConcept<CanvasType>,
        "The second template parameter type of the RenderApp class must be a "
        "class that satisfies the CanvasConcept.");
 
    static_assert(
        (DrawerConcept<Drawers<RenderApp>> && ...),
        "All the Drawer types must satisfy the DrawerConcept.");
 
    KeyModifiers mKeyModifiers = {KeyModifier::NO_MODIFIER};
 
    // hide CanvasType member functions
    using CanvasType::onInit;
    using CanvasType::onPaint;
    using CanvasType::onReadDepth;
    using CanvasType::onResize;
    using CanvasType::onScreenshot;
    using CanvasType::setDefaultClearColor;
    using CanvasType::size;
 
    // hide WindowManagerType member functions
    using WindowManagerType::displayId;
    using WindowManagerType::winId;
 
protected:
    using CanvasType::viewId;
 
    // TODO: find a way to hide the Drawer member functions here
 
public:
    using ParentType = WindowManagerType::ParentType;
 
    // Attorneys
    class CNV;
    class WM;
    class DRW;
 
    RenderApp(ParentType* parent = nullptr) :
            RenderApp("RenderApp", 1024, 768, parent)
    {
    }
 
    RenderApp(
        const std::string& windowTitle,
        uint               width  = 1024,
        uint               height = 768,
        ParentType*        parent = nullptr) :
            WindowManagerType(windowTitle, width, height, parent),
            CanvasType(
                (void*) WindowManagerType::winId(),
                width * WindowManagerType::dpiScale().x(),
                height * WindowManagerType::dpiScale().y(),
                WindowManagerType::displayId()),
            Drawers<RenderApp>(
                width * WindowManagerType::dpiScale().x(),
                height * WindowManagerType::dpiScale().y())...
    {
    }
 
private:
    template<typename D, typename... Others>
    void callEventFunForDrawers(auto lambda)
    {
        bool block = false;
        if constexpr (EventDrawerConcept<D>) {
            if constexpr (BlockerEventDrawerConcept<D>) {
                block = lambda.template operator()<D>(this);
            }
            else {
                lambda.template operator()<D>(this);
            }
        }
        if constexpr (sizeof...(Others) > 0) {
            if (!block) {
                callEventFunForDrawers<Others...>(lambda);
            }
        }
    }
 
    // Base case when there are no drawers
    void callEventFunForDrawers(auto lambda) {}
 
    /***** Member functions called by WindowManagerType *****/
    // Documentation is in the RenderApp::WM inner class
 
    void wmInit()
    {
        CanvasType::onInit();
        (static_cast<Drawers<RenderApp>*>(this)->onInit(CanvasType::viewId()),
         ...);
    }
 
    void wmResize(uint width, uint height)
    {
        CanvasType::onResize(width, height);
 
        // call the onResize member function of each Drawer object.
        // NOTE: use static_cast<Drawers*>(this)->function() to call the
        // right VIRTUAL function of the Drawer object.
        (static_cast<Drawers<RenderApp>*>(this)->onResize(width, height), ...);
    }
 
    void wmPaint() { CanvasType::onPaint(); }
 
    void wmSetModifiers(const KeyModifiers& modifiers)
    {
        mKeyModifiers = modifiers;
    }
 
    void wmKeyPress(Key::Enum key)
    {
        // given this object t and the type of a Drawer D, call the event member
        // function of the Drawer object
        auto lambda = [&]<typename D>(auto* t) {
            // NOTE: use static_cast<Drawers*>(this)->function() to call the
            // right VIRTUAL function of the Drawer object.
            return static_cast<D*>(t)->onKeyPress(key, mKeyModifiers);
        };
 
        // call the lambda for all the drawers
        callEventFunForDrawers<Drawers<RenderApp>...>(lambda);
    }
 
    void wmKeyRelease(Key::Enum key)
    {
        // given this object t and the type of a Drawer D, call the event member
        // function of the Drawer object
        auto lambda = [&]<typename D>(auto* t) {
            // NOTE: use static_cast<Drawers*>(this)->function() to call the
            // right VIRTUAL function of the Drawer object.
            return static_cast<D*>(t)->onKeyRelease(key, mKeyModifiers);
        };
 
        // call the lambda for all the drawers
        callEventFunForDrawers<Drawers<RenderApp>...>(lambda);
    }
 
    void wmMouseMove(double x, double y)
    {
        // given this object t and the type of a Drawer D, call the event member
        // function of the Drawer object
        auto lambda = [&]<typename D>(auto* t) {
            // NOTE: use static_cast<Drawers*>(this)->function() to call the
            // right VIRTUAL function of the Drawer object.
            return static_cast<D*>(t)->onMouseMove(x, y, mKeyModifiers);
        };
 
        // call the lambda for all the drawers
        callEventFunForDrawers<Drawers<RenderApp>...>(lambda);
    }
 
    void wmMousePress(MouseButton::Enum button, double x, double y)
    {
        // given this object t and the type of a Drawer D, call the event member
        // function of the Drawer object
        auto lambda = [&]<typename D>(auto* t) {
            // NOTE: use static_cast<Drawers*>(this)->function() to call the
            // right VIRTUAL function of the Drawer object.
            return static_cast<D*>(t)->onMousePress(
                button, x, y, mKeyModifiers);
        };
 
        // call the lambda for all the drawers
        callEventFunForDrawers<Drawers<RenderApp>...>(lambda);
    }
 
    void wmMouseRelease(MouseButton::Enum button, double x, double y)
    {
        // given this object t and the type of a Drawer D, call the event member
        // function of the Drawer object
        auto lambda = [&]<typename D>(auto* t) {
            // NOTE: use static_cast<Drawers*>(this)->function() to call the
            // right VIRTUAL function of the Drawer object.
            return static_cast<D*>(t)->onMouseRelease(
                button, x, y, mKeyModifiers);
        };
 
        // call the lambda for all the drawers
        callEventFunForDrawers<Drawers<RenderApp>...>(lambda);
    }
 
    void wmMouseDoubleClick(MouseButton::Enum button, double x, double y)
    {
        // given this object t and the type of a Drawer D, call the event member
        // function of the Drawer object
        auto lambda = [&]<typename D>(auto* t) {
            // NOTE: use static_cast<Drawers*>(this)->function() to call the
            // right VIRTUAL function of the Drawer object.
            return static_cast<D*>(t)->onMouseDoubleClick(
                button, x, y, mKeyModifiers);
        };
 
        // call the lambda for all the drawers
        callEventFunForDrawers<Drawers<RenderApp>...>(lambda);
    }
 
    void wmMouseScroll(double x, double y)
    {
        // given this object t and the type of a Drawer D, call the event member
        // function of the Drawer object
        auto lambda = [&]<typename D>(auto* t) {
            // NOTE: use static_cast<Drawers*>(this)->function() to call the
            // right VIRTUAL function of the Drawer object.
            return static_cast<D*>(t)->onMouseScroll(x, y, mKeyModifiers);
        };
 
        // call the lambda for all the drawers
        callEventFunForDrawers<Drawers<RenderApp>...>(lambda);
    }
 
    /***** Member functions called by CanvasType *****/
    // Documentation is in the RenderApp::CNV inner class
 
    void cnvDraw()
    {
        // call the onDraw member function of each Drawer object.
        // NOTE: use static_cast<Drawers*>(this)->function() to call the
        // right VIRTUAL function of the Drawer object.
        (static_cast<Drawers<RenderApp>*>(this)->onDraw(CanvasType::viewId()),
         ...);
    }
 
    void cnvDrawContent()
    {
        // call the onDrawContent member function of each Drawer object.
        // NOTE: use static_cast<Drawers*>(this)->function() to call the
        // right VIRTUAL function of the Drawer object.
        (static_cast<Drawers<RenderApp>*>(this)->onDrawContent(
             CanvasType::viewId()),
         ...);
    }
 
    void cnvDrawId()
    {
        // call the onDrawId member function of each Drawer object.
        // NOTE: use static_cast<Drawers*>(this)->function() to call the
        // right VIRTUAL function of the Drawer object.
        (static_cast<Drawers<RenderApp>*>(this)->onDrawId(CanvasType::viewId()),
         ...);
    }
 
    void cnvPostDraw()
    {
        // call the onPostDraw member function of each Drawer object.
        // NOTE: use static_cast<Drawers*>(this)->function() to call the
        // right VIRTUAL function of the Drawer object.
        (..., static_cast<Drawers<RenderApp>*>(this)->onPostDraw());
    }
 
    /***** Member functions called by Drawer objects *****/
    // Documentation is in the RenderApp::DRW inner class
 
    void* dWindowPtr() { return WindowManagerType::windowPtr(); }
 
    uint dCanvasViewId() const { return CanvasType::viewId(); }
 
    vcl::Point2<uint> dCanvasSize() const { return CanvasType::size(); }
 
    void dSetCanvasDefaultClearColor(const Color& color)
    {
        CanvasType::setDefaultClearColor(color);
    }
 
    auto dCanvasFrameBuffer() const { return CanvasType::frameBuffer(); }
 
    [[nodiscard]] bool dReadDepth(
        const Point2i&                      point,
        ReadBufferTypes::CallbackReadBuffer callback = nullptr)
    {
        return CanvasType::onReadDepth(point, callback);
    }
 
    [[nodiscard]] bool dReadId(
        const Point2i&                      point,
        ReadBufferTypes::CallbackReadBuffer callback = nullptr)
    {
        return CanvasType::onReadId(point, callback);
    }
 
    void dScreenshot(const std::string& filename, uint multiplier = 1)
    {
        CanvasType::onScreenshot(filename, multiplier);
    }
};
 
/*** Inner classes: Attorneys ***/
// (https://tinyurl.com/kp8m28je)
 
template<
    template<typename>
    typename WindowManagerT,
    template<typename>
    typename CanvasT,
    template<typename>
    typename... Drawers>
class RenderApp<WindowManagerT, CanvasT, Drawers...>::WM
{
    using WindowManagerType = WindowManagerT<RenderApp>;
 
    friend WindowManagerType;
 
    static void init(RenderApp* r) { r->wmInit(); }
 
    static void resize(RenderApp* r, uint width, uint height)
    {
        r->wmResize(width, height);
    }
 
    static void paint(RenderApp* r) { r->wmPaint(); }
 
    static void setModifiers(RenderApp* r, const KeyModifiers& modifiers)
    {
        r->wmSetModifiers(modifiers);
    }
 
    static void keyPress(RenderApp* r, Key::Enum key) { r->wmKeyPress(key); }
 
    static void keyRelease(RenderApp* r, Key::Enum key)
    {
        r->wmKeyRelease(key);
    }
 
    static void mouseMove(RenderApp* r, double x, double y)
    {
        r->wmMouseMove(x, y);
    }
 
    static void mousePress(
        RenderApp*        r,
        MouseButton::Enum button,
        double            x,
        double            y)
    {
        r->wmMousePress(button, x, y);
    }
 
    static void mouseRelease(
        RenderApp*        r,
        MouseButton::Enum button,
        double            x,
        double            y)
    {
        r->wmMouseRelease(button, x, y);
    }
 
    static void mouseDoubleClick(
        RenderApp*        r,
        MouseButton::Enum button,
        double            x,
        double            y)
    {
        r->wmMouseDoubleClick(button, x, y);
    }
 
    static void mouseScroll(RenderApp* r, double x, double y)
    {
        r->wmMouseScroll(x, y);
    }
};
 
template<
    template<typename>
    typename WindowManagerT,
    template<typename>
    typename CanvasT,
    template<typename>
    typename... Drawers>
class RenderApp<WindowManagerT, CanvasT, Drawers...>::CNV
{
    using CanvasType = CanvasT<RenderApp>;
 
    friend CanvasType;
 
    static void draw(RenderApp* r) { r->cnvDraw(); }
 
    static void drawContent(RenderApp* r) { r->cnvDrawContent(); }
 
    static void drawId(RenderApp* r) { r->cnvDrawId(); }
 
    static void postDraw(RenderApp* r) { r->cnvPostDraw(); }
};
 
template<
    template<typename>
    typename WindowManagerT,
    template<typename>
    typename CanvasT,
    template<typename>
    typename... Drawers>
class RenderApp<WindowManagerT, CanvasT, Drawers...>::DRW
{
    // TODO: right now all the function in this inner class are public,
    // because variadic friends are still not allowed in C++.
    // It will allowed in C++26: https://stackoverflow.com/a/78246001/5851101
    // As soon as this feature will be available on all the major compilers,
    // the functions will be made private.
    // friend Drawers<RenderApp<WindowManagerT, CanvasT, Drawers...>>...;
 
public: // TODO - remove this when C++26 is supported
    static void* windowPtr(RenderApp* r) { return r->dWindowPtr(); }
 
    static uint canvasViewId(const RenderApp* r) { return r->dCanvasViewId(); }
 
    static Point2<uint> canvasSize(const RenderApp* r)
    {
        return r->dCanvasSize();
    }
 
    static void setCanvasDefaultClearColor(RenderApp* r, const Color& color)
    {
        r->dSetCanvasDefaultClearColor(color);
    }
 
    static auto canvasFrameBuffer(const RenderApp* r)
    {
        return r->dCanvasFrameBuffer();
    }
 
    [[nodiscard]] static bool readDepth(
        RenderApp*                          r,
        const Point2i&                      point,
        ReadBufferTypes::CallbackReadBuffer callback = nullptr)
    {
        return r->dReadDepth(point, callback);
    }
 
    [[nodiscard]] static bool readId(
        RenderApp*                          r,
        const Point2i&                      point,
        ReadBufferTypes::CallbackReadBuffer callback = nullptr)
    {
        return r->dReadId(point, callback);
    }
 
    static void screenshot(
        RenderApp*         r,
        const std::string& filename,
        uint               multiplier = 1)
    {
        r->dScreenshot(filename, multiplier);
    }
};
 
} // namespace vcl
 
#endif // VCL_RENDER_RENDER_APP_H