module bgfx_extras.nanovg;

private {
    import bx.bx : AllocatorI;
    import bgfx_extras.fontstash;
}

//
// Copyright (c) 2013 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//

enum NVG_PI = 3.14159265358979323846264338327f;

// nanovg.cpp

enum NVG_MAX_STATES= 32;
enum NVG_MAX_FONTIMAGES = 4;

struct NVGstate {
	NVGpaint fill;
	NVGpaint stroke;
	float strokeWidth;
	float miterLimit;
	int lineJoin;
	int lineCap;
	float alpha;
	float[6] xform;
	NVGscissor scissor;
	float fontSize;
	float letterSpacing;
	float lineHeight;
	float fontBlur;
	int textAlign;
	int fontId;
}

struct NVGpoint {
	float x,y;
	float dx, dy;
	float len;
	float dmx, dmy;
	ubyte flags;
}

struct NVGpathCache {
	NVGpoint[] points;
	int npoints;
	int cpoints;
	NVGpath[] paths;
	int npaths;
	int cpaths;
	NVGvertex[] verts;
	int nverts;
	int cverts;
	float[4] bounds;
}

struct NVGcontext {
	NVGparams params;
	float* commands;
	int ccommands;
	int ncommands;
	float commandx, commandy;
	NVGstate[NVG_MAX_STATES] states;
	int nstates;
	NVGpathCache* cache;
	float tessTol;
	float distTol;
	float fringeWidth;
	float devicePxRatio;
	FONScontext* fs;
	int[NVG_MAX_FONTIMAGES] fontImages;
	int fontImageIdx;
	int drawCallCount;
	int fillTriCount;
	int strokeTriCount;
	int textTriCount;
}

// 

struct NVGcolor {
    float r, g, b, a;
    
    @property float[4] rgba() {
        return [r, g, b, a];
    }
    @property float[4] rgba(float[4] n_rgba) {
        r = n_rgba[0];
        g = n_rgba[1];
        b = n_rgba[2];
        a = n_rgba[3];
        return n_rgba;
    }
}

struct NVGpaint {
	float[6] xform;
	float[2] extent;
	float radius;
	float feather;
	NVGcolor innerColor;
	NVGcolor outerColor;
	int image;
}

enum NVGwinding {
	NVG_CCW = 1,			// Winding for solid shapes
	NVG_CW = 2,				// Winding for holes
}

enum NVGsolidity {
	NVG_SOLID = 1,			// CCW
	NVG_HOLE = 2,			// CW
}

enum NVGlineCap {
	NVG_BUTT,
	NVG_ROUND,
	NVG_SQUARE,
	NVG_BEVEL,
	NVG_MITER,
}

enum NVGalign {
	// Horizontal align
	NVG_ALIGN_LEFT 		= 1<<0,	// Default, align text horizontally to left.
	NVG_ALIGN_CENTER 	= 1<<1,	// Align text horizontally to center.
	NVG_ALIGN_RIGHT 	= 1<<2,	// Align text horizontally to right.
	// Vertical align
	NVG_ALIGN_TOP 		= 1<<3,	// Align text vertically to top.
	NVG_ALIGN_MIDDLE	= 1<<4,	// Align text vertically to middle.
	NVG_ALIGN_BOTTOM	= 1<<5,	// Align text vertically to bottom. 
	NVG_ALIGN_BASELINE	= 1<<6, // Default, align text vertically to baseline. 
}

struct NVGglyphPosition {
	const(char)* str;	// Position of the glyph in the input string.
	float x;			// The x-coordinate of the logical glyph position.
	float minx, maxx;	// The bounds of the glyph shape.
}

struct NVGtextRow {
	const(char)* start;	// Pointer to the input text where the row starts.
	const(char)* end;	// Pointer to the input text where the row ends (one past the last character).
	const(char)* next;	// Pointer to the beginning of the next row.
	float width;		// Logical width of the row.
	float minx, maxx;	// Actual bounds of the row. Logical with and bounds can differ because of kerning and some parts over extending.
}

enum NVGimageFlags {
    NVG_IMAGE_GENERATE_MIPMAPS	= 1<<0,     // Generate mipmaps during creation of the image.
	NVG_IMAGE_REPEATX			= 1<<1,		// Repeat image in X direction.
	NVG_IMAGE_REPEATY			= 1<<2,		// Repeat image in Y direction.
	NVG_IMAGE_FLIPY				= 1<<3,		// Flips (inverses) image in Y direction when rendered.
	NVG_IMAGE_PREMULTIPLIED		= 1<<4,		// Image data has premultiplied alpha.
}

extern(C) @nogc nothrow {

    // Begin drawing a new frame
    // Calls to nanovg drawing API should be wrapped in nvgBeginFrame() & nvgEndFrame()
    // nvgBeginFrame() defines the size of the window to render to in relation currently
    // set viewport (i.e. glViewport on GL backends). Device pixel ration allows to
    // control the rendering on Hi-DPI devices.
    // For example, GLFW returns two dimension for an opened window: window size and
    // frame buffer size. In that case you would set windowWidth/Height to the window size
    // devicePixelRatio to: frameBufferWidth / windowWidth.
    void nvgBeginFrame(NVGcontext* ctx, int windowWidth, int windowHeight, float devicePixelRatio);

    // Cancels drawing the current frame.
    void nvgCancelFrame(NVGcontext* ctx);

    // Ends drawing flushing remaining render state.
    void nvgEndFrame(NVGcontext* ctx);

    //
    // Color utils
    //
    // Colors in NanoVG are stored as unsigned ints in ABGR format.

    // Returns a color value from red, green, blue values. Alpha will be set to 255 (1.0f).
    NVGcolor nvgRGB(ubyte r, ubyte g, ubyte b);

    // Returns a color value from red, green, blue values. Alpha will be set to 1.0f.
    NVGcolor nvgRGBf(float r, float g, float b);


    // Returns a color value from red, green, blue and alpha values.
    NVGcolor nvgRGBA(ubyte r, ubyte g, ubyte b, ubyte a);

    // Returns a color value from red, green, blue and alpha values.
    NVGcolor nvgRGBAf(float r, float g, float b, float a);


    // Linearly interpolates from color c0 to c1, and returns resulting color value.
    NVGcolor nvgLerpRGBA(NVGcolor c0, NVGcolor c1, float u);

    // Sets transparency of a color value.
    NVGcolor nvgTransRGBA(NVGcolor c0, ubyte a);

    // Sets transparency of a color value.
    NVGcolor nvgTransRGBAf(NVGcolor c0, float a);

    // Returns color value specified by hue, saturation and lightness.
    // HSL values are all in range [0..1], alpha will be set to 255.
    NVGcolor nvgHSL(float h, float s, float l);

    // Returns color value specified by hue, saturation and lightness and alpha.
    // HSL values are all in range [0..1], alpha in range [0..255]
    NVGcolor nvgHSLA(float h, float s, float l, ubyte a);

    //
    // State Handling
    //
    // NanoVG contains state which represents how paths will be rendered.
    // The state contains transform, fill and stroke styles, text and font styles,
    // and scissor clipping.

    // Pushes and saves the current render state into a state stack.
    // A matching nvgRestore() must be used to restore the state.
    void nvgSave(NVGcontext* ctx);

    // Pops and restores current render state.
    void nvgRestore(NVGcontext* ctx);

    // Resets current render state to default values. Does not affect the render state stack.
    void nvgReset(NVGcontext* ctx);

    //
    // Render styles
    //
    // Fill and stroke render style can be either a solid color or a paint which is a gradient or a pattern.
    // Solid color is simply defined as a color value, different kinds of paints can be created
    // using nvgLinearGradient(), nvgBoxGradient(), nvgRadialGradient() and nvgImagePattern().
    //
    // Current render style can be saved and restored using nvgSave() and nvgRestore(). 

    // Sets current stroke style to a solid color.
    void nvgStrokeColor(NVGcontext* ctx, NVGcolor color);

    // Sets current stroke style to a paint, which can be a one of the gradients or a pattern.
    void nvgStrokePaint(NVGcontext* ctx, NVGpaint paint);

    // Sets current fill style to a solid color.
    void nvgFillColor(NVGcontext* ctx, NVGcolor color);

    // Sets current fill style to a paint, which can be a one of the gradients or a pattern.
    void nvgFillPaint(NVGcontext* ctx, NVGpaint paint);

    // Sets the miter limit of the stroke style.
    // Miter limit controls when a sharp corner is beveled.
    void nvgMiterLimit(NVGcontext* ctx, float limit);

    // Sets the stroke width of the stroke style.
    void nvgStrokeWidth(NVGcontext* ctx, float size);

    // Sets how the end of the line (cap) is drawn,
    // Can be one of: NVG_BUTT (default), NVG_ROUND, NVG_SQUARE.
    void nvgLineCap(NVGcontext* ctx, int cap);

    // Sets how sharp path corners are drawn.
    // Can be one of NVG_MITER (default), NVG_ROUND, NVG_BEVEL.
    void nvgLineJoin(NVGcontext* ctx, int join);

    // Sets the transparency applied to all rendered shapes.
    // Alreade transparent paths will get proportionally more transparent as well.
    void nvgGlobalAlpha(NVGcontext* ctx, float alpha);

    //
    // Transforms
    //
    // The paths, gradients, patterns and scissor region are transformed by an transformation
    // matrix at the time when they are passed to the API.
    // The current transformation matrix is a affine matrix:
    //   [sx kx tx]
    //   [ky sy ty]
    //   [ 0  0  1]
    // Where: sx,sy define scaling, kx,ky skewing, and tx,ty translation.
    // The last row is assumed to be 0,0,1 and is not stored.
    //
    // Apart from nvgResetTransform(), each transformation function first creates
    // specific transformation matrix and pre-multiplies the current transformation by it.
    //
    // Current coordinate system (transformation) can be saved and restored using nvgSave() and nvgRestore(). 

    // Resets current transform to a identity matrix.
    void nvgResetTransform(NVGcontext* ctx);

    // Premultiplies current coordinate system by specified matrix.
    // The parameters are interpreted as matrix as follows:
    //   [a c e]
    //   [b d f]
    //   [0 0 1]
    void nvgTransform(NVGcontext* ctx, float a, float b, float c, float d, float e, float f);

    // Translates current coordinate system.
    void nvgTranslate(NVGcontext* ctx, float x, float y);

    // Rotates current coordinate system. Angle is specified in radians.
    void nvgRotate(NVGcontext* ctx, float angle);

    // Skews the current coordinate system along X axis. Angle is specified in radians.
    void nvgSkewX(NVGcontext* ctx, float angle);

    // Skews the current coordinate system along Y axis. Angle is specified in radians.
    void nvgSkewY(NVGcontext* ctx, float angle);

    // Scales the current coordinate system.
    void nvgScale(NVGcontext* ctx, float x, float y);

    // Stores the top part (a-f) of the current transformation matrix in to the specified buffer.
    //   [a c e]
    //   [b d f]
    //   [0 0 1]
    // There should be space for 6 floats in the return buffer for the values a-f.
    void nvgCurrentTransform(NVGcontext* ctx, float* xform);


    // The following functions can be used to make calculations on 2x3 transformation matrices.
    // A 2x3 matrix is represented as float[6].

    // Sets the transform to identity matrix.
    void nvgTransformIdentity(float* dst);

    // Sets the transform to translation matrix matrix.
    void nvgTransformTranslate(float* dst, float tx, float ty);

    // Sets the transform to scale matrix.
    void nvgTransformScale(float* dst, float sx, float sy);

    // Sets the transform to rotate matrix. Angle is specified in radians.
    void nvgTransformRotate(float* dst, float a);

    // Sets the transform to skew-x matrix. Angle is specified in radians.
    void nvgTransformSkewX(float* dst, float a);

    // Sets the transform to skew-y matrix. Angle is specified in radians.
    void nvgTransformSkewY(float* dst, float a);

    // Sets the transform to the result of multiplication of two transforms, of A = A*B.
    void nvgTransformMultiply(float* dst, const(float)* src);

    // Sets the transform to the result of multiplication of two transforms, of A = B*A.
    void nvgTransformPremultiply(float* dst, const(float)* src);

    // Sets the destination to inverse of specified transform.
    // Returns 1 if the inverse could be calculated, else 0.
    int nvgTransformInverse(float* dst, const(float)* src);

    // Transform a point by given transform.
    void nvgTransformPoint(float* dstx, float* dsty, const(float)* xform, float srcx, float srcy);

    // Converts degrees to radians and vice versa.
    float nvgDegToRad(float deg);
    float nvgRadToDeg(float rad);

    //
    // Images
    //
    // NanoVG allows you to load jpg, png, psd, tga, pic and gif files to be used for rendering.
    // In addition you can upload your own image. The image loading is provided by stb_image.
    // The parameter imageFlags is combination of flags defined in NVGimageFlags.

    // Creates image by loading it from the disk from specified file name.
    // Returns handle to the image.
    int nvgCreateImage(NVGcontext* ctx, const(char)* filename, int imageFlags);

    // Creates image by loading it from the specified chunk of memory.
    // Returns handle to the image.
    int nvgCreateImageMem(NVGcontext* ctx, int imageFlags, ubyte* data, int ndata);

    // Creates image from specified image data.
    // Returns handle to the image.
    int nvgCreateImageRGBA(NVGcontext* ctx, int w, int h, int imageFlags, const(ubyte)* data);

    // Updates image data specified by image handle.
    void nvgUpdateImage(NVGcontext* ctx, int image, const(ubyte)* data);

    // Returns the dimensions of a created image.
    void nvgImageSize(NVGcontext* ctx, int image, int* w, int* h);

    // Deletes created image.
    void nvgDeleteImage(NVGcontext* ctx, int image);

    //
    // Paints
    //
    // NanoVG supports four types of paints: linear gradient, box gradient, radial gradient and image pattern.
    // These can be used as paints for strokes and fills.

    // Creates and returns a linear gradient. Parameters (sx,sy)-(ex,ey) specify the start and end coordinates
    // of the linear gradient, icol specifies the start color and ocol the end color.
    // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint().
    NVGpaint nvgLinearGradient(NVGcontext* ctx, float sx, float sy, float ex, float ey,
                            NVGcolor icol, NVGcolor ocol);

    // Creates and returns a box gradient. Box gradient is a feathered rounded rectangle, it is useful for rendering
    // drop shadows or hilights for boxes. Parameters (x,y) define the top-left corner of the rectangle,
    // (w,h) define the size of the rectangle, r defines the corner radius, and f feather. Feather defines how blurry
    // the border of the rectangle is. Parameter icol specifies the inner color and ocol the outer color of the gradient.
    // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint().
    NVGpaint nvgBoxGradient(NVGcontext* ctx, float x, float y, float w, float h,
                            float r, float f, NVGcolor icol, NVGcolor ocol);

    // Creates and returns a radial gradient. Parameters (cx,cy) specify the center, inr and outr specify
    // the inner and outer radius of the gradient, icol specifies the start color and ocol the end color.
    // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint().
    NVGpaint nvgRadialGradient(NVGcontext* ctx, float cx, float cy, float inr, float outr,
                            NVGcolor icol, NVGcolor ocol);

    // Creates and returns an image patter. Parameters (ox,oy) specify the left-top location of the image pattern,
    // (ex,ey) the size of one image, angle rotation around the top-left corner, image is handle to the image to render.
    // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint().
    NVGpaint nvgImagePattern(NVGcontext* ctx, float ox, float oy, float ex, float ey,
                            float angle, int image, float alpha);

    //
    // Scissoring
    //
    // Scissoring allows you to clip the rendering into a rectangle. This is useful for varius
    // user interface cases like rendering a text edit or a timeline. 

    // Sets the current scissor rectangle.
    // The scissor rectangle is transformed by the current transform.
    void nvgScissor(NVGcontext* ctx, float x, float y, float w, float h);

    // Intersects current scissor rectangle with the specified rectangle.
    // The scissor rectangle is transformed by the current transform.
    // Note: in case the rotation of previous scissor rect differs from
    // the current one, the intersection will be done between the specified
    // rectangle and the previous scissor rectangle transformed in the current
    // transform space. The resulting shape is always rectangle.
    void nvgIntersectScissor(NVGcontext* ctx, float x, float y, float w, float h);

    // Reset and disables scissoring.
    void nvgResetScissor(NVGcontext* ctx);

    //
    // Paths
    //
    // Drawing a new shape starts with nvgBeginPath(), it clears all the currently defined paths.
    // Then you define one or more paths and sub-paths which describe the shape. The are functions
    // to draw common shapes like rectangles and circles, and lower level step-by-step functions,
    // which allow to define a path curve by curve.
    //
    // NanoVG uses even-odd fill rule to draw the shapes. Solid shapes should have counter clockwise
    // winding and holes should have counter clockwise order. To specify winding of a path you can
    // call nvgPathWinding(). This is useful especially for the common shapes, which are drawn CCW.
    //
    // Finally you can fill the path using current fill style by calling nvgFill(), and stroke it
    // with current stroke style by calling nvgStroke().
    //
    // The curve segments and sub-paths are transformed by the current transform.

    // Clears the current path and sub-paths.
    void nvgBeginPath(NVGcontext* ctx);

    // Starts new sub-path with specified point as first point.
    void nvgMoveTo(NVGcontext* ctx, float x, float y);

    // Adds line segment from the last point in the path to the specified point.
    void nvgLineTo(NVGcontext* ctx, float x, float y);

    // Adds cubic bezier segment from last point in the path via two control points to the specified point.
    void nvgBezierTo(NVGcontext* ctx, float c1x, float c1y, float c2x, float c2y, float x, float y);

    // Adds quadratic bezier segment from last point in the path via a control point to the specified point.
    void nvgQuadTo(NVGcontext* ctx, float cx, float cy, float x, float y);

    // Adds an arc segment at the corner defined by the last path point, and two specified points.
    void nvgArcTo(NVGcontext* ctx, float x1, float y1, float x2, float y2, float radius);

    // Closes current sub-path with a line segment.
    void nvgClosePath(NVGcontext* ctx);

    // Sets the current sub-path winding, see NVGwinding and NVGsolidity. 
    void nvgPathWinding(NVGcontext* ctx, int dir);

    // Creates new circle arc shaped sub-path. The arc center is at cx,cy, the arc radius is r,
    // and the arc is drawn from angle a0 to a1, and swept in direction dir (NVG_CCW, or NVG_CW).
    // Angles are specified in radians.
    void nvgArc(NVGcontext* ctx, float cx, float cy, float r, float a0, float a1, int dir);

    // Creates new rectangle shaped sub-path.
    void nvgRect(NVGcontext* ctx, float x, float y, float w, float h);

    // Creates new rounded rectangle shaped sub-path.
    void nvgRoundedRect(NVGcontext* ctx, float x, float y, float w, float h, float r);

    // Creates new ellipse shaped sub-path.
    void nvgEllipse(NVGcontext* ctx, float cx, float cy, float rx, float ry);

    // Creates new circle shaped sub-path. 
    void nvgCircle(NVGcontext* ctx, float cx, float cy, float r);

    // Fills the current path with current fill style.
    void nvgFill(NVGcontext* ctx);

    // Fills the current path with current stroke style.
    void nvgStroke(NVGcontext* ctx);


    //
    // Text
    //
    // NanoVG allows you to load .ttf files and use the font to render text.
    //
    // The appearance of the text can be defined by setting the current text style
    // and by specifying the fill color. Common text and font settings such as
    // font size, letter spacing and text align are supported. Font blur allows you
    // to create simple text effects such as drop shadows.
    //
    // At render time the font face can be set based on the font handles or name.
    //
    // Font measure functions return values in local space, the calculations are
    // carried in the same resolution as the final rendering. This is done because
    // the text glyph positions are snapped to the nearest pixels sharp rendering.
    //
    // The local space means that values are not rotated or scale as per the current
    // transformation. For example if you set font size to 12, which would mean that
    // line height is 16, then regardless of the current scaling and rotation, the
    // returned line height is always 16. Some measures may vary because of the scaling
    // since aforementioned pixel snapping.
    //
    // While this may sound a little odd, the setup allows you to always render the
    // same way regardless of scaling. I.e. following works regardless of scaling:
    //
    //		const char* txt = "Text me up.";
    //		nvgTextBounds(vg, x,y, txt, NULL, bounds);
    //		nvgBeginPath(vg);
    //		nvgRoundedRect(vg, bounds[0],bounds[1], bounds[2]-bounds[0], bounds[3]-bounds[1]);
    //		nvgFill(vg);
    //
    // Note: currently only solid color fill is supported for text.

    // Creates font by loading it from the disk from specified file name.
    // Returns handle to the font.
    int nvgCreateFont(NVGcontext* ctx, const(char)* name, const(char)* filename);

    // Creates image by loading it from the specified memory chunk.
    // Returns handle to the font.
    int nvgCreateFontMem(NVGcontext* ctx, const(char)* name, ubyte* data, int ndata, int freeData);

    // Finds a loaded font of specified name, and returns handle to it, or -1 if the font is not found.
    int nvgFindFont(NVGcontext* ctx, const(char)* name);

    // Sets the font size of current text style.
    void nvgFontSize(NVGcontext* ctx, float size);

    // Sets the blur of current text style.
    void nvgFontBlur(NVGcontext* ctx, float blur);

    // Sets the letter spacing of current text style.
    void nvgTextLetterSpacing(NVGcontext* ctx, float spacing);

    // Sets the proportional line height of current text style. The line height is specified as multiple of font size. 
    void nvgTextLineHeight(NVGcontext* ctx, float lineHeight);

    // Sets the text align of current text style, see NVGalign for options.
    void nvgTextAlign(NVGcontext* ctx, int align_);

    // Sets the font face based on specified id of current text style.
    void nvgFontFaceId(NVGcontext* ctx, int font);

    // Sets the font face based on specified name of current text style.
    void nvgFontFace(NVGcontext* ctx, const(char)* font);

    // Draws text string at specified location. If end is specified only the sub-string up to the end is drawn.
    float nvgText(NVGcontext* ctx, float x, float y, const(char)* string, const(char)* end);

    // Draws multi-line text string at specified location wrapped at the specified width. If end is specified only the sub-string up to the end is drawn.
    // White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered.
    // Words longer than the max width are slit at nearest character (i.e. no hyphenation).
    void nvgTextBox(NVGcontext* ctx, float x, float y, float breakRowWidth, const(char)* string_, const(char)* end);

    // Measures the specified text string. Parameter bounds should be a pointer to float[4],
    // if the bounding box of the text should be returned. The bounds value are [xmin,ymin, xmax,ymax]
    // Returns the horizontal advance of the measured text (i.e. where the next character should drawn).
    // Measured values are returned in local coordinate space.
    float nvgTextBounds(NVGcontext* ctx, float x, float y, const(char)* string_, const(char)* end, float* bounds);

    // Measures the specified multi-text string. Parameter bounds should be a pointer to float[4],
    // if the bounding box of the text should be returned. The bounds value are [xmin,ymin, xmax,ymax]
    // Measured values are returned in local coordinate space.
    void nvgTextBoxBounds(NVGcontext* ctx, float x, float y, float breakRowWidth, const(char)* string_, const(char)* end, float* bounds);

    // Calculates the glyph x positions of the specified text. If end is specified only the sub-string will be used.
    // Measured values are returned in local coordinate space.
    int nvgTextGlyphPositions(NVGcontext* ctx, float x, float y, const(char)* string_, const(char)* end, NVGglyphPosition* positions, int maxPositions);

    // Returns the vertical metrics based on the current text style.
    // Measured values are returned in local coordinate space.
    void nvgTextMetrics(NVGcontext* ctx, float* ascender, float* descender, float* lineh);

    // Breaks the specified text into lines. If end is specified only the sub-string will be used.
    // White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered.
    // Words longer than the max width are slit at nearest character (i.e. no hyphenation).
    int nvgTextBreakLines(NVGcontext* ctx, const(char)* string, const(char)* end, float breakRowWidth, NVGtextRow* rows, int maxRows);

}

//
// Internal Render API
//
enum NVGtexture {
	NVG_TEXTURE_ALPHA = 0x01,
	NVG_TEXTURE_RGBA = 0x02,
}

struct NVGscissor {
	float[6] xform;
	float[2] extent;
}

struct NVGvertex {
	float x,y,u,v;
}

struct NVGpath {
	int first;
	int count;
	ubyte closed;
	int nbevel;
	NVGvertex* fill;
	int nfill;
	NVGvertex* stroke;
	int nstroke;
	int winding;
	int convex;
}

struct NVGparams {
	void* userPtr;
	int edgeAntiAlias;
	int delegate(void* uptr) renderCreate;
	int delegate(void* uptr, int type, int w, int h, int imageFlags, const(ubyte)* data) renderCreateTexture;
	int delegate(void* uptr, int image) renderDeleteTexture;
	int delegate(void* uptr, int image, int x, int y, int w, int h, const(ubyte)* data) renderUpdateTexture;
	int delegate(void* uptr, int image, int* w, int* h) renderGetTextureSize;
	void delegate(void* uptr, int width, int height) renderViewport;
	void delegate(void* uptr) renderCancel;
	void delegate(void* uptr) renderFlush;
	void delegate(void* uptr, NVGpaint* paint, NVGscissor* scissor, float fringe, const(float)* bounds, const(NVGpath)* paths, int npaths) renderFill;
	void delegate(void* uptr, NVGpaint* paint, NVGscissor* scissor, float fringe, float strokeWidth, const(NVGpath)* paths, int npaths) renderStroke;
	void delegate(void* uptr, NVGpaint* paint, NVGscissor* scissor, const(NVGvertex)* verts, int nverts) renderTriangles;
	void delegate(void* uptr) renderDelete;
}

extern(C) @nogc nothrow {

    NVGcontext* nvgCreate(int edgeaa, ubyte _viewId, AllocatorI* _allocator = null);
    void nvgViewId(NVGcontext* ctx, ubyte _viewId);
    void nvgDelete(NVGcontext* ctx);

    // Constructor and destructor, called by the render back-end.
    NVGcontext* nvgCreateInternal(NVGparams* params);
    void nvgDeleteInternal(NVGcontext* ctx);

    NVGparams* nvgInternalParams(NVGcontext* ctx);

    // Debug function to dump cached path data.
    void nvgDebugDumpPathCache(NVGcontext* ctx);
    
}


// #define NVG_NOTUSED(v) for (;;) { (void)(1 ? (void)0 : ( (void)(v) ) ); break; }