1 // 2 // Copyright (c) 2013 Mikko Mononen memon@inside.org 3 // 4 // This software is provided 'as-is', without any express or implied 5 // warranty. In no event will the authors be held liable for any damages 6 // arising from the use of this software. 7 // Permission is granted to anyone to use this software for any purpose, 8 // including commercial applications, and to alter it and redistribute it 9 // freely, subject to the following restrictions: 10 // 1. The origin of this software must not be misrepresented; you must not 11 // claim that you wrote the original software. If you use this software 12 // in a product, an acknowledgment in the product documentation would be 13 // appreciated but is not required. 14 // 2. Altered source versions must be plainly marked as such, and must not be 15 // misrepresented as being the original software. 16 // 3. This notice may not be removed or altered from any source distribution. 17 // 18 19 #ifndef NANOVG_H 20 #define NANOVG_H 21 22 #ifdef __cplusplus 23 extern "C" { 24 #endif 25 26 #define NVG_PI 3.14159265358979323846264338327f 27 28 #ifdef _MSC_VER 29 #pragma warning(push) 30 #pragma warning(disable: 4201) // nonstandard extension used : nameless struct/union 31 #endif 32 33 typedef struct NVGcontext NVGcontext; 34 35 struct NVGcolor { 36 union { 37 float rgba[4]; 38 struct { 39 float r,g,b,a; 40 }; 41 }; 42 }; 43 typedef struct NVGcolor NVGcolor; 44 45 struct NVGpaint { 46 float xform[6]; 47 float extent[2]; 48 float radius; 49 float feather; 50 NVGcolor innerColor; 51 NVGcolor outerColor; 52 int image; 53 }; 54 typedef struct NVGpaint NVGpaint; 55 56 enum NVGwinding { 57 NVG_CCW = 1, // Winding for solid shapes 58 NVG_CW = 2, // Winding for holes 59 }; 60 61 enum NVGsolidity { 62 NVG_SOLID = 1, // CCW 63 NVG_HOLE = 2, // CW 64 }; 65 66 enum NVGlineCap { 67 NVG_BUTT, 68 NVG_ROUND, 69 NVG_SQUARE, 70 NVG_BEVEL, 71 NVG_MITER, 72 }; 73 74 enum NVGalign { 75 // Horizontal align 76 NVG_ALIGN_LEFT = 1<<0, // Default, align text horizontally to left. 77 NVG_ALIGN_CENTER = 1<<1, // Align text horizontally to center. 78 NVG_ALIGN_RIGHT = 1<<2, // Align text horizontally to right. 79 // Vertical align 80 NVG_ALIGN_TOP = 1<<3, // Align text vertically to top. 81 NVG_ALIGN_MIDDLE = 1<<4, // Align text vertically to middle. 82 NVG_ALIGN_BOTTOM = 1<<5, // Align text vertically to bottom. 83 NVG_ALIGN_BASELINE = 1<<6, // Default, align text vertically to baseline. 84 }; 85 86 struct NVGglyphPosition { 87 const char* str; // Position of the glyph in the input string. 88 float x; // The x-coordinate of the logical glyph position. 89 float minx, maxx; // The bounds of the glyph shape. 90 }; 91 typedef struct NVGglyphPosition NVGglyphPosition; 92 93 struct NVGtextRow { 94 const char* start; // Pointer to the input text where the row starts. 95 const char* end; // Pointer to the input text where the row ends (one past the last character). 96 const char* next; // Pointer to the beginning of the next row. 97 float width; // Logical width of the row. 98 float minx, maxx; // Actual bounds of the row. Logical with and bounds can differ because of kerning and some parts over extending. 99 }; 100 typedef struct NVGtextRow NVGtextRow; 101 102 enum NVGimageFlags { 103 NVG_IMAGE_GENERATE_MIPMAPS = 1<<0, // Generate mipmaps during creation of the image. 104 NVG_IMAGE_REPEATX = 1<<1, // Repeat image in X direction. 105 NVG_IMAGE_REPEATY = 1<<2, // Repeat image in Y direction. 106 NVG_IMAGE_FLIPY = 1<<3, // Flips (inverses) image in Y direction when rendered. 107 NVG_IMAGE_PREMULTIPLIED = 1<<4, // Image data has premultiplied alpha. 108 }; 109 110 // Begin drawing a new frame 111 // Calls to nanovg drawing API should be wrapped in nvgBeginFrame() & nvgEndFrame() 112 // nvgBeginFrame() defines the size of the window to render to in relation currently 113 // set viewport (i.e. glViewport on GL backends). Device pixel ration allows to 114 // control the rendering on Hi-DPI devices. 115 // For example, GLFW returns two dimension for an opened window: window size and 116 // frame buffer size. In that case you would set windowWidth/Height to the window size 117 // devicePixelRatio to: frameBufferWidth / windowWidth. 118 void nvgBeginFrame(NVGcontext* ctx, int windowWidth, int windowHeight, float devicePixelRatio); 119 120 // Cancels drawing the current frame. 121 void nvgCancelFrame(NVGcontext* ctx); 122 123 // Ends drawing flushing remaining render state. 124 void nvgEndFrame(NVGcontext* ctx); 125 126 // 127 // Color utils 128 // 129 // Colors in NanoVG are stored as unsigned ints in ABGR format. 130 131 // Returns a color value from red, green, blue values. Alpha will be set to 255 (1.0f). 132 NVGcolor nvgRGB(unsigned char r, unsigned char g, unsigned char b); 133 134 // Returns a color value from red, green, blue values. Alpha will be set to 1.0f. 135 NVGcolor nvgRGBf(float r, float g, float b); 136 137 138 // Returns a color value from red, green, blue and alpha values. 139 NVGcolor nvgRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a); 140 141 // Returns a color value from red, green, blue and alpha values. 142 NVGcolor nvgRGBAf(float r, float g, float b, float a); 143 144 145 // Linearly interpolates from color c0 to c1, and returns resulting color value. 146 NVGcolor nvgLerpRGBA(NVGcolor c0, NVGcolor c1, float u); 147 148 // Sets transparency of a color value. 149 NVGcolor nvgTransRGBA(NVGcolor c0, unsigned char a); 150 151 // Sets transparency of a color value. 152 NVGcolor nvgTransRGBAf(NVGcolor c0, float a); 153 154 // Returns color value specified by hue, saturation and lightness. 155 // HSL values are all in range [0..1], alpha will be set to 255. 156 NVGcolor nvgHSL(float h, float s, float l); 157 158 // Returns color value specified by hue, saturation and lightness and alpha. 159 // HSL values are all in range [0..1], alpha in range [0..255] 160 NVGcolor nvgHSLA(float h, float s, float l, unsigned char a); 161 162 // 163 // State Handling 164 // 165 // NanoVG contains state which represents how paths will be rendered. 166 // The state contains transform, fill and stroke styles, text and font styles, 167 // and scissor clipping. 168 169 // Pushes and saves the current render state into a state stack. 170 // A matching nvgRestore() must be used to restore the state. 171 void nvgSave(NVGcontext* ctx); 172 173 // Pops and restores current render state. 174 void nvgRestore(NVGcontext* ctx); 175 176 // Resets current render state to default values. Does not affect the render state stack. 177 void nvgReset(NVGcontext* ctx); 178 179 // 180 // Render styles 181 // 182 // Fill and stroke render style can be either a solid color or a paint which is a gradient or a pattern. 183 // Solid color is simply defined as a color value, different kinds of paints can be created 184 // using nvgLinearGradient(), nvgBoxGradient(), nvgRadialGradient() and nvgImagePattern(). 185 // 186 // Current render style can be saved and restored using nvgSave() and nvgRestore(). 187 188 // Sets current stroke style to a solid color. 189 void nvgStrokeColor(NVGcontext* ctx, NVGcolor color); 190 191 // Sets current stroke style to a paint, which can be a one of the gradients or a pattern. 192 void nvgStrokePaint(NVGcontext* ctx, NVGpaint paint); 193 194 // Sets current fill style to a solid color. 195 void nvgFillColor(NVGcontext* ctx, NVGcolor color); 196 197 // Sets current fill style to a paint, which can be a one of the gradients or a pattern. 198 void nvgFillPaint(NVGcontext* ctx, NVGpaint paint); 199 200 // Sets the miter limit of the stroke style. 201 // Miter limit controls when a sharp corner is beveled. 202 void nvgMiterLimit(NVGcontext* ctx, float limit); 203 204 // Sets the stroke width of the stroke style. 205 void nvgStrokeWidth(NVGcontext* ctx, float size); 206 207 // Sets how the end of the line (cap) is drawn, 208 // Can be one of: NVG_BUTT (default), NVG_ROUND, NVG_SQUARE. 209 void nvgLineCap(NVGcontext* ctx, int cap); 210 211 // Sets how sharp path corners are drawn. 212 // Can be one of NVG_MITER (default), NVG_ROUND, NVG_BEVEL. 213 void nvgLineJoin(NVGcontext* ctx, int join); 214 215 // Sets the transparency applied to all rendered shapes. 216 // Already transparent paths will get proportionally more transparent as well. 217 void nvgGlobalAlpha(NVGcontext* ctx, float alpha); 218 219 // 220 // Transforms 221 // 222 // The paths, gradients, patterns and scissor region are transformed by an transformation 223 // matrix at the time when they are passed to the API. 224 // The current transformation matrix is a affine matrix: 225 // [sx kx tx] 226 // [ky sy ty] 227 // [ 0 0 1] 228 // Where: sx,sy define scaling, kx,ky skewing, and tx,ty translation. 229 // The last row is assumed to be 0,0,1 and is not stored. 230 // 231 // Apart from nvgResetTransform(), each transformation function first creates 232 // specific transformation matrix and pre-multiplies the current transformation by it. 233 // 234 // Current coordinate system (transformation) can be saved and restored using nvgSave() and nvgRestore(). 235 236 // Resets current transform to a identity matrix. 237 void nvgResetTransform(NVGcontext* ctx); 238 239 // Premultiplies current coordinate system by specified matrix. 240 // The parameters are interpreted as matrix as follows: 241 // [a c e] 242 // [b d f] 243 // [0 0 1] 244 void nvgTransform(NVGcontext* ctx, float a, float b, float c, float d, float e, float f); 245 246 // Translates current coordinate system. 247 void nvgTranslate(NVGcontext* ctx, float x, float y); 248 249 // Rotates current coordinate system. Angle is specified in radians. 250 void nvgRotate(NVGcontext* ctx, float angle); 251 252 // Skews the current coordinate system along X axis. Angle is specified in radians. 253 void nvgSkewX(NVGcontext* ctx, float angle); 254 255 // Skews the current coordinate system along Y axis. Angle is specified in radians. 256 void nvgSkewY(NVGcontext* ctx, float angle); 257 258 // Scales the current coordinate system. 259 void nvgScale(NVGcontext* ctx, float x, float y); 260 261 // Stores the top part (a-f) of the current transformation matrix in to the specified buffer. 262 // [a c e] 263 // [b d f] 264 // [0 0 1] 265 // There should be space for 6 floats in the return buffer for the values a-f. 266 void nvgCurrentTransform(NVGcontext* ctx, float* xform); 267 268 269 // The following functions can be used to make calculations on 2x3 transformation matrices. 270 // A 2x3 matrix is represented as float[6]. 271 272 // Sets the transform to identity matrix. 273 void nvgTransformIdentity(float* dst); 274 275 // Sets the transform to translation matrix matrix. 276 void nvgTransformTranslate(float* dst, float tx, float ty); 277 278 // Sets the transform to scale matrix. 279 void nvgTransformScale(float* dst, float sx, float sy); 280 281 // Sets the transform to rotate matrix. Angle is specified in radians. 282 void nvgTransformRotate(float* dst, float a); 283 284 // Sets the transform to skew-x matrix. Angle is specified in radians. 285 void nvgTransformSkewX(float* dst, float a); 286 287 // Sets the transform to skew-y matrix. Angle is specified in radians. 288 void nvgTransformSkewY(float* dst, float a); 289 290 // Sets the transform to the result of multiplication of two transforms, of A = A*B. 291 void nvgTransformMultiply(float* dst, const float* src); 292 293 // Sets the transform to the result of multiplication of two transforms, of A = B*A. 294 void nvgTransformPremultiply(float* dst, const float* src); 295 296 // Sets the destination to inverse of specified transform. 297 // Returns 1 if the inverse could be calculated, else 0. 298 int nvgTransformInverse(float* dst, const float* src); 299 300 // Transform a point by given transform. 301 void nvgTransformPoint(float* dstx, float* dsty, const float* xform, float srcx, float srcy); 302 303 // Converts degrees to radians and vice versa. 304 float nvgDegToRad(float deg); 305 float nvgRadToDeg(float rad); 306 307 // 308 // Images 309 // 310 // NanoVG allows you to load jpg, png, psd, tga, pic and gif files to be used for rendering. 311 // In addition you can upload your own image. The image loading is provided by stb_image. 312 // The parameter imageFlags is combination of flags defined in NVGimageFlags. 313 314 // Creates image by loading it from the disk from specified file name. 315 // Returns handle to the image. 316 int nvgCreateImage(NVGcontext* ctx, const char* filename, int imageFlags); 317 318 // Creates image by loading it from the specified chunk of memory. 319 // Returns handle to the image. 320 int nvgCreateImageMem(NVGcontext* ctx, int imageFlags, const unsigned char* data, int ndata); 321 322 // Creates image from specified image data. 323 // Returns handle to the image. 324 int nvgCreateImageRGBA(NVGcontext* ctx, int w, int h, int imageFlags, const unsigned char* data); 325 326 // Updates image data specified by image handle. 327 void nvgUpdateImage(NVGcontext* ctx, int image, const unsigned char* data); 328 329 // Returns the dimensions of a created image. 330 void nvgImageSize(NVGcontext* ctx, int image, int* w, int* h); 331 332 // Deletes created image. 333 void nvgDeleteImage(NVGcontext* ctx, int image); 334 335 // 336 // Paints 337 // 338 // NanoVG supports four types of paints: linear gradient, box gradient, radial gradient and image pattern. 339 // These can be used as paints for strokes and fills. 340 341 // Creates and returns a linear gradient. Parameters (sx,sy)-(ex,ey) specify the start and end coordinates 342 // of the linear gradient, icol specifies the start color and ocol the end color. 343 // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). 344 NVGpaint nvgLinearGradient(NVGcontext* ctx, float sx, float sy, float ex, float ey, 345 NVGcolor icol, NVGcolor ocol); 346 347 // Creates and returns a box gradient. Box gradient is a feathered rounded rectangle, it is useful for rendering 348 // drop shadows or highlights for boxes. Parameters (x,y) define the top-left corner of the rectangle, 349 // (w,h) define the size of the rectangle, r defines the corner radius, and f feather. Feather defines how blurry 350 // the border of the rectangle is. Parameter icol specifies the inner color and ocol the outer color of the gradient. 351 // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). 352 NVGpaint nvgBoxGradient(NVGcontext* ctx, float x, float y, float w, float h, 353 float r, float f, NVGcolor icol, NVGcolor ocol); 354 355 // Creates and returns a radial gradient. Parameters (cx,cy) specify the center, inr and outr specify 356 // the inner and outer radius of the gradient, icol specifies the start color and ocol the end color. 357 // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). 358 NVGpaint nvgRadialGradient(NVGcontext* ctx, float cx, float cy, float inr, float outr, 359 NVGcolor icol, NVGcolor ocol); 360 361 // Creates and returns an image patter. Parameters (ox,oy) specify the left-top location of the image pattern, 362 // (ex,ey) the size of one image, angle rotation around the top-left corner, image is handle to the image to render. 363 // The gradient is transformed by the current transform when it is passed to nvgFillPaint() or nvgStrokePaint(). 364 NVGpaint nvgImagePattern(NVGcontext* ctx, float ox, float oy, float ex, float ey, 365 float angle, int image, float alpha); 366 367 // 368 // Scissoring 369 // 370 // Scissoring allows you to clip the rendering into a rectangle. This is useful for various 371 // user interface cases like rendering a text edit or a timeline. 372 373 // Sets the current scissor rectangle. 374 // The scissor rectangle is transformed by the current transform. 375 void nvgScissor(NVGcontext* ctx, float x, float y, float w, float h); 376 377 // Intersects current scissor rectangle with the specified rectangle. 378 // The scissor rectangle is transformed by the current transform. 379 // Note: in case the rotation of previous scissor rect differs from 380 // the current one, the intersection will be done between the specified 381 // rectangle and the previous scissor rectangle transformed in the current 382 // transform space. The resulting shape is always rectangle. 383 void nvgIntersectScissor(NVGcontext* ctx, float x, float y, float w, float h); 384 385 // Reset and disables scissoring. 386 void nvgResetScissor(NVGcontext* ctx); 387 388 // 389 // Paths 390 // 391 // Drawing a new shape starts with nvgBeginPath(), it clears all the currently defined paths. 392 // Then you define one or more paths and sub-paths which describe the shape. The are functions 393 // to draw common shapes like rectangles and circles, and lower level step-by-step functions, 394 // which allow to define a path curve by curve. 395 // 396 // NanoVG uses even-odd fill rule to draw the shapes. Solid shapes should have counter clockwise 397 // winding and holes should have counter clockwise order. To specify winding of a path you can 398 // call nvgPathWinding(). This is useful especially for the common shapes, which are drawn CCW. 399 // 400 // Finally you can fill the path using current fill style by calling nvgFill(), and stroke it 401 // with current stroke style by calling nvgStroke(). 402 // 403 // The curve segments and sub-paths are transformed by the current transform. 404 405 // Clears the current path and sub-paths. 406 void nvgBeginPath(NVGcontext* ctx); 407 408 // Starts new sub-path with specified point as first point. 409 void nvgMoveTo(NVGcontext* ctx, float x, float y); 410 411 // Adds line segment from the last point in the path to the specified point. 412 void nvgLineTo(NVGcontext* ctx, float x, float y); 413 414 // Adds cubic bezier segment from last point in the path via two control points to the specified point. 415 void nvgBezierTo(NVGcontext* ctx, float c1x, float c1y, float c2x, float c2y, float x, float y); 416 417 // Adds quadratic bezier segment from last point in the path via a control point to the specified point. 418 void nvgQuadTo(NVGcontext* ctx, float cx, float cy, float x, float y); 419 420 // Adds an arc segment at the corner defined by the last path point, and two specified points. 421 void nvgArcTo(NVGcontext* ctx, float x1, float y1, float x2, float y2, float radius); 422 423 // Closes current sub-path with a line segment. 424 void nvgClosePath(NVGcontext* ctx); 425 426 // Sets the current sub-path winding, see NVGwinding and NVGsolidity. 427 void nvgPathWinding(NVGcontext* ctx, int dir); 428 429 // Creates new circle arc shaped sub-path. The arc center is at cx,cy, the arc radius is r, 430 // and the arc is drawn from angle a0 to a1, and swept in direction dir (NVG_CCW, or NVG_CW). 431 // Angles are specified in radians. 432 void nvgArc(NVGcontext* ctx, float cx, float cy, float r, float a0, float a1, int dir); 433 434 // Creates new rectangle shaped sub-path. 435 void nvgRect(NVGcontext* ctx, float x, float y, float w, float h); 436 437 // Creates new rounded rectangle shaped sub-path. 438 void nvgRoundedRect(NVGcontext* ctx, float x, float y, float w, float h, float r); 439 440 // Creates new ellipse shaped sub-path. 441 void nvgEllipse(NVGcontext* ctx, float cx, float cy, float rx, float ry); 442 443 // Creates new circle shaped sub-path. 444 void nvgCircle(NVGcontext* ctx, float cx, float cy, float r); 445 446 // Fills the current path with current fill style. 447 void nvgFill(NVGcontext* ctx); 448 449 // Fills the current path with current stroke style. 450 void nvgStroke(NVGcontext* ctx); 451 452 453 // 454 // Text 455 // 456 // NanoVG allows you to load .ttf files and use the font to render text. 457 // 458 // The appearance of the text can be defined by setting the current text style 459 // and by specifying the fill color. Common text and font settings such as 460 // font size, letter spacing and text align are supported. Font blur allows you 461 // to create simple text effects such as drop shadows. 462 // 463 // At render time the font face can be set based on the font handles or name. 464 // 465 // Font measure functions return values in local space, the calculations are 466 // carried in the same resolution as the final rendering. This is done because 467 // the text glyph positions are snapped to the nearest pixels sharp rendering. 468 // 469 // The local space means that values are not rotated or scale as per the current 470 // transformation. For example if you set font size to 12, which would mean that 471 // line height is 16, then regardless of the current scaling and rotation, the 472 // returned line height is always 16. Some measures may vary because of the scaling 473 // since aforementioned pixel snapping. 474 // 475 // While this may sound a little odd, the setup allows you to always render the 476 // same way regardless of scaling. I.e. following works regardless of scaling: 477 // 478 // const char* txt = "Text me up."; 479 // nvgTextBounds(vg, x,y, txt, NULL, bounds); 480 // nvgBeginPath(vg); 481 // nvgRoundedRect(vg, bounds[0],bounds[1], bounds[2]-bounds[0], bounds[3]-bounds[1]); 482 // nvgFill(vg); 483 // 484 // Note: currently only solid color fill is supported for text. 485 486 // Creates font by loading it from the disk from specified file name. 487 // Returns handle to the font. 488 int nvgCreateFont(NVGcontext* ctx, const char* name, const char* filename); 489 490 // Creates image by loading it from the specified memory chunk. 491 // Returns handle to the font. 492 int nvgCreateFontMem(NVGcontext* ctx, const char* name, const unsigned char* data, int ndata, int freeData); 493 494 // Finds a loaded font of specified name, and returns handle to it, or -1 if the font is not found. 495 int nvgFindFont(NVGcontext* ctx, const char* name); 496 497 // Sets the font size of current text style. 498 void nvgFontSize(NVGcontext* ctx, float size); 499 500 // Sets the blur of current text style. 501 void nvgFontBlur(NVGcontext* ctx, float blur); 502 503 // Sets the letter spacing of current text style. 504 void nvgTextLetterSpacing(NVGcontext* ctx, float spacing); 505 506 // Sets the proportional line height of current text style. The line height is specified as multiple of font size. 507 void nvgTextLineHeight(NVGcontext* ctx, float lineHeight); 508 509 // Sets the text align of current text style, see NVGalign for options. 510 void nvgTextAlign(NVGcontext* ctx, int align); 511 512 // Sets the font face based on specified id of current text style. 513 void nvgFontFaceId(NVGcontext* ctx, int font); 514 515 // Sets the font face based on specified name of current text style. 516 void nvgFontFace(NVGcontext* ctx, const char* font); 517 518 // Draws text string at specified location. If end is specified only the sub-string up to the end is drawn. 519 float nvgText(NVGcontext* ctx, float x, float y, const char* string, const char* end); 520 521 // 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. 522 // White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. 523 // Words longer than the max width are slit at nearest character (i.e. no hyphenation). 524 void nvgTextBox(NVGcontext* ctx, float x, float y, float breakRowWidth, const char* string, const char* end); 525 526 // Measures the specified text string. Parameter bounds should be a pointer to float[4], 527 // if the bounding box of the text should be returned. The bounds value are [xmin,ymin, xmax,ymax] 528 // Returns the horizontal advance of the measured text (i.e. where the next character should drawn). 529 // Measured values are returned in local coordinate space. 530 float nvgTextBounds(NVGcontext* ctx, float x, float y, const char* string, const char* end, float* bounds); 531 532 // Measures the specified multi-text string. Parameter bounds should be a pointer to float[4], 533 // if the bounding box of the text should be returned. The bounds value are [xmin,ymin, xmax,ymax] 534 // Measured values are returned in local coordinate space. 535 void nvgTextBoxBounds(NVGcontext* ctx, float x, float y, float breakRowWidth, const char* string, const char* end, float* bounds); 536 537 // Calculates the glyph x positions of the specified text. If end is specified only the sub-string will be used. 538 // Measured values are returned in local coordinate space. 539 int nvgTextGlyphPositions(NVGcontext* ctx, float x, float y, const char* string, const char* end, NVGglyphPosition* positions, int maxPositions); 540 541 // Returns the vertical metrics based on the current text style. 542 // Measured values are returned in local coordinate space. 543 void nvgTextMetrics(NVGcontext* ctx, float* ascender, float* descender, float* lineh); 544 545 // Breaks the specified text into lines. If end is specified only the sub-string will be used. 546 // White space is stripped at the beginning of the rows, the text is split at word boundaries or when new-line characters are encountered. 547 // Words longer than the max width are slit at nearest character (i.e. no hyphenation). 548 int nvgTextBreakLines(NVGcontext* ctx, const char* string, const char* end, float breakRowWidth, NVGtextRow* rows, int maxRows); 549 550 // 551 // Internal Render API 552 // 553 enum NVGtexture { 554 NVG_TEXTURE_ALPHA = 0x01, 555 NVG_TEXTURE_RGBA = 0x02, 556 }; 557 558 struct NVGscissor { 559 float xform[6]; 560 float extent[2]; 561 }; 562 typedef struct NVGscissor NVGscissor; 563 564 struct NVGvertex { 565 float x,y,u,v; 566 }; 567 typedef struct NVGvertex NVGvertex; 568 569 struct NVGpath { 570 int first; 571 int count; 572 unsigned char closed; 573 int nbevel; 574 NVGvertex* fill; 575 int nfill; 576 NVGvertex* stroke; 577 int nstroke; 578 int winding; 579 int convex; 580 }; 581 typedef struct NVGpath NVGpath; 582 583 struct NVGparams { 584 void* userPtr; 585 int edgeAntiAlias; 586 int (*renderCreate)(void* uptr); 587 int (*renderCreateTexture)(void* uptr, int type, int w, int h, int imageFlags, const unsigned char* data); 588 int (*renderDeleteTexture)(void* uptr, int image); 589 int (*renderUpdateTexture)(void* uptr, int image, int x, int y, int w, int h, const unsigned char* data); 590 int (*renderGetTextureSize)(void* uptr, int image, int* w, int* h); 591 void (*renderViewport)(void* uptr, int width, int height); 592 void (*renderCancel)(void* uptr); 593 void (*renderFlush)(void* uptr); 594 void (*renderFill)(void* uptr, NVGpaint* paint, NVGscissor* scissor, float fringe, const float* bounds, const NVGpath* paths, int npaths); 595 void (*renderStroke)(void* uptr, NVGpaint* paint, NVGscissor* scissor, float fringe, float strokeWidth, const NVGpath* paths, int npaths); 596 void (*renderTriangles)(void* uptr, NVGpaint* paint, NVGscissor* scissor, const NVGvertex* verts, int nverts); 597 void (*renderDelete)(void* uptr); 598 }; 599 typedef struct NVGparams NVGparams; 600 601 // Constructor and destructor, called by the render back-end. 602 NVGcontext* nvgCreateInternal(NVGparams* params); 603 void nvgDeleteInternal(NVGcontext* ctx); 604 605 NVGparams* nvgInternalParams(NVGcontext* ctx); 606 607 // Debug function to dump cached path data. 608 void nvgDebugDumpPathCache(NVGcontext* ctx); 609 610 #ifdef _MSC_VER 611 #pragma warning(pop) 612 #endif 613 614 #define NVG_NOTUSED(v) for (;;) { (void)(1 ? (void)0 : ( (void)(v) ) ); break; } 615 616 #ifdef __cplusplus 617 } 618 #endif 619 620 #endif // NANOVG_H 621