Remove unneded calls from GraphicsManager interface

modes/classicmode/editor/classiceditorgraphicsmanager.cpp

@@ -0,0 +1,137 @@
+#include "classiceditorgraphicsmanager.h"
+#include "graphics/classicsprite.h"
+
+#include "graphics/classicflyinganimationscenario.h"
+#include "graphics/classicdyinganimationscenario.h"
+
+ClassicEditorGraphicsManager::ClassicEditorGraphicsManager(Timeline<MockClassicNote> &timeline, const microsec& visibility_offset) :
+    ClassicGraphicsManager(visibility_offset),
+    _timeline(&timeline)
+{
+    _timeline->expire(_first);
+    _timeline->expire(_last);
+}
+
+void ClassicEditorGraphicsManager::draw(sf::RenderTarget& target, sf::RenderStates states) const
+{
+    if (nothingToDraw())
+        return;
+
+    for (auto it = _first; it != _last; ++it)
+    {
+        (*it)->draw(this, target, states);
+    }
+}
+
+void ClassicEditorGraphicsManager::draw(const std::vector<MockClassicNote::MockElement>& elements, sf::RenderTarget& target, sf::RenderStates states) const
+{
+    for (std::size_t i = 0; i < elements.size(); ++i)
+    {
+        const auto& sprite = elements[i].sprite;
+
+        if (i >= 1)
+        {
+            const auto& neighbor_sprite = elements[i - 1].sprite;
+
+            const auto c1 = neighbor_sprite->trailCoordinates();
+            const auto c2 = sprite->trailCoordinates();
+
+            target.draw(makeLine(c1, c2));
+        }
+
+        target.draw(*sprite, states);
+    }
+}
+
+sf::VertexArray ClassicEditorGraphicsManager::makeLine(const Coordinates& c1, const Coordinates& c2) const
+{
+    sf::VertexArray line(sf::LinesStrip, 2);
+    line[0].color = sf::Color::Yellow;
+    line[0].position = {c1.x + 10, c1.y};
+    line[1].color = sf::Color::Blue;
+    line[1].position = {c2.x + 10, c2.y};
+
+    return line;
+}
+
+void ClassicEditorGraphicsManager::setGraphics(std::vector<MockClassicNote::MockElement>& elements, TimeRange &&range)
+{
+    for (auto& element : elements)
+    {
+        element.sprite = _sprite_container.getSprite(element.type);
+        element.sprite->setCoordinates(element.coordinates);
+        element.sprite->setTrailCoordinates(Coordinates( 0.f, 9.f ));
+
+        element.animations[MockClassicNote::State::NONE] = nullptr;
+        element.animations[MockClassicNote::State::FLYING] = std::make_shared<ClassicFlyingAnimationScenario>();
+        element.animations[MockClassicNote::State::DYING] = std::make_shared<ClassicDyingAnimationScenario>();
+        element.animations[MockClassicNote::State::DEAD] = nullptr;
+
+        element.animations[MockClassicNote::State::FLYING]->launch(element.sprite, range.begin, range.end);
+    }
+}
+
+void ClassicEditorGraphicsManager::update(const microsec &offset)
+{
+    fetchLastNote(offset);
+    fetchFirstNote(offset);
+
+    updateVisibleNotes(offset);
+}
+
+void ClassicEditorGraphicsManager::updateVisibleNotes(const microsec &offset)
+{
+    for (auto it = _first; it != _last; ++it)
+        (*it)->update(offset);
+}
+
+void ClassicEditorGraphicsManager::fetchFirstNote(const microsec& offset)
+{
+    (void)offset; // ????
+
+    if (nothingToDraw())
+        return;
+
+    Iterator note_iterator = _first;
+    while (note_iterator != _last)
+    {
+        auto note = *note_iterator;
+        if (note->shouldRemove())
+            ++_first;
+
+        ++note_iterator;
+    }
+}
+
+void ClassicEditorGraphicsManager::fetchLastNote(const microsec& offset)
+{
+    Iterator note_iterator = _timeline->getTopNote();
+    while (!_timeline->isExpired(note_iterator) && isVisiblyClose(note_iterator, offset))
+    {
+        if (nothingToDraw())
+            _first = note_iterator;
+
+        auto note = *note_iterator;
+
+        if (!note->isInGame())
+        {
+            note->putToGame();
+            note->setGraphics(this, TimeRange{offset, note->offset()});
+        }
+
+        ++note_iterator;
+    }
+
+    _last = note_iterator;
+}
+
+bool ClassicEditorGraphicsManager::nothingToDraw() const noexcept
+{
+    return _timeline->isExpired(_first)
+        || _timeline->isExpired(_last);
+}
+
+bool ClassicEditorGraphicsManager::isVisiblyClose(const Iterator& iterator, const microsec& music_offset) const noexcept
+{
+    return ((*iterator)->offset() - _visibility_offset) <= music_offset;
+}

modes/classicmode/editor/classiceditorgraphicsmanager.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "mockclassicnote.h"
+#include "graphics/classicgraphicsmanager.h"
+#include "core/timeline.h"
+
+#include <SFML/Graphics/RenderTarget.hpp>
+
+class ClassicSprite;
+
+class ClassicEditorGraphicsManager : public ClassicGraphicsManager
+{
+public:
+    explicit ClassicEditorGraphicsManager(Timeline<MockClassicNote>& timeline, const microsec& visibility_offset);
+    virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
+
+    void draw(const std::vector<MockClassicNote::MockElement>& elements, sf::RenderTarget& target, sf::RenderStates states) const;
+    void setGraphics(std::vector<MockClassicNote::MockElement> &elements, TimeRange&& range);
+
+    virtual void update(const microsec& offset) override;
+
+private:
+    using Iterator = Timeline<MockClassicNote>::Iterator;
+
+    Iterator _first;
+    Iterator _last;
+
+    Timeline<MockClassicNote> * const _timeline;
+
+    inline bool nothingToDraw() const noexcept;
+    inline bool isVisiblyClose(const Iterator& iterator, const microsec& music_offset) const noexcept;
+    inline sf::VertexArray makeLine(const Coordinates& c1, const Coordinates& c2) const;
+
+    void fetchFirstNote(const microsec& offset);
+    void fetchLastNote(const microsec& offset);
+    void updateVisibleNotes(const microsec& offset);
+};

modes/classicmode/editor/mockclassicnote.h

@@ -32,7 +32,6 @@ public:
     virtual void putToGame() override final;
     virtual void update(const microsec &music_offset) override final;
 
-private:
     struct MockElement
     {
         std::shared_ptr<ClassicSprite> sprite;
@@ -43,6 +42,7 @@ private:
         std::vector<Coordinates> falling_curve_interpolation;
     };
 
+private:
     std::vector<MockElement> _elements;
 
     State _state;

modes/classicmode/game/classicarrownote.cpp

@@ -1,5 +1,5 @@
 #include "classicarrownote.h"
-#include "graphics/classicgraphicsmanager.h"
+#include "game/classicgamegraphicsmanager.h"
 #include "graphics/classicanimationscenario.h"
 #include "holdmanager.h"
 
@@ -89,12 +89,12 @@ void ClassicArrowNote::update(const microsec& music_offset)
                 element.animations[_state]->update(music_offset);
 }
 
-void ClassicArrowNote::draw(const ClassicGraphicsManager * const manager, sf::RenderTarget& target, sf::RenderStates states) const
+void ClassicArrowNote::draw(const ClassicGameGraphicsManager * const manager, sf::RenderTarget& target, sf::RenderStates states) const
 {
     manager->draw(_elements, target, states);
 }
 
-void ClassicArrowNote::setGraphics(ClassicGraphicsManager * const manager, TimeRange&& range)
+void ClassicArrowNote::setGraphics(ClassicGameGraphicsManager * const manager, TimeRange&& range)
 {
     manager->setGraphics(_elements, std::move(range));
 }

modes/classicmode/game/classicarrownote.h

@@ -13,8 +13,8 @@ public:
     virtual void update(const microsec &music_offset) override;
     virtual void input(PlayerInput&& inputdata) override;
 
-    virtual void draw(const ClassicGraphicsManager * const manager, sf::RenderTarget& target, sf::RenderStates states) const override;
-    virtual void setGraphics(ClassicGraphicsManager * const manager, TimeRange&& range) override;
+    virtual void draw(const ClassicGameGraphicsManager * const manager, sf::RenderTarget& target, sf::RenderStates states) const override;
+    virtual void setGraphics(ClassicGameGraphicsManager * const manager, TimeRange&& range) override;
 
     bool allElementsPressed() const;
     bool isPressedAs(sf::Keyboard::Key key) const;

modes/classicmode/game/classicgamegraphicsmanager.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "game/classicarrownote.h"
 #include "graphics/classicgraphicsmanager.h"
 #include "core/timeline.h"
 
@@ -13,8 +14,8 @@ public:
     explicit ClassicGameGraphicsManager(Timeline<ClassicNote>& timeline, const microsec& visibility_offset);
     virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override;
 
-    virtual void draw(const std::vector<ClassicArrowNote::ArrowElement>& elements, sf::RenderTarget& target, sf::RenderStates states) const override;
-    virtual void setGraphics(std::vector<ClassicArrowNote::ArrowElement> &elements, TimeRange&& range) override;
+    void draw(const std::vector<ClassicArrowNote::ArrowElement>& elements, sf::RenderTarget& target, sf::RenderStates states) const;
+    void setGraphics(std::vector<ClassicArrowNote::ArrowElement> &elements, TimeRange&& range);
 
     virtual void update(const microsec& offset) override;
 

modes/classicmode/game/classicnote.h

@@ -7,7 +7,7 @@
 
 class ClassicSprite;
 class ClassicAnimationScenario;
-class ClassicGraphicsManager;
+class ClassicGameGraphicsManager;
 
 namespace sf { class RenderTarget; class RenderStates; }
 
@@ -44,8 +44,8 @@ public:
     virtual void input(PlayerInput&& inputdata) = 0;
 
     // encapsulate
-    virtual void draw(const ClassicGraphicsManager * const manager, sf::RenderTarget& target, sf::RenderStates states) const = 0;
-    virtual void setGraphics(ClassicGraphicsManager * const manager, TimeRange&& range) = 0;
+    virtual void draw(const ClassicGameGraphicsManager * const manager, sf::RenderTarget& target, sf::RenderStates states) const = 0;
+    virtual void setGraphics(ClassicGameGraphicsManager * const manager, TimeRange&& range) = 0;
     //
 
 protected:

modes/classicmode/graphics/classicgraphicsmanager.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "game/classicarrownote.h"
 #include "spritecontainer.h"
 #include "classicmode/classicactions.h"
 #include "graphics/classicspritefactory.h"
@@ -20,9 +19,6 @@ public:
         _visibility_offset(visibility_offset)
     {}
 
-    virtual void draw(const std::vector<ClassicArrowNote::ArrowElement>& elements, sf::RenderTarget& target, sf::RenderStates states) const = 0;
-    virtual void setGraphics(std::vector<ClassicArrowNote::ArrowElement> &elements, TimeRange&& range) = 0;
-
     virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const override = 0;
     virtual void update(const microsec& offset) = 0;
 

modes/classicmode/shared/classicmode/classicfactory.h

@@ -3,11 +3,8 @@
 #include <memory>
 
 class Game;
-class Music;
 class Editor;
 
-namespace sf { class RenderWindow; }
-
 namespace classic
 {
     std::unique_ptr<Game> initGame();