window.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__WINDOW__H__
#define __SGCT__WINDOW__H__
 
#include <sgct/sgctexports.h>
 
#include <sgct/definitions.h>
#include <sgct/offscreenbuffer.h>
#include <sgct/screencapture.h>
#include <sgct/shaderprogram.h>
#include <sgct/viewport.h>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#ifdef SGCT_HAS_NDI
#include <Processing.NDI.Lib.h>
#include <Processing.NDI.Send.h>
#include <Processing.NDI.Structs.h>
#endif // SGCT_HAS_NDI
 
struct GLFWwindow;
 
#ifdef SGCT_HAS_SPOUT
struct SPOUTLIBRARY;
using SPOUTHANDLE = SPOUTLIBRARY*;
#endif // SGCT_HAS_SPOUT
 
namespace sgct {
 
namespace config { struct Window; }
 
class SGCT_EXPORT Window {
public:
    enum class StereoMode : uint8_t {
        NoStereo = 0,
        Active,
        AnaglyphRedCyan,
        AnaglyphAmberBlue,
        AnaglyphRedCyanWimmer,
        Checkerboard,
        CheckerboardInverted,
        VerticalInterlaced,
        VerticalInterlacedInverted,
        Dummy,
        SideBySide,
        SideBySideInverted,
        TopBottom,
        TopBottomInverted
    };
 
    static void makeSharedContextCurrent();

    static void initNvidiaSwapGroups();

    static void resetSwapGroupFrameNumber();
    static void setBarrier(bool state);
    static bool isBarrierActive();
    static bool isUsingSwapGroups();
    static unsigned int swapGroupFrameNumber();
 
    Window(const config::Window& window);
    ~Window();

    void openWindow(GLFWwindow* share, bool isLastWindow);
 
    void closeWindow();

    void initialize();
 
    void initializeContextSpecific();
 
    void updateResolutions();
 
    void update();
 
    void draw();
 
    void renderFBOTexture();

    void swapBuffers(bool takeScreenshot);
 
    void makeOpenGLContextCurrent();
 
    // Returns true if this window has any settings that require a fallback on an OpenGL
    // compatibility profile
    bool needsCompatibilityProfile() const;
 
    bool shouldTakeScreenshot() const;
    bool isOpenXREnabled() const;

    vec2 scale() const;

    float aspectRatio() const;

    ivec2 windowSize() const;

    GLFWwindow* windowHandle() const;
 
    void addViewport(std::unique_ptr<Viewport> vpPtr);
    const std::vector<std::unique_ptr<Viewport>>& viewports() const;
 
    void updateFrustums(float nearClip, float farClip);
    void renderScreenQuad() const;

    void setFramebufferResolution(ivec2 resolution);

    ivec2 framebufferResolution() const;

    bool isWindowResized() const;

    bool isFocused() const;

    int id() const;

    void setName(std::string name);

    const std::string& name() const;

    void setTags(std::vector<std::string> tags);

    bool hasTag(std::string_view tag) const;

    void setVisible(bool state);

    bool isVisible() const;

    void setRenderWhileHidden(bool state);

    bool isRenderingWhileHidden() const;

    void setFullscreen(bool fullscreen);

    void setAutoiconify(bool shouldAutoiconify);

    void setFloating(bool floating);

    void setTakeScreenshot(bool takeScreenshot);

    void setWindowDecoration(bool state);

    void setWindowResizable(bool state);

    void setFixResolution(bool state);

    bool isFixResolution() const;
 
    void setHorizFieldOfView(float hFovDeg);

    float horizFieldOfViewDegrees() const;

    void setCallDraw2DFunction(bool state);

    void setCallDraw3DFunction(bool state);

    void setStereoMode(StereoMode sm);

    StereoMode stereoMode() const;

    bool isStereo() const;
 
 
    // @TODO: Remove this
    unsigned int frameBufferTextureEye(Eye eye) const;
 
private:
    enum class TextureType { Color, Depth, Normal, Position };
 
    Window(const Window&) = delete;
    Window& operator=(const Window&) = delete;

    void createTextures();
    void generateTexture(unsigned int& id, TextureType type);

    void resizeFBOs();
 
    void destroyFBOs();

    void createVBOs();
    void loadShaders();
    bool useRightEyeTexture() const;

    void renderViewports(FrustumMode frustum, Eye eye) const;

    void render2D(FrustumMode frustum) const;

    void blitWindowViewport(const Window& prevWindow, const Viewport& viewport,
        FrustumMode mode) const;
 
    std::string _name;
    std::vector<std::string> _tags;
    int8_t _id = -1;
 
    bool _hideMouseCursor;
    bool _takeScreenshot;
    bool _hasAlpha;
    bool _hasCallDraw2DFunction;
    bool _hasCallDraw3DFunction;
    bool _isFullScreen;
    bool _shouldAutoiconify;
    bool _isFloating;
    bool _shouldRenderWhileHidden;
    uint8_t _nAASamples;
    bool _useFXAA;
    bool _isDecorated;
    bool _isResizable;
    bool _isMirrored;
    int8_t _blitWindowId;
    uint8_t _monitorIndex;
    bool _mirrorX;
    bool _mirrorY;
    bool _noError;
    bool _useOpenXR;
    bool _isVisible;
    bool _isIconified = false;
    StereoMode _stereoMode;
    std::optional<ivec2> _windowPos;
    ivec2 _windowSize;
    ivec2 _framebufferRes;
 
    std::optional<ivec2> _pendingWindowSize;
    bool _windowResChanged = false;
    bool _hasFocus = false;
    bool _useFixResolution = false;
    bool _hasAnyMasks = false;
    std::optional<ivec2> _pendingFramebufferRes;
    GLFWwindow* _windowHandle = nullptr;
    float _aspectRatio = 1.f;
    vec2 _scale = vec2{ 0.f, 0.f };
 
#ifdef SGCT_HAS_SPOUT
    struct {
        bool enabled;
        std::string name;
        SPOUTHANDLE handle = nullptr;
    } _spout;
#endif // SGCT_HAS_SPOUT
 
#ifdef SGCT_HAS_NDI
    struct {
        NDIlib_send_instance_t handle = nullptr;
        NDIlib_video_frame_v2_t videoFrame;
        std::string name;
        std::string groups;
        unsigned int pingPongPbo[3] = { 0, 0, 0 };
        int currentFrame = 0;
    } _ndi;
#endif // SGCT_HAS_NDI
 
    const unsigned int _internalColorFormat;
    const unsigned int _colorDataType;
    const int _bytesPerColor = 4;
 
    struct {
        unsigned int leftEye = 0;
        unsigned int rightEye = 0;
        unsigned int depth = 0;
        unsigned int intermediate = 0;
        unsigned int normals = 0;
        unsigned int positions = 0;
    } _frameBufferTextures;
 
    std::unique_ptr<ScreenCapture> _screenCaptureLeftOrMono;
    std::unique_ptr<ScreenCapture> _screenCaptureRight;
 
 
    unsigned int _vao = 0;
    unsigned int _vbo = 0;
 
    ShaderProgram _fboQuad;
    ShaderProgram _overlay;
    ShaderProgram _stereo;
 
    struct FXAAShader {
        ShaderProgram shader;
        int sizeX = -1;
        int sizeY = -1;
    };
    std::optional<FXAAShader> _fxaa;
 
    std::vector<std::unique_ptr<Viewport>> _viewports;
    std::unique_ptr<OffScreenBuffer> _finalFBO;
 
    static GLFWwindow* _sharedHandle;
    static bool _useSwapGroups;
    static bool _isBarrierActive;
 
    // ScalableMesh
    struct {
        void* sdk = nullptr;
        std::filesystem::path path;
    } _scalableMesh;
};
 
config::Window createScalableConfiguration(const config::Window::Scalable& scalable,
    const config::Window& window);
 
} // namespace sgct
 
#endif // __SGCT__WINDOW__H__