Sprite.hpp

Go to the documentation of this file.

// Copyright 2012-2026 Jan Niklas Hasse <jhasse@bixense.com>
// For conditions of distribution and use, see copyright notice in LICENSE.txt
#pragma once
 
#include "Drawable.hpp"
#include "Finally.hpp"
#include "Rgb.hpp"
#include "Rgba.hpp"
#include "ShaderProgram.hpp"
#include "TextureFilter.hpp"
#include "Vec2.hpp"
 
#include <future>
#include <optional>
#include <vector>
 
namespace jngl {
 
class ImageData;
class Mat3;
class Texture;
struct Vertex;
 
class Sprite {
public:
    enum class LoadType : uint8_t {
        NORMAL,
        HALF,
        THREADED,
    };
 
    explicit Sprite(const ImageData&, double scale,
                    std::optional<std::string_view> filename = std::nullopt, bool mipmap = false);
 
    Sprite(const uint8_t* bytes, size_t width, size_t height, bool mipmap = false);
 
    explicit Sprite(const std::string& filename, LoadType loadType = LoadType::NORMAL,
                    bool mipmap = false);
 
    explicit Sprite(const std::string& filename, bool mipmap);
 
    void step();
 
    void draw() const;
 
    class Loader {
    public:
        explicit Loader(std::string filename, bool mipmap = false) noexcept;
 
        ~Loader() noexcept;
 
        std::shared_ptr<Sprite> shared() const;
 
        operator bool() const; // NOLINT
 
        Sprite* operator->() const;
 
    private:
        mutable std::future<std::unique_ptr<ImageData>> imageDataFuture;
        std::string filename;
        bool mipmap = false;
    };
 
    void draw(const Mat3& modelview, const ShaderProgram* shaderProgram = nullptr) const;
    void draw(Mat3 modelview, Alpha, const ShaderProgram* shaderProgram = nullptr) const;
 
    void draw(Mat3 modelview, Rgba color) const;
 
    void drawLerped(Mat3 modelview, Rgb color, float red, float green, float blue, Alpha) const;
 
    void draw(const ShaderProgram* shaderProgram) const;
 
    class Batch {
        struct Impl;
        std::unique_ptr<Impl> impl;
        friend class Sprite;
 
    public:
        explicit Batch(std::unique_ptr<Impl>);
        ~Batch();
        Batch(Batch&&) = default;
        Batch& operator=(Batch&&) = default;
        Batch(const Batch&) = delete;
        Batch& operator=(const Batch&) = delete;
 
        void draw(Mat3 modelview) const;
    };
 
    Batch batch(const ShaderProgram* shaderProgram = nullptr) const;
 
    [[deprecated("Scale the modelview matrix instead using jngl::Mat3::scale")]]
    void drawScaled(float xfactor, float yfactor,
                    const ShaderProgram* shaderProgram = nullptr) const;
 
    [[deprecated("Use new drawClipped(Vec2, Vec2) method instead")]] void
    drawClipped(float xstart, float xend, float ystart, float yend) const;
 
    void drawClipped(Vec2 start, Vec2 end) const;
 
    void drawMesh(const std::vector<Vertex>& vertexes, const ShaderProgram* = nullptr) const;
 
    void drawMesh(const Mat3& modelview, const std::vector<Vertex>& vertexes,
                  const ShaderProgram* shaderProgram = nullptr) const;
    void drawMesh(const Mat3& modelview, const std::vector<Vertex>& vertexes, jngl::Rgba color,
                  const ShaderProgram* = nullptr) const;
 
    void setBytes(const unsigned char*);
 
    static const Shader& vertexShader();
 
    std::shared_ptr<Finally> loader;
 
    // Position and size member variables (from Drawable)
    Vec2 getPos() const;
    void setPos(double x, double y);
    template <class Vect> void setPos(Vect p) {
        setPos(p.x, p.y);
    }
 
    jngl::Vec2 getCenter() const;
    void setCenter(double x, double y);
    template <class Vect> void setCenter(Vect c) {
        setCenter(c.x, c.y);
    }
 
    double getLeft() const;
    void setLeft(double x);
 
    double getTop() const;
    void setTop(double y);
 
    double getRight() const;
    void setRight(double x);
 
    double getBottom() const;
    void setBottom(double y);
 
    double getX() const;
    void setX(double);
 
    double getY() const;
    void setY(double);
 
    Vec2 getSize() const;
 
    float getWidth() const;
 
    float getHeight() const;
 
    void drawBoundingBox() const;
 
    bool contains(jngl::Vec2 point) const;
 
    void setTextureFilter(TextureFilter minification, TextureFilter magnification);
 
private:
    void enableMipmaps();
    static void cleanUpRowPointers(std::vector<unsigned char*>& buf);
    void loadTexture(int scaledWidth, int scaledHeight, const std::string& filename, bool halfLoad,
                     unsigned int format, const unsigned char* const* rowPointers,
                     const unsigned char* data = nullptr, bool mipmap = false);
    Finally LoadPNG(const std::string& filename, FILE* fp, bool halfLoad, bool mipmap);
    struct BMPHeader {
        unsigned int dataOffset;
        unsigned int headerSize;
        int width;
        int height;
        unsigned short planes;
        unsigned short bpp;
        unsigned int compression;
        unsigned int dataSize;
    };
    Finally LoadBMP(const std::string& filename, FILE* fp, bool halfLoad, bool mipmap);
#ifndef NOWEBP
    Finally LoadWebP(const std::string& filename, FILE* file, bool halfLoad, bool mipmap);
#endif
 
    std::shared_ptr<Texture> texture;
 
    // Position in screen coordinates
    Vec2 position;
 
    // Width and height in pixel, NOT screen coordinates
    float width = 0;
    float height = 0;
};
 
void draw(const std::string& filename, double x, double y);
 
template <class Vect> void draw(const std::string& filename, Vect pos) {
    draw(filename, pos.x, pos.y);
}
 
Finally load(const std::string& filename);
 
void unload(const std::string& filename);
 
void unloadAll();
 
void drawClipped(const std::string& filename, double xposition, double yposition, float xstart,
                 float xend, float ystart, float yend);
 
void setSpriteColor(unsigned char red, unsigned char green, unsigned char blue,
                    unsigned char alpha);
 
void setSpriteColor(unsigned char red, unsigned char green, unsigned char blue);
 
void setSpriteColor(Rgb);
 
void setSpriteColor(Rgba);
 
void setSpriteAlpha(unsigned char alpha);
 
void pushSpriteAlpha(unsigned char alpha = 255);
 
void popSpriteAlpha();
 
int getWidth(const std::string& filename);
 
int getHeight(const std::string& filename);
 
#if __cplusplus >= 201703L
[[nodiscard]]
#endif
Finally disableBlending();
 
Finally drawOnlyIntoAlphaChannel();
 
enum class BlendMode : uint8_t {
    Composite,
 
    Premultiplied,
 
    Additive,
 
    PremultipliedAdditive,
 
    Multiply,
 
    Screen,
};
 
#if __cplusplus >= 201703L
[[nodiscard]]
#endif
Finally setBlendMode(BlendMode);
 
} // namespace jngl