Added and tested animations

Reworked and reverted animations, that can be preloaded

Author: kolyaka32

ani/menu.gif

@@ -8,19 +8,29 @@
 #if (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)
 
 
-GUI::Animation::Animation(SDL_Rect _rect, ANI_names _type)
-: dest(_dest), type(_type), frame(0), prevTick(0) {}
+GUI::Animation::Animation(const Window& _window, float _X, float _Y, float _W, float _H, Animations _type)
+: Animation(_window, {_X*window.getWidth(), _Y*window.getHeight(), _W*window.getWidth(), _H*window.getHeight()}, _type) {}
+
+GUI::Animation::Animation(const Window& _window, const SDL_FRect& _dest, Animations _type)
+: TextureTemplate(_window),
+type(_type),
+prevTick(0),
+animation(window.getAnimation(_type)) {
+    rect = _dest;
+    texture = window.createTexture(animation->frames[0]);
+    prevTick = getTime() + animation->delays[0];
+}
 
 GUI::Animation::~Animation() {
     SDL_DestroyTexture(texture);
 }
 
-void GUI::Animation::blit() {
+void GUI::Animation::update() {
     if (SDL_GetTicks() > prevTick) {
-        static unsigned frame = (frame + 1) % Animations[type]->count;
-        window.destroy(texture);
-        texture = window.createTexture(Animations[type]->frames[frame], false);
-        prevTick = SDL_GetTicks() + Animations[type]->delays[frame] / 2;
+        frame = (frame + 1) % animation->count;
+        SDL_DestroyTexture(texture);
+        texture = window.createTexture(animation->frames[frame]);
+        prevTick = getTime() + animation->delays[frame];
     }
 }
 

src/GUI/animation.cpp

@@ -95,14 +95,16 @@ namespace GUI {
     #if (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)
     class Animation : public TextureTemplate {
      private:
-        const Uint8 type;
-        Uint64 prevTick;
-        const SDL_FRect dest;
+        const Animations type;
+        const IMG_Animation* animation;
+        unsigned frame = 0;
+        timer prevTick;
 
      public:
-        Animation(const Window& window, SDL_FRect destination, ANI_names type);
+        Animation(const Window& window, float X, float Y, float width, float height, Animations type);
+        Animation(const Window& window, const SDL_FRect& destination, Animations type);
         ~Animation();
-        void blit() const;
+        void update();
     };
     #endif
 

src/GUI/baseGUI.hpp

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2024-2025, Kazankov Nikolay
+ * <nik.kazankov.05@mail.ru>
+ */
+
+#include "animationsNames.hpp"
+
+
+// Check, if can load animations and should preload it
+#if (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)
+
+
+// File names of the corresponding textures
+const char* animationsFilesNames[unsigned(Animations::Count)] = {
+    "ani/menu.gif",
+};
+
+#endif  // (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)

src/animationsNames.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2024-2025, Kazankov Nikolay
+ * <nik.kazankov.05@mail.ru>
+ */
+
+#pragma once
+
+#include "define.hpp"
+
+
+// Check, if can load animations and should preload it
+#if (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)
+
+
+// Names of all images with related numbers
+enum class Animations : unsigned {
+    // Base part
+    Menu,
+
+    // Count of all animations
+    Count,
+};
+
+// File names of the corresponding animations
+extern const char* animationsFilesNames[unsigned(Animations::Count)];
+
+#endif  // (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)

src/animationsNames.hpp

@@ -5,14 +5,15 @@
 
 #pragma once
 
-#include <SDL3/SDL_log.h>
+#include "logger.hpp"
+
+// Custom exceptions
+#if (CHECK_CORRECTION)
+
 #include <stdexcept>
 #include <string>
-#include "logger.hpp"
 
 
-// Custom exceptions
-#if CHECK_CORRECTION
 // Any error of loading
 class LoadException : public std::exception {
  protected:
@@ -47,4 +48,5 @@ class DataLoadException : LoadException {
         return message;
     }
 };
-#endif
+
+#endif  // (CHECK_CORRECTION)

src/data/exceptions.hpp

@@ -12,7 +12,7 @@
 
 Libraries::Libraries() {
     // Load depend on testing
-    #if CHECK_CORRECTION
+    #if (CHECK_CORRECTION)
     // Initialasing main library
     if (!SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO)) {
         throw LibararyLoadException("Main library: " + std::string(SDL_GetError()));
@@ -39,7 +39,7 @@ Libraries::Libraries() {
     }
     #endif
     logAdditional("Libraries load correctly");
-    #else  // CHECK_CORRECTION
+    #else  // (CHECK_CORRECTION)
     SDL_Init(SDL_INIT_AUDIO | SDL_INIT_VIDEO);
     #if USE_SDL_FONT
     TTF_Init();
@@ -49,7 +49,7 @@ Libraries::Libraries() {
     audioDeviceID = SDL_OpenAudioDevice(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, NULL);
     Mix_OpenAudio(audioDeviceID, NULL);
     #endif
-    #endif  // CHECK_CORRECTION
+    #endif  // (CHECK_CORRECTION)
 }
 
 Libraries::~Libraries() noexcept {

src/data/libraries.cpp

@@ -12,7 +12,7 @@
 // Function for log important information
 template <typename ...Args>
 void logImportant(const char* text, const Args& ...args) {
-    #if CHECK_CORRECTION
+    #if (CHECK_CORRECTION)
     // Writing to stdout
     SDL_Log(text, args...);
     #endif

src/data/logger.hpp

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2024-2025, Kazankov Nikolay
+ * <nik.kazankov.05@mail.ru>
+ */
+
+#include "animations.hpp"
+
+#if (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)
+
+#include "loader/loader.hpp"
+#include "../exceptions.hpp"
+
+
+AnimationsData::AnimationsData() {
+    // Resetting texture array
+    #if (CHECK_CORRECTION)
+    for (unsigned i=0; i < unsigned(Animations::Count); ++i) {
+        animations[i] = nullptr;
+    }
+    #endif
+
+    // Loading all needed textures
+    for (unsigned i=0; i < unsigned(Animations::Count); ++i) {
+        loadAnimation(Animations(i), animationsFilesNames[i]);
+    }
+
+    // Checking massive on loading correction
+    #if (CHECK_CORRECTION)
+    for (unsigned i=0; i < unsigned(Animations::Count); ++i) {
+        if (animations[i] == nullptr) {
+            throw DataLoadException(animationsFilesNames[i]);
+        }
+    }
+    logAdditional("Animations loaded corretly");
+    #endif
+}
+
+AnimationsData::~AnimationsData() {
+    // Closing all animations
+    for (unsigned i=0; i < unsigned(Animations::Count); ++i) {
+        IMG_FreeAnimation(animations[i]);
+    }
+}
+
+void AnimationsData::loadAnimation(Animations _index, const char* _fileName) {
+    // Load data of current texture
+    SDL_IOStream* data = dataLoader.load(_fileName);
+
+    // Creating texture
+    animations[unsigned(_index)] = IMG_LoadAnimation_IO(data, true);
+
+    // Checking correction of loaded texture
+    #if (CHECK_CORRECTION)
+    if (animations[unsigned(_index)] == nullptr) {
+        throw DataLoadException(_fileName);
+    }
+    #endif
+}
+
+IMG_Animation* AnimationsData::operator[] (Animations _index) const {
+    return animations[unsigned(_index)];
+}
+
+#endif  // (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)

src/data/preloaded/animations.cpp

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2024-2025, Kazankov Nikolay
+ * <nik.kazankov.05@mail.ru>
+ */
+
+#pragma once
+
+#include "../../animationsNames.hpp"
+
+// Check, if can load animations and should preload it
+#if (USE_SDL_IMAGE) && (PRELOAD_ANIMATIONS)
+#include <SDL3_image/SDL_image.h>
+
+
+// Class for load, get and clear preloaded animations
+class AnimationsData {
+ private:
+    IMG_Animation* animations[unsigned(Animations::Count)];
+    void loadAnimation(Animations name, const char* fileName);
+
+ public:
+    explicit AnimationsData();
+    ~AnimationsData();
+    IMG_Animation* operator[] (Animations name) const;
+};
+
+#endif  // (USE_SDL_IMAGE) && (PRELOAD_TEXTURES)