sylar/OmniaFramework
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Streamlined the Signal System

Browse source
This commit is contained in:
OmniaX-Dev 2026-04-04 01:38:44 +02:00
parent 92089ed177
commit 41abab36aa
18 changed files with 127 additions and 248 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
other/build.nr
View file

@ -1 +1 @@
2040 2041

36
src/ogfx/gui/RawTextInput.cpp
View file

@ -28,20 +28,20 @@ namespace ogfx
{ {
RawTextInput::EventListener::EventListener(RawTextInput& _parent) : parent(_parent) RawTextInput::EventListener::EventListener(RawTextInput& _parent) : parent(_parent)
{ {
connectSignal(ostd::tBuiltinSignals::KeyPressed); connectSignal(ostd::BuiltinSignals::KeyPressed);
connectSignal(ostd::tBuiltinSignals::KeyReleased); connectSignal(ostd::BuiltinSignals::KeyReleased);
connectSignal(ostd::tBuiltinSignals::TextEntered); connectSignal(ostd::BuiltinSignals::TextEntered);
connectSignal(ostd::tBuiltinSignals::MouseDragged); connectSignal(ostd::BuiltinSignals::MouseDragged);
connectSignal(ostd::tBuiltinSignals::MouseMoved); connectSignal(ostd::BuiltinSignals::MouseMoved);
connectSignal(ostd::tBuiltinSignals::MousePressed); connectSignal(ostd::BuiltinSignals::MousePressed);
connectSignal(ostd::tBuiltinSignals::MouseReleased); connectSignal(ostd::BuiltinSignals::MouseReleased);
connectSignal(ostd::tBuiltinSignals::OnGuiEvent); connectSignal(ostd::BuiltinSignals::OnGuiEvent);
connectSignal(ostd::tBuiltinSignals::WindowResized); connectSignal(ostd::BuiltinSignals::WindowResized);
} }
void RawTextInput::EventListener::handleSignal(ostd::tSignal& signal) void RawTextInput::EventListener::handleSignal(ostd::Signal& signal)
{ {
if (signal.ID == ostd::tBuiltinSignals::TextEntered) if (signal.ID == ostd::BuiltinSignals::TextEntered)
{ {
if (m_lastEvent != eEventType::TextEntered) if (m_lastEvent != eEventType::TextEntered)
{ {
@ -75,7 +75,7 @@ namespace ogfx
parent.m_cursorState = true; parent.m_cursorState = true;
} }
} }
else if (signal.ID == ostd::tBuiltinSignals::KeyPressed) else if (signal.ID == ostd::BuiltinSignals::KeyPressed)
{ {
if (m_lastEvent != eEventType::KeyPressed) if (m_lastEvent != eEventType::KeyPressed)
{ {
@ -132,17 +132,17 @@ namespace ogfx
parent.m_keyRepeatCounter.start(); parent.m_keyRepeatCounter.start();
parent.m_lastKeyCode = data.keyCode; parent.m_lastKeyCode = data.keyCode;
ActionEventData aed(parent, parent.getName(), eActionEventType::Enter, ostd::BaseObject::InvalidRef()); ActionEventData aed(parent, parent.getName(), eActionEventType::Enter, ostd::BaseObject::InvalidRef());
ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::tSignalPriority::RealTime, aed); ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::Signal::Priority::RealTime, aed);
} }
else if (data.keyCode == SDLK_TAB) else if (data.keyCode == SDLK_TAB)
{ {
parent.m_keyRepeatCounter.start(); parent.m_keyRepeatCounter.start();
parent.m_lastKeyCode = data.keyCode; parent.m_lastKeyCode = data.keyCode;
ActionEventData aed(parent, parent.getName(), eActionEventType::Tab, ostd::BaseObject::InvalidRef()); ActionEventData aed(parent, parent.getName(), eActionEventType::Tab, ostd::BaseObject::InvalidRef());
ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::tSignalPriority::RealTime, aed); ostd::SignalHandler::emitSignal(RawTextInput::actionEventSignalID, ostd::Signal::Priority::RealTime, aed);
} }
} }
else if (signal.ID == ostd::tBuiltinSignals::MouseMoved) else if (signal.ID == ostd::BuiltinSignals::MouseMoved)
{ {
auto& data = (ogfx::MouseEventData&)signal.userData; auto& data = (ogfx::MouseEventData&)signal.userData;
if (parent.contains((float)data.position_x, (float)data.position_y)) if (parent.contains((float)data.position_x, (float)data.position_y))
@ -150,7 +150,7 @@ namespace ogfx
else else
parent.m_mouseInside = false; parent.m_mouseInside = false;
} }
else if (signal.ID == ostd::tBuiltinSignals::MousePressed) else if (signal.ID == ostd::BuiltinSignals::MousePressed)
{ {
auto& data = (ogfx::MouseEventData&)signal.userData; auto& data = (ogfx::MouseEventData&)signal.userData;
if (data.button == ogfx::MouseEventData::eButton::Left && parent.m_gfx != nullptr && parent.m_mouseInside) if (data.button == ogfx::MouseEventData::eButton::Left && parent.m_gfx != nullptr && parent.m_mouseInside)
@ -284,9 +284,9 @@ namespace ogfx
void RawTextInputEventListener::onSignalHandled(ostd::tSignal& signal) void RawTextInputEventListener::onSignalHandled(ostd::Signal& signal)
{ {
if (signal.ID == ostd::tBuiltinSignals::MouseMoved) if (signal.ID == ostd::BuiltinSignals::MouseMoved)
{ {
auto& data = (ogfx::MouseEventData&)signal.userData; auto& data = (ogfx::MouseEventData&)signal.userData;
if (getParent().isMouseInside()) if (getParent().isMouseInside())

6
src/ogfx/gui/RawTextInput.hpp
View file

@ -34,8 +34,8 @@ namespace ogfx
public: enum class eEventType { None = 0, TextEntered, KeyPressed, KeyReleased }; public: enum class eEventType { None = 0, TextEntered, KeyPressed, KeyReleased };
public: public:
EventListener(RawTextInput& _parent); EventListener(RawTextInput& _parent);
virtual void handleSignal(ostd::tSignal& signal) override; virtual void handleSignal(ostd::Signal& signal) override;
inline virtual void onSignalHandled(ostd::tSignal& signal) { } inline virtual void onSignalHandled(ostd::Signal& signal) { }
inline RawTextInput& getParent(void) { return parent; } inline RawTextInput& getParent(void) { return parent; }
private: private:
@ -171,7 +171,7 @@ namespace ogfx
{ {
public: public:
inline RawTextInputEventListener(ogfx::gui::RawTextInput& _parent, ogfx::WindowCore& _window) : ogfx::gui::RawTextInput::EventListener::EventListener(_parent), window(_window) { } inline RawTextInputEventListener(ogfx::gui::RawTextInput& _parent, ogfx::WindowCore& _window) : ogfx::gui::RawTextInput::EventListener::EventListener(_parent), window(_window) { }
void onSignalHandled(ostd::tSignal& signal) override; void onSignalHandled(ostd::Signal& signal) override;
public: public:
ogfx::WindowCore& window; ogfx::WindowCore& window;

73
src/ogfx/gui/Window.cpp
View file

@ -71,18 +71,18 @@ namespace ogfx
validate(); validate();
setSize(m_windowWidth, m_windowHeight); setSize(m_windowWidth, m_windowHeight);
connectSignal(ostd::tBuiltinSignals::KeyPressed); connectSignal(ostd::BuiltinSignals::KeyPressed);
connectSignal(ostd::tBuiltinSignals::KeyReleased); connectSignal(ostd::BuiltinSignals::KeyReleased);
connectSignal(ostd::tBuiltinSignals::TextEntered); connectSignal(ostd::BuiltinSignals::TextEntered);
connectSignal(ostd::tBuiltinSignals::MousePressed); connectSignal(ostd::BuiltinSignals::MousePressed);
connectSignal(ostd::tBuiltinSignals::MouseReleased); connectSignal(ostd::BuiltinSignals::MouseReleased);
connectSignal(ostd::tBuiltinSignals::MouseMoved); connectSignal(ostd::BuiltinSignals::MouseMoved);
connectSignal(ostd::tBuiltinSignals::MouseMoved); connectSignal(ostd::BuiltinSignals::MouseMoved);
connectSignal(ostd::tBuiltinSignals::OnGuiEvent); connectSignal(ostd::BuiltinSignals::OnGuiEvent);
connectSignal(ostd::tBuiltinSignals::WindowClosed); connectSignal(ostd::BuiltinSignals::WindowClosed);
connectSignal(ostd::tBuiltinSignals::WindowResized); connectSignal(ostd::BuiltinSignals::WindowResized);
connectSignal(ostd::tBuiltinSignals::WindowFocused); connectSignal(ostd::BuiltinSignals::WindowFocused);
connectSignal(ostd::tBuiltinSignals::WindowLostFocus); connectSignal(ostd::BuiltinSignals::WindowLostFocus);
__on_window_init(width, height, title); __on_window_init(width, height, title);
} }
@ -97,14 +97,14 @@ namespace ogfx
{ {
__on_window_close(); __on_window_close();
m_running = false; m_running = false;
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowClosed, ostd::tSignalPriority::Normal, *this); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowClosed, ostd::Signal::Priority::Normal, *this);
} }
void WindowCore::setSize(int32_t width, int32_t height) void WindowCore::setSize(int32_t width, int32_t height)
{ {
if (!isInitialized()) return; if (!isInitialized()) return;
SDL_SetWindowSize(m_window, width, height); SDL_SetWindowSize(m_window, width, height);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowResized, ostd::tSignalPriority::RealTime); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowResized, ostd::Signal::Priority::RealTime);
} }
void WindowCore::setTitle(const ostd::String& title) void WindowCore::setTitle(const ostd::String& title)
@ -166,7 +166,7 @@ namespace ogfx
SDL_PushEvent(&e); SDL_PushEvent(&e);
} }
void WindowCore::handleSignal(ostd::tSignal& signal) void WindowCore::handleSignal(ostd::Signal& signal)
{ {
__on_signal(signal); __on_signal(signal);
} }
@ -215,6 +215,7 @@ namespace ogfx
void WindowCore::after_render(void) void WindowCore::after_render(void)
{ {
SDL_RenderPresent(m_renderer); SDL_RenderPresent(m_renderer);
ostd::SignalHandler::handleDelegateSignals();
} }
void WindowCore::__handle_event(SDL_Event& event) void WindowCore::__handle_event(SDL_Event& event)
@ -229,11 +230,11 @@ namespace ogfx
} }
else if (event.type == SDL_EVENT_WINDOW_FOCUS_GAINED) else if (event.type == SDL_EVENT_WINDOW_FOCUS_GAINED)
{ {
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowFocused, ostd::tSignalPriority::RealTime, *this); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowFocused, ostd::Signal::Priority::RealTime, *this);
} }
else if (event.type == SDL_EVENT_WINDOW_FOCUS_LOST) else if (event.type == SDL_EVENT_WINDOW_FOCUS_LOST)
{ {
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowLostFocus, ostd::tSignalPriority::RealTime, *this); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowLostFocus, ostd::Signal::Priority::RealTime, *this);
} }
else if (event.type == SDL_EVENT_WINDOW_RESIZED) else if (event.type == SDL_EVENT_WINDOW_RESIZED)
{ {
@ -241,17 +242,17 @@ namespace ogfx
SDL_GetWindowSize(m_window, &m_windowWidth, &m_windowHeight); SDL_GetWindowSize(m_window, &m_windowWidth, &m_windowHeight);
wrd.new_width = m_windowWidth; wrd.new_width = m_windowWidth;
wrd.new_height = m_windowHeight; wrd.new_height = m_windowHeight;
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::WindowResized, ostd::tSignalPriority::RealTime, wrd); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::WindowResized, ostd::Signal::Priority::RealTime, wrd);
} }
else if (event.type == SDL_EVENT_MOUSE_MOTION) else if (event.type == SDL_EVENT_MOUSE_MOTION)
{ {
MouseEventData mmd = get_mouse_state(); MouseEventData mmd = get_mouse_state();
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::MouseMoved, ostd::tSignalPriority::RealTime, mmd); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::MouseMoved, ostd::Signal::Priority::RealTime, mmd);
} }
else if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) else if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN)
{ {
MouseEventData mmd = get_mouse_state(); MouseEventData mmd = get_mouse_state();
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::MousePressed, ostd::tSignalPriority::RealTime, mmd); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::MousePressed, ostd::Signal::Priority::RealTime, mmd);
} }
else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP) else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP)
{ {
@ -263,22 +264,22 @@ namespace ogfx
case SDL_BUTTON_MASK(3): mmd.button = MouseEventData::eButton::Right; break; case SDL_BUTTON_MASK(3): mmd.button = MouseEventData::eButton::Right; break;
default: mmd.button = MouseEventData::eButton::None; break; default: mmd.button = MouseEventData::eButton::None; break;
} }
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::MouseReleased, ostd::tSignalPriority::RealTime, mmd); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::MouseReleased, ostd::Signal::Priority::RealTime, mmd);
} }
else if (event.type == SDL_EVENT_KEY_DOWN) else if (event.type == SDL_EVENT_KEY_DOWN)
{ {
KeyEventData ked(*this, (int32_t)event.key.key, 0, KeyEventData::eKeyEvent::Pressed); KeyEventData ked(*this, (int32_t)event.key.key, 0, KeyEventData::eKeyEvent::Pressed);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::KeyPressed, ostd::tSignalPriority::RealTime, ked); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::KeyPressed, ostd::Signal::Priority::RealTime, ked);
} }
else if (event.type == SDL_EVENT_KEY_UP) else if (event.type == SDL_EVENT_KEY_UP)
{ {
KeyEventData ked(*this, (int32_t)event.key.key, 0, KeyEventData::eKeyEvent::Released); KeyEventData ked(*this, (int32_t)event.key.key, 0, KeyEventData::eKeyEvent::Released);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::KeyReleased, ostd::tSignalPriority::RealTime, ked); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::KeyReleased, ostd::Signal::Priority::RealTime, ked);
} }
else if (event.type == SDL_EVENT_TEXT_INPUT) else if (event.type == SDL_EVENT_TEXT_INPUT)
{ {
KeyEventData ked(*this, 0, event.text.text[0], KeyEventData::eKeyEvent::Text); KeyEventData ked(*this, 0, event.text.text[0], KeyEventData::eKeyEvent::Text);
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::TextEntered, ostd::tSignalPriority::RealTime, ked); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::TextEntered, ostd::Signal::Priority::RealTime, ked);
} }
__on_event(event); __on_event(event);
} }
@ -325,7 +326,7 @@ namespace ogfx
m_fpsUpdateTimer.update(); m_fpsUpdateTimer.update();
} }
void GraphicsWindow::__on_signal(ostd::tSignal& signal) void GraphicsWindow::__on_signal(ostd::Signal& signal)
{ {
onSignal(signal); onSignal(signal);
} }
@ -384,54 +385,54 @@ namespace ogfx
} }
} }
void Window::__on_signal(ostd::tSignal& signal) void Window::__on_signal(ostd::Signal& signal)
{ {
Event evt(*this); Event evt(*this);
if (signal.ID == ostd::tBuiltinSignals::WindowClosed) if (signal.ID == ostd::BuiltinSignals::WindowClosed)
{ {
m_rootWidget.__onWindowClosed(evt); m_rootWidget.__onWindowClosed(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::WindowFocused) else if (signal.ID == ostd::BuiltinSignals::WindowFocused)
{ {
m_rootWidget.__onWIndowFocused(evt); m_rootWidget.__onWIndowFocused(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::WindowLostFocus) else if (signal.ID == ostd::BuiltinSignals::WindowLostFocus)
{ {
m_rootWidget.__onWindowFocusLost(evt); m_rootWidget.__onWindowFocusLost(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::WindowResized) else if (signal.ID == ostd::BuiltinSignals::WindowResized)
{ {
evt.windowResized = &(ogfx::WindowResizedData&)signal.userData; evt.windowResized = &(ogfx::WindowResizedData&)signal.userData;
m_rootWidget.__onWindowResized(evt); m_rootWidget.__onWindowResized(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::MouseMoved) else if (signal.ID == ostd::BuiltinSignals::MouseMoved)
{ {
evt.mouse = &(ogfx::MouseEventData&)signal.userData; evt.mouse = &(ogfx::MouseEventData&)signal.userData;
m_rootWidget.__onMouseMoved(evt); m_rootWidget.__onMouseMoved(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::MousePressed) else if (signal.ID == ostd::BuiltinSignals::MousePressed)
{ {
evt.mouse = &(ogfx::MouseEventData&)signal.userData; evt.mouse = &(ogfx::MouseEventData&)signal.userData;
m_rootWidget.__onMousePressed(evt); m_rootWidget.__onMousePressed(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::MouseReleased) else if (signal.ID == ostd::BuiltinSignals::MouseReleased)
{ {
evt.mouse = &(ogfx::MouseEventData&)signal.userData; evt.mouse = &(ogfx::MouseEventData&)signal.userData;
m_rootWidget.__onMouseReleased(evt); m_rootWidget.__onMouseReleased(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::KeyPressed) else if (signal.ID == ostd::BuiltinSignals::KeyPressed)
{ {
evt.keyboard = &(ogfx::KeyEventData&)signal.userData; evt.keyboard = &(ogfx::KeyEventData&)signal.userData;
m_rootWidget.__onKeyPressed(evt); m_rootWidget.__onKeyPressed(evt);
} }
else if (signal.ID == ostd::tBuiltinSignals::KeyReleased) else if (signal.ID == ostd::BuiltinSignals::KeyReleased)
{ {
evt.keyboard = &(ogfx::KeyEventData&)signal.userData; evt.keyboard = &(ogfx::KeyEventData&)signal.userData;
m_rootWidget.__onKeyReleased(evt); m_rootWidget.__onKeyReleased(evt);
if (evt.keyboard->keyCode == SDLK_ESCAPE) if (evt.keyboard->keyCode == SDLK_ESCAPE)
close(); close();
} }
else if (signal.ID == ostd::tBuiltinSignals::TextEntered) else if (signal.ID == ostd::BuiltinSignals::TextEntered)
{ {
evt.keyboard = &(ogfx::KeyEventData&)signal.userData; evt.keyboard = &(ogfx::KeyEventData&)signal.userData;
m_rootWidget.__onTextEntered(evt); m_rootWidget.__onTextEntered(evt);

12
src/ogfx/gui/Window.hpp
View file

@ -49,7 +49,7 @@ namespace ogfx
void setIcon(const ostd::String& iconFilePath); void setIcon(const ostd::String& iconFilePath);
void setBlockingEventsRefreshFPS(uint32_t fps); void setBlockingEventsRefreshFPS(uint32_t fps);
void requestRedraw(void); void requestRedraw(void);
void handleSignal(ostd::tSignal& signal) override; void handleSignal(ostd::Signal& signal) override;
inline bool isInitialized(void) const { return m_initialized; } inline bool isInitialized(void) const { return m_initialized; }
inline bool isRunning(void) const { return m_running; } inline bool isRunning(void) const { return m_running; }
@ -77,7 +77,7 @@ namespace ogfx
inline virtual void __on_window_init(int32_t width, int32_t height, const ostd::String& title) { } inline virtual void __on_window_init(int32_t width, int32_t height, const ostd::String& title) { }
inline virtual void __on_window_destroy(void) { } inline virtual void __on_window_destroy(void) { }
inline virtual void __on_window_close(void) { } inline virtual void __on_window_close(void) { }
inline virtual void __on_signal(ostd::tSignal& signal) { } inline virtual void __on_signal(ostd::Signal& signal) { }
inline virtual void __main_loop(void) = 0; inline virtual void __main_loop(void) = 0;
private: private:
@ -126,7 +126,7 @@ namespace ogfx
inline virtual void onDestroy(void) { } inline virtual void onDestroy(void) { }
inline virtual void onClose(void) { } inline virtual void onClose(void) { }
inline virtual void onSDLEvent(SDL_Event& event) { } inline virtual void onSDLEvent(SDL_Event& event) { }
inline virtual void onSignal(ostd::tSignal& signal) { } inline virtual void onSignal(ostd::Signal& signal) { }
inline int32_t getFPS(void) const { return m_fps; } inline int32_t getFPS(void) const { return m_fps; }
@ -136,7 +136,7 @@ namespace ogfx
void __on_window_destroy(void) override; void __on_window_destroy(void) override;
void __on_window_close(void) override; void __on_window_close(void) override;
void __main_loop(void) override; void __main_loop(void) override;
void __on_signal(ostd::tSignal& signal) override; void __on_signal(ostd::Signal& signal) override;
private: private:
int32_t m_fps { 0 }; int32_t m_fps { 0 };
@ -161,7 +161,7 @@ namespace ogfx
inline virtual void onClose(void) { } inline virtual void onClose(void) { }
inline virtual void onSDLEvent(SDL_Event& event) { } inline virtual void onSDLEvent(SDL_Event& event) { }
inline virtual void onRedraw(BasicRenderer2D& gfx) { } inline virtual void onRedraw(BasicRenderer2D& gfx) { }
inline virtual void onSignal(ostd::tSignal& signal) { } inline virtual void onSignal(ostd::Signal& signal) { }
inline const gui::Theme& theme(void) const { return *m_guiTheme; } inline const gui::Theme& theme(void) const { return *m_guiTheme; }
void setTheme(const gui::Theme& theme); void setTheme(const gui::Theme& theme);
@ -173,7 +173,7 @@ namespace ogfx
void __on_window_destroy(void) override; void __on_window_destroy(void) override;
void __on_window_close(void) override; void __on_window_close(void) override;
void __main_loop(void) override; void __main_loop(void) override;
void __on_signal(ostd::tSignal& signal) override; void __on_signal(ostd::Signal& signal) override;
private: private:
BasicRenderer2D m_gfx; BasicRenderer2D m_gfx;

6
src/ogfx/render/FontUtils.cpp
View file

@ -26,14 +26,14 @@ namespace ogfx
TTFRenderer::SignalHandler::SignalHandler(TTFRenderer& parent) : m_parent(parent) TTFRenderer::SignalHandler::SignalHandler(TTFRenderer& parent) : m_parent(parent)
{ {
enableSignals(); enableSignals();
connectSignal(ostd::tBuiltinSignals::BeforeSDLShutdown); connectSignal(ostd::BuiltinSignals::BeforeSDLShutdown);
setTypeName("ostd::GraphicsWindowOutputHandler::SignalHandler"); setTypeName("ostd::GraphicsWindowOutputHandler::SignalHandler");
validate(); validate();
} }
void TTFRenderer::SignalHandler::handleSignal(ostd::tSignal& signal) void TTFRenderer::SignalHandler::handleSignal(ostd::Signal& signal)
{ {
if (signal.ID == ostd::tBuiltinSignals::BeforeSDLShutdown) if (signal.ID == ostd::BuiltinSignals::BeforeSDLShutdown)
{ {
m_parent.closeFont(); m_parent.closeFont();
} }

2
src/ogfx/render/FontUtils.hpp
View file

@ -32,7 +32,7 @@ namespace ogfx
{ {
public: public:
SignalHandler(TTFRenderer& parent); SignalHandler(TTFRenderer& parent);
void handleSignal(ostd::tSignal& signal) override; void handleSignal(ostd::Signal& signal) override;
private: private:
TTFRenderer& m_parent; TTFRenderer& m_parent;

6
src/ogfx/render/PixelRenderer.cpp
View file

@ -144,14 +144,14 @@ namespace ogfx
m_windowHeight = parent.getWindowHeight(); m_windowHeight = parent.getWindowHeight();
setTypeName("ogfx::PixelRenderer"); setTypeName("ogfx::PixelRenderer");
enableSignals(); enableSignals();
connectSignal(ostd::tBuiltinSignals::WindowResized); connectSignal(ostd::BuiltinSignals::WindowResized);
validate(); validate();
} }
void PixelRenderer::handleSignal(ostd::tSignal& signal) void PixelRenderer::handleSignal(ostd::Signal& signal)
{ {
if (isInvalid()) return; if (isInvalid()) return;
if (signal.ID == ostd::tBuiltinSignals::WindowResized) if (signal.ID == ostd::BuiltinSignals::WindowResized)
{ {
m_pixels = ostd::Memory::resizeArray<uint32_t>(m_pixels, m_parent->getWindowWidth() * m_parent->getWindowHeight()); m_pixels = ostd::Memory::resizeArray<uint32_t>(m_pixels, m_parent->getWindowWidth() * m_parent->getWindowHeight());
SDL_DestroyTexture(m_texture); SDL_DestroyTexture(m_texture);

2
src/ogfx/render/PixelRenderer.hpp
View file

@ -84,7 +84,7 @@ namespace ogfx
inline PixelRenderer(void) { invalidate(); } inline PixelRenderer(void) { invalidate(); }
~PixelRenderer(void); ~PixelRenderer(void);
void initialize(WindowCore& parent); void initialize(WindowCore& parent);
void handleSignal(ostd::tSignal& signal) override; void handleSignal(ostd::Signal& signal) override;
void updateBuffer(void); void updateBuffer(void);
void displayBuffer(void); void displayBuffer(void);
inline uint32_t* getScreenPixels(void) { return m_pixels; } inline uint32_t* getScreenPixels(void) { return m_pixels; }

2
src/ogfx/utils/SDLInclude.hpp
View file

@ -69,7 +69,7 @@ namespace ogfx
static inline void shutdown_sdl(void) static inline void shutdown_sdl(void)
{ {
ostd::SignalHandler::emitSignal(ostd::tBuiltinSignals::BeforeSDLShutdown, ostd:: tSignalPriority::RealTime); ostd::SignalHandler::emitSignal(ostd::BuiltinSignals::BeforeSDLShutdown, ostd:: Signal::Priority::RealTime);
TTF_Quit(); TTF_Quit();
SDL_Quit(); SDL_Quit();
} }

6
src/ostd/data/BaseObject.cpp
View file

@ -9,7 +9,7 @@ namespace ostd
BaseObject::BaseObject(const BaseObject& copy) BaseObject::BaseObject(const BaseObject& copy)
{ {
m_uid = copy.m_uid; m_uid = copy.m_uid;
m_oid = copy.m_oid; m_oid = BaseObject::s_next_oid++;
m_valid = copy.m_valid; m_valid = copy.m_valid;
m_typeName = copy.m_typeName; m_typeName = copy.m_typeName;
m_signalsEnabled = copy.m_signalsEnabled; m_signalsEnabled = copy.m_signalsEnabled;
@ -18,7 +18,7 @@ namespace ostd
BaseObject& BaseObject::operator=(const BaseObject& copy) BaseObject& BaseObject::operator=(const BaseObject& copy)
{ {
m_uid = copy.m_uid; m_uid = copy.m_uid;
m_oid = copy.m_oid; m_oid = BaseObject::s_next_oid++;
m_valid = copy.m_valid; m_valid = copy.m_valid;
m_typeName = copy.m_typeName; m_typeName = copy.m_typeName;
m_signalsEnabled = copy.m_signalsEnabled; m_signalsEnabled = copy.m_signalsEnabled;
@ -52,7 +52,7 @@ namespace ostd
SignalHandler::connect(*this, signal_id); SignalHandler::connect(*this, signal_id);
} }
void BaseObject::__handle_signal(tSignal& signal) void BaseObject::__handle_signal(Signal& signal)
{ {
if (m_signalsEnabled) if (m_signalsEnabled)
handleSignal(signal); handleSignal(signal);

6
src/ostd/data/BaseObject.hpp
View file

@ -27,7 +27,7 @@
namespace ostd namespace ostd
{ {
class OutputHandlerBase; class OutputHandlerBase;
struct tSignal; struct Signal;
class BaseObject class BaseObject
{ {
public: public:
@ -59,10 +59,10 @@ namespace ostd
virtual inline String toString(void) const { return getObjectHeaderString(); }; virtual inline String toString(void) const { return getObjectHeaderString(); };
virtual void print(bool newLine = true, OutputHandlerBase* __destination = nullptr) const; virtual void print(bool newLine = true, OutputHandlerBase* __destination = nullptr) const;
virtual inline void handleSignal(tSignal& signal) { } virtual inline void handleSignal(Signal& signal) { }
void connectSignal(uint32_t signal_id); void connectSignal(uint32_t signal_id);
void __handle_signal(tSignal& signal); void __handle_signal(Signal& signal);
friend std::ostream& operator<<(std::ostream& os, const BaseObject& obj); friend std::ostream& operator<<(std::ostream& os, const BaseObject& obj);

14
src/ostd/math/Spline.cpp
View file

@ -6,7 +6,7 @@ namespace ostd
{ {
} }
void Spline::handleSignal(tSignal& signal) void Spline::handleSignal(Signal& signal)
{ {
// if (!isEditable()) return; // if (!isEditable()) return;
// if (isUsingCustomEventHandler() && m_eventHandlerCallback) // if (isUsingCustomEventHandler() && m_eventHandlerCallback)
@ -14,7 +14,7 @@ namespace ostd
// m_eventHandlerCallback(signal); // m_eventHandlerCallback(signal);
// return; // return;
// } // }
// if (signal.ID == tBuiltinSignals::MousePressed) // if (signal.ID == BuiltinSignals::MousePressed)
// { // {
// ogfx::MouseEventData& evt = static_cast<ogfx::MouseEventData&>(signal.userData); // ogfx::MouseEventData& evt = static_cast<ogfx::MouseEventData&>(signal.userData);
// for (auto& node : m_points) // for (auto& node : m_points)
@ -26,13 +26,13 @@ namespace ostd
// } // }
// } // }
// } // }
// else if (signal.ID == tBuiltinSignals::MouseReleased) // else if (signal.ID == BuiltinSignals::MouseReleased)
// { // {
// if (m_selectedNode != nullptr) // if (m_selectedNode != nullptr)
// updateTotalLength(); // updateTotalLength();
// m_selectedNode = nullptr; // m_selectedNode = nullptr;
// } // }
// else if (signal.ID == tBuiltinSignals::MouseMoved) // else if (signal.ID == BuiltinSignals::MouseMoved)
// { // {
// ogfx::MouseEventData& evt = static_cast<ogfx::MouseEventData&>(signal.userData); // ogfx::MouseEventData& evt = static_cast<ogfx::MouseEventData&>(signal.userData);
// if (m_selectedNode != nullptr) // if (m_selectedNode != nullptr)
@ -140,9 +140,9 @@ namespace ostd
void Spline::connectSignals(void) void Spline::connectSignals(void)
{ {
if (m_signalsConnected) return; if (m_signalsConnected) return;
connectSignal(tBuiltinSignals::MouseMoved); connectSignal(BuiltinSignals::MouseMoved);
connectSignal(tBuiltinSignals::MousePressed); connectSignal(BuiltinSignals::MousePressed);
connectSignal(tBuiltinSignals::MouseReleased); connectSignal(BuiltinSignals::MouseReleased);
m_signalsConnected = true; m_signalsConnected = true;
} }

4
src/ostd/math/Spline.hpp
View file

@ -35,12 +35,12 @@ namespace ostd
class Spline : public BaseObject class Spline : public BaseObject
{ {
public: public:
using EventHandlerCallback = std::function<void(tSignal&)>; using EventHandlerCallback = std::function<void(Signal&)>;
using DrawCallback = std::function<void(float resolution, float lineWidth, float controlPointSize)>; using DrawCallback = std::function<void(float resolution, float lineWidth, float controlPointSize)>;
public: public:
Spline(void); Spline(void);
void handleSignal(tSignal& signal) override; void handleSignal(Signal& signal) override;
tSplineNode getPoint(float t); tSplineNode getPoint(float t);
tSplineNode getGradient(float t); tSplineNode getGradient(float t);
float updateSegmentLength(int32_t node); float updateSegmentLength(int32_t node);

124
src/ostd/utils/Signals.cpp
View file

@ -1,136 +1,44 @@
#include "Signals.hpp" #include "Signals.hpp"
#include "../data/BaseObject.hpp" #include "../data/BaseObject.hpp"
#include "../io/Logger.hpp"
namespace ostd namespace ostd
{ {
void SignalHandler::init(bool allow_reinit) void SignalHandler::init(bool allow_reinit)
{ {
if (m_initialized && !allow_reinit) return; if (m_initialized && !allow_reinit) return;
SignalHandler::m_customRecievers.clear(); m_recievers.clear();
SignalHandler::m_customRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE); m_recievers.reserve(__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_mousePressedRecievers.clear(); m_DelegateRecievers.clear();
SignalHandler::m_mousePressedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE); m_DelegateRecievers.reserve(__DELEGATE_SIGNALS_BUFFER_START_SIZE);
SignalHandler::m_mouseReleasedRecievers.clear();
SignalHandler::m_mouseReleasedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_keyPressedRecievers.clear();
SignalHandler::m_keyPressedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_keyReleasedRecievers.clear();
SignalHandler::m_keyReleasedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_mouseMovedRecievers.clear();
SignalHandler::m_mouseMovedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_mouseDraggedRecievers.clear();
SignalHandler::m_mouseDraggedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_textEnteredRecievers.clear();
SignalHandler::m_textEnteredRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowResizedRecievers.clear();
SignalHandler::m_windowResizedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowClosedRecievers.clear();
SignalHandler::m_windowClosedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowFocusedRecievers.clear();
SignalHandler::m_windowFocusedRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_windowLostFocusRecievers.clear();
SignalHandler::m_windowLostFocusRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_delegatedSignals.clear();
SignalHandler::m_delegatedSignals.reserve(SignalHandler::__DELEGATED_SIGNALS_BUFFER_START_SIZE);
SignalHandler::m_onGuiEventRecievers.clear();
SignalHandler::m_onGuiEventRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
SignalHandler::m_beforeSDLShutdownRecievers.clear();
SignalHandler::m_beforeSDLShutdownRecievers.reserve(SignalHandler::__SIGNAL_BUFFER_START_SIZE);
m_initialized = true; m_initialized = true;
} }
void SignalHandler::refresh(void) void SignalHandler::handleDelegateSignals(void)
{ {
for (auto& ds : SignalHandler::m_delegatedSignals) for (auto& delegate : m_DelegateRecievers)
SignalHandler::emitSignal(ds.id, tSignalPriority::RealTime, ds.ud); emitSignal(delegate.id, Signal::Priority::RealTime, delegate.ud);
SignalHandler::m_delegatedSignals.clear(); m_DelegateRecievers.clear();
//m_delegatedSignals.reserve(__DELEGATED_SIGNALS_BUFFER_START_SIZE);
} }
void SignalHandler::emitSignal(uint32_t signal_id, uint8_t prio, BaseObject& userData) void SignalHandler::emitSignal(uint32_t signal_id, uint8_t prio, BaseObject& userData)
{ {
if (prio == tSignalPriority::Normal) if (prio == Signal::Priority::Normal)
{ {
SignalHandler::m_delegatedSignals.push_back({ signal_id, userData }); SignalHandler::m_DelegateRecievers.push_back({ signal_id, userData });
return; return;
} }
tSignal signal { signal_id, userData, prio }; Signal signal { signal_id, userData, prio };
std::vector<tSignalObjPair>* sig_list = nullptr; if (m_recievers.count(signal_id) < 1)
if (signal_id == tBuiltinSignals::MousePressed)
sig_list = &m_mousePressedRecievers;
else if (signal_id == tBuiltinSignals::MouseReleased)
sig_list = &m_mouseReleasedRecievers;
else if (signal_id == tBuiltinSignals::KeyPressed)
sig_list = &m_keyPressedRecievers;
else if (signal_id == tBuiltinSignals::KeyReleased)
sig_list = &m_keyReleasedRecievers;
else if (signal_id == tBuiltinSignals::MouseMoved)
sig_list = &m_mouseMovedRecievers;
else if (signal_id == tBuiltinSignals::MouseDragged)
sig_list = &m_mouseDraggedRecievers;
else if (signal_id == tBuiltinSignals::TextEntered)
sig_list = &m_textEnteredRecievers;
else if (signal_id == tBuiltinSignals::WindowResized)
sig_list = &m_windowResizedRecievers;
else if (signal_id == tBuiltinSignals::WindowClosed)
sig_list = &m_windowClosedRecievers;
else if (signal_id == tBuiltinSignals::WindowLostFocus)
sig_list = &m_windowLostFocusRecievers;
else if (signal_id == tBuiltinSignals::WindowFocused)
sig_list = &m_windowFocusedRecievers;
else if (signal_id == tBuiltinSignals::OnGuiEvent)
sig_list = &m_onGuiEventRecievers;
else if (signal_id == tBuiltinSignals::BeforeSDLShutdown)
sig_list = &m_beforeSDLShutdownRecievers;
else if (signal_id > tBuiltinSignals::CustomSignalBase)
sig_list = &m_customRecievers;
if (sig_list == nullptr)
{
OX_WARN("ox::SignalHandler::emitSignal(...): Unknown signal ID: <%d>", signal_id);
return; return;
} for (auto& obj : m_recievers[signal_id])
for (auto& sop : *sig_list)
{ {
if (sop.signal_id == signal_id) obj->__handle_signal(signal);
{ if (signal.handled) return;
sop.object->__handle_signal(signal);
if (signal.handled) return;
}
} }
} }
void SignalHandler::connect(BaseObject& object, uint32_t signal_id) void SignalHandler::connect(BaseObject& object, uint32_t signal_id)
{ {
if (signal_id == tBuiltinSignals::MousePressed) m_recievers[signal_id].push_back(&object);
m_mousePressedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::MouseReleased)
m_mouseReleasedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::KeyPressed)
m_keyPressedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::KeyReleased)
m_keyReleasedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::MouseMoved)
m_mouseMovedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::MouseDragged)
m_mouseDraggedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::TextEntered)
m_textEnteredRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowResized)
m_windowResizedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowClosed)
m_windowClosedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowLostFocus)
m_windowLostFocusRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::WindowFocused)
m_windowFocusedRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::OnGuiEvent)
m_onGuiEventRecievers.push_back({ &object, signal_id });
else if (signal_id == tBuiltinSignals::BeforeSDLShutdown)
m_beforeSDLShutdownRecievers.push_back({ &object, signal_id });
else if (signal_id > tBuiltinSignals::CustomSignalBase)
m_customRecievers.push_back({ &object, signal_id });
else
OX_WARN("ox::SignalHandler::connect(...): Unknown signal ID: <%d>", signal_id);
} }
} }

66
src/ostd/utils/Signals.hpp
View file

@ -22,15 +22,12 @@
#include <ostd/data/Types.hpp> #include <ostd/data/Types.hpp>
#include <ostd/data/BaseObject.hpp> #include <ostd/data/BaseObject.hpp>
#include <unordered_map>
#include <vector> #include <vector>
namespace ostd namespace ostd
{ {
//INFO: (Note to self) When adding new Builtin signals, the corresponding static list must struct BuiltinSignals
// be addeed to the ox::SignalHandler class, and the appropriate branch must be added
// to the ox::SignalHandler::emitSignal and the ox::SignalHandler::connect functions.
// Also, correct initialization in the ox::SignalHandler::init function must be added
struct tBuiltinSignals
{ {
inline static constexpr uint32_t NoSignal = 0x0000; inline static constexpr uint32_t NoSignal = 0x0000;
@ -56,68 +53,41 @@ namespace ostd
inline static constexpr uint32_t CustomSignalBase = 0xFF0000; inline static constexpr uint32_t CustomSignalBase = 0xFF0000;
}; };
struct tSignalPriority struct Signal
{
inline static constexpr uint8_t RealTime = 0;
inline static constexpr uint8_t Normal = 1;
};
struct tSignal
{ {
struct Priority
{
inline static constexpr uint8_t RealTime = 0;
inline static constexpr uint8_t Normal = 1;
};
const uint8_t priority; const uint8_t priority;
const uint32_t ID; const uint32_t ID;
bool handled { false }; bool handled { false };
BaseObject& userData; BaseObject& userData;
inline tSignal(uint32_t id, BaseObject& _userData = BaseObject::InvalidRef(), uint8_t prio = tSignalPriority::Normal) : priority(prio), ID(id), userData(_userData) { } inline Signal(uint32_t id, BaseObject& _userData = BaseObject::InvalidRef(), uint8_t prio = Signal::Priority::Normal) : priority(prio), ID(id), userData(_userData) { }
}; };
class SignalHandler class SignalHandler
{ {
private: struct tSignalObjPair private: struct DelegateSignal
{
BaseObject* object { nullptr };
uint32_t signal_id { tBuiltinSignals::NoSignal };
};
private: struct tDelegateSignal
{ {
uint32_t id; uint32_t id;
BaseObject& ud; BaseObject& ud;
inline DelegateSignal(uint32_t _id, BaseObject& _ud) : id(_id), ud(_ud) { }
inline tDelegateSignal(uint32_t _id, BaseObject& _ud) : id(_id), ud(_ud) { }
}; };
public: public:
static void init(bool allow_reinit = false); static void init(bool allow_reinit = false);
static void refresh(void); static void handleDelegateSignals(void);
static void emitSignal(uint32_t signal_id, uint8_t prio = Signal::Priority::RealTime, BaseObject& userData = BaseObject::InvalidRef());
static void emitSignal(uint32_t signal_id, uint8_t prio = tSignalPriority::Normal, BaseObject& userData = BaseObject::InvalidRef());
static void connect(BaseObject& object, uint32_t signal_id); static void connect(BaseObject& object, uint32_t signal_id);
inline static uint32_t newCustomSignal(uint32_t sub_id) { return BuiltinSignals::CustomSignalBase + sub_id; }
inline static uint32_t newCustomSignal(uint32_t sub_id) { return tBuiltinSignals::CustomSignalBase + sub_id; }
private: private:
inline static std::vector<tSignalObjPair> m_customRecievers; inline static std::unordered_map<uint32_t, std::vector<BaseObject*>> m_recievers;
inline static std::vector<tDelegateSignal> m_delegatedSignals; inline static std::vector<DelegateSignal> m_DelegateRecievers;
inline static constexpr uint16_t __SIGNAL_BUFFER_START_SIZE { 2048 };
/** Builtin signal recievers lists **/ inline static constexpr uint16_t __DELEGATE_SIGNALS_BUFFER_START_SIZE { 2048 };
inline static std::vector<tSignalObjPair> m_mousePressedRecievers;
inline static std::vector<tSignalObjPair> m_mouseReleasedRecievers;
inline static std::vector<tSignalObjPair> m_keyPressedRecievers;
inline static std::vector<tSignalObjPair> m_keyReleasedRecievers;
inline static std::vector<tSignalObjPair> m_mouseMovedRecievers;
inline static std::vector<tSignalObjPair> m_mouseDraggedRecievers;
inline static std::vector<tSignalObjPair> m_textEnteredRecievers;
inline static std::vector<tSignalObjPair> m_windowResizedRecievers;
inline static std::vector<tSignalObjPair> m_windowClosedRecievers;
inline static std::vector<tSignalObjPair> m_windowFocusedRecievers;
inline static std::vector<tSignalObjPair> m_windowLostFocusRecievers;
inline static std::vector<tSignalObjPair> m_onGuiEventRecievers;
inline static std::vector<tSignalObjPair> m_beforeSDLShutdownRecievers;
/************************************/
inline static constexpr uint16_t __SIGNAL_BUFFER_START_SIZE { 128 };
inline static constexpr uint16_t __DELEGATED_SIGNALS_BUFFER_START_SIZE { 128 };
inline static bool m_initialized { false }; inline static bool m_initialized { false };
}; };
} }

4
src/test/GraphicsWindowTest.cpp
View file

@ -41,9 +41,9 @@ class Window : public ogfx::GraphicsWindow
m_textInput.getTheme().extraPaddingTop = 3; m_textInput.getTheme().extraPaddingTop = 3;
} }
inline void handleSignal(ostd::tSignal& signal) override inline void handleSignal(ostd::Signal& signal) override
{ {
if (signal.ID == ostd::tBuiltinSignals::KeyReleased) if (signal.ID == ostd::BuiltinSignals::KeyReleased)
{ {
auto& evtData = (ogfx::KeyEventData&)signal.userData; auto& evtData = (ogfx::KeyEventData&)signal.userData;
if (evtData.keyCode == SDLK_ESCAPE) if (evtData.keyCode == SDLK_ESCAPE)

4
src/test/GuiTest.cpp
View file

@ -66,9 +66,9 @@ class Window : public ogfx::gui::Window
setTheme(m_theme); setTheme(m_theme);
} }
inline void onSignal(ostd::tSignal& signal) override inline void onSignal(ostd::Signal& signal) override
{ {
if (signal.ID == ostd::tBuiltinSignals::KeyReleased) if (signal.ID == ostd::BuiltinSignals::KeyReleased)
{ {
auto& evtData = (ogfx::KeyEventData&)signal.userData; auto& evtData = (ogfx::KeyEventData&)signal.userData;
if (evtData.keyCode == SDLK_ESCAPE) if (evtData.keyCode == SDLK_ESCAPE)