scenes.hpp

Go to the documentation of this file.

#pragma once
 
extern "C" {
    #include "cmdfx/core/scenes.h"
}
 
#include "cmdfx/core/builder.hpp"
#include <string>
#include <vector>
#include <memory>
 
namespace CmdFX {

    class Scene final {
        private:
            CmdFX_Scene* scene;
 
        public:
            Scene(CmdFX_Scene* scene) : scene(scene) {}
            Scene(int width, int height) {
                scene = Scene_create(width, height);
            }
            Scene(int width, int height, char c, char* ansi, int z) {
                scene = Scene_createFilled(width, height, c, ansi, z);
            }
            Scene(std::vector<std::string> data, std::vector<std::vector<std::string>> ansi) {
                scene = Scene_createFromData(to2DArray(data), to3DArray(ansi));
            }
            Scene(char** data, char*** ansi) {
                scene = Scene_createFromData(data, ansi);
            }
 
            ~Scene() {
                if (scene) { Scene_free(scene); }
            }

            CmdFX_Scene* getScene() { return scene; }
 
            int getX() const {
                return scene->x;
            }
 
            int getY() const {
                return scene->y;
            }
 
            int getWidth() const {
                return scene->width;
            }
 
            int getHeight() const {
                return scene->height;
            }
 
            int getZ() const {
                return scene->z;
            }

            int getUniqueId() const {
                return scene->uid;
            }

            std::vector<std::string> getData() {
                std::vector<std::string> data;
                for (int i = 0; i < scene->height; i++) {
                    data.push_back(std::string(scene->data[i]));
                }
                return data;
            }
 
            int setData(char** data) {
                return Scene_setData(scene, data);
            }

            int setData(std::vector<std::string> data) {
                char** text = to2DArray(data);
                return Scene_setData(scene, text);
            }

            std::vector<std::vector<std::string>> getAnsi() {
                std::vector<std::vector<std::string>> ansi;
                for (int i = 0; i < scene->height; i++) {
                    std::vector<std::string> row;
                    for (int j = 0; j < scene->width; j++) {
                        row.push_back(std::string(scene->ansiData[i][j]));
                    }
                    ansi.push_back(row);
                }
                return ansi;
            }
 
            int setAnsi(char*** ansi) {
                return Scene_setAnsiData(scene, ansi);
            }

            int setAnsi(std::vector<std::vector<std::string>> ansi) {
                char*** ansiData = to3DArray(ansi);
                return Scene_setAnsiData(scene, ansiData);
            }
 
            int appendAnsi(char*** ansi) {
                return Scene_appendAnsiData(scene, ansi);
            }

            int appendAnsi(std::vector<std::vector<std::string>> ansi) {
                char*** ansiData = to3DArray(ansi);
                return Scene_appendAnsiData(scene, ansiData);
            }
 
            int setForeground(int x, int y, int width, int height, int rgb) {
                return Scene_setForeground(scene, x, y, width, height, rgb);
            }
 
            int setForegroundAll(int rgb) {
                return Scene_setForegroundAll(scene, rgb);
            }
 
            int setBackground(int x, int y, int width, int height, int rgb) {
                return Scene_setBackground(scene, x, y, width, height, rgb);
            }
 
            int setBackgroundAll(int rgb) {
                return Scene_setBackgroundAll(scene, rgb);
            }
 
            int clear() {
                return Scene_clear(scene);
            }
 
            int draw(int x, int y) {
                return Scene_draw(scene, x, y);
            }
 
            int drawPortion(int x, int y, int sx, int sy, int width, int height) {
                return Scene_drawPortion(scene, x, y, sx, sy, width, height);
            }
 
            bool isOnTop() const {
                return Scene_isOnTop(scene);
            }
 
            bool isOnTopAt(int x, int y) const {
                return Scene_isOnTopAt(scene, x, y);
            }
 
            bool isOnBottom() const {
                return Scene_isOnBottom(scene);
            }
 
            bool isOnBottomAt(int x, int y) const {
                return Scene_isOnBottomAt(scene, x, y);
            }
 
            int remove() {
                return Scene_remove(scene);
            }
 
            bool isEmpty() const {
                return Scene_isEmpty(scene);
            }
 
            int switchTo(int x, int y) {
                return Scene_switchTo(scene, x, y);
            }
 
            static std::unique_ptr<Scene> getSceneAt(int x, int y) {
                CmdFX_Scene* foundScene = Scene_getSceneAt(x, y);
                if (foundScene == nullptr) return nullptr;
                return std::make_unique<Scene>(foundScene);
            }

            int registerScene() {
                return Scene_register(scene);
            }

            int unregisterScene() {
                return Scene_unregister(scene);
            }
 
            static int drawRegistered(int uid, int x, int y) {
                return Scene_drawRegistered(uid, x, y);
            }
 
            static int switchToRegistered(int uid, int x, int y) {
                return Scene_switchToRegistered(uid, x, y);
            }
 
            static int scroll(int uid, int dx, int dy) {
                return Scene_scroll(uid, dx, dy);
            }

            int scroll(int dx, int dy) {
                if (scene->uid < 0) return -1;
                return Scene_scroll(scene->uid, dx, dy);
            }
    };
 
    namespace Canvas {
        
        std::vector<std::unique_ptr<Scene>> getDrawnScenes() {
            std::vector<std::unique_ptr<Scene>> scenes;
            CmdFX_Scene** drawnScenes = Canvas_getDrawnScenes();
            for (int i = 0; i < Canvas_getDrawnScenesCount(); i++) {
                scenes.push_back(std::make_unique<Scene>(drawnScenes[i]));
            }
            return scenes;
        }

        int getDrawnScenesCount() {
            return Canvas_getDrawnScenesCount();
        }

        std::vector<std::unique_ptr<Scene>> getRegisteredScenes() {
            std::vector<std::unique_ptr<Scene>> scenes;
            CmdFX_Scene** registeredScenes = Scene_getRegisteredScenes();
            for (int i = 0; i < Scene_getRegisteredScenesCount(); i++) {
                scenes.push_back(std::make_unique<Scene>(registeredScenes[i]));
            }
            return scenes;
        }

        int getRegisteredScenesCount() {
            return Scene_getRegisteredScenesCount();
        }

        std::unique_ptr<Scene> getRegisteredScene(int uid) {
            CmdFX_Scene* scene = Scene_getRegisteredScene(uid);
            if (scene) {
                return std::make_unique<Scene>(scene);
            }
 
            return nullptr;
        }
 
    }
 
}