Window.h

#pragma once
 
#include <Core/CoreDLL.h>
#include <Foundation/Math/Rect.h>
#include <Foundation/Math/Size.h>
#include <Foundation/Math/Vec2.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Types/UniquePtr.h>
 
class plOpenDdlWriter;
class plOpenDdlReader;
class plOpenDdlReaderElement;
 
// Include the proper Input implementation to use
#if PL_ENABLED(PL_SUPPORTS_GLFW)
#  include <Core/System/Implementation/glfw/InputDevice_glfw.h>
#elif PL_ENABLED(PL_PLATFORM_WINDOWS_DESKTOP)
#  include <Core/System/Implementation/Win/InputDevice_win32.h>
#elif PL_ENABLED(PL_PLATFORM_WINDOWS_UWP)
#  include <Core/System/Implementation/uwp/InputDevice_uwp.h>
#elif PL_ENABLED(PL_PLATFORM_ANDROID)
#  include <Core/System/Implementation/android/InputDevice_android.h>
#else
#  include <Core/System/Implementation/null/InputDevice_null.h>
#endif
 
// Currently the following scenarios are possible
// - Windows native implementation, using HWND
// - GLFW on windows, using GLFWWindow* internally and HWND to pass windows around
// - GLFW / XCB on linux. Runtime uses GLFWWindow*. Editor uses xcb-window. Tagged union is passed around as window handle.
 
#if PL_ENABLED(PL_SUPPORTS_GLFW)
 
extern "C"
{
  typedef struct GLFWwindow GLFWwindow;
}
 
#  if PL_ENABLED(PL_PLATFORM_WINDOWS_DESKTOP)
#    include <Foundation/Basics/Platform/Win/MinWindows.h>
using plWindowHandle = plMinWindows::HWND;
using plWindowInternalHandle = GLFWwindow*;
#    define INVALID_WINDOW_HANDLE_VALUE (plWindowHandle)(0)
#    define INVALID_INTERNAL_WINDOW_HANDLE_VALUE nullptr
#  elif PL_ENABLED(PL_PLATFORM_LINUX)
 
extern "C"
{
  typedef struct xcb_connection_t xcb_connection_t;
}
 
struct plXcbWindowHandle
{
  xcb_connection_t* m_pConnection;
  plUInt32 m_Window;
};
 
struct plWindowHandle
{
  enum class Type
  {
    Invalid = 0,
    GLFW = 1, // Used by the runtime
    XCB = 2   // Used by the editor
  };
 
  Type type;
  union
  {
    GLFWwindow* glfwWindow;
    plXcbWindowHandle xcbWindow;
  };
 
  bool operator==(plWindowHandle& rhs)
  {
    if (type != rhs.type)
      return false;
 
    if (type == Type::GLFW)
    {
      return glfwWindow == rhs.glfwWindow;
    }
    else
    {
      // We don't compare the connection because we only want to know if we reference the same window.
      return xcbWindow.m_Window == rhs.xcbWindow.m_Window;
    }
  }
};
 
using plWindowInternalHandle = plWindowHandle;
#    define INVALID_WINDOW_HANDLE_VALUE \
      plWindowHandle {}
#  else
using plWindowHandle = GLFWwindow*;
using plWindowInternalHandle = GLFWwindow*;
#    define INVALID_WINDOW_HANDLE_VALUE (GLFWwindow*)(0)
#  endif
 
#elif PL_ENABLED(PL_PLATFORM_WINDOWS_DESKTOP)
 
#  include <Foundation/Basics/Platform/Win/MinWindows.h>
using plWindowHandle = plMinWindows::HWND;
using plWindowInternalHandle = plWindowHandle;
#  define INVALID_WINDOW_HANDLE_VALUE (plWindowHandle)(0)
 
#elif PL_ENABLED(PL_PLATFORM_WINDOWS_UWP)
 
using plWindowHandle = IUnknown*;
using plWindowInternalHandle = plWindowHandle;
#  define INVALID_WINDOW_HANDLE_VALUE nullptr
 
#elif PL_ENABLED(PL_PLATFORM_ANDROID)
 
struct ANativeWindow;
using plWindowHandle = ANativeWindow*;
using plWindowInternalHandle = plWindowHandle;
#  define INVALID_WINDOW_HANDLE_VALUE nullptr
 
#else
 
using plWindowHandle = void*;
using plWindowInternalHandle = plWindowHandle;
#  define INVALID_WINDOW_HANDLE_VALUE nullptr
 
#endif
 
#ifndef INVALID_INTERNAL_WINDOW_HANDLE_VALUE
#  define INVALID_INTERNAL_WINDOW_HANDLE_VALUE INVALID_WINDOW_HANDLE_VALUE
#endif
 
class PL_CORE_DLL plWindowBase
{
public:
  virtual ~plWindowBase() = default;
 
  virtual plSizeU32 GetClientAreaSize() const = 0;
  virtual plWindowHandle GetNativeWindowHandle() const = 0;
 
  virtual bool IsFullscreenWindow(bool bOnlyProperFullscreenMode = false) const = 0;
 
  virtual bool IsVisible() const = 0;
 
  virtual void ProcessWindowMessages() = 0;
 
  virtual void AddReference() = 0;
  virtual void RemoveReference() = 0;
};
 
struct PL_CORE_DLL plWindowMode
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    WindowFixedResolution,                
    WindowResizable,                      
    FullscreenBorderlessNativeResolution, 
    FullscreenFixedResolution,            
 
    Default = WindowFixedResolution
  };
 
  static constexpr bool IsFullscreen(Enum e) { return e == FullscreenBorderlessNativeResolution || e == FullscreenFixedResolution; }
};
 
struct PL_CORE_DLL plWindowCreationDesc
{
  plResult AdjustWindowSizeAndPosition();
 
  void SaveToDDL(plOpenDdlWriter& ref_writer);
 
  plResult SaveToDDL(plStringView sFile);
 
  void LoadFromDDL(const plOpenDdlReaderElement* pParentElement);
 
  plResult LoadFromDDL(plStringView sFile);
 
 
  plString m_Title = "plEngine";
 
  plEnum<plWindowMode> m_WindowMode;
 
  plInt8 m_iMonitor = -1;
 
  plVec2I32 m_Position = plVec2I32(0x80000000, 0x80000000); // Magic number on windows that positions the window at a 'good default position'
 
  plSizeU32 m_Resolution = plSizeU32(1280, 720);
 
  plUInt8 m_uiWindowNumber = 0;
 
  bool m_bClipMouseCursor = true;
 
  bool m_bShowMouseCursor = false;
 
  bool m_bSetForegroundOnInit = true;
 
  bool m_bCenterWindowOnDisplay = true;
};
 
class PL_CORE_DLL plWindow : public plWindowBase
{
public:
  plWindow();
 
  virtual ~plWindow();
 
  inline const plWindowCreationDesc& GetCreationDescription() const { return m_CreationDescription; }
 
  virtual plSizeU32 GetClientAreaSize() const override { return m_CreationDescription.m_Resolution; }
 
  virtual plWindowHandle GetNativeWindowHandle() const override;
 
  virtual bool IsFullscreenWindow(bool bOnlyProperFullscreenMode = false) const override
  {
    if (bOnlyProperFullscreenMode)
      return m_CreationDescription.m_WindowMode == plWindowMode::FullscreenFixedResolution;
 
    return plWindowMode::IsFullscreen(m_CreationDescription.m_WindowMode);
  }
 
  virtual bool IsVisible() const override { return m_bVisible; }
 
  virtual void AddReference() override { m_iReferenceCount.Increment(); }
  virtual void RemoveReference() override { m_iReferenceCount.Decrement(); }
 
 
  virtual void ProcessWindowMessages() override;
 
  plResult Initialize();
 
  plResult Initialize(const plWindowCreationDesc& creationDescription)
  {
    m_CreationDescription = creationDescription;
    return Initialize();
  }
 
  inline bool IsInitialized() const { return m_bInitialized; }
 
  plResult Destroy();
 
  plResult Resize(const plSizeU32& newWindowSize);
 
  virtual void OnResize(const plSizeU32& newWindowSize);
 
  virtual void OnWindowMove(const plInt32 iNewPosX, const plInt32 iNewPosY) {}
 
  virtual void OnFocus(bool bHasFocus) {}
 
  virtual void OnVisibleChange(bool bVisible) { m_bVisible = bVisible; }
 
  virtual void OnClickClose() {}
 
 
#if PL_ENABLED(PL_PLATFORM_WINDOWS)
  virtual void OnWindowMessage(plMinWindows::HWND hWnd, plMinWindows::UINT msg, plMinWindows::WPARAM wparam, plMinWindows::LPARAM lparam);
 
#elif PL_ENABLED(PL_PLATFORM_OSX)
 
#elif PL_ENABLED(PL_PLATFORM_LINUX)
 
#elif PL_ENABLED(PL_PLATFORM_ANDROID)
 
#else
#  error "Missing code for plWindow on this platform!"
#endif
 
  plStandardInputDevice* GetInputDevice() const { return m_pInputDevice.Borrow(); }
 
  static plUInt8 GetNextUnusedWindowNumber();
 
protected:
  plWindowCreationDesc m_CreationDescription;
 
private:
  bool m_bInitialized = false;
  bool m_bVisible = true;
 
  plUniquePtr<plStandardInputDevice> m_pInputDevice;
 
  mutable plWindowInternalHandle m_hWindowHandle = plWindowInternalHandle();
 
#if PL_ENABLED(PL_SUPPORTS_GLFW)
  static void IconifyCallback(GLFWwindow* window, int iconified);
  static void SizeCallback(GLFWwindow* window, int width, int height);
  static void PositionCallback(GLFWwindow* window, int xpos, int ypos);
  static void CloseCallback(GLFWwindow* window);
  static void FocusCallback(GLFWwindow* window, int focused);
  static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
  static void CharacterCallback(GLFWwindow* window, unsigned int codepoint);
  static void CursorPositionCallback(GLFWwindow* window, double xpos, double ypos);
  static void MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
  static void ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
#endif
 
  static plUInt8 s_uiNextUnusedWindowNumber;
  plAtomicInteger32 m_iReferenceCount = 0;
};