This branch has a lot of significant changes to the original project, its diverging now quite a bit from the original:

• low level access to TrueType fonts with nvgGetFontHandle
• low level texture handling with nvgCreateImageTexture and nvgImageTextureInfo and nvgForgetImageTexture
• more control over scissors with nvgGetScissor and nvgSetScissor
• added functions nvgChangeFrame and nvgFlushFrame, useful when mixing in FBO code
• there are now three different NVGcontext types. Whereas NVG_FULL_CONTEXT retains full compatibility, NVG_PATH_CONTEXT and NVG_FONT_CONTEXT do not need an OpenGL context, and NVG_PATH_CONTEXT can't additionally deal with fonts
• for NVG_PATH_CONTEXT you can now "precompile" your tesselation with NVG_PATH_CONTEXT and copy it to a NVG_FULL_CONTEXT with nvgCopyPath
• struct NVGglyphPosition has now miny and maxx fields
• new function nvgTextVisualBounds more accurately determines "black ink" space
• added function nvgBezierTessellation to support the merged AFD tesselation code from #328
• added ClearType support from @Const-me (see below), with functions nvgClearType, nvgTextColor, nvgTextBackgroundColor
• added a scheme to extend nanovg through #include to get access to private functions
• improved texture management code #656
• support for MSAA added
• new function nvgTextVisualMetrics
• nvgTrace added for debugging and vibecoding
• nvgTextBreakLines can be used to count the actual lines (pass NULL for rows)

This backports the ClearType code from @Const-me to C. Compile this with -DNANOVG_CLEARTYPE to get the new feature.

Above standard antialias, below cleartype:

The shader uses dFdx, which according to this comment is not available on GLES2. But this example was run with GLES2, so ????

NanoVG is small antialiased vector graphics rendering library for OpenGL. It has lean API modeled after HTML5 canvas API. It is aimed to be a practical and fun toolset for building scalable user interfaces and visualizations.

The NanoVG API is modeled loosely on HTML5 canvas API. If you know canvas, you're up to speed with NanoVG in no time.

The drawing context is created using platform specific constructor function. If you're using the OpenGL 2.0 back-end the context is created as follows:

#define NANOVG_GL2_IMPLEMENTATION	// Use GL2 implementation.
#include "nanovg_gl.h"
...
struct NVGcontext* vg = nvgCreateGL2(NVG_ANTIALIAS | NVG_STENCIL_STROKES);

The first parameter defines flags for creating the renderer.

• NVG_ANTIALIAS means that the renderer adjusts the geometry to include anti-aliasing. If you're using MSAA, you can omit this flags.
• NVG_STENCIL_STROKES means that the render uses better quality rendering for (overlapping) strokes. The quality is mostly visible on wider strokes. If you want speed, you can omit this flag.

Currently there is an OpenGL back-end for NanoVG: nanovg_gl.h for OpenGL 2.0, OpenGL ES 2.0, OpenGL 3.2 core profile and OpenGL ES 3. The implementation can be chosen using a define as in above example. See the header file and examples for further info.

NOTE: The render target you're rendering to must have stencil buffer.

Drawing a simple shape using NanoVG consists of four steps: 1) begin a new shape, 2) define the path to draw, 3) set fill or stroke, 4) and finally fill or stroke the path.

nvgBeginPath(vg);
nvgRect(vg, 100,100, 120,30);
nvgFillColor(vg, nvgRGBA(255,192,0,255));
nvgFill(vg);

Calling nvgBeginPath() will clear any existing paths and start drawing from blank slate. There are number of number of functions to define the path to draw, such as rectangle, rounded rectangle and ellipse, or you can use the common moveTo, lineTo, bezierTo and arcTo API to compose the paths step by step.

Because of the way the rendering backend is build in NanoVG, drawing a composite path, that is path consisting from multiple paths defining holes and fills, is a bit more involved. NanoVG uses even-odd filling rule and by default the paths are wound in counter clockwise order. Keep that in mind when drawing using the low level draw API. In order to wind one of the predefined shapes as a hole, you should call nvgPathWinding(vg, NVG_HOLE), or nvgPathWinding(vg, NVG_CW) after defining the path.

nvgBeginPath(vg);
nvgRect(vg, 100,100, 120,30);
nvgCircle(vg, 120,120, 5);
nvgPathWinding(vg, NVG_HOLE);	// Mark circle as a hole.
nvgFillColor(vg, nvgRGBA(255,192,0,255));
nvgFill(vg);

• make sure you have created NanoVG context using one of the nvgCreatexxx() calls
• make sure you have initialised OpenGL with stencil buffer
• make sure you have cleared stencil buffer
• make sure all rendering calls happen between nvgBeginFrame() and nvgEndFrame()
• to enable more checks for OpenGL errors, add NVG_DEBUG flag to nvgCreatexxx()
• if the problem still persists, please report an issue!

The OpenGL back-end touches following states:

When textures are uploaded or updated, the following pixel store is set to defaults: GL_UNPACK_ALIGNMENT, GL_UNPACK_ROW_LENGTH, GL_UNPACK_SKIP_PIXELS, GL_UNPACK_SKIP_ROWS. Texture binding is also affected. Texture updates can happen when the user loads images, or when new font glyphs are added. Glyphs are added as needed between calls to nvgBeginFrame() and nvgEndFrame().

The data for the whole frame is buffered and flushed in nvgEndFrame(). The following code illustrates the OpenGL state touched by the rendering code:

	glUseProgram(prog);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_CULL_FACE);
	glCullFace(GL_BACK);
	glFrontFace(GL_CCW);
	glEnable(GL_BLEND);
	glDisable(GL_DEPTH_TEST);
	glDisable(GL_SCISSOR_TEST);
	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
	glStencilMask(0xffffffff);
	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
	glStencilFunc(GL_ALWAYS, 0, 0xffffffff);
	glActiveTexture(GL_TEXTURE0);
	glBindBuffer(GL_UNIFORM_BUFFER, buf);
	glBindVertexArray(arr);
	glBindBuffer(GL_ARRAY_BUFFER, buf);
	glBindTexture(GL_TEXTURE_2D, tex);
	glUniformBlockBinding(... , GLNVG_FRAG_BINDING);

See the header file nanovg.h for API reference.

• DX11 port by Chris Maughan
• Metal port by Olli Wang
• bgfx port by Branimir Karadžić

• Processing API simulation by vinjn
• NanoVG for .NET, C# P/Invoke binding

The library is licensed under zlib license Fonts used in examples:

• Roboto licensed under Apache license
• Entypo licensed under CC BY-SA 4.0.
• Noto Emoji licensed under SIL Open Font License, Version 1.1

NanoVG mailing list

Uses stb_truetype (or, optionally, freetype) for font rendering. Uses stb_image for image loading.