IWindowing.h#

// Copyright (c) 2018-2024, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once
#include <carb/input/InputTypes.h>
#include "../Interface.h"
#include "../Types.h"

#define carb_windowing_IWindowing_latest CARB_HEXVERSION(1, 5)
#ifndef carb_windowing_IWindowing
#    define carb_windowing_IWindowing CARB_HEXVERSION(1, 4)
#endif

namespace carb
{

namespace input
{
struct Keyboard;
struct Mouse;
struct Gamepad;
} // namespace input

namespace windowing
{

struct Window;
struct Cursor;
struct Monitor;

enum class MonitorChangeEvent : uint32_t
{
    eUnknown,
    eConnected,
    eDisconnected
};

typedef void (*OnWindowMoveFn)(Window* window, int x, int y, void* userData);
typedef void (*OnWindowResizeFn)(Window* window, int width, int height, void* userData);
typedef void (*OnWindowDropFn)(Window* window, const char** paths, int count, void* userData);
typedef void (*OnWindowCloseFn)(Window* window, void* userData);
typedef void (*OnWindowContentScaleFn)(Window* window, float scaleX, float scaleY, void* userData);
typedef void (*OnWindowFocusFn)(Window* window, bool isFocused, void* userData);
typedef void (*OnWindowMaximizeFn)(Window* window, bool isMaximized, void* userData);
typedef void (*OnWindowMinimizeFn)(Window* window, bool isMinimized, void* userData);
typedef void (*OnMonitorChangeFn)(const Monitor* monitor, MonitorChangeEvent evt);

typedef uint32_t WindowHints;
constexpr WindowHints kWindowHintNone = 0;
constexpr WindowHints kWindowHintNoResize = 1 << 0;
constexpr WindowHints kWindowHintNoDecoration = 1 << 1;
constexpr WindowHints kWindowHintNoAutoIconify = 1 << 2;
constexpr WindowHints kWindowHintNoFocusOnShow = 1 << 3;
constexpr WindowHints kWindowHintScaleToMonitor = 1 << 4;
constexpr WindowHints kWindowHintFloating = 1 << 5;
constexpr WindowHints kWindowHintMaximized = 1 << 6;

struct WindowDesc
{
    int width;
    int height;
    const char* title;
    bool fullscreen;
    WindowHints hints;
};

enum class CursorStandardShape : uint32_t
{
    eArrow,
    eIBeam,
    eCrosshair,
    eHand,
    eHorizontalResize,
    eVerticalResize
};

enum class CursorMode : uint32_t
{
    eNormal,
    eHidden,
    eDisabled,
};

enum class InputMode : uint32_t
{
    eStickyKeys,
    eStickyMouseButtons,
    eLockKeyMods,
    eRawMouseMotion
};

struct VideoMode
{
    int width;
    int height;
    int redBits;
    int greenBits;
    int blueBits;
    int refreshRate;
};

struct Image
{
    int32_t width;
    int32_t height;
    uint8_t* pixels;
};

struct IWindowing
{
    CARB_PLUGIN_INTERFACE_EX("carb::windowing::IWindowing", carb_windowing_IWindowing_latest, carb_windowing_IWindowing)

    Window*(CARB_ABI* createWindow)(const WindowDesc& desc);

    void(CARB_ABI* destroyWindow)(Window* window);

    void(CARB_ABI* showWindow)(Window* window);

    void(CARB_ABI* hideWindow)(Window* window);

    uint32_t(CARB_ABI* getWindowWidth)(Window* window);

    uint32_t(CARB_ABI* getWindowHeight)(Window* window);

    Int2(CARB_ABI* getWindowPosition)(Window* window);

    void(CARB_ABI* setWindowPosition)(Window* window, const Int2& position);

    void(CARB_ABI* setWindowTitle)(Window* window, const char* title);

    void(CARB_ABI* setWindowOpacity)(Window* window, float opacity);

    float(CARB_ABI* getWindowOpacity)(Window* window);

    void(CARB_ABI* setWindowFullscreen)(Window* window, bool fullscreen);

    bool(CARB_ABI* isWindowFullscreen)(Window* window);

    void(CARB_ABI* setWindowResizeFn)(Window* window, OnWindowResizeFn onWindowResize, void* userData);

    void(CARB_ABI* resizeWindow)(Window* window, int width, int height);

    void(CARB_ABI* focusWindow)(Window* window);

    void(CARB_ABI* setWindowFocusFn)(Window* window, OnWindowFocusFn onWindowFocusFn, void* userData);

    bool(CARB_ABI* isWindowFocused)(Window* window);

    void(CARB_ABI* setWindowMinimizeFn)(Window* window, OnWindowMinimizeFn onWindowMinimizeFn, void* userData);

    bool(CARB_ABI* isWindowMinimized)(Window* window);

    void(CARB_ABI* setWindowDropFn)(Window* window, OnWindowDropFn onWindowDrop, void* userData);

    void(CARB_ABI* setWindowCloseFn)(Window* window, OnWindowCloseFn onWindowClose, void* userData);

    bool(CARB_ABI* shouldWindowClose)(Window* window);

    void(CARB_ABI* setWindowShouldClose)(Window* window, bool value);

    void*(CARB_ABI* getWindowUserPointer)(Window* window);

    void(CARB_ABI* setWindowUserPointer)(Window* window, void* pointer);

    void(CARB_ABI* setWindowContentScaleFn)(Window* window, OnWindowContentScaleFn onWindowContentScale, void* userData);

    Float2(CARB_ABI* getWindowContentScale)(Window* window);

    void*(CARB_ABI* getNativeDisplay)(Window* window);

    void*(CARB_ABI* getNativeWindow)(Window* window);

    void(CARB_ABI* setInputMode)(Window* window, InputMode mode, bool enabled);

    bool(CARB_ABI* getInputMode)(Window* window, InputMode mode);

    void(CARB_ABI* updateInputDevices)();

    void(CARB_ABI* pollEvents)();

    void(CARB_ABI* waitEvents)();

    input::Keyboard*(CARB_ABI* getKeyboard)(Window* window);

    input::Mouse*(CARB_ABI* getMouse)(Window* window);

    Cursor*(CARB_ABI* createCursorStandard)(CursorStandardShape shape);

    void(CARB_ABI* destroyCursor)(Cursor* cursor);

    void(CARB_ABI* setCursor)(Window* window, Cursor* cursor);

    void(CARB_ABI* setCursorMode)(Window* window, CursorMode mode);

    CursorMode(CARB_ABI* getCursorMode)(Window* window);

    void(CARB_ABI* setCursorPosition)(Window* window, const Int2& position);

    Int2(CARB_ABI* getCursorPosition)(Window* window);

    void(CARB_ABI* setClipboard)(Window* window, const char* text);

    const char*(CARB_ABI* getClipboard)(Window* window);

    void(CARB_ABI* setMonitorsChangeFn)(OnMonitorChangeFn onMonitorChange);

    const Monitor*(CARB_ABI* getMonitorPrimary)();

    const Monitor**(CARB_ABI* getMonitors)(size_t* monitorCount);

    const char*(CARB_ABI* getMonitorName)(const Monitor* monitor);

    Int2(CARB_ABI* getMonitorPhysicalSize)(const Monitor* monitor);

    const VideoMode*(CARB_ABI* getMonitorVideoMode)(const Monitor* monitor);

    Int2(CARB_ABI* getMonitorPosition)(const Monitor* monitor);

    Float2(CARB_ABI* getMonitorContentScale)(const Monitor* monitor);

    void(CARB_ABI* getMonitorWorkArea)(const Monitor* monitor, Int2* positionOut, Int2* sizeOut);

    void(CARB_ABI* setWindowMoveFn)(Window* window, OnWindowMoveFn onWindowMove, void* userData);

    bool(CARB_ABI* isWindowFloating)(Window* window);

    void(CARB_ABI* setWindowFloating)(Window* window, bool isFloating);

    Cursor*(CARB_ABI* createCursor)(const Image& image, int32_t xhot, int32_t yhot);

    void(CARB_ABI* maximizeWindow)(Window* window);

    void(CARB_ABI* minimizeWindow)(Window* window);

    void(CARB_ABI* restoreWindow)(Window* window);

    void(CARB_ABI* setWindowMaximizeFn)(Window* window, OnWindowMaximizeFn onWindowMaximizeFn, void* userData);

    bool(CARB_ABI* isWindowMaximized)(Window* window);

    void(CARB_ABI* setWindowIcon)(Window* window, const Image& image);

#if CARB_VERSION_ATLEAST(carb_windowing_IWindowing, 1, 5)
    carb::input::KeyboardInput(CARB_ABI* translateKey)(carb::input::KeyboardInput input);
#endif
};

} // namespace windowing
} // namespace carb