From bf177644dc5de58791eb80b11af9d6b4877b0a24 Mon Sep 17 00:00:00 2001 From: Loek Le Blansch Date: Fri, 8 Nov 2024 11:36:39 +0100 Subject: `make format` --- src/crepe/api/Config.cpp | 1 - src/crepe/api/Config.h | 6 ++--- src/crepe/api/SaveManager.cpp | 53 ++++++++++++++++++++++++++++--------------- src/crepe/api/SaveManager.h | 7 +++--- 4 files changed, 41 insertions(+), 26 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Config.cpp b/src/crepe/api/Config.cpp index d6206da..0100bcc 100644 --- a/src/crepe/api/Config.cpp +++ b/src/crepe/api/Config.cpp @@ -6,4 +6,3 @@ Config & Config::get_instance() { static Config instance; return instance; } - diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h index 56e3af5..8c9e643 100644 --- a/src/crepe/api/Config.h +++ b/src/crepe/api/Config.h @@ -7,6 +7,7 @@ namespace crepe { class Config { private: Config() = default; + public: ~Config() = default; @@ -16,8 +17,8 @@ public: // singleton Config(const Config &) = delete; Config(Config &&) = delete; - Config & operator = (const Config &) = delete; - Config & operator = (Config &&) = delete; + Config & operator=(const Config &) = delete; + Config & operator=(Config &&) = delete; public: //! Logging-related settings @@ -60,4 +61,3 @@ public: }; } // namespace crepe - diff --git a/src/crepe/api/SaveManager.cpp b/src/crepe/api/SaveManager.cpp index 23587e4..43276c5 100644 --- a/src/crepe/api/SaveManager.cpp +++ b/src/crepe/api/SaveManager.cpp @@ -2,8 +2,8 @@ #include "../util/log.h" #include "Config.h" -#include "ValueBroker.h" #include "SaveManager.h" +#include "ValueBroker.h" using namespace std; using namespace crepe; @@ -65,17 +65,33 @@ string SaveManager::deserialize(const string & value) const noexcept { return value; } -template <> uint8_t SaveManager::deserialize(const string & value) const noexcept { return deserialize(value); } -template <> int8_t SaveManager::deserialize(const string & value) const noexcept { return deserialize(value); } -template <> uint16_t SaveManager::deserialize(const string & value) const noexcept { return deserialize(value); } -template <> int16_t SaveManager::deserialize(const string & value) const noexcept { return deserialize(value); } -template <> uint32_t SaveManager::deserialize(const string & value) const noexcept { return deserialize(value); } -template <> int32_t SaveManager::deserialize(const string & value) const noexcept { return deserialize(value); } - -SaveManager::SaveManager() { - dbg_trace(); +template <> +uint8_t SaveManager::deserialize(const string & value) const noexcept { + return deserialize(value); +} +template <> +int8_t SaveManager::deserialize(const string & value) const noexcept { + return deserialize(value); +} +template <> +uint16_t SaveManager::deserialize(const string & value) const noexcept { + return deserialize(value); +} +template <> +int16_t SaveManager::deserialize(const string & value) const noexcept { + return deserialize(value); +} +template <> +uint32_t SaveManager::deserialize(const string & value) const noexcept { + return deserialize(value); +} +template <> +int32_t SaveManager::deserialize(const string & value) const noexcept { + return deserialize(value); } +SaveManager::SaveManager() { dbg_trace(); } + SaveManager & SaveManager::get_instance() { dbg_trace(); static SaveManager instance; @@ -118,17 +134,19 @@ template void SaveManager::set(const string &, const double &); template ValueBroker SaveManager::get(const string & key, const T & default_value) { - if (!this->has(key)) - this->set(key, default_value); + if (!this->has(key)) this->set(key, default_value); return this->get(key); } template ValueBroker SaveManager::get(const string &, const uint8_t &); template ValueBroker SaveManager::get(const string &, const int8_t &); -template ValueBroker SaveManager::get(const string &, const uint16_t &); +template ValueBroker SaveManager::get(const string &, + const uint16_t &); template ValueBroker SaveManager::get(const string &, const int16_t &); -template ValueBroker SaveManager::get(const string &, const uint32_t &); +template ValueBroker SaveManager::get(const string &, + const uint32_t &); template ValueBroker SaveManager::get(const string &, const int32_t &); -template ValueBroker SaveManager::get(const string &, const uint64_t &); +template ValueBroker SaveManager::get(const string &, + const uint64_t &); template ValueBroker SaveManager::get(const string &, const int64_t &); template ValueBroker SaveManager::get(const string &, const float &); template ValueBroker SaveManager::get(const string &, const double &); @@ -138,8 +156,8 @@ template ValueBroker SaveManager::get(const string & key) { T value; return { - [this, key] (const T & target) { this->set(key, target); }, - [this, key, value] () mutable -> const T & { + [this, key](const T & target) { this->set(key, target); }, + [this, key, value]() mutable -> const T & { value = this->deserialize(this->get_db().get(key)); return value; }, @@ -156,4 +174,3 @@ template ValueBroker SaveManager::get(const string &); template ValueBroker SaveManager::get(const string &); template ValueBroker SaveManager::get(const string &); template ValueBroker SaveManager::get(const string &); - diff --git a/src/crepe/api/SaveManager.h b/src/crepe/api/SaveManager.h index 3073656..4be85fb 100644 --- a/src/crepe/api/SaveManager.h +++ b/src/crepe/api/SaveManager.h @@ -93,8 +93,8 @@ public: static SaveManager & get_instance(); SaveManager(const SaveManager &) = delete; SaveManager(SaveManager &&) = delete; - SaveManager & operator = (const SaveManager &) = delete; - SaveManager & operator = (SaveManager &&) = delete; + SaveManager & operator=(const SaveManager &) = delete; + SaveManager & operator=(SaveManager &&) = delete; private: /** @@ -110,5 +110,4 @@ private: static DB & get_db(); }; -} - +} // namespace crepe -- cgit v1.2.3 From 9432900158e6a31815345fcf0af8d28ae34c6da9 Mon Sep 17 00:00:00 2001 From: heavydemon21 Date: Fri, 8 Nov 2024 11:44:21 +0100 Subject: code style --- src/compile.sh | 17 +++++ src/crepe/api/Animator.cpp | 23 ++++++ src/crepe/api/Animator.h | 87 ++++++++++++++++++++++ src/crepe/api/CMakeLists.txt | 4 + src/crepe/api/Camera.cpp | 15 ++++ src/crepe/api/Camera.h | 70 ++++++++++++++++++ src/crepe/api/Color.cpp | 3 +- src/crepe/api/Color.h | 17 +++-- src/crepe/api/Sprite.cpp | 4 + src/crepe/api/Sprite.h | 75 ++++++++++++++++++- src/crepe/api/Texture.cpp | 17 +++++ src/crepe/api/Texture.h | 60 +++++++++++++-- src/crepe/facade/SDLContext.cpp | 144 ++++++++++++++++++++---------------- src/crepe/facade/SDLContext.h | 126 +++++++++++++++++++++++++++++-- src/crepe/system/AnimatorSystem.cpp | 39 ++++++++++ src/crepe/system/AnimatorSystem.h | 53 +++++++++++++ src/crepe/system/CMakeLists.txt | 2 + src/crepe/system/RenderSystem.cpp | 35 ++++++--- src/crepe/system/RenderSystem.h | 69 ++++++++++++++++- 19 files changed, 759 insertions(+), 101 deletions(-) create mode 100755 src/compile.sh create mode 100644 src/crepe/api/Animator.cpp create mode 100644 src/crepe/api/Animator.h create mode 100644 src/crepe/api/Camera.cpp create mode 100644 src/crepe/api/Camera.h create mode 100644 src/crepe/system/AnimatorSystem.cpp create mode 100644 src/crepe/system/AnimatorSystem.h (limited to 'src/crepe/api') diff --git a/src/compile.sh b/src/compile.sh new file mode 100755 index 0000000..844f2d9 --- /dev/null +++ b/src/compile.sh @@ -0,0 +1,17 @@ + + + +cmake -B build -G Ninja + +ninja -C build + +#ninja -C build viewport + +#ninja -C build rendering + +#ninja -C build events + +#ninja -C build camera + +#ninja -C build animator + diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp new file mode 100644 index 0000000..3834e0b --- /dev/null +++ b/src/crepe/api/Animator.cpp @@ -0,0 +1,23 @@ + + +#include "Animator.h" +#include "Component.h" +#include "api/Sprite.h" + +#include "util/log.h" +#include + +using namespace crepe; + +Animator::Animator(uint32_t id, Sprite & ss, int row, int col, int col_animator) + : Component(id), spritesheet(ss), row(row), col(col){ + dbg_trace(); + + animator_rect = spritesheet.sprite_rect; + animator_rect.h /= col; + animator_rect.w /= row; + animator_rect.x = 0; + animator_rect.y = col_animator * animator_rect.h; + this->active = false; +} +Animator::~Animator() { dbg_trace(); } diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h new file mode 100644 index 0000000..3493623 --- /dev/null +++ b/src/crepe/api/Animator.h @@ -0,0 +1,87 @@ +#pragma once + +#include "Component.h" +#include "api/Sprite.h" +#include + +namespace crepe { +class AnimatorSystem; +class SDLContext; + + +/** + * \brief The Animator component is used to animate sprites by managing the movement + * and frame changes within a sprite sheet. + * + * This component allows for controlling sprite animation through rows and columns of a sprite sheet. + * It can be used to play animations, loop them, or stop them. + */ +class Animator : public Component { + +public: + //TODO: need to implement this + void loop(); + void stop(); + +public: + /** + * \brief Constructs an Animator object that will control animations for a sprite sheet. + * + * \param[in] id The unique identifier for the component, typically assigned automatically. + * \param[in] spritesheet A reference to the Sprite object which holds the sprite sheet for animation. + * \param[in] row The maximum number of rows in the sprite sheet. + * \param[in] col The maximum number of columns in the sprite sheet. + * \param[in] col__animate The specific col index of the sprite sheet to animate. This allows selecting which col to animate from multiple col in the sheet. + * + * This constructor sets up the Animator with the given parameters, and initializes the animation system. + */ + Animator(uint32_t id, Sprite & spritesheet, int row, int col, + int col_animate); + + /** + * \brief Destroys the Animator object and cleans up any resources. + * + * This destructor will handle any necessary cleanup when the Animator component is no longer needed. + */ + ~Animator(); + + //! Deleted copy constructor to prevent copying of the Animator instance. + Animator(const Animator &) = delete; + + //! Deleted move constructor to prevent moving of the Animator instance. + Animator(Animator &&) = delete; + + //! Deleted copy assignment operator to prevent copying the Animator instance. + Animator & operator=(const Animator &) = delete; + + //! Deleted move assignment operator to prevent moving the Animator instance. + Animator & operator=(Animator &&) = delete; + +private: + //! A reference to the Sprite sheet containing the animation frames. + Sprite & spritesheet; + + //! The maximum number of columns in the sprite sheet. + const int col; + + //! The maximum number of rows in the sprite sheet. + const int row; + + //! The current col being animated. + int curr_col = 0; + + //! The current row being animated. + int curr_row = 0; + + Rect animator_rect; + + //TODO: Is this necessary? + //int fps; + +private: + //! Friend class that can directly access the private members of the Animator. + friend class AnimatorSystem; + friend class SDLContext; +}; +} // namespace crepe +// diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt index 3b20142..87cbb09 100644 --- a/src/crepe/api/CMakeLists.txt +++ b/src/crepe/api/CMakeLists.txt @@ -16,6 +16,8 @@ target_sources(crepe PUBLIC Scene.cpp SceneManager.cpp Vector2.cpp + Camera.cpp + Animator.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -38,4 +40,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES Metadata.h SceneManager.h SceneManager.hpp + Camera.h + Animator.h ) diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp new file mode 100644 index 0000000..46a56b2 --- /dev/null +++ b/src/crepe/api/Camera.cpp @@ -0,0 +1,15 @@ + + +#include "Camera.h" +#include "Component.h" +#include "api/Color.h" +#include "util/log.h" +#include + +using namespace crepe; + +Camera::Camera(uint32_t id, const Color& color) : Component(id), bg_color(color), aspect_width(640), aspect_height(480), zoom(1), x(0),y(0){ + dbg_trace(); +} + +Camera::~Camera() { dbg_trace(); } diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h new file mode 100644 index 0000000..022496d --- /dev/null +++ b/src/crepe/api/Camera.h @@ -0,0 +1,70 @@ +#pragma once + +#include "Component.h" +#include "api/Color.h" +#include + +namespace crepe { + +/** + * \class Camera + * \brief Represents a camera component for rendering in the game. + * + * The Camera class defines the view parameters, including background color, + * aspect ratio, position, and zoom level. It controls what part of the game + * world is visible on the screen. + */ +class Camera : public Component { + +public: + /** + * \brief Constructs a Camera with the specified ID and background color. + * \param id Unique identifier for the camera component. + * \param bg_color Background color for the camera view. + */ + Camera(uint32_t id, const Color & bg_color); + + /** + * \brief Destroys the Camera instance. + */ + ~Camera(); + +public: + /** + * \brief Background color of the camera view. + */ + Color bg_color; + + /** + * \brief Aspect ratio height for the camera. + */ + double aspect_height; + + /** + * \brief Aspect ratio width for the camera. + */ + double aspect_width; + + /** + * \brief X-coordinate of the camera position. + */ + double x; + + /** + * \brief Y-coordinate of the camera position. + */ + double y; + + /** + * \brief Zoom level of the camera view. + */ + double zoom; + +public: + /** + * \brief Gets the maximum number of camera instances allowed. + * \return Maximum instance count as an integer. + */ + virtual int get_instances_max() const { return 10; } +}; +} // namespace crepe diff --git a/src/crepe/api/Color.cpp b/src/crepe/api/Color.cpp index fc6313d..9e5f187 100644 --- a/src/crepe/api/Color.cpp +++ b/src/crepe/api/Color.cpp @@ -11,8 +11,7 @@ Color Color::cyan = Color(0, 255, 255, 0); Color Color::yellow = Color(255, 255, 0, 0); Color Color::magenta = Color(255, 0, 255, 0); -// FIXME: do we really need double precision for color values? -Color::Color(double red, double green, double blue, double alpha) { +Color::Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) { this->a = alpha; this->r = red; this->g = green; diff --git a/src/crepe/api/Color.h b/src/crepe/api/Color.h index 6b54888..4ebe3a3 100644 --- a/src/crepe/api/Color.h +++ b/src/crepe/api/Color.h @@ -1,6 +1,8 @@ #pragma once -namespace crepe { +#include + +namespace crepe{ class Color { @@ -8,7 +10,7 @@ class Color { // instead? public: - Color(double red, double green, double blue, double alpha); + Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha); static const Color & get_white(); static const Color & get_red(); static const Color & get_green(); @@ -19,10 +21,10 @@ public: static const Color & get_black(); private: - double r; - double g; - double b; - double a; + uint8_t r; + uint8_t g; + uint8_t b; + uint8_t a; static Color white; static Color red; @@ -32,6 +34,9 @@ private: static Color magenta; static Color yellow; static Color black; + +private: + friend class SDLContext; }; } // namespace crepe diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp index d3465c7..3db8f2b 100644 --- a/src/crepe/api/Sprite.cpp +++ b/src/crepe/api/Sprite.cpp @@ -6,6 +6,7 @@ #include "Component.h" #include "Sprite.h" #include "Texture.h" +#include "facade/SDLContext.h" using namespace std; using namespace crepe; @@ -14,6 +15,9 @@ Sprite::Sprite(game_object_id_t id, shared_ptr image, const Color & color, const FlipSettings & flip) : Component(id), color(color), flip(flip), sprite_image(image) { dbg_trace(); + + this->sprite_rect.w = sprite_image->get_width(); + this->sprite_rect.h = sprite_image->get_height(); } Sprite::~Sprite() { dbg_trace(); } diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h index 00dcb27..2e8b52a 100644 --- a/src/crepe/api/Sprite.h +++ b/src/crepe/api/Sprite.h @@ -1,6 +1,5 @@ #pragma once -#include #include #include @@ -11,22 +10,92 @@ namespace crepe { +/** + * \struct Rect + * \brief Represents a rectangle area for rendering. + * + * Everything within the defined rectangle will be rendered. + * The SDLContext will translate this into the library's rectangle structure. + */ +struct Rect { + int w = 0; + int h = 0; + int x = 0; + int y = 0; +}; + +/** + * \struct FlipSettings + * \brief Flip settings for the sprite. + * + * Defines the horizontal and vertical flip settings for a sprite, which the + * SDLContext will translate into the corresponding settings for the library. + */ struct FlipSettings { - bool flip_x = true; - bool flip_y = true; + bool flip_x = false; + bool flip_y = false; }; +//! Forward declaration of the SDLContext facade. +class SDLContext; + +//! Forward declaration of the Animator class. +class Animator; + +//! Forward declaration of the AnimatorSystem class. +class AnimatorSystem; + +/** + * \class Sprite + * \brief Represents a renderable sprite component. + * + * A renderable sprite that can be displayed in the game. It includes a texture, + * color, and flip settings, and is managed in layers with defined sorting orders. + */ class Sprite : public Component { public: + /** + * \brief Constructs a Sprite with specified parameters. + * \param game_id Unique identifier for the game object this sprite belongs to. + * \param image Shared pointer to the texture for this sprite. + * \param color Color tint applied to the sprite. + * \param flip Flip settings for horizontal and vertical orientation. + */ Sprite(game_object_id_t id, std::shared_ptr image, const Color & color, const FlipSettings & flip); + + /** + * \brief Destroys the Sprite instance. + */ ~Sprite(); + + + //! Texture used for the sprite std::shared_ptr sprite_image; + //! Color tint of the sprite Color color; + //! Flip settings for the sprite FlipSettings flip; + //! Layer sorting level of the sprite uint8_t sorting_in_layer; + //! Order within the sorting layer uint8_t order_in_layer; + +public: + /** + * \brief Gets the maximum number of instances allowed for this sprite. + * \return Maximum instance count as an integer. + */ + virtual int get_instances_max() const { return 10; } + +private: + friend class SDLContext; + friend class Animator; + friend class AnimatorSystem; + + //! Render area of the sprite + Rect sprite_rect; }; } // namespace crepe diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp index 8fc5c13..5519e5e 100644 --- a/src/crepe/api/Texture.cpp +++ b/src/crepe/api/Texture.cpp @@ -30,3 +30,20 @@ void Texture::load(unique_ptr res) { SDLContext & ctx = SDLContext::get_instance(); this->texture = ctx.texture_from_path(res->canonical()); } + +int Texture::get_width() const{ + if (this->texture) { + return SDLContext::get_instance().get_width(*this); + } + else { + return 0; + } +} +int Texture::get_height() const{ + if (this->texture) { + return SDLContext::get_instance().get_height(*this); + } + else { + return 0; + } +} diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h index 9a86f6f..6d99a93 100644 --- a/src/crepe/api/Texture.h +++ b/src/crepe/api/Texture.h @@ -3,31 +3,75 @@ // FIXME: this header can't be included because this is an API header, and SDL2 // development headers won't be bundled with crepe. Why is this facade in the // API namespace? + #include #include #include "Asset.h" namespace crepe { + +//! Forward declaration of SDLContext class. class SDLContext; -} -namespace crepe { +//! Forward declaration of Animator class. +class Animator; +/** + * \class Texture + * \brief Manages texture loading and properties. + * + * The Texture class is responsible for loading an image from a source + * and providing access to its dimensions. Textures can be used for rendering. + */ class Texture { public: - Texture(const char * src); - Texture(std::unique_ptr res); - ~Texture(); + /** + * \brief Constructs a Texture from a file path. + * \param src Path to the image file to be loaded as a texture. + */ + Texture(const char * src); + + /** + * \brief Constructs a Texture from an Asset resource. + * \param res Unique pointer to an Asset resource containing texture data. + */ + Texture(std::unique_ptr res); + + /** + * \brief Destroys the Texture instance, freeing associated resources. + */ + ~Texture(); + + /** + * \brief Gets the width of the texture. + * \return Width of the texture in pixels. + */ + int get_width() const; + + /** + * \brief Gets the height of the texture. + * \return Height of the texture in pixels. + */ + int get_height() const; private: - void load(std::unique_ptr res); + /** + * \brief Loads the texture from an Asset resource. + * \param res Unique pointer to an Asset resource to load the texture from. + */ + void load(std::unique_ptr res); private: - SDL_Texture * texture = nullptr; + //! The texture of the class from the library + SDL_Texture * texture = nullptr; + + //! Grants SDLContext access to private members. + friend class SDLContext; - friend class crepe::SDLContext; + //! Grants Animator access to private members. + friend class Animator; }; } // namespace crepe diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 8da93e9..bbeb3a9 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -21,34 +22,6 @@ SDLContext & SDLContext::get_instance() { return instance; } -void SDLContext::handle_events(bool & running) { - SDL_Event event; - while (SDL_PollEvent(&event)) { - if (event.type == SDL_QUIT) { - running = false; - } - } -} - -SDLContext::~SDLContext() { - dbg_trace(); - - if (this->game_renderer != nullptr) - SDL_DestroyRenderer(this->game_renderer); - - if (this->game_window != nullptr) { - SDL_DestroyWindow(this->game_window); - } - - // TODO: how are we going to ensure that these are called from the same - // thread that SDL_Init() was called on? This has caused problems for me - // before. - IMG_Quit(); - SDL_Quit(); -} - -void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer); } - SDLContext::SDLContext() { dbg_trace(); // FIXME: read window defaults from config manager @@ -62,7 +35,7 @@ SDLContext::SDLContext() { this->game_window = SDL_CreateWindow( "Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, - 1920, 1080, SDL_WINDOW_SHOWN); + this->viewport.w, this->viewport.h, 0); if (!this->game_window) { // FIXME: throw exception std::cerr << "Window could not be created! SDL_Error: " @@ -87,55 +60,92 @@ SDLContext::SDLContext() { } } +SDLContext::~SDLContext() { + dbg_trace(); + + if (this->game_renderer != nullptr) + SDL_DestroyRenderer(this->game_renderer); + + if (this->game_window != nullptr) { + SDL_DestroyWindow(this->game_window); + } + + // TODO: how are we going to ensure that these are called from the same + // thread that SDL_Init() was called on? This has caused problems for me + // before. + IMG_Quit(); + SDL_Quit(); +} + +void SDLContext::handle_events(bool & running) { + //TODO: wouter i need events + /* + SDL_Event event; + SDL_PollEvent(&event); + switch (event.type) { + case SDL_QUIT: + running = false; + break; + case SDL_KEYDOWN: + triggerEvent(KeyPressedEvent(getCustomKey(event.key.keysym.sym))); + break; + case SDL_MOUSEBUTTONDOWN: + int x, y; + SDL_GetMouseState(&x, &y); + triggerEvent(MousePressedEvent(x, y)); + break; + } + */ +} + +void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer); } void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer); } -void SDLContext::draw(const Sprite & sprite, const Transform & transform) { +void SDLContext::draw(const Sprite & sprite, const Transform & transform, + const Camera & cam) { static SDL_RendererFlip render_flip = (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x) | (SDL_FLIP_VERTICAL * sprite.flip.flip_y)); - int w, h; - SDL_QueryTexture(sprite.sprite_image->texture, NULL, NULL, &w, &h); - // needs maybe camera for position + double adjusted_x = (transform.position.x - cam.x) * cam.zoom; + double adjusted_y = (transform.position.y - cam.y) * cam.zoom; + double adjusted_w = sprite.sprite_rect.w * transform.scale * cam.zoom; + double adjusted_h = sprite.sprite_rect.h * transform.scale * cam.zoom; + + SDL_Rect srcrect = { + .x = sprite.sprite_rect.x, + .y = sprite.sprite_rect.y, + .w = sprite.sprite_rect.w, + .h = sprite.sprite_rect.h, + }; + SDL_Rect dstrect = { - .x = static_cast(transform.position.x), - .y = static_cast(transform.position.y), - .w = static_cast(w * transform.scale), - .h = static_cast(h * transform.scale), + .x = static_cast(adjusted_x), + .y = static_cast(adjusted_y), + .w = static_cast(adjusted_w), + .h = static_cast(adjusted_h), }; double degrees = transform.rotation * 180 / M_PI; - SDL_RenderCopyEx(this->game_renderer, sprite.sprite_image->texture, NULL, - &dstrect, degrees, NULL, render_flip); -} -/* -SDL_Texture * SDLContext::setTextureFromPath(const char * path, SDL_Rect & clip, - const int row, const int col) { - dbg_trace(); + SDL_RenderCopyEx(this->game_renderer, sprite.sprite_image->texture, + &srcrect, - SDL_Surface * tmp = IMG_Load(path); - if (!tmp) { - std::cerr << "Error surface " << IMG_GetError << std::endl; - } - - clip. - w = tmp->w / col; - clip.h = tmp->h / row; - - SDL_Texture * CreatedTexture - = SDL_CreateTextureFromSurface(this->game_renderer, tmp); + &dstrect, degrees, NULL, render_flip); +} - if (!CreatedTexture) { - std::cerr << "Error could not create texture " << IMG_GetError - << std::endl; - } - SDL_FreeSurface(tmp); +void SDLContext::camera(const Camera & cam) { + this->viewport.w = static_cast(cam.aspect_width); + this->viewport.h = static_cast(cam.aspect_height); + this->viewport.x = static_cast(cam.x) - (SCREEN_WIDTH / 2); + this->viewport.y = static_cast(cam.y) - (SCREEN_HEIGHT / 2); - return CreatedTexture; + SDL_SetRenderDrawColor(this->game_renderer, cam.bg_color.r, cam.bg_color.g, + cam.bg_color.b, cam.bg_color.a); } -*/ + +const uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } SDL_Texture * SDLContext::texture_from_path(const char * path) { dbg_trace(); @@ -155,3 +165,13 @@ SDL_Texture * SDLContext::texture_from_path(const char * path) { return created_texture; } +int SDLContext::get_width(const Texture & ctx) { + int w; + SDL_QueryTexture(ctx.texture, NULL, NULL, &w, NULL); + return w; +} +int SDLContext::get_height(const Texture & ctx) { + int h; + SDL_QueryTexture(ctx.texture, NULL, NULL, NULL, &h); + return h; +} diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index f1ba8a6..a08d0d8 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -1,48 +1,160 @@ #pragma once +#include #include #include #include "../api/Sprite.h" #include "../api/Transform.h" -#include "../system/RenderSystem.h" +#include "api/Camera.h" + +typedef SDL_Keycode CREPE_KEYCODES; + +//FIXME: this needs to be removed +const int SCREEN_WIDTH = 640; +const int SCREEN_HEIGHT = 480; namespace crepe { class Texture; +class LoopManager; + +/** + * \class SDLContext + * \brief Facade for the SDL library + * + * SDLContext is a singleton that handles the SDL window and renderer, provides methods + * for event handling, and rendering to the screen. It is never used directly by the user + */ class SDLContext { public: - // singleton + /** + * \brief Gets the singleton instance of SDLContext. + * \return Reference to the SDLContext instance. + */ static SDLContext & get_instance(); + + /** + * \brief Deleted copy constructor. + */ SDLContext(const SDLContext &) = delete; + + /** + * \brief Deleted move constructor. + */ SDLContext(SDLContext &&) = delete; + + /** + * \brief Deleted copy assignment operator. + * \return Reference to the SDLContext instance. + */ SDLContext & operator=(const SDLContext &) = delete; - SDLContext & operator=(SDLContext &&) = delete; - //TODO decide events wouter? + /** + * \brief Deleted move assignment operator. + * \return Reference to the SDLContext instance. + */ + SDLContext & operator=(SDLContext &&) = delete; private: + friend class LoopManager; + /** + * \brief Handles SDL events such as window close and input. + * \param running Reference to a boolean flag that controls the main loop. + */ void handle_events(bool & running); + private: + friend class AnimatorSystem; + + /** + * \brief Gets the current SDL ticks since the program started. + * \return Current ticks in milliseconds as a constant uint64_t. + */ + const uint64_t get_ticks() const; + + +private: + /** + * \brief Constructs an SDLContext instance. + * Initializes SDL, creates a window and renderer. + */ SDLContext(); + + /** + * \brief Destroys the SDLContext instance. + * Cleans up SDL resources, including the window and renderer. + */ virtual ~SDLContext(); + + private: + friend class Texture; - SDL_Texture * texture_from_path(const char *); - //SDL_Texture* setTextureFromPath(const char*, SDL_Rect& clip, const int row, const int col); + friend class Animator; + + /** + * \brief Loads a texture from a file path. + * \param path Path to the image file. + * \return Pointer to the created SDL_Texture. + */ + SDL_Texture * texture_from_path(const char * path); + + /** + * \brief Gets the width of a texture. + * \param texture Reference to the Texture object. + * \return Width of the texture as an integer. + */ + int get_width(const Texture & ); + + /** + * \brief Gets the height of a texture. + * \param texture Reference to the Texture object. + * \return Height of the texture as an integer. + */ + int get_height(const Texture &); + private: + friend class RenderSystem; - void draw(const Sprite &, const Transform &); + + /** + * \brief Draws a sprite to the screen using the specified transform and camera. + * \param sprite Reference to the Sprite to draw. + * \param transform Reference to the Transform for positioning. + * \param camera Reference to the Camera for view adjustments. + */ + void draw(const Sprite & sprite, const Transform & transform, + const Camera & camera); + + /** + * \brief Clears the screen, preparing for a new frame. + */ void clear_screen(); + + /** + * \brief Presents the rendered frame to the screen. + */ void present_screen(); + /** + * \brief Sets the current camera for rendering. + * \param camera Reference to the Camera object. + */ + void camera(const Camera & camera); + private: + //! sdl window SDL_Window * game_window = nullptr; + //! renderer for the crepe engine SDL_Renderer * game_renderer = nullptr; + + //! viewport for the camera window + SDL_Rect viewport = {0, 0, 640, 480}; }; } // namespace crepe diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp new file mode 100644 index 0000000..052d264 --- /dev/null +++ b/src/crepe/system/AnimatorSystem.cpp @@ -0,0 +1,39 @@ + + +#include "AnimatorSystem.h" +#include "ComponentManager.h" +#include "facade/SDLContext.h" +#include "util/log.h" + +#include "api/Animator.h" + +#include +#include +#include + +using namespace crepe; + +AnimatorSystem::AnimatorSystem() { dbg_trace(); } + +AnimatorSystem::~AnimatorSystem() { dbg_trace(); } + +AnimatorSystem & AnimatorSystem::get_instance() { + static AnimatorSystem instance; + return instance; +} + +void AnimatorSystem::update() { + ComponentManager& mgr = ComponentManager::get_instance(); + + std::vector> animations = mgr.get_components_by_type(); + + uint64_t tick = SDLContext::get_instance().get_ticks(); + for(Animator& a : animations){ + if (a.active) { + a.curr_row = (tick / 100) % a.row; + a.animator_rect.x = (a.curr_row * a.animator_rect.w) + a.curr_col; + a.spritesheet.sprite_rect = a.animator_rect; + } + } +} + diff --git a/src/crepe/system/AnimatorSystem.h b/src/crepe/system/AnimatorSystem.h new file mode 100644 index 0000000..553b456 --- /dev/null +++ b/src/crepe/system/AnimatorSystem.h @@ -0,0 +1,53 @@ +#pragma once + +#include "System.h" + +namespace crepe { + +/** + * \brief The AnimatorSystem is responsible for managing and updating all Animator components. + * + * This system is responsible for controlling the behavior of the animations for all entities + * that have the Animator component attached. It updates the animations by controlling their + * frame changes, looping behavior, and overall animation state. + */ +class AnimatorSystem : public System { + +public: + /** + * \brief Retrieves the singleton instance of the AnimatorSystem. + * + * \return A reference to the single instance of the AnimatorSystem. + * + * This method ensures that there is only one instance of the AnimatorSystem, following the + * singleton design pattern. It can be used to access the system globally. + */ + static AnimatorSystem & get_instance(); + + /** + * \brief Updates the Animator components. + * + * This method is called periodically (likely every frame) to update the state of all + * Animator components, moving the animations forward and managing their behavior (e.g., looping). + */ + void update() override; + +private: + /** + * \brief Private constructor for the AnimatorSystem. + * + * The constructor is private to enforce the singleton pattern, ensuring that only + * one instance of this system can exist. + */ + AnimatorSystem(); + + /** + * \brief Private destructor for the AnimatorSystem. + * + * The destructor cleans up any resources used by the AnimatorSystem. It is private + * to maintain the singleton pattern and prevent direct deletion. + */ + ~AnimatorSystem(); +}; + +} // namespace crepe diff --git a/src/crepe/system/CMakeLists.txt b/src/crepe/system/CMakeLists.txt index ff6f66f..4c18b87 100644 --- a/src/crepe/system/CMakeLists.txt +++ b/src/crepe/system/CMakeLists.txt @@ -4,6 +4,7 @@ target_sources(crepe PUBLIC PhysicsSystem.cpp CollisionSystem.cpp RenderSystem.cpp + AnimatorSystem.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -12,4 +13,5 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES PhysicsSystem.h CollisionSystem.h RenderSystem.h + AnimatorSystem.h ) diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index 5a07cc2..149af68 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -20,7 +20,23 @@ RenderSystem & RenderSystem::get_instance() { return instance; } -void RenderSystem::update() { +void RenderSystem::clear_screen() { SDLContext::get_instance().clear_screen(); } + +void RenderSystem::present_screen() { + SDLContext::get_instance().present_screen(); +} +void RenderSystem::update_camera() { + ComponentManager & mgr = ComponentManager::get_instance(); + + std::vector> cameras + = mgr.get_components_by_type(); + + for (Camera & cam : cameras) { + SDLContext::get_instance().camera(cam); + this->curr_cam = &cam; + } +} +void RenderSystem::render_sprites() { ComponentManager & mgr = ComponentManager::get_instance(); @@ -28,14 +44,15 @@ void RenderSystem::update() { = mgr.get_components_by_type(); SDLContext & render = SDLContext::get_instance(); - render.clear_screen(); - for (const Sprite & sprite : sprites) { - std::vector> transforms - = mgr.get_components_by_id(sprite.game_object_id); - for (const Transform & transform : transforms) { - render.draw(sprite, transform); - } + auto transforms = mgr.get_components_by_id(sprite.game_object_id); + render.draw(sprite, transforms[0] , *curr_cam); } - render.present_screen(); +} + +void RenderSystem::update() { + this->clear_screen(); + this->update_camera(); + this->render_sprites(); + this->present_screen(); } diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h index 4b910a4..684776b 100644 --- a/src/crepe/system/RenderSystem.h +++ b/src/crepe/system/RenderSystem.h @@ -1,17 +1,78 @@ #pragma once #include "System.h" +#include "api/Camera.h" namespace crepe { +/** + * \class RenderSystem + * \brief Manages rendering operations for all game objects. + * + * RenderSystem is responsible for rendering sprites, clearing and presenting the screen, + * and managing the active camera. It functions as a singleton, providing centralized + * rendering services for the application. + */ class RenderSystem : public System { public: - static RenderSystem & get_instance(); - void update(); + /** + * \brief Gets the singleton instance of RenderSystem. + * \return Reference to the RenderSystem instance. + */ + static RenderSystem & get_instance(); + + /** + * \brief Updates the RenderSystem for the current frame. + * This method is called to perform all rendering operations for the current game frame. + */ + void update() override; + +private: + /** + * \brief Constructs a RenderSystem instance. + * Private constructor to enforce singleton pattern. + */ + RenderSystem(); + + /** + * \brief Destroys the RenderSystem instance. + */ + ~RenderSystem(); + + /** + * \brief Clears the screen in preparation for rendering. + */ + void clear_screen(); + + /** + * \brief Presents the rendered frame to the display. + */ + void present_screen(); + + /** + * \brief Updates the active camera used for rendering. + */ + void update_camera(); + + /** + * \brief Renders all active sprites to the screen. + */ + void render_sprites(); + + /** + * \todo Include color handling for sprites. + * \todo Implement particle emitter rendering with sprites. + * \todo Add text rendering using SDL_ttf for text components. + * \todo Implement a text component and a button component. + * \todo Ensure each sprite is checked for active status before rendering. + * \todo Sort all layers by order before rendering. + * \todo Consider adding text input functionality. + */ private: - RenderSystem(); - ~RenderSystem(); + //! Pointer to the current active camera for rendering + // \todo needs a better solution + Camera * curr_cam; }; } // namespace crepe -- cgit v1.2.3 From 2e0b75fc51c4ef025f6b74f7f1648d04039bb955 Mon Sep 17 00:00:00 2001 From: heavydemon21 Date: Fri, 8 Nov 2024 12:16:41 +0100 Subject: fixed the includes and const settings --- src/crepe/api/Animator.cpp | 6 +++--- src/crepe/api/Animator.h | 3 ++- src/crepe/api/Camera.cpp | 9 ++++++--- src/crepe/api/Camera.h | 3 ++- src/crepe/api/Sprite.cpp | 9 ++++----- src/crepe/api/Sprite.h | 6 +++--- src/crepe/api/Texture.cpp | 2 +- src/crepe/facade/SDLContext.cpp | 12 ++++++------ src/crepe/facade/SDLContext.h | 12 ++++++------ src/crepe/system/AnimatorSystem.cpp | 9 ++++----- src/crepe/system/RenderSystem.cpp | 6 +++--- src/crepe/system/RenderSystem.h | 6 +++--- 12 files changed, 43 insertions(+), 40 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp index 3834e0b..0896bb0 100644 --- a/src/crepe/api/Animator.cpp +++ b/src/crepe/api/Animator.cpp @@ -1,11 +1,11 @@ +#include -#include "Animator.h" #include "Component.h" #include "api/Sprite.h" - #include "util/log.h" -#include + +#include "Animator.h" using namespace crepe; diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h index 3493623..ec29a7f 100644 --- a/src/crepe/api/Animator.h +++ b/src/crepe/api/Animator.h @@ -1,8 +1,9 @@ #pragma once +#include + #include "Component.h" #include "api/Sprite.h" -#include namespace crepe { class AnimatorSystem; diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp index 46a56b2..d423131 100644 --- a/src/crepe/api/Camera.cpp +++ b/src/crepe/api/Camera.cpp @@ -1,14 +1,17 @@ +#include -#include "Camera.h" #include "Component.h" #include "api/Color.h" #include "util/log.h" -#include + +#include "Camera.h" using namespace crepe; -Camera::Camera(uint32_t id, const Color& color) : Component(id), bg_color(color), aspect_width(640), aspect_height(480), zoom(1), x(0),y(0){ +Camera::Camera(uint32_t id, const Color & color) + : Component(id), bg_color(color), aspect_width(640), aspect_height(480), + zoom(1), x(0), y(0) { dbg_trace(); } diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h index 022496d..1ff9f37 100644 --- a/src/crepe/api/Camera.h +++ b/src/crepe/api/Camera.h @@ -1,8 +1,9 @@ #pragma once +#include + #include "Component.h" #include "api/Color.h" -#include namespace crepe { diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp index 3db8f2b..42e1177 100644 --- a/src/crepe/api/Sprite.cpp +++ b/src/crepe/api/Sprite.cpp @@ -1,17 +1,16 @@ -#include #include -#include "../util/log.h" - #include "Component.h" -#include "Sprite.h" #include "Texture.h" #include "facade/SDLContext.h" +#include "../util/log.h" + +#include "Sprite.h" using namespace std; using namespace crepe; -Sprite::Sprite(game_object_id_t id, shared_ptr image, +Sprite::Sprite(game_object_id_t id, const shared_ptr image, const Color & color, const FlipSettings & flip) : Component(id), color(color), flip(flip), sprite_image(image) { dbg_trace(); diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h index 2e8b52a..6f83ac8 100644 --- a/src/crepe/api/Sprite.h +++ b/src/crepe/api/Sprite.h @@ -5,9 +5,9 @@ #include "api/Color.h" #include "api/Texture.h" - #include "Component.h" + namespace crepe { /** @@ -62,7 +62,7 @@ public: * \param color Color tint applied to the sprite. * \param flip Flip settings for horizontal and vertical orientation. */ - Sprite(game_object_id_t id, std::shared_ptr image, + Sprite(game_object_id_t id, const std::shared_ptr image, const Color & color, const FlipSettings & flip); /** @@ -72,7 +72,7 @@ public: //! Texture used for the sprite - std::shared_ptr sprite_image; + const std::shared_ptr sprite_image; //! Color tint of the sprite Color color; //! Flip settings for the sprite diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp index 5519e5e..f052e4d 100644 --- a/src/crepe/api/Texture.cpp +++ b/src/crepe/api/Texture.cpp @@ -2,8 +2,8 @@ #include "../facade/SDLContext.h" #include "../util/log.h" - #include "Asset.h" + #include "Texture.h" using namespace crepe; diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index bbeb3a9..9a2d15a 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -98,11 +98,11 @@ void SDLContext::handle_events(bool & running) { */ } -void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer); } -void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer); } +void SDLContext::clear_screen() const { SDL_RenderClear(this->game_renderer); } +void SDLContext::present_screen() const { SDL_RenderPresent(this->game_renderer); } void SDLContext::draw(const Sprite & sprite, const Transform & transform, - const Camera & cam) { + const Camera & cam) const { static SDL_RendererFlip render_flip = (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x) @@ -147,7 +147,7 @@ void SDLContext::camera(const Camera & cam) { const uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } -SDL_Texture * SDLContext::texture_from_path(const char * path) { +SDL_Texture * SDLContext::texture_from_path(const char * path) const { dbg_trace(); SDL_Surface * tmp = IMG_Load(path); @@ -165,12 +165,12 @@ SDL_Texture * SDLContext::texture_from_path(const char * path) { return created_texture; } -int SDLContext::get_width(const Texture & ctx) { +int SDLContext::get_width(const Texture & ctx) const { int w; SDL_QueryTexture(ctx.texture, NULL, NULL, &w, NULL); return w; } -int SDLContext::get_height(const Texture & ctx) { +int SDLContext::get_height(const Texture & ctx) const { int h; SDL_QueryTexture(ctx.texture, NULL, NULL, NULL, &h); return h; diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index a08d0d8..3396697 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -101,21 +101,21 @@ private: * \param path Path to the image file. * \return Pointer to the created SDL_Texture. */ - SDL_Texture * texture_from_path(const char * path); + SDL_Texture * texture_from_path(const char * path) const; /** * \brief Gets the width of a texture. * \param texture Reference to the Texture object. * \return Width of the texture as an integer. */ - int get_width(const Texture & ); + int get_width(const Texture & ) const ; /** * \brief Gets the height of a texture. * \param texture Reference to the Texture object. * \return Height of the texture as an integer. */ - int get_height(const Texture &); + int get_height(const Texture &) const ; private: @@ -129,17 +129,17 @@ private: * \param camera Reference to the Camera for view adjustments. */ void draw(const Sprite & sprite, const Transform & transform, - const Camera & camera); + const Camera & camera) const; /** * \brief Clears the screen, preparing for a new frame. */ - void clear_screen(); + void clear_screen() const ; /** * \brief Presents the rendered frame to the screen. */ - void present_screen(); + void present_screen() const ; /** * \brief Sets the current camera for rendering. diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp index 052d264..3d6c807 100644 --- a/src/crepe/system/AnimatorSystem.cpp +++ b/src/crepe/system/AnimatorSystem.cpp @@ -1,15 +1,14 @@ +#include +#include +#include -#include "AnimatorSystem.h" #include "ComponentManager.h" #include "facade/SDLContext.h" #include "util/log.h" - #include "api/Animator.h" -#include -#include -#include +#include "AnimatorSystem.h" using namespace crepe; diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index 149af68..849d810 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -20,9 +20,9 @@ RenderSystem & RenderSystem::get_instance() { return instance; } -void RenderSystem::clear_screen() { SDLContext::get_instance().clear_screen(); } +void RenderSystem::clear_screen() const { SDLContext::get_instance().clear_screen(); } -void RenderSystem::present_screen() { +void RenderSystem::present_screen() const { SDLContext::get_instance().present_screen(); } void RenderSystem::update_camera() { @@ -36,7 +36,7 @@ void RenderSystem::update_camera() { this->curr_cam = &cam; } } -void RenderSystem::render_sprites() { +void RenderSystem::render_sprites() const { ComponentManager & mgr = ComponentManager::get_instance(); diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h index 684776b..c5e674a 100644 --- a/src/crepe/system/RenderSystem.h +++ b/src/crepe/system/RenderSystem.h @@ -43,12 +43,12 @@ private: /** * \brief Clears the screen in preparation for rendering. */ - void clear_screen(); + void clear_screen() const; /** * \brief Presents the rendered frame to the display. */ - void present_screen(); + void present_screen() const; /** * \brief Updates the active camera used for rendering. @@ -58,7 +58,7 @@ private: /** * \brief Renders all active sprites to the screen. */ - void render_sprites(); + void render_sprites() const; /** * \todo Include color handling for sprites. -- cgit v1.2.3 From cb6aae1751a95a29bc04d805d9cc9135b5c54c1e Mon Sep 17 00:00:00 2001 From: heavydemon21 Date: Fri, 8 Nov 2024 12:29:55 +0100 Subject: fixed include code-style --- src/crepe/api/Animator.cpp | 4 ++-- src/crepe/api/Animator.h | 2 +- src/crepe/api/Camera.cpp | 4 ++-- src/crepe/api/Camera.h | 2 +- src/crepe/api/Sprite.cpp | 4 ++-- src/crepe/api/Sprite.h | 4 ++-- src/crepe/api/Texture.cpp | 2 +- src/crepe/system/RenderSystem.h | 4 +++- 8 files changed, 14 insertions(+), 12 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp index 0896bb0..4b4d4be 100644 --- a/src/crepe/api/Animator.cpp +++ b/src/crepe/api/Animator.cpp @@ -1,10 +1,10 @@ #include -#include "Component.h" -#include "api/Sprite.h" #include "util/log.h" +#include "Component.h" +#include "Sprite.h" #include "Animator.h" using namespace crepe; diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h index ec29a7f..ede1610 100644 --- a/src/crepe/api/Animator.h +++ b/src/crepe/api/Animator.h @@ -3,7 +3,7 @@ #include #include "Component.h" -#include "api/Sprite.h" +#include "Sprite.h" namespace crepe { class AnimatorSystem; diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp index d423131..dbbfb32 100644 --- a/src/crepe/api/Camera.cpp +++ b/src/crepe/api/Camera.cpp @@ -1,10 +1,10 @@ #include -#include "Component.h" -#include "api/Color.h" #include "util/log.h" +#include "Component.h" +#include "Color.h" #include "Camera.h" using namespace crepe; diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h index 1ff9f37..7587b44 100644 --- a/src/crepe/api/Camera.h +++ b/src/crepe/api/Camera.h @@ -3,7 +3,7 @@ #include #include "Component.h" -#include "api/Color.h" +#include "Color.h" namespace crepe { diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp index 42e1177..db96c32 100644 --- a/src/crepe/api/Sprite.cpp +++ b/src/crepe/api/Sprite.cpp @@ -1,10 +1,10 @@ #include -#include "Component.h" -#include "Texture.h" #include "facade/SDLContext.h" #include "../util/log.h" +#include "Component.h" +#include "Texture.h" #include "Sprite.h" using namespace std; diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h index 6f83ac8..51cb860 100644 --- a/src/crepe/api/Sprite.h +++ b/src/crepe/api/Sprite.h @@ -3,8 +3,8 @@ #include #include -#include "api/Color.h" -#include "api/Texture.h" +#include "Color.h" +#include "Texture.h" #include "Component.h" diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp index f052e4d..5519e5e 100644 --- a/src/crepe/api/Texture.cpp +++ b/src/crepe/api/Texture.cpp @@ -2,8 +2,8 @@ #include "../facade/SDLContext.h" #include "../util/log.h" -#include "Asset.h" +#include "Asset.h" #include "Texture.h" using namespace crepe; diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h index c5e674a..ec80a0e 100644 --- a/src/crepe/system/RenderSystem.h +++ b/src/crepe/system/RenderSystem.h @@ -1,8 +1,10 @@ #pragma once -#include "System.h" #include "api/Camera.h" +#include "System.h" + + namespace crepe { /** -- cgit v1.2.3 From 91a277c69fd5f8ba814adc1006a49c7415ff65be Mon Sep 17 00:00:00 2001 From: heavydemon21 Date: Fri, 8 Nov 2024 17:31:25 +0100 Subject: updated to satisfy the code review --- src/crepe/api/Animator.h | 14 ++++++----- src/crepe/api/Camera.h | 26 ++++++-------------- src/crepe/api/Sprite.h | 36 ++++++++++----------------- src/crepe/api/Texture.cpp | 16 +++--------- src/crepe/api/Texture.h | 1 + src/crepe/facade/SDLContext.cpp | 17 +++++++------ src/crepe/facade/SDLContext.h | 49 ++++++++++++------------------------- src/crepe/system/AnimatorSystem.cpp | 2 +- 8 files changed, 60 insertions(+), 101 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h index ede1610..42ce957 100644 --- a/src/crepe/api/Animator.h +++ b/src/crepe/api/Animator.h @@ -28,11 +28,11 @@ public: /** * \brief Constructs an Animator object that will control animations for a sprite sheet. * - * \param[in] id The unique identifier for the component, typically assigned automatically. - * \param[in] spritesheet A reference to the Sprite object which holds the sprite sheet for animation. - * \param[in] row The maximum number of rows in the sprite sheet. - * \param[in] col The maximum number of columns in the sprite sheet. - * \param[in] col__animate The specific col index of the sprite sheet to animate. This allows selecting which col to animate from multiple col in the sheet. + * \param id The unique identifier for the component, typically assigned automatically. + * \param spritesheet A reference to the Sprite object which holds the sprite sheet for animation. + * \param row The maximum number of rows in the sprite sheet. + * \param col The maximum number of columns in the sprite sheet. + * \param col__animate The specific col index of the sprite sheet to animate. This allows selecting which col to animate from multiple col in the sheet. * * This constructor sets up the Animator with the given parameters, and initializes the animation system. */ @@ -80,8 +80,10 @@ private: //int fps; private: - //! Friend class that can directly access the private members of the Animator. + //! AnimatorSystem adjust the private member parameters of Animator; friend class AnimatorSystem; + + //! SDLContext reads the Animator member var's friend class SDLContext; }; } // namespace crepe diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h index 7587b44..708a523 100644 --- a/src/crepe/api/Camera.h +++ b/src/crepe/api/Camera.h @@ -2,8 +2,8 @@ #include -#include "Component.h" #include "Color.h" +#include "Component.h" namespace crepe { @@ -31,34 +31,22 @@ public: ~Camera(); public: - /** - * \brief Background color of the camera view. - */ + //! \brief Background color of the camera view. Color bg_color; - /** - * \brief Aspect ratio height for the camera. - */ + //! \brief Aspect ratio height for the camera. double aspect_height; - /** - * \brief Aspect ratio width for the camera. - */ + //! \brief Aspect ratio width for the camera. double aspect_width; - /** - * \brief X-coordinate of the camera position. - */ + //! \brief X-coordinate of the camera position. double x; - /** - * \brief Y-coordinate of the camera position. - */ + //! \brief Y-coordinate of the camera position. double y; - /** - * \brief Zoom level of the camera view. - */ + //! \brief Zoom level of the camera view. double zoom; public: diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h index 51cb860..1db32d7 100644 --- a/src/crepe/api/Sprite.h +++ b/src/crepe/api/Sprite.h @@ -10,13 +10,6 @@ namespace crepe { -/** - * \struct Rect - * \brief Represents a rectangle area for rendering. - * - * Everything within the defined rectangle will be rendered. - * The SDLContext will translate this into the library's rectangle structure. - */ struct Rect { int w = 0; int h = 0; @@ -24,29 +17,16 @@ struct Rect { int y = 0; }; -/** - * \struct FlipSettings - * \brief Flip settings for the sprite. - * - * Defines the horizontal and vertical flip settings for a sprite, which the - * SDLContext will translate into the corresponding settings for the library. - */ struct FlipSettings { bool flip_x = false; bool flip_y = false; }; -//! Forward declaration of the SDLContext facade. class SDLContext; - -//! Forward declaration of the Animator class. class Animator; - -//! Forward declaration of the AnimatorSystem class. class AnimatorSystem; /** - * \class Sprite * \brief Represents a renderable sprite component. * * A renderable sprite that can be displayed in the game. It includes a texture, @@ -55,6 +35,9 @@ class AnimatorSystem; class Sprite : public Component { public: + + // TODO: Loek comment in github #27 will be looked another time + // about shared_ptr Texture /** * \brief Constructs a Sprite with specified parameters. * \param game_id Unique identifier for the game object this sprite belongs to. @@ -78,23 +61,30 @@ public: //! Flip settings for the sprite FlipSettings flip; //! Layer sorting level of the sprite - uint8_t sorting_in_layer; + uint8_t sorting_in_layer = 0; //! Order within the sorting layer - uint8_t order_in_layer; + uint8_t order_in_layer = 0; public: /** * \brief Gets the maximum number of instances allowed for this sprite. * \return Maximum instance count as an integer. + * + * For now is this number randomly picked. I think it will eventually be 1. */ virtual int get_instances_max() const { return 10; } private: + //! Reads the sprite_rect of sprite friend class SDLContext; + + //! Reads the all the variables plus the sprite_rect friend class Animator; + + //! Reads the all the variables plus the sprite_rect friend class AnimatorSystem; - //! Render area of the sprite + //! Render area of the sprite this will also be adjusted by the AnimatorSystem if an Animator object is present in GameObject Rect sprite_rect; }; diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp index 5519e5e..e6c2e05 100644 --- a/src/crepe/api/Texture.cpp +++ b/src/crepe/api/Texture.cpp @@ -32,18 +32,10 @@ void Texture::load(unique_ptr res) { } int Texture::get_width() const{ - if (this->texture) { - return SDLContext::get_instance().get_width(*this); - } - else { - return 0; - } + if (this->texture == nullptr) return 0; + return SDLContext::get_instance().get_width(*this); } int Texture::get_height() const{ - if (this->texture) { - return SDLContext::get_instance().get_height(*this); - } - else { - return 0; - } + if (this->texture == nullptr) return 0; + return SDLContext::get_instance().get_width(*this); } diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h index 6d99a93..828518d 100644 --- a/src/crepe/api/Texture.h +++ b/src/crepe/api/Texture.h @@ -64,6 +64,7 @@ private: void load(std::unique_ptr res); private: + //TODO make RAII //! The texture of the class from the library SDL_Texture * texture = nullptr; diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 9a2d15a..cedb7b8 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include "../api/Sprite.h" #include "../api/Texture.h" @@ -98,13 +99,15 @@ void SDLContext::handle_events(bool & running) { */ } -void SDLContext::clear_screen() const { SDL_RenderClear(this->game_renderer); } -void SDLContext::present_screen() const { SDL_RenderPresent(this->game_renderer); } +void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer); } +void SDLContext::present_screen() { + SDL_RenderPresent(this->game_renderer); +} void SDLContext::draw(const Sprite & sprite, const Transform & transform, - const Camera & cam) const { + const Camera & cam) { - static SDL_RendererFlip render_flip + SDL_RendererFlip render_flip = (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x) | (SDL_FLIP_VERTICAL * sprite.flip.flip_y)); @@ -147,10 +150,10 @@ void SDLContext::camera(const Camera & cam) { const uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } -SDL_Texture * SDLContext::texture_from_path(const char * path) const { - dbg_trace(); +//TODO: make this RAII +SDL_Texture * SDLContext::texture_from_path(const std::string & path) { - SDL_Surface * tmp = IMG_Load(path); + SDL_Surface * tmp = IMG_Load(path.c_str()); if (!tmp) { std::cerr << "Error surface " << IMG_GetError << std::endl; } diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 3396697..80b76dd 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -3,18 +3,18 @@ #include #include #include +#include #include "../api/Sprite.h" #include "../api/Transform.h" #include "api/Camera.h" -typedef SDL_Keycode CREPE_KEYCODES; - //FIXME: this needs to be removed const int SCREEN_WIDTH = 640; const int SCREEN_HEIGHT = 480; namespace crepe { +typedef SDL_Keycode CREPE_KEYCODES; class Texture; class LoopManager; @@ -35,29 +35,13 @@ public: */ static SDLContext & get_instance(); - /** - * \brief Deleted copy constructor. - */ SDLContext(const SDLContext &) = delete; - - /** - * \brief Deleted move constructor. - */ SDLContext(SDLContext &&) = delete; - - /** - * \brief Deleted copy assignment operator. - * \return Reference to the SDLContext instance. - */ SDLContext & operator=(const SDLContext &) = delete; - - /** - * \brief Deleted move assignment operator. - * \return Reference to the SDLContext instance. - */ SDLContext & operator=(SDLContext &&) = delete; private: + //! will only use handle_events friend class LoopManager; /** * \brief Handles SDL events such as window close and input. @@ -65,8 +49,8 @@ private: */ void handle_events(bool & running); - private: + //! Will only use get_ticks friend class AnimatorSystem; /** @@ -75,7 +59,6 @@ private: */ const uint64_t get_ticks() const; - private: /** * \brief Constructs an SDLContext instance. @@ -87,13 +70,13 @@ private: * \brief Destroys the SDLContext instance. * Cleans up SDL resources, including the window and renderer. */ - virtual ~SDLContext(); - - + ~SDLContext(); private: - + //! Will use the funtions: texture_from_path, get_width,get_height. friend class Texture; + + //! Will use the funtions: texture_from_path, get_width,get_height. friend class Animator; /** @@ -101,25 +84,24 @@ private: * \param path Path to the image file. * \return Pointer to the created SDL_Texture. */ - SDL_Texture * texture_from_path(const char * path) const; + SDL_Texture * texture_from_path(const std::string & path); /** * \brief Gets the width of a texture. * \param texture Reference to the Texture object. * \return Width of the texture as an integer. */ - int get_width(const Texture & ) const ; + int get_width(const Texture &) const; /** * \brief Gets the height of a texture. * \param texture Reference to the Texture object. * \return Height of the texture as an integer. */ - int get_height(const Texture &) const ; - + int get_height(const Texture &) const; private: - + //! Will use draw,clear_screen, present_screen, camera. friend class RenderSystem; /** @@ -129,17 +111,17 @@ private: * \param camera Reference to the Camera for view adjustments. */ void draw(const Sprite & sprite, const Transform & transform, - const Camera & camera) const; + const Camera & camera); /** * \brief Clears the screen, preparing for a new frame. */ - void clear_screen() const ; + void clear_screen(); /** * \brief Presents the rendered frame to the screen. */ - void present_screen() const ; + void present_screen(); /** * \brief Sets the current camera for rendering. @@ -148,6 +130,7 @@ private: void camera(const Camera & camera); private: + //TODO: Make this RAII //! sdl window SDL_Window * game_window = nullptr; //! renderer for the crepe engine diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp index 3d6c807..4ea889a 100644 --- a/src/crepe/system/AnimatorSystem.cpp +++ b/src/crepe/system/AnimatorSystem.cpp @@ -3,11 +3,11 @@ #include #include -#include "ComponentManager.h" #include "facade/SDLContext.h" #include "util/log.h" #include "api/Animator.h" +#include "ComponentManager.h" #include "AnimatorSystem.h" using namespace crepe; -- cgit v1.2.3 From ba713ba89127e3b4a24f204f67bccaa9c2972916 Mon Sep 17 00:00:00 2001 From: heavydemon21 Date: Fri, 8 Nov 2024 18:04:36 +0100 Subject: Made it RAII --- src/crepe/api/Texture.cpp | 6 ++---- src/crepe/api/Texture.h | 6 ++++-- src/crepe/api/Transform.h | 2 +- src/crepe/facade/SDLContext.cpp | 40 +++++++++++++++++----------------------- src/crepe/facade/SDLContext.h | 17 +++++++++++++---- 5 files changed, 37 insertions(+), 34 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp index e6c2e05..1eac655 100644 --- a/src/crepe/api/Texture.cpp +++ b/src/crepe/api/Texture.cpp @@ -21,14 +21,12 @@ Texture::Texture(const char * src) { Texture::~Texture() { dbg_trace(); - if (this->texture != nullptr) { - SDL_DestroyTexture(this->texture); - } + this->texture.reset(); } void Texture::load(unique_ptr res) { SDLContext & ctx = SDLContext::get_instance(); - this->texture = ctx.texture_from_path(res->canonical()); + this->texture.reset(ctx.texture_from_path(res->canonical())); } int Texture::get_width() const{ diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h index 828518d..0cacfe5 100644 --- a/src/crepe/api/Texture.h +++ b/src/crepe/api/Texture.h @@ -64,9 +64,11 @@ private: void load(std::unique_ptr res); private: - //TODO make RAII + struct TextureDeleter{ + void operator()(SDL_Texture* texture) const { SDL_DestroyTexture(texture);} + }; //! The texture of the class from the library - SDL_Texture * texture = nullptr; + std::unique_ptr texture; //! Grants SDLContext access to private members. friend class SDLContext; diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h index d7a5b8a..756e45b 100644 --- a/src/crepe/api/Transform.h +++ b/src/crepe/api/Transform.h @@ -32,7 +32,7 @@ public: public: //! Translation (shift) Vector2 position; - //! Rotation, in radians + //! Rotation, in degrees double rotation; //! Multiplication factor double scale; diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index cedb7b8..770e93b 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -34,22 +34,22 @@ SDLContext::SDLContext() { return; } - this->game_window = SDL_CreateWindow( + this->game_window.reset(SDL_CreateWindow( "Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, - this->viewport.w, this->viewport.h, 0); + this->viewport.w, this->viewport.h, 0)); if (!this->game_window) { // FIXME: throw exception std::cerr << "Window could not be created! SDL_Error: " << SDL_GetError() << std::endl; } - this->game_renderer - = SDL_CreateRenderer(this->game_window, -1, SDL_RENDERER_ACCELERATED); + this->game_renderer.reset(SDL_CreateRenderer(this->game_window.get(), -1, + SDL_RENDERER_ACCELERATED)); if (!this->game_renderer) { // FIXME: throw exception std::cerr << "Renderer could not be created! SDL_Error: " << SDL_GetError() << std::endl; - SDL_DestroyWindow(this->game_window); + SDL_DestroyWindow(this->game_window.get()); return; } @@ -64,12 +64,8 @@ SDLContext::SDLContext() { SDLContext::~SDLContext() { dbg_trace(); - if (this->game_renderer != nullptr) - SDL_DestroyRenderer(this->game_renderer); - - if (this->game_window != nullptr) { - SDL_DestroyWindow(this->game_window); - } + this->game_renderer.reset(); + this->game_window.reset(); // TODO: how are we going to ensure that these are called from the same // thread that SDL_Init() was called on? This has caused problems for me @@ -99,9 +95,9 @@ void SDLContext::handle_events(bool & running) { */ } -void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer); } +void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer.get()); } void SDLContext::present_screen() { - SDL_RenderPresent(this->game_renderer); + SDL_RenderPresent(this->game_renderer.get()); } void SDLContext::draw(const Sprite & sprite, const Transform & transform, @@ -130,12 +126,10 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform, .h = static_cast(adjusted_h), }; - double degrees = transform.rotation * 180 / M_PI; - - SDL_RenderCopyEx(this->game_renderer, sprite.sprite_image->texture, - &srcrect, + SDL_RenderCopyEx(this->game_renderer.get(), + sprite.sprite_image->texture.get(), &srcrect, - &dstrect, degrees, NULL, render_flip); + &dstrect, transform.rotation, NULL, render_flip); } void SDLContext::camera(const Camera & cam) { @@ -144,8 +138,8 @@ void SDLContext::camera(const Camera & cam) { this->viewport.x = static_cast(cam.x) - (SCREEN_WIDTH / 2); this->viewport.y = static_cast(cam.y) - (SCREEN_HEIGHT / 2); - SDL_SetRenderDrawColor(this->game_renderer, cam.bg_color.r, cam.bg_color.g, - cam.bg_color.b, cam.bg_color.a); + SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, + cam.bg_color.g, cam.bg_color.b, cam.bg_color.a); } const uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } @@ -158,7 +152,7 @@ SDL_Texture * SDLContext::texture_from_path(const std::string & path) { std::cerr << "Error surface " << IMG_GetError << std::endl; } SDL_Texture * created_texture - = SDL_CreateTextureFromSurface(this->game_renderer, tmp); + = SDL_CreateTextureFromSurface(this->game_renderer.get(), tmp); if (!created_texture) { std::cerr << "Error could not create texture " << IMG_GetError @@ -170,11 +164,11 @@ SDL_Texture * SDLContext::texture_from_path(const std::string & path) { } int SDLContext::get_width(const Texture & ctx) const { int w; - SDL_QueryTexture(ctx.texture, NULL, NULL, &w, NULL); + SDL_QueryTexture(ctx.texture.get(), NULL, NULL, &w, NULL); return w; } int SDLContext::get_height(const Texture & ctx) const { int h; - SDL_QueryTexture(ctx.texture, NULL, NULL, NULL, &h); + SDL_QueryTexture(ctx.texture.get(), NULL, NULL, NULL, &h); return h; } diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 80b76dd..0a8dbcf 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -3,6 +3,7 @@ #include #include #include +#include #include #include "../api/Sprite.h" @@ -130,11 +131,19 @@ private: void camera(const Camera & camera); private: - //TODO: Make this RAII - //! sdl window - SDL_Window * game_window = nullptr; + struct WindowDeleter { + void operator()(SDL_Window * window) { SDL_DestroyWindow(window); } + }; + + struct RendererDeleter { + void operator()(SDL_Renderer * renderer) { SDL_DestroyRenderer(renderer); } + }; + + //! sdl Window + std::unique_ptr game_window; + //! renderer for the crepe engine - SDL_Renderer * game_renderer = nullptr; + std::unique_ptr game_renderer; //! viewport for the camera window SDL_Rect viewport = {0, 0, 640, 480}; -- cgit v1.2.3 From ac8a58a2a16118ea4c40fcc533c3420edde45122 Mon Sep 17 00:00:00 2001 From: heavydemon21 Date: Fri, 8 Nov 2024 19:12:37 +0100 Subject: fixed all the RAII --- src/crepe/api/Animator.h | 14 +----------- src/crepe/api/Texture.cpp | 2 +- src/crepe/api/Texture.h | 9 ++------ src/crepe/facade/SDLContext.cpp | 48 +++++++++++++++++++++++++---------------- src/crepe/facade/SDLContext.h | 17 ++++++--------- 5 files changed, 40 insertions(+), 50 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h index 42ce957..ae0a896 100644 --- a/src/crepe/api/Animator.h +++ b/src/crepe/api/Animator.h @@ -39,23 +39,11 @@ public: Animator(uint32_t id, Sprite & spritesheet, int row, int col, int col_animate); - /** - * \brief Destroys the Animator object and cleans up any resources. - * - * This destructor will handle any necessary cleanup when the Animator component is no longer needed. - */ - ~Animator(); - //! Deleted copy constructor to prevent copying of the Animator instance. + ~Animator(); Animator(const Animator &) = delete; - - //! Deleted move constructor to prevent moving of the Animator instance. Animator(Animator &&) = delete; - - //! Deleted copy assignment operator to prevent copying the Animator instance. Animator & operator=(const Animator &) = delete; - - //! Deleted move assignment operator to prevent moving the Animator instance. Animator & operator=(Animator &&) = delete; private: diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp index 1eac655..c31f704 100644 --- a/src/crepe/api/Texture.cpp +++ b/src/crepe/api/Texture.cpp @@ -26,7 +26,7 @@ Texture::~Texture() { void Texture::load(unique_ptr res) { SDLContext & ctx = SDLContext::get_instance(); - this->texture.reset(ctx.texture_from_path(res->canonical())); + this->texture = std::move(ctx.texture_from_path(res->canonical())); } int Texture::get_width() const{ diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h index 0cacfe5..9bda5fe 100644 --- a/src/crepe/api/Texture.h +++ b/src/crepe/api/Texture.h @@ -5,16 +5,14 @@ // API namespace? #include +#include #include #include "Asset.h" namespace crepe { -//! Forward declaration of SDLContext class. class SDLContext; - -//! Forward declaration of Animator class. class Animator; /** @@ -64,11 +62,8 @@ private: void load(std::unique_ptr res); private: - struct TextureDeleter{ - void operator()(SDL_Texture* texture) const { SDL_DestroyTexture(texture);} - }; //! The texture of the class from the library - std::unique_ptr texture; + std::unique_ptr> texture; //! Grants SDLContext access to private members. friend class SDLContext; diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 770e93b..5b9ca71 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -6,13 +6,17 @@ #include #include #include +#include #include +#include #include +#include #include "../api/Sprite.h" #include "../api/Texture.h" #include "../api/Transform.h" #include "../util/log.h" +#include "Exception.h" #include "SDLContext.h" @@ -33,19 +37,21 @@ SDLContext::SDLContext() { << std::endl; return; } - - this->game_window.reset(SDL_CreateWindow( + SDL_Window * tmp_window = SDL_CreateWindow( "Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, - this->viewport.w, this->viewport.h, 0)); - if (!this->game_window) { + this->viewport.w, this->viewport.h, 0); + if (!tmp_window) { // FIXME: throw exception std::cerr << "Window could not be created! SDL_Error: " << SDL_GetError() << std::endl; + return; } + this->game_window = {tmp_window, [](SDL_Window* window) { SDL_DestroyWindow(window); }}; - this->game_renderer.reset(SDL_CreateRenderer(this->game_window.get(), -1, - SDL_RENDERER_ACCELERATED)); - if (!this->game_renderer) { + + SDL_Renderer* tmp_renderer = SDL_CreateRenderer(this->game_window.get(), -1, + SDL_RENDERER_ACCELERATED); + if (!tmp_renderer) { // FIXME: throw exception std::cerr << "Renderer could not be created! SDL_Error: " << SDL_GetError() << std::endl; @@ -53,6 +59,8 @@ SDLContext::SDLContext() { return; } + this->game_renderer = {tmp_renderer, [](SDL_Renderer* renderer) { SDL_DestroyRenderer(renderer); }}; + int img_flags = IMG_INIT_PNG; if (!(IMG_Init(img_flags) & img_flags)) { // FIXME: throw exception @@ -144,23 +152,27 @@ void SDLContext::camera(const Camera & cam) { const uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } -//TODO: make this RAII -SDL_Texture * SDLContext::texture_from_path(const std::string & path) { +std::unique_ptr> SDLContext::texture_from_path(const std::string & path) { SDL_Surface * tmp = IMG_Load(path.c_str()); - if (!tmp) { - std::cerr << "Error surface " << IMG_GetError << std::endl; + if (tmp == nullptr) { + throw Exception("surface cannot be load from %s", path.c_str()); } - SDL_Texture * created_texture - = SDL_CreateTextureFromSurface(this->game_renderer.get(), tmp); - if (!created_texture) { - std::cerr << "Error could not create texture " << IMG_GetError - << std::endl; + std::unique_ptr> img_surface; + img_surface = {tmp, [](SDL_Surface * surface) { SDL_FreeSurface(surface); }}; + + SDL_Texture * tmp_texture = SDL_CreateTextureFromSurface( + this->game_renderer.get(), img_surface.get()); + + if ( tmp_texture == nullptr) { + throw Exception("Texture cannot be load from %s", path.c_str()); } - SDL_FreeSurface(tmp); - return created_texture; + std::unique_ptr> img_texture; + img_texture = {tmp_texture, [](SDL_Texture * texture) { SDL_DestroyTexture(texture); }}; + + return img_texture; } int SDLContext::get_width(const Texture & ctx) const { int w; diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 0a8dbcf..93166f2 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -15,6 +16,8 @@ const int SCREEN_WIDTH = 640; const int SCREEN_HEIGHT = 480; namespace crepe { + +//TODO: Wouter will fix this. cause user cannot this at the moment typedef SDL_Keycode CREPE_KEYCODES; class Texture; @@ -85,8 +88,7 @@ private: * \param path Path to the image file. * \return Pointer to the created SDL_Texture. */ - SDL_Texture * texture_from_path(const std::string & path); - + std::unique_ptr> texture_from_path(const std::string & path); /** * \brief Gets the width of a texture. * \param texture Reference to the Texture object. @@ -131,19 +133,12 @@ private: void camera(const Camera & camera); private: - struct WindowDeleter { - void operator()(SDL_Window * window) { SDL_DestroyWindow(window); } - }; - - struct RendererDeleter { - void operator()(SDL_Renderer * renderer) { SDL_DestroyRenderer(renderer); } - }; //! sdl Window - std::unique_ptr game_window; + std::unique_ptr> game_window; //! renderer for the crepe engine - std::unique_ptr game_renderer; + std::unique_ptr> game_renderer; //! viewport for the camera window SDL_Rect viewport = {0, 0, 640, 480}; -- cgit v1.2.3 From d69adb5666fd6f73edbc6d410afcdf23c24e7c6b Mon Sep 17 00:00:00 2001 From: Jaro Date: Fri, 8 Nov 2024 19:20:05 +0100 Subject: particle updated --- src/crepe/Particle.cpp | 25 ++++-- src/crepe/Particle.h | 24 +++--- src/crepe/api/ParticleEmitter.cpp | 35 ++------ src/crepe/api/ParticleEmitter.h | 72 ++++++++++------ src/crepe/system/ParticleSystem.cpp | 159 ++++++++++++++++++++++++++++-------- src/crepe/system/ParticleSystem.h | 10 ++- src/example/particles.cpp | 46 +++++++++++ 7 files changed, 262 insertions(+), 109 deletions(-) create mode 100644 src/example/particles.cpp (limited to 'src/crepe/api') diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp index 4810e80..d2b1880 100644 --- a/src/crepe/Particle.cpp +++ b/src/crepe/Particle.cpp @@ -1,20 +1,29 @@ #include "Particle.h" -using namespace crepe; +#include "api/Transform.h" -Particle::Particle() { this->active = false; } +using namespace crepe; -void Particle::reset(float lifespan, Position position, Position velocity) { +void Particle::reset(uint32_t lifespan, Vector2 position, Vector2 velocity, double angle) { this->time_in_life = 0; this->lifespan = lifespan; this->position = position; this->velocity = velocity; this->active = true; + this->angle = angle; +} + +void Particle::update() { + time_in_life++; + if (time_in_life >= lifespan) + { + this->active = false; + return; + } + velocity += force_over_time; + position += velocity; } -void Particle::update(float deltaTime) { - time_in_life += deltaTime; - position.x += velocity.x * deltaTime; - position.y += velocity.y * deltaTime; - if (time_in_life >= lifespan) this->active = false; +void Particle::stop_movement() { + this->velocity = {0,0}; } diff --git a/src/crepe/Particle.h b/src/crepe/Particle.h index 21e691d..f52196c 100644 --- a/src/crepe/Particle.h +++ b/src/crepe/Particle.h @@ -1,22 +1,24 @@ #pragma once -#include "Position.h" +#include "api/Transform.h" namespace crepe { class Particle { public: - Position position; - // FIXME: `Position` is an awkward name for a 2D vector. See FIXME comment in - // api/Transform.h for fix proposal. - Position velocity; - float lifespan; - bool active; + Vector2 position; + Vector2 velocity; + Vector2 force_over_time; + uint32_t lifespan; + bool active = false; + uint32_t time_in_life = 0; + double angle; - Particle(); - void reset(float lifespan, Position position, Position velocity); - void update(float deltaTime); - float time_in_life; + Particle() = default; + void reset(uint32_t lifespan, Vector2 position, Vector2 velocity,double angle); + void update(); + void stop_movement(); + }; } // namespace crepe diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 3b2e2f2..f585a81 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -1,36 +1,19 @@ -#include -#include - #include "Particle.h" #include "ParticleEmitter.h" using namespace crepe; -ParticleEmitter::ParticleEmitter(game_object_id_t id, uint32_t max_particles, - uint32_t emission_rate, uint32_t speed, - uint32_t speed_offset, uint32_t angle, - uint32_t angleOffset, float begin_lifespan, - float end_lifespan) - : Component(id), max_particles(max_particles), emission_rate(emission_rate), - speed(speed), speed_offset(speed_offset), position{0, 0}, - begin_lifespan(begin_lifespan), end_lifespan(end_lifespan) { - std::srand( - static_cast(std::time(nullptr))); // initialize random seed - std::cout << "Create emitter" << std::endl; - // FIXME: Why do these expressions start with `360 +`, only to be `% 360`'d - // right after? This does not make any sense to me. - min_angle = (360 + angle - (angleOffset % 360)) % 360; - max_angle = (360 + angle + (angleOffset % 360)) % 360; - position.x = 400; // FIXME: what are these magic values? - position.y = 400; - for (size_t i = 0; i < max_particles; i++) { - this->particles.emplace_back(); - } +ParticleEmitter::ParticleEmitter(uint32_t game_object_id, const ParticleEmitterData& data) : Component(game_object_id),data(data) { + for (size_t i = 0; i < this->data.max_particles; i++) { + this->data.particles.emplace_back(); + } } + ParticleEmitter::~ParticleEmitter() { - std::vector::iterator it = this->particles.begin(); - while (it != this->particles.end()) { - it = this->particles.erase(it); + std::vector::iterator it = this->data.particles.begin(); + while (it != this->data.particles.end()) { + it = this->data.particles.erase(it); } } + diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index 5939723..f931e8c 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -5,38 +5,58 @@ #include "Component.h" #include "Particle.h" +#include "Transform.h" + +class Sprite; namespace crepe { class ParticleEmitter : public Component { public: - ParticleEmitter(game_object_id_t id, uint32_t max_particles, - uint32_t emission_rate, uint32_t speed, - uint32_t speed_offset, uint32_t angle, uint32_t angleOffset, - float begin_lifespan, float end_lifespan); - ~ParticleEmitter(); - - //! position of the emitter - Position position; - //! maximum number of particles - uint32_t max_particles; - //! rate of particle emission - uint32_t emission_rate; - //! base speed of the particles - uint32_t speed; - //! offset for random speed variation - uint32_t speed_offset; - //! min angle of particle emission - uint32_t min_angle; - //! max angle of particle emission - uint32_t max_angle; - //! begin Lifespan of particle (only visual) - float begin_lifespan; - //! begin Lifespan of particle - float end_lifespan; + struct ParticleBoundary{ + //! boundary width (midpoint is emitter location) + double boundary_width = 0.0; + //! boundary height (midpoint is emitter location) + double boundary_height = 0.0; + //! boundary offset from particle emitter location + Vector2 boundary_offset; + //! reset on exit or stop velocity and set max postion + bool reset_on_exit = false; + }; - //! collection of particles - std::vector particles; + struct ParticleEmitterData{ + //! position of the emitter + Vector2 position; + //! maximum number of particles + uint32_t max_particles = 0; + //! rate of particle emission per update (Lowest value = 0.001 any lower is ignored) + double emission_rate = 0; + //! min speed of the particles + double min_speed = 0; + //! min speed of the particles + double max_speed = 0; + //! min angle of particle emission + double min_angle = 0; + //! max angle of particle emission + double max_angle = 0; + //! begin Lifespan of particle (only visual) + double begin_lifespan = 0.0; + //! end Lifespan of particle + double end_lifespan = 0.0; + //! force over time (physics) + Vector2 force_over_time; + //! particle boundary + ParticleBoundary boundary; + //! collection of particles + std::vector particles; + //! sprite reference + const Sprite* sprite; + }; +public: + ParticleEmitter(uint32_t game_object_id, const ParticleEmitterData& data); + ~ParticleEmitter(); +public: + ParticleEmitterData data; }; } // namespace crepe diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 397b586..23534a3 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -1,62 +1,149 @@ #include #include +#include -#include "../ComponentManager.h" -#include "../api/ParticleEmitter.h" +#include "api/ParticleEmitter.h" +#include "api/Vector2.h" +#include "ComponentManager.h" #include "ParticleSystem.h" using namespace crepe; -ParticleSystem::ParticleSystem() : elapsed_time(0.0f) {} +ParticleSystem::ParticleSystem() {} void ParticleSystem::update() { + + // Get all emitters ComponentManager & mgr = ComponentManager::get_instance(); std::vector> emitters = mgr.get_components_by_type(); - float delta_time = 0.10; + for (ParticleEmitter & emitter : emitters) { - float update_amount = 1 / static_cast(emitter.emission_rate); - for (float i = 0; i < delta_time; i += update_amount) { - emit_particle(emitter); + + // Get transform linked to emitter + const Transform& transform = mgr.get_components_by_id(emitter.GAME_OBJECT_ID).front().get(); + + // Check if within boundary + check_bounds(emitter,transform); + + // Emit particles based on emission_rate + int updates = calculate_update(this->update_count,emitter.data.emission_rate); + for (size_t i = 0; i < updates; i++) + { + emit_particle(emitter,transform); } - for (size_t j = 0; j < emitter.particles.size(); j++) { - if (emitter.particles[j].active) { - emitter.particles[j].update(delta_time); + + // Update all particles + for (size_t j = 0; j < emitter.data.particles.size(); j++) { + if (emitter.data.particles[j].active) { + emitter.data.particles[j].update(); } } } + update_count++; + if(update_count == MAX_UPDATE_COUNT) update_count = 0; } -void ParticleSystem::emit_particle(ParticleEmitter & emitter) { - Position initial_position = {emitter.position.x, emitter.position.y}; - float random_angle = 0.0f; - if (emitter.max_angle < emitter.min_angle) { - random_angle = ((emitter.min_angle - + (std::rand() - % (static_cast(emitter.max_angle + 360 - - emitter.min_angle + 1)))) - % 360); +void ParticleSystem::emit_particle(ParticleEmitter & emitter,const Transform& transform) { + constexpr double DEG_TO_RAD = M_PI / 180.0; + + Vector2 initial_position = emitter.data.position + transform.position; + double min_angle = emitter.data.min_angle; + double max_angle = emitter.data.max_angle; + double random_angle; + + if (min_angle <= max_angle) { + // Standard range (e.g., 10 to 20 degrees) + double angle_offset = max_angle - min_angle; + random_angle = min_angle + static_cast(std::rand() % static_cast(angle_offset)); } else { - random_angle = emitter.min_angle - + (std::rand() - % (static_cast(emitter.max_angle - - emitter.min_angle + 1))); + // Wrap-around range (e.g., 350 to 10 degrees) + double angle_offset = (360 - min_angle) + max_angle; + random_angle = min_angle + static_cast(std::rand() % static_cast(angle_offset)); + + // Wrap around to keep random_angle within 0-360 degrees + if (random_angle >= 360) { + random_angle -= 360; + } } - float angle_in_radians = random_angle * (M_PI / 180.0f); - float random_speed_offset = (static_cast(std::rand()) / RAND_MAX) - * (2 * emitter.speed_offset) - - emitter.speed_offset; - float velocity_x - = (emitter.speed + random_speed_offset) * std::cos(angle_in_radians); - float velocity_y - = (emitter.speed + random_speed_offset) * std::sin(angle_in_radians); - Position initial_velocity = {velocity_x, velocity_y}; - for (size_t i = 0; i < emitter.particles.size(); i++) { - if (!emitter.particles[i].active) { - emitter.particles[i].reset(emitter.end_lifespan, initial_position, - initial_velocity); + + // Generate a random speed between min_speed and max_speed + double speed_offset = emitter.data.max_speed - emitter.data.min_speed; + double random_speed = emitter.data.min_speed + static_cast(std::rand() % static_cast(speed_offset)); + + // Convert random_angle to radians + double angle_radians = random_angle * DEG_TO_RAD; + + Vector2 velocity = { + random_speed * std::cos(angle_radians), + random_speed * std::sin(angle_radians) + }; + + + for (size_t i = 0; i < emitter.data.particles.size(); i++) { + if (!emitter.data.particles[i].active) { + emitter.data.particles[i].reset(emitter.data.end_lifespan, initial_position,velocity,random_angle); break; } } } + +int ParticleSystem::calculate_update(int count, double emission) { + + //get interger part of the emission + double integer_part = std::floor(emission); + + // Get the fractional part of the emission + double fractional_part = emission - integer_part; + + // Convert the fractional part to a denominator value + int denominator = static_cast(1.0 / fractional_part); + + // For emissions like 0.01, 0.1, 0.5, etc., calculate the update frequency + if (fractional_part > 0) { + // Calculate how often the update should be triggered based on the fractional part + if (count % denominator == 0) { + return 1; + } else { + return 0; + } + } + + // For integer emissions, return the emission directly + return static_cast(emission); +} + +void ParticleSystem::check_bounds(ParticleEmitter & emitter,const Transform& transform) +{ + Vector2 offset = emitter.data.boundary.boundary_offset + transform.position + emitter.data.position; + double half_width = emitter.data.boundary.boundary_width / 2.0; + double half_height = emitter.data.boundary.boundary_height / 2.0; + + // Define boundary edges + 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; + + std::vector& particles = emitter.data.particles; + for (Particle& particle : particles) + { + const Vector2& position = particle.position; + + // Check if particle is within bounds + bool within_bounds = (position.x >= left && position.x <= right && position.y >= top && position.y <= bottom); + if (!within_bounds) + { + if (emitter.data.boundary.reset_on_exit) + { + particle.active = false; + } + else + { + particle.velocity = {0, 0}; + //todo add that particle goes back to boundary + } + } + } +} diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h index 3ac1d3f..3b9cb54 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -10,9 +10,15 @@ public: void update(); private: - void emit_particle(ParticleEmitter & emitter); //emits a new particle + void emit_particle(ParticleEmitter & emitter,const Transform& transform); + int calculate_update(int count, double emission); + void check_bounds(ParticleEmitter & emitter,const Transform& transform); - float elapsed_time; //elapsed time since the last emission +private: + //! counter to count updates to determine how many times emit_particle is called. + uint32_t update_count = 0; + //! determines the lowest amount of emissionrate (1000 = 0.001 = 1 particle per 1000 updates). + const uint32_t MAX_UPDATE_COUNT = 100; }; } // namespace crepe diff --git a/src/example/particles.cpp b/src/example/particles.cpp new file mode 100644 index 0000000..a56ec5c --- /dev/null +++ b/src/example/particles.cpp @@ -0,0 +1,46 @@ +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + + +using namespace crepe; +using namespace std; + +int main(int argc, char * argv[]) { + + Color color(0, 0, 0, 0); + GameObject *game_object = new GameObject(0, "Name", "Tag", Vector2{0,0},0,0); + game_object->add_component(ParticleEmitter::ParticleEmitterData{ + .position = {0,0}, + .max_particles = 0, + .emission_rate = 0, + .min_speed = 0, + .max_speed = 0, + .min_angle = 0, + .max_angle = 0, + .begin_lifespan = 0, + .end_lifespan = 0, + .force_over_time = 0, + .boundary{ + .boundary_width = 0, + .boundary_height = 0, + .boundary_offset = {0,0}, + .reset_on_exit = false, + }, + .sprite = nullptr, + }); + + return 0; +} -- cgit v1.2.3 From 506de66aaecc9b82415dde46058b848e46bc7258 Mon Sep 17 00:00:00 2001 From: Loek Le Blansch Date: Fri, 8 Nov 2024 20:21:36 +0100 Subject: nitpicks (merge #27) --- src/crepe/api/Animator.cpp | 4 +- src/crepe/api/Animator.h | 6 +-- src/crepe/api/Camera.cpp | 9 ++-- src/crepe/api/Camera.h | 42 ++++++++-------- src/crepe/api/Color.h | 4 +- src/crepe/api/Sprite.cpp | 4 +- src/crepe/api/Sprite.h | 17 +++---- src/crepe/api/Texture.cpp | 4 +- src/crepe/api/Texture.h | 76 ++++++++++++++--------------- src/crepe/facade/SDLContext.cpp | 33 ++++++++----- src/crepe/facade/SDLContext.h | 95 ++++++++++++++++++------------------- src/crepe/system/AnimatorSystem.cpp | 13 +++-- src/crepe/system/AnimatorSystem.h | 22 ++------- src/crepe/system/RenderSystem.cpp | 9 ++-- src/crepe/system/RenderSystem.h | 80 +++++++++++++------------------ 15 files changed, 195 insertions(+), 223 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp index 4b4d4be..8b396af 100644 --- a/src/crepe/api/Animator.cpp +++ b/src/crepe/api/Animator.cpp @@ -3,14 +3,14 @@ #include "util/log.h" +#include "Animator.h" #include "Component.h" #include "Sprite.h" -#include "Animator.h" using namespace crepe; Animator::Animator(uint32_t id, Sprite & ss, int row, int col, int col_animator) - : Component(id), spritesheet(ss), row(row), col(col){ + : Component(id), spritesheet(ss), row(row), col(col) { dbg_trace(); animator_rect = spritesheet.sprite_rect; diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h index ae0a896..def0240 100644 --- a/src/crepe/api/Animator.h +++ b/src/crepe/api/Animator.h @@ -9,7 +9,6 @@ namespace crepe { class AnimatorSystem; class SDLContext; - /** * \brief The Animator component is used to animate sprites by managing the movement * and frame changes within a sprite sheet. @@ -39,8 +38,7 @@ public: Animator(uint32_t id, Sprite & spritesheet, int row, int col, int col_animate); - - ~Animator(); + ~Animator(); // dbg_trace Animator(const Animator &) = delete; Animator(Animator &&) = delete; Animator & operator=(const Animator &) = delete; @@ -71,7 +69,7 @@ private: //! AnimatorSystem adjust the private member parameters of Animator; friend class AnimatorSystem; - //! SDLContext reads the Animator member var's + //! SDLContext reads the Animator member var's friend class SDLContext; }; } // namespace crepe diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp index dbbfb32..820a6a8 100644 --- a/src/crepe/api/Camera.cpp +++ b/src/crepe/api/Camera.cpp @@ -3,15 +3,14 @@ #include "util/log.h" -#include "Component.h" -#include "Color.h" #include "Camera.h" +#include "Color.h" +#include "Component.h" using namespace crepe; -Camera::Camera(uint32_t id, const Color & color) - : Component(id), bg_color(color), aspect_width(640), aspect_height(480), - zoom(1), x(0), y(0) { +Camera::Camera(uint32_t id, const Color & bg_color) + : Component(id), bg_color(bg_color) { dbg_trace(); } diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h index 708a523..ba3a9ef 100644 --- a/src/crepe/api/Camera.h +++ b/src/crepe/api/Camera.h @@ -19,41 +19,37 @@ class Camera : public Component { public: /** - * \brief Constructs a Camera with the specified ID and background color. - * \param id Unique identifier for the camera component. - * \param bg_color Background color for the camera view. - */ + * \brief Constructs a Camera with the specified ID and background color. + * \param id Unique identifier for the camera component. + * \param bg_color Background color for the camera view. + */ Camera(uint32_t id, const Color & bg_color); - - /** - * \brief Destroys the Camera instance. - */ - ~Camera(); + ~Camera(); // dbg_trace only public: - //! \brief Background color of the camera view. + //! Background color of the camera view. Color bg_color; - //! \brief Aspect ratio height for the camera. - double aspect_height; + //! Aspect ratio height for the camera. + double aspect_height = 480; - //! \brief Aspect ratio width for the camera. - double aspect_width; + //! Aspect ratio width for the camera. + double aspect_width = 640; - //! \brief X-coordinate of the camera position. - double x; + //! X-coordinate of the camera position. + double x = 0.0; - //! \brief Y-coordinate of the camera position. - double y; + //! Y-coordinate of the camera position. + double y = 0.0; - //! \brief Zoom level of the camera view. - double zoom; + //! Zoom level of the camera view. + double zoom = 1.0; public: /** - * \brief Gets the maximum number of camera instances allowed. - * \return Maximum instance count as an integer. - */ + * \brief Gets the maximum number of camera instances allowed. + * \return Maximum instance count as an integer. + */ virtual int get_instances_max() const { return 10; } }; } // namespace crepe diff --git a/src/crepe/api/Color.h b/src/crepe/api/Color.h index 4ebe3a3..aa47bf4 100644 --- a/src/crepe/api/Color.h +++ b/src/crepe/api/Color.h @@ -2,8 +2,9 @@ #include -namespace crepe{ +namespace crepe { +// TODO: make Color a struct w/o constructors/destructors class Color { // FIXME: can't these colors be defined as a `static constexpr const Color` @@ -21,6 +22,7 @@ public: static const Color & get_black(); private: + // TODO: why are these private!? uint8_t r; uint8_t g; uint8_t b; diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp index db96c32..f9cd761 100644 --- a/src/crepe/api/Sprite.cpp +++ b/src/crepe/api/Sprite.cpp @@ -1,11 +1,11 @@ #include -#include "facade/SDLContext.h" #include "../util/log.h" +#include "facade/SDLContext.h" #include "Component.h" -#include "Texture.h" #include "Sprite.h" +#include "Texture.h" using namespace std; using namespace crepe; diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h index 1db32d7..deb3f93 100644 --- a/src/crepe/api/Sprite.h +++ b/src/crepe/api/Sprite.h @@ -4,22 +4,21 @@ #include #include "Color.h" -#include "Texture.h" #include "Component.h" - +#include "Texture.h" namespace crepe { struct Rect { int w = 0; - int h = 0; - int x = 0; - int y = 0; + int h = 0; + int x = 0; + int y = 0; }; struct FlipSettings { - bool flip_x = false; - bool flip_y = false; + bool flip_x = false; + bool flip_y = false; }; class SDLContext; @@ -35,7 +34,6 @@ class AnimatorSystem; class Sprite : public Component { public: - // TODO: Loek comment in github #27 will be looked another time // about shared_ptr Texture /** @@ -53,10 +51,9 @@ public: */ ~Sprite(); - //! Texture used for the sprite const std::shared_ptr sprite_image; - //! Color tint of the sprite + //! Color tint of the sprite Color color; //! Flip settings for the sprite FlipSettings flip; diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp index c31f704..5ebd23d 100644 --- a/src/crepe/api/Texture.cpp +++ b/src/crepe/api/Texture.cpp @@ -29,11 +29,11 @@ void Texture::load(unique_ptr res) { this->texture = std::move(ctx.texture_from_path(res->canonical())); } -int Texture::get_width() const{ +int Texture::get_width() const { if (this->texture == nullptr) return 0; return SDLContext::get_instance().get_width(*this); } -int Texture::get_height() const{ +int Texture::get_height() const { if (this->texture == nullptr) return 0; return SDLContext::get_instance().get_width(*this); } diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h index 9bda5fe..b89bc17 100644 --- a/src/crepe/api/Texture.h +++ b/src/crepe/api/Texture.h @@ -25,51 +25,53 @@ class Animator; class Texture { public: - /** - * \brief Constructs a Texture from a file path. - * \param src Path to the image file to be loaded as a texture. - */ - Texture(const char * src); - - /** - * \brief Constructs a Texture from an Asset resource. - * \param res Unique pointer to an Asset resource containing texture data. - */ - Texture(std::unique_ptr res); - - /** - * \brief Destroys the Texture instance, freeing associated resources. - */ - ~Texture(); - - /** - * \brief Gets the width of the texture. - * \return Width of the texture in pixels. - */ - int get_width() const; - - /** - * \brief Gets the height of the texture. - * \return Height of the texture in pixels. - */ - int get_height() const; + /** + * \brief Constructs a Texture from a file path. + * \param src Path to the image file to be loaded as a texture. + */ + Texture(const char * src); + + /** + * \brief Constructs a Texture from an Asset resource. + * \param res Unique pointer to an Asset resource containing texture data. + */ + Texture(std::unique_ptr res); + + /** + * \brief Destroys the Texture instance, freeing associated resources. + */ + ~Texture(); + // FIXME: this constructor shouldn't be necessary because this class doesn't + // manage memory + + /** + * \brief Gets the width of the texture. + * \return Width of the texture in pixels. + */ + int get_width() const; + + /** + * \brief Gets the height of the texture. + * \return Height of the texture in pixels. + */ + int get_height() const; private: - /** - * \brief Loads the texture from an Asset resource. - * \param res Unique pointer to an Asset resource to load the texture from. - */ - void load(std::unique_ptr res); + /** + * \brief Loads the texture from an Asset resource. + * \param res Unique pointer to an Asset resource to load the texture from. + */ + void load(std::unique_ptr res); private: //! The texture of the class from the library std::unique_ptr> texture; - //! Grants SDLContext access to private members. - friend class SDLContext; + //! Grants SDLContext access to private members. + friend class SDLContext; - //! Grants Animator access to private members. - friend class Animator; + //! Grants Animator access to private members. + friend class Animator; }; } // namespace crepe diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 5b9ca71..c4c96e2 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -46,11 +46,11 @@ SDLContext::SDLContext() { << SDL_GetError() << std::endl; return; } - this->game_window = {tmp_window, [](SDL_Window* window) { SDL_DestroyWindow(window); }}; + this->game_window + = {tmp_window, [](SDL_Window * window) { SDL_DestroyWindow(window); }}; - - SDL_Renderer* tmp_renderer = SDL_CreateRenderer(this->game_window.get(), -1, - SDL_RENDERER_ACCELERATED); + SDL_Renderer * tmp_renderer = SDL_CreateRenderer( + this->game_window.get(), -1, SDL_RENDERER_ACCELERATED); if (!tmp_renderer) { // FIXME: throw exception std::cerr << "Renderer could not be created! SDL_Error: " @@ -59,7 +59,9 @@ SDLContext::SDLContext() { return; } - this->game_renderer = {tmp_renderer, [](SDL_Renderer* renderer) { SDL_DestroyRenderer(renderer); }}; + this->game_renderer = {tmp_renderer, [](SDL_Renderer * renderer) { + SDL_DestroyRenderer(renderer); + }}; int img_flags = IMG_INIT_PNG; if (!(IMG_Init(img_flags) & img_flags)) { @@ -150,27 +152,32 @@ void SDLContext::camera(const Camera & cam) { cam.bg_color.g, cam.bg_color.b, cam.bg_color.a); } -const uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } +uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } -std::unique_ptr> SDLContext::texture_from_path(const std::string & path) { +std::unique_ptr> +SDLContext::texture_from_path(const std::string & path) { SDL_Surface * tmp = IMG_Load(path.c_str()); - if (tmp == nullptr) { + if (tmp == nullptr) { throw Exception("surface cannot be load from %s", path.c_str()); } - std::unique_ptr> img_surface; - img_surface = {tmp, [](SDL_Surface * surface) { SDL_FreeSurface(surface); }}; + std::unique_ptr> + img_surface; + img_surface + = {tmp, [](SDL_Surface * surface) { SDL_FreeSurface(surface); }}; SDL_Texture * tmp_texture = SDL_CreateTextureFromSurface( this->game_renderer.get(), img_surface.get()); - if ( tmp_texture == nullptr) { + if (tmp_texture == nullptr) { throw Exception("Texture cannot be load from %s", path.c_str()); } - std::unique_ptr> img_texture; - img_texture = {tmp_texture, [](SDL_Texture * texture) { SDL_DestroyTexture(texture); }}; + std::unique_ptr> + img_texture; + img_texture = {tmp_texture, + [](SDL_Texture * texture) { SDL_DestroyTexture(texture); }}; return img_texture; } diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 93166f2..e358c21 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -11,13 +11,15 @@ #include "../api/Transform.h" #include "api/Camera.h" -//FIXME: this needs to be removed +// FIXME: this needs to be removed const int SCREEN_WIDTH = 640; const int SCREEN_HEIGHT = 480; namespace crepe { -//TODO: Wouter will fix this. cause user cannot this at the moment +// TODO: SDL_Keycode is defined in a header not distributed with crepe, which +// means this typedef is unusable when crepe is packaged. Wouter will fix this +// later. typedef SDL_Keycode CREPE_KEYCODES; class Texture; @@ -34,9 +36,9 @@ class SDLContext { public: /** - * \brief Gets the singleton instance of SDLContext. - * \return Reference to the SDLContext instance. - */ + * \brief Gets the singleton instance of SDLContext. + * \return Reference to the SDLContext instance. + */ static SDLContext & get_instance(); SDLContext(const SDLContext &) = delete; @@ -48,9 +50,9 @@ private: //! will only use handle_events friend class LoopManager; /** - * \brief Handles SDL events such as window close and input. - * \param running Reference to a boolean flag that controls the main loop. - */ + * \brief Handles SDL events such as window close and input. + * \param running Reference to a boolean flag that controls the main loop. + */ void handle_events(bool & running); private: @@ -58,22 +60,22 @@ private: friend class AnimatorSystem; /** - * \brief Gets the current SDL ticks since the program started. - * \return Current ticks in milliseconds as a constant uint64_t. - */ - const uint64_t get_ticks() const; + * \brief Gets the current SDL ticks since the program started. + * \return Current ticks in milliseconds as a constant uint64_t. + */ + uint64_t get_ticks() const; private: /** - * \brief Constructs an SDLContext instance. - * Initializes SDL, creates a window and renderer. - */ + * \brief Constructs an SDLContext instance. + * Initializes SDL, creates a window and renderer. + */ SDLContext(); /** - * \brief Destroys the SDLContext instance. - * Cleans up SDL resources, including the window and renderer. - */ + * \brief Destroys the SDLContext instance. + * Cleans up SDL resources, including the window and renderer. + */ ~SDLContext(); private: @@ -84,23 +86,24 @@ private: friend class Animator; /** - * \brief Loads a texture from a file path. - * \param path Path to the image file. - * \return Pointer to the created SDL_Texture. - */ - std::unique_ptr> texture_from_path(const std::string & path); + * \brief Loads a texture from a file path. + * \param path Path to the image file. + * \return Pointer to the created SDL_Texture. + */ + std::unique_ptr> + texture_from_path(const std::string & path); /** - * \brief Gets the width of a texture. - * \param texture Reference to the Texture object. - * \return Width of the texture as an integer. - */ + * \brief Gets the width of a texture. + * \param texture Reference to the Texture object. + * \return Width of the texture as an integer. + */ int get_width(const Texture &) const; /** - * \brief Gets the height of a texture. - * \param texture Reference to the Texture object. - * \return Height of the texture as an integer. - */ + * \brief Gets the height of a texture. + * \param texture Reference to the Texture object. + * \return Height of the texture as an integer. + */ int get_height(const Texture &) const; private: @@ -108,37 +111,33 @@ private: friend class RenderSystem; /** - * \brief Draws a sprite to the screen using the specified transform and camera. - * \param sprite Reference to the Sprite to draw. - * \param transform Reference to the Transform for positioning. - * \param camera Reference to the Camera for view adjustments. - */ + * \brief Draws a sprite to the screen using the specified transform and camera. + * \param sprite Reference to the Sprite to draw. + * \param transform Reference to the Transform for positioning. + * \param camera Reference to the Camera for view adjustments. + */ void draw(const Sprite & sprite, const Transform & transform, const Camera & camera); - /** - * \brief Clears the screen, preparing for a new frame. - */ + //! Clears the screen, preparing for a new frame. void clear_screen(); - /** - * \brief Presents the rendered frame to the screen. - */ + //! Presents the rendered frame to the screen. void present_screen(); /** - * \brief Sets the current camera for rendering. - * \param camera Reference to the Camera object. - */ + * \brief Sets the current camera for rendering. + * \param camera Reference to the Camera object. + */ void camera(const Camera & camera); private: - //! sdl Window - std::unique_ptr> game_window; + std::unique_ptr> game_window; //! renderer for the crepe engine - std::unique_ptr> game_renderer; + std::unique_ptr> + game_renderer; //! viewport for the camera window SDL_Rect viewport = {0, 0, 640, 480}; diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp index 4ea889a..bf45362 100644 --- a/src/crepe/system/AnimatorSystem.cpp +++ b/src/crepe/system/AnimatorSystem.cpp @@ -3,17 +3,16 @@ #include #include +#include "api/Animator.h" #include "facade/SDLContext.h" #include "util/log.h" -#include "api/Animator.h" -#include "ComponentManager.h" #include "AnimatorSystem.h" +#include "ComponentManager.h" using namespace crepe; AnimatorSystem::AnimatorSystem() { dbg_trace(); } - AnimatorSystem::~AnimatorSystem() { dbg_trace(); } AnimatorSystem & AnimatorSystem::get_instance() { @@ -22,12 +21,13 @@ AnimatorSystem & AnimatorSystem::get_instance() { } void AnimatorSystem::update() { - ComponentManager& mgr = ComponentManager::get_instance(); + ComponentManager & mgr = ComponentManager::get_instance(); - std::vector> animations = mgr.get_components_by_type(); + std::vector> animations + = mgr.get_components_by_type(); uint64_t tick = SDLContext::get_instance().get_ticks(); - for(Animator& a : animations){ + for (Animator & a : animations) { if (a.active) { a.curr_row = (tick / 100) % a.row; a.animator_rect.x = (a.curr_row * a.animator_rect.w) + a.curr_col; @@ -35,4 +35,3 @@ void AnimatorSystem::update() { } } } - diff --git a/src/crepe/system/AnimatorSystem.h b/src/crepe/system/AnimatorSystem.h index c377ce9..969e9d1 100644 --- a/src/crepe/system/AnimatorSystem.h +++ b/src/crepe/system/AnimatorSystem.h @@ -2,9 +2,7 @@ #include "System.h" - - -//TODO: +//TODO: // control if flip works with animation system namespace crepe { @@ -38,21 +36,9 @@ public: void update() override; private: - /** - * \brief Private constructor for the AnimatorSystem. - * - * The constructor is private to enforce the singleton pattern, ensuring that only - * one instance of this system can exist. - */ - AnimatorSystem(); - - /** - * \brief Private destructor for the AnimatorSystem. - * - * The destructor cleans up any resources used by the AnimatorSystem. It is private - * to maintain the singleton pattern and prevent direct deletion. - */ - ~AnimatorSystem(); + // private because singleton + AnimatorSystem(); // dbg_trace + ~AnimatorSystem(); // dbg_trace }; } // namespace crepe diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp index 849d810..10211a3 100644 --- a/src/crepe/system/RenderSystem.cpp +++ b/src/crepe/system/RenderSystem.cpp @@ -20,7 +20,9 @@ RenderSystem & RenderSystem::get_instance() { return instance; } -void RenderSystem::clear_screen() const { SDLContext::get_instance().clear_screen(); } +void RenderSystem::clear_screen() const { + SDLContext::get_instance().clear_screen(); +} void RenderSystem::present_screen() const { SDLContext::get_instance().present_screen(); @@ -45,8 +47,9 @@ void RenderSystem::render_sprites() const { SDLContext & render = SDLContext::get_instance(); for (const Sprite & sprite : sprites) { - auto transforms = mgr.get_components_by_id(sprite.game_object_id); - render.draw(sprite, transforms[0] , *curr_cam); + auto transforms + = mgr.get_components_by_id(sprite.game_object_id); + render.draw(sprite, transforms[0], *curr_cam); } } diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h index ec80a0e..70db21a 100644 --- a/src/crepe/system/RenderSystem.h +++ b/src/crepe/system/RenderSystem.h @@ -4,7 +4,6 @@ #include "System.h" - namespace crepe { /** @@ -18,63 +17,48 @@ namespace crepe { class RenderSystem : public System { public: - /** - * \brief Gets the singleton instance of RenderSystem. - * \return Reference to the RenderSystem instance. - */ - static RenderSystem & get_instance(); + /** + * \brief Gets the singleton instance of RenderSystem. + * \return Reference to the RenderSystem instance. + */ + static RenderSystem & get_instance(); - /** - * \brief Updates the RenderSystem for the current frame. - * This method is called to perform all rendering operations for the current game frame. - */ - void update() override; + /** + * \brief Updates the RenderSystem for the current frame. + * This method is called to perform all rendering operations for the current game frame. + */ + void update() override; private: - /** - * \brief Constructs a RenderSystem instance. - * Private constructor to enforce singleton pattern. - */ - RenderSystem(); - - /** - * \brief Destroys the RenderSystem instance. - */ - ~RenderSystem(); + // Private constructor to enforce singleton pattern. + RenderSystem(); + ~RenderSystem(); - /** - * \brief Clears the screen in preparation for rendering. - */ - void clear_screen() const; + //! Clears the screen in preparation for rendering. + void clear_screen() const; - /** - * \brief Presents the rendered frame to the display. - */ - void present_screen() const; + //! Presents the rendered frame to the display. + void present_screen() const; - /** - * \brief Updates the active camera used for rendering. - */ - void update_camera(); + //! Updates the active camera used for rendering. + void update_camera(); - /** - * \brief Renders all active sprites to the screen. - */ - void render_sprites() const; + //! Renders all active sprites to the screen. + void render_sprites() const; - /** - * \todo Include color handling for sprites. - * \todo Implement particle emitter rendering with sprites. - * \todo Add text rendering using SDL_ttf for text components. - * \todo Implement a text component and a button component. - * \todo Ensure each sprite is checked for active status before rendering. - * \todo Sort all layers by order before rendering. - * \todo Consider adding text input functionality. - */ + /** + * \todo Include color handling for sprites. + * \todo Implement particle emitter rendering with sprites. + * \todo Add text rendering using SDL_ttf for text components. + * \todo Implement a text component and a button component. + * \todo Ensure each sprite is checked for active status before rendering. + * \todo Sort all layers by order before rendering. + * \todo Consider adding text input functionality. + */ private: //! Pointer to the current active camera for rendering - // \todo needs a better solution - Camera * curr_cam; + Camera * curr_cam = nullptr; + // TODO: needs a better solution }; } // namespace crepe -- cgit v1.2.3 From 4e6f10f2d6ed593a21b985ccabe305a9cd6212cc Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Fri, 8 Nov 2024 21:37:28 +0000 Subject: fixed build --- src/crepe/api/Vector2.cpp | 6 +++--- src/crepe/api/Vector2.h | 10 +++++----- src/crepe/system/ParticleSystem.cpp | 2 +- src/example/CMakeLists.txt | 1 + src/example/particles.cpp | 5 ++--- 5 files changed, 12 insertions(+), 12 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/Vector2.cpp b/src/crepe/api/Vector2.cpp index 09bb59b..09b3fa3 100644 --- a/src/crepe/api/Vector2.cpp +++ b/src/crepe/api/Vector2.cpp @@ -3,7 +3,7 @@ namespace crepe { // Constructor with initial values -Vector2::Vector2(float x, float y) : x(x), y(y) {} +Vector2::Vector2(double x, double y) : x(x), y(y) {} // Subtracts another vector from this vector and returns the result. Vector2 Vector2::operator-(const Vector2 & other) const { @@ -16,7 +16,7 @@ Vector2 Vector2::operator+(const Vector2 & other) const { } // Multiplies this vector by a scalar and returns the result. -Vector2 Vector2::operator*(float scalar) const { +Vector2 Vector2::operator*(double scalar) const { return {x * scalar, y * scalar}; } @@ -35,7 +35,7 @@ Vector2 & Vector2::operator+=(const Vector2 & other) { } // Adds a scalar value to both components of this vector and updates this vector. -Vector2 & Vector2::operator+=(float other) { +Vector2 & Vector2::operator+=(double other) { x += other; y += other; return *this; diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h index 741951b..5a57484 100644 --- a/src/crepe/api/Vector2.h +++ b/src/crepe/api/Vector2.h @@ -6,15 +6,15 @@ namespace crepe { class Vector2 { public: //! X component of the vector - float x; + double x; //! Y component of the vector - float y; + double y; //! Default constructor Vector2() = default; //! Constructor with initial values - Vector2(float x, float y); + Vector2(double x, double y); //! Subtracts another vector from this vector and returns the result. Vector2 operator-(const Vector2 & other) const; @@ -23,7 +23,7 @@ public: Vector2 operator+(const Vector2 & other) const; //! Multiplies this vector by a scalar and returns the result. - Vector2 operator*(float scalar) const; + Vector2 operator*(double scalar) const; //! Multiplies this vector by another vector element-wise and updates this vector. Vector2 & operator*=(const Vector2 & other); @@ -32,7 +32,7 @@ public: Vector2 & operator+=(const Vector2 & other); //! Adds a scalar value to both components of this vector and updates this vector. - Vector2 & operator+=(float other); + Vector2 & operator+=(double other); //! Returns the negation of this vector. Vector2 operator-() const; diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 23534a3..b2fe829 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -22,7 +22,7 @@ void ParticleSystem::update() { for (ParticleEmitter & emitter : emitters) { // Get transform linked to emitter - const Transform& transform = mgr.get_components_by_id(emitter.GAME_OBJECT_ID).front().get(); + const Transform& transform = mgr.get_components_by_id(emitter.game_object_id).front().get(); // Check if within boundary check_bounds(emitter,transform); diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt index 36f9d4d..722ffea 100644 --- a/src/example/CMakeLists.txt +++ b/src/example/CMakeLists.txt @@ -28,4 +28,5 @@ add_example(proxy) add_example(db) add_example(ecs) add_example(scene_manager) +add_example(particles) diff --git a/src/example/particles.cpp b/src/example/particles.cpp index a56ec5c..bcff48f 100644 --- a/src/example/particles.cpp +++ b/src/example/particles.cpp @@ -3,7 +3,6 @@ #include #include #include -#include #include #include @@ -32,11 +31,11 @@ int main(int argc, char * argv[]) { .max_angle = 0, .begin_lifespan = 0, .end_lifespan = 0, - .force_over_time = 0, + .force_over_time = Vector2{0,0}, .boundary{ .boundary_width = 0, .boundary_height = 0, - .boundary_offset = {0,0}, + .boundary_offset = Vector2{0,0}, .reset_on_exit = false, }, .sprite = nullptr, -- cgit v1.2.3 From d3ed3f4daa335bb881dbcf55aa425c602ddbd2f4 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Sat, 9 Nov 2024 12:58:26 +0100 Subject: changed variables --- lib/sdl2 | 2 +- lib/sdl_image | 2 +- lib/sdl_ttf | 2 +- lib/soloud | 2 +- src/crepe/api/CMakeLists.txt | 4 +++ src/crepe/api/LoopManager.cpp | 61 ++++++++++++++++++++++++++++++++ src/crepe/api/LoopManager.h | 66 +++++++++++++++++++++++++++++++++++ src/crepe/api/LoopTimer.cpp | 59 +++++++++++++++++++++++++++++++ src/crepe/api/LoopTimer.h | 81 +++++++++++++++++++++++++++++++++++++++++++ src/example/CMakeLists.txt | 1 + src/example/gameLoop.cpp | 8 +++++ src/makefile | 5 ++- 12 files changed, 288 insertions(+), 5 deletions(-) create mode 100644 src/crepe/api/LoopManager.cpp create mode 100644 src/crepe/api/LoopManager.h create mode 100644 src/crepe/api/LoopTimer.cpp create mode 100644 src/crepe/api/LoopTimer.h create mode 100644 src/example/gameLoop.cpp (limited to 'src/crepe/api') diff --git a/lib/sdl2 b/lib/sdl2 index 9519b99..c98c4fb 160000 --- a/lib/sdl2 +++ b/lib/sdl2 @@ -1 +1 @@ -Subproject commit 9519b9916cd29a14587af0507292f2bd31dd5752 +Subproject commit c98c4fbff6d8f3016a3ce6685bf8f43433c3efcc diff --git a/lib/sdl_image b/lib/sdl_image index abcf63a..5656019 160000 --- a/lib/sdl_image +++ b/lib/sdl_image @@ -1 +1 @@ -Subproject commit abcf63aa71b4e3ac32120fa9870a6500ddcdcc89 +Subproject commit 56560190a6c5b5740e5afdce747e2a2bfbf16db1 diff --git a/lib/sdl_ttf b/lib/sdl_ttf index 4a318f8..a3d0895 160000 --- a/lib/sdl_ttf +++ b/lib/sdl_ttf @@ -1 +1 @@ -Subproject commit 4a318f8dfaa1bb6f10e0c5e54052e25d3c7f3440 +Subproject commit a3d0895c1b60c41ff9e85d9203ddd7485c014dae diff --git a/lib/soloud b/lib/soloud index c8e339f..e82fd32 160000 --- a/lib/soloud +++ b/lib/soloud @@ -1 +1 @@ -Subproject commit c8e339fdce5c7107bdb3e64bbf707c8fd3449beb +Subproject commit e82fd32c1f62183922f08c14c814a02b58db1873 diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt index 3b20142..e7894d7 100644 --- a/src/crepe/api/CMakeLists.txt +++ b/src/crepe/api/CMakeLists.txt @@ -16,6 +16,8 @@ target_sources(crepe PUBLIC Scene.cpp SceneManager.cpp Vector2.cpp + LoopManager.cpp + LoopTimer.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -38,4 +40,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES Metadata.h SceneManager.h SceneManager.hpp + LoopManager.h + LoopTimer.h ) diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp new file mode 100644 index 0000000..746e9ce --- /dev/null +++ b/src/crepe/api/LoopManager.cpp @@ -0,0 +1,61 @@ + + +#include "../system/RenderSystem.h" +#include "../system/ScriptSystem.h" + +#include "LoopManager.h" +#include "LoopTimer.h" + +namespace crepe { + +void LoopManager::process_input() { + SDLContext::get_instance().handle_events(this->gameRunning); +} +void LoopManager::start(){ + this->setup(); + this->loop(); +} +void LoopManager::set_running(bool running) { this->gameRunning = running; } + +void LoopManager::fixed_update() { +} + +void LoopManager::loop() { + LoopTimer & timer = LoopTimer::getInstance(); + timer.start(); + + while (gameRunning) { + timer.update(); + + while (timer.get_lag() >= timer.get_fixed_delta_time()) { + process_input(); + fixed_update(); + timer.advance_fixed_update(); + } + + update(); + render(); + + timer.enforce_frame_rate(); + } +} + + +void LoopManager::setup() { + this->gameRunning = true; + LoopTimer::getInstance().start(); + LoopTimer::getInstance().set_fps(60); +} + +void LoopManager::render() { + if (gameRunning) { + RenderSystem::get_instance().update(); + } +} + +void LoopManager::update() { + LoopTimer & timer = LoopTimer::getInstance(); + ScriptSystem::get_instance().update(); +} + +} // namespace crepe diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h new file mode 100644 index 0000000..a5c88c3 --- /dev/null +++ b/src/crepe/api/LoopManager.h @@ -0,0 +1,66 @@ +#pragma once + +namespace crepe { + +class LoopManager { + public: + void start(); + + private: + /** + * \brief Setup function for one-time initialization. + * + * This function initializes necessary components for the game. + */ + void setup(); + /** + * \brief Main game loop function. + * + * This function runs the main loop, handling game updates and rendering. + */ + void loop(); + + /** + * \brief Function for handling input-related system calls. + * + * Processes user inputs from keyboard and mouse. + */ + void process_input(); + + /** + * \brief Per-frame update. + * + * Updates the game state based on the elapsed time since the last frame. + */ + void update(); + + /** + * \brief Late update which is called after update(). + * + * This function can be used for final adjustments before rendering. + */ + void late_update(); + + /** + * \brief Fixed update executed at a fixed rate. + * + * This function updates physics and game logic based on LoopTimer's fixed_delta_time. + */ + void fixed_update(); + /** + * \brief Set game running variable + * + * \param running running (false = game shutdown, true = game running) + */ + void set_running(bool running); + /** + * \brief Function for executing render-related systems. + * + * Renders the current state of the game to the screen. + */ + void render(); + + bool gameRunning = false; + }; + +} // namespace crepe diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp new file mode 100644 index 0000000..5e432fc --- /dev/null +++ b/src/crepe/api/LoopTimer.cpp @@ -0,0 +1,59 @@ + +#include "../facade/SDLContext.h" + +#include "api/LoopTimer.h" + + +using namespace crepe; +LoopTimer::LoopTimer() {} + +LoopTimer & LoopTimer::getInstance() { + static LoopTimer instance; + return instance; +} + +void LoopTimer::start() { + last_frame_time = SDLContext::get_instance().get_ticks(); + elapsed_time = 0; + elapsed_fixed_time = 0; + delta_time = 0; +} + +void LoopTimer::update() { + uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); + delta_time = (current_frame_time - last_frame_time) / 1000.0; + + if (delta_time > maximum_delta_time) { + delta_time = maximum_delta_time; + } + delta_time = game_scale; + elapsed_time += delta_time; + last_frame_time = current_frame_time; +} + +double LoopTimer::get_delta_time() const { return delta_time; } +int LoopTimer::get_current_time() const { return elapsed_time; } + +void LoopTimer::advance_fixed_update() { elapsed_fixed_time += fixed_delta_time; } + +double LoopTimer::get_fixed_delta_time() const { return fixed_delta_time; } + +void LoopTimer::set_fps(int fps) { + this->fps = fps; + frame_target_time = 1.0 / fps; +} + +int LoopTimer::get_fps() const { return fps; } +void LoopTimer::set_game_scale(double value) { game_scale = value; }; +double LoopTimer::get_game_scale() const { return game_scale; } +void LoopTimer::enforce_frame_rate() { + uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); + double frame_duration = (current_frame_time - last_frame_time) / 1000.0; + + if (frame_duration < frame_target_time) { + uint32_t delay_time + = (uint32_t) ((frame_target_time - frame_duration) / 1000.0); + SDLContext::get_instance().delay(delay_time); + } +} +double LoopTimer::get_lag() const { return elapsed_time - elapsed_fixed_time; } diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h new file mode 100644 index 0000000..584a408 --- /dev/null +++ b/src/crepe/api/LoopTimer.h @@ -0,0 +1,81 @@ +#pragma once + +#include + +namespace crepe{ +class LoopTimer { +public: +/** + * \brief Get the singleton instance of LoopTimer. + * + * \return A reference to the LoopTimer instance. + */ +static LoopTimer& getInstance(); + +/** + * \brief Get the current delta time for the current frame. + * + * \return Delta time in seconds since the last frame. + */ +double get_delta_time() const; + +/** + * \brief Get the current game time. + * + * \note The current game time may vary from the real-world elapsed time. + * It is the cumulative sum of each frame's delta time. + * + * \return Elapsed game time in milliseconds. + */ +int get_current_time() const; + +/** + * \brief Set the target frames per second (FPS). + * + * \param fps The number of frames that should be rendered per second. + */ +void set_fps(int fps); + +/** + * \brief Get the current frames per second (FPS). + * + * \return Current FPS. + */ +int get_fps() const; + +/** + * \brief Get the current game scale. + * + * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. + */ +double get_game_scale() const; + +/** + * \brief Set the game scale. + * + * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). + */ +void set_game_scale(double game_scale); + +private: +friend class LoopManager; +void start(); +void enforce_frame_rate(); +double get_fixed_delta_time() const; +double get_lag() const; +LoopTimer(); +void update(); +void advance_fixed_update(); +private: +int fps = 50; ///< Current frames per second +double game_scale = 1; ///< Current game scale +double maximum_delta_time = 0.25; ///< Maximum delta time to avoid large jumps +double delta_time = 0; ///< Delta time for the current frame +double frame_target_time = 1.0 / fps; ///< Target time per frame in seconds +double fixed_delta_time = 0.02; ///< Fixed delta time for fixed updates +double elapsed_time = 0; ///< Total elapsed game time +double elapsed_fixed_time = 0; ///< Total elapsed time for fixed updates +uint64_t last_frame_time = 0; ///< Time of the last frame +}; + +} // namespace crepe::api diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt index 36f9d4d..751b556 100644 --- a/src/example/CMakeLists.txt +++ b/src/example/CMakeLists.txt @@ -28,4 +28,5 @@ add_example(proxy) add_example(db) add_example(ecs) add_example(scene_manager) +add_example(gameLoop) diff --git a/src/example/gameLoop.cpp b/src/example/gameLoop.cpp new file mode 100644 index 0000000..f3edbdb --- /dev/null +++ b/src/example/gameLoop.cpp @@ -0,0 +1,8 @@ +#include "crepe/api/LoopManager.h" +using namespace crepe; + +int main(){ + LoopManager loop; + loop.start(); + return 1; +} diff --git a/src/makefile b/src/makefile index b9c44c8..5e525e8 100644 --- a/src/makefile +++ b/src/makefile @@ -94,7 +94,10 @@ LOEK += example/script.cpp LOEK += test/audio.cpp LOEK += test/dummy.cpp JARO += test/PhysicsTest.cpp - +WOUTER += crepe/api/LoopManager.cpp +WOUTER += crepe/api/LoopManager.h +WOUTER += crepe/api/LoopTimer.cpp +WOUTER += crepe/api/LoopTimer.h FMT := $(JARO) #<<< CHANGE THIS TO YOUR NAME FOR STEP 2 format: FORCE clang-tidy -p build/compile_commands.json --fix-errors $(FMT) -- cgit v1.2.3 From d3f39a67d62473661f7a76237ebf6df66e26d506 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Sat, 9 Nov 2024 13:17:47 +0100 Subject: more cleanup --- src/crepe/api/LoopManager.cpp | 12 ++++++------ src/crepe/api/LoopManager.h | 2 +- src/crepe/api/LoopTimer.cpp | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index 746e9ce..0e22522 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -3,19 +3,20 @@ #include "../system/RenderSystem.h" #include "../system/ScriptSystem.h" +#include "../facade/SDLContext.h" #include "LoopManager.h" #include "LoopTimer.h" namespace crepe { void LoopManager::process_input() { - SDLContext::get_instance().handle_events(this->gameRunning); + SDLContext::get_instance().handle_events(this->game_running); } void LoopManager::start(){ this->setup(); this->loop(); } -void LoopManager::set_running(bool running) { this->gameRunning = running; } +void LoopManager::set_running(bool running) { this->game_running = running; } void LoopManager::fixed_update() { } @@ -24,7 +25,7 @@ void LoopManager::loop() { LoopTimer & timer = LoopTimer::getInstance(); timer.start(); - while (gameRunning) { + while (game_running) { timer.update(); while (timer.get_lag() >= timer.get_fixed_delta_time()) { @@ -42,20 +43,19 @@ void LoopManager::loop() { void LoopManager::setup() { - this->gameRunning = true; + this->game_running = true; LoopTimer::getInstance().start(); LoopTimer::getInstance().set_fps(60); } void LoopManager::render() { - if (gameRunning) { + if (game_running) { RenderSystem::get_instance().update(); } } void LoopManager::update() { LoopTimer & timer = LoopTimer::getInstance(); - ScriptSystem::get_instance().update(); } } // namespace crepe diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h index a5c88c3..8899bfd 100644 --- a/src/crepe/api/LoopManager.h +++ b/src/crepe/api/LoopManager.h @@ -60,7 +60,7 @@ class LoopManager { */ void render(); - bool gameRunning = false; + bool game_running = false; }; } // namespace crepe diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index 5e432fc..912493a 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -1,7 +1,7 @@ #include "../facade/SDLContext.h" -#include "api/LoopTimer.h" +#include "LoopTimer.h" using namespace crepe; -- cgit v1.2.3 From acfa153789d9b55f3453a1d32f249da04ad6b5c1 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Sat, 9 Nov 2024 13:21:34 +0100 Subject: changed comment --- src/crepe/api/LoopTimer.h | 2 +- src/crepe/facade/SDLContext.cpp | 203 ++++++++++++++++++++++++---------------- src/crepe/facade/SDLContext.h | 127 +++++++++++++++++++++++-- 3 files changed, 239 insertions(+), 93 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index 584a408..8d95921 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -78,4 +78,4 @@ double elapsed_fixed_time = 0; ///< Total elapsed time for fixed updates uint64_t last_frame_time = 0; ///< Time of the last frame }; -} // namespace crepe::api +} // namespace crepe diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 8da93e9..17ced0c 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -1,16 +1,22 @@ #include #include +#include #include #include #include #include #include +#include #include +#include +#include +#include #include "../api/Sprite.h" #include "../api/Texture.h" #include "../api/Transform.h" #include "../util/log.h" +#include "Exception.h" #include "SDLContext.h" @@ -21,34 +27,6 @@ SDLContext & SDLContext::get_instance() { return instance; } -void SDLContext::handle_events(bool & running) { - SDL_Event event; - while (SDL_PollEvent(&event)) { - if (event.type == SDL_QUIT) { - running = false; - } - } -} - -SDLContext::~SDLContext() { - dbg_trace(); - - if (this->game_renderer != nullptr) - SDL_DestroyRenderer(this->game_renderer); - - if (this->game_window != nullptr) { - SDL_DestroyWindow(this->game_window); - } - - // TODO: how are we going to ensure that these are called from the same - // thread that SDL_Init() was called on? This has caused problems for me - // before. - IMG_Quit(); - SDL_Quit(); -} - -void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer); } - SDLContext::SDLContext() { dbg_trace(); // FIXME: read window defaults from config manager @@ -59,26 +37,32 @@ SDLContext::SDLContext() { << std::endl; return; } - - this->game_window = SDL_CreateWindow( + SDL_Window * tmp_window = SDL_CreateWindow( "Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, - 1920, 1080, SDL_WINDOW_SHOWN); - if (!this->game_window) { + this->viewport.w, this->viewport.h, 0); + if (!tmp_window) { // FIXME: throw exception std::cerr << "Window could not be created! SDL_Error: " << SDL_GetError() << std::endl; + return; } + this->game_window + = {tmp_window, [](SDL_Window * window) { SDL_DestroyWindow(window); }}; - this->game_renderer - = SDL_CreateRenderer(this->game_window, -1, SDL_RENDERER_ACCELERATED); - if (!this->game_renderer) { + SDL_Renderer * tmp_renderer = SDL_CreateRenderer( + this->game_window.get(), -1, SDL_RENDERER_ACCELERATED); + if (!tmp_renderer) { // FIXME: throw exception std::cerr << "Renderer could not be created! SDL_Error: " << SDL_GetError() << std::endl; - SDL_DestroyWindow(this->game_window); + SDL_DestroyWindow(this->game_window.get()); return; } + this->game_renderer = {tmp_renderer, [](SDL_Renderer * renderer) { + SDL_DestroyRenderer(renderer); + }}; + int img_flags = IMG_INIT_PNG; if (!(IMG_Init(img_flags) & img_flags)) { // FIXME: throw exception @@ -87,71 +71,126 @@ SDLContext::SDLContext() { } } -void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer); } +SDLContext::~SDLContext() { + dbg_trace(); + + this->game_renderer.reset(); + this->game_window.reset(); + + // TODO: how are we going to ensure that these are called from the same + // thread that SDL_Init() was called on? This has caused problems for me + // before. + IMG_Quit(); + SDL_Quit(); +} + +void SDLContext::handle_events(bool & running) { + //TODO: wouter i need events + /* + SDL_Event event; + SDL_PollEvent(&event); + switch (event.type) { + case SDL_QUIT: + running = false; + break; + case SDL_KEYDOWN: + triggerEvent(KeyPressedEvent(getCustomKey(event.key.keysym.sym))); + break; + case SDL_MOUSEBUTTONDOWN: + int x, y; + SDL_GetMouseState(&x, &y); + triggerEvent(MousePressedEvent(x, y)); + break; + } + */ +} + +void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer.get()); } +void SDLContext::present_screen() { + SDL_RenderPresent(this->game_renderer.get()); +} -void SDLContext::draw(const Sprite & sprite, const Transform & transform) { +void SDLContext::draw(const Sprite & sprite, const Transform & transform, + const Camera & cam) { - static SDL_RendererFlip render_flip + SDL_RendererFlip render_flip = (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x) | (SDL_FLIP_VERTICAL * sprite.flip.flip_y)); - int w, h; - SDL_QueryTexture(sprite.sprite_image->texture, NULL, NULL, &w, &h); - // needs maybe camera for position + double adjusted_x = (transform.position.x - cam.x) * cam.zoom; + double adjusted_y = (transform.position.y - cam.y) * cam.zoom; + double adjusted_w = sprite.sprite_rect.w * transform.scale * cam.zoom; + double adjusted_h = sprite.sprite_rect.h * transform.scale * cam.zoom; + + SDL_Rect srcrect = { + .x = sprite.sprite_rect.x, + .y = sprite.sprite_rect.y, + .w = sprite.sprite_rect.w, + .h = sprite.sprite_rect.h, + }; + SDL_Rect dstrect = { - .x = static_cast(transform.position.x), - .y = static_cast(transform.position.y), - .w = static_cast(w * transform.scale), - .h = static_cast(h * transform.scale), + .x = static_cast(adjusted_x), + .y = static_cast(adjusted_y), + .w = static_cast(adjusted_w), + .h = static_cast(adjusted_h), }; - double degrees = transform.rotation * 180 / M_PI; - SDL_RenderCopyEx(this->game_renderer, sprite.sprite_image->texture, NULL, - &dstrect, degrees, NULL, render_flip); + SDL_RenderCopyEx(this->game_renderer.get(), + sprite.sprite_image->texture.get(), &srcrect, + + &dstrect, transform.rotation, NULL, render_flip); } -/* -SDL_Texture * SDLContext::setTextureFromPath(const char * path, SDL_Rect & clip, - const int row, const int col) { - dbg_trace(); +void SDLContext::camera(const Camera & cam) { + this->viewport.w = static_cast(cam.aspect_width); + this->viewport.h = static_cast(cam.aspect_height); + this->viewport.x = static_cast(cam.x) - (SCREEN_WIDTH / 2); + this->viewport.y = static_cast(cam.y) - (SCREEN_HEIGHT / 2); - SDL_Surface * tmp = IMG_Load(path); - if (!tmp) { - std::cerr << "Error surface " << IMG_GetError << std::endl; - } + SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, + cam.bg_color.g, cam.bg_color.b, cam.bg_color.a); +} - clip. - w = tmp->w / col; - clip.h = tmp->h / row; +uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); } - SDL_Texture * CreatedTexture - = SDL_CreateTextureFromSurface(this->game_renderer, tmp); +std::unique_ptr> +SDLContext::texture_from_path(const std::string & path) { - if (!CreatedTexture) { - std::cerr << "Error could not create texture " << IMG_GetError - << std::endl; + SDL_Surface * tmp = IMG_Load(path.c_str()); + if (tmp == nullptr) { + throw Exception("surface cannot be load from %s", path.c_str()); } - SDL_FreeSurface(tmp); - return CreatedTexture; -} -*/ + std::unique_ptr> + img_surface; + img_surface + = {tmp, [](SDL_Surface * surface) { SDL_FreeSurface(surface); }}; -SDL_Texture * SDLContext::texture_from_path(const char * path) { - dbg_trace(); + SDL_Texture * tmp_texture = SDL_CreateTextureFromSurface( + this->game_renderer.get(), img_surface.get()); - SDL_Surface * tmp = IMG_Load(path); - if (!tmp) { - std::cerr << "Error surface " << IMG_GetError << std::endl; + if (tmp_texture == nullptr) { + throw Exception("Texture cannot be load from %s", path.c_str()); } - SDL_Texture * created_texture - = SDL_CreateTextureFromSurface(this->game_renderer, tmp); - if (!created_texture) { - std::cerr << "Error could not create texture " << IMG_GetError - << std::endl; - } - SDL_FreeSurface(tmp); + std::unique_ptr> + img_texture; + img_texture = {tmp_texture, + [](SDL_Texture * texture) { SDL_DestroyTexture(texture); }}; - return created_texture; + return img_texture; +} +int SDLContext::get_width(const Texture & ctx) const { + int w; + SDL_QueryTexture(ctx.texture.get(), NULL, NULL, &w, NULL); + return w; +} +int SDLContext::get_height(const Texture & ctx) const { + int h; + SDL_QueryTexture(ctx.texture.get(), NULL, NULL, NULL, &h); + return h; +} +void SDLContext::delay(int ms) const{ + SDL_Delay(ms); } diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index f1ba8a6..6c57ef9 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -1,48 +1,155 @@ #pragma once +#include #include #include +#include +#include +#include #include "../api/Sprite.h" #include "../api/Transform.h" -#include "../system/RenderSystem.h" +#include "api/Camera.h" + +// FIXME: this needs to be removed +const int SCREEN_WIDTH = 640; +const int SCREEN_HEIGHT = 480; namespace crepe { +// TODO: SDL_Keycode is defined in a header not distributed with crepe, which +// means this typedef is unusable when crepe is packaged. Wouter will fix this +// later. +typedef SDL_Keycode CREPE_KEYCODES; + class Texture; +class LoopManager; + +/** + * \class SDLContext + * \brief Facade for the SDL library + * + * SDLContext is a singleton that handles the SDL window and renderer, provides methods + * for event handling, and rendering to the screen. It is never used directly by the user + */ class SDLContext { public: - // singleton + /** + * \brief Gets the singleton instance of SDLContext. + * \return Reference to the SDLContext instance. + */ static SDLContext & get_instance(); + SDLContext(const SDLContext &) = delete; SDLContext(SDLContext &&) = delete; SDLContext & operator=(const SDLContext &) = delete; SDLContext & operator=(SDLContext &&) = delete; - //TODO decide events wouter? - private: + //! will only use handle_events + friend class LoopManager; + /** + * \brief Handles SDL events such as window close and input. + * \param running Reference to a boolean flag that controls the main loop. + */ void handle_events(bool & running); private: + //! Will only use get_ticks + friend class AnimatorSystem; + friend class LoopTimer; + /** + * \brief Gets the current SDL ticks since the program started. + * \return Current ticks in milliseconds as a constant uint64_t. + */ + uint64_t get_ticks() const; + /** + * \brief Pauses the execution for a specified duration. + * + * This function uses SDL's delay function to halt the program execution + * for a given number of milliseconds, allowing for frame rate control + * or other timing-related functionality. + * + * \param ms Duration of the delay in milliseconds. + */ + void delay(int ms) const; +private: + /** + * \brief Constructs an SDLContext instance. + * Initializes SDL, creates a window and renderer. + */ SDLContext(); - virtual ~SDLContext(); + + /** + * \brief Destroys the SDLContext instance. + * Cleans up SDL resources, including the window and renderer. + */ + ~SDLContext(); private: + //! Will use the funtions: texture_from_path, get_width,get_height. friend class Texture; - SDL_Texture * texture_from_path(const char *); - //SDL_Texture* setTextureFromPath(const char*, SDL_Rect& clip, const int row, const int col); + + //! Will use the funtions: texture_from_path, get_width,get_height. + friend class Animator; + + /** + * \brief Loads a texture from a file path. + * \param path Path to the image file. + * \return Pointer to the created SDL_Texture. + */ + std::unique_ptr> + texture_from_path(const std::string & path); + /** + * \brief Gets the width of a texture. + * \param texture Reference to the Texture object. + * \return Width of the texture as an integer. + */ + int get_width(const Texture &) const; + + /** + * \brief Gets the height of a texture. + * \param texture Reference to the Texture object. + * \return Height of the texture as an integer. + */ + int get_height(const Texture &) const; private: + //! Will use draw,clear_screen, present_screen, camera. friend class RenderSystem; - void draw(const Sprite &, const Transform &); + + /** + * \brief Draws a sprite to the screen using the specified transform and camera. + * \param sprite Reference to the Sprite to draw. + * \param transform Reference to the Transform for positioning. + * \param camera Reference to the Camera for view adjustments. + */ + void draw(const Sprite & sprite, const Transform & transform, + const Camera & camera); + + //! Clears the screen, preparing for a new frame. void clear_screen(); + + //! Presents the rendered frame to the screen. void present_screen(); + /** + * \brief Sets the current camera for rendering. + * \param camera Reference to the Camera object. + */ + void camera(const Camera & camera); + private: - SDL_Window * game_window = nullptr; - SDL_Renderer * game_renderer = nullptr; + //! sdl Window + std::unique_ptr> game_window; + + //! renderer for the crepe engine + std::unique_ptr> + game_renderer; + + //! viewport for the camera window + SDL_Rect viewport = {0, 0, 640, 480}; }; } // namespace crepe -- cgit v1.2.3 From d23b23610f75797ff37cfd73881c6fd7d5a21c88 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Sat, 9 Nov 2024 13:35:25 +0100 Subject: cleanup code --- lib/sdl2 | 2 +- lib/sdl_image | 2 +- lib/sdl_ttf | 2 +- lib/soloud | 2 +- src/crepe/api/CMakeLists.txt | 4 ---- src/crepe/api/LoopManager.cpp | 1 - src/crepe/api/LoopTimer.cpp | 1 - src/example/CMakeLists.txt | 1 - src/example/gameLoop.cpp | 8 -------- src/makefile | 6 +++--- 10 files changed, 7 insertions(+), 22 deletions(-) delete mode 100644 src/example/gameLoop.cpp (limited to 'src/crepe/api') diff --git a/lib/sdl2 b/lib/sdl2 index c98c4fb..9519b99 160000 --- a/lib/sdl2 +++ b/lib/sdl2 @@ -1 +1 @@ -Subproject commit c98c4fbff6d8f3016a3ce6685bf8f43433c3efcc +Subproject commit 9519b9916cd29a14587af0507292f2bd31dd5752 diff --git a/lib/sdl_image b/lib/sdl_image index 5656019..abcf63a 160000 --- a/lib/sdl_image +++ b/lib/sdl_image @@ -1 +1 @@ -Subproject commit 56560190a6c5b5740e5afdce747e2a2bfbf16db1 +Subproject commit abcf63aa71b4e3ac32120fa9870a6500ddcdcc89 diff --git a/lib/sdl_ttf b/lib/sdl_ttf index a3d0895..4a318f8 160000 --- a/lib/sdl_ttf +++ b/lib/sdl_ttf @@ -1 +1 @@ -Subproject commit a3d0895c1b60c41ff9e85d9203ddd7485c014dae +Subproject commit 4a318f8dfaa1bb6f10e0c5e54052e25d3c7f3440 diff --git a/lib/soloud b/lib/soloud index e82fd32..c8e339f 160000 --- a/lib/soloud +++ b/lib/soloud @@ -1 +1 @@ -Subproject commit e82fd32c1f62183922f08c14c814a02b58db1873 +Subproject commit c8e339fdce5c7107bdb3e64bbf707c8fd3449beb diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt index e7894d7..3b20142 100644 --- a/src/crepe/api/CMakeLists.txt +++ b/src/crepe/api/CMakeLists.txt @@ -16,8 +16,6 @@ target_sources(crepe PUBLIC Scene.cpp SceneManager.cpp Vector2.cpp - LoopManager.cpp - LoopTimer.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -40,6 +38,4 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES Metadata.h SceneManager.h SceneManager.hpp - LoopManager.h - LoopTimer.h ) diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index 0e22522..99763e4 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -1,5 +1,4 @@ - #include "../system/RenderSystem.h" #include "../system/ScriptSystem.h" diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index 912493a..c6ffe9d 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -3,7 +3,6 @@ #include "LoopTimer.h" - using namespace crepe; LoopTimer::LoopTimer() {} diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt index 751b556..36f9d4d 100644 --- a/src/example/CMakeLists.txt +++ b/src/example/CMakeLists.txt @@ -28,5 +28,4 @@ add_example(proxy) add_example(db) add_example(ecs) add_example(scene_manager) -add_example(gameLoop) diff --git a/src/example/gameLoop.cpp b/src/example/gameLoop.cpp deleted file mode 100644 index f3edbdb..0000000 --- a/src/example/gameLoop.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include "crepe/api/LoopManager.h" -using namespace crepe; - -int main(){ - LoopManager loop; - loop.start(); - return 1; -} diff --git a/src/makefile b/src/makefile index 5e525e8..ce5a29f 100644 --- a/src/makefile +++ b/src/makefile @@ -94,11 +94,11 @@ LOEK += example/script.cpp LOEK += test/audio.cpp LOEK += test/dummy.cpp JARO += test/PhysicsTest.cpp -WOUTER += crepe/api/LoopManager.cpp WOUTER += crepe/api/LoopManager.h -WOUTER += crepe/api/LoopTimer.cpp +WOUTER += crepe/api/LoopManager.cpp WOUTER += crepe/api/LoopTimer.h -FMT := $(JARO) #<<< CHANGE THIS TO YOUR NAME FOR STEP 2 +WOUTER += crepe/api/LoopTimer.cpp +FMT := $(WOUTER) #<<< CHANGE THIS TO YOUR NAME FOR STEP 2 format: FORCE clang-tidy -p build/compile_commands.json --fix-errors $(FMT) -- cgit v1.2.3 From aa4fbb5d2778ea40c3f996c9b07bcdbb155cbcd0 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Sat, 9 Nov 2024 13:42:18 +0100 Subject: make format changes --- src/crepe/api/LoopManager.cpp | 8 ++++---- src/crepe/api/LoopTimer.cpp | 2 +- src/crepe/api/LoopTimer.h | 2 +- src/crepe/facade/SDLContext.h | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index 99763e4..e737f78 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -21,7 +21,7 @@ void LoopManager::fixed_update() { } void LoopManager::loop() { - LoopTimer & timer = LoopTimer::getInstance(); + LoopTimer & timer = LoopTimer::get_instance(); timer.start(); while (game_running) { @@ -43,8 +43,8 @@ void LoopManager::loop() { void LoopManager::setup() { this->game_running = true; - LoopTimer::getInstance().start(); - LoopTimer::getInstance().set_fps(60); + LoopTimer::get_instance().start(); + LoopTimer::get_instance().set_fps(60); } void LoopManager::render() { @@ -54,7 +54,7 @@ void LoopManager::render() { } void LoopManager::update() { - LoopTimer & timer = LoopTimer::getInstance(); + LoopTimer & timer = LoopTimer::get_instance(); } } // namespace crepe diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index c6ffe9d..98ce08d 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -6,7 +6,7 @@ using namespace crepe; LoopTimer::LoopTimer() {} -LoopTimer & LoopTimer::getInstance() { +LoopTimer & LoopTimer::get_instance() { static LoopTimer instance; return instance; } diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index 8d95921..5b7d3f2 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -10,7 +10,7 @@ public: * * \return A reference to the LoopTimer instance. */ -static LoopTimer& getInstance(); +static LoopTimer& get_instance(); /** * \brief Get the current delta time for the current frame. diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 6c57ef9..67e330b 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -9,7 +9,7 @@ #include "../api/Sprite.h" #include "../api/Transform.h" -#include "api/Camera.h" +// #include "../api/Camera.h" // FIXME: this needs to be removed const int SCREEN_WIDTH = 640; -- cgit v1.2.3 From 89c96e6478535c3a73aaa6c29591e008399b1a09 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Sat, 9 Nov 2024 13:43:28 +0100 Subject: added line break --- src/crepe/api/LoopManager.cpp | 2 +- src/crepe/facade/SDLContext.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index e737f78..5c79920 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -1,8 +1,8 @@ #include "../system/RenderSystem.h" #include "../system/ScriptSystem.h" - #include "../facade/SDLContext.h" + #include "LoopManager.h" #include "LoopTimer.h" diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 67e330b..6c57ef9 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -9,7 +9,7 @@ #include "../api/Sprite.h" #include "../api/Transform.h" -// #include "../api/Camera.h" +#include "api/Camera.h" // FIXME: this needs to be removed const int SCREEN_WIDTH = 640; -- cgit v1.2.3 From b668abb3a0671c1233bb30d038a5a53018aa8620 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Sun, 10 Nov 2024 15:25:13 +0100 Subject: added unit test for particles --- src/crepe/Particle.h | 43 ++++++++++++++++++- src/crepe/api/ParticleEmitter.cpp | 2 +- src/crepe/api/ParticleEmitter.h | 45 +++++++++++++++---- src/crepe/system/ParticleSystem.cpp | 6 +-- src/example/particles.cpp | 1 - src/test/CMakeLists.txt | 3 +- src/test/ParticleTest.cpp | 86 +++++++++++++++++++++++++++++++++++++ 7 files changed, 169 insertions(+), 17 deletions(-) create mode 100644 src/test/ParticleTest.cpp (limited to 'src/crepe/api') diff --git a/src/crepe/Particle.h b/src/crepe/Particle.h index f52196c..77c3ea3 100644 --- a/src/crepe/Particle.h +++ b/src/crepe/Particle.h @@ -1,22 +1,61 @@ #pragma once -#include "api/Transform.h" +#include + +#include "api/Vector2.h" namespace crepe { +/** + * \brief Represents a particle in the particle emitter. + * + * This class stores information about a single particle, including its position, + * velocity, lifespan, and other properties. Particles can be updated over time + * to simulate movement and can also be reset or stopped. + */ class Particle { public: + //! Position of the particle in 2D space. Vector2 position; + //! Velocity vector indicating the speed and direction of the particle. Vector2 velocity; + //! Accumulated force affecting the particle over time. Vector2 force_over_time; + //! Total lifespan of the particle in milliseconds. uint32_t 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; + //! The angle at which the particle is oriented or moving. double angle; Particle() = default; - void reset(uint32_t lifespan, Vector2 position, Vector2 velocity,double angle); + /** + * \brief Resets the particle with new properties. + * + * This method initializes the particle with a specific lifespan, position, + * velocity, and angle, marking it as active and resetting its life counter. + * + * \param lifespan The lifespan of the particle in amount of updates. + * \param position The starting position of the particle. + * \param velocity The initial velocity of the particle. + * \param angle The angle of the particle's trajectory or orientation. + */ + void reset(uint32_t lifespan, Vector2 position, Vector2 velocity, double angle); + /** + * \brief Updates the particle's state. + * + * Advances the particle's position based on its velocity and applies accumulated forces. + * Deactivates the particle if its lifespan has expired. + */ void update(); + /** + * \brief Stops the particle's movement. + * + * Sets the particle's velocity to zero, effectively halting any further + * movement. + */ void stop_movement(); }; diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index f585a81..000bf30 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -3,7 +3,7 @@ using namespace crepe; -ParticleEmitter::ParticleEmitter(uint32_t game_object_id, const ParticleEmitterData& data) : Component(game_object_id),data(data) { +ParticleEmitter::ParticleEmitter(uint32_t game_object_id, const Data& data) : Component(game_object_id),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 f931e8c..2cda1bb 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -11,24 +11,44 @@ class Sprite; namespace crepe { + +/** + * \brief Data holder for particle emission parameters. + * + * The ParticleEmitter class stores configuration data for particle properties, + * defining the characteristics and boundaries of particle emissions. + */ + class ParticleEmitter : public Component { public: - struct ParticleBoundary{ + /** + * \brief Defines the boundary within which particles are constrained. + * + * This structure specifies the boundary's size and offset, as well as the + * behavior of particles upon reaching the boundary limits. + */ + struct Boundary{ //! boundary width (midpoint is emitter location) - double boundary_width = 0.0; + double width = 0.0; //! boundary height (midpoint is emitter location) - double boundary_height = 0.0; + double height = 0.0; //! boundary offset from particle emitter location - Vector2 boundary_offset; + Vector2 offset; //! reset on exit or stop velocity and set max postion bool reset_on_exit = false; }; - struct ParticleEmitterData{ + /** + * \brief Holds parameters that control particle emission. + * + * Contains settings for the emitter’s position, particle speed, angle, lifespan, + * boundary, and the sprite used for rendering particles. + */ + struct Data{ //! position of the emitter Vector2 position; //! maximum number of particles - uint32_t max_particles = 0; + const uint32_t max_particles = 0; //! rate of particle emission per update (Lowest value = 0.001 any lower is ignored) double emission_rate = 0; //! min speed of the particles @@ -46,17 +66,24 @@ public: //! force over time (physics) Vector2 force_over_time; //! particle boundary - ParticleBoundary boundary; + Boundary boundary; //! collection of particles std::vector particles; //! sprite reference const Sprite* sprite; }; public: - ParticleEmitter(uint32_t game_object_id, const ParticleEmitterData& data); + /** + * \brief Constructs a ParticleEmitter data holder with specified settings. + * + * \param game_object_id Identifier for the game object using this emitter. + * \param data Configuration data defining particle properties. + */ + ParticleEmitter(uint32_t game_object_id, const Data& data); ~ParticleEmitter(); public: - ParticleEmitterData data; + //! Configuration data for particle emission settings. + Data data; }; } // namespace crepe diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index b2fe829..85321f0 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -116,9 +116,9 @@ int ParticleSystem::calculate_update(int count, double emission) { void ParticleSystem::check_bounds(ParticleEmitter & emitter,const Transform& transform) { - Vector2 offset = emitter.data.boundary.boundary_offset + transform.position + emitter.data.position; - double half_width = emitter.data.boundary.boundary_width / 2.0; - double half_height = emitter.data.boundary.boundary_height / 2.0; + Vector2 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; // Define boundary edges const double left = offset.x - half_width; diff --git a/src/example/particles.cpp b/src/example/particles.cpp index bcff48f..01e33cf 100644 --- a/src/example/particles.cpp +++ b/src/example/particles.cpp @@ -19,7 +19,6 @@ using namespace std; int main(int argc, char * argv[]) { - Color color(0, 0, 0, 0); GameObject *game_object = new GameObject(0, "Name", "Tag", Vector2{0,0},0,0); game_object->add_component(ParticleEmitter::ParticleEmitterData{ .position = {0,0}, diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt index 0e4eaed..acab388 100644 --- a/src/test/CMakeLists.txt +++ b/src/test/CMakeLists.txt @@ -1,6 +1,7 @@ target_sources(test_main PUBLIC dummy.cpp # audio.cpp - PhysicsTest.cpp + # PhysicsTest.cpp + ParticleTest.cpp ) diff --git a/src/test/ParticleTest.cpp b/src/test/ParticleTest.cpp new file mode 100644 index 0000000..aa63ccf --- /dev/null +++ b/src/test/ParticleTest.cpp @@ -0,0 +1,86 @@ +#include +#include +#include +#include +#include +#include +#include +#include + + +using namespace std; +using namespace std::chrono_literals; +using namespace crepe; + +class ParticlesTest : public ::testing::Test { +protected: + GameObject * game_object; + ParticleSystem particle_system; + void SetUp() override { + ComponentManager & mgr = ComponentManager::get_instance(); + std::vector> transforms + = mgr.get_components_by_id(0); + if (transforms.empty()) { + game_object = new GameObject(0, "", "", Vector2{0, 0}, 0, 0); + game_object->add_component(ParticleEmitter::Data{ + .position = {0,0}, + .max_particles = 1, + .emission_rate = 0, + .min_speed = 0, + .max_speed = 0, + .min_angle = 0, + .max_angle = 0, + .begin_lifespan = 0, + .end_lifespan = 0, + .force_over_time = Vector2{0,0}, + .boundary{ + .width = 0, + .height = 0, + .offset = Vector2{0,0}, + .reset_on_exit = false, + }, + .sprite = nullptr, + }); + } + transforms = mgr.get_components_by_id(0); + Transform & transform = transforms.front().get(); + transform.position.x = 0.0; + transform.position.y = 0.0; + transform.rotation = 0.0; + std::vector> rigidbodies + = mgr.get_components_by_id(0); + Rigidbody & rigidbody = rigidbodies.front().get(); + rigidbody.data.angular_velocity = 0; + rigidbody.data.linear_velocity.x = 0; + rigidbody.data.linear_velocity.y = 0; + } +}; + +TEST_F(ParticlesTest, spawnParticle) { + Config::get_instance().physics.gravity = 1; + ComponentManager & mgr = ComponentManager::get_instance(); + ParticleEmitter & emitter = mgr.get_components_by_id(0).front().get(); + emitter.data.end_lifespan = 5; + emitter.data.boundary.height = 100; + emitter.data.boundary.width = 100; + emitter.data.max_speed = 1; + emitter.data.max_angle = 1; + particle_system.update(); + //check if nothing happend + EXPECT_EQ(emitter.data.particles.size(), 0); + emitter.data.emission_rate = 1; + particle_system.update(); + //check if particle spawned + EXPECT_EQ(emitter.data.particles.size(), 1); + for (auto& particle : emitter.data.particles) { + // Check velocity range + EXPECT_GE(particle.velocity.x, emitter.data.min_speed); // Speed should be greater than or equal to min_speed + EXPECT_LE(particle.velocity.x, emitter.data.max_speed); // Speed should be less than or equal to max_speed + EXPECT_GE(particle.velocity.y, emitter.data.min_speed); // Speed should be greater than or equal to min_speed + EXPECT_LE(particle.velocity.y, emitter.data.max_speed); // Speed should be less than or equal to max_speed + + // Check angle range + EXPECT_GE(particle.angle, emitter.data.min_angle); // Angle should be greater than or equal to min_angle + EXPECT_LE(particle.angle, emitter.data.max_angle); // Angle should be less than or equal to max_angle + } +} -- cgit v1.2.3 From 0006e959643f0150acd230b174287a85d4cb3255 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Sun, 10 Nov 2024 18:30:10 +0100 Subject: added forward declaration and const reference sprite --- src/crepe/api/ParticleEmitter.h | 6 +++--- src/crepe/system/ParticleSystem.cpp | 1 + src/crepe/system/ParticleSystem.h | 4 ++-- src/test/ParticleTest.cpp | 22 ++++++++++++++++------ 4 files changed, 22 insertions(+), 11 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index 2cda1bb..e81ed3b 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -5,9 +5,9 @@ #include "Component.h" #include "Particle.h" -#include "Transform.h" +#include "Sprite.h" -class Sprite; +// class Sprite; namespace crepe { @@ -70,7 +70,7 @@ public: //! collection of particles std::vector particles; //! sprite reference - const Sprite* sprite; + const Sprite& sprite; }; public: /** diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 33027f8..ad6699b 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -4,6 +4,7 @@ #include "api/ParticleEmitter.h" #include "api/Vector2.h" +#include "api/Transform.h" #include "ComponentManager.h" #include "ParticleSystem.h" diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h index df89ed9..023a886 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -1,9 +1,9 @@ #pragma once -#include "../api/ParticleEmitter.h" namespace crepe { - +class ParticleEmitter; +class Transform; /** * \brief ParticleSystem class responsible for managing particle emission, updates, and bounds checking. */ diff --git a/src/test/ParticleTest.cpp b/src/test/ParticleTest.cpp index 8c6a7e7..7883eca 100644 --- a/src/test/ParticleTest.cpp +++ b/src/test/ParticleTest.cpp @@ -5,25 +5,36 @@ #include #include #include +#include +#include #include #include - +#include using namespace std; using namespace std::chrono_literals; using namespace crepe; + + class ParticlesTest : public ::testing::Test { protected: - GameObject * game_object; ParticleSystem particle_system; void SetUp() override { ComponentManager & mgr = ComponentManager::get_instance(); std::vector> transforms = mgr.get_components_by_id(0); if (transforms.empty()) { - game_object = new GameObject(0, "", "", Vector2{0, 0}, 0, 0); - game_object->add_component(ParticleEmitter::Data{ + + + GameObject game_object(0, "", "", Vector2{0, 0}, 0, 0); + + Color color(0, 0, 0, 0); + Sprite test_sprite = game_object.add_component( + make_shared("../asset/texture/img.png"), color, + FlipSettings{true, true}); + + game_object.add_component(ParticleEmitter::Data{ .position = {0,0}, .max_particles = 100, .emission_rate = 0, @@ -40,7 +51,7 @@ protected: .offset = Vector2{0,0}, .reset_on_exit = false, }, - .sprite = nullptr, + .sprite = test_sprite, }); } transforms = mgr.get_components_by_id(0); @@ -61,7 +72,6 @@ protected: emitter.data.end_lifespan = 0; emitter.data.force_over_time = Vector2{0, 0}; emitter.data.boundary = {0, 0, Vector2{0, 0}, false}; - emitter.data.sprite = nullptr; for (auto& particle : emitter.data.particles) { particle.active = false; } -- cgit v1.2.3 From 46716724df7697fa789329a62f7a5444ceed5585 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Sun, 10 Nov 2024 19:18:58 +0100 Subject: changed includes --- src/crepe/Particle.cpp | 2 -- src/crepe/api/ParticleEmitter.cpp | 3 ++- src/crepe/api/ParticleEmitter.h | 1 + src/crepe/system/ParticleSystem.h | 1 + 4 files changed, 4 insertions(+), 3 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp index cb2ef0d..3777db0 100644 --- a/src/crepe/Particle.cpp +++ b/src/crepe/Particle.cpp @@ -1,7 +1,5 @@ #include "Particle.h" -#include "api/Transform.h" - using namespace crepe; void Particle::reset(uint32_t lifespan, Vector2 position, Vector2 velocity, double angle) { diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 000bf30..1703026 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -1,5 +1,6 @@ -#include "Particle.h" #include "ParticleEmitter.h" +#include "Particle.h" + using namespace crepe; diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index e81ed3b..037effe 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -6,6 +6,7 @@ #include "Component.h" #include "Particle.h" #include "Sprite.h" +#include "Vector2.h" // class Sprite; diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h index 023a886..a74ea79 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -1,5 +1,6 @@ #pragma once +#include namespace crepe { class ParticleEmitter; -- cgit v1.2.3 From e42d0877592aa1e88afbe0bc65822cd53a82205d Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Sun, 10 Nov 2024 19:34:15 +0100 Subject: clang format and tidy --- src/crepe/Particle.cpp | 3 +- src/crepe/Particle.h | 5 +- src/crepe/api/ParticleEmitter.cpp | 12 ++--- src/crepe/api/ParticleEmitter.h | 13 ++--- src/crepe/system/ParticleSystem.cpp | 72 +++++++++++++++---------- src/crepe/system/ParticleSystem.h | 4 +- src/example/particles.cpp | 17 +++--- src/makefile | 2 +- src/test/ParticleTest.cpp | 103 ++++++++++++++++++++---------------- 9 files changed, 129 insertions(+), 102 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp index 3777db0..ab55f37 100644 --- a/src/crepe/Particle.cpp +++ b/src/crepe/Particle.cpp @@ -2,7 +2,8 @@ using namespace crepe; -void Particle::reset(uint32_t lifespan, Vector2 position, Vector2 velocity, double angle) { +void Particle::reset(uint32_t lifespan, Vector2 position, Vector2 velocity, + double 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 88a015d..06431bb 100644 --- a/src/crepe/Particle.h +++ b/src/crepe/Particle.h @@ -15,6 +15,7 @@ namespace crepe { */ class Particle { // TODO: add friend particleSsytem and rendersystem. Unit test will fail. + public: //! Position of the particle in 2D space. Vector2 position; @@ -43,7 +44,8 @@ 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, Vector2 position, Vector2 velocity, double angle); + void reset(uint32_t lifespan, Vector2 position, Vector2 velocity, + double angle); /** * \brief Updates the particle's state. * @@ -58,7 +60,6 @@ public: * movement. */ void stop_movement(); - }; } // namespace crepe diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 1703026..e7f298c 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -1,20 +1,18 @@ #include "ParticleEmitter.h" #include "Particle.h" - using namespace crepe; -ParticleEmitter::ParticleEmitter(uint32_t game_object_id, const Data& data) : Component(game_object_id),data(data) { - for (size_t i = 0; i < this->data.max_particles; i++) { - this->data.particles.emplace_back(); - } +ParticleEmitter::ParticleEmitter(uint32_t game_object_id, const Data & data) + : Component(game_object_id), data(data) { + for (size_t i = 0; i < this->data.max_particles; i++) { + this->data.particles.emplace_back(); + } } - ParticleEmitter::~ParticleEmitter() { std::vector::iterator it = this->data.particles.begin(); while (it != this->data.particles.end()) { it = this->data.particles.erase(it); } } - diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index 037effe..83a1588 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -12,7 +12,6 @@ namespace crepe { - /** * \brief Data holder for particle emission parameters. * @@ -28,7 +27,7 @@ public: * This structure specifies the boundary's size and offset, as well as the * behavior of particles upon reaching the boundary limits. */ - struct Boundary{ + struct Boundary { //! boundary width (midpoint is emitter location) double width = 0.0; //! boundary height (midpoint is emitter location) @@ -45,7 +44,7 @@ public: * Contains settings for the emitter’s position, particle speed, angle, lifespan, * boundary, and the sprite used for rendering particles. */ - struct Data{ + struct Data { //! position of the emitter Vector2 position; //! maximum number of particles @@ -71,8 +70,9 @@ public: //! collection of particles std::vector particles; //! sprite reference - const Sprite& sprite; - }; + const Sprite & sprite; + }; + public: /** * \brief Constructs a ParticleEmitter data holder with specified settings. @@ -80,8 +80,9 @@ public: * \param game_object_id Identifier for the game object using this emitter. * \param data Configuration data defining particle properties. */ - ParticleEmitter(uint32_t game_object_id, const Data& data); + ParticleEmitter(uint32_t game_object_id, const Data & data); ~ParticleEmitter(); + public: //! Configuration data for particle emission settings. Data data; diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index ad6699b..4a25b47 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -1,10 +1,10 @@ #include -#include #include +#include #include "api/ParticleEmitter.h" -#include "api/Vector2.h" #include "api/Transform.h" +#include "api/Vector2.h" #include "ComponentManager.h" #include "ParticleSystem.h" @@ -16,20 +16,25 @@ ParticleSystem::ParticleSystem() {} void ParticleSystem::update() { // Get all emitters ComponentManager & mgr = ComponentManager::get_instance(); - std::vector> emitters = mgr.get_components_by_type(); + std::vector> emitters + = mgr.get_components_by_type(); for (ParticleEmitter & emitter : emitters) { // Get transform linked to emitter - const Transform& transform = mgr.get_components_by_id(emitter.game_object_id).front().get(); + const Transform & transform + = 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 + = calculate_update(this->update_count, emitter.data.emission_rate); for (size_t i = 0; i < updates; i++) { emit_particle(emitter, transform); } // Update all particles - for (Particle& particle : emitter.data.particles) { + for (Particle & particle : emitter.data.particles) { if (particle.active) { particle.update(); } @@ -42,23 +47,25 @@ void ParticleSystem::update() { this->update_count = (this->update_count + 1) % this->MAX_UPDATE_COUNT; } -void ParticleSystem::emit_particle(ParticleEmitter & emitter, const Transform& transform) { +void ParticleSystem::emit_particle(ParticleEmitter & emitter, + const Transform & transform) { constexpr double DEG_TO_RAD = M_PI / 180.0; Vector2 initial_position = emitter.data.position + transform.position; - double random_angle = generate_random_angle(emitter.data.min_angle, emitter.data.max_angle); + double random_angle + = generate_random_angle(emitter.data.min_angle, emitter.data.max_angle); - double random_speed = generate_random_speed(emitter.data.min_speed, emitter.data.max_speed); + double random_speed + = generate_random_speed(emitter.data.min_speed, emitter.data.max_speed); double angle_radians = random_angle * DEG_TO_RAD; - Vector2 velocity = { - random_speed * std::cos(angle_radians), - random_speed * std::sin(angle_radians) - }; + Vector2 velocity = {random_speed * std::cos(angle_radians), + random_speed * std::sin(angle_radians)}; - for (Particle& particle : emitter.data.particles) { + for (Particle & particle : emitter.data.particles) { if (!particle.active) { - particle.reset(emitter.data.end_lifespan, initial_position, velocity, random_angle); + particle.reset(emitter.data.end_lifespan, initial_position, + velocity, random_angle); break; } } @@ -69,15 +76,17 @@ int ParticleSystem::calculate_update(int count, double emission) const { double fractional_part = emission - integer_part; if (fractional_part > 0) { - int denominator = static_cast(1.0 / fractional_part); - return (count % denominator == 0) ? 1 : 0; + int denominator = static_cast(1.0 / fractional_part); + return (count % denominator == 0) ? 1 : 0; } return static_cast(emission); } -void ParticleSystem::check_bounds(ParticleEmitter & emitter, const Transform& transform) { - Vector2 offset = emitter.data.boundary.offset + transform.position + emitter.data.position; +void ParticleSystem::check_bounds(ParticleEmitter & emitter, + const Transform & transform) { + Vector2 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; @@ -86,9 +95,10 @@ void ParticleSystem::check_bounds(ParticleEmitter & emitter, const Transform& tr const double TOP = offset.y - half_height; const double BOTTOM = offset.y + half_height; - for (Particle& particle : emitter.data.particles) { - const Vector2& position = particle.position; - bool within_bounds = (position.x >= LEFT && position.x <= RIGHT && position.y >= TOP && position.y <= BOTTOM); + for (Particle & particle : emitter.data.particles) { + const Vector2 & position = particle.position; + bool within_bounds = (position.x >= LEFT && position.x <= RIGHT + && position.y >= TOP && position.y <= BOTTOM); if (!within_bounds) { if (emitter.data.boundary.reset_on_exit) { @@ -104,22 +114,30 @@ void ParticleSystem::check_bounds(ParticleEmitter & emitter, const Transform& tr } } -double ParticleSystem::generate_random_angle(double min_angle, double max_angle) const { +double ParticleSystem::generate_random_angle(double min_angle, + double 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)); + return 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)); + double 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 { +double ParticleSystem::generate_random_speed(double min_speed, + double 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)); + return 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 a74ea79..3155df1 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -27,7 +27,7 @@ private: * \param emitter Reference to the ParticleEmitter. * \param transform Const reference to the Transform component associated with the emitter. */ - void emit_particle(ParticleEmitter & emitter, const Transform& transform); + void emit_particle(ParticleEmitter & emitter, const Transform & transform); /** * \brief Calculates the number of times particles should be emitted based on emission rate and update count. @@ -44,7 +44,7 @@ private: * \param emitter Reference to the ParticleEmitter. * \param transform Const reference to the Transform component associated with the emitter. */ - void check_bounds(ParticleEmitter & emitter, const Transform& transform); + void check_bounds(ParticleEmitter & emitter, const Transform & transform); /** * \brief Generates a random angle for particle emission within the specified range. diff --git a/src/example/particles.cpp b/src/example/particles.cpp index 407df4e..6eab046 100644 --- a/src/example/particles.cpp +++ b/src/example/particles.cpp @@ -2,14 +2,13 @@ #include #include +#include #include -#include -#include #include +#include #include #include -#include - +#include using namespace crepe; using namespace std; @@ -18,10 +17,10 @@ int main(int argc, char * argv[]) { GameObject game_object(0, "", "", Vector2{0, 0}, 0, 0); Color color(0, 0, 0, 0); Sprite test_sprite = game_object.add_component( - make_shared("../asset/texture/img.png"), color, - FlipSettings{true, true}); + make_shared("../asset/texture/img.png"), color, + FlipSettings{true, true}); game_object.add_component(ParticleEmitter::Data{ - .position = {0,0}, + .position = {0, 0}, .max_particles = 100, .emission_rate = 0, .min_speed = 0, @@ -30,11 +29,11 @@ int main(int argc, char * argv[]) { .max_angle = 0, .begin_lifespan = 0, .end_lifespan = 0, - .force_over_time = Vector2{0,0}, + .force_over_time = Vector2{0, 0}, .boundary{ .width = 0, .height = 0, - .offset = Vector2{0,0}, + .offset = Vector2{0, 0}, .reset_on_exit = false, }, .sprite = test_sprite, diff --git a/src/makefile b/src/makefile index 59298fd..356179e 100644 --- a/src/makefile +++ b/src/makefile @@ -87,7 +87,7 @@ LOEK += example/audio_internal.cpp TODO += example/components_internal.cpp MAX += example/ecs.cpp LOEK += example/log.cpp -JARO += example/particle.cpp +JARO += example/particles.cpp JARO += example/physics.cpp TODO += example/rendering.cpp LOEK += example/script.cpp diff --git a/src/test/ParticleTest.cpp b/src/test/ParticleTest.cpp index 7883eca..6fe3133 100644 --- a/src/test/ParticleTest.cpp +++ b/src/test/ParticleTest.cpp @@ -1,22 +1,20 @@ #include "api/Vector2.h" -#include #include +#include #include #include +#include #include +#include #include -#include -#include #include #include -#include +#include using namespace std; using namespace std::chrono_literals; using namespace crepe; - - class ParticlesTest : public ::testing::Test { protected: ParticleSystem particle_system; @@ -25,17 +23,16 @@ protected: std::vector> transforms = mgr.get_components_by_id(0); if (transforms.empty()) { - - + GameObject game_object(0, "", "", Vector2{0, 0}, 0, 0); Color color(0, 0, 0, 0); Sprite test_sprite = game_object.add_component( - make_shared("../asset/texture/img.png"), color, - FlipSettings{true, true}); + make_shared("../asset/texture/img.png"), color, + FlipSettings{true, true}); game_object.add_component(ParticleEmitter::Data{ - .position = {0,0}, + .position = {0, 0}, .max_particles = 100, .emission_rate = 0, .min_speed = 0, @@ -44,11 +41,11 @@ protected: .max_angle = 0, .begin_lifespan = 0, .end_lifespan = 0, - .force_over_time = Vector2{0,0}, + .force_over_time = Vector2{0, 0}, .boundary{ .width = 0, .height = 0, - .offset = Vector2{0,0}, + .offset = Vector2{0, 0}, .reset_on_exit = false, }, .sprite = test_sprite, @@ -72,7 +69,7 @@ protected: emitter.data.end_lifespan = 0; emitter.data.force_over_time = Vector2{0, 0}; emitter.data.boundary = {0, 0, Vector2{0, 0}, false}; - for (auto& particle : emitter.data.particles) { + for (auto & particle : emitter.data.particles) { particle.active = false; } } @@ -81,7 +78,8 @@ protected: TEST_F(ParticlesTest, spawnParticle) { Config::get_instance().physics.gravity = 1; ComponentManager & mgr = ComponentManager::get_instance(); - ParticleEmitter & emitter = mgr.get_components_by_id(0).front().get(); + ParticleEmitter & emitter + = mgr.get_components_by_id(0).front().get(); emitter.data.end_lifespan = 5; emitter.data.boundary.height = 100; emitter.data.boundary.width = 100; @@ -89,7 +87,7 @@ TEST_F(ParticlesTest, spawnParticle) { emitter.data.max_angle = 0.1; emitter.data.max_speed = 10; emitter.data.max_angle = 10; - particle_system.update(); + particle_system.update(); //check if nothing happend EXPECT_EQ(emitter.data.particles[0].active, false); emitter.data.emission_rate = 1; @@ -103,24 +101,30 @@ TEST_F(ParticlesTest, spawnParticle) { particle_system.update(); EXPECT_EQ(emitter.data.particles[3].active, true); - for (auto& particle : emitter.data.particles) { - // Check velocity range - EXPECT_GE(particle.velocity.x, emitter.data.min_speed); // Speed should be greater than or equal to min_speed - EXPECT_LE(particle.velocity.x, emitter.data.max_speed); // Speed should be less than or equal to max_speed - EXPECT_GE(particle.velocity.y, emitter.data.min_speed); // Speed should be greater than or equal to min_speed - EXPECT_LE(particle.velocity.y, emitter.data.max_speed); // Speed should be less than or equal to max_speed - - // Check angle range - EXPECT_GE(particle.angle, emitter.data.min_angle); // Angle should be greater than or equal to min_angle - EXPECT_LE(particle.angle, emitter.data.max_angle); // Angle should be less than or equal to max_angle - } - + for (auto & particle : emitter.data.particles) { + // Check velocity range + EXPECT_GE(particle.velocity.x, emitter.data.min_speed); + // Speed should be greater than or equal to min_speed + EXPECT_LE(particle.velocity.x, emitter.data.max_speed); + // Speed should be less than or equal to max_speed + EXPECT_GE(particle.velocity.y, emitter.data.min_speed); + // Speed should be greater than or equal to min_speed + EXPECT_LE(particle.velocity.y, emitter.data.max_speed); + // Speed should be less than or equal to max_speed + + // Check angle range + EXPECT_GE(particle.angle, emitter.data.min_angle); + // Angle should be greater than or equal to min_angle + EXPECT_LE(particle.angle, emitter.data.max_angle); + // Angle should be less than or equal to max_angle + } } TEST_F(ParticlesTest, moveParticleHorizontal) { Config::get_instance().physics.gravity = 1; ComponentManager & mgr = ComponentManager::get_instance(); - ParticleEmitter & emitter = mgr.get_components_by_id(0).front().get(); + ParticleEmitter & emitter + = mgr.get_components_by_id(0).front().get(); emitter.data.end_lifespan = 100; emitter.data.boundary.height = 100; emitter.data.boundary.width = 100; @@ -128,17 +132,17 @@ TEST_F(ParticlesTest, moveParticleHorizontal) { emitter.data.max_speed = 1; emitter.data.max_angle = 0; emitter.data.emission_rate = 1; - for (int a = 1; a < emitter.data.boundary.width/2; a++) { - particle_system.update(); - EXPECT_EQ(emitter.data.particles[0].position.x,a); + for (int a = 1; a < emitter.data.boundary.width / 2; a++) { + particle_system.update(); + EXPECT_EQ(emitter.data.particles[0].position.x, a); } } - TEST_F(ParticlesTest, moveParticleVertical) { Config::get_instance().physics.gravity = 1; ComponentManager & mgr = ComponentManager::get_instance(); - ParticleEmitter & emitter = mgr.get_components_by_id(0).front().get(); + ParticleEmitter & emitter + = mgr.get_components_by_id(0).front().get(); emitter.data.end_lifespan = 100; emitter.data.boundary.height = 100; emitter.data.boundary.width = 100; @@ -147,16 +151,17 @@ TEST_F(ParticlesTest, moveParticleVertical) { emitter.data.min_angle = 90; emitter.data.max_angle = 90; emitter.data.emission_rate = 1; - for (int a = 1; a < emitter.data.boundary.width/2; a++) { - particle_system.update(); - EXPECT_EQ(emitter.data.particles[0].position.y,a); + for (int a = 1; a < emitter.data.boundary.width / 2; a++) { + particle_system.update(); + EXPECT_EQ(emitter.data.particles[0].position.y, a); } } TEST_F(ParticlesTest, boundaryParticleReset) { Config::get_instance().physics.gravity = 1; ComponentManager & mgr = ComponentManager::get_instance(); - ParticleEmitter & emitter = mgr.get_components_by_id(0).front().get(); + ParticleEmitter & emitter + = mgr.get_components_by_id(0).front().get(); emitter.data.end_lifespan = 100; emitter.data.boundary.height = 10; emitter.data.boundary.width = 10; @@ -166,16 +171,17 @@ TEST_F(ParticlesTest, boundaryParticleReset) { emitter.data.min_angle = 90; emitter.data.max_angle = 90; emitter.data.emission_rate = 1; - for (int a = 0; a < emitter.data.boundary.width/2+1; a++) { - particle_system.update(); + for (int a = 0; a < emitter.data.boundary.width / 2 + 1; a++) { + particle_system.update(); } - EXPECT_EQ(emitter.data.particles[0].active,false); + EXPECT_EQ(emitter.data.particles[0].active, false); } TEST_F(ParticlesTest, boundaryParticleStop) { Config::get_instance().physics.gravity = 1; ComponentManager & mgr = ComponentManager::get_instance(); - ParticleEmitter & emitter = mgr.get_components_by_id(0).front().get(); + ParticleEmitter & emitter + = mgr.get_components_by_id(0).front().get(); emitter.data.end_lifespan = 100; emitter.data.boundary.height = 10; emitter.data.boundary.width = 10; @@ -185,13 +191,16 @@ TEST_F(ParticlesTest, boundaryParticleStop) { emitter.data.min_angle = 90; emitter.data.max_angle = 90; emitter.data.emission_rate = 1; - for (int a = 0; a < emitter.data.boundary.width/2+1; a++) { - particle_system.update(); + for (int a = 0; a < emitter.data.boundary.width / 2 + 1; a++) { + particle_system.update(); } const double TOLERANCE = 0.01; EXPECT_NEAR(emitter.data.particles[0].velocity.x, 0, TOLERANCE); EXPECT_NEAR(emitter.data.particles[0].velocity.y, 0, TOLERANCE); - if(emitter.data.particles[0].velocity.x != 0) EXPECT_NEAR(std::abs(emitter.data.particles[0].position.x), emitter.data.boundary.height / 2, TOLERANCE); - if(emitter.data.particles[0].velocity.y != 0) EXPECT_NEAR(std::abs(emitter.data.particles[0].position.y), emitter.data.boundary.width / 2, TOLERANCE); + if (emitter.data.particles[0].velocity.x != 0) + EXPECT_NEAR(std::abs(emitter.data.particles[0].position.x), + emitter.data.boundary.height / 2, TOLERANCE); + if (emitter.data.particles[0].velocity.y != 0) + EXPECT_NEAR(std::abs(emitter.data.particles[0].position.y), + emitter.data.boundary.width / 2, TOLERANCE); } - -- cgit v1.2.3 From 44a04278496008a89ffa7044bc52c7cdb9f4d425 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 09:11:19 +0100 Subject: added more doxygen comments --- src/crepe/api/LoopTimer.cpp | 7 +++- src/crepe/api/LoopTimer.h | 80 ++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 77 insertions(+), 10 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index 98ce08d..aaba8b3 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -1,10 +1,14 @@ #include "../facade/SDLContext.h" +#include "../util/log.h" #include "LoopTimer.h" using namespace crepe; -LoopTimer::LoopTimer() {} + +LoopTimer::LoopTimer() { + dbg_trace(); +} LoopTimer & LoopTimer::get_instance() { static LoopTimer instance; @@ -55,4 +59,5 @@ void LoopTimer::enforce_frame_rate() { SDLContext::get_instance().delay(delay_time); } } + double LoopTimer::get_lag() const { return elapsed_time - elapsed_fixed_time; } diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index 5b7d3f2..e1cfc35 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -3,6 +3,7 @@ #include namespace crepe{ + class LoopTimer { public: /** @@ -59,23 +60,84 @@ void set_game_scale(double game_scale); private: friend class LoopManager; + +/** + * \brief Start the loop timer. + * + * Initializes the timer to begin tracking frame times. + */ void start(); + +/** + * \brief Enforce the frame rate limit. + * + * Ensures that the game loop does not exceed the target FPS by delaying + * frame updates as necessary. + */ void enforce_frame_rate(); + +/** + * \brief Get the fixed delta time for consistent updates. + * + * Fixed delta time is used for operations that require uniform time steps, + * such as physics calculations. + * + * \return Fixed delta time in seconds. + */ double get_fixed_delta_time() const; + +/** + * \brief Get the accumulated lag in the game loop. + * + * Lag represents the difference between the target frame time and the + * actual frame time, useful for managing fixed update intervals. + * + * \return Accumulated lag in seconds. + */ double get_lag() const; + +/** + * \brief Construct a new LoopTimer object. + * + * Private constructor for singleton pattern to restrict instantiation + * outside the class. + */ LoopTimer(); + +/** + * \brief Update the timer to the current frame. + * + * Calculates and updates the delta time for the current frame and adds it to + * the cumulative game time. + */ void update(); + +/** + * \brief Advance the game loop by a fixed update interval. + * + * This method progresses the game state by a consistent, fixed time step, + * allowing for stable updates independent of frame rate fluctuations. + */ void advance_fixed_update(); private: -int fps = 50; ///< Current frames per second -double game_scale = 1; ///< Current game scale -double maximum_delta_time = 0.25; ///< Maximum delta time to avoid large jumps -double delta_time = 0; ///< Delta time for the current frame -double frame_target_time = 1.0 / fps; ///< Target time per frame in seconds -double fixed_delta_time = 0.02; ///< Fixed delta time for fixed updates -double elapsed_time = 0; ///< Total elapsed game time -double elapsed_fixed_time = 0; ///< Total elapsed time for fixed updates -uint64_t last_frame_time = 0; ///< Time of the last frame +//! Current frames per second +int fps = 50; +///< Current game scale +double game_scale = 1; +//! Maximum delta time to avoid large jumps +double maximum_delta_time = 0.25; +//! Delta time for the current frame +double delta_time = 0; +//! Target time per frame in seconds +double frame_target_time = 1.0 / fps; +//! Fixed delta time for fixed updates +double fixed_delta_time = 0.02; +//! Total elapsed game time +double elapsed_time = 0; +//! Total elapsed time for fixed updates +double elapsed_fixed_time = 0; +//! Time of the last frame +uint64_t last_frame_time = 0; }; } // namespace crepe -- cgit v1.2.3 From 68fa604568e6dafac383a88d252c125f97431567 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 09:43:53 +0100 Subject: fixed spacing --- src/crepe/api/LoopManager.h | 106 +++++++++--------- src/crepe/api/LoopTimer.h | 264 ++++++++++++++++++++++---------------------- 2 files changed, 185 insertions(+), 185 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h index 8899bfd..af60d44 100644 --- a/src/crepe/api/LoopManager.h +++ b/src/crepe/api/LoopManager.h @@ -3,64 +3,64 @@ namespace crepe { class LoopManager { - public: - void start(); +public: + void start(); - private: - /** - * \brief Setup function for one-time initialization. - * - * This function initializes necessary components for the game. - */ - void setup(); - /** - * \brief Main game loop function. - * - * This function runs the main loop, handling game updates and rendering. - */ - void loop(); +private: + /** + * \brief Setup function for one-time initialization. + * + * This function initializes necessary components for the game. + */ + void setup(); + /** + * \brief Main game loop function. + * + * This function runs the main loop, handling game updates and rendering. + */ + void loop(); - /** - * \brief Function for handling input-related system calls. - * - * Processes user inputs from keyboard and mouse. - */ - void process_input(); + /** + * \brief Function for handling input-related system calls. + * + * Processes user inputs from keyboard and mouse. + */ + void process_input(); - /** - * \brief Per-frame update. - * - * Updates the game state based on the elapsed time since the last frame. - */ - void update(); + /** + * \brief Per-frame update. + * + * Updates the game state based on the elapsed time since the last frame. + */ + void update(); - /** - * \brief Late update which is called after update(). - * - * This function can be used for final adjustments before rendering. - */ - void late_update(); + /** + * \brief Late update which is called after update(). + * + * This function can be used for final adjustments before rendering. + */ + void late_update(); - /** - * \brief Fixed update executed at a fixed rate. - * - * This function updates physics and game logic based on LoopTimer's fixed_delta_time. - */ - void fixed_update(); - /** - * \brief Set game running variable - * - * \param running running (false = game shutdown, true = game running) - */ - void set_running(bool running); - /** - * \brief Function for executing render-related systems. - * - * Renders the current state of the game to the screen. - */ - void render(); + /** + * \brief Fixed update executed at a fixed rate. + * + * This function updates physics and game logic based on LoopTimer's fixed_delta_time. + */ + void fixed_update(); + /** + * \brief Set game running variable + * + * \param running running (false = game shutdown, true = game running) + */ + void set_running(bool running); + /** + * \brief Function for executing render-related systems. + * + * Renders the current state of the game to the screen. + */ + void render(); - bool game_running = false; - }; + bool game_running = false; +}; } // namespace crepe diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index e1cfc35..0089b24 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -3,141 +3,141 @@ #include namespace crepe{ - + class LoopTimer { public: -/** - * \brief Get the singleton instance of LoopTimer. - * - * \return A reference to the LoopTimer instance. - */ -static LoopTimer& get_instance(); - -/** - * \brief Get the current delta time for the current frame. - * - * \return Delta time in seconds since the last frame. - */ -double get_delta_time() const; - -/** - * \brief Get the current game time. - * - * \note The current game time may vary from the real-world elapsed time. - * It is the cumulative sum of each frame's delta time. - * - * \return Elapsed game time in milliseconds. - */ -int get_current_time() const; - -/** - * \brief Set the target frames per second (FPS). - * - * \param fps The number of frames that should be rendered per second. - */ -void set_fps(int fps); - -/** - * \brief Get the current frames per second (FPS). - * - * \return Current FPS. - */ -int get_fps() const; - -/** - * \brief Get the current game scale. - * - * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. - */ -double get_game_scale() const; - -/** - * \brief Set the game scale. - * - * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). - */ -void set_game_scale(double game_scale); - -private: -friend class LoopManager; - -/** - * \brief Start the loop timer. - * - * Initializes the timer to begin tracking frame times. - */ -void start(); - -/** - * \brief Enforce the frame rate limit. - * - * Ensures that the game loop does not exceed the target FPS by delaying - * frame updates as necessary. - */ -void enforce_frame_rate(); - -/** - * \brief Get the fixed delta time for consistent updates. - * - * Fixed delta time is used for operations that require uniform time steps, - * such as physics calculations. - * - * \return Fixed delta time in seconds. - */ -double get_fixed_delta_time() const; - -/** - * \brief Get the accumulated lag in the game loop. - * - * Lag represents the difference between the target frame time and the - * actual frame time, useful for managing fixed update intervals. - * - * \return Accumulated lag in seconds. - */ -double get_lag() const; - -/** - * \brief Construct a new LoopTimer object. - * - * Private constructor for singleton pattern to restrict instantiation - * outside the class. - */ -LoopTimer(); - -/** - * \brief Update the timer to the current frame. - * - * Calculates and updates the delta time for the current frame and adds it to - * the cumulative game time. - */ -void update(); - -/** - * \brief Advance the game loop by a fixed update interval. - * - * This method progresses the game state by a consistent, fixed time step, - * allowing for stable updates independent of frame rate fluctuations. - */ -void advance_fixed_update(); + /** + * \brief Get the singleton instance of LoopTimer. + * + * \return A reference to the LoopTimer instance. + */ + static LoopTimer& get_instance(); + + /** + * \brief Get the current delta time for the current frame. + * + * \return Delta time in seconds since the last frame. + */ + double get_delta_time() const; + + /** + * \brief Get the current game time. + * + * \note The current game time may vary from the real-world elapsed time. + * It is the cumulative sum of each frame's delta time. + * + * \return Elapsed game time in milliseconds. + */ + int get_current_time() const; + + /** + * \brief Set the target frames per second (FPS). + * + * \param fps The number of frames that should be rendered per second. + */ + void set_fps(int fps); + + /** + * \brief Get the current frames per second (FPS). + * + * \return Current FPS. + */ + int get_fps() const; + + /** + * \brief Get the current game scale. + * + * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. + */ + double get_game_scale() const; + + /** + * \brief Set the game scale. + * + * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). + */ + void set_game_scale(double game_scale); + + private: + friend class LoopManager; + + /** + * \brief Start the loop timer. + * + * Initializes the timer to begin tracking frame times. + */ + void start(); + + /** + * \brief Enforce the frame rate limit. + * + * Ensures that the game loop does not exceed the target FPS by delaying + * frame updates as necessary. + */ + void enforce_frame_rate(); + + /** + * \brief Get the fixed delta time for consistent updates. + * + * Fixed delta time is used for operations that require uniform time steps, + * such as physics calculations. + * + * \return Fixed delta time in seconds. + */ + double get_fixed_delta_time() const; + + /** + * \brief Get the accumulated lag in the game loop. + * + * Lag represents the difference between the target frame time and the + * actual frame time, useful for managing fixed update intervals. + * + * \return Accumulated lag in seconds. + */ + double get_lag() const; + + /** + * \brief Construct a new LoopTimer object. + * + * Private constructor for singleton pattern to restrict instantiation + * outside the class. + */ + LoopTimer(); + + /** + * \brief Update the timer to the current frame. + * + * Calculates and updates the delta time for the current frame and adds it to + * the cumulative game time. + */ + void update(); + + /** + * \brief Advance the game loop by a fixed update interval. + * + * This method progresses the game state by a consistent, fixed time step, + * allowing for stable updates independent of frame rate fluctuations. + */ + void advance_fixed_update(); private: -//! Current frames per second -int fps = 50; -///< Current game scale -double game_scale = 1; -//! Maximum delta time to avoid large jumps -double maximum_delta_time = 0.25; -//! Delta time for the current frame -double delta_time = 0; -//! Target time per frame in seconds -double frame_target_time = 1.0 / fps; -//! Fixed delta time for fixed updates -double fixed_delta_time = 0.02; -//! Total elapsed game time -double elapsed_time = 0; -//! Total elapsed time for fixed updates -double elapsed_fixed_time = 0; -//! Time of the last frame -uint64_t last_frame_time = 0; + //! Current frames per second + int fps = 50; + ///< Current game scale + double game_scale = 1; + //! Maximum delta time to avoid large jumps + double maximum_delta_time = 0.25; + //! Delta time for the current frame + double delta_time = 0; + //! Target time per frame in seconds + double frame_target_time = 1.0 / fps; + //! Fixed delta time for fixed updates + double fixed_delta_time = 0.02; + //! Total elapsed game time + double elapsed_time = 0; + //! Total elapsed time for fixed updates + double elapsed_fixed_time = 0; + //! Time of the last frame + uint64_t last_frame_time = 0; }; } // namespace crepe -- cgit v1.2.3 From 30c1eeeb9f1ca5a643a30edb4e7010f8a60bdd30 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 18:09:39 +0100 Subject: code cleanup changes --- src/crepe/api/LoopManager.cpp | 19 +++++++++++----- src/crepe/api/LoopManager.h | 15 +++++++++++- src/crepe/api/LoopTimer.cpp | 53 ++++++++++++++++++++++++------------------- src/crepe/api/LoopTimer.h | 2 +- 4 files changed, 58 insertions(+), 31 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index 5c79920..abf1f7e 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -7,7 +7,14 @@ #include "LoopTimer.h" namespace crepe { - +LoopManager::LoopManager(const RenderSystem& renderSystem, const SDLContext& sdlContext, + const LoopTimer& loopTimer, const ScriptSystem& scriptSystem, + const SoundSystem& soundSystem, const ParticleSystem& particleSystem, + const PhysicsSystem& physicsSystem, const AnimatorSystem& animatorSystem, + const CollisionSystem& collisionSystem) { + // Initialize systems if needed + // Example: this->renderSystem = renderSystem; +} void LoopManager::process_input() { SDLContext::get_instance().handle_events(this->game_running); } @@ -28,13 +35,13 @@ void LoopManager::loop() { timer.update(); while (timer.get_lag() >= timer.get_fixed_delta_time()) { - process_input(); - fixed_update(); + this->process_input(); + this->fixed_update(); timer.advance_fixed_update(); } - update(); - render(); + this->update(); + this->render(); timer.enforce_frame_rate(); } @@ -48,7 +55,7 @@ void LoopManager::setup() { } void LoopManager::render() { - if (game_running) { + if (this->game_running) { RenderSystem::get_instance().update(); } } diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h index af60d44..79abae6 100644 --- a/src/crepe/api/LoopManager.h +++ b/src/crepe/api/LoopManager.h @@ -1,11 +1,24 @@ #pragma once + namespace crepe { +class RenderSystem; +class SDLContext; +class LoopTimer; +class ScriptSystem; +class SoundSystem; +class ParticleSystem; +class PhysicsSystem; +class AnimatorSystem; +class CollisionSystem; + class LoopManager { public: void start(); - + LoopManager(const RenderSystem&, const SDLContext&, const LoopTimer&, const ScriptSystem&, + const SoundSystem&, const ParticleSystem&, const PhysicsSystem&, const AnimatorSystem&, + const CollisionSystem&); private: /** * \brief Setup function for one-time initialization. diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index aaba8b3..f4be510 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -4,6 +4,8 @@ #include "LoopTimer.h" +#define MS_PER_SECOND 1000.0 + using namespace crepe; LoopTimer::LoopTimer() { @@ -16,48 +18,53 @@ LoopTimer & LoopTimer::get_instance() { } void LoopTimer::start() { - last_frame_time = SDLContext::get_instance().get_ticks(); - elapsed_time = 0; - elapsed_fixed_time = 0; - delta_time = 0; + this->last_frame_time = SDLContext::get_instance().get_ticks(); + this->elapsed_time = 0; + this->elapsed_fixed_time = 0; + this->delta_time = 0; } void LoopTimer::update() { uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - delta_time = (current_frame_time - last_frame_time) / 1000.0; + this->delta_time = (current_frame_time - last_frame_time) / MS_PER_SECOND; - if (delta_time > maximum_delta_time) { - delta_time = maximum_delta_time; + if (this->delta_time > this->maximum_delta_time) { + this->delta_time = this->maximum_delta_time; } - delta_time = game_scale; - elapsed_time += delta_time; - last_frame_time = current_frame_time; + this->delta_time = this->game_scale; + this->elapsed_time += this->delta_time; + this->last_frame_time = current_frame_time; } -double LoopTimer::get_delta_time() const { return delta_time; } -int LoopTimer::get_current_time() const { return elapsed_time; } +double LoopTimer::get_delta_time() const { return this->delta_time; } + +int LoopTimer::get_current_time() const { return this->elapsed_time; } -void LoopTimer::advance_fixed_update() { elapsed_fixed_time += fixed_delta_time; } +void LoopTimer::advance_fixed_update() { this->elapsed_fixed_time += this->fixed_delta_time; } -double LoopTimer::get_fixed_delta_time() const { return fixed_delta_time; } +double LoopTimer::get_fixed_delta_time() const { return this->fixed_delta_time; } void LoopTimer::set_fps(int fps) { this->fps = fps; - frame_target_time = 1.0 / fps; + this->frame_target_time = 1.0 / this->fps; } -int LoopTimer::get_fps() const { return fps; } -void LoopTimer::set_game_scale(double value) { game_scale = value; }; -double LoopTimer::get_game_scale() const { return game_scale; } +int LoopTimer::get_fps() const { return this->fps; } + +void LoopTimer::set_game_scale(double value) { this->game_scale = value; }; + +double LoopTimer::get_game_scale() const { return this->game_scale; } + void LoopTimer::enforce_frame_rate() { uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - double frame_duration = (current_frame_time - last_frame_time) / 1000.0; + double frame_duration = (current_frame_time - this->last_frame_time) / MS_PER_SECOND; - if (frame_duration < frame_target_time) { - uint32_t delay_time - = (uint32_t) ((frame_target_time - frame_duration) / 1000.0); + if (frame_duration < this->frame_target_time) { + uint32_t delay_time = static_cast((this->frame_target_time - frame_duration) * MS_PER_SECOND); SDLContext::get_instance().delay(delay_time); } + + this->last_frame_time = current_frame_time; } -double LoopTimer::get_lag() const { return elapsed_time - elapsed_fixed_time; } +double LoopTimer::get_lag() const { return this->elapsed_time - this->elapsed_fixed_time; } diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index 0089b24..4ce0053 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -122,7 +122,7 @@ public: private: //! Current frames per second int fps = 50; - ///< Current game scale + //! Current game scale double game_scale = 1; //! Maximum delta time to avoid large jumps double maximum_delta_time = 0.25; -- cgit v1.2.3 From 31a6448f8c97934dd9974758d9b5049650040bc7 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 18:16:28 +0100 Subject: changed seconds into ms --- lib/sdl2 | 2 +- lib/sdl_image | 2 +- lib/sdl_ttf | 2 +- src/crepe/api/LoopManager.cpp | 3 +- src/crepe/api/LoopTimer.cpp | 27 ++--- src/crepe/api/LoopTimer.h | 265 +++++++++++++++++++++--------------------- 6 files changed, 146 insertions(+), 155 deletions(-) (limited to 'src/crepe/api') diff --git a/lib/sdl2 b/lib/sdl2 index 9519b99..c98c4fb 160000 --- a/lib/sdl2 +++ b/lib/sdl2 @@ -1 +1 @@ -Subproject commit 9519b9916cd29a14587af0507292f2bd31dd5752 +Subproject commit c98c4fbff6d8f3016a3ce6685bf8f43433c3efcc diff --git a/lib/sdl_image b/lib/sdl_image index abcf63a..5656019 160000 --- a/lib/sdl_image +++ b/lib/sdl_image @@ -1 +1 @@ -Subproject commit abcf63aa71b4e3ac32120fa9870a6500ddcdcc89 +Subproject commit 56560190a6c5b5740e5afdce747e2a2bfbf16db1 diff --git a/lib/sdl_ttf b/lib/sdl_ttf index 4a318f8..a3d0895 160000 --- a/lib/sdl_ttf +++ b/lib/sdl_ttf @@ -1 +1 @@ -Subproject commit 4a318f8dfaa1bb6f10e0c5e54052e25d3c7f3440 +Subproject commit a3d0895c1b60c41ff9e85d9203ddd7485c014dae diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index abf1f7e..d4345d0 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -6,7 +6,7 @@ #include "LoopManager.h" #include "LoopTimer.h" -namespace crepe { +using namespace crepe; LoopManager::LoopManager(const RenderSystem& renderSystem, const SDLContext& sdlContext, const LoopTimer& loopTimer, const ScriptSystem& scriptSystem, const SoundSystem& soundSystem, const ParticleSystem& particleSystem, @@ -64,4 +64,3 @@ void LoopManager::update() { LoopTimer & timer = LoopTimer::get_instance(); } -} // namespace crepe diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index f4be510..dd4d7e5 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -1,18 +1,14 @@ - #include "../facade/SDLContext.h" #include "../util/log.h" - #include "LoopTimer.h" -#define MS_PER_SECOND 1000.0 - using namespace crepe; LoopTimer::LoopTimer() { - dbg_trace(); + dbg_trace(); } -LoopTimer & LoopTimer::get_instance() { +LoopTimer& LoopTimer::get_instance() { static LoopTimer instance; return instance; } @@ -26,41 +22,36 @@ void LoopTimer::start() { void LoopTimer::update() { uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - this->delta_time = (current_frame_time - last_frame_time) / MS_PER_SECOND; + this->delta_time = (current_frame_time - last_frame_time); if (this->delta_time > this->maximum_delta_time) { this->delta_time = this->maximum_delta_time; } - this->delta_time = this->game_scale; + this->delta_time *= this->game_scale; this->elapsed_time += this->delta_time; this->last_frame_time = current_frame_time; } double LoopTimer::get_delta_time() const { return this->delta_time; } - -int LoopTimer::get_current_time() const { return this->elapsed_time; } - +double LoopTimer::get_current_time() const { return this->elapsed_time; } void LoopTimer::advance_fixed_update() { this->elapsed_fixed_time += this->fixed_delta_time; } - double LoopTimer::get_fixed_delta_time() const { return this->fixed_delta_time; } void LoopTimer::set_fps(int fps) { this->fps = fps; - this->frame_target_time = 1.0 / this->fps; + this->frame_target_time = 1000.0 / this->fps; } int LoopTimer::get_fps() const { return this->fps; } - -void LoopTimer::set_game_scale(double value) { this->game_scale = value; }; - +void LoopTimer::set_game_scale(double value) { this->game_scale = value; } double LoopTimer::get_game_scale() const { return this->game_scale; } void LoopTimer::enforce_frame_rate() { uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - double frame_duration = (current_frame_time - this->last_frame_time) / MS_PER_SECOND; + double frame_duration = (current_frame_time - this->last_frame_time); if (frame_duration < this->frame_target_time) { - uint32_t delay_time = static_cast((this->frame_target_time - frame_duration) * MS_PER_SECOND); + uint32_t delay_time = static_cast(this->frame_target_time - frame_duration); SDLContext::get_instance().delay(delay_time); } diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index 4ce0053..5f9b6a7 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -2,142 +2,143 @@ #include -namespace crepe{ +namespace crepe { class LoopTimer { public: - /** - * \brief Get the singleton instance of LoopTimer. - * - * \return A reference to the LoopTimer instance. - */ - static LoopTimer& get_instance(); - - /** - * \brief Get the current delta time for the current frame. - * - * \return Delta time in seconds since the last frame. - */ - double get_delta_time() const; - - /** - * \brief Get the current game time. - * - * \note The current game time may vary from the real-world elapsed time. - * It is the cumulative sum of each frame's delta time. - * - * \return Elapsed game time in milliseconds. - */ - int get_current_time() const; - - /** - * \brief Set the target frames per second (FPS). - * - * \param fps The number of frames that should be rendered per second. - */ - void set_fps(int fps); - - /** - * \brief Get the current frames per second (FPS). - * - * \return Current FPS. - */ - int get_fps() const; - - /** - * \brief Get the current game scale. - * - * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. - */ - double get_game_scale() const; - - /** - * \brief Set the game scale. - * - * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). - */ - void set_game_scale(double game_scale); - - private: - friend class LoopManager; - - /** - * \brief Start the loop timer. - * - * Initializes the timer to begin tracking frame times. - */ - void start(); - - /** - * \brief Enforce the frame rate limit. - * - * Ensures that the game loop does not exceed the target FPS by delaying - * frame updates as necessary. - */ - void enforce_frame_rate(); - - /** - * \brief Get the fixed delta time for consistent updates. - * - * Fixed delta time is used for operations that require uniform time steps, - * such as physics calculations. - * - * \return Fixed delta time in seconds. - */ - double get_fixed_delta_time() const; - - /** - * \brief Get the accumulated lag in the game loop. - * - * Lag represents the difference between the target frame time and the - * actual frame time, useful for managing fixed update intervals. - * - * \return Accumulated lag in seconds. - */ - double get_lag() const; - - /** - * \brief Construct a new LoopTimer object. - * - * Private constructor for singleton pattern to restrict instantiation - * outside the class. - */ - LoopTimer(); - - /** - * \brief Update the timer to the current frame. - * - * Calculates and updates the delta time for the current frame and adds it to - * the cumulative game time. - */ - void update(); - - /** - * \brief Advance the game loop by a fixed update interval. - * - * This method progresses the game state by a consistent, fixed time step, - * allowing for stable updates independent of frame rate fluctuations. - */ - void advance_fixed_update(); + /** + * \brief Get the singleton instance of LoopTimer. + * + * \return A reference to the LoopTimer instance. + */ + static LoopTimer& get_instance(); + + /** + * \brief Get the current delta time for the current frame. + * + * \return Delta time in milliseconds since the last frame. + */ + double get_delta_time() const; + + /** + * \brief Get the current game time. + * + * \note The current game time may vary from real-world elapsed time. + * It is the cumulative sum of each frame's delta time. + * + * \return Elapsed game time in milliseconds. + */ + double get_current_time() const; + + /** + * \brief Set the target frames per second (FPS). + * + * \param fps The desired frames rendered per second. + */ + void set_fps(int fps); + + /** + * \brief Get the current frames per second (FPS). + * + * \return Current FPS. + */ + int get_fps() const; + + /** + * \brief Get the current game scale. + * + * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. + */ + double get_game_scale() const; + + /** + * \brief Set the game scale. + * + * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). + */ + void set_game_scale(double game_scale); + +private: + friend class LoopManager; + + /** + * \brief Start the loop timer. + * + * Initializes the timer to begin tracking frame times. + */ + void start(); + + /** + * \brief Enforce the frame rate limit. + * + * Ensures that the game loop does not exceed the target FPS by delaying + * frame updates as necessary. + */ + void enforce_frame_rate(); + + /** + * \brief Get the fixed delta time for consistent updates. + * + * Fixed delta time is used for operations that require uniform time steps, + * such as physics calculations. + * + * \return Fixed delta time in milliseconds. + */ + double get_fixed_delta_time() const; + + /** + * \brief Get the accumulated lag in the game loop. + * + * Lag represents the difference between the target frame time and the + * actual frame time, useful for managing fixed update intervals. + * + * \return Accumulated lag in milliseconds. + */ + double get_lag() const; + + /** + * \brief Construct a new LoopTimer object. + * + * Private constructor for singleton pattern to restrict instantiation + * outside the class. + */ + LoopTimer(); + + /** + * \brief Update the timer to the current frame. + * + * Calculates and updates the delta time for the current frame and adds it to + * the cumulative game time. + */ + void update(); + + /** + * \brief Advance the game loop by a fixed update interval. + * + * This method progresses the game state by a consistent, fixed time step, + * allowing for stable updates independent of frame rate fluctuations. + */ + void advance_fixed_update(); + private: - //! Current frames per second - int fps = 50; - //! Current game scale - double game_scale = 1; - //! Maximum delta time to avoid large jumps - double maximum_delta_time = 0.25; - //! Delta time for the current frame - double delta_time = 0; - //! Target time per frame in seconds - double frame_target_time = 1.0 / fps; - //! Fixed delta time for fixed updates - double fixed_delta_time = 0.02; - //! Total elapsed game time - double elapsed_time = 0; - //! Total elapsed time for fixed updates - double elapsed_fixed_time = 0; - //! Time of the last frame - uint64_t last_frame_time = 0; + //! Current frames per second + int fps = 50; + //! Current game scale + double game_scale = 1; + //! Maximum delta time in milliseconds to avoid large jumps + double maximum_delta_time = 250; + //! Delta time for the current frame in milliseconds + double delta_time = 0; + //! Target time per frame in milliseconds + double frame_target_time = 1000.0 / fps; + //! Fixed delta time for fixed updates in milliseconds + double fixed_delta_time = 20; + //! Total elapsed game time in milliseconds + double elapsed_time = 0; + //! Total elapsed time for fixed updates in milliseconds + double elapsed_fixed_time = 0; + //! Time of the last frame in milliseconds + uint64_t last_frame_time = 0; }; } // namespace crepe -- cgit v1.2.3 From e7dc31dad155b7b623374d3bb0ffbb8a8f579d2a Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 18:18:54 +0100 Subject: ran make format --- mwe/events/include/event.h | 2 +- src/crepe/api/LoopManager.cpp | 72 +++++++++++++++---------------- src/crepe/api/LoopManager.h | 9 ++-- src/crepe/api/LoopTimer.cpp | 68 +++++++++++++++-------------- src/crepe/api/LoopTimer.h | 94 ++++++++++++++++++++--------------------- src/crepe/facade/SDLContext.cpp | 4 +- src/crepe/facade/SDLContext.h | 1 + src/example/gameloop.cpp | 2 +- src/makefile | 6 +-- 9 files changed, 128 insertions(+), 130 deletions(-) (limited to 'src/crepe/api') diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h index 16c75bf..3e70201 100644 --- a/mwe/events/include/event.h +++ b/mwe/events/include/event.h @@ -152,7 +152,7 @@ private: }; class ShutDownEvent : public Event { public: - ShutDownEvent() : Event("ShutDownEvent") {}; + ShutDownEvent() : Event("ShutDownEvent"){}; REGISTER_EVENT_TYPE(ShutDownEvent) diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index d4345d0..b4382a6 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -1,66 +1,62 @@ +#include "../facade/SDLContext.h" #include "../system/RenderSystem.h" #include "../system/ScriptSystem.h" -#include "../facade/SDLContext.h" #include "LoopManager.h" #include "LoopTimer.h" using namespace crepe; -LoopManager::LoopManager(const RenderSystem& renderSystem, const SDLContext& sdlContext, - const LoopTimer& loopTimer, const ScriptSystem& scriptSystem, - const SoundSystem& soundSystem, const ParticleSystem& particleSystem, - const PhysicsSystem& physicsSystem, const AnimatorSystem& animatorSystem, - const CollisionSystem& collisionSystem) { - // Initialize systems if needed - // Example: this->renderSystem = renderSystem; +LoopManager::LoopManager( + const RenderSystem & renderSystem, const SDLContext & sdlContext, + const LoopTimer & loopTimer, const ScriptSystem & scriptSystem, + const SoundSystem & soundSystem, const ParticleSystem & particleSystem, + const PhysicsSystem & physicsSystem, const AnimatorSystem & animatorSystem, + const CollisionSystem & collisionSystem) { + // Initialize systems if needed + // Example: this->renderSystem = renderSystem; } void LoopManager::process_input() { - SDLContext::get_instance().handle_events(this->game_running); + SDLContext::get_instance().handle_events(this->game_running); } -void LoopManager::start(){ - this->setup(); - this->loop(); +void LoopManager::start() { + this->setup(); + this->loop(); } void LoopManager::set_running(bool running) { this->game_running = running; } -void LoopManager::fixed_update() { -} +void LoopManager::fixed_update() {} void LoopManager::loop() { - LoopTimer & timer = LoopTimer::get_instance(); - timer.start(); + LoopTimer & timer = LoopTimer::get_instance(); + timer.start(); - while (game_running) { - timer.update(); + while (game_running) { + timer.update(); - while (timer.get_lag() >= timer.get_fixed_delta_time()) { - this->process_input(); - this->fixed_update(); - timer.advance_fixed_update(); - } + while (timer.get_lag() >= timer.get_fixed_delta_time()) { + this->process_input(); + this->fixed_update(); + timer.advance_fixed_update(); + } - this->update(); - this->render(); + this->update(); + this->render(); - timer.enforce_frame_rate(); - } + timer.enforce_frame_rate(); + } } - void LoopManager::setup() { - this->game_running = true; - LoopTimer::get_instance().start(); - LoopTimer::get_instance().set_fps(60); + this->game_running = true; + LoopTimer::get_instance().start(); + LoopTimer::get_instance().set_fps(60); } void LoopManager::render() { - if (this->game_running) { - RenderSystem::get_instance().update(); - } -} - -void LoopManager::update() { - LoopTimer & timer = LoopTimer::get_instance(); + if (this->game_running) { + RenderSystem::get_instance().update(); + } } +void LoopManager::update() { LoopTimer & timer = LoopTimer::get_instance(); } diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h index 79abae6..5d8c91b 100644 --- a/src/crepe/api/LoopManager.h +++ b/src/crepe/api/LoopManager.h @@ -1,6 +1,5 @@ #pragma once - namespace crepe { class RenderSystem; @@ -16,9 +15,11 @@ class CollisionSystem; class LoopManager { public: void start(); - LoopManager(const RenderSystem&, const SDLContext&, const LoopTimer&, const ScriptSystem&, - const SoundSystem&, const ParticleSystem&, const PhysicsSystem&, const AnimatorSystem&, - const CollisionSystem&); + LoopManager(const RenderSystem &, const SDLContext &, const LoopTimer &, + const ScriptSystem &, const SoundSystem &, + const ParticleSystem &, const PhysicsSystem &, + const AnimatorSystem &, const CollisionSystem &); + private: /** * \brief Setup function for one-time initialization. diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index dd4d7e5..f68d75a 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -1,45 +1,48 @@ +#include "LoopTimer.h" #include "../facade/SDLContext.h" #include "../util/log.h" -#include "LoopTimer.h" using namespace crepe; -LoopTimer::LoopTimer() { - dbg_trace(); -} +LoopTimer::LoopTimer() { dbg_trace(); } -LoopTimer& LoopTimer::get_instance() { - static LoopTimer instance; - return instance; +LoopTimer & LoopTimer::get_instance() { + static LoopTimer instance; + return instance; } void LoopTimer::start() { - this->last_frame_time = SDLContext::get_instance().get_ticks(); - this->elapsed_time = 0; - this->elapsed_fixed_time = 0; - this->delta_time = 0; + this->last_frame_time = SDLContext::get_instance().get_ticks(); + this->elapsed_time = 0; + this->elapsed_fixed_time = 0; + this->delta_time = 0; } void LoopTimer::update() { - uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - this->delta_time = (current_frame_time - last_frame_time); + uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); + this->delta_time = (current_frame_time - last_frame_time); - if (this->delta_time > this->maximum_delta_time) { - this->delta_time = this->maximum_delta_time; - } - this->delta_time *= this->game_scale; - this->elapsed_time += this->delta_time; - this->last_frame_time = current_frame_time; + if (this->delta_time > this->maximum_delta_time) { + this->delta_time = this->maximum_delta_time; + } + this->delta_time *= this->game_scale; + this->elapsed_time += this->delta_time; + this->last_frame_time = current_frame_time; } double LoopTimer::get_delta_time() const { return this->delta_time; } double LoopTimer::get_current_time() const { return this->elapsed_time; } -void LoopTimer::advance_fixed_update() { this->elapsed_fixed_time += this->fixed_delta_time; } -double LoopTimer::get_fixed_delta_time() const { return this->fixed_delta_time; } +void LoopTimer::advance_fixed_update() { + this->elapsed_fixed_time += this->fixed_delta_time; +} +double LoopTimer::get_fixed_delta_time() const { + return this->fixed_delta_time; +} void LoopTimer::set_fps(int fps) { - this->fps = fps; - this->frame_target_time = 1000.0 / this->fps; + this->fps = fps; + //! use fps to calculate frame_target_time in ms + this->frame_target_time = 1000.0 / this->fps; } int LoopTimer::get_fps() const { return this->fps; } @@ -47,15 +50,18 @@ void LoopTimer::set_game_scale(double value) { this->game_scale = value; } double LoopTimer::get_game_scale() const { return this->game_scale; } void LoopTimer::enforce_frame_rate() { - uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - double frame_duration = (current_frame_time - this->last_frame_time); + uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); + double frame_duration = (current_frame_time - this->last_frame_time); - if (frame_duration < this->frame_target_time) { - uint32_t delay_time = static_cast(this->frame_target_time - frame_duration); - SDLContext::get_instance().delay(delay_time); - } + if (frame_duration < this->frame_target_time) { + uint32_t delay_time + = static_cast(this->frame_target_time - frame_duration); + SDLContext::get_instance().delay(delay_time); + } - this->last_frame_time = current_frame_time; + this->last_frame_time = current_frame_time; } -double LoopTimer::get_lag() const { return this->elapsed_time - this->elapsed_fixed_time; } +double LoopTimer::get_lag() const { + return this->elapsed_time - this->elapsed_fixed_time; +} diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index 5f9b6a7..5309d2f 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -6,21 +6,21 @@ namespace crepe { class LoopTimer { public: - /** + /** * \brief Get the singleton instance of LoopTimer. * * \return A reference to the LoopTimer instance. */ - static LoopTimer& get_instance(); + static LoopTimer & get_instance(); - /** + /** * \brief Get the current delta time for the current frame. * * \return Delta time in milliseconds since the last frame. */ - double get_delta_time() const; + double get_delta_time() const; - /** + /** * \brief Get the current game time. * * \note The current game time may vary from real-world elapsed time. @@ -28,55 +28,55 @@ public: * * \return Elapsed game time in milliseconds. */ - double get_current_time() const; + double get_current_time() const; - /** + /** * \brief Set the target frames per second (FPS). * * \param fps The desired frames rendered per second. */ - void set_fps(int fps); + void set_fps(int fps); - /** + /** * \brief Get the current frames per second (FPS). * * \return Current FPS. */ - int get_fps() const; + int get_fps() const; - /** + /** * \brief Get the current game scale. * * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. */ - double get_game_scale() const; + double get_game_scale() const; - /** + /** * \brief Set the game scale. * * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). */ - void set_game_scale(double game_scale); + void set_game_scale(double game_scale); private: - friend class LoopManager; + friend class LoopManager; - /** + /** * \brief Start the loop timer. * * Initializes the timer to begin tracking frame times. */ - void start(); + void start(); - /** + /** * \brief Enforce the frame rate limit. * * Ensures that the game loop does not exceed the target FPS by delaying * frame updates as necessary. */ - void enforce_frame_rate(); + void enforce_frame_rate(); - /** + /** * \brief Get the fixed delta time for consistent updates. * * Fixed delta time is used for operations that require uniform time steps, @@ -84,9 +84,9 @@ private: * * \return Fixed delta time in milliseconds. */ - double get_fixed_delta_time() const; + double get_fixed_delta_time() const; - /** + /** * \brief Get the accumulated lag in the game loop. * * Lag represents the difference between the target frame time and the @@ -94,51 +94,51 @@ private: * * \return Accumulated lag in milliseconds. */ - double get_lag() const; + double get_lag() const; - /** + /** * \brief Construct a new LoopTimer object. * * Private constructor for singleton pattern to restrict instantiation * outside the class. */ - LoopTimer(); + LoopTimer(); - /** + /** * \brief Update the timer to the current frame. * * Calculates and updates the delta time for the current frame and adds it to * the cumulative game time. */ - void update(); + void update(); - /** + /** * \brief Advance the game loop by a fixed update interval. * * This method progresses the game state by a consistent, fixed time step, * allowing for stable updates independent of frame rate fluctuations. */ - void advance_fixed_update(); + void advance_fixed_update(); private: - //! Current frames per second - int fps = 50; - //! Current game scale - double game_scale = 1; - //! Maximum delta time in milliseconds to avoid large jumps - double maximum_delta_time = 250; - //! Delta time for the current frame in milliseconds - double delta_time = 0; - //! Target time per frame in milliseconds - double frame_target_time = 1000.0 / fps; - //! Fixed delta time for fixed updates in milliseconds - double fixed_delta_time = 20; - //! Total elapsed game time in milliseconds - double elapsed_time = 0; - //! Total elapsed time for fixed updates in milliseconds - double elapsed_fixed_time = 0; - //! Time of the last frame in milliseconds - uint64_t last_frame_time = 0; + //! Current frames per second + int fps = 50; + //! Current game scale + double game_scale = 1; + //! Maximum delta time in milliseconds to avoid large jumps + double maximum_delta_time = 250; + //! Delta time for the current frame in milliseconds + double delta_time = 0; + //! Target time per frame in milliseconds + double frame_target_time = 1000.0 / fps; + //! Fixed delta time for fixed updates in milliseconds + double fixed_delta_time = 20; + //! Total elapsed game time in milliseconds + double elapsed_time = 0; + //! Total elapsed time for fixed updates in milliseconds + double elapsed_fixed_time = 0; + //! Time of the last frame in milliseconds + uint64_t last_frame_time = 0; }; } // namespace crepe diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 17ced0c..39d0d4d 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -191,6 +191,4 @@ int SDLContext::get_height(const Texture & ctx) const { SDL_QueryTexture(ctx.texture.get(), NULL, NULL, NULL, &h); return h; } -void SDLContext::delay(int ms) const{ - SDL_Delay(ms); -} +void SDLContext::delay(int ms) const { SDL_Delay(ms); } diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 6c57ef9..90147e0 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -74,6 +74,7 @@ private: * \param ms Duration of the delay in milliseconds. */ void delay(int ms) const; + private: /** * \brief Constructs an SDLContext instance. diff --git a/src/example/gameloop.cpp b/src/example/gameloop.cpp index 6cd0301..a676f20 100644 --- a/src/example/gameloop.cpp +++ b/src/example/gameloop.cpp @@ -1,6 +1,6 @@ #include "crepe/api/LoopManager.h" using namespace crepe; -int main(){ +int main() { LoopManager gameloop; gameloop.start(); return 1; diff --git a/src/makefile b/src/makefile index ce5a29f..a2c2961 100644 --- a/src/makefile +++ b/src/makefile @@ -94,11 +94,7 @@ LOEK += example/script.cpp LOEK += test/audio.cpp LOEK += test/dummy.cpp JARO += test/PhysicsTest.cpp -WOUTER += crepe/api/LoopManager.h -WOUTER += crepe/api/LoopManager.cpp -WOUTER += crepe/api/LoopTimer.h -WOUTER += crepe/api/LoopTimer.cpp -FMT := $(WOUTER) #<<< CHANGE THIS TO YOUR NAME FOR STEP 2 +FMT := $(JARO) #<<< CHANGE THIS TO YOUR NAME FOR STEP 2 format: FORCE clang-tidy -p build/compile_commands.json --fix-errors $(FMT) -- cgit v1.2.3 From ec7a4af3e1cc0ebfe2c6df21f15575a1b1abbd6c Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 18:20:10 +0100 Subject: fixed some headers --- src/crepe/api/LoopManager.cpp | 1 + src/crepe/api/LoopTimer.cpp | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index b4382a6..f477efb 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -7,6 +7,7 @@ #include "LoopTimer.h" using namespace crepe; + LoopManager::LoopManager( const RenderSystem & renderSystem, const SDLContext & sdlContext, const LoopTimer & loopTimer, const ScriptSystem & scriptSystem, diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index f68d75a..16d813f 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -1,7 +1,9 @@ -#include "LoopTimer.h" + #include "../facade/SDLContext.h" #include "../util/log.h" +#include "LoopTimer.h" + using namespace crepe; LoopTimer::LoopTimer() { dbg_trace(); } -- cgit v1.2.3 From 149b3b5dbc8b18a142bf35869e54ab05e8f26d54 Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 20:21:31 +0100 Subject: added chrono::duration --- src/crepe/api/CMakeLists.txt | 4 ++ src/crepe/api/LoopManager.cpp | 9 +--- src/crepe/api/LoopManager.h | 19 ++++++-- src/crepe/api/LoopTimer.cpp | 90 ++++++++++++++++++++++-------------- src/crepe/api/LoopTimer.h | 105 +++++++++++++++++++++--------------------- src/crepe/facade/SDLContext.h | 1 + 6 files changed, 128 insertions(+), 100 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt index 87cbb09..85696c4 100644 --- a/src/crepe/api/CMakeLists.txt +++ b/src/crepe/api/CMakeLists.txt @@ -18,6 +18,8 @@ target_sources(crepe PUBLIC Vector2.cpp Camera.cpp Animator.cpp + LoopManager.cpp + LoopTimer.cpp ) target_sources(crepe PUBLIC FILE_SET HEADERS FILES @@ -42,4 +44,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES SceneManager.hpp Camera.h Animator.h + LoopManager.h + LoopTimer.h ) diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index f477efb..ea63bf6 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -8,14 +8,7 @@ using namespace crepe; -LoopManager::LoopManager( - const RenderSystem & renderSystem, const SDLContext & sdlContext, - const LoopTimer & loopTimer, const ScriptSystem & scriptSystem, - const SoundSystem & soundSystem, const ParticleSystem & particleSystem, - const PhysicsSystem & physicsSystem, const AnimatorSystem & animatorSystem, - const CollisionSystem & collisionSystem) { - // Initialize systems if needed - // Example: this->renderSystem = renderSystem; +LoopManager::LoopManager() { } void LoopManager::process_input() { SDLContext::get_instance().handle_events(this->game_running); diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h index 5d8c91b..d4668b8 100644 --- a/src/crepe/api/LoopManager.h +++ b/src/crepe/api/LoopManager.h @@ -1,6 +1,6 @@ #pragma once -namespace crepe { +#include class RenderSystem; class SDLContext; @@ -11,14 +11,14 @@ class ParticleSystem; class PhysicsSystem; class AnimatorSystem; class CollisionSystem; +namespace crepe { + + class LoopManager { public: void start(); - LoopManager(const RenderSystem &, const SDLContext &, const LoopTimer &, - const ScriptSystem &, const SoundSystem &, - const ParticleSystem &, const PhysicsSystem &, - const AnimatorSystem &, const CollisionSystem &); + LoopManager(); private: /** @@ -75,6 +75,15 @@ private: void render(); bool game_running = false; + // For later if singletons are removed cant make them now because destructors are private. + // std::unique_ptr render_system; + // std::unique_ptr sdl_context; + // std::unique_ptr loop_timer; + // std::unique_ptr script_system; + // std::unique_ptr particle_system; + // std::unique_ptr physics_system; + // std::unique_ptr animator_system; + // std::unique_ptr collision_system; }; } // namespace crepe diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index 16d813f..039e35e 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -1,3 +1,4 @@ +#include #include "../facade/SDLContext.h" #include "../util/log.h" @@ -6,64 +7,83 @@ using namespace crepe; -LoopTimer::LoopTimer() { dbg_trace(); } +LoopTimer::LoopTimer() { + dbg_trace(); +} LoopTimer & LoopTimer::get_instance() { - static LoopTimer instance; - return instance; + static LoopTimer instance; + return instance; } void LoopTimer::start() { - this->last_frame_time = SDLContext::get_instance().get_ticks(); - this->elapsed_time = 0; - this->elapsed_fixed_time = 0; - this->delta_time = 0; + this->last_frame_time = std::chrono::steady_clock::now(); + this->elapsed_time = std::chrono::milliseconds(0); + this->elapsed_fixed_time = std::chrono::milliseconds(0); + this->delta_time = std::chrono::milliseconds(0); } void LoopTimer::update() { - uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - this->delta_time = (current_frame_time - last_frame_time); - - if (this->delta_time > this->maximum_delta_time) { - this->delta_time = this->maximum_delta_time; - } - this->delta_time *= this->game_scale; - this->elapsed_time += this->delta_time; - this->last_frame_time = current_frame_time; + auto current_frame_time = std::chrono::steady_clock::now(); + // Convert to duration in seconds for delta time + this->delta_time = std::chrono::duration_cast>(current_frame_time - last_frame_time); + + if (this->delta_time > this->maximum_delta_time) { + this->delta_time = this->maximum_delta_time; + } + + this->delta_time *= this->game_scale; + this->elapsed_time += this->delta_time; + this->last_frame_time = current_frame_time; +} + +double LoopTimer::get_delta_time() const { + return this->delta_time.count(); +} + +double LoopTimer::get_current_time() const { + return this->elapsed_time.count(); } -double LoopTimer::get_delta_time() const { return this->delta_time; } -double LoopTimer::get_current_time() const { return this->elapsed_time; } void LoopTimer::advance_fixed_update() { - this->elapsed_fixed_time += this->fixed_delta_time; + this->elapsed_fixed_time += this->fixed_delta_time; } + double LoopTimer::get_fixed_delta_time() const { - return this->fixed_delta_time; + return this->fixed_delta_time.count(); } void LoopTimer::set_fps(int fps) { - this->fps = fps; - //! use fps to calculate frame_target_time in ms - this->frame_target_time = 1000.0 / this->fps; + this->fps = fps; + // target time per frame in seconds + this->frame_target_time = std::chrono::seconds(1) / fps; +} + +int LoopTimer::get_fps() const { + return this->fps; } -int LoopTimer::get_fps() const { return this->fps; } -void LoopTimer::set_game_scale(double value) { this->game_scale = value; } -double LoopTimer::get_game_scale() const { return this->game_scale; } +void LoopTimer::set_game_scale(double value) { + this->game_scale = value; +} +double LoopTimer::get_game_scale() const { + return this->game_scale; +} void LoopTimer::enforce_frame_rate() { - uint64_t current_frame_time = SDLContext::get_instance().get_ticks(); - double frame_duration = (current_frame_time - this->last_frame_time); + std::chrono::steady_clock::time_point current_frame_time = std::chrono::steady_clock::now(); + std::chrono::milliseconds frame_duration = std::chrono::duration_cast(current_frame_time - this->last_frame_time); - if (frame_duration < this->frame_target_time) { - uint32_t delay_time - = static_cast(this->frame_target_time - frame_duration); - SDLContext::get_instance().delay(delay_time); - } + if (frame_duration < this->frame_target_time) { + std::chrono::milliseconds delay_time = std::chrono::duration_cast(this->frame_target_time - frame_duration); + if (delay_time.count() > 0) { + SDLContext::get_instance().delay(delay_time.count()); + } + } - this->last_frame_time = current_frame_time; + this->last_frame_time = current_frame_time; } double LoopTimer::get_lag() const { - return this->elapsed_time - this->elapsed_fixed_time; + return (this->elapsed_time - this->elapsed_fixed_time).count(); } diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index 5309d2f..ec48e4a 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -1,144 +1,145 @@ -#pragma once + #pragma once #include +#include namespace crepe { class LoopTimer { public: - /** + /** * \brief Get the singleton instance of LoopTimer. * * \return A reference to the LoopTimer instance. */ - static LoopTimer & get_instance(); + static LoopTimer& get_instance(); - /** + /** * \brief Get the current delta time for the current frame. * - * \return Delta time in milliseconds since the last frame. + * \return Delta time in seconds since the last frame. */ - double get_delta_time() const; + double get_delta_time() const; - /** + /** * \brief Get the current game time. * * \note The current game time may vary from real-world elapsed time. * It is the cumulative sum of each frame's delta time. * - * \return Elapsed game time in milliseconds. + * \return Elapsed game time in seconds. */ - double get_current_time() const; + double get_current_time() const; - /** + /** * \brief Set the target frames per second (FPS). * * \param fps The desired frames rendered per second. */ - void set_fps(int fps); + void set_fps(int fps); - /** + /** * \brief Get the current frames per second (FPS). * * \return Current FPS. */ - int get_fps() const; + int get_fps() const; - /** + /** * \brief Get the current game scale. * * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. */ - double get_game_scale() const; + double get_game_scale() const; - /** + /** * \brief Set the game scale. * * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). */ - void set_game_scale(double game_scale); + void set_game_scale(double game_scale); private: - friend class LoopManager; + friend class LoopManager; - /** + /** * \brief Start the loop timer. * * Initializes the timer to begin tracking frame times. */ - void start(); + void start(); - /** + /** * \brief Enforce the frame rate limit. * * Ensures that the game loop does not exceed the target FPS by delaying * frame updates as necessary. */ - void enforce_frame_rate(); + void enforce_frame_rate(); - /** + /** * \brief Get the fixed delta time for consistent updates. * * Fixed delta time is used for operations that require uniform time steps, * such as physics calculations. * - * \return Fixed delta time in milliseconds. + * \return Fixed delta time in seconds. */ - double get_fixed_delta_time() const; + double get_fixed_delta_time() const; - /** + /** * \brief Get the accumulated lag in the game loop. * * Lag represents the difference between the target frame time and the * actual frame time, useful for managing fixed update intervals. * - * \return Accumulated lag in milliseconds. + * \return Accumulated lag in seconds. */ - double get_lag() const; + double get_lag() const; - /** + /** * \brief Construct a new LoopTimer object. * * Private constructor for singleton pattern to restrict instantiation * outside the class. */ - LoopTimer(); + LoopTimer(); - /** + /** * \brief Update the timer to the current frame. * * Calculates and updates the delta time for the current frame and adds it to * the cumulative game time. */ - void update(); + void update(); - /** + /** * \brief Advance the game loop by a fixed update interval. * * This method progresses the game state by a consistent, fixed time step, * allowing for stable updates independent of frame rate fluctuations. */ - void advance_fixed_update(); + void advance_fixed_update(); private: - //! Current frames per second - int fps = 50; - //! Current game scale - double game_scale = 1; - //! Maximum delta time in milliseconds to avoid large jumps - double maximum_delta_time = 250; - //! Delta time for the current frame in milliseconds - double delta_time = 0; - //! Target time per frame in milliseconds - double frame_target_time = 1000.0 / fps; - //! Fixed delta time for fixed updates in milliseconds - double fixed_delta_time = 20; - //! Total elapsed game time in milliseconds - double elapsed_time = 0; - //! Total elapsed time for fixed updates in milliseconds - double elapsed_fixed_time = 0; - //! Time of the last frame in milliseconds - uint64_t last_frame_time = 0; + //! Current frames per second + int fps = 50; + //! Current game scale + double game_scale = 1; + //! Maximum delta time in seconds to avoid large jumps + std::chrono::duration maximum_delta_time{0.25}; + //! Delta time for the current frame in seconds + std::chrono::duration delta_time{0.0}; + //! Target time per frame in seconds + std::chrono::duration frame_target_time = std::chrono::seconds(1) / fps; + //! Fixed delta time for fixed updates in seconds + std::chrono::duration fixed_delta_time = std::chrono::seconds(1) / 50; + //! Total elapsed game time in seconds + std::chrono::duration elapsed_time{0.0}; + //! Total elapsed time for fixed updates in seconds + std::chrono::duration elapsed_fixed_time{0.0}; + //! Time of the last frame + std::chrono::steady_clock::time_point last_frame_time; }; } // namespace crepe diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index 90147e0..b51fdd5 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -58,6 +58,7 @@ private: private: //! Will only use get_ticks friend class AnimatorSystem; + //! Will use the funtions: get_ticks, delay friend class LoopTimer; /** * \brief Gets the current SDL ticks since the program started. -- cgit v1.2.3 From 4f5597885ce6af93ca4655c193982aa701afb8cf Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Mon, 11 Nov 2024 20:28:29 +0100 Subject: git format --- src/crepe/api/LoopManager.cpp | 3 +- src/crepe/api/LoopManager.h | 18 ++++---- src/crepe/api/LoopTimer.cpp | 95 +++++++++++++++++++-------------------- src/crepe/api/LoopTimer.h | 100 +++++++++++++++++++++--------------------- 4 files changed, 106 insertions(+), 110 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp index ea63bf6..2e9823f 100644 --- a/src/crepe/api/LoopManager.cpp +++ b/src/crepe/api/LoopManager.cpp @@ -8,8 +8,7 @@ using namespace crepe; -LoopManager::LoopManager() { -} +LoopManager::LoopManager() {} void LoopManager::process_input() { SDLContext::get_instance().handle_events(this->game_running); } diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h index d4668b8..755e2d2 100644 --- a/src/crepe/api/LoopManager.h +++ b/src/crepe/api/LoopManager.h @@ -13,8 +13,6 @@ class AnimatorSystem; class CollisionSystem; namespace crepe { - - class LoopManager { public: void start(); @@ -76,14 +74,14 @@ private: bool game_running = false; // For later if singletons are removed cant make them now because destructors are private. - // std::unique_ptr render_system; - // std::unique_ptr sdl_context; - // std::unique_ptr loop_timer; - // std::unique_ptr script_system; - // std::unique_ptr particle_system; - // std::unique_ptr physics_system; - // std::unique_ptr animator_system; - // std::unique_ptr collision_system; + // std::unique_ptr render_system; + // std::unique_ptr sdl_context; + // std::unique_ptr loop_timer; + // std::unique_ptr script_system; + // std::unique_ptr particle_system; + // std::unique_ptr physics_system; + // std::unique_ptr animator_system; + // std::unique_ptr collision_system; }; } // namespace crepe diff --git a/src/crepe/api/LoopTimer.cpp b/src/crepe/api/LoopTimer.cpp index 039e35e..8f09e41 100644 --- a/src/crepe/api/LoopTimer.cpp +++ b/src/crepe/api/LoopTimer.cpp @@ -7,83 +7,80 @@ using namespace crepe; -LoopTimer::LoopTimer() { - dbg_trace(); -} +LoopTimer::LoopTimer() { dbg_trace(); } LoopTimer & LoopTimer::get_instance() { - static LoopTimer instance; - return instance; + static LoopTimer instance; + return instance; } void LoopTimer::start() { - this->last_frame_time = std::chrono::steady_clock::now(); - this->elapsed_time = std::chrono::milliseconds(0); - this->elapsed_fixed_time = std::chrono::milliseconds(0); - this->delta_time = std::chrono::milliseconds(0); + this->last_frame_time = std::chrono::steady_clock::now(); + this->elapsed_time = std::chrono::milliseconds(0); + this->elapsed_fixed_time = std::chrono::milliseconds(0); + this->delta_time = std::chrono::milliseconds(0); } void LoopTimer::update() { - auto current_frame_time = std::chrono::steady_clock::now(); - // Convert to duration in seconds for delta time - this->delta_time = std::chrono::duration_cast>(current_frame_time - last_frame_time); - - if (this->delta_time > this->maximum_delta_time) { - this->delta_time = this->maximum_delta_time; - } - - this->delta_time *= this->game_scale; - this->elapsed_time += this->delta_time; - this->last_frame_time = current_frame_time; + auto current_frame_time = std::chrono::steady_clock::now(); + // Convert to duration in seconds for delta time + this->delta_time + = std::chrono::duration_cast>( + current_frame_time - last_frame_time); + + if (this->delta_time > this->maximum_delta_time) { + this->delta_time = this->maximum_delta_time; + } + + this->delta_time *= this->game_scale; + this->elapsed_time += this->delta_time; + this->last_frame_time = current_frame_time; } -double LoopTimer::get_delta_time() const { - return this->delta_time.count(); -} +double LoopTimer::get_delta_time() const { return this->delta_time.count(); } double LoopTimer::get_current_time() const { - return this->elapsed_time.count(); + return this->elapsed_time.count(); } void LoopTimer::advance_fixed_update() { - this->elapsed_fixed_time += this->fixed_delta_time; + this->elapsed_fixed_time += this->fixed_delta_time; } double LoopTimer::get_fixed_delta_time() const { - return this->fixed_delta_time.count(); + return this->fixed_delta_time.count(); } void LoopTimer::set_fps(int fps) { - this->fps = fps; + this->fps = fps; // target time per frame in seconds - this->frame_target_time = std::chrono::seconds(1) / fps; + this->frame_target_time = std::chrono::seconds(1) / fps; } -int LoopTimer::get_fps() const { - return this->fps; -} +int LoopTimer::get_fps() const { return this->fps; } -void LoopTimer::set_game_scale(double value) { - this->game_scale = value; -} +void LoopTimer::set_game_scale(double value) { this->game_scale = value; } -double LoopTimer::get_game_scale() const { - return this->game_scale; -} +double LoopTimer::get_game_scale() const { return this->game_scale; } void LoopTimer::enforce_frame_rate() { - std::chrono::steady_clock::time_point current_frame_time = std::chrono::steady_clock::now(); - std::chrono::milliseconds frame_duration = std::chrono::duration_cast(current_frame_time - this->last_frame_time); - - if (frame_duration < this->frame_target_time) { - std::chrono::milliseconds delay_time = std::chrono::duration_cast(this->frame_target_time - frame_duration); - if (delay_time.count() > 0) { - SDLContext::get_instance().delay(delay_time.count()); - } - } - - this->last_frame_time = current_frame_time; + std::chrono::steady_clock::time_point current_frame_time + = std::chrono::steady_clock::now(); + std::chrono::milliseconds frame_duration + = std::chrono::duration_cast( + current_frame_time - this->last_frame_time); + + if (frame_duration < this->frame_target_time) { + std::chrono::milliseconds delay_time + = std::chrono::duration_cast( + this->frame_target_time - frame_duration); + if (delay_time.count() > 0) { + SDLContext::get_instance().delay(delay_time.count()); + } + } + + this->last_frame_time = current_frame_time; } double LoopTimer::get_lag() const { - return (this->elapsed_time - this->elapsed_fixed_time).count(); + return (this->elapsed_time - this->elapsed_fixed_time).count(); } diff --git a/src/crepe/api/LoopTimer.h b/src/crepe/api/LoopTimer.h index ec48e4a..85687be 100644 --- a/src/crepe/api/LoopTimer.h +++ b/src/crepe/api/LoopTimer.h @@ -1,27 +1,27 @@ - #pragma once +#pragma once -#include #include +#include namespace crepe { class LoopTimer { public: - /** + /** * \brief Get the singleton instance of LoopTimer. * * \return A reference to the LoopTimer instance. */ - static LoopTimer& get_instance(); + static LoopTimer & get_instance(); - /** + /** * \brief Get the current delta time for the current frame. * * \return Delta time in seconds since the last frame. */ - double get_delta_time() const; + double get_delta_time() const; - /** + /** * \brief Get the current game time. * * \note The current game time may vary from real-world elapsed time. @@ -29,55 +29,55 @@ public: * * \return Elapsed game time in seconds. */ - double get_current_time() const; + double get_current_time() const; - /** + /** * \brief Set the target frames per second (FPS). * * \param fps The desired frames rendered per second. */ - void set_fps(int fps); + void set_fps(int fps); - /** + /** * \brief Get the current frames per second (FPS). * * \return Current FPS. */ - int get_fps() const; + int get_fps() const; - /** + /** * \brief Get the current game scale. * * \return The current game scale, where 0 = paused, 1 = normal speed, and values > 1 speed up the game. */ - double get_game_scale() const; + double get_game_scale() const; - /** + /** * \brief Set the game scale. * * \param game_scale The desired game scale (0 = pause, 1 = normal speed, > 1 = speed up). */ - void set_game_scale(double game_scale); + void set_game_scale(double game_scale); private: - friend class LoopManager; + friend class LoopManager; - /** + /** * \brief Start the loop timer. * * Initializes the timer to begin tracking frame times. */ - void start(); + void start(); - /** + /** * \brief Enforce the frame rate limit. * * Ensures that the game loop does not exceed the target FPS by delaying * frame updates as necessary. */ - void enforce_frame_rate(); + void enforce_frame_rate(); - /** + /** * \brief Get the fixed delta time for consistent updates. * * Fixed delta time is used for operations that require uniform time steps, @@ -85,9 +85,9 @@ private: * * \return Fixed delta time in seconds. */ - double get_fixed_delta_time() const; + double get_fixed_delta_time() const; - /** + /** * \brief Get the accumulated lag in the game loop. * * Lag represents the difference between the target frame time and the @@ -95,51 +95,53 @@ private: * * \return Accumulated lag in seconds. */ - double get_lag() const; + double get_lag() const; - /** + /** * \brief Construct a new LoopTimer object. * * Private constructor for singleton pattern to restrict instantiation * outside the class. */ - LoopTimer(); + LoopTimer(); - /** + /** * \brief Update the timer to the current frame. * * Calculates and updates the delta time for the current frame and adds it to * the cumulative game time. */ - void update(); + void update(); - /** + /** * \brief Advance the game loop by a fixed update interval. * * This method progresses the game state by a consistent, fixed time step, * allowing for stable updates independent of frame rate fluctuations. */ - void advance_fixed_update(); + void advance_fixed_update(); private: - //! Current frames per second - int fps = 50; - //! Current game scale - double game_scale = 1; - //! Maximum delta time in seconds to avoid large jumps - std::chrono::duration maximum_delta_time{0.25}; - //! Delta time for the current frame in seconds - std::chrono::duration delta_time{0.0}; - //! Target time per frame in seconds - std::chrono::duration frame_target_time = std::chrono::seconds(1) / fps; - //! Fixed delta time for fixed updates in seconds - std::chrono::duration fixed_delta_time = std::chrono::seconds(1) / 50; - //! Total elapsed game time in seconds - std::chrono::duration elapsed_time{0.0}; - //! Total elapsed time for fixed updates in seconds - std::chrono::duration elapsed_fixed_time{0.0}; - //! Time of the last frame - std::chrono::steady_clock::time_point last_frame_time; + //! Current frames per second + int fps = 50; + //! Current game scale + double game_scale = 1; + //! Maximum delta time in seconds to avoid large jumps + std::chrono::duration maximum_delta_time{0.25}; + //! Delta time for the current frame in seconds + std::chrono::duration delta_time{0.0}; + //! Target time per frame in seconds + std::chrono::duration frame_target_time + = std::chrono::seconds(1) / fps; + //! Fixed delta time for fixed updates in seconds + std::chrono::duration fixed_delta_time + = std::chrono::seconds(1) / 50; + //! Total elapsed game time in seconds + std::chrono::duration elapsed_time{0.0}; + //! Total elapsed time for fixed updates in seconds + std::chrono::duration elapsed_fixed_time{0.0}; + //! Time of the last frame + std::chrono::steady_clock::time_point last_frame_time; }; } // namespace crepe -- cgit v1.2.3 From 3c9b331668189e9c1a35d3d6ac6ded601f725e78 Mon Sep 17 00:00:00 2001 From: heavydemon21 Date: Tue, 12 Nov 2024 15:11:27 +0100 Subject: assetmanager --- src/crepe/api/AssetManager.h | 45 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) (limited to 'src/crepe/api') diff --git a/src/crepe/api/AssetManager.h b/src/crepe/api/AssetManager.h index fefbed9..68235c3 100644 --- a/src/crepe/api/AssetManager.h +++ b/src/crepe/api/AssetManager.h @@ -7,24 +7,69 @@ namespace crepe { + +/** + * \brief The AssetManager is responsible for storing and managing assets over multiple scenes. + * + * The AssetManager ensures that assets are loaded once and can be accessed across different scenes. + * It caches assets to avoid reloading them every time a scene is loaded. Assets are retained in memory + * until the AssetManager is destroyed, at which point the cached assets are cleared. + */ class AssetManager { private: + //! A cache that holds all the assets, accessible by their file path, over multiple scenes. std::unordered_map asset_cache; private: + /** + * \brief Private constructor for the AssetManager. + * + */ AssetManager(); + + /** + * \brief Private destructor for the AssetManager. + * + */ virtual ~AssetManager(); public: + + //! Deleted copy constructor to prevent copying of the AssetManager instance. AssetManager(const AssetManager &) = delete; + + //! Deleted move constructor to prevent moving of the AssetManager instance. AssetManager(AssetManager &&) = delete; + + //! Deleted copy assignment operator to prevent copying the AssetManager instance. AssetManager & operator=(const AssetManager &) = delete; + + //! Deleted move assignment operator to prevent moving the AssetManager instance. AssetManager & operator=(AssetManager &&) = delete; + /** + * \brief Retrieves the singleton instance of the AssetManager. + * + * \return A reference to the single instance of the AssetManager. + * + */ static AssetManager & get_instance(); public: + /** + * \brief Caches an asset by loading it from the given file path. + * + * \param[in] file_path The path to the asset file to load. + * \param[in] reload If true, the asset will be reloaded from the file, even if it is already cached. + * \tparam asset The type of asset to cache (e.g., texture, sound, etc.). + * + * \return A shared pointer to the cached asset. + * + * This template function caches the asset at the given file path. If the asset is already cached + * and `reload` is false, the existing cached version will be returned. Otherwise, the asset will + * be reloaded and added to the cache. + */ template std::shared_ptr cache(const std::string & file_path, bool reload = false); -- cgit v1.2.3 From 113e2d299d22921212a793eb7cd55afbd49ba22e Mon Sep 17 00:00:00 2001 From: WBoerenkamps Date: Tue, 12 Nov 2024 15:13:19 +0100 Subject: changed doxygen comment of friend class --- src/crepe/api/LoopManager.h | 10 +--------- src/crepe/facade/SDLContext.h | 2 +- src/makefile | 4 ++-- 3 files changed, 4 insertions(+), 12 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h index 755e2d2..2f03193 100644 --- a/src/crepe/api/LoopManager.h +++ b/src/crepe/api/LoopManager.h @@ -73,15 +73,7 @@ private: void render(); bool game_running = false; - // For later if singletons are removed cant make them now because destructors are private. - // std::unique_ptr render_system; - // std::unique_ptr sdl_context; - // std::unique_ptr loop_timer; - // std::unique_ptr script_system; - // std::unique_ptr particle_system; - // std::unique_ptr physics_system; - // std::unique_ptr animator_system; - // std::unique_ptr collision_system; + //#TODO add system instances }; } // namespace crepe diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h index b51fdd5..536dec5 100644 --- a/src/crepe/facade/SDLContext.h +++ b/src/crepe/facade/SDLContext.h @@ -58,7 +58,7 @@ private: private: //! Will only use get_ticks friend class AnimatorSystem; - //! Will use the funtions: get_ticks, delay + //! Will only use delay friend class LoopTimer; /** * \brief Gets the current SDL ticks since the program started. diff --git a/src/makefile b/src/makefile index a2c2961..bd05b2e 100644 --- a/src/makefile +++ b/src/makefile @@ -94,10 +94,10 @@ LOEK += example/script.cpp LOEK += test/audio.cpp LOEK += test/dummy.cpp JARO += test/PhysicsTest.cpp -FMT := $(JARO) #<<< CHANGE THIS TO YOUR NAME FOR STEP 2 +FMT := $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp') format: FORCE clang-tidy -p build/compile_commands.json --fix-errors $(FMT) -# FMT += $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp') +# FMT := $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp') # TODO: re-enable linter after all corrections -- cgit v1.2.3 From d9130d78738b6cb1bdc4e7ec65362b0ef46b1035 Mon Sep 17 00:00:00 2001 From: Loek Le Blansch Date: Tue, 12 Nov 2024 18:26:59 +0100 Subject: `make format` --- mwe/ecs-homemade/src/Components.cpp | 4 ++- mwe/ecs-homemade/src/GameObjectMax.cpp | 6 ++++- .../inc/ContiguousContainer.hpp | 3 ++- mwe/ecs-memory-efficient/src/Components.cpp | 4 ++- mwe/ecs-memory-efficient/src/GameObjectMax.cpp | 6 ++++- mwe/events/include/customTypes.h | 4 ++- mwe/events/include/event.h | 2 +- mwe/events/include/eventHandler.h | 3 ++- mwe/events/src/event.cpp | 31 ++++++++++++++++------ mwe/events/src/main.cpp | 4 ++- mwe/events/src/uiObject.cpp | 13 ++++++--- mwe/gameloop/src/gameObject.cpp | 7 ++++- src/crepe/ValueBroker.hpp | 3 ++- src/crepe/api/Animator.cpp | 5 +++- src/crepe/api/Camera.cpp | 3 ++- src/crepe/api/CircleCollider.h | 3 ++- src/crepe/api/Metadata.cpp | 4 ++- src/crepe/api/ParticleEmitter.cpp | 11 +++++--- src/crepe/api/Rigidbody.cpp | 3 ++- src/crepe/api/Sprite.cpp | 5 +++- src/crepe/api/Transform.cpp | 5 +++- 21 files changed, 97 insertions(+), 32 deletions(-) (limited to 'src/crepe/api') diff --git a/mwe/ecs-homemade/src/Components.cpp b/mwe/ecs-homemade/src/Components.cpp index de8753e..0d62bd5 100644 --- a/mwe/ecs-homemade/src/Components.cpp +++ b/mwe/ecs-homemade/src/Components.cpp @@ -6,7 +6,9 @@ Component::Component() : mActive(true) {} Sprite::Sprite(std::string path) : mPath(path) {} Rigidbody::Rigidbody(int mass, int gravityScale, int bodyType) - : mMass(mass), mGravityScale(gravityScale), mBodyType(bodyType) {} + : mMass(mass), + mGravityScale(gravityScale), + mBodyType(bodyType) {} Colider::Colider(int size) : mSize(size) {} diff --git a/mwe/ecs-homemade/src/GameObjectMax.cpp b/mwe/ecs-homemade/src/GameObjectMax.cpp index b0c5af7..753c8e2 100644 --- a/mwe/ecs-homemade/src/GameObjectMax.cpp +++ b/mwe/ecs-homemade/src/GameObjectMax.cpp @@ -4,4 +4,8 @@ GameObject::GameObject(std::uint32_t id, std::string name, std::string tag, int layer) - : mId(id), mName(name), mTag(tag), mActive(true), mLayer(layer) {} + : mId(id), + mName(name), + mTag(tag), + mActive(true), + mLayer(layer) {} diff --git a/mwe/ecs-memory-efficient/inc/ContiguousContainer.hpp b/mwe/ecs-memory-efficient/inc/ContiguousContainer.hpp index 408d5aa..ff8fde4 100644 --- a/mwe/ecs-memory-efficient/inc/ContiguousContainer.hpp +++ b/mwe/ecs-memory-efficient/inc/ContiguousContainer.hpp @@ -1,5 +1,6 @@ template -ContiguousContainer::ContiguousContainer() : mSize(0), mCapacity(10) { +ContiguousContainer::ContiguousContainer() : mSize(0), + mCapacity(10) { // Allocate memory for 10 objects initially mData = static_cast(malloc(mCapacity * sizeof(T))); if (!mData) { diff --git a/mwe/ecs-memory-efficient/src/Components.cpp b/mwe/ecs-memory-efficient/src/Components.cpp index c8347b3..2ec8609 100644 --- a/mwe/ecs-memory-efficient/src/Components.cpp +++ b/mwe/ecs-memory-efficient/src/Components.cpp @@ -6,6 +6,8 @@ Component::Component() : mActive(true) {} Sprite::Sprite(std::string path) : mPath(path) {} Rigidbody::Rigidbody(int mass, int gravityScale, int bodyType) - : mMass(mass), mGravityScale(gravityScale), mBodyType(bodyType) {} + : mMass(mass), + mGravityScale(gravityScale), + mBodyType(bodyType) {} Colider::Colider(int size) : mSize(size) {} diff --git a/mwe/ecs-memory-efficient/src/GameObjectMax.cpp b/mwe/ecs-memory-efficient/src/GameObjectMax.cpp index b0c5af7..753c8e2 100644 --- a/mwe/ecs-memory-efficient/src/GameObjectMax.cpp +++ b/mwe/ecs-memory-efficient/src/GameObjectMax.cpp @@ -4,4 +4,8 @@ GameObject::GameObject(std::uint32_t id, std::string name, std::string tag, int layer) - : mId(id), mName(name), mTag(tag), mActive(true), mLayer(layer) {} + : mId(id), + mName(name), + mTag(tag), + mActive(true), + mLayer(layer) {} diff --git a/mwe/events/include/customTypes.h b/mwe/events/include/customTypes.h index a5d8dc9..415b989 100644 --- a/mwe/events/include/customTypes.h +++ b/mwe/events/include/customTypes.h @@ -33,6 +33,8 @@ struct Collision { // Constructor to initialize a Collision Collision(int idA, int idB, const Vector2 & point, const Vector2 & normal, float depth) - : objectIdA(idA), objectIdB(idB), contactPoint(point), + : objectIdA(idA), + objectIdB(idB), + contactPoint(point), contactNormal(normal) {} }; diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h index 3e70201..16c75bf 100644 --- a/mwe/events/include/event.h +++ b/mwe/events/include/event.h @@ -152,7 +152,7 @@ private: }; class ShutDownEvent : public Event { public: - ShutDownEvent() : Event("ShutDownEvent"){}; + ShutDownEvent() : Event("ShutDownEvent") {}; REGISTER_EVENT_TYPE(ShutDownEvent) diff --git a/mwe/events/include/eventHandler.h b/mwe/events/include/eventHandler.h index aa8f63b..3a83b15 100644 --- a/mwe/events/include/eventHandler.h +++ b/mwe/events/include/eventHandler.h @@ -24,7 +24,8 @@ class EventHandlerWrapper : public IEventHandlerWrapper { public: explicit EventHandlerWrapper(const EventHandler & handler, const bool destroyOnSuccess = false) - : m_handler(handler), m_handlerType(m_handler.target_type().name()), + : m_handler(handler), + m_handlerType(m_handler.target_type().name()), m_destroyOnSuccess(destroyOnSuccess) { // std::cout << m_handlerType << std::endl; } diff --git a/mwe/events/src/event.cpp b/mwe/events/src/event.cpp index 0c9f3ed..8ffa0b1 100644 --- a/mwe/events/src/event.cpp +++ b/mwe/events/src/event.cpp @@ -23,7 +23,9 @@ void Event::markHandled() { isHandled = true; } // KeyPressedEvent class methods KeyPressedEvent::KeyPressedEvent(int keycode) - : Event("KeyPressedEvent"), key(keycode), repeatCount(0) {} + : Event("KeyPressedEvent"), + key(keycode), + repeatCount(0) {} Keycode KeyPressedEvent::getKeyCode() const { return key; } @@ -31,13 +33,16 @@ int KeyPressedEvent::getRepeatCount() const { return repeatCount; } // KeyReleasedEvent class methods KeyReleasedEvent::KeyReleasedEvent(int keycode) - : Event("KeyReleasedEvent"), key(keycode) {} + : Event("KeyReleasedEvent"), + key(keycode) {} Keycode KeyReleasedEvent::getKeyCode() const { return key; } // MousePressedEvent class methods MousePressedEvent::MousePressedEvent(int mouseX, int mouseY) - : Event("MousePressedEvent"), mouseX(mouseX), mouseY(mouseY) {} + : Event("MousePressedEvent"), + mouseX(mouseX), + mouseY(mouseY) {} std::pair MousePressedEvent::getMousePosition() const { return {mouseX, mouseY}; @@ -45,26 +50,36 @@ std::pair MousePressedEvent::getMousePosition() const { //Collision event CollisionEvent::CollisionEvent(Collision collision) - : collisionData(collision), Event("CollisionEvent") {} + : collisionData(collision), + Event("CollisionEvent") {} Collision CollisionEvent::getCollisionData() const { return this->collisionData; } TextSubmitEvent::TextSubmitEvent(std::string text) - : text(text), Event("TextSubmitEvent") {} + : text(text), + Event("TextSubmitEvent") {} std::string TextSubmitEvent::getText() const { return this->text; } MouseReleasedEvent::MouseReleasedEvent(int x, int y, MouseButton button) - : mouseX(x), mouseY(y), button(button), Event("MouseReleased") {} + : mouseX(x), + mouseY(y), + button(button), + Event("MouseReleased") {} std::pair MouseReleasedEvent::getMousePosition() const { return {mouseX, mouseY}; } MouseClickEvent::MouseClickEvent(int x, int y, MouseButton button) - : mouseX(x), mouseY(y), button(button), Event("MouseClickEvent") {} + : mouseX(x), + mouseY(y), + button(button), + Event("MouseClickEvent") {} MouseMovedEvent::MouseMovedEvent(int x, int y) - : mouseX(x), mouseY(y), Event("MouseMovedEvent") {} + : mouseX(x), + mouseY(y), + Event("MouseMovedEvent") {} std::pair MouseClickEvent::getMousePosition() const { return {mouseX, mouseY}; } diff --git a/mwe/events/src/main.cpp b/mwe/events/src/main.cpp index d49cf74..f4e7390 100644 --- a/mwe/events/src/main.cpp +++ b/mwe/events/src/main.cpp @@ -11,7 +11,9 @@ class PlayerDamagedEvent : public Event { public: PlayerDamagedEvent(int damage, int playerID) - : Event("PlayerDamaged"), damage(damage), playerID(playerID) {} + : Event("PlayerDamaged"), + damage(damage), + playerID(playerID) {} REGISTER_EVENT_TYPE(PlayerDamagedEvent); diff --git a/mwe/events/src/uiObject.cpp b/mwe/events/src/uiObject.cpp index 8405469..947d1a2 100644 --- a/mwe/events/src/uiObject.cpp +++ b/mwe/events/src/uiObject.cpp @@ -7,7 +7,9 @@ UIObject::UIObject(int width, int height) : width(width), height(height) {} Button::Button(int width, int height) : UIObject(width, height) {} Text::Text(int width, int height) - : UIObject(width, height), size(12), font(nullptr), + : UIObject(width, height), + size(12), + font(nullptr), color{255, 255, 255} { // Default size and color alignment.horizontal = Alignment::Horizontal::CENTER; alignment.vertical = Alignment::Vertical::MIDDLE; @@ -15,8 +17,13 @@ Text::Text(int width, int height) } TextInput::TextInput(int width, int height) - : UIObject(width, height), textBuffer(""), placeholder(""), isActive(false), - textColor{255, 255, 255}, backgroundColor{0, 0, 0}, maxLength(100), + : UIObject(width, height), + textBuffer(""), + placeholder(""), + isActive(false), + textColor{255, 255, 255}, + backgroundColor{0, 0, 0}, + maxLength(100), font(nullptr) { alignment.horizontal = Alignment::Horizontal::LEFT; alignment.vertical = Alignment::Vertical::TOP; diff --git a/mwe/gameloop/src/gameObject.cpp b/mwe/gameloop/src/gameObject.cpp index 78217c4..b33dc78 100644 --- a/mwe/gameloop/src/gameObject.cpp +++ b/mwe/gameloop/src/gameObject.cpp @@ -26,5 +26,10 @@ void GameObject::setVelY(float value) { velY = value; } GameObject::GameObject(std::string name, float x, float y, float width, float height, float velX, float velY) - : name(name), x(x), y(y), width(width), height(height), velX(velX), + : name(name), + x(x), + y(y), + width(width), + height(height), + velX(velX), velY(velY) {} diff --git a/src/crepe/ValueBroker.hpp b/src/crepe/ValueBroker.hpp index 927142f..5c3bed9 100644 --- a/src/crepe/ValueBroker.hpp +++ b/src/crepe/ValueBroker.hpp @@ -6,7 +6,8 @@ namespace crepe { template ValueBroker::ValueBroker(const setter_t & setter, const getter_t & getter) - : setter(setter), getter(getter) {} + : setter(setter), + getter(getter) {} template const T & ValueBroker::get() { diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp index 8b396af..58fee2a 100644 --- a/src/crepe/api/Animator.cpp +++ b/src/crepe/api/Animator.cpp @@ -10,7 +10,10 @@ using namespace crepe; Animator::Animator(uint32_t id, Sprite & ss, int row, int col, int col_animator) - : Component(id), spritesheet(ss), row(row), col(col) { + : Component(id), + spritesheet(ss), + row(row), + col(col) { dbg_trace(); animator_rect = spritesheet.sprite_rect; diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp index 820a6a8..6355a03 100644 --- a/src/crepe/api/Camera.cpp +++ b/src/crepe/api/Camera.cpp @@ -10,7 +10,8 @@ using namespace crepe; Camera::Camera(uint32_t id, const Color & bg_color) - : Component(id), bg_color(bg_color) { + : Component(id), + bg_color(bg_color) { dbg_trace(); } diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h index caa7e43..e77a592 100644 --- a/src/crepe/api/CircleCollider.h +++ b/src/crepe/api/CircleCollider.h @@ -6,7 +6,8 @@ namespace crepe { class CircleCollider : public Collider { public: CircleCollider(game_object_id_t game_object_id, int radius) - : Collider(game_object_id), radius(radius) {} + : Collider(game_object_id), + radius(radius) {} int radius; }; diff --git a/src/crepe/api/Metadata.cpp b/src/crepe/api/Metadata.cpp index 76f11d7..d421de5 100644 --- a/src/crepe/api/Metadata.cpp +++ b/src/crepe/api/Metadata.cpp @@ -4,4 +4,6 @@ using namespace crepe; using namespace std; Metadata::Metadata(game_object_id_t id, const string & name, const string & tag) - : Component(id), name(name), tag(tag) {} + : Component(id), + name(name), + tag(tag) {} diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 3b2e2f2..0bc2197 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -11,9 +11,14 @@ ParticleEmitter::ParticleEmitter(game_object_id_t id, uint32_t max_particles, uint32_t speed_offset, uint32_t angle, uint32_t angleOffset, float begin_lifespan, float end_lifespan) - : Component(id), max_particles(max_particles), emission_rate(emission_rate), - speed(speed), speed_offset(speed_offset), position{0, 0}, - begin_lifespan(begin_lifespan), end_lifespan(end_lifespan) { + : Component(id), + max_particles(max_particles), + emission_rate(emission_rate), + speed(speed), + speed_offset(speed_offset), + position{0, 0}, + begin_lifespan(begin_lifespan), + end_lifespan(end_lifespan) { std::srand( static_cast(std::time(nullptr))); // initialize random seed std::cout << "Create emitter" << std::endl; diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp index cbf1325..3bf1c5b 100644 --- a/src/crepe/api/Rigidbody.cpp +++ b/src/crepe/api/Rigidbody.cpp @@ -3,7 +3,8 @@ using namespace crepe; crepe::Rigidbody::Rigidbody(uint32_t game_object_id, const Data & data) - : Component(game_object_id), data(data) {} + : Component(game_object_id), + data(data) {} void crepe::Rigidbody::add_force_linear(const Vector2 & force) { this->data.linear_velocity += force; diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp index f9cd761..6f0433f 100644 --- a/src/crepe/api/Sprite.cpp +++ b/src/crepe/api/Sprite.cpp @@ -12,7 +12,10 @@ using namespace crepe; Sprite::Sprite(game_object_id_t id, const shared_ptr image, const Color & color, const FlipSettings & flip) - : Component(id), color(color), flip(flip), sprite_image(image) { + : Component(id), + color(color), + flip(flip), + sprite_image(image) { dbg_trace(); this->sprite_rect.w = sprite_image->get_width(); diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp index a244bc5..e401120 100644 --- a/src/crepe/api/Transform.cpp +++ b/src/crepe/api/Transform.cpp @@ -6,6 +6,9 @@ using namespace crepe; Transform::Transform(game_object_id_t id, const Vector2 & point, double rotation, double scale) - : Component(id), position(point), rotation(rotation), scale(scale) { + : Component(id), + position(point), + rotation(rotation), + scale(scale) { dbg_trace(); } -- cgit v1.2.3 From f2509e89c02894ebd3ad992324eb300103621d26 Mon Sep 17 00:00:00 2001 From: Loek Le Blansch Date: Tue, 12 Nov 2024 18:32:56 +0100 Subject: nitpick #30 --- src/crepe/api/AssetManager.h | 48 +++++++++++++++----------------------------- 1 file changed, 16 insertions(+), 32 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/AssetManager.h b/src/crepe/api/AssetManager.h index 68235c3..dbfaef3 100644 --- a/src/crepe/api/AssetManager.h +++ b/src/crepe/api/AssetManager.h @@ -7,13 +7,14 @@ namespace crepe { - /** - * \brief The AssetManager is responsible for storing and managing assets over multiple scenes. + * \brief The AssetManager is responsible for storing and managing assets over + * multiple scenes. * - * The AssetManager ensures that assets are loaded once and can be accessed across different scenes. - * It caches assets to avoid reloading them every time a scene is loaded. Assets are retained in memory - * until the AssetManager is destroyed, at which point the cached assets are cleared. + * The AssetManager ensures that assets are loaded once and can be accessed + * across different scenes. It caches assets to avoid reloading them every time + * a scene is loaded. Assets are retained in memory until the AssetManager is + * destroyed, at which point the cached assets are cleared. */ class AssetManager { @@ -22,37 +23,19 @@ private: std::unordered_map asset_cache; private: - /** - * \brief Private constructor for the AssetManager. - * - */ AssetManager(); - - /** - * \brief Private destructor for the AssetManager. - * - */ virtual ~AssetManager(); public: - - //! Deleted copy constructor to prevent copying of the AssetManager instance. AssetManager(const AssetManager &) = delete; - - //! Deleted move constructor to prevent moving of the AssetManager instance. AssetManager(AssetManager &&) = delete; - - //! Deleted copy assignment operator to prevent copying the AssetManager instance. AssetManager & operator=(const AssetManager &) = delete; - - //! Deleted move assignment operator to prevent moving the AssetManager instance. AssetManager & operator=(AssetManager &&) = delete; /** * \brief Retrieves the singleton instance of the AssetManager. * * \return A reference to the single instance of the AssetManager. - * */ static AssetManager & get_instance(); @@ -60,19 +43,20 @@ public: /** * \brief Caches an asset by loading it from the given file path. * - * \param[in] file_path The path to the asset file to load. - * \param[in] reload If true, the asset will be reloaded from the file, even if it is already cached. - * \tparam asset The type of asset to cache (e.g., texture, sound, etc.). + * \param file_path The path to the asset file to load. + * \param reload If true, the asset will be reloaded from the file, even if + * it is already cached. + * \tparam T The type of asset to cache (e.g., texture, sound, etc.). * * \return A shared pointer to the cached asset. * - * This template function caches the asset at the given file path. If the asset is already cached - * and `reload` is false, the existing cached version will be returned. Otherwise, the asset will - * be reloaded and added to the cache. + * This template function caches the asset at the given file path. If the + * asset is already cached and `reload` is false, the existing cached version + * will be returned. Otherwise, the asset will be reloaded and added to the + * cache. */ - template - std::shared_ptr cache(const std::string & file_path, - bool reload = false); + template + std::shared_ptr cache(const std::string & file_path, bool reload = false); }; } // namespace crepe -- cgit v1.2.3 From 1d4b3a44c9ce1e69f4f0e3909998225f8af3fea2 Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Wed, 13 Nov 2024 19:00:29 +0100 Subject: fixed feedback --- src/crepe/Particle.cpp | 2 +- src/crepe/Particle.h | 5 ++--- src/crepe/api/ParticleEmitter.cpp | 9 +-------- src/crepe/api/ParticleEmitter.h | 5 ++--- src/crepe/system/ParticleSystem.h | 8 +++++--- src/crepe/system/PhysicsSystem.h | 10 ++++------ 6 files changed, 15 insertions(+), 24 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp index ab55f37..1c3c138 100644 --- a/src/crepe/Particle.cpp +++ b/src/crepe/Particle.cpp @@ -2,7 +2,7 @@ using namespace crepe; -void Particle::reset(uint32_t lifespan, Vector2 position, Vector2 velocity, +void Particle::reset(uint32_t lifespan, const Vector2& position,const Vector2& velocity, double angle) { // Initialize the particle state this->time_in_life = 0; diff --git a/src/crepe/Particle.h b/src/crepe/Particle.h index 06431bb..8782382 100644 --- a/src/crepe/Particle.h +++ b/src/crepe/Particle.h @@ -30,9 +30,8 @@ public: //! The time the particle has been alive, in milliseconds. uint32_t time_in_life = 0; //! The angle at which the particle is oriented or moving. - double angle; + double angle = 0; - Particle() = default; /** * \brief Resets the particle with new properties. * @@ -44,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, Vector2 position, Vector2 velocity, + void reset(uint32_t lifespan, const Vector2& position,const Vector2& velocity, double angle); /** * \brief Updates the particle's state. diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index e7f298c..7032f9e 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -3,16 +3,9 @@ using namespace crepe; -ParticleEmitter::ParticleEmitter(uint32_t game_object_id, const Data & data) +ParticleEmitter::ParticleEmitter(game_object_id_t game_object_id, const Data & data) : Component(game_object_id), data(data) { for (size_t i = 0; i < this->data.max_particles; i++) { this->data.particles.emplace_back(); } } - -ParticleEmitter::~ParticleEmitter() { - std::vector::iterator it = this->data.particles.begin(); - while (it != this->data.particles.end()) { - it = this->data.particles.erase(it); - } -} diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index 83a1588..6e29e60 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -48,7 +48,7 @@ public: //! position of the emitter Vector2 position; //! maximum number of particles - const uint32_t max_particles = 0; + const unsigned int max_particles = 0; //! rate of particle emission per update (Lowest value = 0.001 any lower is ignored) double emission_rate = 0; //! min speed of the particles @@ -80,8 +80,7 @@ public: * \param game_object_id Identifier for the game object using this emitter. * \param data Configuration data defining particle properties. */ - ParticleEmitter(uint32_t game_object_id, const Data & data); - ~ParticleEmitter(); + ParticleEmitter(game_object_id_t game_object_id, const Data & data); public: //! Configuration data for particle emission settings. diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h index 3155df1..3a118fb 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -2,13 +2,15 @@ #include +#include "System.h" + namespace crepe { class ParticleEmitter; class Transform; /** * \brief ParticleSystem class responsible for managing particle emission, updates, and bounds checking. */ -class ParticleSystem { +class ParticleSystem : public System{ public: /** * \brief Default constructor. @@ -18,7 +20,7 @@ public: /** * \brief Updates all particle emitters by emitting particles, updating particle states, and checking bounds. */ - void update(); + void update() override; private: /** @@ -68,7 +70,7 @@ private: //! Counter to count updates to determine how many times emit_particle is called. uint32_t update_count = 0; //! Determines the lowest amount of emission rate (1000 = 0.001 = 1 particle per 1000 updates). - static constexpr uint32_t MAX_UPDATE_COUNT = 100; + static constexpr unsigned int MAX_UPDATE_COUNT = 100; }; } // namespace crepe diff --git a/src/crepe/system/PhysicsSystem.h b/src/crepe/system/PhysicsSystem.h index cc13b70..038c120 100644 --- a/src/crepe/system/PhysicsSystem.h +++ b/src/crepe/system/PhysicsSystem.h @@ -1,5 +1,7 @@ #pragma once +#include "System.h" + namespace crepe { /** * \brief System that controls all physics @@ -7,18 +9,14 @@ namespace crepe { * This class is a physics system that uses a rigidbody and transform * to add physics to a game object. */ -class PhysicsSystem { +class PhysicsSystem : public System { public: - /** - * Constructor is default - */ - PhysicsSystem() = default; /** * \brief updates the physics system. * * It calculates new velocties and changes the postion in the transform. */ - void update(); + void update() override; }; } // namespace crepe -- cgit v1.2.3 From 9a95e6cb2c1f1255643d1b8996cd8eeb108c6f8c Mon Sep 17 00:00:00 2001 From: JAROWMR Date: Wed, 13 Nov 2024 19:24:32 +0100 Subject: fixed issues --- src/crepe/api/ParticleEmitter.cpp | 1 - src/crepe/api/ParticleEmitter.h | 9 ++------- src/crepe/system/ParticleSystem.cpp | 2 -- src/crepe/system/ParticleSystem.h | 7 +------ 4 files changed, 3 insertions(+), 16 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 7032f9e..43d2e69 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -1,5 +1,4 @@ #include "ParticleEmitter.h" -#include "Particle.h" using namespace crepe; diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h index 6e29e60..a9e872f 100644 --- a/src/crepe/api/ParticleEmitter.h +++ b/src/crepe/api/ParticleEmitter.h @@ -1,24 +1,21 @@ #pragma once -#include #include #include "Component.h" #include "Particle.h" -#include "Sprite.h" #include "Vector2.h" -// class Sprite; - namespace crepe { +class Sprite; + /** * \brief Data holder for particle emission parameters. * * The ParticleEmitter class stores configuration data for particle properties, * defining the characteristics and boundaries of particle emissions. */ - class ParticleEmitter : public Component { public: /** @@ -75,8 +72,6 @@ public: public: /** - * \brief Constructs a ParticleEmitter data holder with specified settings. - * * \param game_object_id Identifier for the game object using this emitter. * \param data Configuration data defining particle properties. */ diff --git a/src/crepe/system/ParticleSystem.cpp b/src/crepe/system/ParticleSystem.cpp index 4a25b47..e7a3bec 100644 --- a/src/crepe/system/ParticleSystem.cpp +++ b/src/crepe/system/ParticleSystem.cpp @@ -11,8 +11,6 @@ using namespace crepe; -ParticleSystem::ParticleSystem() {} - void ParticleSystem::update() { // Get all emitters ComponentManager & mgr = ComponentManager::get_instance(); diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h index 3a118fb..664394e 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -12,11 +12,6 @@ class Transform; */ class ParticleSystem : public System{ public: - /** - * \brief Default constructor. - */ - ParticleSystem(); - /** * \brief Updates all particle emitters by emitting particles, updating particle states, and checking bounds. */ @@ -68,7 +63,7 @@ private: private: //! Counter to count updates to determine how many times emit_particle is called. - uint32_t update_count = 0; + unsigned int update_count = 0; //! Determines the lowest amount of emission rate (1000 = 0.001 = 1 particle per 1000 updates). static constexpr unsigned int MAX_UPDATE_COUNT = 100; }; -- cgit v1.2.3 From be1e97bc7a494963ab1567492fafcda99e36f683 Mon Sep 17 00:00:00 2001 From: Loek Le Blansch Date: Wed, 13 Nov 2024 19:52:11 +0100 Subject: `make format` --- src/crepe/Particle.cpp | 4 ++-- src/crepe/Particle.h | 4 ++-- src/crepe/api/AssetManager.h | 3 ++- src/crepe/api/ParticleEmitter.cpp | 6 ++++-- src/crepe/facade/SDLContext.cpp | 2 +- src/crepe/system/ParticleSystem.h | 2 +- src/example/rendering.cpp | 4 +++- 7 files changed, 15 insertions(+), 10 deletions(-) (limited to 'src/crepe/api') diff --git a/src/crepe/Particle.cpp b/src/crepe/Particle.cpp index 1c3c138..582edf4 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 Vector2& position,const Vector2& velocity, - double angle) { +void Particle::reset(uint32_t lifespan, const Vector2 & position, + const Vector2 & velocity, double 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 8782382..3eaebc3 100644 --- a/src/crepe/Particle.h +++ b/src/crepe/Particle.h @@ -43,8 +43,8 @@ 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 Vector2& position,const Vector2& velocity, - double angle); + void reset(uint32_t lifespan, const Vector2 & position, + const Vector2 & velocity, double angle); /** * \brief Updates the particle's state. * diff --git a/src/crepe/api/AssetManager.h b/src/crepe/api/AssetManager.h index dbfaef3..86a9902 100644 --- a/src/crepe/api/AssetManager.h +++ b/src/crepe/api/AssetManager.h @@ -56,7 +56,8 @@ public: * cache. */ template - std::shared_ptr cache(const std::string & file_path, bool reload = false); + std::shared_ptr cache(const std::string & file_path, + bool reload = false); }; } // namespace crepe diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp index 43d2e69..35f960d 100644 --- a/src/crepe/api/ParticleEmitter.cpp +++ b/src/crepe/api/ParticleEmitter.cpp @@ -2,8 +2,10 @@ using namespace crepe; -ParticleEmitter::ParticleEmitter(game_object_id_t game_object_id, const Data & data) - : Component(game_object_id), data(data) { +ParticleEmitter::ParticleEmitter(game_object_id_t game_object_id, + const Data & data) + : Component(game_object_id), + data(data) { for (size_t i = 0; i < this->data.max_particles; i++) { this->data.particles.emplace_back(); } diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp index 46230b4..236bf8c 100644 --- a/src/crepe/facade/SDLContext.cpp +++ b/src/crepe/facade/SDLContext.cpp @@ -159,7 +159,7 @@ SDLContext::texture_from_path(const std::string & path) { SDL_Surface * tmp = IMG_Load(path.c_str()); if (tmp == nullptr) { - tmp = IMG_Load("../asset/texture/ERROR.png"); + tmp = IMG_Load("../asset/texture/ERROR.png"); } std::unique_ptr> diff --git a/src/crepe/system/ParticleSystem.h b/src/crepe/system/ParticleSystem.h index 664394e..d7ca148 100644 --- a/src/crepe/system/ParticleSystem.h +++ b/src/crepe/system/ParticleSystem.h @@ -10,7 +10,7 @@ class Transform; /** * \brief ParticleSystem class responsible for managing particle emission, updates, and bounds checking. */ -class ParticleSystem : public System{ +class ParticleSystem : public System { public: /** * \brief Updates all particle emitters by emitting particles, updating particle states, and checking bounds. diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp index e02f6a3..827ad07 100644 --- a/src/example/rendering.cpp +++ b/src/example/rendering.cpp @@ -34,7 +34,9 @@ int main() { } { Color color(0, 0, 0, 0); - obj1.add_component(make_shared("../asset/texture/second.png"), color, FlipSettings{true, true}); + obj1.add_component( + make_shared("../asset/texture/second.png"), color, + FlipSettings{true, true}); } /* -- cgit v1.2.3