Оформление списка (вектора) объектов, содержащих текстуры и спрайты

struct Bullet
{
    static constexpr float speed = 200.0f;
 
    sf::Vector2f m_pos;
    sf::Vector2f m_dir;
    float life_time = 3.0f;
 
    Bullet() {}
    Bullet(sf::Vector2f pos, sf::Vector2f dir) : m_pos(pos), m_dir(dir) {}
 
    void update(float dt)
    {
        m_pos += m_dir * dt * speed;
        life_time -= dt;
    }
};
 
struct Pull
{
    static Pull& instance()
    {
        static std::unique_ptr<Pull> singl{ new Pull{} };
        return *singl;
    }
 
    Bullet* create(sf::Vector2f pos, sf::Vector2f dir)
    {
        Bullet* result = nullptr;
        if (!allowed.empty())
        {
            result = allowed.back();
            allowed.pop_back();
            *result = Bullet(pos, dir);
        }
        return result;
    }
 
    void destroy(Bullet* bull)
    {
        allowed.push_back(bull);
    }
 
private:
    Pull()
    {
        allowed.reserve(m_size);
        for (auto& bull : m_data)
        {
            allowed.push_back(&bull);
        }
    }
    Pull(const Pull&);
    Pull& operator=(const Pull&);
 
    static constexpr size_t m_size = 512;
    std::vector<Bullet> m_data{ m_size };
    std::vector<Bullet*> allowed;
};
 
struct Player : sf::Drawable, sf::Transformable
{
    Player(sf::Vector2f pos)
        :
        me(sf::Vector2f(20, 50)),
        bullet_sprite(10, 10)
    {
        me.setOrigin(10, 50);
        bullet_sprite.setOrigin(5, 5);
        setPosition(pos);
        bullet_sprite.setFillColor(sf::Color::Red);
    }
 
    void update(float dt)
    {
        for (size_t i{}; i < m_bullets.size();)
        {
            if (m_bullets[i]->life_time < 0)
            {
                std::swap(m_bullets[i], m_bullets.back());
                Pull::instance().destroy(m_bullets.back());
                m_bullets.pop_back();
            }
            else
            {
                m_bullets[i]->update(dt);
                ++i;
            }
        }
    }
 
    void shoot(sf::Vector2f target)
    {
        const auto pos = getPosition();
        target -= pos;
        target /= std::hypot(target.x, target.y);
        auto bull = Pull::instance().create(pos, target);
        if (bull) m_bullets.push_back(bull);
    }
 
private:
    sf::RectangleShape me;
    sf::CircleShape bullet_sprite;
    std::vector<Bullet*> m_bullets;
 
    void draw(sf::RenderTarget& target, sf::RenderStates states) const override
    {
        auto st = states;
        for (auto bull : m_bullets)
        {
            st.transform = states.transform;
            st.transform.translate(bull->m_pos);
            target.draw(bullet_sprite, st);
        }
        states.transform *= getTransform();
        target.draw(me, states);
        
    }
};
 
int main()
{
    
    sf::RenderWindow window(sf::VideoMode(800, 600), "test");
    window.setVerticalSyncEnabled(true);
 
    Player p(sf::Vector2f(400, 300));
    sf::Clock timer;
    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
        }
 
        p.update(timer.restart().asSeconds());
        auto mouse = window.mapPixelToCoords(sf::Mouse::getPosition(window));
        auto look = mouse - p.getPosition();
        const float angle = std::atan2f(look.x, look.y);
        p.setRotation(angle * -180 / 3.1416f);
        if (sf::Mouse::isButtonPressed(sf::Mouse::Left))
            p.shoot(mouse);
 
        window.clear();
        window.draw(p);
        window.display();
    }
 
    return 0;
}