engine.h

Go to the documentation of this file.

/*****************************************************************************************
 * SGCT                                                                                  *
 * Simple Graphics Cluster Toolkit                                                       *
 *                                                                                       *
 * Copyright (c) 2012-2026                                                               *
 * For conditions of distribution and use, see copyright notice in LICENSE.md            *
 ****************************************************************************************/
 
#ifndef __SGCT__ENGINE__H__
#define __SGCT__ENGINE__H__
 
#include <sgct/sgctexports.h>
 
#include <sgct/actions.h>
#include <sgct/callbackdata.h>
#include <sgct/config.h>
#include <sgct/keys.h>
#include <sgct/math.h>
#include <sgct/modifiers.h>
#include <sgct/mouse.h>
#include <sgct/window.h>
#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <thread>
#include <utility>
#include <vector>
 
namespace sgct {
 
struct Configuration;
class Node;
class StatisticsRenderer;
class User;

SGCT_EXPORT config::Cluster loadCluster(
    std::optional<std::filesystem::path> path = std::nullopt);

SGCT_EXPORT double time();

class SGCT_EXPORT Engine {
public:
    using DrawFunction = void (*)(const RenderData&);

    struct SGCT_EXPORT Statistics {
        static constexpr int HistoryLength = 128;

        std::array<double, HistoryLength> frametimes = {};

        std::array<double, HistoryLength> drawTimes = {};

        std::array<double, HistoryLength> syncTimes = {};

        std::array<double, HistoryLength> loopTimeMin = {};

        std::array<double, HistoryLength> loopTimeMax = {};

        double dt() const;

        double avgDt() const;

        double minDt() const;

        double maxDt() const;
    };
 
    struct SGCT_EXPORT Settings {
        bool createDebugContext = false;

        int8_t swapInterval = 1;

        bool printSyncMessage = true;

        bool captureBackBuffer = false;
 
        bool useDepthTexture = false;
        bool useNormalTexture = false;
        bool usePositionTexture = false;

        float syncTimeout = 60.f;
 
        struct SS {
            std::filesystem::path capturePath;
 
            // The number of capture threads
            int nCaptureThreads = std::max(std::thread::hardware_concurrency() / 2, 1u);

            bool addNodeName = false;

            bool addWindowName = true;

            std::string prefix;

            std::optional<std::pair<uint64_t, uint64_t>> limits;
        } capture;
    };

    struct SGCT_EXPORT Callbacks {
        void (*preWindow)() = nullptr;

        void (*initOpenGL)(GLFWwindow*) = nullptr;

        void (*preSync)() = nullptr;

        void (*postSyncPreDraw)() = nullptr;

        void (*draw)(const RenderData&) = nullptr;

        void (*draw2D)(const RenderData&) = nullptr;

        void (*postDraw)() = nullptr;

        void (*cleanup)() = nullptr;

        std::vector<std::byte> (*encode)() = nullptr;

        void (*decode)(const std::vector<std::byte>&) = nullptr;

        void (*externalDecode)(const char*, int) = nullptr;

        void (*externalStatus)(bool) = nullptr;

        void (*dataTransferDecode)(void*, int, int, int) = nullptr;

        void (*dataTransferStatus)(bool, int) = nullptr;

        void (*dataTransferAcknowledge)(int, int) = nullptr;

        void (*keyboard)(Key, Modifier, Action, int, Window*) = nullptr;

        void (*character)(unsigned int, int, Window*) = nullptr;

        void (*mouseButton)(MouseButton, Modifier, Action, Window*) = nullptr;

        void (*mousePos)(double, double, Window*) = nullptr;

        void (*mouseScroll)(double, double, Window*) = nullptr;

        void (*drop)(const std::vector<std::string_view>&) = nullptr;
    };

    static Engine& instance();

    static void create(config::Cluster cluster, Callbacks callbacks,
        const Configuration& arg);

    static void destroy();

    void terminate();

    void exec();

    const Statistics& statistics() const;

    float nearClipPlane() const;

    float farClipPlane() const;

    void setNearAndFarClippingPlanes(float nearClippingPlane, float farClippingPlane);

    void updateFrustums() const;

    const Window* focusedWindow() const;

    void setStatsGraphVisibility(bool value);

    float statsGraphScale() const;

    void setStatsGraphScale(float scale);

    vec2 statsGraphOffset() const;

    void setStatsGraphOffset(vec2 offset);

    void takeScreenshot(std::vector<int> windowIds = std::vector<int>());

    void resetScreenshotNumber();

    void setScreenshotNumber(unsigned int number);

    unsigned int screenShotNumber() const;

    Engine::DrawFunction drawFunction() const;
 
    Engine::DrawFunction draw2DFunction() const;
 

    const Node& thisNode() const;

    const std::vector<std::unique_ptr<Window>>& windows() const;

    static User& defaultUser();

    bool isMaster() const;

    unsigned int currentFrameNumber() const;

    void setCapturePath(std::filesystem::path path);

    void setCaptureFromBackBuffer(bool state);
 
    StatisticsRenderer* statisticsRenderer();
 
    const Settings& settings() const;
 
private:
    static Engine* _instance;

    Engine(config::Cluster cluster, Callbacks callbacks, const Configuration& config);

    ~Engine();

    void initialize();

    void frameLockPreStage();

    void frameLockPostStage();

    void waitForAllWindowsInSwapGroupToOpen();

    void (*_preWindowFn)() = nullptr;

    void (*_initOpenGLFn)(GLFWwindow*) = nullptr;

    void (*_preSyncFn)() = nullptr;

    void (*_postSyncPreDrawFn)() = nullptr;

    void (*_drawFn)(const RenderData&) = nullptr;

    void (*_draw2DFn)(const RenderData&) = nullptr;

    void (*_postDrawFn)() = nullptr;

    void (*_cleanupFn)() = nullptr;

    float _nearClipPlane = 0.1f;

    float _farClipPlane = 100.f;

    Statistics _statistics;

    double _statsPrevTimestamp = 0.0;

    std::unique_ptr<StatisticsRenderer> _statisticsRenderer;

    bool _shouldTakeScreenshot = false;

    bool _shouldTerminate = false;

    std::vector<int> _shouldTakeScreenshotIds;
 
    Settings _settings;
 
    std::unique_ptr<std::thread> _thread;
 
    unsigned int _frameCounter = 0;
    unsigned int _shotCounter = 0;
};
 
} // namespace sgct
 
#endif // __SGCT__ENGINE__H__