GLType.h

#pragma once
#include <string>
#include "PERef.h"

#define GL_CONTENT_SCALE_FACTOR() 1


namespace ParaEngine {
    

enum class GlyphCollection {
    DYNAMIC,
    NEHE,
    ASCII,
    CUSTOM
};

class GL {
public:
    static void bindTexture2D(GLuint textureId);
    static void bindTexture2DN(GLuint textureUnit, GLuint textureId);

    static void deleteTexture(GLuint textureId);

    static void deleteProgram(GLuint program);
    static void useProgram(GLuint program);
    static void bindVAO(GLuint vaoId);
    static void enableVertexAttribs(uint32_t flags);
};

typedef struct _ttfConfig
{
    std::string fontFilePath;
    float fontSize;

    GlyphCollection glyphs;
    const char *customGlyphs;

    bool distanceFieldEnabled;
    int outlineSize;

    bool italics;
    bool bold;
    bool underline;
    bool strikethrough;

    _ttfConfig(const std::string& filePath = "", float size = 12, const GlyphCollection& glyphCollection = GlyphCollection::DYNAMIC,
        const char *customGlyphCollection = nullptr, bool useDistanceField = false, int outline = 0,
        bool useItalics = false, bool useBold = false, bool useUnderline = false, bool useStrikethrough = false)
        : fontFilePath(filePath)
        , fontSize(size)
        , glyphs(glyphCollection)
        , customGlyphs(customGlyphCollection)
        , distanceFieldEnabled(useDistanceField)
        , outlineSize(outline)
        , italics(useItalics)
        , bold(useBold)
        , underline(useUnderline)
        , strikethrough(useStrikethrough)
    {
        if (outline > 0)
        {
            distanceFieldEnabled = false;
        }
    }
} TTFConfig;

struct FontLetterDefinition
{
    unsigned short  letteCharUTF16;
    float U;
    float V;
    float width;
    float height;
    float offsetX;
    float offsetY;
    int textureID;
    bool validDefinition;
    int xAdvance;

    int clipBottom;
};


struct Color4B;
struct Color4F;

struct Color3B
{
    Color3B();
    Color3B(GLubyte _r, GLubyte _g, GLubyte _b);
    explicit Color3B(const Color4B& color);
    explicit Color3B(const Color4F& color);

    bool operator==(const Color3B& right) const;
    bool operator==(const Color4B& right) const;
    bool operator==(const Color4F& right) const;
    bool operator!=(const Color3B& right) const;
    bool operator!=(const Color4B& right) const;
    bool operator!=(const Color4F& right) const;

    bool equals(const Color3B& other)
    {
        return (*this == other);
    }

    GLubyte r;
    GLubyte g;
    GLubyte b;

    static const Color3B WHITE;
    static const Color3B YELLOW;
    static const Color3B BLUE;
    static const Color3B GREEN;
    static const Color3B RED;
    static const Color3B MAGENTA;
    static const Color3B BLACK;
    static const Color3B ORANGE;
    static const Color3B GRAY;
};

struct Color4B
{
    Color4B();
    Color4B(GLubyte _r, GLubyte _g, GLubyte _b, GLubyte _a);
    explicit Color4B(const Color3B& color);
    explicit Color4B(const Color4F& color);

    bool operator==(const Color4B& right) const;
    bool operator==(const Color3B& right) const;
    bool operator==(const Color4F& right) const;
    bool operator!=(const Color4B& right) const;
    bool operator!=(const Color3B& right) const;
    bool operator!=(const Color4F& right) const;

    GLubyte r;
    GLubyte g;
    GLubyte b;
    GLubyte a;

    static const Color4B WHITE;
    static const Color4B YELLOW;
    static const Color4B BLUE;
    static const Color4B GREEN;
    static const Color4B RED;
    static const Color4B MAGENTA;
    static const Color4B BLACK;
    static const Color4B ORANGE;
    static const Color4B GRAY;
};


struct Color4F
{
    Color4F();
    Color4F(float _r, float _g, float _b, float _a);
    explicit Color4F(const Color3B& color);
    explicit Color4F(const Color4B& color);

    bool operator==(const Color4F& right) const;
    bool operator==(const Color3B& right) const;
    bool operator==(const Color4B& right) const;
    bool operator!=(const Color4F& right) const;
    bool operator!=(const Color3B& right) const;
    bool operator!=(const Color4B& right) const;

    bool equals(const Color4F &other)
    {
        return (*this == other);
    }

    GLfloat r;
    GLfloat g;
    GLfloat b;
    GLfloat a;

    static const Color4F WHITE;
    static const Color4F YELLOW;
    static const Color4F BLUE;
    static const Color4F GREEN;
    static const Color4F RED;
    static const Color4F MAGENTA;
    static const Color4F BLACK;
    static const Color4F ORANGE;
    static const Color4F GRAY;
};




class CCVector2
{
public:


    float x;
    float y;

    CCVector2();
    CCVector2(float vx, float vy);

    bool equals(const CCVector2& v) const;

    static CCVector2 ZERO;

};

class Size
{
public:

    Size();

    Size(float width, float height);


    bool equals(const Size& v) const;


    float width;
    float height;

    static const Size ZERO;
};



class CCRect
{
public:
    CCVector2 origin;
    Size  size;

public:
    CCRect();
    CCRect(float x, float y, float width, float height);
    CCRect(const CCVector2& pos, const Size& dimension);
    CCRect(const CCRect& other);
    CCRect& operator= (const CCRect& other);
    void setRect(float x, float y, float width, float height);
    float getMinX() const; 

    float getMidX() const; 

    float getMaxX() const; 

    float getMinY() const; 

    float getMidY() const; 

    float getMaxY() const; 

    bool equals(const CCRect& rect) const;
    bool containsPoint(const CCVector2& point) const;
    bool intersectsRect(const CCRect& rect) const;
    bool intersectsCircle(const CCVector2& center, float radius) const;
    CCRect unionWithRect(const CCRect & rect) const;
    void merge(const CCRect& rect);
    static const CCRect ZERO;
};
}