Implement user sprite manager and factory

Author: kblaschke

src/libprojectM/UserSprites/Factory.cpp

@@ -1,15 +1,24 @@
-#include "Factory.hpp"
+#include "UserSprites/Factory.hpp"
+
+#include "UserSprites/MilkdropSprite.hpp"
+
+#include <Utils.hpp>
 
 namespace libprojectM {
 namespace UserSprites {
 
-Factory::Factory()
+auto Factory::CreateSprite(const std::string& type) -> Sprite::Ptr
 {
-}
+    const auto lowerCaseType = Utils::ToLower(type);
 
-Factory::~Factory()
-{
+    if (lowerCaseType == "milkdrop")
+    {
+        return std::make_unique<MilkdropSprite>();
+    }
+
+    return {};
 }
 
+
 } // namespace UserSprites
 } // namespace libprojectM

src/libprojectM/UserSprites/Factory.hpp

@@ -1,16 +1,19 @@
 #pragma once
 
+#include "UserSprites/Sprite.hpp"
+
+#include <memory>
+#include <string>
+
 namespace libprojectM {
 namespace UserSprites {
 
 class Factory
 {
 public:
-    Factory();
-
-    virtual ~Factory();
+    Factory() = delete;
 
-private:
+    static auto CreateSprite(const std::string& type) -> Sprite::Ptr;
 };
 
 } // namespace UserSprites

src/libprojectM/UserSprites/SpriteManager.cpp

@@ -1,14 +1,143 @@
-#include "SpriteManager.hpp"
+#include "UserSprites/SpriteManager.hpp"
+
+#include "UserSprites/Factory.hpp"
+
+#include <Renderer/Shader.hpp>
+
+#include <algorithm>
 
 namespace libprojectM {
 namespace UserSprites {
 
-SpriteManager::SpriteManager()
+auto SpriteManager::Spawn(const std::string& type,
+                          const std::string& spriteData,
+                          const Renderer::RenderContext& renderContext) -> uint32_t
+{
+    // If user set the limit to zero, don't bother.
+    if (m_spriteSlots == 0)
+    {
+        return 0;
+    }
+
+    auto sprite = Factory::CreateSprite(type);
+
+    if (!sprite)
+    {
+        return 0;
+    }
+
+    try
+    {
+        sprite->Init(spriteData, renderContext);
+    }
+    catch (SpriteException& ex)
+    {
+        return 0;
+    }
+    catch (Renderer::ShaderException& ex)
+    {
+        return 0;
+    }
+    catch (...)
+    {
+        return 0;
+    }
+
+    auto spriteIdentifier = GetLowestFreeIdentifier();
+
+    // Already at max sprites, destroy the oldest sprite to make room.
+    if (m_sprites.size() == m_spriteSlots)
+    {
+        Destroy(m_sprites.front().first);
+    }
+
+    m_sprites.emplace_back(spriteIdentifier, std::move(sprite));
+    m_spriteIdentifiers.insert(spriteIdentifier);
+
+    return spriteIdentifier;
+}
+
+void SpriteManager::Draw(const Audio::FrameAudioData& audioData,
+                         const Renderer::RenderContext& renderContext,
+                         uint32_t outputFramebufferObject,
+                         Sprite::PresetList presets)
+{
+    for (auto& idAndSprite : m_sprites) {
+        idAndSprite.second->Draw(audioData, renderContext, outputFramebufferObject, presets);
+
+        if (idAndSprite.second->Done())
+        {
+            Destroy(idAndSprite.first);
+        }
+    }
+}
+
+void SpriteManager::Destroy(SpriteIdentifier spriteIdentifier)
+{
+    if (m_spriteIdentifiers.find(spriteIdentifier) == m_spriteIdentifiers.end())
+    {
+        return;
+    }
+
+    m_spriteIdentifiers.erase(spriteIdentifier);
+    m_sprites.remove_if([spriteIdentifier](const auto& idAndSprite) {
+        return idAndSprite.first == spriteIdentifier;
+    });
+}
+
+void SpriteManager::DestroyAll()
+{
+    m_spriteIdentifiers.clear();
+    m_sprites.clear();
+}
+
+auto SpriteManager::ActiveSpriteCount() const -> uint32_t
 {
+    return m_sprites.size();
 }
 
-SpriteManager::~SpriteManager()
+auto SpriteManager::ActiveSpriteIdentifiers() const -> std::vector<SpriteIdentifier>
 {
+    std::vector<SpriteIdentifier> identifierList;
+    for (auto& idAndSprite : m_sprites) {
+        identifierList.emplace_back(idAndSprite.first);
+    }
+
+    return identifierList;
+}
+
+void SpriteManager::SpriteSlots(uint32_t slots)
+{
+    m_spriteSlots = slots;
+
+    // Remove excess sprites if limit was lowered
+    while (m_sprites.size() > slots)
+    {
+        m_spriteIdentifiers.erase(m_sprites.front().first);
+        m_sprites.pop_front();
+    }
+}
+
+auto SpriteManager::SpriteSlots() const -> uint32_t
+{
+    return m_spriteSlots;
+}
+
+auto SpriteManager::GetLowestFreeIdentifier() -> SpriteIdentifier
+{
+    SpriteIdentifier lowestId = 0;
+
+    for (const auto& spriteId : m_spriteIdentifiers)
+    {
+        if (spriteId > lowestId + 1)
+        {
+            return lowestId + 1;
+        }
+
+        lowestId = spriteId;
+    }
+
+    return lowestId + 1;
 }
 
 } // namespace UserSprites

src/libprojectM/UserSprites/SpriteManager.hpp

@@ -1,44 +1,56 @@
 #pragma once
 
-#include "Sprite.hpp"
+#include "UserSprites/Sprite.hpp"
+
+#include <Renderer/RenderContext.hpp>
 
 #include <cstdint>
 #include <list>
+#include <set>
+#include <utility>
+#include <vector>
 
 namespace libprojectM {
 namespace UserSprites {
 
 class SpriteManager
 {
 public:
-    SpriteManager();
-
-    virtual ~SpriteManager();
+    using SpriteIdentifier = uint32_t;
 
     /**
      * @brief Spawns a new sprite.
+     * @param type The type name of the sprite.
+     * @param spriteData The sprite code/data, depending on the type.
+     * @return A unique, non-zero identifier if the sprite was successfully spawned, or zero if an error occurred.
      */
-    void Spawn();
+    auto Spawn(const std::string& type,
+               const std::string& spriteData,
+               const Renderer::RenderContext& renderContext) -> SpriteIdentifier;
 
     /**
      * @brief Draws all active sprites.
+     * @param audioData The frame audio data structure.
+     * @param renderContext The current frame's rendering context.
+     * @param outputFramebufferObject Framebuffer object the sprite will be rendered to.
+     * @param presets The active preset, plus eventually the transitioning one. Used for the burn-in effect.
      */
-    void Draw();
+    void Draw(const Audio::FrameAudioData& audioData,
+              const Renderer::RenderContext& renderContext,
+              uint32_t outputFramebufferObject,
+              Sprite::PresetList presets);
 
     /**
-     * @brief Queues a single active sprite for destruction.
-     *
-     * The index is the 0-based index of the sprite in the list of currently active sprites, with 0 being the
-     * oldest sprite being displayed. Sprites marked for destruction will be removed when drawing the next frame.
+     * @brief Destroys a single active sprite.
      *
-     * If spriteIndex is larger than the maximum index available, no action is taken.
+     * If spriteIdentifier is invalid, no action will be taken.
      *
-     * @param spriteIndex The slot index of the sprite to destroy.
+     * @param spriteIdentifier The identifier of the sprite to destroy.
      */
-    void Destroy(uint32_t spriteIndex);
+    void Destroy(SpriteIdentifier spriteIdentifier);
 
     /**
-     * @brief Marks all active sprites for destruction.
+     * @brief Destroys all active sprites.
      *
      * Sprites will be removed when drawing the next frame.
      */
@@ -48,12 +60,18 @@ class SpriteManager
      * @brief Returns the current number of active sprites.
      * @return The current number of active sprites.
      */
-    auto ActiveSprites() const -> uint32_t;
+    auto ActiveSpriteCount() const -> uint32_t;
+
+    /**
+     * @brief Returns a set of identifiers for all active sprites.
+     * @return A vector with the identifiers of all active sprites.
+     */
+    auto ActiveSpriteIdentifiers() const -> std::vector<SpriteIdentifier>;
 
     /**
-     * @brief Sets the numer of available sprite slots, e.g. the number of concurrently active sprites.
+     * @brief Sets the number of available sprite slots, e.g. the number of concurrently active sprites.
      * If there are more active sprites than the newly set limit, the oldest sprites will be destroyed
-     * when drawing the next frame until the new limit it met.
+     * in order until the new limit is matched.
      * @param slots The maximum number of active sprites. 0 disables user sprites. Default is 16.
      */
     void SpriteSlots(uint32_t slots);
@@ -65,8 +83,17 @@ class SpriteManager
     auto SpriteSlots() const -> uint32_t;
 
 private:
-    uint32_t m_spriteSlots{16};       //!< Max number of active sprites.
-    std::list<Sprite::Ptr> m_sprites; //!< Active sprites.
+    using SpriteIdPair = std::pair<SpriteIdentifier, Sprite::Ptr>;
+
+    /**
+     * Returns the lowest free ID, starting at 1.
+     * @return The lowest available/unused sprite ID.
+     */
+    SpriteIdentifier GetLowestFreeIdentifier();
+
+    uint32_t m_spriteSlots{16};                     //!< Max number of active sprites.
+    std::set<SpriteIdentifier> m_spriteIdentifiers; //!< Set to keep track of ordered sprite IDs.
+    std::list<SpriteIdPair> m_sprites;              //!< Active sprites with their identifier.
 };
 
 } // namespace UserSprites