Package org.lwjgl.nanovg

Class NanoVG

java.lang.Object
org.lwjgl.nanovg.NanoVG
public class NanoVG extends Object

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    NVG_ALIGN_BASELINE
     
    static final int
    NVG_ALIGN_BOTTOM
     
    static final int
    NVG_ALIGN_CENTER
     
    static final int
    NVG_ALIGN_LEFT
     
    static final int
    NVG_ALIGN_MIDDLE
     
    static final int
    NVG_ALIGN_RIGHT
     
    static final int
    NVG_ALIGN_TOP
     
    static final int
    NVG_ATOP
     
    static final int
    NVG_BEVEL
     
    static final int
    NVG_BUTT
     
    static final int
    NVG_CCW
     
    static final int
    NVG_COPY
     
    static final int
    NVG_CW
     
    static final int
    NVG_DESTINATION_ATOP
     
    static final int
    NVG_DESTINATION_IN
     
    static final int
    NVG_DESTINATION_OUT
     
    static final int
    NVG_DESTINATION_OVER
     
    static final int
    NVG_DST_ALPHA
     
    static final int
    NVG_DST_COLOR
     
    static final int
    NVG_HOLE
     
    static final int
    NVG_IMAGE_FLIPY
     
    static final int
    NVG_IMAGE_GENERATE_MIPMAPS
     
    static final int
    NVG_IMAGE_NEAREST
     
    static final int
    NVG_IMAGE_PREMULTIPLIED
     
    static final int
    NVG_IMAGE_REPEATX
     
    static final int
    NVG_IMAGE_REPEATY
     
    static final int
    NVG_LIGHTER
     
    static final int
    NVG_MITER
     
    static final int
    NVG_ONE
     
    static final int
    NVG_ONE_MINUS_DST_ALPHA
     
    static final int
    NVG_ONE_MINUS_DST_COLOR
     
    static final int
    NVG_ONE_MINUS_SRC_ALPHA
     
    static final int
    NVG_ONE_MINUS_SRC_COLOR
     
    static final float
    NVG_PI
     
    static final int
    NVG_ROUND
     
    static final int
    NVG_SOLID
     
    static final int
    NVG_SOURCE_IN
     
    static final int
    NVG_SOURCE_OUT
     
    static final int
    NVG_SOURCE_OVER
     
    static final int
    NVG_SQUARE
     
    static final int
    NVG_SRC_ALPHA
     
    static final int
    NVG_SRC_ALPHA_SATURATE
     
    static final int
    NVG_SRC_COLOR
     
    static final int
    NVG_XOR
     
    static final int
    NVG_ZERO
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static int
    nnvgAddFallbackFont(long ctx, long baseFont, long fallbackFont)
    int nvgAddFallbackFont(NVGcontext * ctx, char const * baseFont, char const * fallbackFont)
    static int
    nnvgAddFallbackFontId(long ctx, int baseFont, int fallbackFont)
    int nvgAddFallbackFontId(NVGcontext * ctx, int baseFont, int fallbackFont)
    static void
    nnvgArc(long ctx, float cx, float cy, float r, float a0, float a1, int dir)
    void nvgArc(NVGcontext * ctx, float cx, float cy, float r, float a0, float a1, int dir)
    static void
    nnvgArcTo(long ctx, float x1, float y1, float x2, float y2, float radius)
    void nvgArcTo(NVGcontext * ctx, float x1, float y1, float x2, float y2, float radius)
    static void
    nnvgBeginFrame(long ctx, float windowWidth, float windowHeight, float devicePixelRatio)
    void nvgBeginFrame(NVGcontext * ctx, float windowWidth, float windowHeight, float devicePixelRatio)
    static void
    nnvgBeginPath(long ctx)
    void nvgBeginPath(NVGcontext * ctx)
    static void
    nnvgBezierTo(long ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)
    void nvgBezierTo(NVGcontext * ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)
    static void
    nnvgBoxGradient(long ctx, float x, float y, float w, float h, float r, float f, long icol, long ocol, long __result)
    NVGpaint nvgBoxGradient(NVGcontext * ctx, float x, float y, float w, float h, float r, float f, NVGcolor icol, NVGcolor ocol)
    static void
    nnvgCancelFrame(long ctx)
    void nvgCancelFrame(NVGcontext * ctx)
    static void
    nnvgCircle(long ctx, float cx, float cy, float r)
    void nvgCircle(NVGcontext * ctx, float cx, float cy, float r)
    static void
    nnvgClosePath(long ctx)
    void nvgClosePath(NVGcontext * ctx)
    static int
    nnvgCreateFont(long ctx, long name, long filename)
    int nvgCreateFont(NVGcontext * ctx, char const * name, char const * filename)
    static int
    nnvgCreateFontAtIndex(long ctx, long name, long filename, int fontIndex)
    int nvgCreateFontAtIndex(NVGcontext * ctx, char const * name, char const * filename, int fontIndex)
    static int
    nnvgCreateFontMem(long ctx, long name, long data, int ndata, int freeData)
    int nvgCreateFontMem(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData)
    static int
    nnvgCreateFontMemAtIndex(long ctx, long name, long data, int ndata, int freeData, int fontIndex)
    int nvgCreateFontMemAtIndex(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData, int fontIndex)
    static int
    nnvgCreateImage(long ctx, long filename, int imageFlags)
    int nvgCreateImage(NVGcontext * ctx, char const * filename, int imageFlags)
    static int
    nnvgCreateImageMem(long ctx, int imageFlags, long data, int ndata)
    int nvgCreateImageMem(NVGcontext * ctx, int imageFlags, unsigned char * data, int ndata)
    static int
    nnvgCreateImageRGBA(long ctx, int w, int h, int imageFlags, long data)
    int nvgCreateImageRGBA(NVGcontext * ctx, int w, int h, int imageFlags, unsigned char const * data)
    static void
    nnvgCurrentTransform(long ctx, float[] xform)
    void nvgCurrentTransform(NVGcontext * ctx, float * xform)
    static void
    nnvgCurrentTransform(long ctx, long xform)
    void nvgCurrentTransform(NVGcontext * ctx, float * xform)
    static void
    nnvgDeleteImage(long ctx, int image)
    void nvgDeleteImage(NVGcontext * ctx, int image)
    static void
    nnvgEllipse(long ctx, float cx, float cy, float rx, float ry)
    void nvgEllipse(NVGcontext * ctx, float cx, float cy, float rx, float ry)
    static void
    nnvgEndFrame(long ctx)
    void nvgEndFrame(NVGcontext * ctx)
    static void
    nnvgFill(long ctx)
    void nvgFill(NVGcontext * ctx)
    static void
    nnvgFillColor(long ctx, long color)
    void nvgFillColor(NVGcontext * ctx, NVGcolor color)
    static void
    nnvgFillPaint(long ctx, long paint)
    void nvgFillPaint(NVGcontext * ctx, NVGpaint paint)
    static int
    nnvgFindFont(long ctx, long name)
    int nvgFindFont(NVGcontext * ctx, char const * name)
    static void
    nnvgFontBlur(long ctx, float blur)
    void nvgFontBlur(NVGcontext * ctx, float blur)
    static void
    nnvgFontFace(long ctx, long font)
    void nvgFontFace(NVGcontext * ctx, char const * font)
    static void
    nnvgFontFaceId(long ctx, int font)
    void nvgFontFaceId(NVGcontext * ctx, int font)
    static void
    nnvgFontSize(long ctx, float size)
    void nvgFontSize(NVGcontext * ctx, float size)
    static void
    nnvgGlobalAlpha(long ctx, float alpha)
    void nvgGlobalAlpha(NVGcontext * ctx, float alpha)
    static void
    nnvgGlobalCompositeBlendFunc(long ctx, int sfactor, int dfactor)
    void nvgGlobalCompositeBlendFunc(NVGcontext * ctx, int sfactor, int dfactor)
    static void
    nnvgGlobalCompositeBlendFuncSeparate(long ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)
    void nvgGlobalCompositeBlendFuncSeparate(NVGcontext * ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)
    static void
    nnvgGlobalCompositeOperation(long ctx, int op)
    void nvgGlobalCompositeOperation(NVGcontext * ctx, int op)
    static void
    nnvgHSL(float h, float s, float l, long __result)
    NVGcolor nvgHSL(float h, float s, float l)
    static void
    nnvgHSLA(float h, float s, float l, byte a, long __result)
    NVGcolor nvgHSLA(float h, float s, float l, unsigned char a)
    static void
    nnvgImagePattern(long ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha, long __result)
    NVGpaint nvgImagePattern(NVGcontext * ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha)
    static void
    nnvgImageSize(long ctx, int image, int[] w, int[] h)
    void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)
    static void
    nnvgImageSize(long ctx, int image, long w, long h)
    void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)
    static void
    nnvgIntersectScissor(long ctx, float x, float y, float w, float h)
    void nvgIntersectScissor(NVGcontext * ctx, float x, float y, float w, float h)
    static void
    nnvgLerpRGBA(long c0, long c1, float u, long __result)
    NVGcolor nvgLerpRGBA(NVGcolor c0, NVGcolor c1, float u)
    static void
    nnvgLinearGradient(long ctx, float sx, float sy, float ex, float ey, long icol, long ocol, long __result)
    NVGpaint nvgLinearGradient(NVGcontext * ctx, float sx, float sy, float ex, float ey, NVGcolor icol, NVGcolor ocol)
    static void
    nnvgLineCap(long ctx, int cap)
    void nvgLineCap(NVGcontext * ctx, int cap)
    static void
    nnvgLineJoin(long ctx, int join)
    void nvgLineJoin(NVGcontext * ctx, int join)
    static void
    nnvgLineTo(long ctx, float x, float y)
    void nvgLineTo(NVGcontext * ctx, float x, float y)
    static void
    nnvgMiterLimit(long ctx, float limit)
    void nvgMiterLimit(NVGcontext * ctx, float limit)
    static void
    nnvgMoveTo(long ctx, float x, float y)
    void nvgMoveTo(NVGcontext * ctx, float x, float y)
    static void
    nnvgPathWinding(long ctx, int dir)
    void nvgPathWinding(NVGcontext * ctx, int dir)
    static void
    nnvgQuadTo(long ctx, float cx, float cy, float x, float y)
    void nvgQuadTo(NVGcontext * ctx, float cx, float cy, float x, float y)
    static void
    nnvgRadialGradient(long ctx, float cx, float cy, float inr, float outr, long icol, long ocol, long __result)
    NVGpaint nvgRadialGradient(NVGcontext * ctx, float cx, float cy, float inr, float outr, NVGcolor icol, NVGcolor ocol)
    static void
    nnvgRect(long ctx, float x, float y, float w, float h)
    void nvgRect(NVGcontext * ctx, float x, float y, float w, float h)
    static void
    nnvgReset(long ctx)
    void nvgReset(NVGcontext * ctx)
    static void
    nnvgResetFallbackFonts(long ctx, long baseFont)
    void nvgResetFallbackFonts(NVGcontext * ctx, char const * baseFont)
    static void
    nnvgResetFallbackFontsId(long ctx, int baseFont)
    void nvgResetFallbackFontsId(NVGcontext * ctx, int baseFont)
    static void
    nnvgResetScissor(long ctx)
    void nvgResetScissor(NVGcontext * ctx)
    static void
    nnvgResetTransform(long ctx)
    void nvgResetTransform(NVGcontext * ctx)
    static void
    nnvgRestore(long ctx)
    void nvgRestore(NVGcontext * ctx)
    static void
    nnvgRGB(byte r, byte g, byte b, long __result)
    NVGcolor nvgRGB(unsigned char r, unsigned char g, unsigned char b)
    static void
    nnvgRGBA(byte r, byte g, byte b, byte a, long __result)
    NVGcolor nvgRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
    static void
    nnvgRGBAf(float r, float g, float b, float a, long __result)
    NVGcolor nvgRGBAf(float r, float g, float b, float a)
    static void
    nnvgRGBf(float r, float g, float b, long __result)
    NVGcolor nvgRGBf(float r, float g, float b)
    static void
    nnvgRotate(long ctx, float angle)
    void nvgRotate(NVGcontext * ctx, float angle)
    static void
    nnvgRoundedRect(long ctx, float x, float y, float w, float h, float r)
    void nvgRoundedRect(NVGcontext * ctx, float x, float y, float w, float h, float r)
    static void
    nnvgRoundedRectVarying(long ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)
    void nvgRoundedRectVarying(NVGcontext * ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)
    static void
    nnvgSave(long ctx)
    void nvgSave(NVGcontext * ctx)
    static void
    nnvgScale(long ctx, float x, float y)
    void nvgScale(NVGcontext * ctx, float x, float y)
    static void
    nnvgScissor(long ctx, float x, float y, float w, float h)
    void nvgScissor(NVGcontext * ctx, float x, float y, float w, float h)
    static void
    nnvgShapeAntiAlias(long ctx, int enabled)
    void nvgShapeAntiAlias(NVGcontext * ctx, int enabled)
    static void
    nnvgSkewX(long ctx, float angle)
    void nvgSkewX(NVGcontext * ctx, float angle)
    static void
    nnvgSkewY(long ctx, float angle)
    void nvgSkewY(NVGcontext * ctx, float angle)
    static void
    nnvgStroke(long ctx)
    void nvgStroke(NVGcontext * ctx)
    static void
    nnvgStrokeColor(long ctx, long color)
    void nvgStrokeColor(NVGcontext * ctx, NVGcolor color)
    static void
    nnvgStrokePaint(long ctx, long paint)
    void nvgStrokePaint(NVGcontext * ctx, NVGpaint paint)
    static void
    nnvgStrokeWidth(long ctx, float size)
    void nvgStrokeWidth(NVGcontext * ctx, float size)
    static float
    nnvgText(long ctx, float x, float y, long string, long end)
    float nvgText(NVGcontext * ctx, float x, float y, char const * string, char const * end)
    static void
    nnvgTextAlign(long ctx, int align)
    void nvgTextAlign(NVGcontext * ctx, int align)
    static float
    nnvgTextBounds(long ctx, float x, float y, long string, long end, float[] bounds)
    float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)
    static float
    nnvgTextBounds(long ctx, float x, float y, long string, long end, long bounds)
    float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)
    static void
    nnvgTextBox(long ctx, float x, float y, float breakRowWidth, long string, long end)
    void nvgTextBox(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end)
    static void
    nnvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, long string, long end, float[] bounds)
    void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)
    static void
    nnvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, long string, long end, long bounds)
    void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)
    static int
    nnvgTextBreakLines(long ctx, long string, long end, float breakRowWidth, long rows, int maxRows)
    int nvgTextBreakLines(NVGcontext * ctx, char const * string, char const * end, float breakRowWidth, NVGtextRow * rows, int maxRows)
    static int
    nnvgTextGlyphPositions(long ctx, float x, float y, long string, long end, long positions, int maxPositions)
    int nvgTextGlyphPositions(NVGcontext * ctx, float x, float y, char const * string, char const * end, NVGglyphPosition * positions, int maxPositions)
    static void
    nnvgTextLetterSpacing(long ctx, float spacing)
    void nvgTextLetterSpacing(NVGcontext * ctx, float spacing)
    static void
    nnvgTextLineHeight(long ctx, float lineHeight)
    void nvgTextLineHeight(NVGcontext * ctx, float lineHeight)
    static void
    nnvgTextMetrics(long ctx, float[] ascender, float[] descender, float[] lineh)
    void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)
    static void
    nnvgTextMetrics(long ctx, long ascender, long descender, long lineh)
    void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)
    static void
    nnvgTransform(long ctx, float a, float b, float c, float d, float e, float f)
    void nvgTransform(NVGcontext * ctx, float a, float b, float c, float d, float e, float f)
    static void
    nnvgTransformIdentity(float[] dst)
    void nvgTransformIdentity(float * dst)
    static void
    nnvgTransformIdentity(long dst)
    void nvgTransformIdentity(float * dst)
    static int
    nnvgTransformInverse(float[] dst, float[] src)
    int nvgTransformInverse(float * dst, float const * src)
    static int
    nnvgTransformInverse(long dst, long src)
    int nvgTransformInverse(float * dst, float const * src)
    static void
    nnvgTransformMultiply(float[] dst, float[] src)
    void nvgTransformMultiply(float * dst, float const * src)
    static void
    nnvgTransformMultiply(long dst, long src)
    void nvgTransformMultiply(float * dst, float const * src)
    static void
    nnvgTransformPoint(float[] dstx, float[] dsty, float[] xform, float srcx, float srcy)
    void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)
    static void
    nnvgTransformPoint(long dstx, long dsty, long xform, float srcx, float srcy)
    void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)
    static void
    nnvgTransformPremultiply(float[] dst, float[] src)
    void nvgTransformPremultiply(float * dst, float const * src)
    static void
    nnvgTransformPremultiply(long dst, long src)
    void nvgTransformPremultiply(float * dst, float const * src)
    static void
    nnvgTransformRotate(float[] dst, float a)
    void nvgTransformRotate(float * dst, float a)
    static void
    nnvgTransformRotate(long dst, float a)
    void nvgTransformRotate(float * dst, float a)
    static void
    nnvgTransformScale(float[] dst, float sx, float sy)
    void nvgTransformScale(float * dst, float sx, float sy)
    static void
    nnvgTransformScale(long dst, float sx, float sy)
    void nvgTransformScale(float * dst, float sx, float sy)
    static void
    nnvgTransformSkewX(float[] dst, float a)
    void nvgTransformSkewX(float * dst, float a)
    static void
    nnvgTransformSkewX(long dst, float a)
    void nvgTransformSkewX(float * dst, float a)
    static void
    nnvgTransformSkewY(float[] dst, float a)
    void nvgTransformSkewY(float * dst, float a)
    static void
    nnvgTransformSkewY(long dst, float a)
    void nvgTransformSkewY(float * dst, float a)
    static void
    nnvgTransformTranslate(float[] dst, float tx, float ty)
    void nvgTransformTranslate(float * dst, float tx, float ty)
    static void
    nnvgTransformTranslate(long dst, float tx, float ty)
    void nvgTransformTranslate(float * dst, float tx, float ty)
    static void
    nnvgTranslate(long ctx, float x, float y)
    void nvgTranslate(NVGcontext * ctx, float x, float y)
    static void
    nnvgTransRGBA(long c0, byte a, long __result)
    NVGcolor nvgTransRGBA(NVGcolor c0, unsigned char a)
    static void
    nnvgTransRGBAf(long c0, float a, long __result)
    NVGcolor nvgTransRGBAf(NVGcolor c0, float a)
    static void
    nnvgUpdateImage(long ctx, int image, long data)
    void nvgUpdateImage(NVGcontext * ctx, int image, unsigned char const * data)
    static int
    nvgAddFallbackFont(long ctx, CharSequence baseFont, CharSequence fallbackFont)
    int nvgAddFallbackFont(NVGcontext * ctx, char const * baseFont, char const * fallbackFont)
    static int
    nvgAddFallbackFont(long ctx, ByteBuffer baseFont, ByteBuffer fallbackFont)
    int nvgAddFallbackFont(NVGcontext * ctx, char const * baseFont, char const * fallbackFont)
    static int
    nvgAddFallbackFontId(long ctx, int baseFont, int fallbackFont)
    int nvgAddFallbackFontId(NVGcontext * ctx, int baseFont, int fallbackFont)
    static void
    nvgArc(long ctx, float cx, float cy, float r, float a0, float a1, int dir)
    void nvgArc(NVGcontext * ctx, float cx, float cy, float r, float a0, float a1, int dir)
    static void
    nvgArcTo(long ctx, float x1, float y1, float x2, float y2, float radius)
    void nvgArcTo(NVGcontext * ctx, float x1, float y1, float x2, float y2, float radius)
    static void
    nvgBeginFrame(long ctx, float windowWidth, float windowHeight, float devicePixelRatio)
    void nvgBeginFrame(NVGcontext * ctx, float windowWidth, float windowHeight, float devicePixelRatio)
    static void
    nvgBeginPath(long ctx)
    void nvgBeginPath(NVGcontext * ctx)
    static void
    nvgBezierTo(long ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)
    void nvgBezierTo(NVGcontext * ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)
    static NVGPaint
    nvgBoxGradient(long ctx, float x, float y, float w, float h, float r, float f, NVGColor icol, NVGColor ocol, NVGPaint __result)
    NVGpaint nvgBoxGradient(NVGcontext * ctx, float x, float y, float w, float h, float r, float f, NVGcolor icol, NVGcolor ocol)
    static void
    nvgCancelFrame(long ctx)
    void nvgCancelFrame(NVGcontext * ctx)
    static void
    nvgCircle(long ctx, float cx, float cy, float r)
    void nvgCircle(NVGcontext * ctx, float cx, float cy, float r)
    static void
    nvgClosePath(long ctx)
    void nvgClosePath(NVGcontext * ctx)
    static int
    nvgCreateFont(long ctx, CharSequence name, CharSequence filename)
    int nvgCreateFont(NVGcontext * ctx, char const * name, char const * filename)
    static int
    nvgCreateFont(long ctx, ByteBuffer name, ByteBuffer filename)
    int nvgCreateFont(NVGcontext * ctx, char const * name, char const * filename)
    static int
    nvgCreateFontAtIndex(long ctx, CharSequence name, CharSequence filename, int fontIndex)
    int nvgCreateFontAtIndex(NVGcontext * ctx, char const * name, char const * filename, int fontIndex)
    static int
    nvgCreateFontAtIndex(long ctx, ByteBuffer name, ByteBuffer filename, int fontIndex)
    int nvgCreateFontAtIndex(NVGcontext * ctx, char const * name, char const * filename, int fontIndex)
    static int
    nvgCreateFontMem(long ctx, CharSequence name, ByteBuffer data, boolean freeData)
    int nvgCreateFontMem(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData)
    static int
    nvgCreateFontMem(long ctx, ByteBuffer name, ByteBuffer data, boolean freeData)
    int nvgCreateFontMem(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData)
    static int
    nvgCreateFontMemAtIndex(long ctx, CharSequence name, ByteBuffer data, boolean freeData, int fontIndex)
    int nvgCreateFontMemAtIndex(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData, int fontIndex)
    static int
    nvgCreateFontMemAtIndex(long ctx, ByteBuffer name, ByteBuffer data, boolean freeData, int fontIndex)
    int nvgCreateFontMemAtIndex(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData, int fontIndex)
    static int
    nvgCreateImage(long ctx, CharSequence filename, int imageFlags)
    int nvgCreateImage(NVGcontext * ctx, char const * filename, int imageFlags)
    static int
    nvgCreateImage(long ctx, ByteBuffer filename, int imageFlags)
    int nvgCreateImage(NVGcontext * ctx, char const * filename, int imageFlags)
    static int
    nvgCreateImageMem(long ctx, int imageFlags, ByteBuffer data)
    int nvgCreateImageMem(NVGcontext * ctx, int imageFlags, unsigned char * data, int ndata)
    static int
    nvgCreateImageRGBA(long ctx, int w, int h, int imageFlags, ByteBuffer data)
    int nvgCreateImageRGBA(NVGcontext * ctx, int w, int h, int imageFlags, unsigned char const * data)
    static void
    nvgCurrentTransform(long ctx, float[] xform)
    void nvgCurrentTransform(NVGcontext * ctx, float * xform)
    static void
    nvgCurrentTransform(long ctx, FloatBuffer xform)
    void nvgCurrentTransform(NVGcontext * ctx, float * xform)
    static float
    nvgDegToRad(float deg)
    float nvgDegToRad(float deg)
    static void
    nvgDeleteImage(long ctx, int image)
    void nvgDeleteImage(NVGcontext * ctx, int image)
    static void
    nvgEllipse(long ctx, float cx, float cy, float rx, float ry)
    void nvgEllipse(NVGcontext * ctx, float cx, float cy, float rx, float ry)
    static void
    nvgEndFrame(long ctx)
    void nvgEndFrame(NVGcontext * ctx)
    static void
    nvgFill(long ctx)
    void nvgFill(NVGcontext * ctx)
    static void
    nvgFillColor(long ctx, NVGColor color)
    void nvgFillColor(NVGcontext * ctx, NVGcolor color)
    static void
    nvgFillPaint(long ctx, NVGPaint paint)
    void nvgFillPaint(NVGcontext * ctx, NVGpaint paint)
    static int
    nvgFindFont(long ctx, CharSequence name)
    int nvgFindFont(NVGcontext * ctx, char const * name)
    static int
    nvgFindFont(long ctx, ByteBuffer name)
    int nvgFindFont(NVGcontext * ctx, char const * name)
    static void
    nvgFontBlur(long ctx, float blur)
    void nvgFontBlur(NVGcontext * ctx, float blur)
    static void
    nvgFontFace(long ctx, CharSequence font)
    void nvgFontFace(NVGcontext * ctx, char const * font)
    static void
    nvgFontFace(long ctx, ByteBuffer font)
    void nvgFontFace(NVGcontext * ctx, char const * font)
    static void
    nvgFontFaceId(long ctx, int font)
    void nvgFontFaceId(NVGcontext * ctx, int font)
    static void
    nvgFontSize(long ctx, float size)
    void nvgFontSize(NVGcontext * ctx, float size)
    static void
    nvgGlobalAlpha(long ctx, float alpha)
    void nvgGlobalAlpha(NVGcontext * ctx, float alpha)
    static void
    nvgGlobalCompositeBlendFunc(long ctx, int sfactor, int dfactor)
    void nvgGlobalCompositeBlendFunc(NVGcontext * ctx, int sfactor, int dfactor)
    static void
    nvgGlobalCompositeBlendFuncSeparate(long ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)
    void nvgGlobalCompositeBlendFuncSeparate(NVGcontext * ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)
    static void
    nvgGlobalCompositeOperation(long ctx, int op)
    void nvgGlobalCompositeOperation(NVGcontext * ctx, int op)
    static NVGColor
    nvgHSL(float h, float s, float l, NVGColor __result)
    NVGcolor nvgHSL(float h, float s, float l)
    static NVGColor
    nvgHSLA(float h, float s, float l, byte a, NVGColor __result)
    NVGcolor nvgHSLA(float h, float s, float l, unsigned char a)
    static NVGPaint
    nvgImagePattern(long ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha, NVGPaint __result)
    NVGpaint nvgImagePattern(NVGcontext * ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha)
    static void
    nvgImageSize(long ctx, int image, int[] w, int[] h)
    void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)
    static void
    nvgImageSize(long ctx, int image, IntBuffer w, IntBuffer h)
    void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)
    static void
    nvgIntersectScissor(long ctx, float x, float y, float w, float h)
    void nvgIntersectScissor(NVGcontext * ctx, float x, float y, float w, float h)
    static NVGColor
    nvgLerpRGBA(NVGColor c0, NVGColor c1, float u, NVGColor __result)
    NVGcolor nvgLerpRGBA(NVGcolor c0, NVGcolor c1, float u)
    static NVGPaint
    nvgLinearGradient(long ctx, float sx, float sy, float ex, float ey, NVGColor icol, NVGColor ocol, NVGPaint __result)
    NVGpaint nvgLinearGradient(NVGcontext * ctx, float sx, float sy, float ex, float ey, NVGcolor icol, NVGcolor ocol)
    static void
    nvgLineCap(long ctx, int cap)
    void nvgLineCap(NVGcontext * ctx, int cap)
    static void
    nvgLineJoin(long ctx, int join)
    void nvgLineJoin(NVGcontext * ctx, int join)
    static void
    nvgLineTo(long ctx, float x, float y)
    void nvgLineTo(NVGcontext * ctx, float x, float y)
    static void
    nvgMiterLimit(long ctx, float limit)
    void nvgMiterLimit(NVGcontext * ctx, float limit)
    static void
    nvgMoveTo(long ctx, float x, float y)
    void nvgMoveTo(NVGcontext * ctx, float x, float y)
    static void
    nvgPathWinding(long ctx, int dir)
    void nvgPathWinding(NVGcontext * ctx, int dir)
    static void
    nvgQuadTo(long ctx, float cx, float cy, float x, float y)
    void nvgQuadTo(NVGcontext * ctx, float cx, float cy, float x, float y)
    static NVGPaint
    nvgRadialGradient(long ctx, float cx, float cy, float inr, float outr, NVGColor icol, NVGColor ocol, NVGPaint __result)
    NVGpaint nvgRadialGradient(NVGcontext * ctx, float cx, float cy, float inr, float outr, NVGcolor icol, NVGcolor ocol)
    static float
    nvgRadToDeg(float rad)
    float nvgRadToDeg(float rad)
    static void
    nvgRect(long ctx, float x, float y, float w, float h)
    void nvgRect(NVGcontext * ctx, float x, float y, float w, float h)
    static void
    nvgReset(long ctx)
    void nvgReset(NVGcontext * ctx)
    static void
    nvgResetFallbackFonts(long ctx, CharSequence baseFont)
    void nvgResetFallbackFonts(NVGcontext * ctx, char const * baseFont)
    static void
    nvgResetFallbackFonts(long ctx, ByteBuffer baseFont)
    void nvgResetFallbackFonts(NVGcontext * ctx, char const * baseFont)
    static void
    nvgResetFallbackFontsId(long ctx, int baseFont)
    void nvgResetFallbackFontsId(NVGcontext * ctx, int baseFont)
    static void
    nvgResetScissor(long ctx)
    void nvgResetScissor(NVGcontext * ctx)
    static void
    nvgResetTransform(long ctx)
    void nvgResetTransform(NVGcontext * ctx)
    static void
    nvgRestore(long ctx)
    void nvgRestore(NVGcontext * ctx)
    static NVGColor
    nvgRGB(byte r, byte g, byte b, NVGColor __result)
    NVGcolor nvgRGB(unsigned char r, unsigned char g, unsigned char b)
    static NVGColor
    nvgRGBA(byte r, byte g, byte b, byte a, NVGColor __result)
    NVGcolor nvgRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
    static NVGColor
    nvgRGBAf(float r, float g, float b, float a, NVGColor __result)
    NVGcolor nvgRGBAf(float r, float g, float b, float a)
    static NVGColor
    nvgRGBf(float r, float g, float b, NVGColor __result)
    NVGcolor nvgRGBf(float r, float g, float b)
    static void
    nvgRotate(long ctx, float angle)
    void nvgRotate(NVGcontext * ctx, float angle)
    static void
    nvgRoundedRect(long ctx, float x, float y, float w, float h, float r)
    void nvgRoundedRect(NVGcontext * ctx, float x, float y, float w, float h, float r)
    static void
    nvgRoundedRectVarying(long ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)
    void nvgRoundedRectVarying(NVGcontext * ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)
    static void
    nvgSave(long ctx)
    void nvgSave(NVGcontext * ctx)
    static void
    nvgScale(long ctx, float x, float y)
    void nvgScale(NVGcontext * ctx, float x, float y)
    static void
    nvgScissor(long ctx, float x, float y, float w, float h)
    void nvgScissor(NVGcontext * ctx, float x, float y, float w, float h)
    static void
    nvgShapeAntiAlias(long ctx, boolean enabled)
    void nvgShapeAntiAlias(NVGcontext * ctx, int enabled)
    static void
    nvgSkewX(long ctx, float angle)
    void nvgSkewX(NVGcontext * ctx, float angle)
    static void
    nvgSkewY(long ctx, float angle)
    void nvgSkewY(NVGcontext * ctx, float angle)
    static void
    nvgStroke(long ctx)
    void nvgStroke(NVGcontext * ctx)
    static void
    nvgStrokeColor(long ctx, NVGColor color)
    void nvgStrokeColor(NVGcontext * ctx, NVGcolor color)
    static void
    nvgStrokePaint(long ctx, NVGPaint paint)
    void nvgStrokePaint(NVGcontext * ctx, NVGpaint paint)
    static void
    nvgStrokeWidth(long ctx, float size)
    void nvgStrokeWidth(NVGcontext * ctx, float size)
    static float
    nvgText(long ctx, float x, float y, CharSequence string)
    float nvgText(NVGcontext * ctx, float x, float y, char const * string, char const * end)
    static float
    nvgText(long ctx, float x, float y, ByteBuffer string)
    float nvgText(NVGcontext * ctx, float x, float y, char const * string, char const * end)
    static void
    nvgTextAlign(long ctx, int align)
    void nvgTextAlign(NVGcontext * ctx, int align)
    static float
    nvgTextBounds(long ctx, float x, float y, CharSequence string, float @Nullable [] bounds)
    float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)
    static float
    nvgTextBounds(long ctx, float x, float y, CharSequence string, @Nullable FloatBuffer bounds)
    float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)
    static float
    nvgTextBounds(long ctx, float x, float y, ByteBuffer string, float @Nullable [] bounds)
    float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)
    static float
    nvgTextBounds(long ctx, float x, float y, ByteBuffer string, @Nullable FloatBuffer bounds)
    float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)
    static void
    nvgTextBox(long ctx, float x, float y, float breakRowWidth, CharSequence string)
    void nvgTextBox(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end)
    static void
    nvgTextBox(long ctx, float x, float y, float breakRowWidth, ByteBuffer string)
    void nvgTextBox(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end)
    static void
    nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, CharSequence string, float @Nullable [] bounds)
    void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)
    static void
    nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, CharSequence string, @Nullable FloatBuffer bounds)
    void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)
    static void
    nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, ByteBuffer string, float @Nullable [] bounds)
    void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)
    static void
    nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, ByteBuffer string, @Nullable FloatBuffer bounds)
    void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)
    static int
    nvgTextBreakLines(long ctx, CharSequence string, float breakRowWidth, NVGTextRow.Buffer rows)
    int nvgTextBreakLines(NVGcontext * ctx, char const * string, char const * end, float breakRowWidth, NVGtextRow * rows, int maxRows)
    static int
    nvgTextBreakLines(long ctx, ByteBuffer string, float breakRowWidth, NVGTextRow.Buffer rows)
    int nvgTextBreakLines(NVGcontext * ctx, char const * string, char const * end, float breakRowWidth, NVGtextRow * rows, int maxRows)
    static int
    nvgTextGlyphPositions(long ctx, float x, float y, CharSequence string, NVGGlyphPosition.Buffer positions)
    int nvgTextGlyphPositions(NVGcontext * ctx, float x, float y, char const * string, char const * end, NVGglyphPosition * positions, int maxPositions)
    static int
    nvgTextGlyphPositions(long ctx, float x, float y, ByteBuffer string, NVGGlyphPosition.Buffer positions)
    int nvgTextGlyphPositions(NVGcontext * ctx, float x, float y, char const * string, char const * end, NVGglyphPosition * positions, int maxPositions)
    static void
    nvgTextLetterSpacing(long ctx, float spacing)
    void nvgTextLetterSpacing(NVGcontext * ctx, float spacing)
    static void
    nvgTextLineHeight(long ctx, float lineHeight)
    void nvgTextLineHeight(NVGcontext * ctx, float lineHeight)
    static void
    nvgTextMetrics(long ctx, float @Nullable [] ascender, float @Nullable [] descender, float @Nullable [] lineh)
    void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)
    static void
    nvgTextMetrics(long ctx, @Nullable FloatBuffer ascender, @Nullable FloatBuffer descender, @Nullable FloatBuffer lineh)
    void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)
    static void
    nvgTransform(long ctx, float a, float b, float c, float d, float e, float f)
    void nvgTransform(NVGcontext * ctx, float a, float b, float c, float d, float e, float f)
    static void
    nvgTransformIdentity(float[] dst)
    void nvgTransformIdentity(float * dst)
    static void
    nvgTransformIdentity(FloatBuffer dst)
    void nvgTransformIdentity(float * dst)
    static boolean
    nvgTransformInverse(float[] dst, float[] src)
    int nvgTransformInverse(float * dst, float const * src)
    static boolean
    nvgTransformInverse(FloatBuffer dst, FloatBuffer src)
    int nvgTransformInverse(float * dst, float const * src)
    static void
    nvgTransformMultiply(float[] dst, float[] src)
    void nvgTransformMultiply(float * dst, float const * src)
    static void
    nvgTransformMultiply(FloatBuffer dst, FloatBuffer src)
    void nvgTransformMultiply(float * dst, float const * src)
    static void
    nvgTransformPoint(float[] dstx, float[] dsty, float[] xform, float srcx, float srcy)
    void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)
    static void
    nvgTransformPoint(FloatBuffer dstx, FloatBuffer dsty, FloatBuffer xform, float srcx, float srcy)
    void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)
    static void
    nvgTransformPremultiply(float[] dst, float[] src)
    void nvgTransformPremultiply(float * dst, float const * src)
    static void
    nvgTransformPremultiply(FloatBuffer dst, FloatBuffer src)
    void nvgTransformPremultiply(float * dst, float const * src)
    static void
    nvgTransformRotate(float[] dst, float a)
    void nvgTransformRotate(float * dst, float a)
    static void
    nvgTransformRotate(FloatBuffer dst, float a)
    void nvgTransformRotate(float * dst, float a)
    static void
    nvgTransformScale(float[] dst, float sx, float sy)
    void nvgTransformScale(float * dst, float sx, float sy)
    static void
    nvgTransformScale(FloatBuffer dst, float sx, float sy)
    void nvgTransformScale(float * dst, float sx, float sy)
    static void
    nvgTransformSkewX(float[] dst, float a)
    void nvgTransformSkewX(float * dst, float a)
    static void
    nvgTransformSkewX(FloatBuffer dst, float a)
    void nvgTransformSkewX(float * dst, float a)
    static void
    nvgTransformSkewY(float[] dst, float a)
    void nvgTransformSkewY(float * dst, float a)
    static void
    nvgTransformSkewY(FloatBuffer dst, float a)
    void nvgTransformSkewY(float * dst, float a)
    static void
    nvgTransformTranslate(float[] dst, float tx, float ty)
    void nvgTransformTranslate(float * dst, float tx, float ty)
    static void
    nvgTransformTranslate(FloatBuffer dst, float tx, float ty)
    void nvgTransformTranslate(float * dst, float tx, float ty)
    static void
    nvgTranslate(long ctx, float x, float y)
    void nvgTranslate(NVGcontext * ctx, float x, float y)
    static NVGColor
    nvgTransRGBA(NVGColor c0, byte a, NVGColor __result)
    NVGcolor nvgTransRGBA(NVGcolor c0, unsigned char a)
    static NVGColor
    nvgTransRGBAf(NVGColor c0, float a, NVGColor __result)
    NVGcolor nvgTransRGBAf(NVGcolor c0, float a)
    static void
    nvgUpdateImage(long ctx, int image, ByteBuffer data)
    void nvgUpdateImage(NVGcontext * ctx, int image, unsigned char const * data)

    Methods inherited from class java.lang.Object

    equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Field Details

  • Method Details

    • nnvgBeginFrame

      public static void nnvgBeginFrame(long ctx, float windowWidth, float windowHeight, float devicePixelRatio)
      void nvgBeginFrame(NVGcontext * ctx, float windowWidth, float windowHeight, float devicePixelRatio)

    • nvgBeginFrame

      public static void nvgBeginFrame(long ctx, float windowWidth, float windowHeight, float devicePixelRatio)
      void nvgBeginFrame(NVGcontext * ctx, float windowWidth, float windowHeight, float devicePixelRatio)

    • nnvgCancelFrame

      public static void nnvgCancelFrame(long ctx)
      void nvgCancelFrame(NVGcontext * ctx)

    • nvgCancelFrame

      public static void nvgCancelFrame(long ctx)
      void nvgCancelFrame(NVGcontext * ctx)

    • nnvgEndFrame

      public static void nnvgEndFrame(long ctx)
      void nvgEndFrame(NVGcontext * ctx)

    • nvgEndFrame

      public static void nvgEndFrame(long ctx)
      void nvgEndFrame(NVGcontext * ctx)

    • nnvgGlobalCompositeOperation

      public static void nnvgGlobalCompositeOperation(long ctx, int op)
      void nvgGlobalCompositeOperation(NVGcontext * ctx, int op)

    • nvgGlobalCompositeOperation

      public static void nvgGlobalCompositeOperation(long ctx, int op)
      void nvgGlobalCompositeOperation(NVGcontext * ctx, int op)

    • nnvgGlobalCompositeBlendFunc

      public static void nnvgGlobalCompositeBlendFunc(long ctx, int sfactor, int dfactor)
      void nvgGlobalCompositeBlendFunc(NVGcontext * ctx, int sfactor, int dfactor)

    • nvgGlobalCompositeBlendFunc

      public static void nvgGlobalCompositeBlendFunc(long ctx, int sfactor, int dfactor)
      void nvgGlobalCompositeBlendFunc(NVGcontext * ctx, int sfactor, int dfactor)

    • nnvgGlobalCompositeBlendFuncSeparate

      public static void nnvgGlobalCompositeBlendFuncSeparate(long ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)
      void nvgGlobalCompositeBlendFuncSeparate(NVGcontext * ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)

    • nvgGlobalCompositeBlendFuncSeparate

      public static void nvgGlobalCompositeBlendFuncSeparate(long ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)
      void nvgGlobalCompositeBlendFuncSeparate(NVGcontext * ctx, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha)

    • nnvgRGB

      public static void nnvgRGB(byte r, byte g, byte b, long __result)
      NVGcolor nvgRGB(unsigned char r, unsigned char g, unsigned char b)

    • nvgRGB

      public static NVGColor nvgRGB(byte r, byte g, byte b, NVGColor __result)
      NVGcolor nvgRGB(unsigned char r, unsigned char g, unsigned char b)

    • nnvgRGBf

      public static void nnvgRGBf(float r, float g, float b, long __result)
      NVGcolor nvgRGBf(float r, float g, float b)

    • nvgRGBf

      public static NVGColor nvgRGBf(float r, float g, float b, NVGColor __result)
      NVGcolor nvgRGBf(float r, float g, float b)

    • nnvgRGBA

      public static void nnvgRGBA(byte r, byte g, byte b, byte a, long __result)
      NVGcolor nvgRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)

    • nvgRGBA

      public static NVGColor nvgRGBA(byte r, byte g, byte b, byte a, NVGColor __result)
      NVGcolor nvgRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)

    • nnvgRGBAf

      public static void nnvgRGBAf(float r, float g, float b, float a, long __result)
      NVGcolor nvgRGBAf(float r, float g, float b, float a)

    • nvgRGBAf

      public static NVGColor nvgRGBAf(float r, float g, float b, float a, NVGColor __result)
      NVGcolor nvgRGBAf(float r, float g, float b, float a)

    • nnvgLerpRGBA

      public static void nnvgLerpRGBA(long c0, long c1, float u, long __result)
      NVGcolor nvgLerpRGBA(NVGcolor c0, NVGcolor c1, float u)

    • nvgLerpRGBA

      public static NVGColor nvgLerpRGBA(NVGColor c0, NVGColor c1, float u, NVGColor __result)
      NVGcolor nvgLerpRGBA(NVGcolor c0, NVGcolor c1, float u)

    • nnvgTransRGBA

      public static void nnvgTransRGBA(long c0, byte a, long __result)
      NVGcolor nvgTransRGBA(NVGcolor c0, unsigned char a)

    • nvgTransRGBA

      public static NVGColor nvgTransRGBA(NVGColor c0, byte a, NVGColor __result)
      NVGcolor nvgTransRGBA(NVGcolor c0, unsigned char a)

    • nnvgTransRGBAf

      public static void nnvgTransRGBAf(long c0, float a, long __result)
      NVGcolor nvgTransRGBAf(NVGcolor c0, float a)

    • nvgTransRGBAf

      public static NVGColor nvgTransRGBAf(NVGColor c0, float a, NVGColor __result)
      NVGcolor nvgTransRGBAf(NVGcolor c0, float a)

    • nnvgHSL

      public static void nnvgHSL(float h, float s, float l, long __result)
      NVGcolor nvgHSL(float h, float s, float l)

    • nvgHSL

      public static NVGColor nvgHSL(float h, float s, float l, NVGColor __result)
      NVGcolor nvgHSL(float h, float s, float l)

    • nnvgHSLA

      public static void nnvgHSLA(float h, float s, float l, byte a, long __result)
      NVGcolor nvgHSLA(float h, float s, float l, unsigned char a)

    • nvgHSLA

      public static NVGColor nvgHSLA(float h, float s, float l, byte a, NVGColor __result)
      NVGcolor nvgHSLA(float h, float s, float l, unsigned char a)

    • nnvgSave

      public static void nnvgSave(long ctx)
      void nvgSave(NVGcontext * ctx)

    • nvgSave

      public static void nvgSave(long ctx)
      void nvgSave(NVGcontext * ctx)

    • nnvgRestore

      public static void nnvgRestore(long ctx)
      void nvgRestore(NVGcontext * ctx)

    • nvgRestore

      public static void nvgRestore(long ctx)
      void nvgRestore(NVGcontext * ctx)

    • nnvgReset

      public static void nnvgReset(long ctx)
      void nvgReset(NVGcontext * ctx)

    • nvgReset

      public static void nvgReset(long ctx)
      void nvgReset(NVGcontext * ctx)

    • nnvgShapeAntiAlias

      public static void nnvgShapeAntiAlias(long ctx, int enabled)
      void nvgShapeAntiAlias(NVGcontext * ctx, int enabled)

    • nvgShapeAntiAlias

      public static void nvgShapeAntiAlias(long ctx, boolean enabled)
      void nvgShapeAntiAlias(NVGcontext * ctx, int enabled)

    • nnvgStrokeColor

      public static void nnvgStrokeColor(long ctx, long color)
      void nvgStrokeColor(NVGcontext * ctx, NVGcolor color)

    • nvgStrokeColor

      public static void nvgStrokeColor(long ctx, NVGColor color)
      void nvgStrokeColor(NVGcontext * ctx, NVGcolor color)

    • nnvgStrokePaint

      public static void nnvgStrokePaint(long ctx, long paint)
      void nvgStrokePaint(NVGcontext * ctx, NVGpaint paint)

    • nvgStrokePaint

      public static void nvgStrokePaint(long ctx, NVGPaint paint)
      void nvgStrokePaint(NVGcontext * ctx, NVGpaint paint)

    • nnvgFillColor

      public static void nnvgFillColor(long ctx, long color)
      void nvgFillColor(NVGcontext * ctx, NVGcolor color)

    • nvgFillColor

      public static void nvgFillColor(long ctx, NVGColor color)
      void nvgFillColor(NVGcontext * ctx, NVGcolor color)

    • nnvgFillPaint

      public static void nnvgFillPaint(long ctx, long paint)
      void nvgFillPaint(NVGcontext * ctx, NVGpaint paint)

    • nvgFillPaint

      public static void nvgFillPaint(long ctx, NVGPaint paint)
      void nvgFillPaint(NVGcontext * ctx, NVGpaint paint)

    • nnvgMiterLimit

      public static void nnvgMiterLimit(long ctx, float limit)
      void nvgMiterLimit(NVGcontext * ctx, float limit)

    • nvgMiterLimit

      public static void nvgMiterLimit(long ctx, float limit)
      void nvgMiterLimit(NVGcontext * ctx, float limit)

    • nnvgStrokeWidth

      public static void nnvgStrokeWidth(long ctx, float size)
      void nvgStrokeWidth(NVGcontext * ctx, float size)

    • nvgStrokeWidth

      public static void nvgStrokeWidth(long ctx, float size)
      void nvgStrokeWidth(NVGcontext * ctx, float size)

    • nnvgLineCap

      public static void nnvgLineCap(long ctx, int cap)
      void nvgLineCap(NVGcontext * ctx, int cap)

    • nvgLineCap

      public static void nvgLineCap(long ctx, int cap)
      void nvgLineCap(NVGcontext * ctx, int cap)

    • nnvgLineJoin

      public static void nnvgLineJoin(long ctx, int join)
      void nvgLineJoin(NVGcontext * ctx, int join)

    • nvgLineJoin

      public static void nvgLineJoin(long ctx, int join)
      void nvgLineJoin(NVGcontext * ctx, int join)

    • nnvgGlobalAlpha

      public static void nnvgGlobalAlpha(long ctx, float alpha)
      void nvgGlobalAlpha(NVGcontext * ctx, float alpha)

    • nvgGlobalAlpha

      public static void nvgGlobalAlpha(long ctx, float alpha)
      void nvgGlobalAlpha(NVGcontext * ctx, float alpha)

    • nnvgResetTransform

      public static void nnvgResetTransform(long ctx)
      void nvgResetTransform(NVGcontext * ctx)

    • nvgResetTransform

      public static void nvgResetTransform(long ctx)
      void nvgResetTransform(NVGcontext * ctx)

    • nnvgTransform

      public static void nnvgTransform(long ctx, float a, float b, float c, float d, float e, float f)
      void nvgTransform(NVGcontext * ctx, float a, float b, float c, float d, float e, float f)

    • nvgTransform

      public static void nvgTransform(long ctx, float a, float b, float c, float d, float e, float f)
      void nvgTransform(NVGcontext * ctx, float a, float b, float c, float d, float e, float f)

    • nnvgTranslate

      public static void nnvgTranslate(long ctx, float x, float y)
      void nvgTranslate(NVGcontext * ctx, float x, float y)

    • nvgTranslate

      public static void nvgTranslate(long ctx, float x, float y)
      void nvgTranslate(NVGcontext * ctx, float x, float y)

    • nnvgRotate

      public static void nnvgRotate(long ctx, float angle)
      void nvgRotate(NVGcontext * ctx, float angle)

    • nvgRotate

      public static void nvgRotate(long ctx, float angle)
      void nvgRotate(NVGcontext * ctx, float angle)

    • nnvgSkewX

      public static void nnvgSkewX(long ctx, float angle)
      void nvgSkewX(NVGcontext * ctx, float angle)

    • nvgSkewX

      public static void nvgSkewX(long ctx, float angle)
      void nvgSkewX(NVGcontext * ctx, float angle)

    • nnvgSkewY

      public static void nnvgSkewY(long ctx, float angle)
      void nvgSkewY(NVGcontext * ctx, float angle)

    • nvgSkewY

      public static void nvgSkewY(long ctx, float angle)
      void nvgSkewY(NVGcontext * ctx, float angle)

    • nnvgScale

      public static void nnvgScale(long ctx, float x, float y)
      void nvgScale(NVGcontext * ctx, float x, float y)

    • nvgScale

      public static void nvgScale(long ctx, float x, float y)
      void nvgScale(NVGcontext * ctx, float x, float y)

    • nnvgCurrentTransform

      public static void nnvgCurrentTransform(long ctx, long xform)
      void nvgCurrentTransform(NVGcontext * ctx, float * xform)

    • nvgCurrentTransform

      public static void nvgCurrentTransform(long ctx, FloatBuffer xform)
      void nvgCurrentTransform(NVGcontext * ctx, float * xform)

    • nnvgTransformIdentity

      public static void nnvgTransformIdentity(long dst)
      void nvgTransformIdentity(float * dst)

    • nvgTransformIdentity

      public static void nvgTransformIdentity(FloatBuffer dst)
      void nvgTransformIdentity(float * dst)

    • nnvgTransformTranslate

      public static void nnvgTransformTranslate(long dst, float tx, float ty)
      void nvgTransformTranslate(float * dst, float tx, float ty)

    • nvgTransformTranslate

      public static void nvgTransformTranslate(FloatBuffer dst, float tx, float ty)
      void nvgTransformTranslate(float * dst, float tx, float ty)

    • nnvgTransformScale

      public static void nnvgTransformScale(long dst, float sx, float sy)
      void nvgTransformScale(float * dst, float sx, float sy)

    • nvgTransformScale

      public static void nvgTransformScale(FloatBuffer dst, float sx, float sy)
      void nvgTransformScale(float * dst, float sx, float sy)

    • nnvgTransformRotate

      public static void nnvgTransformRotate(long dst, float a)
      void nvgTransformRotate(float * dst, float a)

    • nvgTransformRotate

      public static void nvgTransformRotate(FloatBuffer dst, float a)
      void nvgTransformRotate(float * dst, float a)

    • nnvgTransformSkewX

      public static void nnvgTransformSkewX(long dst, float a)
      void nvgTransformSkewX(float * dst, float a)

    • nvgTransformSkewX

      public static void nvgTransformSkewX(FloatBuffer dst, float a)
      void nvgTransformSkewX(float * dst, float a)

    • nnvgTransformSkewY

      public static void nnvgTransformSkewY(long dst, float a)
      void nvgTransformSkewY(float * dst, float a)

    • nvgTransformSkewY

      public static void nvgTransformSkewY(FloatBuffer dst, float a)
      void nvgTransformSkewY(float * dst, float a)

    • nnvgTransformMultiply

      public static void nnvgTransformMultiply(long dst, long src)
      void nvgTransformMultiply(float * dst, float const * src)

    • nvgTransformMultiply

      public static void nvgTransformMultiply(FloatBuffer dst, FloatBuffer src)
      void nvgTransformMultiply(float * dst, float const * src)

    • nnvgTransformPremultiply

      public static void nnvgTransformPremultiply(long dst, long src)
      void nvgTransformPremultiply(float * dst, float const * src)

    • nvgTransformPremultiply

      public static void nvgTransformPremultiply(FloatBuffer dst, FloatBuffer src)
      void nvgTransformPremultiply(float * dst, float const * src)

    • nnvgTransformInverse

      public static int nnvgTransformInverse(long dst, long src)
      int nvgTransformInverse(float * dst, float const * src)

    • nvgTransformInverse

      public static boolean nvgTransformInverse(FloatBuffer dst, FloatBuffer src)
      int nvgTransformInverse(float * dst, float const * src)

    • nnvgTransformPoint

      public static void nnvgTransformPoint(long dstx, long dsty, long xform, float srcx, float srcy)
      void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)

    • nvgTransformPoint

      public static void nvgTransformPoint(FloatBuffer dstx, FloatBuffer dsty, FloatBuffer xform, float srcx, float srcy)
      void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)

    • nvgDegToRad

      public static float nvgDegToRad(float deg)
      float nvgDegToRad(float deg)

    • nvgRadToDeg

      public static float nvgRadToDeg(float rad)
      float nvgRadToDeg(float rad)

    • nnvgCreateImage

      public static int nnvgCreateImage(long ctx, long filename, int imageFlags)
      int nvgCreateImage(NVGcontext * ctx, char const * filename, int imageFlags)

    • nvgCreateImage

      public static int nvgCreateImage(long ctx, ByteBuffer filename, int imageFlags)
      int nvgCreateImage(NVGcontext * ctx, char const * filename, int imageFlags)

    • nvgCreateImage

      public static int nvgCreateImage(long ctx, CharSequence filename, int imageFlags)
      int nvgCreateImage(NVGcontext * ctx, char const * filename, int imageFlags)

    • nnvgCreateImageMem

      public static int nnvgCreateImageMem(long ctx, int imageFlags, long data, int ndata)
      int nvgCreateImageMem(NVGcontext * ctx, int imageFlags, unsigned char * data, int ndata)

    • nvgCreateImageMem

      public static int nvgCreateImageMem(long ctx, int imageFlags, ByteBuffer data)
      int nvgCreateImageMem(NVGcontext * ctx, int imageFlags, unsigned char * data, int ndata)

    • nnvgCreateImageRGBA

      public static int nnvgCreateImageRGBA(long ctx, int w, int h, int imageFlags, long data)
      int nvgCreateImageRGBA(NVGcontext * ctx, int w, int h, int imageFlags, unsigned char const * data)

    • nvgCreateImageRGBA

      public static int nvgCreateImageRGBA(long ctx, int w, int h, int imageFlags, ByteBuffer data)
      int nvgCreateImageRGBA(NVGcontext * ctx, int w, int h, int imageFlags, unsigned char const * data)

    • nnvgUpdateImage

      public static void nnvgUpdateImage(long ctx, int image, long data)
      void nvgUpdateImage(NVGcontext * ctx, int image, unsigned char const * data)

    • nvgUpdateImage

      public static void nvgUpdateImage(long ctx, int image, ByteBuffer data)
      void nvgUpdateImage(NVGcontext * ctx, int image, unsigned char const * data)

    • nnvgImageSize

      public static void nnvgImageSize(long ctx, int image, long w, long h)
      void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)

    • nvgImageSize

      public static void nvgImageSize(long ctx, int image, IntBuffer w, IntBuffer h)
      void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)

    • nnvgDeleteImage

      public static void nnvgDeleteImage(long ctx, int image)
      void nvgDeleteImage(NVGcontext * ctx, int image)

    • nvgDeleteImage

      public static void nvgDeleteImage(long ctx, int image)
      void nvgDeleteImage(NVGcontext * ctx, int image)

    • nnvgLinearGradient

      public static void nnvgLinearGradient(long ctx, float sx, float sy, float ex, float ey, long icol, long ocol, long __result)
      NVGpaint nvgLinearGradient(NVGcontext * ctx, float sx, float sy, float ex, float ey, NVGcolor icol, NVGcolor ocol)

    • nvgLinearGradient

      public static NVGPaint nvgLinearGradient(long ctx, float sx, float sy, float ex, float ey, NVGColor icol, NVGColor ocol, NVGPaint __result)
      NVGpaint nvgLinearGradient(NVGcontext * ctx, float sx, float sy, float ex, float ey, NVGcolor icol, NVGcolor ocol)

    • nnvgBoxGradient

      public static void nnvgBoxGradient(long ctx, float x, float y, float w, float h, float r, float f, long icol, long ocol, long __result)
      NVGpaint nvgBoxGradient(NVGcontext * ctx, float x, float y, float w, float h, float r, float f, NVGcolor icol, NVGcolor ocol)

    • nvgBoxGradient

      public static NVGPaint nvgBoxGradient(long ctx, float x, float y, float w, float h, float r, float f, NVGColor icol, NVGColor ocol, NVGPaint __result)
      NVGpaint nvgBoxGradient(NVGcontext * ctx, float x, float y, float w, float h, float r, float f, NVGcolor icol, NVGcolor ocol)

    • nnvgRadialGradient

      public static void nnvgRadialGradient(long ctx, float cx, float cy, float inr, float outr, long icol, long ocol, long __result)
      NVGpaint nvgRadialGradient(NVGcontext * ctx, float cx, float cy, float inr, float outr, NVGcolor icol, NVGcolor ocol)

    • nvgRadialGradient

      public static NVGPaint nvgRadialGradient(long ctx, float cx, float cy, float inr, float outr, NVGColor icol, NVGColor ocol, NVGPaint __result)
      NVGpaint nvgRadialGradient(NVGcontext * ctx, float cx, float cy, float inr, float outr, NVGcolor icol, NVGcolor ocol)

    • nnvgImagePattern

      public static void nnvgImagePattern(long ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha, long __result)
      NVGpaint nvgImagePattern(NVGcontext * ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha)

    • nvgImagePattern

      public static NVGPaint nvgImagePattern(long ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha, NVGPaint __result)
      NVGpaint nvgImagePattern(NVGcontext * ctx, float ox, float oy, float ex, float ey, float angle, int image, float alpha)

    • nnvgScissor

      public static void nnvgScissor(long ctx, float x, float y, float w, float h)
      void nvgScissor(NVGcontext * ctx, float x, float y, float w, float h)

    • nvgScissor

      public static void nvgScissor(long ctx, float x, float y, float w, float h)
      void nvgScissor(NVGcontext * ctx, float x, float y, float w, float h)

    • nnvgIntersectScissor

      public static void nnvgIntersectScissor(long ctx, float x, float y, float w, float h)
      void nvgIntersectScissor(NVGcontext * ctx, float x, float y, float w, float h)

    • nvgIntersectScissor

      public static void nvgIntersectScissor(long ctx, float x, float y, float w, float h)
      void nvgIntersectScissor(NVGcontext * ctx, float x, float y, float w, float h)

    • nnvgResetScissor

      public static void nnvgResetScissor(long ctx)
      void nvgResetScissor(NVGcontext * ctx)

    • nvgResetScissor

      public static void nvgResetScissor(long ctx)
      void nvgResetScissor(NVGcontext * ctx)

    • nnvgBeginPath

      public static void nnvgBeginPath(long ctx)
      void nvgBeginPath(NVGcontext * ctx)

    • nvgBeginPath

      public static void nvgBeginPath(long ctx)
      void nvgBeginPath(NVGcontext * ctx)

    • nnvgMoveTo

      public static void nnvgMoveTo(long ctx, float x, float y)
      void nvgMoveTo(NVGcontext * ctx, float x, float y)

    • nvgMoveTo

      public static void nvgMoveTo(long ctx, float x, float y)
      void nvgMoveTo(NVGcontext * ctx, float x, float y)

    • nnvgLineTo

      public static void nnvgLineTo(long ctx, float x, float y)
      void nvgLineTo(NVGcontext * ctx, float x, float y)

    • nvgLineTo

      public static void nvgLineTo(long ctx, float x, float y)
      void nvgLineTo(NVGcontext * ctx, float x, float y)

    • nnvgBezierTo

      public static void nnvgBezierTo(long ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)
      void nvgBezierTo(NVGcontext * ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)

    • nvgBezierTo

      public static void nvgBezierTo(long ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)
      void nvgBezierTo(NVGcontext * ctx, float c1x, float c1y, float c2x, float c2y, float x, float y)

    • nnvgQuadTo

      public static void nnvgQuadTo(long ctx, float cx, float cy, float x, float y)
      void nvgQuadTo(NVGcontext * ctx, float cx, float cy, float x, float y)

    • nvgQuadTo

      public static void nvgQuadTo(long ctx, float cx, float cy, float x, float y)
      void nvgQuadTo(NVGcontext * ctx, float cx, float cy, float x, float y)

    • nnvgArcTo

      public static void nnvgArcTo(long ctx, float x1, float y1, float x2, float y2, float radius)
      void nvgArcTo(NVGcontext * ctx, float x1, float y1, float x2, float y2, float radius)

    • nvgArcTo

      public static void nvgArcTo(long ctx, float x1, float y1, float x2, float y2, float radius)
      void nvgArcTo(NVGcontext * ctx, float x1, float y1, float x2, float y2, float radius)

    • nnvgClosePath

      public static void nnvgClosePath(long ctx)
      void nvgClosePath(NVGcontext * ctx)

    • nvgClosePath

      public static void nvgClosePath(long ctx)
      void nvgClosePath(NVGcontext * ctx)

    • nnvgPathWinding

      public static void nnvgPathWinding(long ctx, int dir)
      void nvgPathWinding(NVGcontext * ctx, int dir)

    • nvgPathWinding

      public static void nvgPathWinding(long ctx, int dir)
      void nvgPathWinding(NVGcontext * ctx, int dir)

    • nnvgArc

      public static void nnvgArc(long ctx, float cx, float cy, float r, float a0, float a1, int dir)
      void nvgArc(NVGcontext * ctx, float cx, float cy, float r, float a0, float a1, int dir)

    • nvgArc

      public static void nvgArc(long ctx, float cx, float cy, float r, float a0, float a1, int dir)
      void nvgArc(NVGcontext * ctx, float cx, float cy, float r, float a0, float a1, int dir)

    • nnvgRect

      public static void nnvgRect(long ctx, float x, float y, float w, float h)
      void nvgRect(NVGcontext * ctx, float x, float y, float w, float h)

    • nvgRect

      public static void nvgRect(long ctx, float x, float y, float w, float h)
      void nvgRect(NVGcontext * ctx, float x, float y, float w, float h)

    • nnvgRoundedRect

      public static void nnvgRoundedRect(long ctx, float x, float y, float w, float h, float r)
      void nvgRoundedRect(NVGcontext * ctx, float x, float y, float w, float h, float r)

    • nvgRoundedRect

      public static void nvgRoundedRect(long ctx, float x, float y, float w, float h, float r)
      void nvgRoundedRect(NVGcontext * ctx, float x, float y, float w, float h, float r)

    • nnvgRoundedRectVarying

      public static void nnvgRoundedRectVarying(long ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)
      void nvgRoundedRectVarying(NVGcontext * ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)

    • nvgRoundedRectVarying

      public static void nvgRoundedRectVarying(long ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)
      void nvgRoundedRectVarying(NVGcontext * ctx, float x, float y, float w, float h, float radTopLeft, float radTopRight, float radBottomRight, float radBottomLeft)

    • nnvgEllipse

      public static void nnvgEllipse(long ctx, float cx, float cy, float rx, float ry)
      void nvgEllipse(NVGcontext * ctx, float cx, float cy, float rx, float ry)

    • nvgEllipse

      public static void nvgEllipse(long ctx, float cx, float cy, float rx, float ry)
      void nvgEllipse(NVGcontext * ctx, float cx, float cy, float rx, float ry)

    • nnvgCircle

      public static void nnvgCircle(long ctx, float cx, float cy, float r)
      void nvgCircle(NVGcontext * ctx, float cx, float cy, float r)

    • nvgCircle

      public static void nvgCircle(long ctx, float cx, float cy, float r)
      void nvgCircle(NVGcontext * ctx, float cx, float cy, float r)

    • nnvgFill

      public static void nnvgFill(long ctx)
      void nvgFill(NVGcontext * ctx)

    • nvgFill

      public static void nvgFill(long ctx)
      void nvgFill(NVGcontext * ctx)

    • nnvgStroke

      public static void nnvgStroke(long ctx)
      void nvgStroke(NVGcontext * ctx)

    • nvgStroke

      public static void nvgStroke(long ctx)
      void nvgStroke(NVGcontext * ctx)

    • nnvgCreateFont

      public static int nnvgCreateFont(long ctx, long name, long filename)
      int nvgCreateFont(NVGcontext * ctx, char const * name, char const * filename)

    • nvgCreateFont

      public static int nvgCreateFont(long ctx, ByteBuffer name, ByteBuffer filename)
      int nvgCreateFont(NVGcontext * ctx, char const * name, char const * filename)

    • nvgCreateFont

      public static int nvgCreateFont(long ctx, CharSequence name, CharSequence filename)
      int nvgCreateFont(NVGcontext * ctx, char const * name, char const * filename)

    • nnvgCreateFontAtIndex

      public static int nnvgCreateFontAtIndex(long ctx, long name, long filename, int fontIndex)
      int nvgCreateFontAtIndex(NVGcontext * ctx, char const * name, char const * filename, int fontIndex)

    • nvgCreateFontAtIndex

      public static int nvgCreateFontAtIndex(long ctx, ByteBuffer name, ByteBuffer filename, int fontIndex)
      int nvgCreateFontAtIndex(NVGcontext * ctx, char const * name, char const * filename, int fontIndex)

    • nvgCreateFontAtIndex

      public static int nvgCreateFontAtIndex(long ctx, CharSequence name, CharSequence filename, int fontIndex)
      int nvgCreateFontAtIndex(NVGcontext * ctx, char const * name, char const * filename, int fontIndex)

    • nnvgCreateFontMem

      public static int nnvgCreateFontMem(long ctx, long name, long data, int ndata, int freeData)
      int nvgCreateFontMem(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData)

    • nvgCreateFontMem

      public static int nvgCreateFontMem(long ctx, ByteBuffer name, ByteBuffer data, boolean freeData)
      int nvgCreateFontMem(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData)

    • nvgCreateFontMem

      public static int nvgCreateFontMem(long ctx, CharSequence name, ByteBuffer data, boolean freeData)
      int nvgCreateFontMem(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData)

    • nnvgCreateFontMemAtIndex

      public static int nnvgCreateFontMemAtIndex(long ctx, long name, long data, int ndata, int freeData, int fontIndex)
      int nvgCreateFontMemAtIndex(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData, int fontIndex)

    • nvgCreateFontMemAtIndex

      public static int nvgCreateFontMemAtIndex(long ctx, ByteBuffer name, ByteBuffer data, boolean freeData, int fontIndex)
      int nvgCreateFontMemAtIndex(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData, int fontIndex)

    • nvgCreateFontMemAtIndex

      public static int nvgCreateFontMemAtIndex(long ctx, CharSequence name, ByteBuffer data, boolean freeData, int fontIndex)
      int nvgCreateFontMemAtIndex(NVGcontext * ctx, char const * name, unsigned char * data, int ndata, int freeData, int fontIndex)

    • nnvgFindFont

      public static int nnvgFindFont(long ctx, long name)
      int nvgFindFont(NVGcontext * ctx, char const * name)

    • nvgFindFont

      public static int nvgFindFont(long ctx, ByteBuffer name)
      int nvgFindFont(NVGcontext * ctx, char const * name)

    • nvgFindFont

      public static int nvgFindFont(long ctx, CharSequence name)
      int nvgFindFont(NVGcontext * ctx, char const * name)

    • nnvgAddFallbackFontId

      public static int nnvgAddFallbackFontId(long ctx, int baseFont, int fallbackFont)
      int nvgAddFallbackFontId(NVGcontext * ctx, int baseFont, int fallbackFont)

    • nvgAddFallbackFontId

      public static int nvgAddFallbackFontId(long ctx, int baseFont, int fallbackFont)
      int nvgAddFallbackFontId(NVGcontext * ctx, int baseFont, int fallbackFont)

    • nnvgAddFallbackFont

      public static int nnvgAddFallbackFont(long ctx, long baseFont, long fallbackFont)
      int nvgAddFallbackFont(NVGcontext * ctx, char const * baseFont, char const * fallbackFont)

    • nvgAddFallbackFont

      public static int nvgAddFallbackFont(long ctx, ByteBuffer baseFont, ByteBuffer fallbackFont)
      int nvgAddFallbackFont(NVGcontext * ctx, char const * baseFont, char const * fallbackFont)

    • nvgAddFallbackFont

      public static int nvgAddFallbackFont(long ctx, CharSequence baseFont, CharSequence fallbackFont)
      int nvgAddFallbackFont(NVGcontext * ctx, char const * baseFont, char const * fallbackFont)

    • nnvgResetFallbackFontsId

      public static void nnvgResetFallbackFontsId(long ctx, int baseFont)
      void nvgResetFallbackFontsId(NVGcontext * ctx, int baseFont)

    • nvgResetFallbackFontsId

      public static void nvgResetFallbackFontsId(long ctx, int baseFont)
      void nvgResetFallbackFontsId(NVGcontext * ctx, int baseFont)

    • nnvgResetFallbackFonts

      public static void nnvgResetFallbackFonts(long ctx, long baseFont)
      void nvgResetFallbackFonts(NVGcontext * ctx, char const * baseFont)

    • nvgResetFallbackFonts

      public static void nvgResetFallbackFonts(long ctx, ByteBuffer baseFont)
      void nvgResetFallbackFonts(NVGcontext * ctx, char const * baseFont)

    • nvgResetFallbackFonts

      public static void nvgResetFallbackFonts(long ctx, CharSequence baseFont)
      void nvgResetFallbackFonts(NVGcontext * ctx, char const * baseFont)

    • nnvgFontSize

      public static void nnvgFontSize(long ctx, float size)
      void nvgFontSize(NVGcontext * ctx, float size)

    • nvgFontSize

      public static void nvgFontSize(long ctx, float size)
      void nvgFontSize(NVGcontext * ctx, float size)

    • nnvgFontBlur

      public static void nnvgFontBlur(long ctx, float blur)
      void nvgFontBlur(NVGcontext * ctx, float blur)

    • nvgFontBlur

      public static void nvgFontBlur(long ctx, float blur)
      void nvgFontBlur(NVGcontext * ctx, float blur)

    • nnvgTextLetterSpacing

      public static void nnvgTextLetterSpacing(long ctx, float spacing)
      void nvgTextLetterSpacing(NVGcontext * ctx, float spacing)

    • nvgTextLetterSpacing

      public static void nvgTextLetterSpacing(long ctx, float spacing)
      void nvgTextLetterSpacing(NVGcontext * ctx, float spacing)

    • nnvgTextLineHeight

      public static void nnvgTextLineHeight(long ctx, float lineHeight)
      void nvgTextLineHeight(NVGcontext * ctx, float lineHeight)

    • nvgTextLineHeight

      public static void nvgTextLineHeight(long ctx, float lineHeight)
      void nvgTextLineHeight(NVGcontext * ctx, float lineHeight)

    • nnvgTextAlign

      public static void nnvgTextAlign(long ctx, int align)
      void nvgTextAlign(NVGcontext * ctx, int align)

    • nvgTextAlign

      public static void nvgTextAlign(long ctx, int align)
      void nvgTextAlign(NVGcontext * ctx, int align)

    • nnvgFontFaceId

      public static void nnvgFontFaceId(long ctx, int font)
      void nvgFontFaceId(NVGcontext * ctx, int font)

    • nvgFontFaceId

      public static void nvgFontFaceId(long ctx, int font)
      void nvgFontFaceId(NVGcontext * ctx, int font)

    • nnvgFontFace

      public static void nnvgFontFace(long ctx, long font)
      void nvgFontFace(NVGcontext * ctx, char const * font)

    • nvgFontFace

      public static void nvgFontFace(long ctx, ByteBuffer font)
      void nvgFontFace(NVGcontext * ctx, char const * font)

    • nvgFontFace

      public static void nvgFontFace(long ctx, CharSequence font)
      void nvgFontFace(NVGcontext * ctx, char const * font)

    • nnvgText

      public static float nnvgText(long ctx, float x, float y, long string, long end)
      float nvgText(NVGcontext * ctx, float x, float y, char const * string, char const * end)

    • nvgText

      public static float nvgText(long ctx, float x, float y, ByteBuffer string)
      float nvgText(NVGcontext * ctx, float x, float y, char const * string, char const * end)

    • nvgText

      public static float nvgText(long ctx, float x, float y, CharSequence string)
      float nvgText(NVGcontext * ctx, float x, float y, char const * string, char const * end)

    • nnvgTextBox

      public static void nnvgTextBox(long ctx, float x, float y, float breakRowWidth, long string, long end)
      void nvgTextBox(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end)

    • nvgTextBox

      public static void nvgTextBox(long ctx, float x, float y, float breakRowWidth, ByteBuffer string)
      void nvgTextBox(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end)

    • nvgTextBox

      public static void nvgTextBox(long ctx, float x, float y, float breakRowWidth, CharSequence string)
      void nvgTextBox(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end)

    • nnvgTextBounds

      public static float nnvgTextBounds(long ctx, float x, float y, long string, long end, long bounds)
      float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)

    • nvgTextBounds

      public static float nvgTextBounds(long ctx, float x, float y, ByteBuffer string, @Nullable FloatBuffer bounds)
      float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)

    • nvgTextBounds

      public static float nvgTextBounds(long ctx, float x, float y, CharSequence string, @Nullable FloatBuffer bounds)
      float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)

    • nnvgTextBoxBounds

      public static void nnvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, long string, long end, long bounds)
      void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)

    • nvgTextBoxBounds

      public static void nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, ByteBuffer string, @Nullable FloatBuffer bounds)
      void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)

    • nvgTextBoxBounds

      public static void nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, CharSequence string, @Nullable FloatBuffer bounds)
      void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)

    • nnvgTextGlyphPositions

      public static int nnvgTextGlyphPositions(long ctx, float x, float y, long string, long end, long positions, int maxPositions)
      int nvgTextGlyphPositions(NVGcontext * ctx, float x, float y, char const * string, char const * end, NVGglyphPosition * positions, int maxPositions)

    • nvgTextGlyphPositions

      public static int nvgTextGlyphPositions(long ctx, float x, float y, ByteBuffer string, NVGGlyphPosition.Buffer positions)
      int nvgTextGlyphPositions(NVGcontext * ctx, float x, float y, char const * string, char const * end, NVGglyphPosition * positions, int maxPositions)

    • nvgTextGlyphPositions

      public static int nvgTextGlyphPositions(long ctx, float x, float y, CharSequence string, NVGGlyphPosition.Buffer positions)
      int nvgTextGlyphPositions(NVGcontext * ctx, float x, float y, char const * string, char const * end, NVGglyphPosition * positions, int maxPositions)

    • nnvgTextMetrics

      public static void nnvgTextMetrics(long ctx, long ascender, long descender, long lineh)
      void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)

    • nvgTextMetrics

      public static void nvgTextMetrics(long ctx, @Nullable FloatBuffer ascender, @Nullable FloatBuffer descender, @Nullable FloatBuffer lineh)
      void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)

    • nnvgTextBreakLines

      public static int nnvgTextBreakLines(long ctx, long string, long end, float breakRowWidth, long rows, int maxRows)
      int nvgTextBreakLines(NVGcontext * ctx, char const * string, char const * end, float breakRowWidth, NVGtextRow * rows, int maxRows)

    • nvgTextBreakLines

      public static int nvgTextBreakLines(long ctx, ByteBuffer string, float breakRowWidth, NVGTextRow.Buffer rows)
      int nvgTextBreakLines(NVGcontext * ctx, char const * string, char const * end, float breakRowWidth, NVGtextRow * rows, int maxRows)

    • nvgTextBreakLines

      public static int nvgTextBreakLines(long ctx, CharSequence string, float breakRowWidth, NVGTextRow.Buffer rows)
      int nvgTextBreakLines(NVGcontext * ctx, char const * string, char const * end, float breakRowWidth, NVGtextRow * rows, int maxRows)

    • nnvgCurrentTransform

      public static void nnvgCurrentTransform(long ctx, float[] xform)
      void nvgCurrentTransform(NVGcontext * ctx, float * xform)

    • nvgCurrentTransform

      public static void nvgCurrentTransform(long ctx, float[] xform)
      void nvgCurrentTransform(NVGcontext * ctx, float * xform)

    • nnvgTransformIdentity

      public static void nnvgTransformIdentity(float[] dst)
      void nvgTransformIdentity(float * dst)

    • nvgTransformIdentity

      public static void nvgTransformIdentity(float[] dst)
      void nvgTransformIdentity(float * dst)

    • nnvgTransformTranslate

      public static void nnvgTransformTranslate(float[] dst, float tx, float ty)
      void nvgTransformTranslate(float * dst, float tx, float ty)

    • nvgTransformTranslate

      public static void nvgTransformTranslate(float[] dst, float tx, float ty)
      void nvgTransformTranslate(float * dst, float tx, float ty)

    • nnvgTransformScale

      public static void nnvgTransformScale(float[] dst, float sx, float sy)
      void nvgTransformScale(float * dst, float sx, float sy)

    • nvgTransformScale

      public static void nvgTransformScale(float[] dst, float sx, float sy)
      void nvgTransformScale(float * dst, float sx, float sy)

    • nnvgTransformRotate

      public static void nnvgTransformRotate(float[] dst, float a)
      void nvgTransformRotate(float * dst, float a)

    • nvgTransformRotate

      public static void nvgTransformRotate(float[] dst, float a)
      void nvgTransformRotate(float * dst, float a)

    • nnvgTransformSkewX

      public static void nnvgTransformSkewX(float[] dst, float a)
      void nvgTransformSkewX(float * dst, float a)

    • nvgTransformSkewX

      public static void nvgTransformSkewX(float[] dst, float a)
      void nvgTransformSkewX(float * dst, float a)

    • nnvgTransformSkewY

      public static void nnvgTransformSkewY(float[] dst, float a)
      void nvgTransformSkewY(float * dst, float a)

    • nvgTransformSkewY

      public static void nvgTransformSkewY(float[] dst, float a)
      void nvgTransformSkewY(float * dst, float a)

    • nnvgTransformMultiply

      public static void nnvgTransformMultiply(float[] dst, float[] src)
      void nvgTransformMultiply(float * dst, float const * src)

    • nvgTransformMultiply

      public static void nvgTransformMultiply(float[] dst, float[] src)
      void nvgTransformMultiply(float * dst, float const * src)

    • nnvgTransformPremultiply

      public static void nnvgTransformPremultiply(float[] dst, float[] src)
      void nvgTransformPremultiply(float * dst, float const * src)

    • nvgTransformPremultiply

      public static void nvgTransformPremultiply(float[] dst, float[] src)
      void nvgTransformPremultiply(float * dst, float const * src)

    • nnvgTransformInverse

      public static int nnvgTransformInverse(float[] dst, float[] src)
      int nvgTransformInverse(float * dst, float const * src)

    • nvgTransformInverse

      public static boolean nvgTransformInverse(float[] dst, float[] src)
      int nvgTransformInverse(float * dst, float const * src)

    • nnvgTransformPoint

      public static void nnvgTransformPoint(float[] dstx, float[] dsty, float[] xform, float srcx, float srcy)
      void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)

    • nvgTransformPoint

      public static void nvgTransformPoint(float[] dstx, float[] dsty, float[] xform, float srcx, float srcy)
      void nvgTransformPoint(float * dstx, float * dsty, float const * xform, float srcx, float srcy)

    • nnvgImageSize

      public static void nnvgImageSize(long ctx, int image, int[] w, int[] h)
      void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)

    • nvgImageSize

      public static void nvgImageSize(long ctx, int image, int[] w, int[] h)
      void nvgImageSize(NVGcontext * ctx, int image, int * w, int * h)

    • nnvgTextBounds

      public static float nnvgTextBounds(long ctx, float x, float y, long string, long end, float[] bounds)
      float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)

    • nvgTextBounds

      public static float nvgTextBounds(long ctx, float x, float y, ByteBuffer string, float @Nullable [] bounds)
      float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)

    • nvgTextBounds

      public static float nvgTextBounds(long ctx, float x, float y, CharSequence string, float @Nullable [] bounds)
      float nvgTextBounds(NVGcontext * ctx, float x, float y, char const * string, char const * end, float * bounds)

    • nnvgTextBoxBounds

      public static void nnvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, long string, long end, float[] bounds)
      void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)

    • nvgTextBoxBounds

      public static void nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, ByteBuffer string, float @Nullable [] bounds)
      void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)

    • nvgTextBoxBounds

      public static void nvgTextBoxBounds(long ctx, float x, float y, float breakRowWidth, CharSequence string, float @Nullable [] bounds)
      void nvgTextBoxBounds(NVGcontext * ctx, float x, float y, float breakRowWidth, char const * string, char const * end, float * bounds)

    • nnvgTextMetrics

      public static void nnvgTextMetrics(long ctx, float[] ascender, float[] descender, float[] lineh)
      void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)

    • nvgTextMetrics

      public static void nvgTextMetrics(long ctx, float @Nullable [] ascender, float @Nullable [] descender, float @Nullable [] lineh)
      void nvgTextMetrics(NVGcontext * ctx, float * ascender, float * descender, float * lineh)