From 289ecc3a3829e9b3acff0b1778f75bc526173977 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Sat, 7 Dec 2024 19:14:34 +0100 Subject: changed double to float --- src/crepe/Particle.cpp | 4 ++-- src/crepe/Particle.h | 8 ++++---- src/crepe/api/ParticleEmitter.cpp | 5 +++-- src/crepe/api/ParticleEmitter.h | 29 +++++++++++++++------------- src/crepe/system/ParticleSystem.cpp | 38 ++++++++++++++++++------------------- src/crepe/system/ParticleSystem.h | 6 +++--- 6 files changed, 47 insertions(+), 43 deletions(-) diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp index 485a0d4..ce000a1 100644 --- a/src/crepe/Particle.cpp +++ b/src/crepe/Particle.cpp @@ -2,8 +2,8 @@ using namespace crepe; -void Particle::reset(uint32_t lifespan, const vec2 & position, const vec2 & velocity, - double angle) { +void Particle::reset(unsigned int lifespan, const vec2 & position, const vec2 & velocity, + float angle) { // Initialize the particle state this->time_in_life = 0; this->lifespan = lifespan; diff --git a/src/crepe/Particle.h b/src/crepe/Particle.h index d0397c9..4fa93a1 100644 --- a/src/crepe/Particle.h +++ b/src/crepe/Particle.h @@ -24,13 +24,13 @@ public: //! Accumulated force affecting the particle over time. vec2 force_over_time; //! Total lifespan of the particle in milliseconds. - uint32_t lifespan; + unsigned int lifespan; //! Active state of the particle; true if it is in use, false otherwise. bool active = false; //! The time the particle has been alive, in milliseconds. - uint32_t time_in_life = 0; + unsigned int time_in_life = 0; //! The angle at which the particle is oriented or moving. - double angle = 0; + float angle = 0; /** * \brief Resets the particle with new properties. @@ -43,7 +43,7 @@ public: * \param velocity The initial velocity of the particle. * \param angle The angle of the particle's trajectory or orientation. */ - void reset(uint32_t lifespan, const vec2 & position, const vec2 & velocity, double angle); + void reset(unsigned int lifespan, const vec2 & position, const vec2 & velocity, float angle); /** * \brief Updates the particle's state. * diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 90b77a0..1cfdceb 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -1,10 +1,11 @@ #include "ParticleEmitter.h" +#include "api/Sprite.h" using namespace crepe; -ParticleEmitter::ParticleEmitter(game_object_id_t game_object_id, const Data & data) +ParticleEmitter::ParticleEmitter(game_object_id_t game_object_id, const Sprite & sprite, const Data & data) : Component(game_object_id), - data(data) { + sprite(sprite), data(data) { for (size_t i = 0; i < this->data.max_particles; i++) { this->data.particles.emplace_back(); } diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index b83fd61..e8fa15e 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -1,5 +1,6 @@ #pragma once +#include #include #include "Component.h" @@ -26,15 +27,18 @@ public: */ struct Boundary { //! boundary width (midpoint is emitter location) - double width = 0.0; + float width = INFINITY; //! boundary height (midpoint is emitter location) - double height = 0.0; + float height = INFINITY; //! boundary offset from particle emitter location vec2 offset; //! reset on exit or stop velocity and set max postion bool reset_on_exit = false; }; + //! sprite reference of displayed sprite + const Sprite & sprite; + /** * \brief Holds parameters that control particle emission. * @@ -45,29 +49,28 @@ public: //! position of the emitter vec2 position; //! maximum number of particles - const unsigned int max_particles = 0; + const unsigned int max_particles = 256; //! rate of particle emission per update (Lowest value = 0.001 any lower is ignored) - double emission_rate = 0; + float emission_rate = 1; //! min speed of the particles - double min_speed = 0; + float min_speed = 1; //! min speed of the particles - double max_speed = 0; + float max_speed = 2; //! min angle of particle emission - double min_angle = 0; + float min_angle = 0; //! max angle of particle emission - double max_angle = 0; + float max_angle = 0; //! begin Lifespan of particle (only visual) - double begin_lifespan = 0.0; + float begin_lifespan = 0.0; //! end Lifespan of particle - double end_lifespan = 0.0; + float end_lifespan = 10.0; //! force over time (physics) vec2 force_over_time; //! particle boundary Boundary boundary; //! collection of particles std::vector particles; - //! sprite reference - const Sprite & sprite; + }; public: @@ -75,7 +78,7 @@ public: * \param game_object_id Identifier for the game object using this emitter. * \param data Configuration data defining particle properties. */ - ParticleEmitter(game_object_id_t game_object_id, const Data & data); + ParticleEmitter(game_object_id_t game_object_id, const Sprite & sprite,const Data & data); public: //! Configuration data for particle emission settings. diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index b14c52f..596b4b0 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -21,9 +21,9 @@ void ParticleSystem::update() { = mgr.get_components_by_id(emitter.game_object_id).front().get(); // Emit particles based on emission_rate - int updates = calculate_update(this->update_count, emitter.data.emission_rate); + int updates = this->calculate_update(this->update_count, emitter.data.emission_rate); for (size_t i = 0; i < updates; i++) { - emit_particle(emitter, transform); + this->emit_particle(emitter, transform); } // Update all particles @@ -34,7 +34,7 @@ void ParticleSystem::update() { } // Check if within boundary - check_bounds(emitter, transform); + this->check_bounds(emitter, transform); } this->update_count = (this->update_count + 1) % this->MAX_UPDATE_COUNT; @@ -61,9 +61,9 @@ void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform & } } -int ParticleSystem::calculate_update(int count, double emission) const { - double integer_part = std::floor(emission); - double fractional_part = emission - integer_part; +int ParticleSystem::calculate_update(int count, float emission) const { + float integer_part = std::floor(emission); + float fractional_part = emission - integer_part; if (fractional_part > 0) { int denominator = static_cast(1.0 / fractional_part); @@ -75,13 +75,13 @@ int ParticleSystem::calculate_update(int count, double emission) const { void ParticleSystem::check_bounds(ParticleEmitter & emitter, const Transform & transform) { vec2 offset = emitter.data.boundary.offset + transform.position + emitter.data.position; - double half_width = emitter.data.boundary.width / 2.0; - double half_height = emitter.data.boundary.height / 2.0; + float half_width = emitter.data.boundary.width / 2.0; + float half_height = emitter.data.boundary.height / 2.0; - const double LEFT = offset.x - half_width; - const double RIGHT = offset.x + half_width; - const double TOP = offset.y - half_height; - const double BOTTOM = offset.y + half_height; + const float LEFT = offset.x - half_width; + const float RIGHT = offset.x + half_width; + const float TOP = offset.y - half_height; + const float BOTTOM = offset.y + half_height; for (Particle & particle : emitter.data.particles) { const vec2 & position = particle.position; @@ -102,25 +102,25 @@ void ParticleSystem::check_bounds(ParticleEmitter & emitter, const Transform & t } } -double ParticleSystem::generate_random_angle(double min_angle, double max_angle) const { +float ParticleSystem::generate_random_angle(float min_angle, float max_angle) const { if (min_angle == max_angle) { return min_angle; } else if (min_angle < max_angle) { return min_angle - + static_cast(std::rand() % static_cast(max_angle - min_angle)); + + static_cast(std::rand() % static_cast(max_angle - min_angle)); } else { - double angle_offset = (360 - min_angle) + max_angle; - double random_angle - = min_angle + static_cast(std::rand() % static_cast(angle_offset)); + float angle_offset = (360 - min_angle) + max_angle; + float random_angle + = min_angle + static_cast(std::rand() % static_cast(angle_offset)); return (random_angle >= 360) ? random_angle - 360 : random_angle; } } -double ParticleSystem::generate_random_speed(double min_speed, double max_speed) const { +float ParticleSystem::generate_random_speed(float min_speed, float max_speed) const { if (min_speed == max_speed) { return min_speed; } else { return min_speed - + static_cast(std::rand() % static_cast(max_speed - min_speed)); + + static_cast(std::rand() % static_cast(max_speed - min_speed)); } } diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h index 068f01c..2adb0f0 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -39,7 +39,7 @@ private: * \param emission Emission rate. * \return The number of particles to emit. */ - int calculate_update(int count, double emission) const; + int calculate_update(int count, float emission) const; /** * \brief Checks whether particles are within the emitter’s boundary, resets or stops @@ -57,7 +57,7 @@ private: * \param max_angle Maximum emission angle in degrees. * \return Random angle in degrees. */ - double generate_random_angle(double min_angle, double max_angle) const; + float generate_random_angle(float min_angle, float max_angle) const; /** * \brief Generates a random speed for particle emission within the specified range. @@ -66,7 +66,7 @@ private: * \param max_speed Maximum emission speed. * \return Random speed. */ - double generate_random_speed(double min_speed, double max_speed) const; + float generate_random_speed(float min_speed, float max_speed) const; private: //! Counter to count updates to determine how many times emit_particle is -- cgit v1.2.3 From 666292e33d6997a61d9eaff31e8180a602656474 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Sat, 7 Dec 2024 20:39:19 +0100 Subject: save --- src/crepe/api/Event.h | 97 ++++--- src/crepe/api/Transform.h | 8 + src/crepe/facade/SDLContext.cpp | 134 +++++---- src/crepe/facade/SDLContext.h | 35 ++- src/crepe/system/InputSystem.cpp | 102 ++++--- src/test/EventTest.cpp | 39 ++- src/test/InputTest.cpp | 586 +++++++++++++++++++-------------------- 7 files changed, 550 insertions(+), 451 deletions(-) diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h index f2f3daf..265e925 100644 --- a/src/crepe/api/Event.h +++ b/src/crepe/api/Event.h @@ -4,7 +4,7 @@ #include #include "KeyCodes.h" - +#include "types.h" namespace crepe { /** @@ -38,11 +38,8 @@ public: */ class MousePressEvent : public Event { public: - //! X-coordinate of the mouse position at the time of the event. - int mouse_x = 0; - - //! Y-coordinate of the mouse position at the time of the event. - int mouse_y = 0; + //! mouse position + ivec2 mouse_pos = {0,0}; //! The mouse button that was pressed. MouseButton button = MouseButton::NONE; @@ -53,11 +50,8 @@ public: */ class MouseClickEvent : public Event { public: - //! X-coordinate of the mouse position at the time of the event. - int mouse_x = 0; - - //! Y-coordinate of the mouse position at the time of the event. - int mouse_y = 0; + //! mouse position + ivec2 mouse_pos = {0,0}; //! The mouse button that was clicked. MouseButton button = MouseButton::NONE; @@ -68,11 +62,8 @@ public: */ class MouseReleaseEvent : public Event { public: - //! X-coordinate of the mouse position at the time of the event. - int mouse_x = 0; - - //! Y-coordinate of the mouse position at the time of the event. - int mouse_y = 0; + //! mouse position + ivec2 mouse_pos = {0,0}; //! The mouse button that was released. MouseButton button = MouseButton::NONE; @@ -83,17 +74,10 @@ public: */ class MouseMoveEvent : public Event { public: - //! X-coordinate of the mouse position at the time of the event. - int mouse_x = 0; - - //! Y-coordinate of the mouse position at the time of the event. - int mouse_y = 0; - - // Movement since last event in x - int delta_x = 0; - - // Movement since last event in y - int delta_y = 0; + //! new mouse position + ivec2 mouse_pos = {0,0}; + //! The change in mouse position relative to the last position (in pixels). + ivec2 mouse_delta = {0,0}; }; /** @@ -101,12 +85,8 @@ public: */ class MouseScrollEvent : public Event { public: - //! X-coordinate of the mouse position at the time of the event. - int mouse_x = 0; - - //! Y-coordinate of the mouse position at the time of the event. - int mouse_y = 0; - + //! mouse position when the scroll happened. + ivec2 mouse_pos = {0,0}; //! scroll direction (-1 = down, 1 = up) int scroll_direction = 0; //! scroll amount in y axis (from and away from the person). @@ -127,4 +107,55 @@ public: */ class ShutDownEvent : public Event {}; +/** + * \brief Event triggered to indicate the window is overlapped by another window. + * + * When two windows overlap the bottom window gets distorted and that window has to be redrawn. + */ +class WindowExposeEvent : public Event{}; + +/** + * \brief Event triggered to indicate the window is resized. + */ +class WindowResizeEvent : public Event{ + public: + //! new window dimensions + ivec2 dimensions = {0,0}; +}; + +/** + * \brief Event triggered to indicate the window is moved. + */ +class WindowMoveEvent : public Event{ + public: + //! The change in position relative to the last position (in pixels). + ivec2 delta_move = {0,0}; +}; + +/** + * \brief Event triggered to indicate the window is minimized. + */ +class WindowMinimizeEvent : public Event{}; + +/** + * \brief Event triggered to indicate the window is maximized + */ +class WindowMaximizeEvent : public Event{}; + +/** + * \brief Event triggered to indicate the window gained focus + * + * This event is triggered when the window receives focus, meaning it becomes the active window + * for user interaction. + */ +class WindowFocusGainEvent : public Event{}; + +/** + * \brief Event triggered to indicate the window lost focus + * + * This event is triggered when the window loses focus, meaning it is no longer the active window + * for user interaction. + */ +class WindowFocusLostEvent : public Event{}; + } // namespace crepe diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h index 7ee6d65..78407ee 100644 --- a/src/crepe/api/Transform.h +++ b/src/crepe/api/Transform.h @@ -13,6 +13,14 @@ namespace crepe { */ class Transform : public Component { public: + //! Specifies the coordinate space for transformations. + enum Space { + //! coordinates are relative to the active camera + HUD, + //! coordinates are relative to the game world + WORLD, + }; + Space coordinate_space = Space::WORLD; //! Translation (shift) vec2 position = {0, 0}; //! Rotation, in degrees clockwise diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 4cc2206..e3410cb 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -375,65 +375,83 @@ ivec2 SDLContext::get_size(const Texture & ctx) { void SDLContext::delay(int ms) const { SDL_Delay(ms); } std::vector SDLContext::get_events() { - std::vector event_list; - SDL_Event event; - while (SDL_PollEvent(&event)) { - switch (event.type) { - case SDL_QUIT: - event_list.push_back(EventData{ - .event_type = SDLContext::EventType::SHUTDOWN, - }); - break; - case SDL_KEYDOWN: - event_list.push_back(EventData{ - .event_type = SDLContext::EventType::KEYDOWN, - .key = sdl_to_keycode(event.key.keysym.scancode), - .key_repeat = (event.key.repeat != 0), - }); - break; - case SDL_KEYUP: - event_list.push_back(EventData{ - .event_type = SDLContext::EventType::KEYUP, - .key = sdl_to_keycode(event.key.keysym.scancode), - }); - break; - case SDL_MOUSEBUTTONDOWN: - event_list.push_back(EventData{ - .event_type = SDLContext::EventType::MOUSEDOWN, - .mouse_button = sdl_to_mousebutton(event.button.button), - .mouse_position = {event.button.x, event.button.y}, - }); - break; - case SDL_MOUSEBUTTONUP: { - int x, y; - SDL_GetMouseState(&x, &y); - event_list.push_back(EventData{ - .event_type = SDLContext::EventType::MOUSEUP, - .mouse_button = sdl_to_mousebutton(event.button.button), - .mouse_position = {event.button.x, event.button.y}, - }); - } break; - - case SDL_MOUSEMOTION: { - event_list.push_back( - EventData{.event_type = SDLContext::EventType::MOUSEMOVE, - .mouse_position = {event.motion.x, event.motion.y}, - .rel_mouse_move = {event.motion.xrel, event.motion.yrel}}); - } break; - - case SDL_MOUSEWHEEL: { - event_list.push_back(EventData{ - .event_type = SDLContext::EventType::MOUSEWHEEL, - .mouse_position = {event.motion.x, event.motion.y}, - // TODO: why is this needed? - .scroll_direction = event.wheel.y < 0 ? -1 : 1, - .scroll_delta = event.wheel.preciseY, - }); - } break; - } - } - return event_list; + std::vector event_list; + SDL_Event event; + + // Handle general SDL events + while (SDL_PollEvent(&event)) { + switch (event.type) { + case SDL_QUIT: + event_list.push_back({SDLContext::EventType::SHUTDOWN, {}, {}, {}}); + break; + case SDL_KEYDOWN: + event_list.push_back({SDLContext::EventType::KEYDOWN, + {sdl_to_keycode(event.key.keysym.scancode), event.key.repeat != 0}, {}, {}}); + break; + case SDL_KEYUP: + event_list.push_back({SDLContext::EventType::KEYUP, + {sdl_to_keycode(event.key.keysym.scancode), false}, {}, {}}); + break; + case SDL_MOUSEBUTTONDOWN: + event_list.push_back({SDLContext::EventType::MOUSEDOWN, {}, + {sdl_to_mousebutton(event.button.button), {event.button.x, event.button.y}}, {}}); + break; + case SDL_MOUSEBUTTONUP: + event_list.push_back({SDLContext::EventType::MOUSEUP, {}, + {sdl_to_mousebutton(event.button.button), {event.button.x, event.button.y}}, {}}); + break; + case SDL_MOUSEMOTION: + event_list.push_back({SDLContext::EventType::MOUSEMOVE, {}, + {{}, {event.motion.x, event.motion.y}, -1, INFINITY, {event.motion.xrel, event.motion.yrel}}, {}}); + break; + case SDL_MOUSEWHEEL: + event_list.push_back({SDLContext::EventType::MOUSEWHEEL, {}, + {{}, {}, event.wheel.y < 0 ? -1 : 1, event.wheel.preciseY, {}}, {}}); + break; + + // Forward window events for further processing + case SDL_WINDOWEVENT: + handle_window_event(event.window, event_list); + break; + } + } + + return event_list; +} + +// Separate function for SDL_WINDOWEVENT subtypes +void SDLContext::handle_window_event(const SDL_WindowEvent& window_event, + std::vector& event_list) { + switch (window_event.event) { + case SDL_WINDOWEVENT_EXPOSED: + event_list.push_back({SDLContext::EventType::WINDOW_EXPOSE, {}, {}, {}}); + break; + case SDL_WINDOWEVENT_RESIZED: + event_list.push_back({SDLContext::EventType::WINDOW_RESIZE, {}, {}, + {{}, {window_event.data1, window_event.data2}}}); + break; + case SDL_WINDOWEVENT_MOVED: + event_list.push_back({SDLContext::EventType::WINDOW_MOVE, {}, {}, + {{window_event.data1, window_event.data2}, {}}}); + break; + case SDL_WINDOWEVENT_MINIMIZED: + event_list.push_back({SDLContext::EventType::WINDOW_MINIMIZE, {}, {}, {}}); + break; + case SDL_WINDOWEVENT_MAXIMIZED: + event_list.push_back({SDLContext::EventType::WINDOW_MAXIMIZE, {}, {}, {}}); + break; + case SDL_WINDOWEVENT_FOCUS_GAINED: + event_list.push_back({SDLContext::EventType::WINDOW_FOCUS_GAIN, {}, {}, {}}); + break; + case SDL_WINDOWEVENT_FOCUS_LOST: + event_list.push_back({SDLContext::EventType::WINDOW_FOCUS_LOST, {}, {}, {}}); + break; + } } + + + + void SDLContext::set_color_texture(const Texture & texture, const Color & color) { SDL_SetTextureColorMod(texture.texture.get(), color.r, color.g, color.b); SDL_SetTextureAlphaMod(texture.texture.get(), color.a); diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index e232511..1f83985 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -79,19 +79,37 @@ public: KEYUP, KEYDOWN, SHUTDOWN, - + WINDOW_MINIMIZE, + WINDOW_MAXIMIZE, + WINDOW_FOCUS_GAIN, + WINDOW_FOCUS_LOST, + WINDOW_MOVE, + WINDOW_RESIZE, + WINDOW_EXPOSE, }; - //! EventData struct for passing event data from facade - struct EventData { - SDLContext::EventType event_type = SDLContext::EventType::NONE; + struct KeyData{ Keycode key = Keycode::NONE; bool key_repeat = false; + }; + struct MouseData{ MouseButton mouse_button = MouseButton::NONE; ivec2 mouse_position = {-1, -1}; int scroll_direction = -1; float scroll_delta = INFINITY; ivec2 rel_mouse_move = {-1, -1}; }; + struct WindowData{ + ivec2 move_delta; + ivec2 resize_dimension; + }; + //! EventData struct for passing event data from facade + struct EventData { + SDLContext::EventType event_type = SDLContext::EventType::NONE; + KeyData key_data; + MouseData mouse_data; + WindowData window_data; + }; + /** * \brief Gets the singleton instance of SDLContext. * \return Reference to the SDLContext instance. @@ -116,7 +134,14 @@ private: * \return Events that occurred since last call to `get_events()` */ std::vector get_events(); - + /** + * \brief Fills event_list with triggered window events + * + * This method checks if any window events are triggered and adds them to the event_list. + * + */ + void handle_window_event(const SDL_WindowEvent& window_event, + std::vector& event_list); /** * \brief Converts an SDL key code to the custom Keycode type. * diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp index aaa8bdf..b7d2eb4 100644 --- a/src/crepe/system/InputSystem.cpp +++ b/src/crepe/system/InputSystem.cpp @@ -26,29 +26,31 @@ void InputSystem::update() { Transform & cam_transform = transform_vec.front().get(); int camera_origin_x = cam_transform.position.x + current_cam.data.postion_offset.x - (current_cam.viewport_size.x / 2); - int camera_origin_y = cam_transform.position.y + current_cam.data.postion_offset.y + int camera_origin_y = + ivec2 camera_origin; + camera_origin.y = cam_transform.position.y + current_cam.data.postion_offset.y - (current_cam.viewport_size.y / 2); - + camera_origin for (const SDLContext::EventData & event : event_list) { - int world_mouse_x = event.mouse_position.x + camera_origin_x; - int world_mouse_y = event.mouse_position.y + camera_origin_y; + int adjusted_mouse_x = event.mouse_data.mouse_position.x + camera_origin_x; + int adjusted_mouse_y = event.mouse_data.mouse_position.y + camera_origin_y; // check if the mouse is within the viewport bool mouse_in_viewport - = !(world_mouse_x < camera_origin_x - || world_mouse_x > camera_origin_x + current_cam.viewport_size.x - || world_mouse_y < camera_origin_y - || world_mouse_y > camera_origin_y + current_cam.viewport_size.y); + = !(adjusted_mouse_x < camera_origin_x + || adjusted_mouse_x > camera_origin_x + current_cam.viewport_size.x + || adjusted_mouse_y < camera_origin_y + || adjusted_mouse_y > camera_origin_y + current_cam.viewport_size.y); switch (event.event_type) { case SDLContext::EventType::KEYDOWN: event_mgr.queue_event(KeyPressEvent{ - .repeat = event.key_repeat, - .key = event.key, + .repeat = event.key_data.key_repeat, + .key = event.key_data.key, }); break; case SDLContext::EventType::KEYUP: event_mgr.queue_event(KeyReleaseEvent{ - .key = event.key, + .key = event.key_data.key, }); break; case SDLContext::EventType::MOUSEDOWN: @@ -56,36 +58,32 @@ void InputSystem::update() { break; } event_mgr.queue_event(MousePressEvent{ - .mouse_x = world_mouse_x, - .mouse_y = world_mouse_y, - .button = event.mouse_button, + .mouse_pos = {adjusted_mouse_x,adjusted_mouse_y}, + .button = event.mouse_data.mouse_button, }); - this->last_mouse_down_position = {world_mouse_x, world_mouse_y}; - this->last_mouse_button = event.mouse_button; + this->last_mouse_down_position = {adjusted_mouse_x, adjusted_mouse_y}; + this->last_mouse_button = event.mouse_data.mouse_button; break; case SDLContext::EventType::MOUSEUP: { if (!mouse_in_viewport) { break; } event_mgr.queue_event(MouseReleaseEvent{ - .mouse_x = world_mouse_x, - .mouse_y = world_mouse_y, - .button = event.mouse_button, + .mouse_pos = {adjusted_mouse_x,adjusted_mouse_y}, + .button = event.mouse_data.mouse_button, }); - //check if its a click by checking the last button down - int delta_x = world_mouse_x - this->last_mouse_down_position.x; - int delta_y = world_mouse_y - this->last_mouse_down_position.y; + int delta_x = adjusted_mouse_x - this->last_mouse_down_position.x; + int delta_y = adjusted_mouse_y - this->last_mouse_down_position.y; - if (this->last_mouse_button == event.mouse_button + if (this->last_mouse_button == event.mouse_data.mouse_button && std::abs(delta_x) <= click_tolerance && std::abs(delta_y) <= click_tolerance) { event_mgr.queue_event(MouseClickEvent{ - .mouse_x = world_mouse_x, - .mouse_y = world_mouse_y, - .button = event.mouse_button, + .mouse_pos = {adjusted_mouse_x,adjusted_mouse_y}, + .button = event.mouse_data.mouse_button, }); - this->handle_click(event.mouse_button, world_mouse_x, world_mouse_y); + this->handle_click(event.mouse_data.mouse_button, adjusted_mouse_x, adjusted_mouse_y); } } break; case SDLContext::EventType::MOUSEMOVE: @@ -93,31 +91,53 @@ void InputSystem::update() { break; } event_mgr.queue_event(MouseMoveEvent{ - .mouse_x = world_mouse_x, - .mouse_y = world_mouse_y, - .delta_x = event.rel_mouse_move.x, - .delta_y = event.rel_mouse_move.y, + .mouse_pos = {adjusted_mouse_x,adjusted_mouse_y}, + .mouse_delta = event.mouse_data.rel_mouse_move, }); - this->handle_move(event, world_mouse_x, world_mouse_y); + this->handle_move(event, adjusted_mouse_x, adjusted_mouse_y); break; case SDLContext::EventType::MOUSEWHEEL: event_mgr.queue_event(MouseScrollEvent{ - .mouse_x = world_mouse_x, - .mouse_y = world_mouse_y, - .scroll_direction = event.scroll_direction, - .scroll_delta = event.scroll_delta, + .mouse_pos = {adjusted_mouse_x,adjusted_mouse_y}, + .scroll_direction = event.mouse_data.scroll_direction, + .scroll_delta = event.mouse_data.scroll_delta, }); break; case SDLContext::EventType::SHUTDOWN: event_mgr.queue_event(ShutDownEvent{}); break; + case SDLContext::EventType::WINDOW_EXPOSE: + event_mgr.queue_event(WindowExposeEvent{}); + break; + case SDLContext::EventType::WINDOW_RESIZE: + event_mgr.queue_event(WindowResizeEvent{ + .dimensions = event.window_data.resize_dimension, + }); + break; + case SDLContext::EventType::WINDOW_MOVE: + event_mgr.queue_event(WindowMoveEvent{ + .delta_move = event.window_data.move_delta, + }); + break; + case SDLContext::EventType::WINDOW_MINIMIZE: + event_mgr.queue_event(WindowMinimizeEvent{}); + break; + case SDLContext::EventType::WINDOW_MAXIMIZE: + event_mgr.queue_event(WindowMaximizeEvent{}); + break; + case SDLContext::EventType::WINDOW_FOCUS_GAIN: + event_mgr.queue_event(WindowFocusGainEvent{}); + break; + case SDLContext::EventType::WINDOW_FOCUS_LOST: + event_mgr.queue_event(WindowFocusLostEvent{}); + break; default: break; } } } void InputSystem::handle_move(const SDLContext::EventData & event_data, - const int world_mouse_x, const int world_mouse_y) { + const int adjusted_mouse_x, const int adjusted_mouse_y) { ComponentManager & mgr = this->mediator.component_manager; RefVector