lauchmelder/quark
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

add events for imgui

Browse source
This commit is contained in:
lauchmelder 2025-01-05 20:56:24 +01:00
parent 996c583520
commit 2b0f757fcb
19 changed files with 490 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitmodules vendored Normal file
View file

@ -0,0 +1,3 @@
[submodule "quark/vendor/imgui"]
path = quark/vendor/imgui
url = https://github.com/ocornut/imgui

16
quark/CMakeLists.txt
View file

@ -1,9 +1,7 @@
project(quark CXX)
FetchContent_MakeAvailable(spdlog)
FetchContent_MakeAvailable(glfw3)
add_subdirectory(glad)
FetchContent_MakeAvailable(spdlog glfw3)
add_subdirectory(vendor)
add_library(quark SHARED)
@ -15,6 +13,9 @@ target_sources(quark
src/quark/LayerStack.cpp
src/platform/linux/LinuxWindow.cpp
src/platform/glfw/IoTranslateGlfw.cpp
src/quark/imgui/ImGuiLayer.cpp
PUBLIC FILE_SET HEADERS
BASE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/src FILES
@ -32,7 +33,7 @@ target_sources(quark
src/quark/events/KeyEvent.hpp
src/quark/events/MouseEvent.hpp
src/platform/linux/LinuxWindow.hpp
src/quark/imgui/ImGuiLayer.hpp
)
target_include_directories(quark INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/src)
@ -42,10 +43,15 @@ target_precompile_headers(quark
src/qkpch.hpp
)
target_compile_definitions(quark
PUBLIC GLFW_INCLUDE_NONE
)
target_link_libraries(quark
spdlog::spdlog
glad
glfw
imgui
)
include(GNUInstallDirs)

8
quark/src/platform/IoTranslate.hpp Normal file
View file

@ -0,0 +1,8 @@
#pragma once
#include <imgui.h>
namespace qk {
ImGuiMouseButton TranslateMouseButton(int button);
int TranslateKey(int key);
}

140
quark/src/platform/glfw/IoTranslateGlfw.cpp Normal file
View file

@ -0,0 +1,140 @@
#include <imgui.h>
#include <GLFW/glfw3.h>
namespace qk {
ImGuiMouseButton TranslateMouseButton(int button) {
switch (button) {
case GLFW_MOUSE_BUTTON_LEFT: return ImGuiMouseButton_Left;
case GLFW_MOUSE_BUTTON_RIGHT: return ImGuiMouseButton_Right;
case GLFW_MOUSE_BUTTON_MIDDLE: return ImGuiMouseButton_Middle;
}
return button;
}
int TranslateKey(int key) {
switch (key) {
case GLFW_KEY_TAB: return ImGuiKey_Tab;
case GLFW_KEY_LEFT: return ImGuiKey_LeftArrow;
case GLFW_KEY_RIGHT: return ImGuiKey_RightArrow;
case GLFW_KEY_UP: return ImGuiKey_UpArrow;
case GLFW_KEY_DOWN: return ImGuiKey_DownArrow;
case GLFW_KEY_PAGE_UP: return ImGuiKey_PageUp;
case GLFW_KEY_PAGE_DOWN: return ImGuiKey_PageDown;
case GLFW_KEY_HOME: return ImGuiKey_Home;
case GLFW_KEY_END: return ImGuiKey_End;
case GLFW_KEY_INSERT: return ImGuiKey_Insert;
case GLFW_KEY_DELETE: return ImGuiKey_Delete;
case GLFW_KEY_BACKSPACE: return ImGuiKey_Backspace;
case GLFW_KEY_SPACE: return ImGuiKey_Space;
case GLFW_KEY_ENTER: return ImGuiKey_Enter;
case GLFW_KEY_ESCAPE: return ImGuiKey_Escape;
case GLFW_KEY_LEFT_CONTROL: return (ImGuiKey)(ImGuiKey_LeftCtrl | ImGuiMod_Ctrl);
case GLFW_KEY_LEFT_SHIFT: return (ImGuiKey)(ImGuiKey_LeftShift | ImGuiMod_Shift);
case GLFW_KEY_LEFT_ALT: return (ImGuiKey)(ImGuiKey_LeftAlt | ImGuiMod_Alt);
case GLFW_KEY_LEFT_SUPER: return (ImGuiKey)(ImGuiKey_LeftSuper | ImGuiMod_Super);
case GLFW_KEY_RIGHT_CONTROL: return (ImGuiKey)(ImGuiKey_RightCtrl | ImGuiMod_Ctrl);
case GLFW_KEY_RIGHT_SHIFT: return (ImGuiKey)(ImGuiKey_RightShift | ImGuiMod_Shift);
case GLFW_KEY_RIGHT_ALT: return (ImGuiKey)(ImGuiKey_RightAlt | ImGuiMod_Alt);
case GLFW_KEY_RIGHT_SUPER: return (ImGuiKey)(ImGuiKey_RightSuper | ImGuiMod_Super);
case GLFW_KEY_MENU: return ImGuiKey_Menu;
case GLFW_KEY_0: return ImGuiKey_0;
case GLFW_KEY_1: return ImGuiKey_1;
case GLFW_KEY_2: return ImGuiKey_2;
case GLFW_KEY_3: return ImGuiKey_3;
case GLFW_KEY_4: return ImGuiKey_4;
case GLFW_KEY_5: return ImGuiKey_5;
case GLFW_KEY_6: return ImGuiKey_6;
case GLFW_KEY_7: return ImGuiKey_7;
case GLFW_KEY_8: return ImGuiKey_8;
case GLFW_KEY_9: return ImGuiKey_9;
case GLFW_KEY_A: return ImGuiKey_A;
case GLFW_KEY_B: return ImGuiKey_B;
case GLFW_KEY_C: return ImGuiKey_C;
case GLFW_KEY_D: return ImGuiKey_D;
case GLFW_KEY_E: return ImGuiKey_E;
case GLFW_KEY_F: return ImGuiKey_F;
case GLFW_KEY_G: return ImGuiKey_G;
case GLFW_KEY_H: return ImGuiKey_H;
case GLFW_KEY_I: return ImGuiKey_I;
case GLFW_KEY_J: return ImGuiKey_J;
case GLFW_KEY_K: return ImGuiKey_K;
case GLFW_KEY_L: return ImGuiKey_L;
case GLFW_KEY_M: return ImGuiKey_M;
case GLFW_KEY_N: return ImGuiKey_N;
case GLFW_KEY_O: return ImGuiKey_O;
case GLFW_KEY_P: return ImGuiKey_P;
case GLFW_KEY_Q: return ImGuiKey_Q;
case GLFW_KEY_R: return ImGuiKey_R;
case GLFW_KEY_S: return ImGuiKey_S;
case GLFW_KEY_T: return ImGuiKey_T;
case GLFW_KEY_U: return ImGuiKey_U;
case GLFW_KEY_V: return ImGuiKey_V;
case GLFW_KEY_W: return ImGuiKey_W;
case GLFW_KEY_X: return ImGuiKey_X;
case GLFW_KEY_Y: return ImGuiKey_Y;
case GLFW_KEY_Z: return ImGuiKey_Z;
case GLFW_KEY_F1: return ImGuiKey_F1;
case GLFW_KEY_F2: return ImGuiKey_F2;
case GLFW_KEY_F3: return ImGuiKey_F3;
case GLFW_KEY_F4: return ImGuiKey_F4;
case GLFW_KEY_F5: return ImGuiKey_F5;
case GLFW_KEY_F6: return ImGuiKey_F6;
case GLFW_KEY_F7: return ImGuiKey_F7;
case GLFW_KEY_F8: return ImGuiKey_F8;
case GLFW_KEY_F9: return ImGuiKey_F9;
case GLFW_KEY_F10: return ImGuiKey_F10;
case GLFW_KEY_F11: return ImGuiKey_F11;
case GLFW_KEY_F12: return ImGuiKey_F12;
case GLFW_KEY_F13: return ImGuiKey_F13;
case GLFW_KEY_F14: return ImGuiKey_F14;
case GLFW_KEY_F15: return ImGuiKey_F15;
case GLFW_KEY_F16: return ImGuiKey_F16;
case GLFW_KEY_F17: return ImGuiKey_F17;
case GLFW_KEY_F18: return ImGuiKey_F18;
case GLFW_KEY_F19: return ImGuiKey_F19;
case GLFW_KEY_F20: return ImGuiKey_F20;
case GLFW_KEY_F21: return ImGuiKey_F21;
case GLFW_KEY_F22: return ImGuiKey_F22;
case GLFW_KEY_F23: return ImGuiKey_F23;
case GLFW_KEY_F24: return ImGuiKey_F24;
case GLFW_KEY_APOSTROPHE: return ImGuiKey_Apostrophe;
case GLFW_KEY_COMMA: return ImGuiKey_Comma;
case GLFW_KEY_MINUS: return ImGuiKey_Minus;
case GLFW_KEY_PERIOD: return ImGuiKey_Period;
case GLFW_KEY_SLASH: return ImGuiKey_Slash;
case GLFW_KEY_SEMICOLON: return ImGuiKey_Semicolon;
case GLFW_KEY_EQUAL: return ImGuiKey_Equal;
case GLFW_KEY_LEFT_BRACKET: return ImGuiKey_LeftBracket;
case GLFW_KEY_BACKSLASH: return ImGuiKey_Backslash;
case GLFW_KEY_RIGHT_BRACKET: return ImGuiKey_RightBracket;
case GLFW_KEY_GRAVE_ACCENT: return ImGuiKey_GraveAccent;
case GLFW_KEY_CAPS_LOCK: return ImGuiKey_CapsLock;
case GLFW_KEY_SCROLL_LOCK: return ImGuiKey_ScrollLock;
case GLFW_KEY_NUM_LOCK: return ImGuiKey_NumLock;
case GLFW_KEY_PRINT_SCREEN: return ImGuiKey_PrintScreen;
case GLFW_KEY_PAUSE: return ImGuiKey_Pause;
case GLFW_KEY_KP_0: return ImGuiKey_Keypad0;
case GLFW_KEY_KP_1: return ImGuiKey_Keypad1;
case GLFW_KEY_KP_2: return ImGuiKey_Keypad2;
case GLFW_KEY_KP_3: return ImGuiKey_Keypad3;
case GLFW_KEY_KP_4: return ImGuiKey_Keypad4;
case GLFW_KEY_KP_5: return ImGuiKey_Keypad5;
case GLFW_KEY_KP_6: return ImGuiKey_Keypad6;
case GLFW_KEY_KP_7: return ImGuiKey_Keypad7;
case GLFW_KEY_KP_8: return ImGuiKey_Keypad8;
case GLFW_KEY_KP_9: return ImGuiKey_Keypad9;
case GLFW_KEY_KP_DECIMAL: return ImGuiKey_KeypadDecimal;
case GLFW_KEY_KP_DIVIDE: return ImGuiKey_KeypadDivide;
case GLFW_KEY_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
case GLFW_KEY_KP_SUBTRACT: return ImGuiKey_KeypadSubtract;
case GLFW_KEY_KP_ADD: return ImGuiKey_KeypadAdd;
case GLFW_KEY_KP_ENTER: return ImGuiKey_KeypadEnter;
case GLFW_KEY_KP_EQUAL: return ImGuiKey_KeypadEqual;
}
return ImGuiKey_None;
}
}

15
quark/src/platform/linux/LinuxWindow.cpp
View file

@ -1,4 +1,5 @@
#include "LinuxWindow.hpp"
#include "imgui.h"
#include "quark/Core.hpp"
#include "quark/Logger.hpp"
#include "quark/events/ApplicationEvent.hpp"
@ -6,6 +7,7 @@
#include "quark/events/MouseEvent.hpp"
#include <GLFW/glfw3.h>
#include <glad/gl.h>
namespace qk {
static bool GLFWInitialized = false;
@ -46,6 +48,12 @@ namespace qk {
window = glfwCreateWindow((int)config.width, (int)config.height, config.title.c_str(), nullptr, nullptr);
glfwMakeContextCurrent(window);
int version = gladLoadGL(glfwGetProcAddress);
QK_CORE_ASSERT(version, "Failed to load OpenGL");
QK_CORE_INFO("Loaded OpenGL {0}.{1}", GLAD_VERSION_MAJOR(version), GLAD_VERSION_MINOR(version));
glfwSetWindowUserPointer(window, &data);
InstallGLFWCallbacks();
@ -97,6 +105,13 @@ namespace qk {
}
});
glfwSetCharCallback(window, [] (GLFWwindow* window, unsigned int key) {
WindowData* data = reinterpret_cast<WindowData*>(glfwGetWindowUserPointer(window));
KeyTypedEvent event(key);
data->eventCallback(event);
});
glfwSetMouseButtonCallback(window, [] (GLFWwindow* window, int button, int action, int modes) {
WindowData* data = reinterpret_cast<WindowData*>(glfwGetWindowUserPointer(window));

5
quark/src/platform/linux/LinuxWindow.hpp
View file

@ -1,7 +1,6 @@
#pragma once
#include <GLFW/glfw3.h>
#include "quark/Window.hpp"
namespace qk {
@ -22,8 +21,8 @@ namespace qk {
bool HasVSync() const override;
private:
virtual void Init(const WindowConfig& config);
virtual void Destroy();
void Init(const WindowConfig& config);
void Destroy();
void InstallGLFWCallbacks();

7
quark/src/quark/Application.cpp
View file

@ -1,10 +1,13 @@
#include "Application.hpp"
#include "quark.hpp"
#include "quark/Core.hpp"
#include <spdlog/spdlog.h>
namespace qk {
Application::Application() {
QK_CORE_ASSERT(instance == nullptr, "Application already exists");
instance = this;
window = Window::Create();
window->SetEventCallback(std::bind(&Application::OnEvent, this, std::placeholders::_1));
}
@ -35,10 +38,12 @@ namespace qk {
void Application::PushLayer(Layer* layer) {
layers.PushLayer(layer);
layer->OnAttach();
}
void Application::PushOverlay(Layer* layer) {
layers.PushOverlay(layer);
layer->OnAttach();
}
bool Application::OnWindowClose(WindowCloseEvent& e) {

12
quark/src/quark/Application.hpp
View file

@ -20,6 +20,8 @@ namespace qk {
void PushLayer(Layer* layer);
void PushOverlay(Layer* layer);
inline Window& GetWindow() { return *window; };
private:
bool OnWindowClose(WindowCloseEvent& e);
@ -28,8 +30,16 @@ namespace qk {
bool isRunning = true;
LayerStack layers;
public:
static Application& GetInstance() {
return *instance;
}
private:
inline static Application* instance = nullptr;
};
std::unique_ptr<qk::Application> CreateApplication();
Application* CreateApplication();
}

2
quark/src/quark/Core.hpp
View file

@ -1,8 +1,8 @@
#pragma once
#ifndef NDEBUG
# include <signal.h>
# include "quark/Logger.hpp"
# define _LINE_TO_STR(x) #x
# define LINE_TO_STR(x) _LINE_TO_STR(x)
# define QK_ASSERT(x, ...) { if (!(x)) { QK_CRITICAL(__FILE__ ":" LINE_TO_STR(__LINE__) ": Assertion failed: {0}", __VA_ARGS__); raise(SIGTRAP); } }

4
quark/src/quark/Entrypoint.cpp
View file

@ -1,13 +1,13 @@
#include "Application.hpp"
#include "Logger.hpp"
extern std::unique_ptr<qk::Application> qk::CreateApplication();
extern qk::Application* qk::CreateApplication();
int main(int argc, char** argv) {
qk::Logger::Init();
QK_CORE_INFO("Logger initialised");
auto application = qk::CreateApplication();
qk::Application* application = qk::CreateApplication();
application->Run();
return 0;

3
quark/src/quark/events/Event.hpp
View file

@ -5,6 +5,8 @@
#include <fmt/ostream.h>
#include <type_traits>
#define BIND_EVENT_CB(cb) std::bind(&cb, this, std::placeholders::_1)
namespace qk {
enum class EventType {
None = 0,
@ -16,6 +18,7 @@ namespace qk {
WindowMoved,
KeyPressed,
KeyTyped,
KeyReleased,
MouseButtonPressed,

19
quark/src/quark/events/KeyEvent.hpp
View file

@ -42,6 +42,25 @@ namespace qk {
int repeatCount;
};
class KeyTypedEvent
: public KeyEvent
{
public:
KeyTypedEvent(int keyCode) :
KeyEvent(keyCode)
{ }
virtual operator std::string() const override {
std::stringstream ss;
ss << "KeyTypedEvent: " << keyCode;
return ss.str();
}
EVENT_CLASS_TYPE(KeyTyped)
private:
};
class KeyReleasedEvent
: public KeyEvent
{

3
quark/src/quark/events/MouseEvent.hpp
View file

@ -36,6 +36,9 @@ namespace qk {
offsetX(offsetX), offsetY(offsetY)
{ }
inline float GetX() const { return offsetX; }
inline float GetY() const { return offsetY; }
virtual operator std::string() const override {
std::stringstream ss;
ss << "MouseScrolledEvent: " << offsetX << ", " << offsetY;

181
quark/src/quark/imgui/ImGuiLayer.cpp Normal file
View file

@ -0,0 +1,181 @@
#include "ImGuiLayer.hpp"
// TODO: Remove these, these are temporary
#include <glad/gl.h>
#include <GLFW/glfw3.h>
#include <imgui.h>
#include <backends/imgui_impl_opengl3.h>
#include <quark.hpp>
#include "platform/IoTranslate.hpp"
#include "quark/Application.hpp"
#include "quark/events/Event.hpp"
namespace qk {
ImGuiLayer::ImGuiLayer() :
Layer("ImGui Quark")
{
}
ImGuiLayer::~ImGuiLayer() {
}
void ImGuiLayer::OnAttach() {
ImGui::CreateContext();
ImGui::StyleColorsDark();
ImGuiIO& io = ImGui::GetIO();
Application& app = Application::GetInstance();
io.DisplaySize = ImVec2(app.GetWindow().GetWidth(), app.GetWindow().GetHeight());
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;
// io.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports;
// io.BackendFlags |= ImGuiBackendFlags_RendererHasViewports;
io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
// io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
ImGui_ImplOpenGL3_Init("#version 410");
}
void ImGuiLayer::OnDetach() {
}
void ImGuiLayer::OnUpdate() {
ImGui_ImplOpenGL3_NewFrame();
ImGui::NewFrame();
float time = (float)glfwGetTime();
ImGui::GetIO().DeltaTime = (lastTime > 0.0f) ? (time - lastTime) : (1.0f / 60.0f);
lastTime = time;
static bool show = true;
ImGui::ShowDemoWindow(&show);
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
}
void ImGuiLayer::OnEvent(Event& event) {
EventDispatcher dispatcher(event);
dispatcher.Dispatch<MouseButtonPressedEvent>(BIND_EVENT_CB(ImGuiLayer::OnMouseButtonPressed));
dispatcher.Dispatch<MouseButtonReleasedEvent>(BIND_EVENT_CB(ImGuiLayer::OnMouseButtonReleased));
dispatcher.Dispatch<MouseMovedEvent>(BIND_EVENT_CB(ImGuiLayer::OnMouseMoved));
dispatcher.Dispatch<MouseScrolledEvent>(BIND_EVENT_CB(ImGuiLayer::OnMouseScrolled));
dispatcher.Dispatch<KeyPressedEvent>(BIND_EVENT_CB(ImGuiLayer::OnKeyPressedEvent));
dispatcher.Dispatch<KeyReleasedEvent>(BIND_EVENT_CB(ImGuiLayer::OnKeyReleasedEvent));
dispatcher.Dispatch<KeyTypedEvent>(BIND_EVENT_CB(ImGuiLayer::OnKeyTypedEvent));
dispatcher.Dispatch<WindowResizeEvent>(BIND_EVENT_CB(ImGuiLayer::OnWindowResized));
}
bool ImGuiLayer::OnMouseButtonPressed(MouseButtonPressedEvent& e) {
ImGuiIO& io = ImGui::GetIO();
io.AddMouseButtonEvent(TranslateMouseButton(e.GetMouseButton()), true);
return false;
}
bool ImGuiLayer::OnMouseButtonReleased(MouseButtonReleasedEvent& e) {
ImGuiIO& io = ImGui::GetIO();
io.AddMouseButtonEvent(TranslateMouseButton(e.GetMouseButton()), false);
return false;
}
bool ImGuiLayer::OnMouseMoved(MouseMovedEvent& e) {
ImGuiIO& io = ImGui::GetIO();
io.AddMousePosEvent(e.GetX(), e.GetY());
return false;
}
bool ImGuiLayer::OnMouseScrolled(MouseScrolledEvent& e) {
ImGuiIO& io = ImGui::GetIO();
io.AddMouseWheelEvent(e.GetX(), e.GetY());
return false;
}
bool ImGuiLayer::OnKeyPressedEvent(KeyPressedEvent& e) {
ImGuiIO& io = ImGui::GetIO();
int key = TranslateKey(e.GetKeyCode());
int mod = ImGuiMod_Mask_ & key;
if ((mod & ImGuiMod_Ctrl) != 0) {
io.AddKeyEvent(ImGuiMod_Ctrl, true);
}
if ((mod & ImGuiMod_Shift) != 0) {
io.AddKeyEvent(ImGuiMod_Shift, true);
}
if ((mod & ImGuiMod_Alt) != 0) {
io.AddKeyEvent(ImGuiMod_Alt, true);
}
if ((mod & ImGuiMod_Super) != 0) {
io.AddKeyEvent(ImGuiMod_Super, true);
}
io.AddKeyEvent((ImGuiKey)(key & ~ImGuiMod_Mask_), true);
return false;
}
bool ImGuiLayer::OnKeyReleasedEvent(KeyReleasedEvent& e) {
ImGuiIO& io = ImGui::GetIO();
int key = TranslateKey(e.GetKeyCode());
int mod = ImGuiMod_Mask_ & key;
if ((mod & ImGuiMod_Ctrl) != 0) {
io.AddKeyEvent(ImGuiMod_Ctrl, false);
}
if ((mod & ImGuiMod_Shift) != 0) {
io.AddKeyEvent(ImGuiMod_Shift, false);
}
if ((mod & ImGuiMod_Alt) != 0) {
io.AddKeyEvent(ImGuiMod_Alt, false);
}
if ((mod & ImGuiMod_Super) != 0) {
io.AddKeyEvent(ImGuiMod_Super, false);
}
io.AddKeyEvent((ImGuiKey)(key & ~ImGuiMod_Mask_), false);
return false;
}
bool ImGuiLayer::OnKeyTypedEvent(KeyTypedEvent& e) {
ImGuiIO& io = ImGui::GetIO();
int c = e.GetKeyCode();
if (c > 0 && c < 0x10000) {
io.AddInputCharacter(c);
}
return false;
}
bool ImGuiLayer::OnWindowResized(WindowResizeEvent& e) {
ImGuiIO& io = ImGui::GetIO();
io.DisplaySize = ImVec2(e.GetWidth(), e.GetHeight());
io.DisplayFramebufferScale = ImVec2(1.f, 1.f);
glViewport(0, 0, e.GetWidth(), e.GetHeight());
return false;
}
}

38
quark/src/quark/imgui/ImGuiLayer.hpp Normal file
View file

@ -0,0 +1,38 @@
#pragma once
#include "quark/Layer.hpp"
#include "quark/events/Event.hpp"
#include "quark/events/MouseEvent.hpp"
#include "quark/events/KeyEvent.hpp"
#include "quark/events/ApplicationEvent.hpp"
namespace qk {
class ImGuiLayer :
public Layer
{
public:
ImGuiLayer();
~ImGuiLayer();
void OnAttach() override;
void OnDetach() override;
void OnUpdate() override;
void OnEvent(Event& event) override;
private:
bool OnMouseButtonPressed(MouseButtonPressedEvent& e);
bool OnMouseButtonReleased(MouseButtonReleasedEvent& e);
bool OnMouseMoved(MouseMovedEvent& e);
bool OnMouseScrolled(MouseScrolledEvent& e);
bool OnKeyPressedEvent(KeyPressedEvent& e);
bool OnKeyReleasedEvent(KeyReleasedEvent& e);
bool OnKeyTypedEvent(KeyTypedEvent& e);
bool OnWindowResized(WindowResizeEvent& e);
private:
float lastTime = 0.0f;
};
}

41
quark/vendor/CMakeLists.txt vendored Normal file
View file

@ -0,0 +1,41 @@
########################
# GLAD
########################
add_library(glad
glad/src/gl.c
)
target_include_directories(glad
PUBLIC glad/include
)
set_property(
TARGET glad
PROPERTY POSITION_INDEPENDENT_CODE ON
)
########################
# ImGui
########################
add_library(imgui
imgui/imgui.cpp
imgui/imgui_draw.cpp
imgui/imgui_tables.cpp
imgui/imgui_widgets.cpp
imgui/imgui_demo.cpp
# TODO: this is shit
imgui/backends/imgui_impl_opengl3.cpp
)
target_include_directories(imgui
PUBLIC imgui
)
set_property(
TARGET imgui
PROPERTY POSITION_INDEPENDENT_CODE ON
)

7
quark/vendor/glad/CMakeLists.txt vendored
View file

@ -1,7 +0,0 @@
add_library(glad
src/gl.c
)
target_include_directories(glad
PUBLIC include
)

1
quark/vendor/imgui vendored Submodule

@ -0,0 +1 @@
Subproject commit eb642a9535055eacca6c6f7f7310fb5b41a96424

9
sandbox/src/Application.cpp
View file

@ -1,5 +1,5 @@
#include <memory>
#include <quark.hpp>
#include "quark/imgui/ImGuiLayer.hpp"
class ExampleLayer :
public qk::Layer
@ -10,7 +10,7 @@ public:
{ }
void OnUpdate() override {
QK_TRACE("ExampleLayer::Update");
// QK_TRACE("ExampleLayer::Update");
}
void OnEvent(qk::Event& event) override {
@ -24,9 +24,10 @@ class Sandbox :
public:
Sandbox() {
PushLayer(new ExampleLayer);
PushOverlay(new qk::ImGuiLayer);
}
};
std::unique_ptr<qk::Application> qk::CreateApplication() {
return std::make_unique<Sandbox>();
qk::Application* qk::CreateApplication() {
return new Sandbox;
}