summaryrefslogtreecommitdiff
path: root/nanovg/nanovg.h
diff options
context:
space:
mode:
authorMitya Selivanov <automainint@guattari.tech>2024-07-14 21:12:37 +0200
committerMitya Selivanov <automainint@guattari.tech>2024-07-14 21:12:37 +0200
commit30740ca4131d1f574718262451b4410207dc8d4e (patch)
treefc88b16a216079397ad85b9c6b1a1c1c5712a814 /nanovg/nanovg.h
parent5e3c99bb1cf1d03ea006300121265571f5008fd2 (diff)
downloadsaw-30740ca4131d1f574718262451b4410207dc8d4e.zip
Reworking the build system
Diffstat (limited to 'nanovg/nanovg.h')
-rw-r--r--nanovg/nanovg.h708
1 files changed, 708 insertions, 0 deletions
diff --git a/nanovg/nanovg.h b/nanovg/nanovg.h
new file mode 100644
index 0000000..f32a175
--- /dev/null
+++ b/nanovg/nanovg.h
@@ -0,0 +1,708 @@
+//
+// 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.
+//
+
+#ifndef NANOVG_H_F380EB38_CDA3_11EA_AF53_BBD96082A0CB
+#define NANOVG_H_F380EB38_CDA3_11EA_AF53_BBD96082A0CB
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define NVG_PI 3.14159265358979323846264338327f
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union
+#endif
+
+typedef struct NVGcontext NVGcontext;
+
+struct NVGcolor {
+ union {
+ float rgba[4];
+ struct {
+ float r,g,b,a;
+ };
+ };
+};
+typedef struct NVGcolor NVGcolor;
+
+struct NVGpaint {
+ float xform[6];
+ float extent[2];
+ float radius;
+ float feather;
+ NVGcolor innerColor;
+ NVGcolor outerColor;
+ int image;
+};
+typedef struct NVGpaint NVGpaint;
+
+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.
+};
+
+enum NVGblendFactor {
+ NVG_ZERO = 1<<0,
+ NVG_ONE = 1<<1,
+ NVG_SRC_COLOR = 1<<2,
+ NVG_ONE_MINUS_SRC_COLOR = 1<<3,
+ NVG_DST_COLOR = 1<<4,
+ NVG_ONE_MINUS_DST_COLOR = 1<<5,
+ NVG_SRC_ALPHA = 1<<6,
+ NVG_ONE_MINUS_SRC_ALPHA = 1<<7,
+ NVG_DST_ALPHA = 1<<8,
+ NVG_ONE_MINUS_DST_ALPHA = 1<<9,
+ NVG_SRC_ALPHA_SATURATE = 1<<10,
+};
+
+enum NVGcompositeOperation {
+ NVG_SOURCE_OVER,
+ NVG_SOURCE_IN,
+ NVG_SOURCE_OUT,
+ NVG_ATOP,
+ NVG_DESTINATION_OVER,
+ NVG_DESTINATION_IN,
+ NVG_DESTINATION_OUT,
+ NVG_DESTINATION_ATOP,
+ NVG_LIGHTER,
+ NVG_COPY,
+ NVG_XOR,
+};
+
+struct NVGcompositeOperationState {
+ int srcRGB;
+ int dstRGB;
+ int srcAlpha;
+ int dstAlpha;
+};
+typedef struct NVGcompositeOperationState NVGcompositeOperationState;
+
+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.
+};
+typedef struct NVGglyphPosition NVGglyphPosition;
+
+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.
+};
+typedef struct NVGtextRow NVGtextRow;
+
+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.
+ NVG_IMAGE_NEAREST = 1<<5, // Image interpolation is Nearest instead Linear
+};
+
+// 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, float windowWidth, float windowHeight, float devicePixelRatio);
+
+// Cancels drawing the current frame.
+void nvgCancelFrame(NVGcontext* ctx);
+
+// Ends drawing flushing remaining render state.
+void nvgEndFrame(NVGcontext* ctx);
+
+//
+// Composite operation
+//
+// The composite operations in NanoVG are modeled after HTML Canvas API, and
+// the blend func is based on OpenGL (see corresponding manuals for more info).
+// The colors in the blending state have premultiplied alpha.
+
+// Sets the composite operation. The op parameter should be one of NVGcompositeOperation.
+void nvgGlobalCompositeOperation(NVGcontext* ctx, int op);
+
+// Sets the composite operation with custom pixel arithmetic. The parameters should be one of NVGblendFactor.
+void nvgGlobalCompositeBlendFunc(NVGcontext* ctx, int sfactor, int dfactor);
+
+// Sets the composite operation with custom pixel arithmetic for RGB and alpha components separately. The parameters should be one of NVGblendFactor.
+void nvgGlobalCompositeBlendFuncSeparate(NVGcontext* ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha);
+
+//
+// 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(unsigned char r, unsigned char g, unsigned char 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(unsigned char r, unsigned char g, unsigned char b, unsigned char 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, unsigned char 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, unsigned char 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 whether to draw antialias for nvgStroke() and nvgFill(). It's enabled by default.
+void nvgShapeAntiAlias(NVGcontext* ctx, int enabled);
+
+// 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.
+// Already 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, unsigned char* 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 unsigned char* data);
+
+int nvgCreateImageAlpha(NVGcontext* ctx, int w, int h, int imageFlags, const unsigned char* data);
+
+// Updates image data specified by image handle.
+void nvgUpdateImage(NVGcontext* ctx, int image, const unsigned char* 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 highlights 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 pattern. 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 various
+// 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);
+
+void nvgBarc(NVGcontext* ctx, float cx, float cy, float r, float a0, float a1, int dir, int join);
+
+// 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 rounded rectangle shaped sub-path with varying radii for each corner.
+void nvgRoundedRectVarying(NVGcontext* ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft);
+
+// 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);
+
+// fontIndex specifies which font face to load from a .ttf/.ttc file.
+int nvgCreateFontAtIndex(NVGcontext* ctx, const char* name, const char* filename, const int fontIndex);
+
+// Creates font by loading it from the specified memory chunk.
+// Returns handle to the font.
+int nvgCreateFontMem(NVGcontext* ctx, const char* name, unsigned char* data, int ndata, int freeData);
+
+// fontIndex specifies which font face to load from a .ttf/.ttc file.
+int nvgCreateFontMemAtIndex(NVGcontext* ctx, const char* name, unsigned char* data, int ndata, int freeData, const int fontIndex);
+
+// 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);
+
+// Adds a fallback font by handle.
+int nvgAddFallbackFontId(NVGcontext* ctx, int baseFont, int fallbackFont);
+
+// Adds a fallback font by name.
+int nvgAddFallbackFont(NVGcontext* ctx, const char* baseFont, const char* fallbackFont);
+
+// Resets fallback fonts by handle.
+void nvgResetFallbackFontsId(NVGcontext* ctx, int baseFont);
+
+// Resets fallback fonts by name.
+void nvgResetFallbackFonts(NVGcontext* ctx, const char* baseFont);
+
+// 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 xform[6];
+ float extent[2];
+};
+typedef struct NVGscissor NVGscissor;
+
+struct NVGvertex {
+ float x,y,u,v;
+};
+typedef struct NVGvertex NVGvertex;
+
+struct NVGpath {
+ int first;
+ int count;
+ unsigned char closed;
+ int nbevel;
+ NVGvertex* fill;
+ int nfill;
+ NVGvertex* stroke;
+ int nstroke;
+ int winding;
+ int convex;
+};
+typedef struct NVGpath NVGpath;
+
+struct NVGparams {
+ void* userPtr;
+ int edgeAntiAlias;
+ int (*renderCreate)(void* uptr);
+ int (*renderCreateTexture)(void* uptr, int type, int w, int h, int imageFlags, const unsigned char* data);
+ int (*renderDeleteTexture)(void* uptr, int image);
+ int (*renderUpdateTexture)(void* uptr, int image, int x, int y, int w, int h, const unsigned char* data);
+ int (*renderGetTextureSize)(void* uptr, int image, int* w, int* h);
+ void (*renderViewport)(void* uptr, float width, float height, float devicePixelRatio);
+ void (*renderCancel)(void* uptr);
+ void (*renderFlush)(void* uptr);
+ void (*renderFill)(void* uptr, NVGpaint* paint, NVGcompositeOperationState compositeOperation, NVGscissor* scissor, float fringe, const float* bounds, const NVGpath* paths, int npaths);
+ void (*renderStroke)(void* uptr, NVGpaint* paint, NVGcompositeOperationState compositeOperation, NVGscissor* scissor, float fringe, float strokeWidth, const NVGpath* paths, int npaths);
+ void (*renderTriangles)(void* uptr, NVGpaint* paint, NVGcompositeOperationState compositeOperation, NVGscissor* scissor, const NVGvertex* verts, int nverts, float fringe);
+ void (*renderDelete)(void* uptr);
+};
+typedef struct NVGparams NVGparams;
+
+// 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);
+
+#if defined(__ANDROID__)
+#include <stdio.h>
+#include <android/asset_manager.h>
+void nvgSetAndroidAssetManager(AAssetManager * manager);
+FILE * android_fopen(const char* fname, const char* mode);
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#define NVG_NOTUSED(v) for (;;) { (void)(1 ? (void)0 : ( (void)(v) ) ); break; }
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NANOVG_H_F380EB38_CDA3_11EA_AF53_BBD96082A0CB