AxioDL
/
boo
mirror of https://github.com/AxioDL/boo.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
boo/lib/win/WindowWin32.cpp

1382 lines
46 KiB
C++
Raw Blame History

#include "lib/win/Win32Common.hpp"
#include <Windowsx.h>
#include "boo/IApplication.hpp"
#include "boo/IGraphicsContext.hpp"
#include "boo/IWindow.hpp"
#include "boo/audiodev/IAudioVoiceEngine.hpp"
#include "boo/graphicsdev/IGraphicsCommandQueue.hpp"
#include "boo/graphicsdev/D3D.hpp"
#if BOO_HAS_GL
#include "boo/graphicsdev/GL.hpp"
#endif
#include "boo/graphicsdev/glew.h"
#include "boo/graphicsdev/wglew.h"
#if BOO_HAS_VULKAN
#include "boo/graphicsdev/Vulkan.hpp"
#endif
#if _WIN32_WINNT_WIN10
#include <dxgi1_5.h>
#endif
#include <logvisor/logvisor.hpp>
#include <nowide/stackstring.hpp>
static const int ContextAttribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 3,
WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
// WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
// WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
0, 0};
namespace boo {
static logvisor::Module Log("boo::WindowWin32");
std::unique_ptr<IGraphicsCommandQueue> _NewD3D11CommandQueue(D3D11Context* ctx, D3D11Context::Window* windowCtx,
IGraphicsContext* parent);
std::unique_ptr<IGraphicsDataFactory> _NewD3D11DataFactory(D3D11Context* ctx, IGraphicsContext* parent);
#if BOO_HAS_GL
std::unique_ptr<IGraphicsCommandQueue> _NewGLCommandQueue(IGraphicsContext* parent, GLContext* glCtx);
std::unique_ptr<IGraphicsDataFactory> _NewGLDataFactory(IGraphicsContext* parent, GLContext* glCtx);
#endif
#if BOO_HAS_VULKAN
std::unique_ptr<IGraphicsCommandQueue> _NewVulkanCommandQueue(VulkanContext* ctx, VulkanContext::Window* windowCtx,
IGraphicsContext* parent);
std::unique_ptr<IGraphicsDataFactory> _NewVulkanDataFactory(IGraphicsContext* parent, VulkanContext* ctx);
#endif
struct GraphicsContextWin32 : IGraphicsContext {
EGraphicsAPI m_api;
EPixelFormat m_pf;
IWindow* m_parentWindow;
Boo3DAppContextWin32& m_3dCtx;
ComPtr<IDXGIOutput> m_output;
GraphicsContextWin32(EGraphicsAPI api, IWindow* parentWindow, Boo3DAppContextWin32& b3dCtx)
: m_api(api), m_pf(EPixelFormat::RGBA8), m_parentWindow(parentWindow), m_3dCtx(b3dCtx) {}
virtual void resized(const SWindowRect& rect) { m_3dCtx.resize(m_parentWindow, rect.size[0], rect.size[1]); }
};
struct GraphicsContextWin32D3D : GraphicsContextWin32 {
ComPtr<IDXGISwapChain1> m_swapChain;
std::unique_ptr<IGraphicsDataFactory> m_dataFactory;
std::unique_ptr<IGraphicsCommandQueue> m_commandQueue;
public:
IWindowCallback* m_callback;
GraphicsContextWin32D3D(EGraphicsAPI api, IWindow* parentWindow, HWND hwnd, Boo3DAppContextWin32& b3dCtx)
: GraphicsContextWin32(api, parentWindow, b3dCtx) {
/* Create Swap Chain */
DXGI_SWAP_CHAIN_DESC1 scDesc = {};
scDesc.SampleDesc.Count = 1;
scDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scDesc.BufferCount = 2;
scDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
scDesc.Format = b3dCtx.m_ctx11.m_fbFormat;
if (FAILED(b3dCtx.m_ctx11.m_dxFactory->CreateSwapChainForHwnd(b3dCtx.m_ctx11.m_dev.Get(), hwnd, &scDesc, nullptr,
nullptr, &m_swapChain)))
Log.report(logvisor::Fatal, FMT_STRING("unable to create swap chain"));
b3dCtx.m_ctx11.m_dxFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER);
auto insIt = b3dCtx.m_ctx11.m_windows.emplace(std::make_pair(parentWindow, D3D11Context::Window()));
D3D11Context::Window& w = insIt.first->second;
w.setupRTV(m_swapChain, b3dCtx.m_ctx11.m_dev.Get());
m_dataFactory = _NewD3D11DataFactory(&b3dCtx.m_ctx11, this);
m_commandQueue = _NewD3D11CommandQueue(&b3dCtx.m_ctx11, &insIt.first->second, this);
m_commandQueue->startRenderer();
if (FAILED(m_swapChain->GetContainingOutput(&m_output)))
Log.report(logvisor::Fatal, FMT_STRING("unable to get DXGI output"));
}
~GraphicsContextWin32D3D() override { m_3dCtx.m_ctx11.m_windows.erase(m_parentWindow); }
void _setCallback(IWindowCallback* cb) override { m_callback = cb; }
EGraphicsAPI getAPI() const override { return m_api; }
EPixelFormat getPixelFormat() const override { return m_pf; }
void setPixelFormat(EPixelFormat pf) override {
if (pf > EPixelFormat::RGBAF32_Z24)
return;
m_pf = pf;
}
bool initializeContext(void*) override { return true; }
void makeCurrent() override {}
void postInit() override {}
void present() override {}
IGraphicsCommandQueue* getCommandQueue() override { return m_commandQueue.get(); }
IGraphicsDataFactory* getDataFactory() override { return m_dataFactory.get(); }
IGraphicsDataFactory* getMainContextDataFactory() override { return m_dataFactory.get(); }
IGraphicsDataFactory* getLoadContextDataFactory() override { return m_dataFactory.get(); }
};
#if BOO_HAS_GL
struct GraphicsContextWin32GL : GraphicsContextWin32 {
std::unique_ptr<IGraphicsDataFactory> m_dataFactory;
std::unique_ptr<IGraphicsCommandQueue> m_commandQueue;
public:
IWindowCallback* m_callback;
GraphicsContextWin32GL(EGraphicsAPI api, IWindow* parentWindow, HWND hwnd, Boo3DAppContextWin32& b3dCtx)
: GraphicsContextWin32(api, parentWindow, b3dCtx) {
HMONITOR testMon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY);
ComPtr<IDXGIAdapter1> adapter;
ComPtr<IDXGIOutput> foundOut;
int i = 0;
while (b3dCtx.m_ctxOgl.m_dxFactory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND) {
int j = 0;
ComPtr<IDXGIOutput> out;
while (adapter->EnumOutputs(j, &out) != DXGI_ERROR_NOT_FOUND) {
DXGI_OUTPUT_DESC desc;
out->GetDesc(&desc);
if (desc.Monitor == testMon) {
out.As<IDXGIOutput>(&m_output);
break;
}
++j;
}
if (m_output)
break;
++i;
}
if (!m_output)
Log.report(logvisor::Fatal, FMT_STRING("unable to find window's IDXGIOutput"));
auto insIt = b3dCtx.m_ctxOgl.m_windows.emplace(std::make_pair(parentWindow, OGLContext::Window()));
OGLContext::Window& w = insIt.first->second;
w.m_hwnd = hwnd;
w.m_deviceContext = GetDC(hwnd);
if (!w.m_deviceContext)
Log.report(logvisor::Fatal, FMT_STRING("unable to create window's device context"));
if (!m_3dCtx.m_ctxOgl.m_lastContext) {
PIXELFORMATDESCRIPTOR pfd = {sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, // Flags
PFD_TYPE_RGBA, // The kind of framebuffer. RGBA or palette.
32, // Colordepth of the framebuffer.
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
24, // Number of bits for the depthbuffer
8, // Number of bits for the stencilbuffer
0, // Number of Aux buffers in the framebuffer.
PFD_MAIN_PLANE,
0,
0,
0,
0};
int pf = ChoosePixelFormat(w.m_deviceContext, &pfd);
SetPixelFormat(w.m_deviceContext, pf, &pfd);
#if 1
HGLRC tmpCtx = wglCreateContext(w.m_deviceContext);
wglMakeCurrent(w.m_deviceContext, tmpCtx);
if (glewInit() != GLEW_OK)
Log.report(logvisor::Fatal, FMT_STRING("glewInit failed"));
wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB");
wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");
wglMakeCurrent(w.m_deviceContext, nullptr);
wglDeleteContext(tmpCtx);
if (b3dCtx.m_ctxOgl.m_glCtx.m_deepColor) {
const int attribs1[] = {
WGL_SUPPORT_OPENGL_ARB,
TRUE,
WGL_DRAW_TO_WINDOW_ARB,
TRUE,
WGL_PIXEL_TYPE_ARB,
WGL_TYPE_RGBA_ARB,
WGL_RED_BITS_ARB,
10,
WGL_GREEN_BITS_ARB,
10,
WGL_BLUE_BITS_ARB,
10,
WGL_ALPHA_BITS_ARB,
2,
WGL_DOUBLE_BUFFER_ARB,
TRUE,
0, // zero terminates the list
};
float fattribs[] = {
0.0f, // zero terminates the list
};
int pixelFormat;
UINT numFormats;
wglChoosePixelFormatARB(w.m_deviceContext, attribs1, fattribs, 1, &pixelFormat, &numFormats);
if (numFormats)
SetPixelFormat(w.m_deviceContext, pixelFormat, nullptr);
}
#endif
}
// w.m_mainContext = wglCreateContext(w.m_deviceContext);
w.m_mainContext = wglCreateContextAttribsARB(w.m_deviceContext, 0, ContextAttribs);
if (!w.m_mainContext)
Log.report(logvisor::Fatal, FMT_STRING("unable to create window's main context"));
if (m_3dCtx.m_ctxOgl.m_lastContext)
if (!wglShareLists(w.m_mainContext, m_3dCtx.m_ctxOgl.m_lastContext))
Log.report(logvisor::Fatal, FMT_STRING("unable to share contexts"));
m_3dCtx.m_ctxOgl.m_lastContext = w.m_mainContext;
m_dataFactory = _NewGLDataFactory(this, &b3dCtx.m_ctxOgl.m_glCtx);
m_commandQueue = _NewGLCommandQueue(this, &b3dCtx.m_ctxOgl.m_glCtx);
m_commandQueue->startRenderer();
}
~GraphicsContextWin32GL() override { m_3dCtx.m_ctxOgl.m_windows.erase(m_parentWindow); }
void _setCallback(IWindowCallback* cb) override { m_callback = cb; }
EGraphicsAPI getAPI() const override { return m_api; }
EPixelFormat getPixelFormat() const override { return m_pf; }
void setPixelFormat(EPixelFormat pf) override {
if (pf > EPixelFormat::RGBAF32_Z24)
return;
m_pf = pf;
}
bool initializeContext(void*) override { return true; }
void makeCurrent() override {
OGLContext::Window& w = m_3dCtx.m_ctxOgl.m_windows[m_parentWindow];
// if (!wglMakeCurrent(w.m_deviceContext, w.m_mainContext))
// Log.report(logvisor::Fatal, FMT_STRING("unable to make WGL context current"));
w.m_renderContext = wglCreateContextAttribsARB(w.m_deviceContext, w.m_mainContext, ContextAttribs);
if (!w.m_renderContext)
Log.report(logvisor::Fatal, FMT_STRING("unable to make new WGL context"));
if (!wglMakeCurrent(w.m_deviceContext, w.m_renderContext))
Log.report(logvisor::Fatal, FMT_STRING("unable to make WGL context current"));
}
void postInit() override {
// OGLContext::Window& w = m_3dCtx.m_ctxOgl.m_windows[m_parentWindow];
// wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)
// wglGetProcAddress("wglCreateContextAttribsARB");
// w.m_renderContext = wglCreateContextAttribsARB(w.m_deviceContext, w.m_mainContext, ContextAttribs);
// if (!w.m_renderContext)
// Log.report(logvisor::Fatal, FMT_STRING("unable to make new WGL context"));
// if (!wglMakeCurrent(w.m_deviceContext, w.m_renderContext))
// Log.report(logvisor::Fatal, FMT_STRING("unable to make WGL context current"));
if (!WGLEW_EXT_swap_control)
Log.report(logvisor::Fatal, FMT_STRING("WGL_EXT_swap_control not available"));
wglSwapIntervalEXT(1);
}
void present() override {
OGLContext::Window& w = m_3dCtx.m_ctxOgl.m_windows[m_parentWindow];
SwapBuffers(w.m_deviceContext);
}
IGraphicsCommandQueue* getCommandQueue() override { return m_commandQueue.get(); }
IGraphicsDataFactory* getDataFactory() override { return m_dataFactory.get(); }
/* Creates a new context on current thread!! Call from client loading thread */
HGLRC m_mainCtx = nullptr;
IGraphicsDataFactory* getMainContextDataFactory() override {
OGLContext::Window& w = m_3dCtx.m_ctxOgl.m_windows[m_parentWindow];
if (!m_mainCtx) {
m_mainCtx = wglCreateContextAttribsARB(w.m_deviceContext, w.m_mainContext, ContextAttribs);
if (!m_mainCtx)
Log.report(logvisor::Fatal, FMT_STRING("unable to make main WGL context"));
}
if (!wglMakeCurrent(w.m_deviceContext, m_mainCtx))
Log.report(logvisor::Fatal, FMT_STRING("unable to make main WGL context current"));
return m_dataFactory.get();
}
/* Creates a new context on current thread!! Call from client loading thread */
HGLRC m_loadCtx = nullptr;
IGraphicsDataFactory* getLoadContextDataFactory() override {
OGLContext::Window& w = m_3dCtx.m_ctxOgl.m_windows[m_parentWindow];
if (!m_loadCtx) {
m_loadCtx = wglCreateContextAttribsARB(w.m_deviceContext, w.m_mainContext, ContextAttribs);
if (!m_loadCtx)
Log.report(logvisor::Fatal, FMT_STRING("unable to make load WGL context"));
}
if (!wglMakeCurrent(w.m_deviceContext, m_loadCtx))
Log.report(logvisor::Fatal, FMT_STRING("unable to make load WGL context current"));
return m_dataFactory.get();
}
};
#endif
#if BOO_HAS_VULKAN
struct GraphicsContextWin32Vulkan : GraphicsContextWin32 {
HINSTANCE m_appInstance;
HWND m_hwnd;
VulkanContext* m_ctx;
VkSurfaceKHR m_surface = VK_NULL_HANDLE;
VkFormat m_format = VK_FORMAT_UNDEFINED;
VkColorSpaceKHR m_colorspace;
std::unique_ptr<IGraphicsDataFactory> m_dataFactory;
std::unique_ptr<IGraphicsCommandQueue> m_commandQueue;
std::thread m_vsyncThread;
bool m_vsyncRunning;
static void ThrowIfFailed(VkResult res) {
if (res == VK_SUCCESS) {
return;
}
Log.report(logvisor::Fatal, FMT_STRING("{}\n"), res);
}
public:
IWindowCallback* m_callback;
GraphicsContextWin32Vulkan(IWindow* parentWindow, HINSTANCE appInstance, HWND hwnd, VulkanContext* ctx,
Boo3DAppContextWin32& b3dCtx)
: GraphicsContextWin32(EGraphicsAPI::Vulkan, parentWindow, b3dCtx)
, m_appInstance(appInstance)
, m_hwnd(hwnd)
, m_ctx(ctx) {
HMONITOR testMon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY);
ComPtr<IDXGIAdapter1> adapter;
ComPtr<IDXGIOutput> foundOut;
int i = 0;
while (b3dCtx.m_vulkanDxFactory->EnumAdapters1(i, &adapter) != DXGI_ERROR_NOT_FOUND) {
int j = 0;
ComPtr<IDXGIOutput> out;
while (adapter->EnumOutputs(j, &out) != DXGI_ERROR_NOT_FOUND) {
DXGI_OUTPUT_DESC desc;
out->GetDesc(&desc);
if (desc.Monitor == testMon) {
out.As<IDXGIOutput>(&m_output);
break;
}
++j;
}
if (m_output)
break;
++i;
}
if (!m_output)
Log.report(logvisor::Fatal, FMT_STRING("unable to find window's IDXGIOutput"));
}
void destroy() {
VulkanContext::Window& m_windowCtx = *m_ctx->m_windows[m_parentWindow];
m_windowCtx.m_swapChains[0].destroy(m_ctx->m_dev);
m_windowCtx.m_swapChains[1].destroy(m_ctx->m_dev);
// vk::DestroySurfaceKHR(m_ctx->m_instance, m_surface, nullptr);
if (m_vsyncRunning) {
m_vsyncRunning = false;
if (m_vsyncThread.joinable())
m_vsyncThread.join();
}
m_ctx->m_windows.erase(m_parentWindow);
}
~GraphicsContextWin32Vulkan() override { destroy(); }
VulkanContext::Window* m_windowCtx = nullptr;
void resized(const SWindowRect& rect) override {
if (m_windowCtx)
m_ctx->resizeSwapChain(*m_windowCtx, m_surface, m_format, m_colorspace, rect);
}
void _setCallback(IWindowCallback* cb) override { m_callback = cb; }
EGraphicsAPI getAPI() const override { return m_api; }
EPixelFormat getPixelFormat() const override { return m_pf; }
void setPixelFormat(EPixelFormat pf) override {
if (pf > EPixelFormat::RGBAF32_Z24)
return;
m_pf = pf;
}
bool initializeContext(void*) override {
m_windowCtx = m_ctx->m_windows.emplace(std::make_pair(m_parentWindow, std::make_unique<VulkanContext::Window>()))
.first->second.get();
m_windowCtx->m_hwnd = m_hwnd;
VkWin32SurfaceCreateInfoKHR surfaceInfo = {};
surfaceInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
surfaceInfo.hinstance = m_appInstance;
surfaceInfo.hwnd = m_hwnd;
ThrowIfFailed(vk::CreateWin32SurfaceKHR(m_ctx->m_instance, &surfaceInfo, nullptr, &m_surface));
/* Iterate over each queue to learn whether it supports presenting */
VkBool32* supportsPresent = (VkBool32*)malloc(m_ctx->m_queueCount * sizeof(VkBool32));
for (uint32_t i = 0; i < m_ctx->m_queueCount; ++i)
vk::GetPhysicalDeviceSurfaceSupportKHR(m_ctx->m_gpus[0], i, m_surface, &supportsPresent[i]);
/* Search for a graphics queue and a present queue in the array of queue
* families, try to find one that supports both */
if (m_ctx->m_graphicsQueueFamilyIndex == UINT32_MAX) {
/* First window, init device */
for (uint32_t i = 0; i < m_ctx->m_queueCount; ++i) {
if ((m_ctx->m_queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
if (supportsPresent[i] == VK_TRUE) {
m_ctx->m_graphicsQueueFamilyIndex = i;
}
}
}
/* Generate error if could not find a queue that supports both a graphics
* and present */
if (m_ctx->m_graphicsQueueFamilyIndex == UINT32_MAX)
Log.report(logvisor::Fatal, FMT_STRING("Could not find a queue that supports both graphics and present"));
m_ctx->initDevice();
} else {
/* Subsequent window, verify present */
if (supportsPresent[m_ctx->m_graphicsQueueFamilyIndex] == VK_FALSE)
Log.report(logvisor::Fatal, FMT_STRING("subsequent surface doesn't support present"));
}
free(supportsPresent);
if (!vk::GetPhysicalDeviceWin32PresentationSupportKHR(m_ctx->m_gpus[0], m_ctx->m_graphicsQueueFamilyIndex)) {
Log.report(logvisor::Fatal, FMT_STRING("Win32 doesn't support vulkan present"));
return false;
}
/* Get the list of VkFormats that are supported */
uint32_t formatCount;
ThrowIfFailed(vk::GetPhysicalDeviceSurfaceFormatsKHR(m_ctx->m_gpus[0], m_surface, &formatCount, nullptr));
VkSurfaceFormatKHR* surfFormats = (VkSurfaceFormatKHR*)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
ThrowIfFailed(vk::GetPhysicalDeviceSurfaceFormatsKHR(m_ctx->m_gpus[0], m_surface, &formatCount, surfFormats));
/* If the format list includes just one entry of VK_FORMAT_UNDEFINED,
* the surface has no preferred format. Otherwise, at least one
* supported format will be returned. */
if (formatCount >= 1) {
if (m_ctx->m_deepColor) {
for (int i = 0; i < formatCount; ++i) {
if (surfFormats[i].format == VK_FORMAT_R16G16B16A16_UNORM) {
m_format = surfFormats[i].format;
m_colorspace = surfFormats[i].colorSpace;
break;
}
}
}
if (m_format == VK_FORMAT_UNDEFINED) {
for (int i = 0; i < formatCount; ++i) {
if (surfFormats[i].format == VK_FORMAT_B8G8R8A8_UNORM || surfFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM) {
m_format = surfFormats[i].format;
m_colorspace = surfFormats[i].colorSpace;
break;
}
}
}
} else
Log.report(logvisor::Fatal, FMT_STRING("no surface formats available for Vulkan swapchain"));
if (m_format == VK_FORMAT_UNDEFINED)
Log.report(logvisor::Fatal, FMT_STRING("no UNORM formats available for Vulkan swapchain"));
m_ctx->initSwapChain(*m_windowCtx, m_surface, m_format, m_colorspace);
m_dataFactory = _NewVulkanDataFactory(this, m_ctx);
m_commandQueue = _NewVulkanCommandQueue(m_ctx, m_ctx->m_windows[m_parentWindow].get(), this);
m_commandQueue->startRenderer();
return true;
}
void makeCurrent() override {}
void postInit() override {}
IGraphicsCommandQueue* getCommandQueue() override { return m_commandQueue.get(); }
IGraphicsDataFactory* getDataFactory() override { return m_dataFactory.get(); }
IGraphicsDataFactory* getMainContextDataFactory() override { return getDataFactory(); }
IGraphicsDataFactory* getLoadContextDataFactory() override { return getDataFactory(); }
void present() override {}
};
#endif
static void genFrameDefault(MONITORINFO* screen, int& xOut, int& yOut, int& wOut, int& hOut) {
float width = screen->rcMonitor.right * 2.0 / 3.0;
float height = screen->rcMonitor.bottom * 2.0 / 3.0;
xOut = (screen->rcMonitor.right - width) / 2.0;
yOut = (screen->rcMonitor.bottom - height) / 2.0;
wOut = width;
hOut = height;
}
static uint32_t translateKeysym(WPARAM sym, UINT scancode, ESpecialKey& specialSym, EModifierKey& modifierSym) {
specialSym = ESpecialKey::None;
modifierSym = EModifierKey::None;
if (sym >= VK_F1 && sym <= VK_F12)
specialSym = ESpecialKey(uint32_t(ESpecialKey::F1) + sym - VK_F1);
else if (sym == VK_ESCAPE)
specialSym = ESpecialKey::Esc;
else if (sym == VK_RETURN)
specialSym = ESpecialKey::Enter;
else if (sym == VK_BACK)
specialSym = ESpecialKey::Backspace;
else if (sym == VK_INSERT)
specialSym = ESpecialKey::Insert;
else if (sym == VK_DELETE)
specialSym = ESpecialKey::Delete;
else if (sym == VK_HOME)
specialSym = ESpecialKey::Home;
else if (sym == VK_END)
specialSym = ESpecialKey::End;
else if (sym == VK_PRIOR)
specialSym = ESpecialKey::PgUp;
else if (sym == VK_NEXT)
specialSym = ESpecialKey::PgDown;
else if (sym == VK_LEFT)
specialSym = ESpecialKey::Left;
else if (sym == VK_RIGHT)
specialSym = ESpecialKey::Right;
else if (sym == VK_UP)
specialSym = ESpecialKey::Up;
else if (sym == VK_DOWN)
specialSym = ESpecialKey::Down;
else if (sym == VK_TAB)
specialSym = ESpecialKey::Tab;
else if (sym == VK_SHIFT)
modifierSym = EModifierKey::Shift;
else if (sym == VK_CONTROL)
modifierSym = EModifierKey::Ctrl;
else if (sym == VK_MENU)
modifierSym = EModifierKey::Alt;
else {
BYTE kbState[256];
GetKeyboardState(kbState);
kbState[VK_CONTROL] = 0;
WORD ch = 0;
ToAscii(sym, scancode, kbState, &ch, 0);
return ch;
}
return 0;
}
static EModifierKey translateModifiers(UINT msg) {
EModifierKey retval = EModifierKey::None;
if ((GetKeyState(VK_SHIFT) & 0x8000) != 0)
retval |= EModifierKey::Shift;
if ((GetKeyState(VK_CONTROL) & 0x8000) != 0)
retval |= EModifierKey::Ctrl;
if ((GetKeyState(VK_MENU) & 0x8000) != 0)
retval |= EModifierKey::Alt;
if (msg == WM_SYSKEYDOWN || msg == WM_SYSKEYUP)
retval |= EModifierKey::Alt;
return retval;
}
static HGLOBAL MakeANSICRLF(const char* data, size_t sz) {
size_t retSz = 1;
char lastCh = 0;
for (size_t i = 0; i < sz; ++i) {
char ch = data[i];
if (ch == '\n' && lastCh != '\r')
retSz += 2;
else
retSz += 1;
lastCh = ch;
}
HGLOBAL ret = GlobalAlloc(GMEM_MOVEABLE, retSz);
char* retData = reinterpret_cast<char*>(GlobalLock(ret));
lastCh = 0;
for (size_t i = 0; i < sz; ++i) {
char ch = data[i];
if (ch == '\n' && lastCh != '\r') {
*retData = '\r';
++retData;
*retData = '\n';
++retData;
} else {
*retData = ch;
++retData;
}
lastCh = ch;
}
*retData = '\0';
GlobalUnlock(ret);
return ret;
}
static std::unique_ptr<uint8_t[]> MakeANSILF(const char* data, size_t sz, size_t& szOut) {
szOut = 0;
char lastCh = 0;
for (size_t i = 0; i < sz; ++i) {
char ch = data[i];
if (ch == '\n' && lastCh == '\r') {
} else
szOut += 1;
lastCh = ch;
}
std::unique_ptr<uint8_t[]> ret(new uint8_t[szOut]);
uint8_t* retPtr = ret.get();
lastCh = 0;
for (size_t i = 0; i < sz; ++i) {
char ch = data[i];
if (ch == '\n' && lastCh == '\r')
retPtr[-1] = uint8_t('\n');
else {
*retPtr = uint8_t(ch);
++retPtr;
}
lastCh = ch;
}
return ret;
}
/** Memory could not be allocated. */
#define UTF8PROC_ERROR_NOMEM -1
/** The given string is too long to be processed. */
#define UTF8PROC_ERROR_OVERFLOW -2
/** The given string is not a legal UTF-8 string. */
#define UTF8PROC_ERROR_INVALIDUTF8 -3
/** The @ref UTF8PROC_REJECTNA flag was set and an unassigned codepoint was found. */
#define UTF8PROC_ERROR_NOTASSIGNED -4
/** Invalid options have been used. */
#define UTF8PROC_ERROR_INVALIDOPTS -5
#define UTF8PROC_cont(ch) (((ch)&0xc0) == 0x80)
static inline int utf8proc_iterate(const uint8_t* str, int strlen, int32_t* dst) {
uint32_t uc;
const uint8_t* end;
*dst = -1;
if (!strlen)
return 0;
end = str + ((strlen < 0) ? 4 : strlen);
uc = *str++;
if (uc < 0x80) {
*dst = uc;
return 1;
}
// Must be between 0xc2 and 0xf4 inclusive to be valid
if ((uc - 0xc2) > (0xf4 - 0xc2))
return UTF8PROC_ERROR_INVALIDUTF8;
if (uc < 0xe0) { // 2-byte sequence
// Must have valid continuation character
if (!UTF8PROC_cont(*str))
return UTF8PROC_ERROR_INVALIDUTF8;
*dst = ((uc & 0x1f) << 6) | (*str & 0x3f);
return 2;
}
if (uc < 0xf0) { // 3-byte sequence
if ((str + 1 >= end) || !UTF8PROC_cont(*str) || !UTF8PROC_cont(str[1]))
return UTF8PROC_ERROR_INVALIDUTF8;
// Check for surrogate chars
if (uc == 0xed && *str > 0x9f)
return UTF8PROC_ERROR_INVALIDUTF8;
uc = ((uc & 0xf) << 12) | ((*str & 0x3f) << 6) | (str[1] & 0x3f);
if (uc < 0x800)
return UTF8PROC_ERROR_INVALIDUTF8;
*dst = uc;
return 3;
}
// 4-byte sequence
// Must have 3 valid continuation characters
if ((str + 2 >= end) || !UTF8PROC_cont(*str) || !UTF8PROC_cont(str[1]) || !UTF8PROC_cont(str[2]))
return UTF8PROC_ERROR_INVALIDUTF8;
// Make sure in correct range (0x10000 - 0x10ffff)
if (uc == 0xf0) {
if (*str < 0x90)
return UTF8PROC_ERROR_INVALIDUTF8;
} else if (uc == 0xf4) {
if (*str > 0x8f)
return UTF8PROC_ERROR_INVALIDUTF8;
}
*dst = ((uc & 7) << 18) | ((*str & 0x3f) << 12) | ((str[1] & 0x3f) << 6) | (str[2] & 0x3f);
return 4;
}
static HGLOBAL MakeUnicodeCRLF(const char* data, size_t sz) {
size_t retSz = 2;
int32_t lastCh = 0;
for (size_t i = 0; i < sz;) {
int32_t ch;
int chSz = utf8proc_iterate(reinterpret_cast<const uint8_t*>(data + i), -1, &ch);
if (chSz < 0)
Log.report(logvisor::Fatal, FMT_STRING("invalid UTF-8 char"));
if (ch <= 0xffff) {
if (ch == '\n' && lastCh != '\r')
retSz += 4;
else
retSz += 2;
lastCh = ch;
}
i += chSz;
}
HGLOBAL ret = GlobalAlloc(GMEM_MOVEABLE, retSz);
wchar_t* retData = reinterpret_cast<wchar_t*>(GlobalLock(ret));
lastCh = 0;
for (size_t i = 0; i < sz;) {
int32_t ch;
int chSz = utf8proc_iterate(reinterpret_cast<const uint8_t*>(data + i), -1, &ch);
if (ch <= 0xffff) {
if (ch == '\n' && lastCh != '\r') {
*retData = L'\r';
++retData;
*retData = L'\n';
++retData;
} else {
*retData = wchar_t(ch);
++retData;
}
lastCh = ch;
}
i += chSz;
}
*retData = L'\0';
GlobalUnlock(ret);
return ret;
}
static inline int utf8proc_encode_char(int32_t uc, uint8_t* dst) {
if (uc < 0x00) {
return 0;
} else if (uc < 0x80) {
dst[0] = uc;
return 1;
} else if (uc < 0x800) {
dst[0] = 0xC0 + (uc >> 6);
dst[1] = 0x80 + (uc & 0x3F);
return 2;
// Note: we allow encoding 0xd800-0xdfff here, so as not to change
// the API, however, these are actually invalid in UTF-8
} else if (uc < 0x10000) {
dst[0] = 0xE0 + (uc >> 12);
dst[1] = 0x80 + ((uc >> 6) & 0x3F);
dst[2] = 0x80 + (uc & 0x3F);
return 3;
} else if (uc < 0x110000) {
dst[0] = 0xF0 + (uc >> 18);
dst[1] = 0x80 + ((uc >> 12) & 0x3F);
dst[2] = 0x80 + ((uc >> 6) & 0x3F);
dst[3] = 0x80 + (uc & 0x3F);
return 4;
} else
return 0;
}
static std::unique_ptr<uint8_t[]> MakeUnicodeLF(const wchar_t* data, size_t sz, size_t& szOut) {
szOut = 0;
wchar_t lastCh = 0;
for (size_t i = 0; i < sz; ++i) {
wchar_t ch = data[i];
if (ch == L'\n' && lastCh == L'\r') {
} else {
uint8_t dummy[4];
szOut += utf8proc_encode_char(ch, dummy);
}
lastCh = ch;
}
std::unique_ptr<uint8_t[]> ret(new uint8_t[szOut]);
uint8_t* retPtr = ret.get();
lastCh = 0;
for (size_t i = 0; i < sz; ++i) {
wchar_t ch = data[i];
if (ch == L'\n' && lastCh == L'\r')
retPtr[-1] = uint8_t('\n');
else
retPtr += utf8proc_encode_char(ch, retPtr);
lastCh = ch;
}
return ret;
}
class WindowWin32 : public IWindow {
friend struct GraphicsContextWin32;
HWND m_hwnd;
HIMC m_imc;
std::unique_ptr<GraphicsContextWin32> m_gfxCtx;
IWindowCallback* m_callback = nullptr;
EMouseCursor m_cursor = EMouseCursor::None;
bool m_cursorWait = false;
bool m_openGL = false;
static HCURSOR GetWin32Cursor(EMouseCursor cur) {
switch (cur) {
case EMouseCursor::Pointer:
return WIN32_CURSORS.m_arrow;
case EMouseCursor::HorizontalArrow:
return WIN32_CURSORS.m_weResize;
case EMouseCursor::VerticalArrow:
return WIN32_CURSORS.m_nsResize;
case EMouseCursor::IBeam:
return WIN32_CURSORS.m_ibeam;
case EMouseCursor::Crosshairs:
return WIN32_CURSORS.m_crosshairs;
case EMouseCursor::BottomRightArrow:
return WIN32_CURSORS.m_nwseResize;
case EMouseCursor::BottomLeftArrow:
return WIN32_CURSORS.m_neswResize;
case EMouseCursor::Hand:
return WIN32_CURSORS.m_hand;
case EMouseCursor::NotAllowed:
return WIN32_CURSORS.m_notAllowed;
default:
break;
}
return WIN32_CURSORS.m_arrow;
}
public:
WindowWin32(std::string_view title, Boo3DAppContextWin32& b3dCtx) {
const POINT ptZero = {0, 0};
HMONITOR monitor = MonitorFromPoint(ptZero, MONITOR_DEFAULTTOPRIMARY);
MONITORINFO monInfo = {};
monInfo.cbSize = sizeof(MONITORINFO);
GetMonitorInfo(monitor, &monInfo);
int x, y, w, h;
genFrameDefault(&monInfo, x, y, w, h);
RECT r = {x, y, x + w, y + h};
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
const nowide::wstackstring wtitle(title);
m_hwnd = CreateWindowW(L"BooWindow", wtitle.get(), WS_OVERLAPPEDWINDOW, r.left, r.top, r.right - r.left,
r.bottom - r.top, nullptr, nullptr, nullptr, nullptr);
m_imc = ImmGetContext(m_hwnd);
#if BOO_HAS_VULKAN
HINSTANCE wndInstance = HINSTANCE(GetWindowLongPtr(m_hwnd, GWLP_HINSTANCE));
if (b3dCtx.m_vulkanDxFactory) {
m_gfxCtx.reset(new GraphicsContextWin32Vulkan(this, wndInstance, m_hwnd, &g_VulkanContext, b3dCtx));
if (m_gfxCtx->initializeContext(nullptr))
return;
}
#endif
IGraphicsContext::EGraphicsAPI api = IGraphicsContext::EGraphicsAPI::D3D11;
#if BOO_HAS_GL
if (b3dCtx.m_ctxOgl.m_dxFactory) {
m_gfxCtx = std::make_unique<GraphicsContextWin32GL>(IGraphicsContext::EGraphicsAPI::OpenGL3_3, this, m_hwnd, b3dCtx);
m_openGL = true;
return;
}
#endif
m_gfxCtx = std::make_unique<GraphicsContextWin32D3D>(api, this, m_hwnd, b3dCtx);
}
void _cleanup() override { m_gfxCtx.reset(); }
void setCallback(IWindowCallback* cb) override { m_callback = cb; }
void closeWindow() override {
// TODO: Perform thread-coalesced deallocation
ShowWindow(m_hwnd, SW_HIDE);
}
void showWindow() override { ShowWindow(m_hwnd, SW_SHOW); }
void hideWindow() override { ShowWindow(m_hwnd, SW_HIDE); }
std::string getTitle() override {
wchar_t title[256];
int c = GetWindowTextW(m_hwnd, title, 256);
return nowide::narrow(title, c);
}
void setTitle(std::string_view title) override {
const nowide::wstackstring wtitle(title);
SetWindowTextW(m_hwnd, wtitle.get());
}
static void _setCursor(HCURSOR cur) { PostThreadMessageW(g_mainThreadId, WM_USER + 2, WPARAM(cur), 0); }
void setCursor(EMouseCursor cursor) override {
if (cursor == m_cursor && !m_cursorWait)
return;
m_cursor = cursor;
_setCursor(GetWin32Cursor(cursor));
}
void setWaitCursor(bool wait) override {
if (wait && !m_cursorWait) {
_setCursor(WIN32_CURSORS.m_wait);
m_cursorWait = true;
} else if (!wait && m_cursorWait) {
setCursor(m_cursor);
m_cursorWait = false;
}
}
double getWindowRefreshRate() const override {
/* TODO: Actually get refresh rate */
return 60.0;
}
void setWindowFrameDefault() override {
MONITORINFO monInfo = {};
monInfo.cbSize = sizeof(MONITORINFO);
HMONITOR mon = MonitorFromWindow(m_hwnd, MONITOR_DEFAULTTOPRIMARY);
GetMonitorInfo(mon, &monInfo);
int x, y, w, h;
genFrameDefault(&monInfo, x, y, w, h);
setWindowFrame(x, y, w, h);
}
void getWindowFrame(float& xOut, float& yOut, float& wOut, float& hOut) const override {
RECT rct;
GetClientRect(m_hwnd, &rct);
POINT pt;
pt.x = rct.left;
pt.y = rct.top;
MapWindowPoints(m_hwnd, HWND_DESKTOP, &pt, 1);
xOut = pt.x;
yOut = pt.y;
wOut = rct.right;
hOut = rct.bottom;
}
void getWindowFrame(int& xOut, int& yOut, int& wOut, int& hOut) const override {
RECT rct;
GetClientRect(m_hwnd, &rct);
POINT pt;
pt.x = rct.left;
pt.y = rct.top;
MapWindowPoints(m_hwnd, HWND_DESKTOP, &pt, 1);
xOut = pt.x;
yOut = pt.y;
wOut = rct.right;
hOut = rct.bottom;
}
void setWindowFrame(float x, float y, float w, float h) override { setWindowFrame(int(x), int(y), int(w), int(h)); }
void setWindowFrame(int x, int y, int w, int h) override {
RECT r = {x, y, x + w, y + h};
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
MoveWindow(m_hwnd, r.left, r.top, r.right - r.left, r.bottom - r.top, true);
}
float getVirtualPixelFactor() const override {
#if _WIN32_WINNT_WINBLUE
if (MyGetScaleFactorForMonitor != nullptr) {
DEVICE_SCALE_FACTOR Factor = DEVICE_SCALE_FACTOR_INVALID;
HMONITOR mon = MonitorFromWindow(m_hwnd, MONITOR_DEFAULTTOPRIMARY);
MyGetScaleFactorForMonitor(mon, &Factor);
if (Factor == 0) {
return 1.f;
}
return static_cast<float>(Factor) / 100.f;
}
#endif
return 1.f;
}
bool isFullscreen() const override { return m_gfxCtx->m_3dCtx.isFullscreen(this); }
void setFullscreen(bool fs) override { m_gfxCtx->m_3dCtx.setFullscreen(this, fs); }
void _immSetOpenStatus(bool open) {
if (GetCurrentThreadId() != g_mainThreadId) {
if (!PostThreadMessageW(g_mainThreadId, WM_USER + 3, WPARAM(m_imc), LPARAM(open)))
Log.report(logvisor::Fatal, FMT_STRING("PostThreadMessage error"));
return;
}
ImmSetOpenStatus(m_imc, open);
}
COMPOSITIONFORM m_cForm = {CFS_POINT};
void _immSetCompositionWindow(const int coord[2]) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
m_cForm.ptCurrentPos.x = coord[0];
m_cForm.ptCurrentPos.y = h - coord[1];
if (GetCurrentThreadId() != g_mainThreadId) {
if (!PostThreadMessageW(g_mainThreadId, WM_USER + 4, WPARAM(m_imc), LPARAM(&m_cForm)))
Log.report(logvisor::Fatal, FMT_STRING("PostThreadMessage error"));
return;
}
ImmSetCompositionWindow(m_imc, &m_cForm);
}
void claimKeyboardFocus(const int coord[2]) override {
if (!coord) {
//_immSetOpenStatus(false);
return;
}
_immSetCompositionWindow(coord);
//_immSetOpenStatus(true);
}
bool clipboardCopy(EClipboardType type, const uint8_t* data, size_t sz) override {
switch (type) {
case EClipboardType::String: {
HGLOBAL gStr = MakeANSICRLF(reinterpret_cast<const char*>(data), sz);
OpenClipboard(m_hwnd);
EmptyClipboard();
SetClipboardData(CF_TEXT, gStr);
CloseClipboard();
return true;
}
case EClipboardType::UTF8String: {
HGLOBAL gStr = MakeUnicodeCRLF(reinterpret_cast<const char*>(data), sz);
OpenClipboard(m_hwnd);
EmptyClipboard();
SetClipboardData(CF_UNICODETEXT, gStr);
CloseClipboard();
return true;
}
default:
break;
}
return false;
}
std::unique_ptr<uint8_t[]> clipboardPaste(EClipboardType type, size_t& sz) override {
switch (type) {
case EClipboardType::String: {
OpenClipboard(m_hwnd);
HGLOBAL gStr = GetClipboardData(CF_TEXT);
if (!gStr)
break;
const char* str = reinterpret_cast<const char*>(GlobalLock(gStr));
std::unique_ptr<uint8_t[]> ret = MakeANSILF(str, GlobalSize(gStr), sz);
GlobalUnlock(gStr);
CloseClipboard();
return ret;
}
case EClipboardType::UTF8String: {
OpenClipboard(m_hwnd);
HGLOBAL gStr = GetClipboardData(CF_UNICODETEXT);
if (!gStr)
break;
const wchar_t* str = reinterpret_cast<const wchar_t*>(GlobalLock(gStr));
std::unique_ptr<uint8_t[]> ret = MakeUnicodeLF(str, GlobalSize(gStr) / 2, sz);
GlobalUnlock(gStr);
CloseClipboard();
return ret;
}
default:
break;
}
return std::unique_ptr<uint8_t[]>();
}
int waitForRetrace() override {
m_gfxCtx->m_output->WaitForVBlank();
return 1;
}
uintptr_t getPlatformHandle() const override { return uintptr_t(m_hwnd); }
void buttonDown(HWNDEvent& e, EMouseButton button) {
if (m_callback) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
EModifierKey modifierMask = translateModifiers(e.uMsg);
SWindowCoord coord = {{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{float(GET_X_LPARAM(e.lParam)) / float(w), float(h - GET_Y_LPARAM(e.lParam)) / float(h)}};
m_callback->mouseDown(coord, button, modifierMask);
}
}
void buttonUp(HWNDEvent& e, EMouseButton button) {
if (m_callback) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
EModifierKey modifierMask = translateModifiers(e.uMsg);
SWindowCoord coord = {{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{float(GET_X_LPARAM(e.lParam)) / float(w), float(h - GET_Y_LPARAM(e.lParam)) / float(h)}};
m_callback->mouseUp(coord, button, modifierMask);
}
}
void _trackMouse() {
TRACKMOUSEEVENT tme;
tme.cbSize = sizeof(TRACKMOUSEEVENT);
tme.dwFlags = TME_NONCLIENT | TME_HOVER | TME_LEAVE;
tme.dwHoverTime = 500;
tme.hwndTrack = m_hwnd;
}
bool mouseTracking = false;
bool _incomingEvent(void* ev) override {
HWNDEvent& e = *static_cast<HWNDEvent*>(ev);
switch (e.uMsg) {
case WM_CLOSE:
if (m_callback)
m_callback->destroyed();
return true;
case WM_SIZE: {
SWindowRect rect;
getWindowFrame(rect.location[0], rect.location[1], rect.size[0], rect.size[1]);
if (!rect.size[0] || !rect.size[1])
return false;
m_gfxCtx->resized(rect);
if (m_callback)
m_callback->resized(rect, m_openGL);
return false;
}
case WM_MOVING: {
SWindowRect rect;
getWindowFrame(rect.location[0], rect.location[1], rect.size[0], rect.size[1]);
if (!rect.size[0] || !rect.size[1])
return false;
if (m_callback)
m_callback->windowMoved(rect);
return false;
}
case WM_KEYDOWN:
case WM_SYSKEYDOWN: {
if (m_callback) {
ESpecialKey specialKey;
EModifierKey modifierKey;
uint32_t charCode = translateKeysym(e.wParam, (e.lParam >> 16) & 0xff, specialKey, modifierKey);
EModifierKey modifierMask = translateModifiers(e.uMsg);
if (charCode)
m_callback->charKeyDown(charCode, modifierMask, (HIWORD(e.lParam) & KF_REPEAT) != 0);
else if (specialKey != ESpecialKey::None)
m_callback->specialKeyDown(specialKey, modifierMask, (HIWORD(e.lParam) & KF_REPEAT) != 0);
else if (modifierKey != EModifierKey::None)
m_callback->modKeyDown(modifierKey, (HIWORD(e.lParam) & KF_REPEAT) != 0);
}
return false;
}
case WM_KEYUP:
case WM_SYSKEYUP: {
if (m_callback) {
ESpecialKey specialKey;
EModifierKey modifierKey;
uint32_t charCode = translateKeysym(e.wParam, (e.lParam >> 16) & 0xff, specialKey, modifierKey);
EModifierKey modifierMask = translateModifiers(e.uMsg);
if (charCode)
m_callback->charKeyUp(charCode, modifierMask);
else if (specialKey != ESpecialKey::None)
m_callback->specialKeyUp(specialKey, modifierMask);
else if (modifierKey != EModifierKey::None)
m_callback->modKeyUp(modifierKey);
}
return false;
}
case WM_LBUTTONDOWN: {
buttonDown(e, EMouseButton::Primary);
return false;
}
case WM_LBUTTONUP: {
buttonUp(e, EMouseButton::Primary);
return false;
}
case WM_RBUTTONDOWN: {
buttonDown(e, EMouseButton::Secondary);
return false;
}
case WM_RBUTTONUP: {
buttonUp(e, EMouseButton::Secondary);
return false;
}
case WM_MBUTTONDOWN: {
buttonDown(e, EMouseButton::Middle);
return false;
}
case WM_MBUTTONUP: {
buttonUp(e, EMouseButton::Middle);
return false;
}
case WM_XBUTTONDOWN: {
if (HIWORD(e.wParam) == XBUTTON1)
buttonDown(e, EMouseButton::Aux1);
else if (HIWORD(e.wParam) == XBUTTON2)
buttonDown(e, EMouseButton::Aux2);
return false;
}
case WM_XBUTTONUP: {
if (HIWORD(e.wParam) == XBUTTON1)
buttonUp(e, EMouseButton::Aux1);
else if (HIWORD(e.wParam) == XBUTTON2)
buttonUp(e, EMouseButton::Aux2);
return false;
}
case WM_MOUSEMOVE: {
if (m_callback) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
SWindowCoord coord = {{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{float(GET_X_LPARAM(e.lParam)) / float(w), float(h - GET_Y_LPARAM(e.lParam)) / float(h)}};
if (!mouseTracking) {
_trackMouse();
mouseTracking = true;
m_callback->mouseEnter(coord);
} else
m_callback->mouseMove(coord);
}
return false;
}
case WM_MOUSELEAVE:
case WM_NCMOUSELEAVE: {
if (m_callback) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
SWindowCoord coord = {{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{float(GET_X_LPARAM(e.lParam)) / float(w), float(h - GET_Y_LPARAM(e.lParam)) / float(h)}};
m_callback->mouseLeave(coord);
mouseTracking = false;
}
return false;
}
case WM_NCMOUSEHOVER:
case WM_MOUSEHOVER: {
if (m_callback) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
SWindowCoord coord = {{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{float(GET_X_LPARAM(e.lParam)) / float(w), float(h - GET_Y_LPARAM(e.lParam)) / float(h)}};
m_callback->mouseEnter(coord);
}
return false;
}
case WM_MOUSEWHEEL: {
if (m_callback) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
SWindowCoord coord = {{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{float(GET_X_LPARAM(e.lParam)) / float(w), float(h - GET_Y_LPARAM(e.lParam)) / float(h)}};
SScrollDelta scroll = {};
scroll.delta[1] = GET_WHEEL_DELTA_WPARAM(e.wParam) / double(WHEEL_DELTA);
m_callback->scroll(coord, scroll);
}
return false;
}
case WM_MOUSEHWHEEL: {
if (m_callback) {
int x, y, w, h;
getWindowFrame(x, y, w, h);
SWindowCoord coord = {{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{GET_X_LPARAM(e.lParam), h - GET_Y_LPARAM(e.lParam)},
{float(GET_X_LPARAM(e.lParam)) / float(w), float(h - GET_Y_LPARAM(e.lParam)) / float(h)}};
SScrollDelta scroll = {};
scroll.delta[0] = GET_WHEEL_DELTA_WPARAM(e.wParam) / double(-WHEEL_DELTA);
m_callback->scroll(coord, scroll);
}
return false;
}
case WM_CHAR:
case WM_UNICHAR: {
if (m_callback) {
ITextInputCallback* inputCb = m_callback->getTextInputCallback();
uint8_t utf8ch[4];
size_t len = utf8proc_encode_char(e.wParam, utf8ch);
if (inputCb && len)
inputCb->insertText(std::string((char*)utf8ch, len));
}
return false;
}
default:
break;
}
return false;
}
ETouchType getTouchType() const override { return ETouchType::None; }
void setStyle(EWindowStyle style) override {
LONG_PTR sty = GetWindowLongPtr(m_hwnd, GWL_STYLE);
if ((style & EWindowStyle::Titlebar) != EWindowStyle::None) {
sty |= WS_CAPTION;
} else {
sty &= ~WS_CAPTION;
}
if ((style & EWindowStyle::Resize) != EWindowStyle::None) {
sty |= WS_THICKFRAME;
} else {
sty &= ~WS_THICKFRAME;
}
if ((style & EWindowStyle::Close) != EWindowStyle::None) {
sty |= (WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
} else {
sty &= ~(WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
}
SetWindowLongPtr(m_hwnd, GWL_STYLE, sty);
}
EWindowStyle getStyle() const override {
const LONG_PTR sty = GetWindowLongPtr(m_hwnd, GWL_STYLE);
EWindowStyle retval = EWindowStyle::None;
if ((sty & WS_CAPTION) != 0) {
retval |= EWindowStyle::Titlebar;
}
if ((sty & WS_THICKFRAME) != 0) {
retval |= EWindowStyle::Resize;
}
if ((sty & WS_SYSMENU)) {
retval |= EWindowStyle::Close;
}
return retval;
}
IGraphicsCommandQueue* getCommandQueue() override { return m_gfxCtx->getCommandQueue(); }
IGraphicsDataFactory* getDataFactory() override { return m_gfxCtx->getDataFactory(); }
/* Creates a new context on current thread!! Call from main client thread */
IGraphicsDataFactory* getMainContextDataFactory() override { return m_gfxCtx->getMainContextDataFactory(); }
/* Creates a new context on current thread!! Call from client loading thread */
IGraphicsDataFactory* getLoadContextDataFactory() override { return m_gfxCtx->getLoadContextDataFactory(); }
};
std::shared_ptr<IWindow> _WindowWin32New(std::string_view title, Boo3DAppContextWin32& d3dCtx) {
return std::make_shared<WindowWin32>(title, d3dCtx);
}
} // namespace boo
Reference in New Issue View Git Blame Copy Permalink