GHOST_Types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include <stdint.h>
#include <string>
 
#ifdef WITH_VULKAN_BACKEND
#  include <vulkan/vulkan_core.h>
VK_DEFINE_HANDLE(VmaAllocator)
#endif
 
/* This is used by `GHOST_C-api.h` too, cannot use C++ conventions. */
// NOLINTBEGIN: modernize-use-using
 
#include "MEM_guardedalloc.h"
 
#if defined(__cplusplus)
#  define GHOST_DECLARE_HANDLE(name) \
    typedef struct name##__ { \
      int unused; \
      MEM_CXX_CLASS_ALLOC_FUNCS(#name) \
    } *name
#else
#  define GHOST_DECLARE_HANDLE(name) \
    typedef struct name##__ { \
      int unused; \
    } *name
#endif

 
GHOST_DECLARE_HANDLE(GHOST_SystemHandle);
GHOST_DECLARE_HANDLE(GHOST_TimerTaskHandle);
GHOST_DECLARE_HANDLE(GHOST_WindowHandle);
GHOST_DECLARE_HANDLE(GHOST_EventHandle);
GHOST_DECLARE_HANDLE(GHOST_RectangleHandle);
GHOST_DECLARE_HANDLE(GHOST_EventConsumerHandle);
GHOST_DECLARE_HANDLE(GHOST_ContextHandle);
GHOST_DECLARE_HANDLE(GHOST_XrContextHandle);
 
typedef void (*GHOST_TBacktraceFn)(void *file_handle);
 
typedef void *GHOST_TUserDataPtr;
 
typedef enum { GHOST_kFailure = 0, GHOST_kSuccess } GHOST_TSuccess;

typedef struct {
  const uint8_t *data;
  int data_size[2];
  int hot_spot[2];
} GHOST_CursorBitmapRef;

typedef struct GHOST_CursorGenerator {
  uint8_t *(*generate_fn)(const struct GHOST_CursorGenerator *cursor_generator,
                          int cursor_size,
                          int cursor_size_max,
                          uint8_t *(*alloc_fn)(size_t size),
                          int r_bitmap_size[2],
                          int r_hot_spot[2],
                          bool *r_can_invert_color);
  void (*free_fn)(struct GHOST_CursorGenerator *cursor_generator);
  GHOST_TUserDataPtr user_data;
 
} GHOST_CursorGenerator;
 
typedef enum {
  GHOST_gpuStereoVisual = (1 << 0),
  GHOST_gpuDebugContext = (1 << 1),
  GHOST_gpuVSyncIsOverridden = (1 << 2),
 
} GHOST_GPUFlags;
 
typedef enum GHOST_DialogOptions {
  GHOST_DialogWarning = (1 << 0),
  GHOST_DialogError = (1 << 1),
} GHOST_DialogOptions;

typedef enum {
  GHOST_kCapabilityCursorWarp = (1 << 0),
  GHOST_kCapabilityWindowPosition = (1 << 1),
  GHOST_kCapabilityClipboardPrimary = (1 << 2),
  GHOST_kCapabilityGPUReadFrontBuffer = (1 << 3),
  GHOST_kCapabilityClipboardImage = (1 << 4),
  GHOST_kCapabilityDesktopSample = (1 << 5),
  GHOST_kCapabilityInputIME = (1 << 6),
  GHOST_kCapabilityTrackpadPhysicalDirection = (1 << 7),
  GHOST_kCapabilityWindowDecorationStyles = (1 << 8),
  GHOST_kCapabilityKeyboardHyperKey = (1 << 9),
  GHOST_kCapabilityCursorRGBA = (1 << 10),
  GHOST_kCapabilityCursorGenerator = (1 << 11),
  GHOST_kCapabilityMultiMonitorPlacement = (1 << 12),
 
} GHOST_TCapabilityFlag;

#define GHOST_CAPABILITY_FLAG_ALL \
  (GHOST_kCapabilityCursorWarp | GHOST_kCapabilityWindowPosition | \
   GHOST_kCapabilityClipboardPrimary | GHOST_kCapabilityGPUReadFrontBuffer | \
   GHOST_kCapabilityClipboardImage | GHOST_kCapabilityDesktopSample | GHOST_kCapabilityInputIME | \
   GHOST_kCapabilityTrackpadPhysicalDirection | GHOST_kCapabilityWindowDecorationStyles | \
   GHOST_kCapabilityKeyboardHyperKey | GHOST_kCapabilityCursorRGBA | \
   GHOST_kCapabilityCursorGenerator | GHOST_kCapabilityMultiMonitorPlacement)
 
/* Xtilt and Ytilt represent how much the pen is tilted away from
 * vertically upright in either the X or Y direction, with X and Y the
 * axes of the tablet surface.
 * In other words, Xtilt and Ytilt are components of a vector created by projecting
 * the pen's angle in 3D space vertically downwards on to the XY plane
 * --Matt
 */
typedef enum {
  GHOST_kTabletModeNone = 0,
  GHOST_kTabletModeStylus,
  GHOST_kTabletModeEraser
} GHOST_TTabletMode;
 
typedef enum {
  GHOST_kTabletAutomatic = 0,
  /* Show as Windows Ink to users to match "Use Windows Ink" in tablet utilities,
   * but we use the dependent Windows Pointer API. */
  GHOST_kTabletWinPointer,
  GHOST_kTabletWintab,
} GHOST_TTabletAPI;
 
typedef struct GHOST_TabletData {
  GHOST_TTabletMode Active; /* 0=None, 1=Stylus, 2=Eraser */
  float Pressure;           /* range 0.0 (not touching) to 1.0 (full pressure) */
  float Xtilt;              /* range -1.0 (left) to +1.0 (right) */
  float Ytilt;              /* range -1.0 (away from user) to +1.0 (toward user) */
} GHOST_TabletData;
 
static const GHOST_TabletData GHOST_TABLET_DATA_NONE = {
    GHOST_kTabletModeNone, /* No cursor in range */
    1.0f,                  /* Pressure */
    0.0f,                  /* Xtilt */
    0.0f};                 /* Ytilt */
 
typedef enum {
  GHOST_kNotVisible = 0,
  GHOST_kPartiallyVisible,
  GHOST_kFullyVisible
} GHOST_TVisibility;
 
typedef enum { GHOST_kFireTimeNever = 0xFFFFFFFF } GHOST_TFireTimeConstant;
 
typedef enum {
  GHOST_kModifierKeyLeftShift = 0,
  GHOST_kModifierKeyRightShift,
  GHOST_kModifierKeyLeftAlt,
  GHOST_kModifierKeyRightAlt,
  GHOST_kModifierKeyLeftControl,
  GHOST_kModifierKeyRightControl,
  GHOST_kModifierKeyLeftOS,
  GHOST_kModifierKeyRightOS,
  GHOST_kModifierKeyLeftHyper,
  GHOST_kModifierKeyRightHyper,
  GHOST_kModifierKeyNum
} GHOST_TModifierKey;

typedef enum {
  GHOST_kWindowStateNormal = 0,
  GHOST_kWindowStateMaximized = 1,
  GHOST_kWindowStateMinimized = 2,
  GHOST_kWindowStateFullScreen = 3,
} GHOST_TWindowState;
 
typedef enum {
  GHOST_kConsoleWindowStateHide = 0,
  GHOST_kConsoleWindowStateShow,
  GHOST_kConsoleWindowStateToggle,
  GHOST_kConsoleWindowStateHideForNonConsoleLaunch
} GHOST_TConsoleWindowState;
 
typedef enum { GHOST_kWindowOrderTop = 0, GHOST_kWindowOrderBottom } GHOST_TWindowOrder;
 
typedef enum {
  GHOST_kDrawingContextTypeNone = 0,
#if defined(WITH_OPENGL_BACKEND)
  GHOST_kDrawingContextTypeOpenGL,
#endif
#ifdef WIN32
  GHOST_kDrawingContextTypeD3D,
#endif
#if defined(__APPLE__) && defined(WITH_METAL_BACKEND)
  GHOST_kDrawingContextTypeMetal,
#endif
#ifdef WITH_VULKAN_BACKEND
  GHOST_kDrawingContextTypeVulkan,
#endif
} GHOST_TDrawingContextType;
 
typedef enum {
  GHOST_kButtonMaskNone,
  GHOST_kButtonMaskLeft,
  GHOST_kButtonMaskMiddle,
  GHOST_kButtonMaskRight,
  GHOST_kButtonMaskButton4,
  GHOST_kButtonMaskButton5,
  /* Trackballs and programmable buttons. */
  GHOST_kButtonMaskButton6,
  GHOST_kButtonMaskButton7,
 
#define GHOST_kButtonNum (int(GHOST_kButtonMaskButton7) + 1)
} GHOST_TButton;
 
typedef enum {
  GHOST_kEventUnknown = 0,

  GHOST_kEventCursorMove,
  GHOST_kEventButtonDown,
  GHOST_kEventButtonUp,
  GHOST_kEventWheel,
  GHOST_kEventTrackpad,
 
#ifdef WITH_INPUT_NDOF
  GHOST_kEventNDOFMotion,
  GHOST_kEventNDOFButton,
#endif

  GHOST_kEventKeyDown,
  GHOST_kEventKeyUp,
 
  GHOST_kEventQuitRequest,
 
  GHOST_kEventWindowClose,
  GHOST_kEventWindowActivate,
  GHOST_kEventWindowDeactivate,
  GHOST_kEventWindowUpdate,
  GHOST_kEventWindowUpdateDecor,
  GHOST_kEventWindowSize,
  GHOST_kEventWindowMove,
  GHOST_kEventWindowDPIHintChanged,
 
  GHOST_kEventDraggingEntered,
  GHOST_kEventDraggingUpdated,
  GHOST_kEventDraggingExited,
  GHOST_kEventDraggingDropDone,
 
  GHOST_kEventOpenMainFile, /* Needed for Cocoa to open double-clicked .blend file at startup. */
  GHOST_kEventNativeResolutionChange, /* Needed for Cocoa when window moves to other display. */
 
  GHOST_kEventImeCompositionStart,
  GHOST_kEventImeComposition,
  GHOST_kEventImeCompositionEnd,
 
#define GHOST_kNumEventTypes (GHOST_kEventImeCompositionEnd + 1)
} GHOST_TEventType;
 
typedef enum {
#define GHOST_kStandardCursorFirstCursor int(GHOST_kStandardCursorDefault)
  GHOST_kStandardCursorDefault = 0,
  GHOST_kStandardCursorRightArrow,
  GHOST_kStandardCursorLeftArrow,
  GHOST_kStandardCursorInfo,
  GHOST_kStandardCursorDestroy,
  GHOST_kStandardCursorHelp,
  GHOST_kStandardCursorWait,
  GHOST_kStandardCursorText,
  GHOST_kStandardCursorCrosshair,
  GHOST_kStandardCursorCrosshairA,
  GHOST_kStandardCursorCrosshairB,
  GHOST_kStandardCursorCrosshairC,
  GHOST_kStandardCursorPencil,
  GHOST_kStandardCursorUpArrow,
  GHOST_kStandardCursorDownArrow,
  GHOST_kStandardCursorVerticalSplit,
  GHOST_kStandardCursorHorizontalSplit,
  GHOST_kStandardCursorEraser,
  GHOST_kStandardCursorKnife,
  GHOST_kStandardCursorEyedropper,
  GHOST_kStandardCursorZoomIn,
  GHOST_kStandardCursorZoomOut,
  GHOST_kStandardCursorMove,
  GHOST_kStandardCursorNSEWScroll,
  GHOST_kStandardCursorNSScroll,
  GHOST_kStandardCursorEWScroll,
  GHOST_kStandardCursorStop,
  GHOST_kStandardCursorUpDown,
  GHOST_kStandardCursorLeftRight,
  GHOST_kStandardCursorTopSide,
  GHOST_kStandardCursorBottomSide,
  GHOST_kStandardCursorLeftSide,
  GHOST_kStandardCursorRightSide,
  GHOST_kStandardCursorTopLeftCorner,
  GHOST_kStandardCursorTopRightCorner,
  GHOST_kStandardCursorBottomRightCorner,
  GHOST_kStandardCursorBottomLeftCorner,
  GHOST_kStandardCursorCopy,
  GHOST_kStandardCursorLeftHandle,
  GHOST_kStandardCursorRightHandle,
  GHOST_kStandardCursorBothHandles,
  GHOST_kStandardCursorHandOpen,
  GHOST_kStandardCursorHandClosed,
  GHOST_kStandardCursorHandPoint,
  GHOST_kStandardCursorBlade,
  GHOST_kStandardCursorSlip,
  GHOST_kStandardCursorCustom,
 
#define GHOST_kStandardCursorNumCursors (int(GHOST_kStandardCursorCustom) + 1)
} GHOST_TStandardCursor;
 
typedef enum {
  GHOST_kKeyUnknown = -1,
  GHOST_kKeyBackSpace,
  GHOST_kKeyTab,
  GHOST_kKeyLinefeed,
  GHOST_kKeyClear,
  GHOST_kKeyEnter = 0x0D,
 
  GHOST_kKeyEsc = 0x1B,
  GHOST_kKeySpace = ' ',
  GHOST_kKeyQuote = 0x27,
  GHOST_kKeyComma = ',',
  GHOST_kKeyMinus = '-',
  GHOST_kKeyPlus = '+',
  GHOST_kKeyPeriod = '.',
  GHOST_kKeySlash = '/',
 
  /* Number keys. */
  GHOST_kKey0 = '0',
  GHOST_kKey1,
  GHOST_kKey2,
  GHOST_kKey3,
  GHOST_kKey4,
  GHOST_kKey5,
  GHOST_kKey6,
  GHOST_kKey7,
  GHOST_kKey8,
  GHOST_kKey9,
 
  GHOST_kKeySemicolon = ';',
  GHOST_kKeyEqual = '=',
 
  /* Character keys. */
  GHOST_kKeyA = 'A',
  GHOST_kKeyB,
  GHOST_kKeyC,
  GHOST_kKeyD,
  GHOST_kKeyE,
  GHOST_kKeyF,
  GHOST_kKeyG,
  GHOST_kKeyH,
  GHOST_kKeyI,
  GHOST_kKeyJ,
  GHOST_kKeyK,
  GHOST_kKeyL,
  GHOST_kKeyM,
  GHOST_kKeyN,
  GHOST_kKeyO,
  GHOST_kKeyP,
  GHOST_kKeyQ,
  GHOST_kKeyR,
  GHOST_kKeyS,
  GHOST_kKeyT,
  GHOST_kKeyU,
  GHOST_kKeyV,
  GHOST_kKeyW,
  GHOST_kKeyX,
  GHOST_kKeyY,
  GHOST_kKeyZ,
 
  GHOST_kKeyLeftBracket = '[',
  GHOST_kKeyRightBracket = ']',
  GHOST_kKeyBackslash = 0x5C,
  GHOST_kKeyAccentGrave = '`',
 
#define _GHOST_KEY_MODIFIER_MIN GHOST_kKeyLeftShift
  /* Modifiers: See #GHOST_KEY_MODIFIER_CHECK. */
  GHOST_kKeyLeftShift = 0x100,
  GHOST_kKeyRightShift,
  GHOST_kKeyLeftControl,
  GHOST_kKeyRightControl,
  GHOST_kKeyLeftAlt,
  GHOST_kKeyRightAlt,
  GHOST_kKeyLeftOS, /* Command key on Apple, Windows key(s) on Windows. */
  GHOST_kKeyRightOS,
 
  GHOST_kKeyLeftHyper, /* Additional modifier on Wayland & X11, see !136340. */
  GHOST_kKeyRightHyper,
#define _GHOST_KEY_MODIFIER_MAX GHOST_kKeyRightHyper
 
  GHOST_kKeyGrLess, /* German PC only! */
  GHOST_kKeyApp,    /* Also known as menu key. */
 
  GHOST_kKeyCapsLock,
  GHOST_kKeyNumLock,
  GHOST_kKeyScrollLock,
 
  GHOST_kKeyLeftArrow,
  GHOST_kKeyRightArrow,
  GHOST_kKeyUpArrow,
  GHOST_kKeyDownArrow,
 
  GHOST_kKeyPrintScreen,
  GHOST_kKeyPause,
 
  GHOST_kKeyInsert,
  GHOST_kKeyDelete,
  GHOST_kKeyHome,
  GHOST_kKeyEnd,
  GHOST_kKeyUpPage,
  GHOST_kKeyDownPage,
 
  /* Numpad keys. */
  GHOST_kKeyNumpad0,
  GHOST_kKeyNumpad1,
  GHOST_kKeyNumpad2,
  GHOST_kKeyNumpad3,
  GHOST_kKeyNumpad4,
  GHOST_kKeyNumpad5,
  GHOST_kKeyNumpad6,
  GHOST_kKeyNumpad7,
  GHOST_kKeyNumpad8,
  GHOST_kKeyNumpad9,
  GHOST_kKeyNumpadPeriod,
  GHOST_kKeyNumpadEnter,
  GHOST_kKeyNumpadPlus,
  GHOST_kKeyNumpadMinus,
  GHOST_kKeyNumpadAsterisk,
  GHOST_kKeyNumpadSlash,
 
  /* Function keys. */
  GHOST_kKeyF1,
  GHOST_kKeyF2,
  GHOST_kKeyF3,
  GHOST_kKeyF4,
  GHOST_kKeyF5,
  GHOST_kKeyF6,
  GHOST_kKeyF7,
  GHOST_kKeyF8,
  GHOST_kKeyF9,
  GHOST_kKeyF10,
  GHOST_kKeyF11,
  GHOST_kKeyF12,
  GHOST_kKeyF13,
  GHOST_kKeyF14,
  GHOST_kKeyF15,
  GHOST_kKeyF16,
  GHOST_kKeyF17,
  GHOST_kKeyF18,
  GHOST_kKeyF19,
  GHOST_kKeyF20,
  GHOST_kKeyF21,
  GHOST_kKeyF22,
  GHOST_kKeyF23,
  GHOST_kKeyF24,
 
  /* Multimedia keypad buttons. */
  GHOST_kKeyMediaPlay,
  GHOST_kKeyMediaStop,
  GHOST_kKeyMediaFirst,
  GHOST_kKeyMediaLast
} GHOST_TKey;
 
#define GHOST_KEY_MODIFIER_NUM ((_GHOST_KEY_MODIFIER_MAX - _GHOST_KEY_MODIFIER_MIN) + 1)
#define GHOST_KEY_MODIFIER_TO_INDEX(key) ((unsigned int)(key) - _GHOST_KEY_MODIFIER_MIN)
#define GHOST_KEY_MODIFIER_FROM_INDEX(key) \
  (GHOST_TKey)(((unsigned int)(key) + _GHOST_KEY_MODIFIER_MIN))
#define GHOST_KEY_MODIFIER_CHECK(key) (GHOST_KEY_MODIFIER_TO_INDEX(key) < GHOST_KEY_MODIFIER_NUM)
 
typedef enum {
  GHOST_kGrabDisable = 0,
  GHOST_kGrabNormal,
  GHOST_kGrabWrap,
  GHOST_kGrabHide,
} GHOST_TGrabCursorMode;
 
#define GHOST_GRAB_NEEDS_SOFTWARE_CURSOR_FOR_WARP(grab) ((grab) == GHOST_kGrabWrap)
 
typedef enum {
  GHOST_kAxisNone = 0,
  GHOST_kAxisX = (1 << 0),
  GHOST_kAxisY = (1 << 1),
} GHOST_TAxisFlag;
 
typedef const void *GHOST_TEventDataPtr;
 
typedef struct {
  int32_t x;
  int32_t y;
  GHOST_TabletData tablet;
} GHOST_TEventCursorData;
 
typedef struct {
  GHOST_TButton button;
  GHOST_TabletData tablet;
} GHOST_TEventButtonData;
 
typedef enum {
  GHOST_kEventWheelAxisVertical = 0,
  GHOST_kEventWheelAxisHorizontal = 1,
} GHOST_TEventWheelAxis;
 
typedef struct {
  GHOST_TEventWheelAxis axis;
  int32_t value;
} GHOST_TEventWheelData;
 
typedef enum {
  GHOST_kTrackpadEventUnknown = 0,
  GHOST_kTrackpadEventScroll,
  GHOST_kTrackpadEventRotate,
  GHOST_kTrackpadEventSwipe, /* Reserved, not used for now */
  GHOST_kTrackpadEventMagnify,
  GHOST_kTrackpadEventSmartMagnify
} GHOST_TTrackpadEventSubTypes;
 
typedef struct {
  GHOST_TTrackpadEventSubTypes subtype;
  int32_t x;
  int32_t y;
  int32_t deltaX;
  int32_t deltaY;
  char isDirectionInverted;
} GHOST_TEventTrackpadData;
 
typedef enum {
  GHOST_kDragnDropTypeUnknown = 0,
  GHOST_kDragnDropTypeFilenames, /* Array of strings representing file names (full path). */
  GHOST_kDragnDropTypeString,    /* Unformatted text UTF8 string. */
  GHOST_kDragnDropTypeBitmap     /* Bitmap image data. */
} GHOST_TDragnDropTypes;
 
typedef void *GHOST_TDragnDropDataPtr;
 
typedef struct {
  int32_t x;
  int32_t y;
  GHOST_TDragnDropTypes dataType;
  GHOST_TDragnDropDataPtr data;
} GHOST_TEventDragnDropData;

typedef struct {
  std::string result, composite;
  int cursor_position;
  int target_start;
  int target_end;
} GHOST_TEventImeData;
 
typedef struct {
  int count;
  uint8_t **strings;
} GHOST_TStringArray;

typedef enum {
  GHOST_kNotStarted = 0,
  GHOST_kStarting,
  GHOST_kInProgress,
  GHOST_kFinishing,
  GHOST_kFinished
} GHOST_TProgress;
 
#ifdef WITH_INPUT_NDOF
typedef struct {
  /* Each component normally ranges from -1 to +1, but can exceed that.
   * These use blender standard view coordinates,
   * with positive rotations being CCW about the axis. */
  /* translation: */
  float tx, ty, tz;
  /* rotation:
   * - `axis = (rx,ry,rz).normalized`
   * - `amount = (rx,ry,rz).magnitude` [in revolutions, 1.0 = 360 deg]. */
  float rx, ry, rz;
  float dt;
  GHOST_TProgress progress;
} GHOST_TEventNDOFMotionData;
 
typedef enum { GHOST_kPress, GHOST_kRelease } GHOST_TButtonAction;
/* Good for mouse or other buttons too? */
 
typedef struct {
  GHOST_TButtonAction action;
  short button;
} GHOST_TEventNDOFButtonData;
#endif  // WITH_INPUT_NDOF
 
typedef struct {
  GHOST_TKey key;

  char utf8_buf[6];

  char is_repeat;
} GHOST_TEventKeyData;
 
typedef enum {
  GHOST_kUserSpecialDirDesktop,
  GHOST_kUserSpecialDirDocuments,
  GHOST_kUserSpecialDirDownloads,
  GHOST_kUserSpecialDirMusic,
  GHOST_kUserSpecialDirPictures,
  GHOST_kUserSpecialDirVideos,
  GHOST_kUserSpecialDirCaches,
  /* Can be extended as needed. */
} GHOST_TUserSpecialDirTypes;
 
typedef enum {
  GHOST_kDecorationNone = 0,
  GHOST_kDecorationColoredTitleBar = (1 << 0),
} GHOST_TWindowDecorationStyleFlags;
 
typedef struct {
  int index;
  uint vendor_id;
  uint device_id;
} GHOST_GPUDevice;

typedef enum {
  GHOST_kVSyncModeUnset = -2,
  GHOST_kVSyncModeAuto = -1,
  GHOST_kVSyncModeOff = 0,
  GHOST_kVSyncModeOn = 1,
} GHOST_TVSyncModes;

typedef struct {
  bool is_stereo_visual;
  bool is_debug;
  GHOST_TVSyncModes vsync;
} GHOST_ContextParams;
 
#define GHOST_CONTEXT_PARAMS_NONE \
  { \
      /*is_stereo_visual*/ false, \
      /*is_debug*/ false, \
      /*vsync*/ GHOST_kVSyncModeUnset, \
  }
 
#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS_OFFSCREEN(gpu_settings) \
  { \
      /*is_stereo_visual*/ false, \
      /*is_debug*/ (((gpu_settings).flags & GHOST_gpuDebugContext) != 0), \
      /*vsync*/ GHOST_kVSyncModeUnset, \
  }
 
#define GHOST_CONTEXT_PARAMS_FROM_GPU_SETTINGS(gpu_settings) \
  { \
      /*is_stereo_visual*/ (((gpu_settings).flags & GHOST_gpuStereoVisual) != 0), \
      /*is_debug*/ (((gpu_settings).flags & GHOST_gpuDebugContext) != 0), /*vsync*/ \
      (((gpu_settings).flags & GHOST_gpuVSyncIsOverridden) ? (gpu_settings).vsync : \
                                                             GHOST_kVSyncModeUnset), \
  }
 
typedef struct {
  int flags;
  GHOST_TVSyncModes vsync;
  GHOST_TDrawingContextType context_type;
  GHOST_GPUDevice preferred_device;
} GHOST_GPUSettings;
 
typedef struct {
  float colored_titlebar_bg_color[3];
} GHOST_WindowDecorationStyleSettings;
 
typedef struct {
  /* Is HDR enabled for this Window? */
  bool hdr_enabled;
  /* Is wide gamut enabled for this Window? */
  bool wide_gamut_enabled;
  /* Scale factor to display SDR content in HDR. */
  float sdr_white_level;
} GHOST_WindowHDRInfo;
 
#define GHOST_WINDOW_HDR_INFO_NONE \
  { \
      /*hdr_enabled*/ false, \
      /*wide_gamut_enabled*/ false, \
      /*sdr_white_level*/ 1.0f, \
  }
 
#ifdef WITH_VULKAN_BACKEND
typedef struct {
  VkImage image;
  VkSurfaceFormatKHR surface_format;
  VkExtent2D extent;
  VkSemaphore acquire_semaphore;
  VkSemaphore present_semaphore;
  VkFence submission_fence;
  /* Factor to scale SDR content to HDR. */
  float sdr_scale;
} GHOST_VulkanSwapChainData;
 
typedef enum {
  GHOST_kVulkanXRModeCPU,

  GHOST_kVulkanXRModeFD,

  GHOST_kVulkanXRModeWin32,
} GHOST_TVulkanXRModes;
 
typedef struct {
  GHOST_TVulkanXRModes data_transfer_mode;

  VkExtent2D extent;
 
  union {
    struct {

      void *image_data;
    } cpu;
    struct {
      VkImage vk_image_blender;

      bool new_handle;

      uint64_t image_handle;

      VkFormat image_format;

      VkDeviceSize memory_size;

      VkDeviceSize memory_offset;
    } gpu;
  };
 
} GHOST_VulkanOpenXRData;

typedef struct {
  VkInstance instance;
  VkPhysicalDevice physical_device;
  VkDevice device;
  uint32_t graphic_queue_family;
  VkQueue queue;
  void *queue_mutex;
  VmaAllocator vma_allocator;
} GHOST_VulkanHandles;
 
#endif
 
typedef enum {
  GHOST_kDebugDefault = (1 << 1),
  GHOST_kDebugWintab = (1 << 2),
} GHOST_TDebugFlags;
 
typedef struct {
  int flags;
} GHOST_Debug;
 
#ifdef _WIN32
typedef void *GHOST_TEmbedderWindowID;
#endif  // _WIN32
 
#ifndef _WIN32
/* I can't use "Window" from `X11/Xlib.h`
 * because it conflicts with Window defined in `winlay.h`. */
typedef int GHOST_TEmbedderWindowID;
#endif  // _WIN32

#ifdef __cplusplus
class GHOST_ITimerTask;
typedef void (*GHOST_TimerProcPtr)(GHOST_ITimerTask *task, uint64_t time);
#else
struct GHOST_TimerTaskHandle__;
typedef void (*GHOST_TimerProcPtr)(struct GHOST_TimerTaskHandle__ *task, uint64_t time);
#endif
 
#ifdef WITH_XR_OPENXR
 
struct GHOST_XrDrawViewInfo;
struct GHOST_XrError;
typedef enum GHOST_TXrGraphicsBinding {
  GHOST_kXrGraphicsUnknown = 0,
  GHOST_kXrGraphicsOpenGL,
  GHOST_kXrGraphicsVulkan,
#  ifdef WIN32
  GHOST_kXrGraphicsOpenGLD3D11,
  GHOST_kXrGraphicsVulkanD3D11,
#  endif
  /* For later */
  //  GHOST_kXrGraphicsVulkan,
} GHOST_TXrGraphicsBinding;
 
typedef void (*GHOST_XrErrorHandlerFn)(const struct GHOST_XrError *);
 
typedef void (*GHOST_XrSessionCreateFn)(void);
typedef void (*GHOST_XrSessionExitFn)(void *customdata);
typedef void (*GHOST_XrCustomdataFreeFn)(void *customdata);
 
typedef void *(*GHOST_XrGraphicsContextBindFn)(void);
typedef void (*GHOST_XrGraphicsContextUnbindFn)(GHOST_ContextHandle graphics_context);
typedef void (*GHOST_XrDrawViewFn)(const struct GHOST_XrDrawViewInfo *draw_view, void *customdata);
typedef bool (*GHOST_XrPassthroughEnabledFn)(void *customdata);
typedef void (*GHOST_XrDisablePassthroughFn)(void *customdata);

typedef const GHOST_TXrGraphicsBinding *GHOST_XrGraphicsBindingCandidates;
 
typedef struct {
  bool is_active;
  float position[3];
  /* Blender convention (w, x, y, z) */
  float orientation_quat[4];
} GHOST_XrPose;
 
enum {
  GHOST_kXrContextDebug = (1 << 0),
  GHOST_kXrContextDebugTime = (1 << 1),
#  ifdef WIN32
  /* Needed to avoid issues with the SteamVR OpenGL graphics binding
   * (use DirectX fallback instead). */
  GHOST_kXrContextGpuNVIDIA = (1 << 2),
#  endif
};
 
typedef struct {
  const GHOST_XrGraphicsBindingCandidates gpu_binding_candidates;
  unsigned int gpu_binding_candidates_count;
 
  unsigned int context_flag;
} GHOST_XrContextCreateInfo;
 
typedef struct {
  GHOST_XrPose base_pose;
 
  GHOST_XrSessionCreateFn create_fn;
  GHOST_XrSessionExitFn exit_fn;
  void *exit_customdata;
} GHOST_XrSessionBeginInfo;

typedef enum GHOST_TXrSwapchainFormat {
  GHOST_kXrSwapchainFormatRGBA8,
  GHOST_kXrSwapchainFormatRGBA16,
  GHOST_kXrSwapchainFormatRGBA16F,
  GHOST_kXrSwapchainFormatRGB10_A2,
} GHOST_TXrSwapchainFormat;
 
typedef struct GHOST_XrDrawViewInfo {
  int ofsx, ofsy;
  int width, height;
 
  GHOST_XrPose eye_pose;
  GHOST_XrPose local_pose;
 
  struct {
    float angle_left, angle_right;
    float angle_up, angle_down;
  } fov;
 
  GHOST_TXrSwapchainFormat swapchain_format;
  char expects_srgb_buffer;

  char view_idx;
} GHOST_XrDrawViewInfo;
 
typedef struct GHOST_XrError {
  const char *user_message;
 
  void *customdata;
} GHOST_XrError;
 
typedef struct GHOST_XrActionSetInfo {
  const char *name;
 
  GHOST_XrCustomdataFreeFn customdata_free_fn;
  void *customdata; /* wmXrActionSet */
} GHOST_XrActionSetInfo;

typedef enum GHOST_XrActionType {
  GHOST_kXrActionTypeBooleanInput = 1,
  GHOST_kXrActionTypeFloatInput = 2,
  GHOST_kXrActionTypeVector2fInput = 3,
  GHOST_kXrActionTypePoseInput = 4,
  GHOST_kXrActionTypeVibrationOutput = 100,
} GHOST_XrActionType;
 
typedef struct GHOST_XrActionInfo {
  const char *name;
  GHOST_XrActionType type;
  uint32_t count_subaction_paths;
  const char **subaction_paths;
  void *states;
  float *float_thresholds;
  int16_t *axis_flags;
 
  GHOST_XrCustomdataFreeFn customdata_free_fn;
  void *customdata; /* wmXrAction */
} GHOST_XrActionInfo;
 
typedef struct GHOST_XrActionBindingInfo {
  const char *component_path;
  float float_threshold;
  int16_t axis_flag;
  GHOST_XrPose pose;
} GHOST_XrActionBindingInfo;
 
typedef struct GHOST_XrActionProfileInfo {
  const char *action_name;
  const char *profile_path;
  uint32_t count_subaction_paths;
  const char **subaction_paths;
  const GHOST_XrActionBindingInfo *bindings;
} GHOST_XrActionProfileInfo;
 
typedef struct GHOST_XrControllerModelVertex {
  float position[3];
  float normal[3];
} GHOST_XrControllerModelVertex;
 
typedef struct GHOST_XrControllerModelComponent {
  float transform[4][4];
  uint32_t vertex_offset;
  uint32_t vertex_count;
  uint32_t index_offset;
  uint32_t index_count;
} GHOST_XrControllerModelComponent;
 
typedef struct GHOST_XrControllerModelData {
  uint32_t count_vertices;
  const GHOST_XrControllerModelVertex *vertices;
  uint32_t count_indices;
  const uint32_t *indices;
  uint32_t count_components;
  const GHOST_XrControllerModelComponent *components;
} GHOST_XrControllerModelData;
 
#endif /* WITH_XR_OPENXR */
 
// NOLINTEND: modernize-use-using

typedef enum {
 
  GHOST_NDOF_BUTTON_NONE = -1,
  /* Used internally, never sent or used as an index. */
  GHOST_NDOF_BUTTON_INVALID = 0,
 
  /* These two are available from any 3Dconnexion device. */
  GHOST_NDOF_BUTTON_MENU = 1,
  GHOST_NDOF_BUTTON_FIT = 2,
 
  /* Standard views. */
  GHOST_NDOF_BUTTON_TOP = 3,
  GHOST_NDOF_BUTTON_LEFT = 4,
  GHOST_NDOF_BUTTON_RIGHT = 5,
  GHOST_NDOF_BUTTON_FRONT = 6,
  GHOST_NDOF_BUTTON_BOTTOM = 7,
  GHOST_NDOF_BUTTON_BACK = 8,
 
  /* 90 degrees rotations. */
  GHOST_NDOF_BUTTON_ROLL_CW = 9,
  GHOST_NDOF_BUTTON_ROLL_CCW = 10,
 
  /* More views. */
  GHOST_NDOF_BUTTON_ISO1 = 11,
  GHOST_NDOF_BUTTON_ISO2 = 12,
 
  /* General-purpose buttons.
   * Users can assign functions via keymap editor. */
  GHOST_NDOF_BUTTON_1 = 13,
  GHOST_NDOF_BUTTON_2 = 14,
  GHOST_NDOF_BUTTON_3 = 15,
  GHOST_NDOF_BUTTON_4 = 16,
  GHOST_NDOF_BUTTON_5 = 17,
  GHOST_NDOF_BUTTON_6 = 18,
  GHOST_NDOF_BUTTON_7 = 19,
  GHOST_NDOF_BUTTON_8 = 20,
  GHOST_NDOF_BUTTON_9 = 21,
  GHOST_NDOF_BUTTON_10 = 22,
 
  /* Keyboard keys. */
  GHOST_NDOF_BUTTON_ESC = 23,
  GHOST_NDOF_BUTTON_ALT = 24,
  GHOST_NDOF_BUTTON_SHIFT = 25,
  GHOST_NDOF_BUTTON_CTRL = 26,
 
  /* Device control. */
  GHOST_NDOF_BUTTON_ROTATE = 27,
  GHOST_NDOF_BUTTON_PANZOOM = 28,
  GHOST_NDOF_BUTTON_DOMINANT = 29,
  GHOST_NDOF_BUTTON_PLUS = 30,
  GHOST_NDOF_BUTTON_MINUS = 31,
 
  /* New spin buttons. */
  GHOST_NDOF_BUTTON_SPIN_CW = 32,
  GHOST_NDOF_BUTTON_SPIN_CCW = 33,
  GHOST_NDOF_BUTTON_TILT_CW = 34,
  GHOST_NDOF_BUTTON_TILT_CCW = 35,
 
  /* Keyboard keys. */
  GHOST_NDOF_BUTTON_ENTER = 36,
  GHOST_NDOF_BUTTON_DELETE = 37,
 
  /* Keyboard Pro special buttons. */
  GHOST_NDOF_BUTTON_KBP_F1 = 41,
  GHOST_NDOF_BUTTON_KBP_F2 = 42,
  GHOST_NDOF_BUTTON_KBP_F3 = 43,
  GHOST_NDOF_BUTTON_KBP_F4 = 44,
  GHOST_NDOF_BUTTON_KBP_F5 = 45,
  GHOST_NDOF_BUTTON_KBP_F6 = 46,
  GHOST_NDOF_BUTTON_KBP_F7 = 47,
  GHOST_NDOF_BUTTON_KBP_F8 = 48,
  GHOST_NDOF_BUTTON_KBP_F9 = 49,
  GHOST_NDOF_BUTTON_KBP_F10 = 50,
  GHOST_NDOF_BUTTON_KBP_F11 = 51,
  GHOST_NDOF_BUTTON_KBP_F12 = 52,
 
  /* General-purpose buttons.
   * Users can assign functions via keymap editor. */
  GHOST_NDOF_BUTTON_11 = 77,
  GHOST_NDOF_BUTTON_12 = 78,
 
  /* Store views. */
  GHOST_NDOF_BUTTON_V1 = 103,
  GHOST_NDOF_BUTTON_V2 = 104,
  GHOST_NDOF_BUTTON_V3 = 105,
  GHOST_NDOF_BUTTON_SAVE_V1 = 139,
  GHOST_NDOF_BUTTON_SAVE_V2 = 140,
  GHOST_NDOF_BUTTON_SAVE_V3 = 141,
 
  /* Keyboard keys. */
  GHOST_NDOF_BUTTON_TAB = 175,
  GHOST_NDOF_BUTTON_SPACE = 176,
 
  /* Numpad Pro special buttons. */
  GHOST_NDOF_BUTTON_NP_F1 = 229,
  GHOST_NDOF_BUTTON_NP_F2 = 230,
  GHOST_NDOF_BUTTON_NP_F3 = 231,
  GHOST_NDOF_BUTTON_NP_F4 = 232,
 
  GHOST_NDOF_BUTTON_USER = 0x10000
 
} GHOST_NDOF_ButtonT;