components.hpp

Go to the documentation of this file.

#pragma once
#include "../definitions.hpp"
#include "../../services/services.hpp"
#include "../../services/input/keycode.hpp"
#include "../../services/input/input.hpp"
#include "../ui/definitions.hpp"
#include "backend/core/signal.hpp"
#include <cereal/types/map.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/string.hpp>
 
class Node; // Forward declaration'
 
struct Component
{
    virtual ~Component() = default;
    virtual void update(float deltaTime) {};
    virtual void render(std::shared_ptr<Window> window) {};
    virtual void initialize() {};
    virtual void physicsUpdate() {};
    virtual void input(InputEvent &event) {};
    virtual void postLoad() {};
    virtual void exit() {};
 
    Node *getNode() const;
    void setNode(Node *n);
 
    template <class Archive>
    void save(Archive &ar) const {}
 
    template <class Archive>
    void load(Archive &ar) {}
 
private:
    Node *node;
};
 
class Sprite : public Component
{
public:
    Sprite();
    explicit Sprite(const std::string &texturePath, std::shared_ptr<Window> window, TextureScaling scaling = TextureScaling::NEAREST);
 
    void postLoad() override;
    void render(std::shared_ptr<Window>) override;
    void initialize() override;
 
    Vector2 origin = {0.5f, 0.5f};
    Texture texture;
 
    Rect sourceRect;
    bool visible = true;
    // int zIndex = 1;
    bool screenSpace = false;
    Color modulate = Color::WHITE;
 
    bool flipH = false;
    bool flipV = false;
 
    template <class Archive>
    void save(Archive &ar) const
    {
        ar(CEREAL_NVP(origin), CEREAL_NVP(sourceRect), CEREAL_NVP(visible), CEREAL_NVP(texture), CEREAL_NVP(screenSpace), CEREAL_NVP(modulate), CEREAL_NVP(flipH), CEREAL_NVP(flipV));
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        std::cout << "LOADING SPRITE" << std::endl;
        ar(CEREAL_NVP(origin), CEREAL_NVP(sourceRect), CEREAL_NVP(visible), CEREAL_NVP(texture), CEREAL_NVP(screenSpace), CEREAL_NVP(modulate), CEREAL_NVP(flipH), CEREAL_NVP(flipV));
    }
};
 
class AnimatedSprite : public Component
{
public:
    AnimatedSprite() = default;
    AnimatedSprite(std::shared_ptr<Window> window) : window(window) {};
 
    void initialize() override;
    void render(std::shared_ptr<Window>) override;
    void update(float deltaTime) override;
 
    void addAnimation(const Animation &animation);
    void removeAnimation(const std::string &name);
 
    void play(const std::string &animation);
    void stop();
    void pause();
 
    Signal<std::string> changed;
    Signal<std::string> finished;
    Signal<std::string> looped;
    Signal<std::string> stopped;
    Signal<std::string> paused;
 
    bool flipH = false;
    bool flipV = false;
 
    const Texture *getCurrentTexture() const;
    Vector2 getCurrentSize() const;
    bool isPlaying() const;
    Frame *getCurrentFrame() const;
 
    std::string getCurrentAnimationName() const;
    Animation *getCurrentAnimation() const;
 
    std::map<std::string, Animation> animations;
    bool visible = true;
    // int zIndex = 1; I'm not implementing this rn
    bool screenSpace = false;
 
    template <class Archive>
    void save(Archive &ar) const
    {
        std::string currentAnimName = currentAnimation ? currentAnimation->name : std::string("");
        ar(CEREAL_NVP(animations), CEREAL_NVP(visible), CEREAL_NVP(screenSpace),
           CEREAL_NVP(frame), CEREAL_NVP(playing), currentAnimName);
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        std::string currentAnimName;
        ar(CEREAL_NVP(animations), CEREAL_NVP(visible), CEREAL_NVP(screenSpace),
           CEREAL_NVP(frame), CEREAL_NVP(playing), currentAnimName);
        
        saveCurrentAnimName = currentAnimName;
    }
 
    void postLoad();
private:
    float elapsed = 0.0f;
    int frame = 0;
    std::unique_ptr<Animation> currentAnimation = nullptr;
    
    std::string saveCurrentAnimName;
    Texture currentTexture;
    bool playing = false;
    std::shared_ptr<Window> window = nullptr;
};
 
class Tilemap : public Component
{
public:
    Tilemap() = default;
    Tilemap(const std::string &texturePath, Vector2 tileSize, std::shared_ptr<Window> window, TextureScaling scaling = TextureScaling::PIXELART);
 
    bool visible = true;
    Texture texture;
    Vector2 tileSize;
    std::vector<Tile> tiles;
 
    // sdl bullshit
    std::vector<SDL_Vertex> vertexBuffer;
    std::vector<int> indexBuffer;
 
    int addTile(const Tile &tile);
    void removeTile(int index);
 
    template <typename... Args>
    void addTiles(Args... tiles)
    {
        (this->tiles.push_back(tiles), ...);
        dirty = true;
    }
 
    void update();
    void render(std::shared_ptr<Window>) override;
    void initialize() { bake(); };
    void bake();
 
    template <class Archive>
    void save(Archive &ar) const
    {
        ar(CEREAL_NVP(visible), CEREAL_NVP(texture), CEREAL_NVP(tileSize), CEREAL_NVP(tiles));
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        ar(CEREAL_NVP(visible), CEREAL_NVP(texture), CEREAL_NVP(tileSize), CEREAL_NVP(tiles));
        bake();
    }
 
private:
    bool dirty = false;
};
 
class Script : public Component
{
public:
    virtual void update(float deltaTime) {};
    virtual void initialize() {};
    virtual void physicsUpdate() {};
    virtual void render(std::shared_ptr<Window> window) {};
    virtual void exit() {};
 
    template <class Archive>
    void save(Archive &ar) const {};
 
    template <class Archive>
    void load(Archive &ar) {};
};
 
class Camera : public Component
{
public:
    void setActive();
    bool active = true;
    Vector2 origin = {0.5f, 0.5f};
    float smoothing = 0.0f;
 
    void update(float deltaTime) override;
    void initialize() override;
 
    Vector2 getGlobalPosition();
    Transform getCameraTransform() const;
    Vector2 screenToWorld(Vector2 screen) const;
 
    template <class Archive>
    void save(Archive &ar) const
    {
        ar(CEREAL_NVP(active), CEREAL_NVP(origin));
    }
 
    template <class Archive>
    void load(Archive &ar)
    {
        ar(CEREAL_NVP(active), CEREAL_NVP(origin));
    }
 
private:
    Vector2 globalPos = Vector2{0.0f, 0.0f};
};