draw.h

Go to the documentation of this file.

/*------------------------------------------------------------------------
  draw: C++11 cross-platform GPU-accelerated pixel-space 2D drawing library
  Original location: https://github.com/vsergey3d/draw
  Distributed under the Simplified BSD License:
  https://github.com/vsergey3d/draw/blob/master/LICENSE
------------------------------------------------------------------------*/
#pragma once
#include <stdint.h>
#include <memory>

#ifndef ASSERT
#include <cassert>
#define ASSERT(e) assert(e)
#endif

#define DRAW_NO_EXCEPTIONS
#ifndef DRAW_NO_EXCEPTIONS
#include <exception>
#endif

#ifndef SHARED_PTR
#define SHARED_PTR std::shared_ptr
#define MAKE_SHARED_PTR std::make_shared
#endif

namespace draw {

enum ErrorCode {

    NoError = 0, 
    InvalidArgument, 
    OpenGLAbsentFeature, 
    OpenGLOutOfMemory, 
    InvalidFontFile, 
    IncompleteFontFile 
};

#ifndef DRAW_NO_EXCEPTIONS

class Error : public std::exception {

public:
    virtual ~Error() = default;

    virtual ErrorCode code() const = 0;
};

#else
ErrorCode getLastError();
#endif

struct Point {

    int32_t x {0};
    int32_t y {0};

    Point() = default;

    Point(int32_t x, int32_t y) :
        x(x), y(y) {};
};

bool operator == (const Point& left, const Point& right);

bool operator != (const Point& left, const Point& right);

struct Size {

    uint32_t width {1};
    uint32_t height {1};

    Size() = default;
    Size(uint32_t width, uint32_t height) :
        width(width), height(height) {};
};

bool operator == (const Size& left, const Size& right);

bool operator != (const Size& left, const Size& right);

struct Rect {

    int32_t left {0};
    int32_t bottom {0};
    int32_t right {0};
    int32_t top {0};

    Rect() = default;
    Rect(int32_t left, int32_t bottom, int32_t right, int32_t top) :
        left(left), bottom(bottom), right(right), top(top) {};
};

bool operator == (const Rect& left, const Rect& right);

bool operator != (const Rect& left, const Rect& right);

struct Vector2 {

    float x {0.0f};
    float y {0.0f};

    Vector2() = default;
    Vector2(float x, float y) :
        x(x), y(y) {};
};

struct Color {

    float r {0.0f};
    float g {0.0f};
    float b {0.0f};
    float a {1.0f};

    Color() = default;
    Color(float r, float g, float b, float a = 1.0f) :
        r(r), g(g), b(b), a(a) {};
};

template <typename T>
struct Span {

    const T* ptr;
    uint32_t count;

    Span(const T* ptr, uint32_t count) :
        ptr(ptr), count(count) {}
};


class Geometry {

public:
    static const uint32_t kMaxVertexCount = 65535;//std::numeric_limits<Index>::max();
    struct Vertex {
        Vector2 position;
        Vector2 uv;
        Vertex() = default;
        Vertex(const Vector2& position, const Vector2& uv) :
            position(position), uv(uv) {};
    };
    using Vertices = Span<Vertex>;
    using Index = uint16_t;
    using Indices = Span<Index>;
    enum class Primitive {

        Point = 1, 
        Line, 
        Triangle 
    };
    virtual ~Geometry() = default;
    virtual uint32_t vertexCount() const = 0;
    virtual uint32_t indexCount() const = 0;
    virtual Primitive primitive() const = 0;
};

using GeometryPtr = SHARED_PTR<Geometry>;


#ifdef DRAW_NO_EXCEPTIONS

#endif
class Image {

public:
    static const uint32_t kMaxSize = 4096;
    using Bytes = Span<uint8_t>;
    enum class Format {

        A, 
        RGB, 
        RGBA 
    };
    virtual ~Image() = default;

    virtual const Size& size() const = 0;
    virtual Format format() const = 0;
    virtual bool filter() const = 0;

    virtual void upload(Bytes bytes) = 0;
};

using ImagePtr = SHARED_PTR<Image>;

class Visual {

public:
    virtual ~Visual() = default;
    virtual void visibility(bool enable) = 0;
    virtual bool visibility() const = 0;
    virtual void order(uint32_t order) = 0;
    virtual uint32_t order() const = 0;
    virtual void position(const Point& position) = 0;
    virtual const Point& position() const = 0;
    virtual const Rect& bounds() const = 0;
};

using VisualPtr = SHARED_PTR<Visual>;


class Shape : public Visual {

public:
    virtual ~Shape() = default;
    virtual void size(const Size& size) = 0;
    virtual const Size& size() const = 0;
    virtual void color(const Color& color) = 0;
    virtual const Color& color() const = 0;
    virtual void transparency(bool value) = 0;
    virtual bool transparency() const = 0;
    virtual void geometry(const GeometryPtr& geometry) = 0;
    virtual GeometryPtr geometry() const = 0;
    virtual void image(const ImagePtr& image) = 0;
    virtual void image(const ImagePtr& image, const Vector2& tile) = 0;
    virtual ImagePtr image() const = 0;
    virtual void image(const ImagePtr& atlas, const Rect& element) = 0;
    virtual ImagePtr image(Rect& element) const = 0;
};

using ShapePtr = SHARED_PTR<Shape>;


class Font {

public:
    static const uint32_t kMinLetterSize = 5;

    virtual ~Font() = default;
    virtual const char* filePath() const = 0;
    virtual uint32_t letterSize() const = 0;
};

using FontPtr = SHARED_PTR<Font>;


class Text : public Visual {

public:
    virtual ~Text() = default;
    virtual void font(const FontPtr& font) = 0;
    virtual FontPtr font() const = 0;
    virtual void text(const wchar_t* text) = 0;
    virtual const wchar_t* text() const = 0;
    virtual void color(const Color& color) = 0;
    virtual const Color& color() const = 0;
    enum class HorizAlign {

        Left,
        Center,
        Right
    };
    virtual void horizAlign(HorizAlign alignment) = 0;
    virtual HorizAlign horizAlign() const = 0;
    enum class VertAlign {

        Top,
        Middle,
        Bottom
    };
    virtual void vertAlign(VertAlign alignment) = 0;
    virtual VertAlign vertAlign() const = 0;
};

using TextPtr = SHARED_PTR<Text>;


#ifdef DRAW_NO_EXCEPTIONS

#endif
class Renderer {

public:

    virtual ~Renderer() = default;

    virtual GeometryPtr makeGeometry(Geometry::Vertices vertices,
        Geometry::Indices indices, Geometry::Primitive primitive) = 0;

    virtual ImagePtr makeImage(const Size& size, Image::Format format, bool filter) = 0;

    virtual FontPtr makeFont(const char* filePath, uint32_t letterSize) = 0;

    virtual ShapePtr makeRect() = 0;

    virtual ShapePtr makeShape() = 0;

    virtual TextPtr makeText() = 0;

    virtual uint32_t draw(const Color& clear) = 0;
    virtual void resize(const Size& size) = 0;
};

using RendererPtr = SHARED_PTR<Renderer>;


class Context {

public:
    virtual ~Context() = default;
    virtual void setCurrent() = 0;
};

using ContextPtr = std::unique_ptr<Context>;

#ifdef DRAW_NO_EXCEPTIONS

#endif

RendererPtr makeRenderer(ContextPtr context);

} // namespace draw