cppgfx.hpp

 
#ifndef CPP_GRAPHICS_LIB_CPPGFX_HPP
#define CPP_GRAPHICS_LIB_CPPGFX_HPP
 
#include "SFML/Graphics.hpp"
#include "SFML/Window.hpp"
#include "SFML/System.hpp"
#include "spdlog/spdlog.h"
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/fmt/fmt.h"
#include "spdlog/fmt/std.h"
#include "spdlog/fmt/ranges.h"
#include <iostream>
#include <random>
 
#include "glm/glm.hpp"
 
#include "imgui.h"
 
#include "cppgfx/base64.hpp"
 
 
 
 
 
 
 
 
enum class TextAlign {
    Left,
    Center,
    Right
};
 
enum class LineCap {
    Round,
    Square
};
 
enum class RectMode {
    Center, // Origin is at center and x y is size
    Corner, // Origin is at top left corner and x y is size
    Corners // Origin is at top left corner and x y is bottom right corner
};
 
namespace cppgfx {
 
    class App {
    public:
        App();
        ~App();
 
        static App& Get() {
            if (m_instance == nullptr) {
                throw std::logic_error("cppgfx::App::Get(): No instance of cppgfx::App exists. "
                                       "Did you forget to create an instance of your application class?");
            }
 
            return *m_instance;
        }
 
        sf::RenderWindow window;
 
        bool darkTitleBar = true;
 
        uint32_t width = 800;
 
        uint32_t height = 600;
 
        uint32_t displayWidth = 0;
 
        uint32_t displayHeight = 0;
 
        std::string title = "My cppgfx application";
 
        bool focused = true;
 
        uint64_t frameCount = 0;
 
        float frameTime = 0;
 
        float frameRate = 0;
 
        constexpr static float PI = 3.14159265358979323846f;
 
        int mouseX = 0;
 
        int mouseY = 0;
 
        int pmouseX = 0;
 
        int pmouseY = 0;
 
        int dmouseX = 0;
 
        int dmouseY = 0;
 
        bool mousePressed = false;
 
 
 
 
        // =======================================
        // =====     Virtual Functions    ========
        // =======================================
 
        virtual void setup() = 0;
 
        virtual void update() = 0;
 
        virtual void cleanup() {}
 
        virtual bool onWindowClose() { return true; }
 
        virtual void onTextInput(const sf::Event::TextEvent& event) {}
 
        virtual void onKeyPressed(const sf::Event::KeyEvent& event) {}
 
        virtual void onKeyReleased(const sf::Event::KeyEvent& event) {}
 
        virtual void onMousePressed(const sf::Event::MouseButtonEvent& event) {}
 
        virtual void onMouseReleased(const sf::Event::MouseButtonEvent& event) {}
 
        virtual void onMouseMoved(const sf::Event::MouseMoveEvent& event) {}
 
        virtual void onMouseWheel(const sf::Event::MouseWheelScrollEvent& event) {}
 
        virtual void onMouseEnter() {}
 
        virtual void onMouseLeave() {}
 
        virtual void onWindowResize() {}
 
        virtual void onWindowFocus() {}
 
        virtual void onWindowUnfocus() {}
 
 
 
 
        // =======================================
        // =====        Graphics API      ========
        // =======================================
 
        void background(const sf::Color& color);
 
        void background(uint8_t shade);
 
        void background(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255);
 
        void fill(const sf::Color& color);
 
        void fill(uint8_t shade);
 
        void fill(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255);
 
        void noFill();
 
        void stroke(const sf::Color& color);
 
        void stroke(uint8_t shade);
 
        void stroke(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255);
 
        void noStroke();
 
        void strokeWeight(float weight);
 
        void push();
 
        void pop();
 
        void line(float x1, float y1, float x2, float y2);
 
        void lineCap(LineCap cap);
 
        void rect(float x, float y, float w, float h);
 
        void rectMode(RectMode mode);
 
        void circle(float x, float y, float radius);
 
        void ellipse(float x, float y, float w, float h);
 
        void triangle(float x1, float y1, float x2, float y2, float x3, float y3);
 
        void vector(float vectorX, float vectorY, float originX, float originY);
 
        void textFont(const sf::Font& font);
 
        sf::Font loadFont(const std::string& filename);
 
        void textAlign(TextAlign alignment);
 
        float textWidth(const std::string& text);
 
        void textSize(uint32_t size);
 
        void text(const std::string& text, float x, float y);
 
 
 
        // =======================================
        // =====         Window API       ========
        // =======================================
 
        void size(int w, int h);
 
        void setTitle(const std::string& text);
 
        void setFrameRate(float framerate);
 
        void fullscreen();
 
        void exitFullscreen();
 
        void close();
 
        void focus();
 
 
 
 
 
        // =======================================
        // =====        System API        ========
        // =======================================
 
        template<typename... Args>
        void print(Args&&... args) {
            fmt::print(std::forward<Args>(args)...);
        }
 
        template<typename... Args>
        void println(Args&&... args) {
            fmt::print(std::forward<Args>(args)...);
            fmt::print("\n");
        }
 
        std::string encodeBase64(const std::vector<uint8_t>& input) {
            return encode_base64(input);
        }
 
        std::vector<uint8_t> decodeBase64(const std::string& input) {
            return decode_base64(input);
        }
 
 
 
 
        // =======================================
        // =====         Math API         ========
        // =======================================
 
        float dist(float x1, float y1, float x2, float y2);
 
        float radians(float degrees);
 
        float degrees(float radians);
 
        template<typename T>
        T max(T a, T b) {
            return std::max(a, b);
        }
 
        template<typename T>
        T min(T a, T b) {
            return std::min(a, b);
        }
 
        template<typename T>
        T clamp(T value, T min, T max) {
            return std::clamp(value, min, max);
        }
 
        void randomSeed(uint32_t seed);
 
        int randomInt(int min, int max);
 
        int randomInt(int max);
 
        float random(float min, float max);
 
        float random(float max);
 
 
 
 
        // =======================================
        // =====     Time and Date API    ========
        // =======================================
 
        uint64_t micros();
 
        uint64_t millis();
 
        int second();
 
        int minute();
 
        int hour();
 
        int day();
 
        int month();
 
        int year();
 
 
 
 
        // =======================================
        // =====        Reserved API      ========
        // =======================================
 
        void run();
 
    private:
        App(const App&) = delete;
        App& operator=(const App&) = delete;
 
        void updateDisplaySize();
 
        inline static App* m_instance = nullptr;
        bool m_windowShouldClose = false;
 
        sf::Color m_defaultBackgroundColor = sf::Color(60, 60, 60);
        bool m_isDarkTitleBar = false;
        sf::Clock m_lifetimeClock;
        sf::Clock m_frametimeClock;
 
        uint32_t m_widthBeforeFullscreen = 0;
        uint32_t m_heightBeforeFullscreen = 0;
 
        inline static sf::Font m_defaultFont;
 
        struct DrawStyle {
            sf::Color m_fillColor = sf::Color::White;
            sf::Color m_strokeColor = sf::Color::Black;
            float m_strokeWeight = 0.f;
            sf::Font m_font = m_defaultFont;
            uint32_t m_fontSize = 18;
 
            LineCap m_lineCap = LineCap::Round;
            RectMode m_rectMode = RectMode::Corner;
            TextAlign m_textAlign = TextAlign::Left;
        };
        std::vector<DrawStyle> m_drawStyleStack;
 
    };
 
}
 
#endif //CPP_GRAPHICS_LIB_CPPGFX_HPP