DarkMoon Engine

CopyC++#include <darkmoon/graphics.hpp>

int main(){
    DarkMoonEngine dm{};

    Monitor primary = dm.GetPrimaryMonitor();
    std::cout << "Primary monitor: " << primary.getName() << "\n";

    Window win = Window(800, 600, "Monitor Example");
    win.SetFullscreen(primary); // Monitor::getPrimary() is also the default

    while(!win.ShouldClose()){
        win.BeginDrawing(BLACK);
        win.EndDrawing();
    }
}

C++struct VideoMode {
    int width, height;
    int redBits, greenBits, blueBits;
    int refreshRate;
};

struct PhysicalSize    { int widthMM, heightMM; };
struct ContentScale   { float x, y; };
struct VirtualPosition{ int x, y; };
struct WorkArea       { int x, y, width, height; };

struct GammaRamp {
    std::vector<unsigned short> red, green, blue;
    unsigned int size() const;
};

C++struct Camera2D {
    Vector2Df target   {};        // World point the camera is looking at
    Vector2Df offset   {};        // Where target appears on screen (px)
    float     zoom     { 1.0f };
    float     rotation { 0.0f }; // In degrees
};

textDraw()
    │
    └── vertices are treated as already being in screen/pixel space
        (e.g. UI elements, HUD) the camera is never consulted

Draw(camera)
    │
    ├── for each vertex: screenPos = camera.WorldToScreen(worldPos)
    ├── converts each screenPos to NDC
    └── uploads a temporary VAO/VBO/EBO for this single draw call,
        then deletes it immediately afterwards

Triangle

TriangleLines

Rectangle

textA --- B
|     |
C --- D

RectangleLines

Circle

CircleLines

RegularPolygon

RegularPolygonLines

C++struct Resource {
protected:
    std::size_t m_idResource { 0 };
    std::size_t m_fileType   {};
    std::string m_filePath   {};
    bool        m_isLoaded  { false };

    Resource(std::size_t idResource, std::size_t fileType, const char* filePath);
    virtual void setup() {};

public:
    virtual ~Resource() {};
    virtual void unload() {};
    bool        isLoaded();
    std::size_t getIDResource();
    std::string getFilePath();
    std::size_t getFileType();
};

textloadResource<T>(filePath, args...)
    │
    ├── scans every loaded resource for a MATCH:
    │       filePath equal   AND   stored type == typeid(T)
    │
    ├── match found   → returns the EXISTING T*  (args... are ignored!)
    │
    └── no match       → constructs a new T(nextID, typeid(T), filePath, args...)
            ├── isLoaded() == true  → stores it, returns the new T*
            └── isLoaded() == false → discards it, returns nullptr

C++struct Vector2D {
    int x, y;
};

C++struct Vector2Df {
    float x, y;
};

CopyC++#include <darkmoon/utils/math.hpp>

Vector2D  gridPos  { 3, 4 };
Vector2Df worldPos = gridPos.toFloat() * 32.0f;

Vector2Df dir = (target - worldPos).normalized();
worldPos += dir * speed * win.GetDeltaTime();

// Back to integer tile coordinates (truncates)
Vector2D tile = worldPos.toInt() / 32;

C++struct MemoryViewer {
    template <typename T>
    MemoryViewer(T const& obj_or_ptr);

    void printMemory();
};

text##### MOSTRANDO OBJETO. Size: 8 bytes #####
||   DIRECCIONES   || 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ||    CARACTERES    ||
============================================================================================
||  0x7ffe1a2b3c40 || 40 E2 01 00 00 00 00 00 -- -- -- -- -- -- -- -- ||    @........     ||
============================================================================================

CopyC++#include <darkmoon/utils/memory.hpp>

// Inspecting a value directly
Vector2Df pos { 3.5f, 7.2f };
MemoryViewer(pos).printMemory();

// Inspecting through a pointer: dumps the pointee, not the pointer itself
Vector2Df* posPtr = &pos;
MemoryViewer(posPtr).printMemory();