From 6fddd34ca593b3b29b2c70ef5b744e88f823c14e Mon Sep 17 00:00:00 2001 From: Noel Berry Date: Tue, 23 Mar 2021 01:56:53 -0700 Subject: [PATCH] cleaning up cmake defines; adding a Win32 Platform Backend --- CMakeLists.txt | 33 +- README.md | 7 +- include/blah/core/app.h | 16 +- include/blah/input/input.h | 365 +++++------ src/graphics/batch.cpp | 19 +- src/internal/graphics_backend_d3d11.cpp | 30 +- src/internal/graphics_backend_dummy.cpp | 6 +- src/internal/graphics_backend_gl.cpp | 6 +- src/internal/platform_backend_sdl2.cpp | 4 +- src/internal/platform_backend_win32.cpp | 776 ++++++++++++++++++++++++ src/math/stopwatch.cpp | 1 - 11 files changed, 1009 insertions(+), 254 deletions(-) create mode 100644 src/internal/platform_backend_win32.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 15aa378..299654a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -56,6 +56,7 @@ add_library(blah src/internal/graphics_backend_d3d11.cpp src/internal/graphics_backend_dummy.cpp src/internal/platform_backend_sdl2.cpp + src/internal/platform_backend_win32.cpp ) target_include_directories(blah @@ -66,26 +67,28 @@ target_include_directories(blah ) # Platform Variables -set(SDL2_ENABLED true CACHE BOOL "Use SDL2 as the System implementation") -set(OPENGL_ENABLED true CACHE BOOL "Use OpenGL graphics implementation") -set(D3D11_ENABLED false CACHE BOOL "Use D3D11 graphics implementation") +set(PLATFORM_SDL2 true CACHE BOOL "Use SDL2 Platform Backend") +set(PLATFORM_WIN32 false CACHE BOOL "Use Win32 Platform Backend") +set(GRAPHICS_OPENGL true CACHE BOOL "Use OpenGL Graphics Backend") +set(GRAPHICS_D3D11 false CACHE BOOL "Use D3D11 Graphics Backend") set(LIBS "") -# add OpenGL definition if we're using it -if (OPENGL_ENABLED) - add_compile_definitions(BLAH_USE_OPENGL) -endif() +# use the OpenGL Graphics Backend +if (GRAPHICS_OPENGL) + add_compile_definitions(BLAH_GRAPHICS_OPENGL) -# add D3D11 definition if we're using it -if (D3D11_ENABLED) - add_compile_definitions(BLAH_USE_D3D11) +# use the D3D11 Graphics Backend +elseif (GRAPHICS_D3D11) + add_compile_definitions(BLAH_GRAPHICS_D3D11) set(LIBS ${LIBS} d3d11.lib dxguid.lib D3Dcompiler.lib) endif() -# Link and create SDL2 Definition if we're using it -if (SDL2_ENABLED) - add_compile_definitions(BLAH_USE_SDL2) +# use the SDL2 Platform Backend +# Link and create SDL2 Definition +if (PLATFORM_SDL2) + add_compile_definitions(BLAH_PLATFORM_SDL2) + if (${CMAKE_SYSTEM_NAME} MATCHES "Emscripten") set_target_properties(blah PROPERTIES COMPILE_FLAGS "-s USE_SDL=2") else() @@ -96,6 +99,10 @@ if (SDL2_ENABLED) target_include_directories(blah PUBLIC "$") set(LIBS ${LIBS} ${SDL2_LIBRARIES}) endif() + +# use the Win32 Platform Backend +elseif (PLATFORM_WIN32) + add_compile_definitions(BLAH_PLATFORM_WIN32) endif() target_link_libraries(blah PUBLIC ${LIBS}) diff --git a/README.md b/README.md index 0405ec9..a4d4cf7 100644 --- a/README.md +++ b/README.md @@ -6,11 +6,12 @@ A small 2D C++ Game Framework, using few dependencies and simple code to mainain #### building - Requires C++17 and CMake 3.12+ - A single *Platform* backend must be enabled: - - [SDL2](https://github.com/NoelFB/blah/blob/master/src/internal/platform_backend_sdl2.cpp) can be enabled in CMake with `SDL2_ENABLED`, and setting `SDL2_INCLUDE_DIRS` and `SDL2_LIBRARIES` + - [SDL2](https://github.com/NoelFB/blah/blob/master/src/internal/platform_backend_sdl2.cpp) can be enabled in CMake with `PLATFORM_SDL2`, and setting `SDL2_INCLUDE_DIRS` and `SDL2_LIBRARIES` + - [WIN32](https://github.com/NoelFB/blah/blob/master/src/internal/platform_backend_win32.cpp) (UNFINISHED) can be enabled in CMake with `PLATFORM_WIN32`. - Additional backends can be added by implementing the [Platform Backend](https://github.com/NoelFB/blah/blob/master/src/internal/platform_backend.h) - A single *Graphics* backend must be enabled: - - [OpenGL](https://github.com/NoelFB/blah/blob/master/src/internal/graphics_backend_gl.cpp) can be enabled in CMake with `OPENGL_ENABLED`. - - [D3D11](https://github.com/NoelFB/blah/blob/master/src/internal/graphics_backend_d3d11.cpp) can be enabled in CMake with `D3D11_ENABLED`. + - [OpenGL](https://github.com/NoelFB/blah/blob/master/src/internal/graphics_backend_gl.cpp) can be enabled in CMake with `GRAPHICS_OPENGL`. + - [D3D11](https://github.com/NoelFB/blah/blob/master/src/internal/graphics_backend_d3d11.cpp) can be enabled in CMake with `GRAPHICS_D3D11`. - Additional backends can be added by implementing the [Graphics Backend](https://github.com/NoelFB/blah/blob/master/src/internal/graphics_backend.h). #### notes diff --git a/include/blah/core/app.h b/include/blah/core/app.h index 408c341..18e0049 100644 --- a/include/blah/core/app.h +++ b/include/blah/core/app.h @@ -102,7 +102,9 @@ namespace Blah // Returns whether the application is running bool is_running(); - // Exits the application + // Exits the application. + // This only signals for the application to close, it will not stop + // until the current update and render calls are finished. void exit(); // Gets the config data used to run the application @@ -120,16 +122,20 @@ namespace Blah // Gets the height of the window int height(); - // Gets the drawable width of the window + // Gets the drawable width of the window, in pixels. + // This may differ from the width when on platforms with High DPI Displays. int draw_width(); - // Gets the drawable height of the window + // Gets the drawable height of the window, in pixels. + // This may differ from the height when on platforms with High DPI Displays. int draw_height(); - // Gets the content scale based on the OS + // Gets the content scale based on the platform. + // macOS is usually 2.0, other platforms vary. float content_scale(); - // Toggles fullscreen + // Toggles fullscreen if supported on the platform. + // Otherwise this function does nothing. void fullscreen(bool enabled); // Returns the Rendering API in use diff --git a/include/blah/input/input.h b/include/blah/input/input.h index 1d75d29..9fdb3df 100644 --- a/include/blah/input/input.h +++ b/include/blah/input/input.h @@ -4,221 +4,190 @@ #include #include -// These are generally copied from the SDL2 Scancode Keys +// These are generally copied from the SDL2 Scancode Keys, +// which are in turn based on the USB standards: +// https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf #define BLAH_KEY_DEFINITIONS \ DEFINE_KEY(Unknown, 0) \ - DEFINE_KEY(A, 4) \ - DEFINE_KEY(B, 5) \ - DEFINE_KEY(C, 6) \ - DEFINE_KEY(D, 7) \ - DEFINE_KEY(E, 8) \ - DEFINE_KEY(F, 9) \ - DEFINE_KEY(G, 10) \ - DEFINE_KEY(H, 11) \ - DEFINE_KEY(I, 12) \ - DEFINE_KEY(J, 13) \ - DEFINE_KEY(K, 14) \ - DEFINE_KEY(L, 15) \ - DEFINE_KEY(M, 16) \ - DEFINE_KEY(N, 17) \ - DEFINE_KEY(O, 18) \ - DEFINE_KEY(P, 19) \ - DEFINE_KEY(Q, 20) \ - DEFINE_KEY(R, 21) \ - DEFINE_KEY(S, 22) \ - DEFINE_KEY(T, 23) \ - DEFINE_KEY(U, 24) \ - DEFINE_KEY(V, 25) \ - DEFINE_KEY(W, 26) \ - DEFINE_KEY(X, 27) \ - DEFINE_KEY(Y, 28) \ - DEFINE_KEY(Z, 29) \ - DEFINE_KEY(D1, 30) \ - DEFINE_KEY(D2, 31) \ - DEFINE_KEY(D3, 32) \ - DEFINE_KEY(D4, 33) \ - DEFINE_KEY(D5, 34) \ - DEFINE_KEY(D6, 35) \ - DEFINE_KEY(D7, 36) \ - DEFINE_KEY(D8, 37) \ - DEFINE_KEY(D9, 38) \ - DEFINE_KEY(D0, 39) \ + \ + DEFINE_KEY(A, 4) \ + DEFINE_KEY(B, 5) \ + DEFINE_KEY(C, 6) \ + DEFINE_KEY(D, 7) \ + DEFINE_KEY(E, 8) \ + DEFINE_KEY(F, 9) \ + DEFINE_KEY(G, 10) \ + DEFINE_KEY(H, 11) \ + DEFINE_KEY(I, 12) \ + DEFINE_KEY(J, 13) \ + DEFINE_KEY(K, 14) \ + DEFINE_KEY(L, 15) \ + DEFINE_KEY(M, 16) \ + DEFINE_KEY(N, 17) \ + DEFINE_KEY(O, 18) \ + DEFINE_KEY(P, 19) \ + DEFINE_KEY(Q, 20) \ + DEFINE_KEY(R, 21) \ + DEFINE_KEY(S, 22) \ + DEFINE_KEY(T, 23) \ + DEFINE_KEY(U, 24) \ + DEFINE_KEY(V, 25) \ + DEFINE_KEY(W, 26) \ + DEFINE_KEY(X, 27) \ + DEFINE_KEY(Y, 28) \ + DEFINE_KEY(Z, 29) \ + \ + DEFINE_KEY(D1, 30) \ + DEFINE_KEY(D2, 31) \ + DEFINE_KEY(D3, 32) \ + DEFINE_KEY(D4, 33) \ + DEFINE_KEY(D5, 34) \ + DEFINE_KEY(D6, 35) \ + DEFINE_KEY(D7, 36) \ + DEFINE_KEY(D8, 37) \ + DEFINE_KEY(D9, 38) \ + DEFINE_KEY(D0, 39) \ + \ DEFINE_KEY(Enter, 40) \ DEFINE_KEY(Escape, 41) \ DEFINE_KEY(Backspace, 42) \ DEFINE_KEY(Tab, 43) \ DEFINE_KEY(Space, 44) \ + \ DEFINE_KEY(Minus, 45) \ DEFINE_KEY(Equals, 46) \ DEFINE_KEY(LeftBracket, 47) \ DEFINE_KEY(RightBracket, 48) \ - DEFINE_KEY(BackSlash, 49) \ - DEFINE_KEY(NonUSHash, 50) \ + DEFINE_KEY(Backslash, 49) \ DEFINE_KEY(Semicolon, 51) \ DEFINE_KEY(Apostrophe, 52) \ - DEFINE_KEY(Grave, 53) \ + DEFINE_KEY(Tilde, 53) \ DEFINE_KEY(Comma, 54) \ DEFINE_KEY(Period, 55) \ DEFINE_KEY(Slash, 56) \ + \ DEFINE_KEY(Capslock, 57) \ - DEFINE_KEY(F1, 58) \ - DEFINE_KEY(F2, 59) \ - DEFINE_KEY(F3, 60) \ - DEFINE_KEY(F4, 61) \ - DEFINE_KEY(F5, 62) \ - DEFINE_KEY(F6, 63) \ - DEFINE_KEY(F7, 64) \ - DEFINE_KEY(F8, 65) \ - DEFINE_KEY(F9, 66) \ - DEFINE_KEY(F10, 67) \ - DEFINE_KEY(F11, 68) \ - DEFINE_KEY(F12, 69) \ - DEFINE_KEY(PrintScreen, 70) \ - DEFINE_KEY(ScrollLock, 71) \ - DEFINE_KEY(Pause, 72) \ - DEFINE_KEY(Insert, 73) \ - DEFINE_KEY(Home, 74) \ - DEFINE_KEY(PageUp, 75) \ - DEFINE_KEY(Delete, 76) \ - DEFINE_KEY(End, 77) \ - DEFINE_KEY(PageDown, 78) \ - DEFINE_KEY(Right, 79) \ - DEFINE_KEY(Left, 80) \ - DEFINE_KEY(Down, 81) \ - DEFINE_KEY(Up, 82) \ - DEFINE_KEY(NumlockClear, 83) \ - DEFINE_KEY(KP_Divide, 84) \ - DEFINE_KEY(KP_Multiply, 85) \ - DEFINE_KEY(KP_Minus, 86) \ - DEFINE_KEY(KP_Plus, 87) \ - DEFINE_KEY(KP_Enter, 88) \ - DEFINE_KEY(KP_1, 89) \ - DEFINE_KEY(KP_2, 90) \ - DEFINE_KEY(KP_3, 91) \ - DEFINE_KEY(KP_4, 92) \ - DEFINE_KEY(KP_5, 93) \ - DEFINE_KEY(KP_6, 94) \ - DEFINE_KEY(KP_7, 95) \ - DEFINE_KEY(KP_8, 96) \ - DEFINE_KEY(KP_9, 97) \ - DEFINE_KEY(KP_0, 98) \ - DEFINE_KEY(KP_Period, 99) \ - DEFINE_KEY(NonUSBackSlash, 100) \ - DEFINE_KEY(Application, 101) \ - DEFINE_KEY(Power, 102) \ - DEFINE_KEY(KP_Equals, 103) \ - DEFINE_KEY(F13, 104) \ - DEFINE_KEY(F14, 105) \ - DEFINE_KEY(F15, 106) \ - DEFINE_KEY(F16, 107) \ - DEFINE_KEY(F17, 108) \ - DEFINE_KEY(F18, 109) \ - DEFINE_KEY(F19, 110) \ - DEFINE_KEY(F20, 111) \ - DEFINE_KEY(F21, 112) \ - DEFINE_KEY(F22, 113) \ - DEFINE_KEY(F23, 114) \ - DEFINE_KEY(F24, 115) \ - DEFINE_KEY(Execute, 116) \ - DEFINE_KEY(Help, 117) \ - DEFINE_KEY(Menu, 118) \ - DEFINE_KEY(Select, 119) \ - DEFINE_KEY(Stop, 120) \ - DEFINE_KEY(Again, 121) \ - DEFINE_KEY(Undo, 122) \ - DEFINE_KEY(Cut, 123) \ - DEFINE_KEY(Copy, 124) \ - DEFINE_KEY(Paste, 125) \ - DEFINE_KEY(Find, 126) \ - DEFINE_KEY(Mute, 127) \ - DEFINE_KEY(VolumeUp, 128) \ - DEFINE_KEY(VolumeDown, 129) \ - DEFINE_KEY(KP_Comma, 133) \ - DEFINE_KEY(KP_EqualsAs400, 134) \ - DEFINE_KEY(International1, 135) \ - DEFINE_KEY(International2, 136) \ - DEFINE_KEY(International3, 137) \ - DEFINE_KEY(International4, 138) \ - DEFINE_KEY(International5, 139) \ - DEFINE_KEY(International6, 140) \ - DEFINE_KEY(International7, 141) \ - DEFINE_KEY(International8, 142) \ - DEFINE_KEY(International9, 143) \ - DEFINE_KEY(Language1, 144) \ - DEFINE_KEY(Language2, 145) \ - DEFINE_KEY(Language3, 146) \ - DEFINE_KEY(Language4, 147) \ - DEFINE_KEY(Language5, 148) \ - DEFINE_KEY(Language6, 149) \ - DEFINE_KEY(Language7, 150) \ - DEFINE_KEY(Language8, 151) \ - DEFINE_KEY(Language9, 152) \ - DEFINE_KEY(AltErase, 153) \ - DEFINE_KEY(SysReq, 154) \ - DEFINE_KEY(Cancel, 155) \ - DEFINE_KEY(clear, 156) \ - DEFINE_KEY(Prior, 157) \ - DEFINE_KEY(Return2, 158) \ - DEFINE_KEY(Separator, 159) \ - DEFINE_KEY(Out, 160) \ - DEFINE_KEY(Oper, 161) \ - DEFINE_KEY(ClearAgain, 162) \ - DEFINE_KEY(CRSEL, 163) \ - DEFINE_KEY(EXSEL, 164) \ - DEFINE_KEY(KP_00, 176) \ - DEFINE_KEY(KP_000, 177) \ - DEFINE_KEY(ThousandsSeparator, 178) \ - DEFINE_KEY(DecimalSeparator, 179) \ - DEFINE_KEY(CurrencyUnit, 180) \ - DEFINE_KEY(CurrencySubUnit, 181) \ - DEFINE_KEY(KP_LeftParen, 182) \ - DEFINE_KEY(KP_RightParent, 183) \ - DEFINE_KEY(KP_LeftBrace, 184) \ - DEFINE_KEY(KP_RightBrace, 185) \ - DEFINE_KEY(KP_Tab, 186) \ - DEFINE_KEY(KP_BackSpace, 187) \ - DEFINE_KEY(KP_A, 188) \ - DEFINE_KEY(KP_B, 189) \ - DEFINE_KEY(KP_C, 190) \ - DEFINE_KEY(KP_D, 191) \ - DEFINE_KEY(KP_E, 192) \ - DEFINE_KEY(KP_F, 193) \ - DEFINE_KEY(KP_XOR, 194) \ - DEFINE_KEY(KP_Power, 195) \ - DEFINE_KEY(KP_Percent, 196) \ - DEFINE_KEY(KP_Less, 197) \ - DEFINE_KEY(KP_Greater, 198) \ - DEFINE_KEY(KP_Ampersand, 199) \ - DEFINE_KEY(KP_DoubleAmpersand, 200) \ - DEFINE_KEY(KP_VerticalBar, 201) \ - DEFINE_KEY(KP_DoubleVerticalBar, 202) \ - DEFINE_KEY(KP_Colon, 203) \ - DEFINE_KEY(KP_Hash, 204) \ - DEFINE_KEY(KP_Space, 205) \ - DEFINE_KEY(KP_At, 206) \ - DEFINE_KEY(KP_EXCLAM, 207) \ - DEFINE_KEY(KP_MemStore, 208) \ - DEFINE_KEY(KP_MemRecall, 209) \ - DEFINE_KEY(KP_MemClear, 210) \ - DEFINE_KEY(KP_MemAdd, 211) \ - DEFINE_KEY(KP_MemSubstract, 212) \ - DEFINE_KEY(KP_MemMultiply, 213) \ - DEFINE_KEY(KP_MemDivide, 214) \ - DEFINE_KEY(KP_PlusMinus, 215) \ - DEFINE_KEY(KP_Clear, 216) \ - DEFINE_KEY(KP_ClearEntry, 217) \ - DEFINE_KEY(KP_Binary, 218) \ - DEFINE_KEY(KP_Octal, 219) \ - DEFINE_KEY(KP_Decimal, 220) \ - DEFINE_KEY(KP_Hexadecimal, 221) \ - DEFINE_KEY(LeftControl, 224) \ - DEFINE_KEY(LeftShift, 225) \ - DEFINE_KEY(LeftAlt, 226) \ - DEFINE_KEY(LeftGui, 227) \ - DEFINE_KEY(RightControl, 228) \ - DEFINE_KEY(RightShift, 229) \ - DEFINE_KEY(RightAlt, 230) \ - DEFINE_KEY(RightGui, 231) + \ + DEFINE_KEY(F1, 58) \ + DEFINE_KEY(F2, 59) \ + DEFINE_KEY(F3, 60) \ + DEFINE_KEY(F4, 61) \ + DEFINE_KEY(F5, 62) \ + DEFINE_KEY(F6, 63) \ + DEFINE_KEY(F7, 64) \ + DEFINE_KEY(F8, 65) \ + DEFINE_KEY(F9, 66) \ + DEFINE_KEY(F10, 67) \ + DEFINE_KEY(F11, 68) \ + DEFINE_KEY(F12, 69) \ + DEFINE_KEY(F13, 104) \ + DEFINE_KEY(F14, 105) \ + DEFINE_KEY(F15, 106) \ + DEFINE_KEY(F16, 107) \ + DEFINE_KEY(F17, 108) \ + DEFINE_KEY(F18, 109) \ + DEFINE_KEY(F19, 110) \ + DEFINE_KEY(F20, 111) \ + DEFINE_KEY(F21, 112) \ + DEFINE_KEY(F22, 113) \ + DEFINE_KEY(F23, 114) \ + DEFINE_KEY(F24, 115) \ + \ + DEFINE_KEY(PrintScreen, 70) \ + DEFINE_KEY(ScrollLock, 71) \ + DEFINE_KEY(Pause, 72) \ + DEFINE_KEY(Insert, 73) \ + DEFINE_KEY(Home, 74) \ + DEFINE_KEY(PageUp, 75) \ + DEFINE_KEY(Delete, 76) \ + DEFINE_KEY(End, 77) \ + DEFINE_KEY(PageDown, 78) \ + DEFINE_KEY(Right, 79) \ + DEFINE_KEY(Left, 80) \ + DEFINE_KEY(Down, 81) \ + DEFINE_KEY(Up, 82) \ + \ + DEFINE_KEY(Numlock, 83) \ + \ + DEFINE_KEY(Application, 101) \ + \ + DEFINE_KEY(Execute, 116) \ + DEFINE_KEY(Help, 117) \ + DEFINE_KEY(Menu, 118) \ + DEFINE_KEY(Select, 119) \ + DEFINE_KEY(Stop, 120) \ + DEFINE_KEY(Redo, 121) \ + DEFINE_KEY(Undo, 122) \ + DEFINE_KEY(Cut, 123) \ + DEFINE_KEY(Copy, 124) \ + DEFINE_KEY(Paste, 125) \ + DEFINE_KEY(Find, 126) \ + DEFINE_KEY(Mute, 127) \ + DEFINE_KEY(VolumeUp, 128) \ + DEFINE_KEY(VolumeDown, 129) \ + \ + DEFINE_KEY(AltErase, 153) \ + DEFINE_KEY(SysReq, 154) \ + DEFINE_KEY(Cancel, 155) \ + DEFINE_KEY(Clear, 156) \ + DEFINE_KEY(Prior, 157) \ + DEFINE_KEY(Enter2, 158) \ + DEFINE_KEY(Separator, 159) \ + DEFINE_KEY(Out, 160) \ + DEFINE_KEY(Oper, 161) \ + DEFINE_KEY(ClearAgain, 162) \ + \ + DEFINE_KEY(KeypadA, 188) \ + DEFINE_KEY(KeypadB, 189) \ + DEFINE_KEY(KeypadC, 190) \ + DEFINE_KEY(KeypadD, 191) \ + DEFINE_KEY(KeypadE, 192) \ + DEFINE_KEY(KeypadF, 193) \ + DEFINE_KEY(Keypad0, 98) \ + DEFINE_KEY(Keypad00, 176) \ + DEFINE_KEY(Keypad000, 177) \ + DEFINE_KEY(Keypad1, 89) \ + DEFINE_KEY(Keypad2, 90) \ + DEFINE_KEY(Keypad3, 91) \ + DEFINE_KEY(Keypad4, 92) \ + DEFINE_KEY(Keypad5, 93) \ + DEFINE_KEY(Keypad6, 94) \ + DEFINE_KEY(Keypad7, 95) \ + DEFINE_KEY(Keypad8, 96) \ + DEFINE_KEY(Keypad9, 97) \ + DEFINE_KEY(KeypadDivide, 84) \ + DEFINE_KEY(KeypadMultiply, 85) \ + DEFINE_KEY(KeypadMinus, 86) \ + DEFINE_KEY(KeypadPlus, 87) \ + DEFINE_KEY(KeypadEnter, 88) \ + DEFINE_KEY(KeypadPeroid, 99) \ + DEFINE_KEY(KeypadEquals, 103) \ + DEFINE_KEY(KeypadComma, 133) \ + DEFINE_KEY(KeypadLeftParen, 182) \ + DEFINE_KEY(KeypadRightParen, 183) \ + DEFINE_KEY(KeypadLeftBrace, 184) \ + DEFINE_KEY(KeypadRightBrace, 185) \ + DEFINE_KEY(KeypadTab, 186) \ + DEFINE_KEY(KeypadBackspace, 187) \ + DEFINE_KEY(KeypadXor, 194) \ + DEFINE_KEY(KeypadPower, 195) \ + DEFINE_KEY(KeypadPercent, 196) \ + DEFINE_KEY(KeypadLess, 197) \ + DEFINE_KEY(KeypadGreater, 198) \ + DEFINE_KEY(KeypadAmpersand, 199) \ + DEFINE_KEY(KeypadColon, 203) \ + DEFINE_KEY(KeypadHash, 204) \ + DEFINE_KEY(KeypadSpace, 205) \ + DEFINE_KEY(KeypadClear, 216) \ + \ + DEFINE_KEY(LeftControl, 224) \ + DEFINE_KEY(LeftShift, 225) \ + DEFINE_KEY(LeftAlt, 226) \ + DEFINE_KEY(LeftOS, 227) \ + DEFINE_KEY(RightControl, 228) \ + DEFINE_KEY(RightShift, 229) \ + DEFINE_KEY(RightAlt, 230) \ + DEFINE_KEY(RightOS, 231) #define BLAH_BUTTON_DEFINITIONS \ DEFINE_BTN(None, -1) \ diff --git a/src/graphics/batch.cpp b/src/graphics/batch.cpp index 6ebe4a3..95cdf73 100644 --- a/src/graphics/batch.cpp +++ b/src/graphics/batch.cpp @@ -15,9 +15,7 @@ namespace // TODO: // This shader needs to be graphics API agnostic -#ifdef BLAH_USE_OPENGL - - const ShaderData shader_data = { + const ShaderData opengl_shader_data = { // vertex shader #ifdef __EMSCRIPTEN__ "#version 300 es\n" @@ -62,8 +60,6 @@ namespace "}" }; -#elif BLAH_USE_D3D11 - const char* d3d11_shader = "" "cbuffer constants : register(b0)\n" "{\n" @@ -110,7 +106,7 @@ namespace " input.mask.z * input.color;\n" "}\n"; - const ShaderData shader_data = { + const ShaderData d3d11_shader_data = { d3d11_shader, d3d11_shader, { @@ -121,10 +117,6 @@ namespace } }; -#else - const ShaderData shader_data; -#endif - const VertexFormat format = VertexFormat( { { 0, VertexType::Float2, false }, @@ -384,7 +376,12 @@ void Batch::render(const FrameBufferRef& target, const Mat4x4& matrix) m_mesh = Mesh::create(); if (!m_default_shader) - m_default_shader = Shader::create(shader_data); + { + if (App::renderer() == Renderer::OpenGL) + m_default_shader = Shader::create(opengl_shader_data); + else if (App::renderer() == Renderer::D3D11) + m_default_shader = Shader::create(d3d11_shader_data); + } if (!m_default_material) m_default_material = Material::create(m_default_shader); diff --git a/src/internal/graphics_backend_d3d11.cpp b/src/internal/graphics_backend_d3d11.cpp index f1568f6..abeaa71 100644 --- a/src/internal/graphics_backend_d3d11.cpp +++ b/src/internal/graphics_backend_d3d11.cpp @@ -1,4 +1,4 @@ -#ifdef BLAH_USE_D3D11 +#ifdef BLAH_GRAPHICS_D3D11 // TODO: // Note the D3D11 Implementation is still a work-in-progress @@ -592,7 +592,7 @@ namespace Blah if (index_buffer) index_buffer->Release(); index_buffer = nullptr; - + // buffer description D3D11_BUFFER_DESC desc = { 0 }; desc.ByteWidth = (UINT)(index_stride * m_index_capacity); @@ -1287,7 +1287,7 @@ namespace Blah { bool same_format = true; for (int n = 0; same_format && n < format.attributes.size(); n++) - if (it.format.attributes[n].index != format.attributes[n].index || + if (it.format.attributes[n].index != format.attributes[n].index || it.format.attributes[n].type != format.attributes[n].type || it.format.attributes[n].normalized != format.attributes[n].normalized) same_format = false; @@ -1403,7 +1403,7 @@ namespace Blah desc.RenderTarget[0].DestBlendAlpha = blend_factor(blend.alpha_dst); } - for (int i = 1; i < 8; i ++) + for (int i = 1; i < 8; i++) desc.RenderTarget[i] = desc.RenderTarget[0]; ID3D11BlendState* blend_state = nullptr; @@ -1453,7 +1453,7 @@ namespace Blah case TextureWrap::Clamp: desc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP; break; case TextureWrap::Repeat: desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; break; } - + ID3D11SamplerState* result; auto hr = state.device->CreateSamplerState(&desc, &result); @@ -1522,15 +1522,15 @@ namespace Blah switch (pass.depth) { - case Compare::None: desc.DepthFunc = D3D11_COMPARISON_NEVER; break; - case Compare::Always: desc.DepthFunc = D3D11_COMPARISON_ALWAYS; break; - case Compare::Never: desc.DepthFunc = D3D11_COMPARISON_NEVER; break; - case Compare::Less: desc.DepthFunc = D3D11_COMPARISON_LESS; break; - case Compare::Equal: desc.DepthFunc = D3D11_COMPARISON_EQUAL; break; - case Compare::LessOrEqual: desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL; break; - case Compare::Greater: desc.DepthFunc = D3D11_COMPARISON_GREATER; break; - case Compare::NotEqual: desc.DepthFunc = D3D11_COMPARISON_NOT_EQUAL; break; - case Compare::GreatorOrEqual: desc.DepthFunc = D3D11_COMPARISON_GREATER_EQUAL; break; + case Compare::None: desc.DepthFunc = D3D11_COMPARISON_NEVER; break; + case Compare::Always: desc.DepthFunc = D3D11_COMPARISON_ALWAYS; break; + case Compare::Never: desc.DepthFunc = D3D11_COMPARISON_NEVER; break; + case Compare::Less: desc.DepthFunc = D3D11_COMPARISON_LESS; break; + case Compare::Equal: desc.DepthFunc = D3D11_COMPARISON_EQUAL; break; + case Compare::LessOrEqual: desc.DepthFunc = D3D11_COMPARISON_LESS_EQUAL; break; + case Compare::Greater: desc.DepthFunc = D3D11_COMPARISON_GREATER; break; + case Compare::NotEqual: desc.DepthFunc = D3D11_COMPARISON_NOT_EQUAL; break; + case Compare::GreatorOrEqual: desc.DepthFunc = D3D11_COMPARISON_GREATER_EQUAL; break; } ID3D11DepthStencilState* result; @@ -1548,4 +1548,4 @@ namespace Blah } } -#endif // BLAH_USE_D3D11 +#endif // BLAH_GRAPHICS_D3D11 diff --git a/src/internal/graphics_backend_dummy.cpp b/src/internal/graphics_backend_dummy.cpp index 4118447..f3359fc 100644 --- a/src/internal/graphics_backend_dummy.cpp +++ b/src/internal/graphics_backend_dummy.cpp @@ -1,4 +1,4 @@ -#if !(defined(BLAH_USE_OPENGL) || defined(BLAH_USE_D3D11)) +#if !(defined(BLAH_GRAPHICS_OPENGL) || defined(BLAH_GRAPHICS_D3D11)) #include "../internal/graphics_backend.h" #include "../internal/platform_backend.h" @@ -193,7 +193,7 @@ namespace Blah const RendererFeatures& GraphicsBackend::features() { - static const RendererFeatures features { false, true, 4096 }; + static const RendererFeatures features{ false, true, 4096 }; return features; } @@ -232,4 +232,4 @@ namespace Blah } } -#endif // !(defined(BLAH_USE_OPENGL) || defined(BLAH_USE_D3D11)) +#endif // !(defined(BLAH_GRAPHICS_OPENGL) || defined(BLAH_GRAPHICS_D3D11)) diff --git a/src/internal/graphics_backend_gl.cpp b/src/internal/graphics_backend_gl.cpp index 8e88a3b..530e17d 100644 --- a/src/internal/graphics_backend_gl.cpp +++ b/src/internal/graphics_backend_gl.cpp @@ -1,4 +1,4 @@ -#ifdef BLAH_USE_OPENGL +#ifdef BLAH_GRAPHICS_OPENGL #include "../internal/graphics_backend.h" #include "../internal/platform_backend.h" @@ -674,7 +674,7 @@ namespace Blah GLuint m_id; int m_width; int m_height; - StackVector m_attachments; + StackVector m_attachments; public: @@ -1517,4 +1517,4 @@ namespace Blah } } -#endif // BLAH_USE_OPENGL +#endif // BLAH_GRAPHICS_OPENGL diff --git a/src/internal/platform_backend_sdl2.cpp b/src/internal/platform_backend_sdl2.cpp index 16fed07..3716edd 100644 --- a/src/internal/platform_backend_sdl2.cpp +++ b/src/internal/platform_backend_sdl2.cpp @@ -1,4 +1,4 @@ -#ifdef BLAH_USE_SDL2 +#ifdef BLAH_PLATFORM_SDL2 #include "../internal/platform_backend.h" #include "../internal/input_backend.h" @@ -722,4 +722,4 @@ void* PlatformBackend::d3d11_get_hwnd() #endif } -#endif // BLAH_USE_SDL2 +#endif // BLAH_PLATFORM_SDL2 diff --git a/src/internal/platform_backend_win32.cpp b/src/internal/platform_backend_win32.cpp new file mode 100644 index 0000000..7742723 --- /dev/null +++ b/src/internal/platform_backend_win32.cpp @@ -0,0 +1,776 @@ +#ifdef BLAH_PLATFORM_WIN32 + +// Note: +// This backend implementation is unfinished! +// It's missing a few things, namely: +// - Controller Support +// - Mouse wheel +// - Text input +// - Probably other stuff? +// (And error testing) + +#include "../internal/platform_backend.h" +#include "../internal/input_backend.h" +#include "../internal/graphics_backend.h" +#include +#include +#include +#include +#include +#include + +#define WIN32_LEAN_AND_MEAN +#include +#include // for SetProcessDPIAware +#include // for File Reading/Writing +#include // for file explore +#include // for known folder +#include // for ticks method + +using namespace Blah; +namespace fs = std::filesystem; + +namespace +{ + // Primary Window + HWND g_hwnd; + + // Working Directories + FilePath g_working_directory; + FilePath g_user_directory; + + // Timestamp for calculating ticks + std::chrono::system_clock::duration g_start_time; + + // OpenGL Methods + // These are only loaded if built using the OpenGL Backend + HMODULE g_opengl_dll; + void* (WINAPI* g_wglGetProcAddress) (const char* proc); + HGLRC(WINAPI* g_wglCreateContext) (HDC hdc); + BOOL(WINAPI* g_wglDeleteContext) (HGLRC hglrc); + BOOL(WINAPI* g_wglMakeCurrent) (HDC hdc, HGLRC hglrc); + + // fullscreen state + RECT g_windowed_position; + bool g_fullscreen = false; +} + +Key blah_scancode_to_key(WPARAM wParam, LPARAM lParam); +LRESULT CALLBACK blah_window_procedure(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam); + +bool PlatformBackend::init(const Config* config) +{ + // Required to call this for Windows + // I'm not sure why SDL2 doesn't do this on Windows automatically? + SetProcessDPIAware(); + + // Get the hInstance + HINSTANCE hInstance = GetModuleHandle(NULL); + + // Create the Window Class + WNDCLASS wc = {}; + wc.lpfnWndProc = DefWindowProc; + wc.lpszClassName = "BLAH WINDOW"; + wc.hInstance = hInstance; + wc.lpfnWndProc = blah_window_procedure; + wc.hCursor = NULL; + wc.hIcon = NULL; + wc.lpszMenuName = NULL; + wc.hbrBackground = (HBRUSH)COLOR_WINDOW; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + + // Register the Window class + RegisterClass(&wc); + + // Create the Window Instance + g_hwnd = CreateWindow("BLAH WINDOW", config->name, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, 640, 480, NULL, NULL, hInstance, NULL); + + // Failed to create the Window + if (g_hwnd == NULL) + { + Log::error("Window Creation Failed"); + return false; + } + + // Create the OpenGL device info + if (App::renderer() == Renderer::OpenGL) + { + // Load the DLL + g_opengl_dll = LoadLibraryA("opengl32.dll"); + if (g_opengl_dll == NULL) + { + Log::error("OpenGL Instantiation Failed - unable to fine opengl32.dll"); + return false; + } + + // Get the Windows GL functions we need + g_wglGetProcAddress = (void*(WINAPI*) (const char*))GetProcAddress(g_opengl_dll, "wglGetProcAddress"); + g_wglCreateContext = (HGLRC(WINAPI*) (HDC))GetProcAddress(g_opengl_dll, "wglCreateContext"); + g_wglDeleteContext = (BOOL(WINAPI*) (HGLRC))GetProcAddress(g_opengl_dll, "wglDeleteContext"); + g_wglMakeCurrent = (BOOL(WINAPI*) (HDC, HGLRC))GetProcAddress(g_opengl_dll, "wglMakeCurrent"); + + // TODO: + // Allow the user to apply (some of) these values before instantiation. + // Also applies to the SDL2 Backend + + PIXELFORMATDESCRIPTOR pfd = + { + sizeof(PIXELFORMATDESCRIPTOR), // size of this pfd + 1, // version number + PFD_DRAW_TO_WINDOW | // support window + PFD_SUPPORT_OPENGL | // support OpenGL + PFD_DOUBLEBUFFER, // double buffered + PFD_TYPE_RGBA, // RGBA type + 32, // 24-bit color depth + 0, 0, 0, 0, 0, 0, // color bits ignored + 0, // no alpha buffer + 0, // shift bit ignored + 0, // no accumulation buffer + 0, 0, 0, 0, // accum bits ignored + 24, // 32-bit z-buffer + 8, // no stencil buffer + 0, // no auxiliary buffer + PFD_MAIN_PLANE, // main layer + 0, // reserved + 0, 0, 0 // layer masks ignored + }; + + HDC hdc = GetDC(g_hwnd); + + // get the best available match of pixel format for the device context + int pixel_format = ChoosePixelFormat(hdc, &pfd); + + // make that the pixel format of the device context + SetPixelFormat(hdc, pixel_format, &pfd); + } + + // Reset our game timer + g_start_time = std::chrono::system_clock::now().time_since_epoch(); + + // Get Working Directory + { + TCHAR buffer[MAX_PATH]; + GetModuleFileName(NULL, buffer, MAX_PATH); + + auto normalized = Path::normalize(buffer); + auto end = normalized.last_index_of('/');; + if (end >= 0) + g_working_directory = FilePath(normalized.begin(), normalized.begin() + end); + else + g_working_directory = normalized; + g_working_directory.append("/"); + } + + // Get Application User Directory + { + PWSTR path = NULL; + if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_RoamingAppData, KF_FLAG_CREATE, NULL, &path))) + { + auto end = path; + while (*end != 0) end++; + + FilePath result; + result.append_utf16((u16*)path, (u16*)end); + + g_user_directory = Path::join(Path::normalize(result), config->name) + "/"; + } + CoTaskMemFree(path); + } + + // Not currently fullscreen + g_fullscreen = false; + + // Finished Platform Setup + return true; +} + +void PlatformBackend::ready() +{ + // Setup Window Size + { + auto scale = get_content_scale(); + int sw = (int)(App::config()->width * scale); + int sh = (int)(App::config()->height * scale); + set_size(sw, sh); + } + + // Display the game window + ShowWindow(g_hwnd, SW_SHOW); +} + +void PlatformBackend::shutdown() +{ + DestroyWindow(g_hwnd); +} + +u64 PlatformBackend::ticks() +{ + // Todo: + // This should account for whatever Time::ticks_per_second is set to + + auto now = std::chrono::system_clock::now().time_since_epoch(); + return std::chrono::duration_cast(now - g_start_time).count(); +} + +LRESULT CALLBACK blah_window_procedure(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + switch (msg) + { + case WM_CLOSE: + { + auto config = App::config(); + if (config->on_exit_request != nullptr) + config->on_exit_request(); + return 0; + } + + case WM_DESTROY: + PostQuitMessage(0); + return 0; + + case WM_LBUTTONDOWN: + InputBackend::on_mouse_down(MouseButton::Left); + return 0; + + case WM_LBUTTONUP: + InputBackend::on_mouse_up(MouseButton::Left); + return 0; + + case WM_RBUTTONDOWN: + InputBackend::on_mouse_down(MouseButton::Right); + return 0; + + case WM_RBUTTONUP: + InputBackend::on_mouse_up(MouseButton::Right); + return 0; + + case WM_MBUTTONDOWN: + InputBackend::on_mouse_down(MouseButton::Middle); + return 0; + + case WM_MBUTTONUP: + InputBackend::on_mouse_up(MouseButton::Middle); + return 0; + + case WM_MOUSEMOVE: + InputBackend::on_mouse_move((u16)(lParam), lParam >> 16); + return 0; + + case WM_KEYDOWN: + case WM_SYSKEYDOWN: + { + auto is_repeat = ((lParam & (1 << 30)) >> 30) == 1; + if (!is_repeat) + { + auto key = blah_scancode_to_key(wParam, lParam); + if (key != Key::Unknown) + InputBackend::on_key_down(key); + } + return 0; + } + + case WM_KEYUP: + case WM_SYSKEYUP: + { + auto key = blah_scancode_to_key(wParam, lParam); + if (key != Key::Unknown) + InputBackend::on_key_up(key); + return 0; + } + } + + return DefWindowProc(hwnd, msg, wParam, lParam); +} + +void PlatformBackend::frame() +{ + // Catch & Dispatch Window Messages + MSG msg; + while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } +} + +void PlatformBackend::sleep(int milliseconds) +{ + if (milliseconds > 0) + Sleep(milliseconds); +} + +void PlatformBackend::present() +{ + if (App::renderer() == Renderer::OpenGL) + { + HDC hdc = GetDC(g_hwnd); + SwapBuffers(hdc); + } +} + +const char* PlatformBackend::get_title() +{ + return nullptr; +} + +void PlatformBackend::set_title(const char* title) +{ + SetWindowText(g_hwnd, title); +} + +void PlatformBackend::get_position(int* x, int* y) +{ + RECT rect; + if (GetWindowRect(g_hwnd, &rect)) + { + *x = rect.left; + *y = rect.top; + } +} + +void PlatformBackend::set_position(int x, int y) +{ + int w, h; + get_size(&w, &h); + SetWindowPos(g_hwnd, NULL, x, y, w, h, 0); +} + +void PlatformBackend::set_fullscreen(bool enabled) +{ + if (g_fullscreen == enabled) + return; + + g_fullscreen = enabled; + + if (g_fullscreen) + { + GetWindowRect(g_hwnd, &g_windowed_position); + + int w = GetSystemMetrics(SM_CXSCREEN); + int h = GetSystemMetrics(SM_CYSCREEN); + SetWindowLongPtr(g_hwnd, GWL_STYLE, WS_VISIBLE | WS_POPUP); + SetWindowPos(g_hwnd, HWND_TOP, 0, 0, w, h, 0); + ShowWindow(g_hwnd, SW_SHOW); + } + else + { + SetWindowLongPtr(g_hwnd, GWL_STYLE, WS_OVERLAPPEDWINDOW); + SetWindowPos(g_hwnd, HWND_TOP, + g_windowed_position.left, + g_windowed_position.top, + g_windowed_position.right - g_windowed_position.left, + g_windowed_position.bottom - g_windowed_position.top, 0); + ShowWindow(g_hwnd, SW_SHOW); + } +} + +void PlatformBackend::get_size(int* width, int* height) +{ + RECT rect; + if (GetClientRect(g_hwnd, &rect)) + { + *width = rect.right - rect.left; + *height = rect.bottom - rect.top; + } +} + +void PlatformBackend::set_size(int width, int height) +{ + RECT client_rect; + RECT border_rect; + + GetClientRect(g_hwnd, &client_rect); + GetWindowRect(g_hwnd, &border_rect); + + int border_width = (border_rect.right - border_rect.left) - (client_rect.right - client_rect.left); + int border_height = (border_rect.bottom - border_rect.top) - (client_rect.bottom - client_rect.top); + + SetWindowPos(g_hwnd, NULL, border_rect.left, border_rect.top, width + border_width, height + border_height, 0); +} + +void PlatformBackend::get_draw_size(int* width, int* height) +{ + RECT rect; + if (GetClientRect(g_hwnd, &rect)) + { + *width = rect.right - rect.left; + *height = rect.bottom - rect.top; + } +} + +float PlatformBackend::get_content_scale() +{ + // base value of Windows DPI + // as seen here: https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdpiforwindow + constexpr float base_raw_value = 96.0f; + + UINT raw_value = GetDpiForWindow(g_hwnd); + + return (raw_value / base_raw_value); +} + +// FILE IO + +const char* PlatformBackend::app_path() +{ + return g_working_directory.cstr(); +} + +const char* PlatformBackend::user_path() +{ + return g_user_directory.cstr(); +} + +bool PlatformBackend::file_exists(const char* path) +{ + return fs::is_regular_file(path); +} + +bool PlatformBackend::file_delete(const char* path) +{ + return fs::remove(path); +} + +bool PlatformBackend::dir_create(const char* path) +{ + std::error_code error; + return fs::create_directories(path, error); +} + +bool PlatformBackend::dir_exists(const char* path) +{ + return fs::is_directory(path); +} + +bool PlatformBackend::dir_delete(const char* path) +{ + BLAH_ERROR("not implemented"); + return false; +} + +void PlatformBackend::dir_enumerate(Vector& list, const char* path, bool recursive) +{ + if (fs::is_directory(path)) + { + if (recursive) + { + for (auto& p : fs::recursive_directory_iterator(path)) + list.emplace_back(p.path().string().c_str()); + } + else + { + for (auto& p : fs::directory_iterator(path)) + list.emplace_back(p.path().string().c_str()); + } + } +} + +void PlatformBackend::dir_explore(const char* path) +{ + ShellExecute(NULL, "open", path, NULL, NULL, SW_SHOWDEFAULT); +} + +bool PlatformBackend::file_open(const char* path, PlatformBackend::FileHandle* handle, FileMode mode) +{ + int access = 0; + int creation = 0; + + if (((int)mode & (int)FileMode::Read) == (int)FileMode::Read) + { + access |= GENERIC_READ; + creation = OPEN_EXISTING; + } + + if (((int)mode & (int)FileMode::Write) == (int)FileMode::Write) + { + access |= GENERIC_WRITE; + creation = OPEN_ALWAYS; + } + + auto result = CreateFile(path, access, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL); + + if (result == INVALID_HANDLE_VALUE) + return false; + + *handle = result; + return true; +} + +i64 PlatformBackend::file_length(PlatformBackend::FileHandle handle) +{ + // Todo: cache this value? not sure how performant it is + + LARGE_INTEGER file_size; + if (GetFileSizeEx(handle, &file_size)) + return file_size.QuadPart; + + return 0; +} + +i64 PlatformBackend::file_position(PlatformBackend::FileHandle handle) +{ + // Todo: handle 64-bit values properly + // Todo: cache this value? not sure how performant it is + return SetFilePointer(handle, 0, NULL, FILE_CURRENT); +} + +i64 PlatformBackend::file_seek(PlatformBackend::FileHandle handle, i64 seekTo) +{ + // Todo: handle 64-bit values properly + return SetFilePointer(handle, seekTo, NULL, FILE_BEGIN); +} + +i64 PlatformBackend::file_read(PlatformBackend::FileHandle handle, void* ptr, i64 length) +{ + DWORD read = 0; + if (ReadFile(handle, ptr, length, &read, NULL)) + return read; + return 0; +} + +i64 PlatformBackend::file_write(PlatformBackend::FileHandle handle, const void* ptr, i64 length) +{ + DWORD written = 0; + if (WriteFile(handle, ptr, length, &written, NULL)) + return written; + return 0; +} + +void PlatformBackend::file_close(PlatformBackend::FileHandle handle) +{ + CloseHandle(handle); +} + +void* PlatformBackend::gl_get_func(const char* name) +{ + // this check is taken from https://www.khronos.org/opengl/wiki/Load_OpenGL_Functions + // wglGetProcAddress doesn't always return valid pointers for some specific methods? + + void* p = (void*)g_wglGetProcAddress(name); + if ((p == 0) || + (p == (void*)0x1) || + (p == (void*)0x2) || + (p == (void*)0x3) || + (p == (void*)-1)) + { + p = (void*)GetProcAddress(g_opengl_dll, name); + } + + return p; +} + +void* PlatformBackend::gl_context_create() +{ + HDC hdc = GetDC(g_hwnd); + return g_wglCreateContext(hdc); +} + +void PlatformBackend::gl_context_make_current(void* context) +{ + if (context != nullptr) + { + HDC hdc = GetDC(g_hwnd); + g_wglMakeCurrent(hdc, (HGLRC)context); + } + else + g_wglMakeCurrent(NULL, NULL); +} + +void PlatformBackend::gl_context_destroy(void* context) +{ + g_wglDeleteContext((HGLRC)context); +} + +void* PlatformBackend::d3d11_get_hwnd() +{ + return g_hwnd; +} + +Key blah_scancode_to_key(WPARAM wParam, LPARAM lParam) +{ + Key key = Key::Unknown; + + switch (wParam) + { + case VK_CANCEL: key = Key::Cancel; break; + case VK_BACK: key = Key::Backspace; break; + case VK_TAB: key = Key::Tab; break; + case VK_CLEAR: key = Key::Clear; break; + case VK_RETURN: key = Key::Enter; break; + case VK_SHIFT: key = Key::LeftShift; break; + case VK_CONTROL: key = Key::LeftControl; break; + case VK_MENU: key = Key::Menu; break; + case VK_PAUSE: key = Key::Pause; break; + case VK_CAPITAL: key = Key::Capslock; break; + case VK_ESCAPE: key = Key::Escape; break; + case VK_SPACE: key = Key::Space; break; + case VK_PRIOR: key = Key::Prior; break; + case VK_END: key = Key::End; break; + case VK_HOME: key = Key::Home; break; + case VK_LEFT: key = Key::Left; break; + case VK_UP: key = Key::Up; break; + case VK_RIGHT: key = Key::Right; break; + case VK_DOWN: key = Key::Down; break; + case VK_SELECT: key = Key::Select; break; + case VK_PRINT: key = Key::PrintScreen; break; + case VK_EXECUTE: key = Key::Execute; break; + case VK_SNAPSHOT: key = Key::PrintScreen; break; + case VK_INSERT: key = Key::Insert; break; + case VK_DELETE: key = Key::Delete; break; + case VK_HELP: key = Key::Help; break; + case VK_LWIN: key = Key::LeftOS; break; + case VK_RWIN: key = Key::RightOS; break; + case VK_APPS: key = Key::Application; break; + case VK_SLEEP: key = Key::Unknown; break; + case VK_NUMPAD0: key = Key::Keypad0; break; + case VK_NUMPAD1: key = Key::Keypad1; break; + case VK_NUMPAD2: key = Key::Keypad2; break; + case VK_NUMPAD3: key = Key::Keypad3; break; + case VK_NUMPAD4: key = Key::Keypad4; break; + case VK_NUMPAD5: key = Key::Keypad5; break; + case VK_NUMPAD6: key = Key::Keypad6; break; + case VK_NUMPAD7: key = Key::Keypad7; break; + case VK_NUMPAD8: key = Key::Keypad8; break; + case VK_NUMPAD9: key = Key::Keypad9; break; + case VK_F1: key = Key::F1; break; + case VK_F2: key = Key::F2; break; + case VK_F3: key = Key::F3; break; + case VK_F4: key = Key::F4; break; + case VK_F5: key = Key::F5; break; + case VK_F6: key = Key::F6; break; + case VK_F7: key = Key::F7; break; + case VK_F8: key = Key::F8; break; + case VK_F9: key = Key::F9; break; + case VK_F10: key = Key::F10; break; + case VK_F11: key = Key::F11; break; + case VK_F12: key = Key::F12; break; + case VK_F13: key = Key::F13; break; + case VK_F14: key = Key::F14; break; + case VK_F15: key = Key::F15; break; + case VK_F16: key = Key::F16; break; + case VK_F17: key = Key::F17; break; + case VK_F18: key = Key::F18; break; + case VK_F19: key = Key::F19; break; + case VK_F20: key = Key::F20; break; + case VK_F21: key = Key::F21; break; + case VK_F22: key = Key::F22; break; + case VK_F23: key = Key::F23; break; + case VK_F24: key = Key::F24; break; + case VK_NUMLOCK: key = Key::Numlock; break; + case VK_LSHIFT: key = Key::LeftShift; break; + case VK_RSHIFT: key = Key::RightShift; break; + case VK_LCONTROL: key = Key::LeftControl; break; + case VK_RCONTROL: key = Key::RightControl; break; + case VK_VOLUME_MUTE: key = Key::Mute; break; + case VK_VOLUME_DOWN: key = Key::VolumeDown; break; + case VK_VOLUME_UP: key = Key::VolumeUp; break; + } + + if (key == Key::Unknown) + { + int scancode = (lParam >> 16) & 0xFF; + + switch (scancode) + { + case 1: key = Key::Escape; break; + case 2: key = Key::D1; break; + case 3: key = Key::D2; break; + case 4: key = Key::D3; break; + case 5: key = Key::D4; break; + case 6: key = Key::D5; break; + case 7: key = Key::D6; break; + case 8: key = Key::D7; break; + case 9: key = Key::D8; break; + case 10: key = Key::D9; break; + case 11: key = Key::D0; break; + case 12: key = Key::Minus; break; + case 13: key = Key::Equals; break; + case 14: key = Key::Backspace; break; + case 15: key = Key::Tab; break; + case 16: key = Key::Q; break; + case 17: key = Key::W; break; + case 18: key = Key::E; break; + case 19: key = Key::R; break; + case 20: key = Key::T; break; + case 21: key = Key::Y; break; + case 22: key = Key::U; break; + case 23: key = Key::I; break; + case 24: key = Key::O; break; + case 25: key = Key::P; break; + case 26: key = Key::LeftBracket; break; + case 27: key = Key::RightBracket; break; + case 28: key = Key::Enter; break; + case 29: key = Key::LeftControl; break; + case 30: key = Key::A; break; + case 31: key = Key::S; break; + case 32: key = Key::D; break; + case 33: key = Key::F; break; + case 34: key = Key::G; break; + case 35: key = Key::H; break; + case 36: key = Key::J; break; + case 37: key = Key::K; break; + case 38: key = Key::L; break; + case 39: key = Key::Semicolon; break; + case 40: key = Key::Apostrophe; break; + case 41: key = Key::Tilde; break; + case 42: key = Key::LeftShift; break; + case 43: key = Key::Backslash; break; + case 44: key = Key::Z; break; + case 45: key = Key::X; break; + case 46: key = Key::C; break; + case 47: key = Key::V; break; + case 48: key = Key::B; break; + case 49: key = Key::N; break; + case 50: key = Key::M; break; + case 51: key = Key::Comma; break; + case 52: key = Key::Period; break; + case 53: key = Key::Slash; break; + case 54: key = Key::RightShift; break; + case 55: key = Key::PrintScreen; break; + case 56: key = Key::LeftAlt; break; + case 57: key = Key::Space; break; + case 58: key = Key::Capslock; break; + case 59: key = Key::F1; break; + case 60: key = Key::F2; break; + case 61: key = Key::F3; break; + case 62: key = Key::F4; break; + case 63: key = Key::F5; break; + case 64: key = Key::F6; break; + case 65: key = Key::F7; break; + case 66: key = Key::F8; break; + case 67: key = Key::F9; break; + case 68: key = Key::F10; break; + case 71: key = Key::Home; break; + case 72: key = Key::Up; break; + case 73: key = Key::PageUp; break; + case 74: key = Key::KeypadMinus; break; + case 75: key = Key::Left; break; + case 76: key = Key::Keypad5; break; + case 77: key = Key::Right; break; + case 78: key = Key::KeypadPlus; break; + case 79: key = Key::End; break; + case 80: key = Key::Down; break; + case 81: key = Key::PageDown; break; + case 82: key = Key::Insert; break; + case 83: key = Key::Delete; break; + case 87: key = Key::F11; break; + case 88: key = Key::F12; break; + case 89: key = Key::Pause; break; + case 91: key = Key::LeftOS; break; + case 92: key = Key::RightOS; break; + case 93: key = Key::Application; break; + case 100: key = Key::F13; break; + case 101: key = Key::F14; break; + case 102: key = Key::F15; break; + case 103: key = Key::F16; break; + case 104: key = Key::F17; break; + case 105: key = Key::F18; break; + case 106: key = Key::F19; break; + } + } + + return key; +} + +#endif // BLAH_PLATFORM_WINDOWS diff --git a/src/math/stopwatch.cpp b/src/math/stopwatch.cpp index baa1ab1..33191cb 100644 --- a/src/math/stopwatch.cpp +++ b/src/math/stopwatch.cpp @@ -19,7 +19,6 @@ u64 Stopwatch::milliseconds() return microseconds() / 1000; } - u64 Stopwatch::microseconds() { return std::chrono::duration_cast(system_clock::now().time_since_epoch()).count() - start_time;