// // 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 #define NANOVG_H #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 }; enum NVGorientation { NVG_ORIENTATION_0 = 0, NVG_ORIENTATION_90 = 90, NVG_ORIENTATION_180 = 180, NVG_ORIENTATION_270 = 270 }; // 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, enum NVGorientation orientation); void nvgBeginFrameEx(NVGcontext* ctx, float windowWidth, float windowHeight, float devicePixelRatio, int reset, enum NVGorientation orientation); float nvgGetHeight(NVGcontext* ctx); float nvgGetWidth(NVGcontext* ctx); // 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); // 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); // Deletes font's assets for font's name. void nvgDeleteFontByName(NVGcontext* ctx, const char* name); // // 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 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); // get xfrom data void nvgGetStateXfrom(NVGcontext* ctx, float* xform); // // 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); /** * @method nvgIntersectScissor_ex * 设置一个与前一个裁剪区做交集的矩形裁剪区。 * 输入要设置的裁剪区，做交集后把新的裁剪区返回来给用户。 * * @annotation ["scriptable"] * @param {NVGcontext*} ctx nanovg的对象 * @param {float_t} x 裁剪区x坐标。 * @param {float_t} y 裁剪区y坐标。 * @param {float_t} w 裁剪区宽度。 * @param {float_t} h 裁剪区高度。 * */ void nvgIntersectScissor_ex(NVGcontext* ctx, float* x, float* y, float* w, float* h); // Reset and disables scissoring. void nvgResetScissor(NVGcontext* ctx); /** * @method nvgGetCurrScissor * 获取当前裁剪区 * * @annotation ["scriptable"] * @param {NVGcontext*} ctx nanovg的对象 * @param {float_t*} x 裁剪区x坐标。 * @param {float_t*} y 裁剪区y坐标。 * @param {float_t*} w 裁剪区宽度。 * @param {float_t*} h 裁剪区高度。 * * @return {int} 返回成功返回 1，失败返回 0。 */ int nvgGetCurrScissor(NVGcontext* ctx, float* x, float* y, float* w, float* h); /** * @method nvgIntersectScissorForOtherRect * 设置一个裁剪区，但是该裁剪区收到脏矩形的影响 * 首先会把脏矩形根据当前 nanovg 的坐标系转换为新的脏矩形区域，再和裁剪区做交集，把交集设为新的裁剪区 * * @annotation ["scriptable"] * @param {NVGcontext*} ctx nanovg的对象 * @param {float_t} x 裁剪区x坐标。 * @param {float_t} y 裁剪区y坐标。 * @param {float_t} w 裁剪区宽度。 * @param {float_t} h 裁剪区高度。 * @param {float_t} dx 脏矩形x坐标。 * @param {float_t} dy 脏矩形y坐标。 * @param {float_t} dw 脏矩形宽度。 * @param {float_t} dh 脏矩形高度。 * */ void nvgIntersectScissorForOtherRect(NVGcontext* ctx, float x, float y, float w, float h, float dx, float dy, float dw, float dh); // // 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 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); // 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); // 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); // 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 = 1, NVG_TEXTURE_RGBA = 2, NVG_TEXTURE_BGRA = 4, NVG_TEXTURE_RGB = 8, NVG_TEXTURE_BGR = 16, NVG_TEXTURE_RGB565 = 32, NVG_TEXTURE_BGR565 = 64, NVG_TEXTURE_ARGB = 128, NVG_TEXTURE_ABGR = 256, }; 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; void (*setLineCap)(void* uptr, int lineCap); void (*setLineJoin)(void* uptr, int lineJoin); int (*clearCache)(void* uptr); int (*renderCreate)(void* uptr); int (*findTexture)(void* uptr, const void* data); void (*setStateXfrom)(void* uptr, float* xform); int (*renderCreateTexture)(void* uptr, int type, int w, int h, int stride, int imageFlags, enum NVGorientation orientation, 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 (*globalSreenOrientation)(void* uptr, enum NVGorientation orientation); 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); 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); #ifdef _MSC_VER #pragma warning(pop) #endif #define NVG_NOTUSED(v) for (;;) { (void)(1 ? (void)0 : ( (void)(v) ) ); break; } NVGparams* nvgGetParams(NVGcontext* ctx); int nvgCreateImageRaw(NVGcontext* ctx, int w, int h, int format, int stride, int imageFlags, enum NVGorientation orientation, const unsigned char* data); int nvgFindTextureRaw(NVGcontext* ctx, const void* data); int nvgClearCache(NVGcontext* ctx); #ifdef __cplusplus } #endif #endif // NANOVG_H