//
// Copyright (c) 2009-2013 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty.  In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
#ifndef NANOVG_GL_H
#define NANOVG_GL_H

#include "../../lv_conf_internal.h"

#if LV_USE_NANOVG

#ifdef __cplusplus
extern "C" {
#endif

// Create flags

enum NVGcreateFlags {
    // Flag indicating if geometry based anti-aliasing is used (may not be needed when using MSAA).
    NVG_ANTIALIAS       = 1 << 0,
    // Flag indicating if strokes should be drawn using stencil buffer. The rendering will be a little
    // slower, but path overlaps (i.e. self-intersecting or sharp turns) will be drawn just once.
    NVG_STENCIL_STROKES = 1 << 1,
    // Flag indicating that additional debug checks are done.
    NVG_DEBUG           = 1 << 2,
};

#if defined NANOVG_GL2_IMPLEMENTATION
#  define NANOVG_GL2 1
#  define NANOVG_GL_IMPLEMENTATION 1
#  define NANOVG_GL_USE_UNIFORMBUFFER 0
#elif defined NANOVG_GL3_IMPLEMENTATION
#  define NANOVG_GL3 1
#  define NANOVG_GL_IMPLEMENTATION 1
#  define NANOVG_GL_USE_UNIFORMBUFFER 1
#elif defined NANOVG_GLES2_IMPLEMENTATION
#  define NANOVG_GLES2 1
#  define NANOVG_GL_IMPLEMENTATION 1
#  define NANOVG_GL_USE_UNIFORMBUFFER 0
#elif defined NANOVG_GLES3_IMPLEMENTATION
#  define NANOVG_GLES3 1
#  define NANOVG_GL_IMPLEMENTATION 1
#  define NANOVG_GL_USE_UNIFORMBUFFER 0
#endif

#define NANOVG_GL_USE_STATE_FILTER (1)

// Creates NanoVG contexts for different OpenGL (ES) versions.
// Flags should be combination of the create flags above.

#if defined NANOVG_GL2

NVGcontext * nvgCreateGL2(int flags);
void nvgDeleteGL2(NVGcontext * ctx);

int nvglCreateImageFromHandleGL2(NVGcontext * ctx, GLuint textureId, int w, int h, int flags);
GLuint nvglImageHandleGL2(NVGcontext * ctx, int image);

#endif

#if defined NANOVG_GL3

NVGcontext * nvgCreateGL3(int flags);
void nvgDeleteGL3(NVGcontext * ctx);

int nvglCreateImageFromHandleGL3(NVGcontext * ctx, GLuint textureId, int w, int h, int flags);
GLuint nvglImageHandleGL3(NVGcontext * ctx, int image);

#endif

#if defined NANOVG_GLES2

NVGcontext * nvgCreateGLES2(int flags);
void nvgDeleteGLES2(NVGcontext * ctx);

int nvglCreateImageFromHandleGLES2(NVGcontext * ctx, GLuint textureId, int w, int h, int flags);
GLuint nvglImageHandleGLES2(NVGcontext * ctx, int image);

#endif

#if defined NANOVG_GLES3

NVGcontext * nvgCreateGLES3(int flags);
void nvgDeleteGLES3(NVGcontext * ctx);

int nvglCreateImageFromHandleGLES3(NVGcontext * ctx, GLuint textureId, int w, int h, int flags);
GLuint nvglImageHandleGLES3(NVGcontext * ctx, int image);

#endif

// These are additional flags on top of NVGimageFlags.
enum NVGimageFlagsGL {
    NVG_IMAGE_NODELETE          = 1 << 16,  // Do not delete GL texture handle.
};

#ifdef __cplusplus
}
#endif

#endif /* NANOVG_GL_H */

#ifdef NANOVG_GL_IMPLEMENTATION

#include <math.h>
#include "nanovg.h"
#include "../../stdlib/lv_mem.h"
#include "../../stdlib/lv_string.h"
#include "../../stdlib/lv_sprintf.h"
#include "../../misc/lv_log.h"
#include "../../misc/lv_profiler.h"

enum GLNVGuniformLoc {
    GLNVG_LOC_VIEWSIZE,
    GLNVG_LOC_TEX,
    GLNVG_LOC_FRAG,
    GLNVG_MAX_LOCS
};

enum GLNVGshaderType {
    NSVG_SHADER_FILLGRAD,
    NSVG_SHADER_FILLIMG,
    NSVG_SHADER_SIMPLE,
    NSVG_SHADER_IMG
};

#define GLNVG_SHADER_COUNT 4

#if NANOVG_GL_USE_UNIFORMBUFFER
enum GLNVGuniformBindings {
    GLNVG_FRAG_BINDING = 0,
};
#endif

struct GLNVGshader {
    GLuint prog;
    GLuint frag;
    GLuint vert;
    GLint loc[GLNVG_MAX_LOCS];
};
typedef struct GLNVGshader GLNVGshader;

struct GLNVGtexture {
    int id;
    GLuint tex;
    int width, height;
    int type;
    int flags;
};
typedef struct GLNVGtexture GLNVGtexture;

struct GLNVGblend {
    GLenum srcRGB;
    GLenum dstRGB;
    GLenum srcAlpha;
    GLenum dstAlpha;
};
typedef struct GLNVGblend GLNVGblend;

enum GLNVGcallType {
    GLNVG_NONE = 0,
    GLNVG_FILL,
    GLNVG_CONVEXFILL,
    GLNVG_STROKE,
    GLNVG_TRIANGLES,
};

struct GLNVGcall {
    int type;
    int image;
    int pathOffset;
    int pathCount;
    int triangleOffset;
    int triangleCount;
    int uniformOffset;
    int shaderType;
    GLNVGblend blendFunc;
};
typedef struct GLNVGcall GLNVGcall;

struct GLNVGpath {
    int fillOffset;
    int fillCount;
    int strokeOffset;
    int strokeCount;
};
typedef struct GLNVGpath GLNVGpath;

#if NANOVG_GL_USE_UNIFORMBUFFER
struct GLNVGfragUniforms {
    struct {
        float scissorMat[12]; // matrices are actually 3 vec4s
        float paintMat[12];
        union NVGcolor innerCol;
        union NVGcolor outerCol;
        float scissorExt[2];
        float scissorScale[2];
        float extent[2];
        float radius;
        float feather;
        float strokeMult;
        float strokeThr;
        int texType;
        int type;
    } s;
};
typedef struct GLNVGfragUniforms GLNVGfragUniforms;
#else
// note: after modifying layout or size of uniform array,
// don't forget to also update the fragment shader source!
#define NANOVG_GL_UNIFORMARRAY_SIZE 11
union GLNVGfragUniforms {
    struct {
        float scissorMat[12]; // matrices are actually 3 vec4s
        float paintMat[12];
        union NVGcolor innerCol;
        union NVGcolor outerCol;
        float scissorExt[2];
        float scissorScale[2];
        float extent[2];
        float radius;
        float feather;
        float strokeMult;
        float strokeThr;
        float texType;
        float type;
    } s;
    float uniformArray[NANOVG_GL_UNIFORMARRAY_SIZE][4];
};
typedef union GLNVGfragUniforms GLNVGfragUniforms;
#endif

struct GLNVGcontext {
    GLNVGshader shaders[GLNVG_SHADER_COUNT];
    GLNVGtexture * textures;
    float view[2];
    int ntextures;
    int ctextures;
    int textureId;
    GLuint vertBuf[2];
    int vertBufIndex;
#if defined NANOVG_GL3
    GLuint vertArr;
#endif
#if NANOVG_GL_USE_UNIFORMBUFFER
    GLuint fragBuf;
#endif
    int fragSize;
    int flags;
    int boundShader;

    // Per frame buffers
    GLNVGcall * calls;
    int ccalls;
    int ncalls;
    GLNVGpath * paths;
    int cpaths;
    int npaths;
    struct NVGvertex * verts;
    int cverts;
    int nverts;
    unsigned char * uniforms;
    int cuniforms;
    int nuniforms;

    // cached state
#if NANOVG_GL_USE_STATE_FILTER
    GLuint boundTexture;
    GLuint stencilMask;
    GLenum stencilFunc;
    GLint stencilFuncRef;
    GLuint stencilFuncMask;
    GLNVGblend blendFunc;
#endif

    int dummyTex;
};
typedef struct GLNVGcontext GLNVGcontext;

static int glnvg__maxi(int a, int b)
{
    return a > b ? a : b;
}

#ifdef NANOVG_GLES2
static unsigned int glnvg__nearestPow2(unsigned int num)
{
    unsigned n = num > 0 ? num - 1 : 0;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    n++;
    return n;
}
#endif

static void glnvg__bindTexture(GLNVGcontext * gl, GLuint tex)
{
#if NANOVG_GL_USE_STATE_FILTER
    if(gl->boundTexture != tex) {
        gl->boundTexture = tex;
        glBindTexture(GL_TEXTURE_2D, tex);
    }
#else
    glBindTexture(GL_TEXTURE_2D, tex);
#endif
}

static void glnvg__stencilMask(GLNVGcontext * gl, GLuint mask)
{
#if NANOVG_GL_USE_STATE_FILTER
    if(gl->stencilMask != mask) {
        gl->stencilMask = mask;
        glStencilMask(mask);
    }
#else
    glStencilMask(mask);
#endif
}

static void glnvg__stencilFunc(GLNVGcontext * gl, GLenum func, GLint ref, GLuint mask)
{
#if NANOVG_GL_USE_STATE_FILTER
    if((gl->stencilFunc != func) ||
       (gl->stencilFuncRef != ref) ||
       (gl->stencilFuncMask != mask)) {

        gl->stencilFunc = func;
        gl->stencilFuncRef = ref;
        gl->stencilFuncMask = mask;
        glStencilFunc(func, ref, mask);
    }
#else
    glStencilFunc(func, ref, mask);
#endif
}
static void glnvg__blendFuncSeparate(GLNVGcontext * gl, const GLNVGblend * blend)
{
#if NANOVG_GL_USE_STATE_FILTER
    if((gl->blendFunc.srcRGB != blend->srcRGB) ||
       (gl->blendFunc.dstRGB != blend->dstRGB) ||
       (gl->blendFunc.srcAlpha != blend->srcAlpha) ||
       (gl->blendFunc.dstAlpha != blend->dstAlpha)) {

        gl->blendFunc = *blend;
        glBlendFuncSeparate(blend->srcRGB, blend->dstRGB, blend->srcAlpha, blend->dstAlpha);
    }
#else
    glBlendFuncSeparate(blend->srcRGB, blend->dstRGB, blend->srcAlpha, blend->dstAlpha);
#endif
}

static GLNVGtexture * glnvg__allocTexture(GLNVGcontext * gl)
{
    GLNVGtexture * tex = NULL;
    int i;

    for(i = 0; i < gl->ntextures; i++) {
        if(gl->textures[i].id == 0) {
            tex = &gl->textures[i];
            break;
        }
    }
    if(tex == NULL) {
        if(gl->ntextures + 1 > gl->ctextures) {
            GLNVGtexture * textures;
            int ctextures = glnvg__maxi(gl->ntextures + 1, 4) +  gl->ctextures / 2; // 1.5x Overallocate
            textures = (GLNVGtexture *)lv_realloc(gl->textures, sizeof(GLNVGtexture) * ctextures);
            if(textures == NULL) return NULL;
            gl->textures = textures;
            gl->ctextures = ctextures;
        }
        tex = &gl->textures[gl->ntextures++];
    }

    lv_memzero(tex, sizeof(*tex));
    tex->id = ++gl->textureId;

    return tex;
}

static GLNVGtexture * glnvg__findTexture(GLNVGcontext * gl, int id)
{
    int i;
    for(i = 0; i < gl->ntextures; i++)
        if(gl->textures[i].id == id)
            return &gl->textures[i];
    return NULL;
}

static int glnvg__deleteTexture(GLNVGcontext * gl, int id)
{
    int i;
    for(i = 0; i < gl->ntextures; i++) {
        if(gl->textures[i].id == id) {
            if(gl->textures[i].tex != 0 && (gl->textures[i].flags & NVG_IMAGE_NODELETE) == 0)
                glDeleteTextures(1, &gl->textures[i].tex);
            lv_memzero(&gl->textures[i], sizeof(gl->textures[i]));
            return 1;
        }
    }
    return 0;
}

static void glnvg__dumpShaderError(GLuint shader, const char * name, const char * type)
{
    GLchar str[512 + 1];
    GLsizei len = 0;
    glGetShaderInfoLog(shader, 512, &len, str);
    if(len > 512) len = 512;
    str[len] = '\0';
    LV_LOG_ERROR("Shader %s/%s error:\n%s", name, type, str);
}

static void glnvg__dumpProgramError(GLuint prog, const char * name)
{
    GLchar str[512 + 1];
    GLsizei len = 0;
    glGetProgramInfoLog(prog, 512, &len, str);
    if(len > 512) len = 512;
    str[len] = '\0';
    LV_LOG_ERROR("Program %s error:\n%s", name, str);
}

static void glnvg__checkError(GLNVGcontext * gl, const char * str)
{
    GLenum err;
    if((gl->flags & NVG_DEBUG) == 0) return;
    err = glGetError();
    if(err != GL_NO_ERROR) {
        LV_LOG_ERROR("Error %08x after %s", err, str);
        return;
    }
}

static int glnvg__createShader(GLNVGshader * shader, const char * name, const char * header, const char * opts,
                               const char * vshader, const char * fshader)
{
    GLint status;
    GLuint prog, vert, frag;
    const char * str[3];
    str[0] = header;
    str[1] = opts != NULL ? opts : "";

    lv_memzero(shader, sizeof(*shader));

    prog = glCreateProgram();
    vert = glCreateShader(GL_VERTEX_SHADER);
    frag = glCreateShader(GL_FRAGMENT_SHADER);
    str[2] = vshader;
    glShaderSource(vert, 3, str, 0);
    str[2] = fshader;
    glShaderSource(frag, 3, str, 0);

    glCompileShader(vert);
    glGetShaderiv(vert, GL_COMPILE_STATUS, &status);
    if(status != GL_TRUE) {
        glnvg__dumpShaderError(vert, name, "vert");
        return 0;
    }

    glCompileShader(frag);
    glGetShaderiv(frag, GL_COMPILE_STATUS, &status);
    if(status != GL_TRUE) {
        glnvg__dumpShaderError(frag, name, "frag");
        return 0;
    }

    glAttachShader(prog, vert);
    glAttachShader(prog, frag);

    glBindAttribLocation(prog, 0, "vertex");
    glBindAttribLocation(prog, 1, "tcoord");

    glLinkProgram(prog);
    glGetProgramiv(prog, GL_LINK_STATUS, &status);
    if(status != GL_TRUE) {
        glnvg__dumpProgramError(prog, name);
        return 0;
    }

    shader->prog = prog;
    shader->vert = vert;
    shader->frag = frag;

    return 1;
}

static void glnvg__deleteShader(GLNVGshader * shader)
{
    if(shader->prog != 0)
        glDeleteProgram(shader->prog);
    if(shader->vert != 0)
        glDeleteShader(shader->vert);
    if(shader->frag != 0)
        glDeleteShader(shader->frag);
}

static void glnvg__getUniforms(GLNVGshader * shader)
{
    shader->loc[GLNVG_LOC_VIEWSIZE] = glGetUniformLocation(shader->prog, "viewSize");
    shader->loc[GLNVG_LOC_TEX] = glGetUniformLocation(shader->prog, "tex");

#if NANOVG_GL_USE_UNIFORMBUFFER
    shader->loc[GLNVG_LOC_FRAG] = glGetUniformBlockIndex(shader->prog, "frag");
#else
    shader->loc[GLNVG_LOC_FRAG] = glGetUniformLocation(shader->prog, "frag");
#endif
}

static int glnvg__renderCreateTexture(void * uptr, int type, int w, int h, int imageFlags, const unsigned char * data);

static int glnvg__renderCreate(void * uptr)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    int align = 4;

    // TODO: mediump float may not be enough for GLES2 in iOS.
    // see the following discussion: https://github.com/memononen/nanovg/issues/46
    static const char * shaderHeader =
#if defined NANOVG_GL2
        "#define NANOVG_GL2 1\n"
#elif defined NANOVG_GL3
        "#version 150 core\n"
        "#define NANOVG_GL3 1\n"
#elif defined NANOVG_GLES2
        "#version 100\n"
        "#define NANOVG_GL2 1\n"
#elif defined NANOVG_GLES3
        "#version 300 es\n"
        "#define NANOVG_GL3 1\n"
#endif

#if NANOVG_GL_USE_UNIFORMBUFFER
        "#define USE_UNIFORMBUFFER 1\n"
#else
        "#define UNIFORMARRAY_SIZE 11\n"
#endif
        "\n";

    static const char * fillVertShader =
        "#ifdef GL_ES\n"
        "#if defined(NANOVG_GL3)\n"
        " precision highp float;\n"
        "#else\n"
        " precision mediump float;\n"
        "#endif\n"
        "#endif\n"
        "#ifdef NANOVG_GL3\n"
        "	uniform vec2 viewSize;\n"
        "	in vec2 vertex;\n"
        "	in vec2 tcoord;\n"
        "	out vec2 ftcoord;\n"
        "	out vec2 fpos;\n"
        "	out vec2 v_scissorPos;\n"
        "	out vec2 v_paintPos;\n"
        "#else\n"
        "	uniform vec2 viewSize;\n"
        "	attribute vec2 vertex;\n"
        "	attribute vec2 tcoord;\n"
        "	varying vec2 ftcoord;\n"
        "	varying vec2 fpos;\n"
        "	varying vec2 v_scissorPos;\n"
        "	varying vec2 v_paintPos;\n"
        "#endif\n"
        "#ifdef NANOVG_GL3\n"
        "#ifdef USE_UNIFORMBUFFER\n"
        "	layout(std140) uniform frag {\n"
        "		mat3 scissorMat;\n"
        "		mat3 paintMat;\n"
        "		vec4 innerCol;\n"
        "		vec4 outerCol;\n"
        "		vec2 scissorExt;\n"
        "		vec2 scissorScale;\n"
        "		vec2 extent;\n"
        "		float radius;\n"
        "		float feather;\n"
        "		float strokeMult;\n"
        "		float strokeThr;\n"
        "		int texType;\n"
        "		int type;\n"
        "	};\n"
        "#else\n"
        "	uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
        "#endif\n"
        "#else\n"
        "	uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
        "#endif\n"
        "#ifndef USE_UNIFORMBUFFER\n"
        "	#define scissorMat mat3(frag[0].xyz, frag[1].xyz, frag[2].xyz)\n"
        "	#define paintMat mat3(frag[3].xyz, frag[4].xyz, frag[5].xyz)\n"
        "#endif\n"
        "void main(void) {\n"
        "	ftcoord = tcoord;\n"
        "	fpos = vertex;\n"
        "	gl_Position = vec4(2.0*vertex.x/viewSize.x - 1.0, 1.0 - 2.0*vertex.y/viewSize.y, 0, 1);\n"
        "	#if SHADER_TYPE != 2\n" // Not SIMPLE
        "		v_scissorPos = (scissorMat * vec3(vertex, 1.0)).xy;\n"
        "	#endif\n"
        "	#if SHADER_TYPE == 0 || SHADER_TYPE == 1\n" // FILLGRAD or FILLIMG
        "		v_paintPos = (paintMat * vec3(vertex, 1.0)).xy;\n"
        "	#endif\n"
        "}\n";

    static const char * fillFragShader =
        "#ifdef GL_ES\n"
        "#if defined(NANOVG_GL3)\n"
        " precision highp float;\n"
        "#else\n"
        " precision mediump float;\n"
        "#endif\n"
        "#endif\n"
        "#ifdef NANOVG_GL3\n"
        "#ifdef USE_UNIFORMBUFFER\n"
        "	layout(std140) uniform frag {\n"
        "		mat3 scissorMat;\n"
        "		mat3 paintMat;\n"
        "		vec4 innerCol;\n"
        "		vec4 outerCol;\n"
        "		vec2 scissorExt;\n"
        "		vec2 scissorScale;\n"
        "		vec2 extent;\n"
        "		float radius;\n"
        "		float feather;\n"
        "		float strokeMult;\n"
        "		float strokeThr;\n"
        "		int texType;\n"
        "		int type;\n"
        "	};\n"
        "#else\n" // NANOVG_GL3 && !USE_UNIFORMBUFFER
        "	uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
        "#endif\n"
        "	uniform sampler2D tex;\n"
        "	in vec2 ftcoord;\n"
        "	in vec2 fpos;\n"
        "	in vec2 v_scissorPos;\n"
        "	in vec2 v_paintPos;\n"
        "	out vec4 outColor;\n"
        "#else\n" // !NANOVG_GL3
        "	uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
        "	uniform sampler2D tex;\n"
        "	varying vec2 ftcoord;\n"
        "	varying vec2 fpos;\n"
        "	varying vec2 v_scissorPos;\n"
        "	varying vec2 v_paintPos;\n"
        "#endif\n"
        "#ifndef USE_UNIFORMBUFFER\n"
        "	#define scissorMat mat3(frag[0].xyz, frag[1].xyz, frag[2].xyz)\n"
        "	#define paintMat mat3(frag[3].xyz, frag[4].xyz, frag[5].xyz)\n"
        "	#define innerCol frag[6]\n"
        "	#define outerCol frag[7]\n"
        "	#define scissorExt frag[8].xy\n"
        "	#define scissorScale frag[8].zw\n"
        "	#define extent frag[9].xy\n"
        "	#define radius frag[9].z\n"
        "	#define feather frag[9].w\n"
        "	#define strokeMult frag[10].x\n"
        "	#define strokeThr frag[10].y\n"
        "	#define texType int(frag[10].z)\n"
        "	#define type int(frag[10].w)\n"
        "#endif\n"
        "\n"
        "float sdroundrect(vec2 pt, vec2 ext, float rad) {\n"
        "	vec2 ext2 = ext - vec2(rad,rad);\n"
        "	vec2 d = abs(pt) - ext2;\n"
        "	return min(max(d.x,d.y),0.0) + length(max(d,0.0)) - rad;\n"
        "}\n"
        "\n"
        "// Scissoring\n"
        "float scissorMask(vec2 p) {\n"
        "	vec2 sc = (abs(p) - scissorExt);\n"
        "	sc = vec2(0.5,0.5) - sc * scissorScale;\n"
        "	return clamp(sc.x,0.0,1.0) * clamp(sc.y,0.0,1.0);\n"
        "}\n"
        "#ifdef EDGE_AA\n"
        "// Stroke - from [0..1] to clipped pyramid, where the slope is 1px.\n"
        "float strokeMask() {\n"
        "	return min(1.0, (1.0-abs(ftcoord.x*2.0-1.0))*strokeMult) * min(1.0, ftcoord.y);\n"
        "}\n"
        "#endif\n"
        "\n"
        "void main(void) {\n"
        "   vec4 result;\n"
        "	#if SHADER_TYPE != 2\n" // Not SIMPLE
        "		float scissor = scissorMask(v_scissorPos);\n"
        "	#endif\n"
        "#ifdef EDGE_AA\n"
        "	float strokeAlpha = strokeMask();\n"
        "	// if (strokeAlpha < strokeThr) discard;\n"
        "#else\n"
        "	float strokeAlpha = 1.0;\n"
        "#endif\n"
        "	#if SHADER_TYPE == 0\n"           // Gradient
        "		// Calculate gradient color using box gradient\n"
        "		vec2 pt = v_paintPos;\n"
        "		float d = clamp((sdroundrect(pt, extent, radius) + feather*0.5) / feather, 0.0, 1.0);\n"
        "		vec4 color = mix(innerCol,outerCol,d);\n"
        "		// Combine alpha\n"
        "		color *= strokeAlpha * scissor;\n"
        "		result = color;\n"
        "	#elif SHADER_TYPE == 1\n"     // Image
        "		// Calculate color fron texture\n"
        "		vec2 pt = v_paintPos / extent;\n"
        "#ifdef NANOVG_GL3\n"
        "		vec4 color = texture(tex, pt);\n"
        "#else\n"
        "		vec4 color = texture2D(tex, pt);\n"
        "#endif\n"
        "		if (texType == 1) color = vec4(color.xyz*color.w,color.w);"
        "		else if (texType == 2) color = vec4(color.x);"
        "		else if (texType == 3) color.rgb = color.bgr;"  // BGR -> RGB swizzle (premultiplied)
        "		else if (texType == 4) color = vec4(color.bgr, 1.0);"  // BGRX -> RGB with alpha=1
        "		else if (texType == 5) color = vec4(color.bgr*color.a, color.a);"  // BGR swizzle + premultiply
        "		// Apply color tint and alpha.\n"
        "		color *= innerCol;\n"
        "		// Combine alpha\n"
        "		color *= strokeAlpha * scissor;\n"
        "		result = color;\n"
        "	#elif SHADER_TYPE == 2\n"     // Stencil fill
        "		result = vec4(1,1,1,1);\n"
        "	#elif SHADER_TYPE == 3\n"     // Textured tris
        "#ifdef NANOVG_GL3\n"
        "		vec4 color = texture(tex, ftcoord);\n"
        "#else\n"
        "		vec4 color = texture2D(tex, ftcoord);\n"
        "#endif\n"
        "		if (texType == 1) color = vec4(color.xyz*color.w,color.w);"
        "		else if (texType == 2) color = vec4(color.x);"
        "		else if (texType == 3) color.rgb = color.bgr;"  // BGR -> RGB swizzle (premultiplied)
        "		else if (texType == 4) color = vec4(color.bgr, 1.0);"  // BGRX -> RGB with alpha=1
        "		else if (texType == 5) color = vec4(color.bgr*color.a, color.a);"  // BGR swizzle + premultiply
        "		color *= scissor;\n"
        "		result = color * innerCol;\n"
        "	#endif\n"
        "#ifdef NANOVG_GL3\n"
        "	outColor = result;\n"
        "#else\n"
        "	gl_FragColor = result;\n"
        "#endif\n"
        "}\n";

    glnvg__checkError(gl, "init");

    int i;
    char opts[64];
    for(i = 0; i < GLNVG_SHADER_COUNT; i++) {
        lv_snprintf(opts, sizeof(opts), "#define SHADER_TYPE %d\n%s", i,
                    (gl->flags & NVG_ANTIALIAS) ? "#define EDGE_AA 1\n" : "");
        if(glnvg__createShader(&gl->shaders[i], "shader", shaderHeader, opts, fillVertShader, fillFragShader) == 0)
            return 0;
        glnvg__checkError(gl, "uniform locations");
        glnvg__getUniforms(&gl->shaders[i]);
    }

    // Create dynamic vertex array
#if defined NANOVG_GL3
    glGenVertexArrays(1, &gl->vertArr);
#endif
    glGenBuffers(2, gl->vertBuf);

#if NANOVG_GL_USE_UNIFORMBUFFER
    // Create UBOs
    glUniformBlockBinding(gl->shaders[0].prog, gl->shaders[0].loc[GLNVG_LOC_FRAG], GLNVG_FRAG_BINDING);
    glGenBuffers(1, &gl->fragBuf);
    glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &align);
#endif
    gl->fragSize = sizeof(GLNVGfragUniforms) + align - sizeof(GLNVGfragUniforms) % align;

    // Some platforms does not allow to have samples to unset textures.
    // Create empty one which is bound when there's no texture specified.
    gl->dummyTex = glnvg__renderCreateTexture(gl, NVG_TEXTURE_ALPHA, 1, 1, 0, NULL);

    glnvg__checkError(gl, "create done");

    glFinish();

    return 1;
}

static int glnvg__renderCreateTexture(void * uptr, int type, int w, int h, int imageFlags, const unsigned char * data)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    GLNVGtexture * tex = glnvg__allocTexture(gl);

    if(tex == NULL) return 0;

#ifdef NANOVG_GLES2
    // Check for non-power of 2.
    if(glnvg__nearestPow2(w) != (unsigned int)w || glnvg__nearestPow2(h) != (unsigned int)h) {
        // No repeat
        if((imageFlags & NVG_IMAGE_REPEATX) != 0 || (imageFlags & NVG_IMAGE_REPEATY) != 0) {
            LV_LOG_WARN("Repeat X/Y is not supported for non power-of-two textures (%d x %d)", w, h);
            imageFlags &= ~(NVG_IMAGE_REPEATX | NVG_IMAGE_REPEATY);
        }
        // No mips.
        if(imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
            LV_LOG_WARN("Mip-maps is not support for non power-of-two textures (%d x %d)", w, h);
            imageFlags &= ~NVG_IMAGE_GENERATE_MIPMAPS;
        }
    }
#endif

    glGenTextures(1, &tex->tex);
    tex->width = w;
    tex->height = h;
    tex->type = type;
    tex->flags = imageFlags;
    glnvg__bindTexture(gl, tex->tex);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#ifndef NANOVG_GLES2
    glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width);
    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
#endif

#if defined (NANOVG_GL2)
    // GL 1.4 and later has support for generating mipmaps using a tex parameter.
    if(imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
        glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
    }
#endif

    if(type == NVG_TEXTURE_BGRA || type == NVG_TEXTURE_BGRX)
        /* BGRA/BGRX: upload as RGBA, shader will swizzle BGR->RGB */
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    else if(type == NVG_TEXTURE_RGBA)
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
    else if(type == NVG_TEXTURE_BGR)
        /* BGR888: upload as RGB, shader will swizzle BGR->RGB */
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
    else if(type == NVG_TEXTURE_RGB565)
        /* RGB565: directly compatible with GL */
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, data);
    else
#if defined(NANOVG_GLES2) || defined (NANOVG_GL2)
        glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, w, h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
#elif defined(NANOVG_GLES3)
        glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, data);
#else
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, data);
#endif

    if(imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
        if(imageFlags & NVG_IMAGE_NEAREST) {
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
        }
        else {
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        }
    }
    else {
        if(imageFlags & NVG_IMAGE_NEAREST) {
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        }
        else {
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        }
    }

    if(imageFlags & NVG_IMAGE_NEAREST) {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    }
    else {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    }

    if(imageFlags & NVG_IMAGE_REPEATX)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    else
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    if(imageFlags & NVG_IMAGE_REPEATY)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    else
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
#ifndef NANOVG_GLES2
    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
#endif

    // The new way to build mipmaps on GLES and GL3
#if !defined(NANOVG_GL2)
    if(imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
        glGenerateMipmap(GL_TEXTURE_2D);
    }
#endif

    glnvg__checkError(gl, "create tex");
    glnvg__bindTexture(gl, 0);

    return tex->id;
}


static int glnvg__renderDeleteTexture(void * uptr, int image)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    return glnvg__deleteTexture(gl, image);
}

static int glnvg__renderUpdateTexture(void * uptr, int image, int x, int y, int w, int h, const unsigned char * data)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    GLNVGtexture * tex = glnvg__findTexture(gl, image);

    if(tex == NULL) return 0;
    glnvg__bindTexture(gl, tex->tex);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

#ifndef NANOVG_GLES2
    glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width);
    glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
    glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
#else
    // No support for all of skip, need to update a whole row at a time.
    if(tex->type == NVG_TEXTURE_BGRA || tex->type == NVG_TEXTURE_RGBA || tex->type == NVG_TEXTURE_BGRX)
        data += y * tex->width * 4;
    else if(tex->type == NVG_TEXTURE_BGR)
        data += y * tex->width * 3;
    else if(tex->type == NVG_TEXTURE_RGB565)
        data += y * tex->width * 2;
    else
        data += y * tex->width;
    x = 0;
    w = tex->width;
#endif

    if(tex->type == NVG_TEXTURE_BGRA || tex->type == NVG_TEXTURE_BGRX)
        /* BGRA/BGRX: upload as RGBA, shader will swizzle BGR->RGB */
        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data);
    else if(tex->type == NVG_TEXTURE_RGBA)
        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data);
    else if(tex->type == NVG_TEXTURE_BGR)
        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_RGB, GL_UNSIGNED_BYTE, data);
    else if(tex->type == NVG_TEXTURE_RGB565)
        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, data);
    else
#if defined(NANOVG_GLES2) || defined(NANOVG_GL2)
        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
#else
        glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, GL_RED, GL_UNSIGNED_BYTE, data);
#endif

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
#ifndef NANOVG_GLES2
    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
    glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
    glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
#endif

    glnvg__bindTexture(gl, 0);

    return 1;
}

static int glnvg__renderGetTextureSize(void * uptr, int image, int * w, int * h)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    GLNVGtexture * tex = glnvg__findTexture(gl, image);
    if(tex == NULL) return 0;
    *w = tex->width;
    *h = tex->height;
    return 1;
}

static void glnvg__xformToMat3x4(float * m3, float * t)
{
    m3[0] = t[0];
    m3[1] = t[1];
    m3[2] = 0.0f;
    m3[3] = 0.0f;
    m3[4] = t[2];
    m3[5] = t[3];
    m3[6] = 0.0f;
    m3[7] = 0.0f;
    m3[8] = t[4];
    m3[9] = t[5];
    m3[10] = 1.0f;
    m3[11] = 0.0f;
}

static NVGcolor glnvg__premulColor(NVGcolor c)
{
    c.ch.r *= c.ch.a;
    c.ch.g *= c.ch.a;
    c.ch.b *= c.ch.a;
    return c;
}

static int glnvg__convertPaint(GLNVGcontext * gl, GLNVGfragUniforms * frag, NVGpaint * paint,
                               NVGscissor * scissor, float width, float fringe, float strokeThr)
{
    GLNVGtexture * tex = NULL;
    float invxform[6];

    lv_memzero(frag, sizeof(*frag));

    frag->s.innerCol = glnvg__premulColor(paint->innerColor);
    frag->s.outerCol = glnvg__premulColor(paint->outerColor);

    if(scissor->extent[0] < -0.5f || scissor->extent[1] < -0.5f) {
        lv_memzero(frag->s.scissorMat, sizeof(frag->s.scissorMat));
        frag->s.scissorExt[0] = 1.0f;
        frag->s.scissorExt[1] = 1.0f;
        frag->s.scissorScale[0] = 1.0f;
        frag->s.scissorScale[1] = 1.0f;
    }
    else {
        nvgTransformInverse(invxform, scissor->xform);
        glnvg__xformToMat3x4(frag->s.scissorMat, invxform);
        frag->s.scissorExt[0] = scissor->extent[0];
        frag->s.scissorExt[1] = scissor->extent[1];
        frag->s.scissorScale[0] = sqrtf(scissor->xform[0] * scissor->xform[0] + scissor->xform[2] * scissor->xform[2]) / fringe;
        frag->s.scissorScale[1] = sqrtf(scissor->xform[1] * scissor->xform[1] + scissor->xform[3] * scissor->xform[3]) / fringe;
    }

    lv_memcpy(frag->s.extent, paint->extent, sizeof(frag->s.extent));
    frag->s.strokeMult = (width * 0.5f + fringe * 0.5f) / fringe;
    frag->s.strokeThr = strokeThr;

    if(paint->image != 0) {
        tex = glnvg__findTexture(gl, paint->image);
        if(tex == NULL) return 0;
        if((tex->flags & NVG_IMAGE_FLIPY) != 0) {
            float m1[6], m2[6];
            nvgTransformTranslate(m1, 0.0f, frag->s.extent[1] * 0.5f);
            nvgTransformMultiply(m1, paint->xform);
            nvgTransformScale(m2, 1.0f, -1.0f);
            nvgTransformMultiply(m2, m1);
            nvgTransformTranslate(m1, 0.0f, -frag->s.extent[1] * 0.5f);
            nvgTransformMultiply(m1, m2);
            nvgTransformInverse(invxform, m1);
        }
        else {
            nvgTransformInverse(invxform, paint->xform);
        }
        frag->s.type = NSVG_SHADER_FILLIMG;

#if NANOVG_GL_USE_UNIFORMBUFFER
        if(tex->type == NVG_TEXTURE_RGBA)
            frag->s.texType = (tex->flags & NVG_IMAGE_PREMULTIPLIED) ? 0 : 1;
        else if(tex->type == NVG_TEXTURE_BGRA)
            frag->s.texType = (tex->flags & NVG_IMAGE_PREMULTIPLIED) ? 3 : 5;  // BGR swizzle, optionally premultiply
        else if(tex->type == NVG_TEXTURE_BGR)
            frag->s.texType = 3;  // BGR -> RGB swizzle (no alpha channel)
        else if(tex->type == NVG_TEXTURE_BGRX)
            frag->s.texType = 4;  // BGRX -> RGB with alpha=1 in shader
        else if(tex->type == NVG_TEXTURE_RGB565)
            frag->s.texType = 0;  // RGB565 is directly compatible
        else
            frag->s.texType = 2;
#else
        if(tex->type == NVG_TEXTURE_RGBA)
            frag->s.texType = (tex->flags & NVG_IMAGE_PREMULTIPLIED) ? 0.0f : 1.0f;
        else if(tex->type == NVG_TEXTURE_BGRA)
            frag->s.texType = (tex->flags & NVG_IMAGE_PREMULTIPLIED) ? 3.0f : 5.0f;  // BGR swizzle, optionally premultiply
        else if(tex->type == NVG_TEXTURE_BGR)
            frag->s.texType = 3.0f;  // BGR -> RGB swizzle (no alpha channel)
        else if(tex->type == NVG_TEXTURE_BGRX)
            frag->s.texType = 4.0f;  // BGRX -> RGB with alpha=1 in shader
        else if(tex->type == NVG_TEXTURE_RGB565)
            frag->s.texType = 0.0f;  // RGB565 is directly compatible
        else
            frag->s.texType = 2.0f;
#endif
        //      printf("frag->texType = %d\n", frag->texType);
    }
    else {
        frag->s.type = NSVG_SHADER_FILLGRAD;
        frag->s.radius = paint->radius;
        frag->s.feather = paint->feather;
        nvgTransformInverse(invxform, paint->xform);
    }

    glnvg__xformToMat3x4(frag->s.paintMat, invxform);

    return 1;
}

static GLNVGfragUniforms * nvg__fragUniformPtr(GLNVGcontext * gl, int i);

static void glnvg__bindShader(GLNVGcontext * gl, int shaderType)
{
    if(gl->boundShader != shaderType) {
        gl->boundShader = shaderType;
        glUseProgram(gl->shaders[shaderType].prog);
        glUniform1i(gl->shaders[shaderType].loc[GLNVG_LOC_TEX], 0);
        glUniform2fv(gl->shaders[shaderType].loc[GLNVG_LOC_VIEWSIZE], 1, gl->view);
    }
}

static void glnvg__setUniforms(GLNVGcontext * gl, int uniformOffset, int image, int shaderType)
{
    GLNVGtexture * tex = NULL;

    glnvg__bindShader(gl, shaderType);

#if NANOVG_GL_USE_UNIFORMBUFFER
    glBindBufferRange(GL_UNIFORM_BUFFER, GLNVG_FRAG_BINDING, gl->fragBuf, uniformOffset, sizeof(GLNVGfragUniforms));
#else
    // Optimization: NSVG_SHADER_SIMPLE doesn't use any uniforms in the fragment shader,
    // so we can skip uploading them.
    if(shaderType != NSVG_SHADER_SIMPLE) {
        GLNVGfragUniforms * frag = nvg__fragUniformPtr(gl, uniformOffset);
        glUniform4fv(gl->shaders[shaderType].loc[GLNVG_LOC_FRAG], NANOVG_GL_UNIFORMARRAY_SIZE, &(frag->uniformArray[0][0]));
    }
#endif

    if(image != 0) {
        tex = glnvg__findTexture(gl, image);
    }
    // If no image is set, use empty texture
    if(tex == NULL) {
        tex = glnvg__findTexture(gl, gl->dummyTex);
    }
    glnvg__bindTexture(gl, tex != NULL ? tex->tex : 0);
    glnvg__checkError(gl, "tex paint tex");
}

static void glnvg__renderViewport(void * uptr, float width, float height, float devicePixelRatio)
{
    NVG_NOTUSED(devicePixelRatio);
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    gl->view[0] = width;
    gl->view[1] = height;
}

static void glnvg__fill(GLNVGcontext * gl, GLNVGcall * call)
{
    LV_PROFILER_DRAW_BEGIN;
    GLNVGpath * paths = &gl->paths[call->pathOffset];
    int i, npaths = call->pathCount;

    // Draw shapes
    glEnable(GL_STENCIL_TEST);
    glnvg__stencilMask(gl, 0xff);
    glnvg__stencilFunc(gl, GL_ALWAYS, 0, 0xff);
    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

    // set bindpoint for solid loc
    glnvg__setUniforms(gl, call->uniformOffset, 0, NSVG_SHADER_SIMPLE);
    glnvg__checkError(gl, "fill simple");

    glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP);
    glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP);
    glDisable(GL_CULL_FACE);
    for(i = 0; i < npaths; i++)
        glDrawArrays(GL_TRIANGLE_FAN, paths[i].fillOffset, paths[i].fillCount);
    glEnable(GL_CULL_FACE);

    // Draw anti-aliased pixels
    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

    glnvg__setUniforms(gl, call->uniformOffset + gl->fragSize, call->image, call->shaderType);
    glnvg__checkError(gl, "fill fill");

    if(gl->flags & NVG_ANTIALIAS) {
        glnvg__stencilFunc(gl, GL_EQUAL, 0x00, 0xff);
        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
        // Draw fringes
        for(i = 0; i < npaths; i++)
            glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
    }

    // Draw fill
    glnvg__stencilFunc(gl, GL_NOTEQUAL, 0x0, 0xff);
    glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
    glDrawArrays(GL_TRIANGLE_STRIP, call->triangleOffset, call->triangleCount);

    glDisable(GL_STENCIL_TEST);
    LV_PROFILER_DRAW_END;
}

static void glnvg__convexFill(GLNVGcontext * gl, GLNVGcall * call)
{
    LV_PROFILER_DRAW_BEGIN;
    GLNVGpath * paths = &gl->paths[call->pathOffset];
    int i, npaths = call->pathCount;

    glnvg__setUniforms(gl, call->uniformOffset, call->image, call->shaderType);
    glnvg__checkError(gl, "convex fill");

    for(i = 0; i < npaths; i++) {
        glDrawArrays(GL_TRIANGLE_FAN, paths[i].fillOffset, paths[i].fillCount);
        // Draw fringes
        if(paths[i].strokeCount > 0) {
            glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
        }
    }
    LV_PROFILER_DRAW_END;
}

static void glnvg__stroke(GLNVGcontext * gl, GLNVGcall * call)
{
    LV_PROFILER_DRAW_BEGIN;
    GLNVGpath * paths = &gl->paths[call->pathOffset];
    int npaths = call->pathCount, i;

    if(gl->flags & NVG_STENCIL_STROKES) {

        glEnable(GL_STENCIL_TEST);
        glnvg__stencilMask(gl, 0xff);

        // Fill the stroke base without overlap
        glnvg__stencilFunc(gl, GL_EQUAL, 0x0, 0xff);
        glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
        glnvg__setUniforms(gl, call->uniformOffset + gl->fragSize, call->image, NSVG_SHADER_SIMPLE);
        glnvg__checkError(gl, "stroke fill 0");
        for(i = 0; i < npaths; i++)
            glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);

        // Draw anti-aliased pixels.
        glnvg__setUniforms(gl, call->uniformOffset, call->image, call->shaderType);
        glnvg__stencilFunc(gl, GL_EQUAL, 0x00, 0xff);
        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
        for(i = 0; i < npaths; i++)
            glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);

        // Clear stencil buffer.
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
        glnvg__stencilFunc(gl, GL_ALWAYS, 0x0, 0xff);
        glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
        glnvg__checkError(gl, "stroke fill 1");
        for(i = 0; i < npaths; i++)
            glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        glDisable(GL_STENCIL_TEST);

        //      glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, strokeWidth, fringe, 1.0f - 0.5f/255.0f);

    }
    else {
        glnvg__setUniforms(gl, call->uniformOffset, call->image, call->shaderType);
        glnvg__checkError(gl, "stroke fill");
        // Draw Strokes
        for(i = 0; i < npaths; i++)
            glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
    }
    LV_PROFILER_DRAW_END;
}

static void glnvg__triangles(GLNVGcontext * gl, GLNVGcall * call)
{
    LV_PROFILER_DRAW_BEGIN;
    glnvg__setUniforms(gl, call->uniformOffset, call->image, NSVG_SHADER_IMG);
    glnvg__checkError(gl, "triangles fill");

    glDrawArrays(GL_TRIANGLES, call->triangleOffset, call->triangleCount);
    LV_PROFILER_DRAW_END;
}

static void glnvg__renderCancel(void * uptr)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    gl->nverts = 0;
    gl->npaths = 0;
    gl->ncalls = 0;
    gl->nuniforms = 0;
}

static GLenum glnvg_convertBlendFuncFactor(int factor)
{
    if(factor == NVG_ZERO)
        return GL_ZERO;
    if(factor == NVG_ONE)
        return GL_ONE;
    if(factor == NVG_SRC_COLOR)
        return GL_SRC_COLOR;
    if(factor == NVG_ONE_MINUS_SRC_COLOR)
        return GL_ONE_MINUS_SRC_COLOR;
    if(factor == NVG_DST_COLOR)
        return GL_DST_COLOR;
    if(factor == NVG_ONE_MINUS_DST_COLOR)
        return GL_ONE_MINUS_DST_COLOR;
    if(factor == NVG_SRC_ALPHA)
        return GL_SRC_ALPHA;
    if(factor == NVG_ONE_MINUS_SRC_ALPHA)
        return GL_ONE_MINUS_SRC_ALPHA;
    if(factor == NVG_DST_ALPHA)
        return GL_DST_ALPHA;
    if(factor == NVG_ONE_MINUS_DST_ALPHA)
        return GL_ONE_MINUS_DST_ALPHA;
    if(factor == NVG_SRC_ALPHA_SATURATE)
        return GL_SRC_ALPHA_SATURATE;
    return GL_INVALID_ENUM;
}

static GLNVGblend glnvg__blendCompositeOperation(NVGcompositeOperationState op)
{
    GLNVGblend blend;
    blend.srcRGB = glnvg_convertBlendFuncFactor(op.srcRGB);
    blend.dstRGB = glnvg_convertBlendFuncFactor(op.dstRGB);
    blend.srcAlpha = glnvg_convertBlendFuncFactor(op.srcAlpha);
    blend.dstAlpha = glnvg_convertBlendFuncFactor(op.dstAlpha);
    if(blend.srcRGB == GL_INVALID_ENUM || blend.dstRGB == GL_INVALID_ENUM || blend.srcAlpha == GL_INVALID_ENUM ||
       blend.dstAlpha == GL_INVALID_ENUM) {
        blend.srcRGB = GL_ONE;
        blend.dstRGB = GL_ONE_MINUS_SRC_ALPHA;
        blend.srcAlpha = GL_ONE;
        blend.dstAlpha = GL_ONE_MINUS_SRC_ALPHA;
    }
    return blend;
}

static void glnvg__renderFlush(void * uptr)
{
    LV_PROFILER_DRAW_BEGIN;
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    int i;

    if(gl->ncalls > 0) {

        // Setup require GL state.
        LV_PROFILER_DRAW_BEGIN_TAG("setup_gl_state");
        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);
        glBindTexture(GL_TEXTURE_2D, 0);
#if NANOVG_GL_USE_STATE_FILTER
        gl->boundTexture = 0;
        gl->boundShader = -1;
        gl->stencilMask = 0xffffffff;
        gl->stencilFunc = GL_ALWAYS;
        gl->stencilFuncRef = 0;
        gl->stencilFuncMask = 0xffffffff;
        gl->blendFunc.srcRGB = GL_INVALID_ENUM;
        gl->blendFunc.srcAlpha = GL_INVALID_ENUM;
        gl->blendFunc.dstRGB = GL_INVALID_ENUM;
        gl->blendFunc.dstAlpha = GL_INVALID_ENUM;
#endif
        LV_PROFILER_DRAW_END_TAG("setup_gl_state");

#if NANOVG_GL_USE_UNIFORMBUFFER
        // Upload ubo for frag shaders
        LV_PROFILER_DRAW_BEGIN_TAG("glBindBuffer");
        glBindBuffer(GL_UNIFORM_BUFFER, gl->fragBuf);
        LV_PROFILER_DRAW_END_TAG("glBindBuffer");
        LV_PROFILER_DRAW_BEGIN_TAG("glBufferData");
        glBufferData(GL_UNIFORM_BUFFER, gl->nuniforms * gl->fragSize, gl->uniforms, GL_STREAM_DRAW);
        LV_PROFILER_DRAW_END_TAG("glBufferData");
#endif

        // Upload vertex data
#if defined NANOVG_GL3
        LV_PROFILER_DRAW_BEGIN_TAG("glBindVertexArray");
        glBindVertexArray(gl->vertArr);
        LV_PROFILER_DRAW_END_TAG("glBindVertexArray");
#endif
        gl->vertBufIndex = (gl->vertBufIndex + 1) % 2;
        LV_PROFILER_DRAW_BEGIN_TAG("glBindBuffer");
        glBindBuffer(GL_ARRAY_BUFFER, gl->vertBuf[gl->vertBufIndex]);
        LV_PROFILER_DRAW_END_TAG("glBindBuffer");
        LV_PROFILER_DRAW_BEGIN_TAG("glBufferData");
        glBufferData(GL_ARRAY_BUFFER, gl->nverts * sizeof(NVGvertex), gl->verts, GL_STREAM_DRAW);
        LV_PROFILER_DRAW_END_TAG("glBufferData");
        LV_PROFILER_DRAW_BEGIN_TAG("glEnableVertexAttribArray");
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
        LV_PROFILER_DRAW_END_TAG("glEnableVertexAttribArray");
        LV_PROFILER_DRAW_BEGIN_TAG("glVertexAttribPointer");
        glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(NVGvertex), (const GLvoid *)(size_t)0);
        glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(NVGvertex), (const GLvoid *)(0 + 2 * sizeof(float)));
        LV_PROFILER_DRAW_END_TAG("glVertexAttribPointer");

#if NANOVG_GL_USE_UNIFORMBUFFER
        LV_PROFILER_DRAW_BEGIN_TAG("glBindBuffer");
        glBindBuffer(GL_UNIFORM_BUFFER, gl->fragBuf);
        LV_PROFILER_DRAW_END_TAG("glBindBuffer");
#endif

        for(i = 0; i < gl->ncalls; i++) {
            GLNVGcall * call = &gl->calls[i];
            glnvg__blendFuncSeparate(gl, &call->blendFunc);
            if(call->type == GLNVG_FILL)
                glnvg__fill(gl, call);
            else if(call->type == GLNVG_CONVEXFILL)
                glnvg__convexFill(gl, call);
            else if(call->type == GLNVG_STROKE)
                glnvg__stroke(gl, call);
            else if(call->type == GLNVG_TRIANGLES)
                glnvg__triangles(gl, call);
        }

        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);
#if defined NANOVG_GL3
        glBindVertexArray(0);
#endif
        glDisable(GL_CULL_FACE);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glUseProgram(0);
        glnvg__bindTexture(gl, 0);
    }

    // Reset calls
    gl->nverts = 0;
    gl->npaths = 0;
    gl->ncalls = 0;
    gl->nuniforms = 0;
    LV_PROFILER_DRAW_END;
}

static int glnvg__maxVertCount(const NVGpath * paths, int npaths)
{
    int i, count = 0;
    for(i = 0; i < npaths; i++) {
        count += paths[i].nfill;
        count += paths[i].nstroke;
    }
    return count;
}

static GLNVGcall * glnvg__allocCall(GLNVGcontext * gl)
{
    GLNVGcall * ret = NULL;
    if(gl->ncalls + 1 > gl->ccalls) {
        GLNVGcall * calls;
        int ccalls = glnvg__maxi(gl->ncalls + 1, 128) + gl->ccalls / 2; // 1.5x Overallocate
        calls = (GLNVGcall *)lv_realloc(gl->calls, sizeof(GLNVGcall) * ccalls);
        if(calls == NULL) return NULL;
        gl->calls = calls;
        gl->ccalls = ccalls;
    }
    ret = &gl->calls[gl->ncalls++];
    lv_memzero(ret, sizeof(GLNVGcall));
    return ret;
}

static int glnvg__allocPaths(GLNVGcontext * gl, int n)
{
    int ret = 0;
    if(gl->npaths + n > gl->cpaths) {
        GLNVGpath * paths;
        int cpaths = glnvg__maxi(gl->npaths + n, 128) + gl->cpaths / 2; // 1.5x Overallocate
        paths = (GLNVGpath *)lv_realloc(gl->paths, sizeof(GLNVGpath) * cpaths);
        if(paths == NULL) return -1;
        gl->paths = paths;
        gl->cpaths = cpaths;
    }
    ret = gl->npaths;
    gl->npaths += n;
    return ret;
}

static int glnvg__allocVerts(GLNVGcontext * gl, int n)
{
    int ret = 0;
    if(gl->nverts + n > gl->cverts) {
        NVGvertex * verts;
        int cverts = glnvg__maxi(gl->nverts + n, 4096) + gl->cverts / 2; // 1.5x Overallocate
        verts = (NVGvertex *)lv_realloc(gl->verts, sizeof(NVGvertex) * cverts);
        if(verts == NULL) return -1;
        gl->verts = verts;
        gl->cverts = cverts;
    }
    ret = gl->nverts;
    gl->nverts += n;
    return ret;
}

static int glnvg__allocFragUniforms(GLNVGcontext * gl, int n)
{
    int ret = 0, structSize = gl->fragSize;
    if(gl->nuniforms + n > gl->cuniforms) {
        unsigned char * uniforms;
        int cuniforms = glnvg__maxi(gl->nuniforms + n, 128) + gl->cuniforms / 2; // 1.5x Overallocate
        uniforms = (unsigned char *)lv_realloc(gl->uniforms, structSize * cuniforms);
        if(uniforms == NULL) return -1;
        gl->uniforms = uniforms;
        gl->cuniforms = cuniforms;
    }
    ret = gl->nuniforms * structSize;
    gl->nuniforms += n;
    return ret;
}

static GLNVGfragUniforms * nvg__fragUniformPtr(GLNVGcontext * gl, int i)
{
    return (GLNVGfragUniforms *)&gl->uniforms[i];
}

static void glnvg__vset(NVGvertex * vtx, float x, float y, float u, float v)
{
    vtx->x = x;
    vtx->y = y;
    vtx->u = u;
    vtx->v = v;
}

static void glnvg__renderFill(void * uptr, NVGpaint * paint, NVGcompositeOperationState compositeOperation,
                              NVGscissor * scissor, float fringe,
                              const float * bounds, const NVGpath * paths, int npaths)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    GLNVGcall * call = glnvg__allocCall(gl);
    NVGvertex * quad;
    GLNVGfragUniforms * frag;
    int i, maxverts, offset;

    if(call == NULL) return;

    call->type = GLNVG_FILL;
    call->triangleCount = 4;
    call->pathOffset = glnvg__allocPaths(gl, npaths);
    if(call->pathOffset == -1) goto error;
    call->pathCount = npaths;
    call->image = paint->image;
    call->blendFunc = glnvg__blendCompositeOperation(compositeOperation);

    if(npaths == 1 && paths[0].convex) {
        call->type = GLNVG_CONVEXFILL;
        call->triangleCount = 0;    // Bounding box fill quad not needed for convex fill
    }

    // Allocate vertices for all the paths.
    maxverts = glnvg__maxVertCount(paths, npaths) + call->triangleCount;
    offset = glnvg__allocVerts(gl, maxverts);
    if(offset == -1) goto error;

    for(i = 0; i < npaths; i++) {
        GLNVGpath * copy = &gl->paths[call->pathOffset + i];
        const NVGpath * path = &paths[i];
        lv_memzero(copy, sizeof(GLNVGpath));
        if(path->nfill > 0) {
            copy->fillOffset = offset;
            copy->fillCount = path->nfill;
            lv_memcpy(&gl->verts[offset], path->fill, sizeof(NVGvertex) * path->nfill);
            offset += path->nfill;
        }
        if(path->nstroke > 0) {
            copy->strokeOffset = offset;
            copy->strokeCount = path->nstroke;
            lv_memcpy(&gl->verts[offset], path->stroke, sizeof(NVGvertex) * path->nstroke);
            offset += path->nstroke;
        }
    }

    // Setup uniforms for draw calls
    if(call->type == GLNVG_FILL) {
        // Quad
        call->triangleOffset = offset;
        quad = &gl->verts[call->triangleOffset];
        glnvg__vset(&quad[0], bounds[2], bounds[3], 0.5f, 1.0f);
        glnvg__vset(&quad[1], bounds[2], bounds[1], 0.5f, 1.0f);
        glnvg__vset(&quad[2], bounds[0], bounds[3], 0.5f, 1.0f);
        glnvg__vset(&quad[3], bounds[0], bounds[1], 0.5f, 1.0f);

        call->uniformOffset = glnvg__allocFragUniforms(gl, 2);
        if(call->uniformOffset == -1) goto error;
        // Simple shader for stencil
        frag = nvg__fragUniformPtr(gl, call->uniformOffset);
        lv_memzero(frag, sizeof(*frag));
        frag->s.strokeThr = -1.0f;
        frag->s.type = NSVG_SHADER_SIMPLE;
        // Fill shader
        glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, fringe, fringe,
                            -1.0f);
    }
    else {
        call->uniformOffset = glnvg__allocFragUniforms(gl, 1);
        if(call->uniformOffset == -1) goto error;
        // Fill shader
        glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, fringe, fringe, -1.0f);
    }

    if(paint->image != 0)
        call->shaderType = NSVG_SHADER_FILLIMG;
    else
        call->shaderType = NSVG_SHADER_FILLGRAD;

    return;

error:
    // We get here if call alloc was ok, but something else is not.
    // Roll back the last call to prevent drawing it.
    if(gl->ncalls > 0) gl->ncalls--;
}

static void glnvg__renderStroke(void * uptr, NVGpaint * paint, NVGcompositeOperationState compositeOperation,
                                NVGscissor * scissor, float fringe,
                                float strokeWidth, const NVGpath * paths, int npaths)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    GLNVGcall * call = glnvg__allocCall(gl);
    int i, maxverts, offset;

    if(call == NULL) return;

    call->type = GLNVG_STROKE;
    call->pathOffset = glnvg__allocPaths(gl, npaths);
    if(call->pathOffset == -1) goto error;
    call->pathCount = npaths;
    call->image = paint->image;
    call->blendFunc = glnvg__blendCompositeOperation(compositeOperation);

    // Allocate vertices for all the paths.
    maxverts = glnvg__maxVertCount(paths, npaths);
    offset = glnvg__allocVerts(gl, maxverts);
    if(offset == -1) goto error;

    for(i = 0; i < npaths; i++) {
        GLNVGpath * copy = &gl->paths[call->pathOffset + i];
        const NVGpath * path = &paths[i];
        lv_memzero(copy, sizeof(GLNVGpath));
        if(path->nstroke) {
            copy->strokeOffset = offset;
            copy->strokeCount = path->nstroke;
            lv_memcpy(&gl->verts[offset], path->stroke, sizeof(NVGvertex) * path->nstroke);
            offset += path->nstroke;
        }
    }

    if(gl->flags & NVG_STENCIL_STROKES) {
        // Fill shader
        call->uniformOffset = glnvg__allocFragUniforms(gl, 2);
        if(call->uniformOffset == -1) goto error;

        glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, strokeWidth, fringe, -1.0f);
        glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, strokeWidth,
                            fringe, 1.0f - 0.5f / 255.0f);

    }
    else {
        // Fill shader
        call->uniformOffset = glnvg__allocFragUniforms(gl, 1);
        if(call->uniformOffset == -1) goto error;
        glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, strokeWidth, fringe, -1.0f);
    }

    if(paint->image != 0)
        call->shaderType = NSVG_SHADER_FILLIMG;
    else
        call->shaderType = NSVG_SHADER_FILLGRAD;

    return;

error:
    // We get here if call alloc was ok, but something else is not.
    // Roll back the last call to prevent drawing it.
    if(gl->ncalls > 0) gl->ncalls--;
}

static void glnvg__renderTriangles(void * uptr, NVGpaint * paint, NVGcompositeOperationState compositeOperation,
                                   NVGscissor * scissor,
                                   const NVGvertex * verts, int nverts, float fringe)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    GLNVGcall * call = glnvg__allocCall(gl);
    GLNVGfragUniforms * frag;

    if(call == NULL) return;

    call->type = GLNVG_TRIANGLES;
    call->image = paint->image;
    call->blendFunc = glnvg__blendCompositeOperation(compositeOperation);

    // Allocate vertices for all the paths.
    call->triangleOffset = glnvg__allocVerts(gl, nverts);
    if(call->triangleOffset == -1) goto error;
    call->triangleCount = nverts;

    lv_memcpy(&gl->verts[call->triangleOffset], verts, sizeof(NVGvertex) * nverts);

    // Fill shader
    call->uniformOffset = glnvg__allocFragUniforms(gl, 1);
    if(call->uniformOffset == -1) goto error;
    frag = nvg__fragUniformPtr(gl, call->uniformOffset);
    glnvg__convertPaint(gl, frag, paint, scissor, 1.0f, fringe, -1.0f);
    frag->s.type = NSVG_SHADER_IMG;
    call->shaderType = NSVG_SHADER_IMG;

    return;

error:
    // We get here if call alloc was ok, but something else is not.
    // Roll back the last call to prevent drawing it.
    if(gl->ncalls > 0) gl->ncalls--;
}

static void glnvg__renderDelete(void * uptr)
{
    GLNVGcontext * gl = (GLNVGcontext *)uptr;
    int i;
    if(gl == NULL) return;

    for(i = 0; i < GLNVG_SHADER_COUNT; i++)
        glnvg__deleteShader(&gl->shaders[i]);

#if defined NANOVG_GL3
#if NANOVG_GL_USE_UNIFORMBUFFER
    if(gl->fragBuf != 0)
        glDeleteBuffers(1, &gl->fragBuf);
#endif
    if(gl->vertArr != 0)
        glDeleteVertexArrays(1, &gl->vertArr);
#endif
    if(gl->vertBuf[0] != 0)
        glDeleteBuffers(2, gl->vertBuf);

    for(i = 0; i < gl->ntextures; i++) {
        if(gl->textures[i].tex != 0 && (gl->textures[i].flags & NVG_IMAGE_NODELETE) == 0)
            glDeleteTextures(1, &gl->textures[i].tex);
    }
    lv_free(gl->textures);

    lv_free(gl->paths);
    lv_free(gl->verts);
    lv_free(gl->uniforms);
    lv_free(gl->calls);

    lv_free(gl);
}


#if defined NANOVG_GL2
    NVGcontext * nvgCreateGL2(int flags)
#elif defined NANOVG_GL3
    NVGcontext * nvgCreateGL3(int flags)
#elif defined NANOVG_GLES2
    NVGcontext * nvgCreateGLES2(int flags)
#elif defined NANOVG_GLES3
    NVGcontext * nvgCreateGLES3(int flags)
#endif
{
    NVGparams params;
    NVGcontext * ctx = NULL;
    GLNVGcontext * gl = (GLNVGcontext *)lv_malloc(sizeof(GLNVGcontext));
    if(gl == NULL) goto error;
    lv_memzero(gl, sizeof(GLNVGcontext));

    lv_memzero(&params, sizeof(params));
    params.renderCreate = glnvg__renderCreate;
    params.renderCreateTexture = glnvg__renderCreateTexture;
    params.renderDeleteTexture = glnvg__renderDeleteTexture;
    params.renderUpdateTexture = glnvg__renderUpdateTexture;
    params.renderGetTextureSize = glnvg__renderGetTextureSize;
    params.renderViewport = glnvg__renderViewport;
    params.renderCancel = glnvg__renderCancel;
    params.renderFlush = glnvg__renderFlush;
    params.renderFill = glnvg__renderFill;
    params.renderStroke = glnvg__renderStroke;
    params.renderTriangles = glnvg__renderTriangles;
    params.renderDelete = glnvg__renderDelete;
    params.userPtr = gl;
    params.edgeAntiAlias = flags & NVG_ANTIALIAS ? 1 : 0;

    gl->flags = flags;

    ctx = nvgCreateInternal(&params);
    if(ctx == NULL) goto error;

    return ctx;

error:
    // 'gl' is freed by nvgDeleteInternal.
    if(ctx != NULL) nvgDeleteInternal(ctx);
    return NULL;
}

#if defined NANOVG_GL2
    void nvgDeleteGL2(NVGcontext * ctx)
#elif defined NANOVG_GL3
    void nvgDeleteGL3(NVGcontext * ctx)
#elif defined NANOVG_GLES2
    void nvgDeleteGLES2(NVGcontext * ctx)
#elif defined NANOVG_GLES3
    void nvgDeleteGLES3(NVGcontext * ctx)
#endif
{
    nvgDeleteInternal(ctx);
}

#if defined NANOVG_GL2
    int nvglCreateImageFromHandleGL2(NVGcontext * ctx, GLuint textureId, int w, int h, int imageFlags)
#elif defined NANOVG_GL3
    int nvglCreateImageFromHandleGL3(NVGcontext * ctx, GLuint textureId, int w, int h, int imageFlags)
#elif defined NANOVG_GLES2
    int nvglCreateImageFromHandleGLES2(NVGcontext * ctx, GLuint textureId, int w, int h, int imageFlags)
#elif defined NANOVG_GLES3
    int nvglCreateImageFromHandleGLES3(NVGcontext * ctx, GLuint textureId, int w, int h, int imageFlags)
#endif
{
    GLNVGcontext * gl = (GLNVGcontext *)nvgInternalParams(ctx)->userPtr;
    GLNVGtexture * tex = glnvg__allocTexture(gl);

    if(tex == NULL) return 0;

    tex->type = NVG_TEXTURE_RGBA;
    tex->tex = textureId;
    tex->flags = imageFlags;
    tex->width = w;
    tex->height = h;

    return tex->id;
}

#if defined NANOVG_GL2
    GLuint nvglImageHandleGL2(NVGcontext * ctx, int image)
#elif defined NANOVG_GL3
    GLuint nvglImageHandleGL3(NVGcontext * ctx, int image)
#elif defined NANOVG_GLES2
    GLuint nvglImageHandleGLES2(NVGcontext * ctx, int image)
#elif defined NANOVG_GLES3
    GLuint nvglImageHandleGLES3(NVGcontext * ctx, int image)
#endif
{
    GLNVGcontext * gl = (GLNVGcontext *)nvgInternalParams(ctx)->userPtr;
    GLNVGtexture * tex = glnvg__findTexture(gl, image);
    return tex->tex;
}

#endif /* LV_USE_NANOVG */

#endif /* NANOVG_GL_IMPLEMENTATION */
