ge211_sprites.hxx

#pragma once
 
#include "ge211_color.hxx"
#include "ge211_forward.hxx"
#include "ge211_geometry.hxx"
#include "ge211_noexcept.hxx"
#include "ge211_time.hxx"
#include "ge211_render.hxx"
#include "ge211_resource.hxx"
 
#include <vector>
#include <sstream>
 
namespace ge211 {
 
namespace sprites {
 
class Sprite
{
public:
    virtual Dims<int> dimensions() const = 0;
 
    virtual ~Sprite() {}
 
private:
    friend class detail::Engine;
    friend struct detail::Placed_sprite;
    friend Multiplexed_sprite;
 
    virtual void render(detail::Renderer&,
                        Posn<int>,
                        Transform const&) const = 0;
 
    virtual void prepare(detail::Renderer const&) const {}
};
 
} // end namespace sprites
 
namespace detail {
 
// A `Texture_sprite` is a `Sprite` that can be rendered by copying
// a texture. Instead of specifying how to render themselves directly,
// derived classes must specify how to get a `Texture` representing
// the sprite. The dimensions of the sprite are the dimensions of the
// resulting texture. The return type of `Texture const&` means that
// `get_texture_` cannot just create and return a texture, but must
// store it somewhere. This is because `Texture`s will usually be
// cached. (Otherwise, you wouldn't use a `Texture_sprite`.)
class Texture_sprite : public Sprite
{
public:
    Dims<int> dimensions() const override;
 
private:
    void render(detail::Renderer&, Posn<int>, Transform const&) const override;
    void prepare(detail::Renderer const&) const override;
 
    virtual Texture const& get_texture_() const = 0;
};
 
} // end namespace detail
 
namespace internal {
 
class Render_sprite : public detail::Texture_sprite
{
protected:
    explicit Render_sprite(Dims<int>);
 
    bool can_paint() const;
 
    void fill_surface(Color);
 
    void fill_rectangle(Rect<int>, Color);
 
    void set_pixel(Posn<int>, Color);
 
    Borrowed<SDL_Surface> raw_surface();
 
private:
    detail::Texture texture_;
 
    detail::Texture const& get_texture_() const override;
 
    void fill_rectangle_(Rect<int>, Color, char const* who);
 
    Borrowed<SDL_Surface> raw_surface_(char const* who);
 
    static detail::Uniq_SDL_Surface
    create_surface_(Dims<int>);
};
 
} // end namespace internal
 
namespace sprites {
 
class Rectangle_sprite : public internal::Render_sprite
{
public:
    explicit Rectangle_sprite(Dims<int>, Color = Color::white());
 
    void recolor(Color);
};
 
class Circle_sprite : public internal::Render_sprite
{
public:
    explicit Circle_sprite(int radius, Color = Color::white());
 
    void recolor(Color);
 
private:
    int radius_() const;
};
 
class Image_sprite : public detail::Texture_sprite
{
public:
    explicit Image_sprite(std::string const& filename);
 
private:
    detail::Texture const& get_texture_() const override;
 
    static detail::Texture load_texture_(std::string const& filename);
 
    detail::Texture texture_;
};
 
class Text_sprite : public detail::Texture_sprite
{
public:
    Text_sprite();
 
    Text_sprite(std::string const&, Font const&);
 
    bool empty() const;
 
    explicit operator bool() const;
 
    // Defined below.
    class Builder;
 
    void reconfigure(Builder const&);
 
private:
    explicit Text_sprite(Builder const&);
 
    void assert_initialized_() const;
 
    detail::Texture const& get_texture_() const override;
 
    static detail::Texture create_texture(Builder const&);
 
    detail::Texture texture_;
};
 
class Text_sprite::Builder
{
public:
 
    explicit Builder(Font const&);
 
    Text_sprite build() const;
 
 
 
    template <typename PRINTABLE>
    Builder& add_message(PRINTABLE const& value)
    {
        message_ << value;
        return *this;
    }
 
    template <typename PRINTABLE>
    Builder& operator<<(PRINTABLE const& value)
    {
        return add_message(value);
    }
 
    Builder& message(std::string const&);
    Builder& font(Font const&);
    Builder& color(Color);
    Builder& antialias(bool);
    Builder& word_wrap(int);
 
 
 
    std::string message() const;
    Font const& font() const;
    Color color() const;
    bool antialias() const;
    int word_wrap() const;
 
 
private:
    std::ostringstream message_;
    const Font* font_;
    Color color_;
    bool antialias_;
    uint32_t word_wrap_;
};
 
class Multiplexed_sprite : public Sprite
{
public:
    void reset();
 
protected:
    virtual const Sprite& select_(Duration age) const = 0;
 
private:
    void render(detail::Renderer& renderer, Posn<int> position,
                Transform const& transform) const override;
 
    Timer since_;
};
 
} // end namespace sprites
 
namespace detail {
 
struct Placed_sprite
{
    const Sprite* sprite;
    Posn<int> xy;
    int z;
    Transform transform;
 
    Placed_sprite(Sprite const&, Posn<int>, int, Transform const&) NOEXCEPT;
 
    void render(Renderer&) const;
};
 
bool operator<(Placed_sprite const&, Placed_sprite const&) NOEXCEPT;
 
} // end namespace detail
 
class Sprite_set
{
public:
    Sprite_set& add_sprite(Sprite const& sprite,
                           Posn<int> xy,
                           int z = 0,
                           Transform const& transform = Transform());
 
private:
    friend class detail::Engine;
 
    Sprite_set();
    std::vector<detail::Placed_sprite> sprites_;
};
 
}