1 //
2 // Copyright (c) 2009-2013 Mikko Mononen memon@inside.org
3 //
4 // This software is provided 'as-is', without any express or implied
5 // warranty. In no event will the authors be held liable for any damages
6 // arising from the use of this software.
7 // Permission is granted to anyone to use this software for any purpose,
8 // including commercial applications, and to alter it and redistribute it
9 // freely, subject to the following restrictions:
10 // 1. The origin of this software must not be misrepresented; you must not
11 // claim that you wrote the original software. If you use this software
12 // in a product, an acknowledgment in the product documentation would be
13 // appreciated but is not required.
14 // 2. Altered source versions must be plainly marked as such, and must not be
15 // misrepresented as being the original software.
16 // 3. This notice may not be removed or altered from any source distribution.
17 //
18 #ifndef NANOVG_GL_H
19 #define NANOVG_GL_H
20
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 // Create flags
26
27 enum NVGcreateFlags {
28 // Flag indicating if geometry based anti-aliasing is used (may not be needed when using MSAA).
29 NVG_ANTIALIAS = 1<<0,
30 // Flag indicating if strokes should be drawn using stencil buffer. The rendering will be a little
31 // slower, but path overlaps (i.e. self-intersecting or sharp turns) will be drawn just once.
32 NVG_STENCIL_STROKES = 1<<1,
33 // Flag indicating that additional debug checks are done.
34 NVG_DEBUG = 1<<2,
35 };
36
37 #if defined NANOVG_GL2_IMPLEMENTATION
38 # define NANOVG_GL2 1
39 # define NANOVG_GL_IMPLEMENTATION 1
40 #elif defined NANOVG_GL3_IMPLEMENTATION
41 # define NANOVG_GL3 1
42 # define NANOVG_GL_IMPLEMENTATION 1
43 # define NANOVG_GL_USE_UNIFORMBUFFER 1
44 #elif defined NANOVG_GLES2_IMPLEMENTATION
45 # define NANOVG_GLES2 1
46 # define NANOVG_GL_IMPLEMENTATION 1
47 #elif defined NANOVG_GLES3_IMPLEMENTATION
48 # define NANOVG_GLES3 1
49 # define NANOVG_GL_IMPLEMENTATION 1
50 #endif
51
52 #define NANOVG_GL_USE_STATE_FILTER (1)
53
54 // Creates NanoVG contexts for different OpenGL (ES) versions.
55 // Flags should be combination of the create flags above.
56
57 #if defined NANOVG_GL2
58
59 NVGcontext* nvgCreateGL2(int flags);
60 void nvgDeleteGL2(NVGcontext* ctx);
61
62 #endif
63
64 #if defined NANOVG_GL3
65
66 NVGcontext* nvgCreateGL3(int flags);
67 void nvgDeleteGL3(NVGcontext* ctx);
68
69 #endif
70
71 #if defined NANOVG_GLES2
72
73 NVGcontext* nvgCreateGLES2(int flags);
74 void nvgDeleteGLES2(NVGcontext* ctx);
75
76 #endif
77
78 #if defined NANOVG_GLES3
79
80 NVGcontext* nvgCreateGLES3(int flags);
81 void nvgDeleteGLES3(NVGcontext* ctx);
82
83 #endif
84
85 // These are additional flags on top of NVGimageFlags.
86 enum NVGimageFlagsGL {
87 NVG_IMAGE_NODELETE = 1<<16, // Do not delete GL texture handle.
88 };
89
90 int nvglCreateImageFromHandle(NVGcontext* ctx, GLuint textureId, int w, int h, int flags);
91 GLuint nvglImageHandle(NVGcontext* ctx, int image);
92
93
94 #ifdef __cplusplus
95 }
96 #endif
97
98 #endif /* NANOVG_GL_H */
99
100 #ifdef NANOVG_GL_IMPLEMENTATION
101
102 #include <stdlib.h>
103 #include <stdio.h>
104 #include <string.h>
105 #include <math.h>
106 #include "nanovg.h"
107
108 enum GLNVGuniformLoc {
109 GLNVG_LOC_VIEWSIZE,
110 GLNVG_LOC_TEX,
111 GLNVG_LOC_FRAG,
112 GLNVG_MAX_LOCS
113 };
114
115 enum GLNVGshaderType {
116 NSVG_SHADER_FILLGRAD,
117 NSVG_SHADER_FILLIMG,
118 NSVG_SHADER_SIMPLE,
119 NSVG_SHADER_IMG
120 };
121
122 #if NANOVG_GL_USE_UNIFORMBUFFER
123 enum GLNVGuniformBindings {
124 GLNVG_FRAG_BINDING = 0,
125 };
126 #endif
127
128 struct GLNVGshader {
129 GLuint prog;
130 GLuint frag;
131 GLuint vert;
132 GLint loc[GLNVG_MAX_LOCS];
133 };
134 typedef struct GLNVGshader GLNVGshader;
135
136 struct GLNVGtexture {
137 int id;
138 GLuint tex;
139 int width, height;
140 int type;
141 int flags;
142 };
143 typedef struct GLNVGtexture GLNVGtexture;
144
145 enum GLNVGcallType {
146 GLNVG_NONE = 0,
147 GLNVG_FILL,
148 GLNVG_CONVEXFILL,
149 GLNVG_STROKE,
150 GLNVG_TRIANGLES,
151 };
152
153 struct GLNVGcall {
154 int type;
155 int image;
156 int pathOffset;
157 int pathCount;
158 int triangleOffset;
159 int triangleCount;
160 int uniformOffset;
161 };
162 typedef struct GLNVGcall GLNVGcall;
163
164 struct GLNVGpath {
165 int fillOffset;
166 int fillCount;
167 int strokeOffset;
168 int strokeCount;
169 };
170 typedef struct GLNVGpath GLNVGpath;
171
172 struct GLNVGfragUniforms {
173 #if NANOVG_GL_USE_UNIFORMBUFFER
174 float scissorMat[12]; // matrices are actually 3 vec4s
175 float paintMat[12];
176 struct NVGcolor innerCol;
177 struct NVGcolor outerCol;
178 float scissorExt[2];
179 float scissorScale[2];
180 float extent[2];
181 float radius;
182 float feather;
183 float strokeMult;
184 float strokeThr;
185 int texType;
186 int type;
187 #else
188 // note: after modifying layout or size of uniform array,
189 // don't forget to also update the fragment shader source!
190 #define NANOVG_GL_UNIFORMARRAY_SIZE 11
191 union {
192 struct {
193 float scissorMat[12]; // matrices are actually 3 vec4s
194 float paintMat[12];
195 struct NVGcolor innerCol;
196 struct NVGcolor outerCol;
197 float scissorExt[2];
198 float scissorScale[2];
199 float extent[2];
200 float radius;
201 float feather;
202 float strokeMult;
203 float strokeThr;
204 float texType;
205 float type;
206 };
207 float uniformArray[NANOVG_GL_UNIFORMARRAY_SIZE][4];
208 };
209 #endif
210 };
211 typedef struct GLNVGfragUniforms GLNVGfragUniforms;
212
213 struct GLNVGcontext {
214 GLNVGshader shader;
215 GLNVGtexture* textures;
216 float view[2];
217 int ntextures;
218 int ctextures;
219 int textureId;
220 GLuint vertBuf;
221 #if defined NANOVG_GL3
222 GLuint vertArr;
223 #endif
224 #if NANOVG_GL_USE_UNIFORMBUFFER
225 GLuint fragBuf;
226 #endif
227 int fragSize;
228 int flags;
229
230 // Per frame buffers
231 GLNVGcall* calls;
232 int ccalls;
233 int ncalls;
234 GLNVGpath* paths;
235 int cpaths;
236 int npaths;
237 struct NVGvertex* verts;
238 int cverts;
239 int nverts;
240 unsigned char* uniforms;
241 int cuniforms;
242 int nuniforms;
243
244 // cached state
245 #if NANOVG_GL_USE_STATE_FILTER
246 GLuint boundTexture;
247 GLuint stencilMask;
248 GLenum stencilFunc;
249 GLint stencilFuncRef;
250 GLuint stencilFuncMask;
251 #endif
252 };
253 typedef struct GLNVGcontext GLNVGcontext;
254
glnvg__maxi(int a,int b)255 static int glnvg__maxi(int a, int b) { return a > b ? a : b; }
256
257 #ifdef NANOVG_GLES2
glnvg__nearestPow2(unsigned int num)258 static unsigned int glnvg__nearestPow2(unsigned int num)
259 {
260 unsigned n = num > 0 ? num - 1 : 0;
261 n |= n >> 1;
262 n |= n >> 2;
263 n |= n >> 4;
264 n |= n >> 8;
265 n |= n >> 16;
266 n++;
267 return n;
268 }
269 #endif
270
glnvg__bindTexture(GLNVGcontext * gl,GLuint tex)271 static void glnvg__bindTexture(GLNVGcontext* gl, GLuint tex)
272 {
273 #if NANOVG_GL_USE_STATE_FILTER
274 if (gl->boundTexture != tex) {
275 gl->boundTexture = tex;
276 glBindTexture(GL_TEXTURE_2D, tex);
277 }
278 #else
279 glBindTexture(GL_TEXTURE_2D, tex);
280 #endif
281 }
282
glnvg__stencilMask(GLNVGcontext * gl,GLuint mask)283 static void glnvg__stencilMask(GLNVGcontext* gl, GLuint mask)
284 {
285 #if NANOVG_GL_USE_STATE_FILTER
286 if (gl->stencilMask != mask) {
287 gl->stencilMask = mask;
288 glStencilMask(mask);
289 }
290 #else
291 glStencilMask(mask);
292 #endif
293 }
294
glnvg__stencilFunc(GLNVGcontext * gl,GLenum func,GLint ref,GLuint mask)295 static void glnvg__stencilFunc(GLNVGcontext* gl, GLenum func, GLint ref, GLuint mask)
296 {
297 #if NANOVG_GL_USE_STATE_FILTER
298 if ((gl->stencilFunc != func) ||
299 (gl->stencilFuncRef != ref) ||
300 (gl->stencilFuncMask != mask)) {
301
302 gl->stencilFunc = func;
303 gl->stencilFuncRef = ref;
304 gl->stencilFuncMask = mask;
305 glStencilFunc(func, ref, mask);
306 }
307 #else
308 glStencilFunc(func, ref, mask);
309 #endif
310 }
311
glnvg__allocTexture(GLNVGcontext * gl)312 static GLNVGtexture* glnvg__allocTexture(GLNVGcontext* gl)
313 {
314 GLNVGtexture* tex = NULL;
315 int i;
316
317 for (i = 0; i < gl->ntextures; i++) {
318 if (gl->textures[i].id == 0) {
319 tex = &gl->textures[i];
320 break;
321 }
322 }
323 if (tex == NULL) {
324 if (gl->ntextures+1 > gl->ctextures) {
325 GLNVGtexture* textures;
326 int ctextures = glnvg__maxi(gl->ntextures+1, 4) + gl->ctextures/2; // 1.5x Overallocate
327 textures = (GLNVGtexture*)realloc(gl->textures, sizeof(GLNVGtexture)*ctextures);
328 if (textures == NULL) return NULL;
329 gl->textures = textures;
330 gl->ctextures = ctextures;
331 }
332 tex = &gl->textures[gl->ntextures++];
333 }
334
335 memset(tex, 0, sizeof(*tex));
336 tex->id = ++gl->textureId;
337
338 return tex;
339 }
340
glnvg__findTexture(GLNVGcontext * gl,int id)341 static GLNVGtexture* glnvg__findTexture(GLNVGcontext* gl, int id)
342 {
343 int i;
344 for (i = 0; i < gl->ntextures; i++)
345 if (gl->textures[i].id == id)
346 return &gl->textures[i];
347 return NULL;
348 }
349
glnvg__deleteTexture(GLNVGcontext * gl,int id)350 static int glnvg__deleteTexture(GLNVGcontext* gl, int id)
351 {
352 int i;
353 for (i = 0; i < gl->ntextures; i++) {
354 if (gl->textures[i].id == id) {
355 if (gl->textures[i].tex != 0 && (gl->textures[i].flags & NVG_IMAGE_NODELETE) == 0)
356 glDeleteTextures(1, &gl->textures[i].tex);
357 memset(&gl->textures[i], 0, sizeof(gl->textures[i]));
358 return 1;
359 }
360 }
361 return 0;
362 }
363
glnvg__dumpShaderError(GLuint shader,const char * name,const char * type)364 static void glnvg__dumpShaderError(GLuint shader, const char* name, const char* type)
365 {
366 char str[512+1];
367 int len = 0;
368 glGetShaderInfoLog(shader, 512, &len, str);
369 if (len > 512) len = 512;
370 str[len] = '\0';
371 printf("Shader %s/%s error:\n%s\n", name, type, str);
372 }
373
glnvg__dumpProgramError(GLuint prog,const char * name)374 static void glnvg__dumpProgramError(GLuint prog, const char* name)
375 {
376 char str[512+1];
377 int len = 0;
378 glGetProgramInfoLog(prog, 512, &len, str);
379 if (len > 512) len = 512;
380 str[len] = '\0';
381 printf("Program %s error:\n%s\n", name, str);
382 }
383
glnvg__checkError(GLNVGcontext * gl,const char * str)384 static void glnvg__checkError(GLNVGcontext* gl, const char* str)
385 {
386 GLenum err;
387 if ((gl->flags & NVG_DEBUG) == 0) return;
388 err = glGetError();
389 if (err != GL_NO_ERROR) {
390 printf("Error %08x after %s\n", err, str);
391 return;
392 }
393 }
394
glnvg__createShader(GLNVGshader * shader,const char * name,const char * header,const char * opts,const char * vshader,const char * fshader)395 static int glnvg__createShader(GLNVGshader* shader, const char* name, const char* header, const char* opts, const char* vshader, const char* fshader)
396 {
397 GLint status;
398 GLuint prog, vert, frag;
399 const char* str[3];
400 str[0] = header;
401 str[1] = opts != NULL ? opts : "";
402
403 memset(shader, 0, sizeof(*shader));
404
405 prog = glCreateProgram();
406 vert = glCreateShader(GL_VERTEX_SHADER);
407 frag = glCreateShader(GL_FRAGMENT_SHADER);
408 str[2] = vshader;
409 glShaderSource(vert, 3, str, 0);
410 str[2] = fshader;
411 glShaderSource(frag, 3, str, 0);
412
413 glCompileShader(vert);
414 glGetShaderiv(vert, GL_COMPILE_STATUS, &status);
415 if (status != GL_TRUE) {
416 glnvg__dumpShaderError(vert, name, "vert");
417 return 0;
418 }
419
420 glCompileShader(frag);
421 glGetShaderiv(frag, GL_COMPILE_STATUS, &status);
422 if (status != GL_TRUE) {
423 glnvg__dumpShaderError(frag, name, "frag");
424 return 0;
425 }
426
427 glAttachShader(prog, vert);
428 glAttachShader(prog, frag);
429
430 glBindAttribLocation(prog, 0, "vertex");
431 glBindAttribLocation(prog, 1, "tcoord");
432
433 glLinkProgram(prog);
434 glGetProgramiv(prog, GL_LINK_STATUS, &status);
435 if (status != GL_TRUE) {
436 glnvg__dumpProgramError(prog, name);
437 return 0;
438 }
439
440 shader->prog = prog;
441 shader->vert = vert;
442 shader->frag = frag;
443
444 return 1;
445 }
446
glnvg__deleteShader(GLNVGshader * shader)447 static void glnvg__deleteShader(GLNVGshader* shader)
448 {
449 if (shader->prog != 0)
450 glDeleteProgram(shader->prog);
451 if (shader->vert != 0)
452 glDeleteShader(shader->vert);
453 if (shader->frag != 0)
454 glDeleteShader(shader->frag);
455 }
456
glnvg__getUniforms(GLNVGshader * shader)457 static void glnvg__getUniforms(GLNVGshader* shader)
458 {
459 shader->loc[GLNVG_LOC_VIEWSIZE] = glGetUniformLocation(shader->prog, "viewSize");
460 shader->loc[GLNVG_LOC_TEX] = glGetUniformLocation(shader->prog, "tex");
461
462 #if NANOVG_GL_USE_UNIFORMBUFFER
463 shader->loc[GLNVG_LOC_FRAG] = glGetUniformBlockIndex(shader->prog, "frag");
464 #else
465 shader->loc[GLNVG_LOC_FRAG] = glGetUniformLocation(shader->prog, "frag");
466 #endif
467 }
468
glnvg__renderCreate(void * uptr)469 static int glnvg__renderCreate(void* uptr)
470 {
471 GLNVGcontext* gl = (GLNVGcontext*)uptr;
472 int align = 4;
473
474 // TODO: mediump float may not be enough for GLES2 in iOS.
475 // see the following discussion: https://github.com/memononen/nanovg/issues/46
476 static const char* shaderHeader =
477 #if defined NANOVG_GL2
478 "#define NANOVG_GL2 1\n"
479 #elif defined NANOVG_GL3
480 "#version 150 core\n"
481 "#define NANOVG_GL3 1\n"
482 #elif defined NANOVG_GLES2
483 "#version 100\n"
484 "#define NANOVG_GL2 1\n"
485 #elif defined NANOVG_GLES3
486 "#version 300 es\n"
487 "#define NANOVG_GL3 1\n"
488 #endif
489
490 #if NANOVG_GL_USE_UNIFORMBUFFER
491 "#define USE_UNIFORMBUFFER 1\n"
492 #else
493 "#define UNIFORMARRAY_SIZE 11\n"
494 #endif
495 "\n";
496
497 static const char* fillVertShader =
498 "#ifdef NANOVG_GL3\n"
499 " uniform vec2 viewSize;\n"
500 " in vec2 vertex;\n"
501 " in vec2 tcoord;\n"
502 " out vec2 ftcoord;\n"
503 " out vec2 fpos;\n"
504 "#else\n"
505 " uniform vec2 viewSize;\n"
506 " attribute vec2 vertex;\n"
507 " attribute vec2 tcoord;\n"
508 " varying vec2 ftcoord;\n"
509 " varying vec2 fpos;\n"
510 "#endif\n"
511 "void main(void) {\n"
512 " ftcoord = tcoord;\n"
513 " fpos = vertex;\n"
514 " gl_Position = vec4(2.0*vertex.x/viewSize.x - 1.0, 1.0 - 2.0*vertex.y/viewSize.y, 0, 1);\n"
515 "}\n";
516
517 static const char* fillFragShader =
518 "#ifdef GL_ES\n"
519 "#if defined(GL_FRAGMENT_PRECISION_HIGH) || defined(NANOVG_GL3)\n"
520 " precision highp float;\n"
521 "#else\n"
522 " precision mediump float;\n"
523 "#endif\n"
524 "#endif\n"
525 "#ifdef NANOVG_GL3\n"
526 "#ifdef USE_UNIFORMBUFFER\n"
527 " layout(std140) uniform frag {\n"
528 " mat3 scissorMat;\n"
529 " mat3 paintMat;\n"
530 " vec4 innerCol;\n"
531 " vec4 outerCol;\n"
532 " vec2 scissorExt;\n"
533 " vec2 scissorScale;\n"
534 " vec2 extent;\n"
535 " float radius;\n"
536 " float feather;\n"
537 " float strokeMult;\n"
538 " float strokeThr;\n"
539 " int texType;\n"
540 " int type;\n"
541 " };\n"
542 "#else\n" // NANOVG_GL3 && !USE_UNIFORMBUFFER
543 " uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
544 "#endif\n"
545 " uniform sampler2D tex;\n"
546 " in vec2 ftcoord;\n"
547 " in vec2 fpos;\n"
548 " out vec4 outColor;\n"
549 "#else\n" // !NANOVG_GL3
550 " uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
551 " uniform sampler2D tex;\n"
552 " varying vec2 ftcoord;\n"
553 " varying vec2 fpos;\n"
554 "#endif\n"
555 "#ifndef USE_UNIFORMBUFFER\n"
556 " #define scissorMat mat3(frag[0].xyz, frag[1].xyz, frag[2].xyz)\n"
557 " #define paintMat mat3(frag[3].xyz, frag[4].xyz, frag[5].xyz)\n"
558 " #define innerCol frag[6]\n"
559 " #define outerCol frag[7]\n"
560 " #define scissorExt frag[8].xy\n"
561 " #define scissorScale frag[8].zw\n"
562 " #define extent frag[9].xy\n"
563 " #define radius frag[9].z\n"
564 " #define feather frag[9].w\n"
565 " #define strokeMult frag[10].x\n"
566 " #define strokeThr frag[10].y\n"
567 " #define texType int(frag[10].z)\n"
568 " #define type int(frag[10].w)\n"
569 "#endif\n"
570 "\n"
571 "float sdroundrect(vec2 pt, vec2 ext, float rad) {\n"
572 " vec2 ext2 = ext - vec2(rad,rad);\n"
573 " vec2 d = abs(pt) - ext2;\n"
574 " return min(max(d.x,d.y),0.0) + length(max(d,0.0)) - rad;\n"
575 "}\n"
576 "\n"
577 "// Scissoring\n"
578 "float scissorMask(vec2 p) {\n"
579 " vec2 sc = (abs((scissorMat * vec3(p,1.0)).xy) - scissorExt);\n"
580 " sc = vec2(0.5,0.5) - sc * scissorScale;\n"
581 " return clamp(sc.x,0.0,1.0) * clamp(sc.y,0.0,1.0);\n"
582 "}\n"
583 "#ifdef EDGE_AA\n"
584 "// Stroke - from [0..1] to clipped pyramid, where the slope is 1px.\n"
585 "float strokeMask() {\n"
586 " return min(1.0, (1.0-abs(ftcoord.x*2.0-1.0))*strokeMult) * min(1.0, ftcoord.y);\n"
587 "}\n"
588 "#endif\n"
589 "\n"
590 "void main(void) {\n"
591 " vec4 result;\n"
592 " float scissor = scissorMask(fpos);\n"
593 "#ifdef EDGE_AA\n"
594 " float strokeAlpha = strokeMask();\n"
595 "#else\n"
596 " float strokeAlpha = 1.0;\n"
597 "#endif\n"
598 " if (type == 0) { // Gradient\n"
599 " // Calculate gradient color using box gradient\n"
600 " vec2 pt = (paintMat * vec3(fpos,1.0)).xy;\n"
601 " float d = clamp((sdroundrect(pt, extent, radius) + feather*0.5) / feather, 0.0, 1.0);\n"
602 " vec4 color = mix(innerCol,outerCol,d);\n"
603 " // Combine alpha\n"
604 " color *= strokeAlpha * scissor;\n"
605 " result = color;\n"
606 " } else if (type == 1) { // Image\n"
607 " // Calculate color fron texture\n"
608 " vec2 pt = (paintMat * vec3(fpos,1.0)).xy / extent;\n"
609 "#ifdef NANOVG_GL3\n"
610 " vec4 color = texture(tex, pt);\n"
611 "#else\n"
612 " vec4 color = texture2D(tex, pt);\n"
613 "#endif\n"
614 " if (texType == 1) color = vec4(color.xyz*color.w,color.w);"
615 " if (texType == 2) color = vec4(color.x);"
616 " // Apply color tint and alpha.\n"
617 " color *= innerCol;\n"
618 " // Combine alpha\n"
619 " color *= strokeAlpha * scissor;\n"
620 " result = color;\n"
621 " } else if (type == 2) { // Stencil fill\n"
622 " result = vec4(1,1,1,1);\n"
623 " } else if (type == 3) { // Textured tris\n"
624 "#ifdef NANOVG_GL3\n"
625 " vec4 color = texture(tex, ftcoord);\n"
626 "#else\n"
627 " vec4 color = texture2D(tex, ftcoord);\n"
628 "#endif\n"
629 " if (texType == 1) color = vec4(color.xyz*color.w,color.w);"
630 " if (texType == 2) color = vec4(color.x);"
631 " color *= scissor;\n"
632 " result = color * innerCol;\n"
633 " }\n"
634 "#ifdef EDGE_AA\n"
635 " if (strokeAlpha < strokeThr) discard;\n"
636 "#endif\n"
637 "#ifdef NANOVG_GL3\n"
638 " outColor = result;\n"
639 "#else\n"
640 " gl_FragColor = result;\n"
641 "#endif\n"
642 "}\n";
643
644 glnvg__checkError(gl, "init");
645
646 if (gl->flags & NVG_ANTIALIAS) {
647 if (glnvg__createShader(&gl->shader, "shader", shaderHeader, "#define EDGE_AA 1\n", fillVertShader, fillFragShader) == 0)
648 return 0;
649 } else {
650 if (glnvg__createShader(&gl->shader, "shader", shaderHeader, NULL, fillVertShader, fillFragShader) == 0)
651 return 0;
652 }
653
654 glnvg__checkError(gl, "uniform locations");
655 glnvg__getUniforms(&gl->shader);
656
657 // Create dynamic vertex array
658 #if defined NANOVG_GL3
659 glGenVertexArrays(1, &gl->vertArr);
660 #endif
661 glGenBuffers(1, &gl->vertBuf);
662
663 #if NANOVG_GL_USE_UNIFORMBUFFER
664 // Create UBOs
665 glUniformBlockBinding(gl->shader.prog, gl->shader.loc[GLNVG_LOC_FRAG], GLNVG_FRAG_BINDING);
666 glGenBuffers(1, &gl->fragBuf);
667 glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &align);
668 #endif
669 gl->fragSize = sizeof(GLNVGfragUniforms) + align - sizeof(GLNVGfragUniforms) % align;
670
671 glnvg__checkError(gl, "create done");
672
673 glFinish();
674
675 return 1;
676 }
677
glnvg__renderCreateTexture(void * uptr,int type,int w,int h,int imageFlags,const unsigned char * data)678 static int glnvg__renderCreateTexture(void* uptr, int type, int w, int h, int imageFlags, const unsigned char* data)
679 {
680 GLNVGcontext* gl = (GLNVGcontext*)uptr;
681 GLNVGtexture* tex = glnvg__allocTexture(gl);
682
683 if (tex == NULL) return 0;
684
685 #ifdef NANOVG_GLES2
686 // Check for non-power of 2.
687 if (glnvg__nearestPow2(w) != (unsigned int)w || glnvg__nearestPow2(h) != (unsigned int)h) {
688 // No repeat
689 if ((imageFlags & NVG_IMAGE_REPEATX) != 0 || (imageFlags & NVG_IMAGE_REPEATY) != 0) {
690 printf("Repeat X/Y is not supported for non power-of-two textures (%d x %d)\n", w, h);
691 imageFlags &= ~(NVG_IMAGE_REPEATX | NVG_IMAGE_REPEATY);
692 }
693 // No mips.
694 if (imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
695 printf("Mip-maps is not support for non power-of-two textures (%d x %d)\n", w, h);
696 imageFlags &= ~NVG_IMAGE_GENERATE_MIPMAPS;
697 }
698 }
699 #endif
700
701 glGenTextures(1, &tex->tex);
702 tex->width = w;
703 tex->height = h;
704 tex->type = type;
705 tex->flags = imageFlags;
706 glnvg__bindTexture(gl, tex->tex);
707
708 glPixelStorei(GL_UNPACK_ALIGNMENT,1);
709 #ifndef NANOVG_GLES2
710 glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width);
711 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
712 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
713 #endif
714
715 #if defined (NANOVG_GL2)
716 // GL 1.4 and later has support for generating mipmaps using a tex parameter.
717 if (imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
718 glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
719 }
720 #endif
721
722 if (type == NVG_TEXTURE_RGBA)
723 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
724 else
725 #if defined(NANOVG_GLES2)
726 glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, w, h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
727 #elif defined(NANOVG_GLES3)
728 glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, data);
729 #else
730 glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, w, h, 0, GL_RED, GL_UNSIGNED_BYTE, data);
731 #endif
732
733 if (imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
734 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
735 } else {
736 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
737 }
738 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
739
740 if (imageFlags & NVG_IMAGE_REPEATX)
741 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
742 else
743 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
744
745 if (imageFlags & NVG_IMAGE_REPEATY)
746 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
747 else
748 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
749
750 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
751 #ifndef NANOVG_GLES2
752 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
753 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
754 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
755 #endif
756
757 // The new way to build mipmaps on GLES and GL3
758 #if !defined(NANOVG_GL2)
759 if (imageFlags & NVG_IMAGE_GENERATE_MIPMAPS) {
760 glGenerateMipmap(GL_TEXTURE_2D);
761 }
762 #endif
763
764 glnvg__checkError(gl, "create tex");
765 glnvg__bindTexture(gl, 0);
766
767 return tex->id;
768 }
769
770
glnvg__renderDeleteTexture(void * uptr,int image)771 static int glnvg__renderDeleteTexture(void* uptr, int image)
772 {
773 GLNVGcontext* gl = (GLNVGcontext*)uptr;
774 return glnvg__deleteTexture(gl, image);
775 }
776
glnvg__renderUpdateTexture(void * uptr,int image,int x,int y,int w,int h,const unsigned char * data)777 static int glnvg__renderUpdateTexture(void* uptr, int image, int x, int y, int w, int h, const unsigned char* data)
778 {
779 GLNVGcontext* gl = (GLNVGcontext*)uptr;
780 GLNVGtexture* tex = glnvg__findTexture(gl, image);
781
782 if (tex == NULL) return 0;
783 glnvg__bindTexture(gl, tex->tex);
784
785 glPixelStorei(GL_UNPACK_ALIGNMENT,1);
786
787 #ifndef NANOVG_GLES2
788 glPixelStorei(GL_UNPACK_ROW_LENGTH, tex->width);
789 glPixelStorei(GL_UNPACK_SKIP_PIXELS, x);
790 glPixelStorei(GL_UNPACK_SKIP_ROWS, y);
791 #else
792 // No support for all of skip, need to update a whole row at a time.
793 if (tex->type == NVG_TEXTURE_RGBA)
794 data += y*tex->width*4;
795 else
796 data += y*tex->width;
797 x = 0;
798 w = tex->width;
799 #endif
800
801 if (tex->type == NVG_TEXTURE_RGBA)
802 glTexSubImage2D(GL_TEXTURE_2D, 0, x,y, w,h, GL_RGBA, GL_UNSIGNED_BYTE, data);
803 else
804 #ifdef NANOVG_GLES2
805 glTexSubImage2D(GL_TEXTURE_2D, 0, x,y, w,h, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
806 #else
807 glTexSubImage2D(GL_TEXTURE_2D, 0, x,y, w,h, GL_RED, GL_UNSIGNED_BYTE, data);
808 #endif
809
810 glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
811 #ifndef NANOVG_GLES2
812 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
813 glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
814 glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
815 #endif
816
817 glnvg__bindTexture(gl, 0);
818
819 return 1;
820 }
821
glnvg__renderGetTextureSize(void * uptr,int image,int * w,int * h)822 static int glnvg__renderGetTextureSize(void* uptr, int image, int* w, int* h)
823 {
824 GLNVGcontext* gl = (GLNVGcontext*)uptr;
825 GLNVGtexture* tex = glnvg__findTexture(gl, image);
826 if (tex == NULL) return 0;
827 *w = tex->width;
828 *h = tex->height;
829 return 1;
830 }
831
glnvg__xformToMat3x4(float * m3,float * t)832 static void glnvg__xformToMat3x4(float* m3, float* t)
833 {
834 m3[0] = t[0];
835 m3[1] = t[1];
836 m3[2] = 0.0f;
837 m3[3] = 0.0f;
838 m3[4] = t[2];
839 m3[5] = t[3];
840 m3[6] = 0.0f;
841 m3[7] = 0.0f;
842 m3[8] = t[4];
843 m3[9] = t[5];
844 m3[10] = 1.0f;
845 m3[11] = 0.0f;
846 }
847
glnvg__premulColor(NVGcolor c)848 static NVGcolor glnvg__premulColor(NVGcolor c)
849 {
850 c.r *= c.a;
851 c.g *= c.a;
852 c.b *= c.a;
853 return c;
854 }
855
glnvg__convertPaint(GLNVGcontext * gl,GLNVGfragUniforms * frag,NVGpaint * paint,NVGscissor * scissor,float width,float fringe,float strokeThr)856 static int glnvg__convertPaint(GLNVGcontext* gl, GLNVGfragUniforms* frag, NVGpaint* paint,
857 NVGscissor* scissor, float width, float fringe, float strokeThr)
858 {
859 GLNVGtexture* tex = NULL;
860 float invxform[6];
861
862 memset(frag, 0, sizeof(*frag));
863
864 frag->innerCol = glnvg__premulColor(paint->innerColor);
865 frag->outerCol = glnvg__premulColor(paint->outerColor);
866
867 if (scissor->extent[0] < -0.5f || scissor->extent[1] < -0.5f) {
868 memset(frag->scissorMat, 0, sizeof(frag->scissorMat));
869 frag->scissorExt[0] = 1.0f;
870 frag->scissorExt[1] = 1.0f;
871 frag->scissorScale[0] = 1.0f;
872 frag->scissorScale[1] = 1.0f;
873 } else {
874 nvgTransformInverse(invxform, scissor->xform);
875 glnvg__xformToMat3x4(frag->scissorMat, invxform);
876 frag->scissorExt[0] = scissor->extent[0];
877 frag->scissorExt[1] = scissor->extent[1];
878 frag->scissorScale[0] = sqrtf(scissor->xform[0]*scissor->xform[0] + scissor->xform[2]*scissor->xform[2]) / fringe;
879 frag->scissorScale[1] = sqrtf(scissor->xform[1]*scissor->xform[1] + scissor->xform[3]*scissor->xform[3]) / fringe;
880 }
881
882 memcpy(frag->extent, paint->extent, sizeof(frag->extent));
883 frag->strokeMult = (width*0.5f + fringe*0.5f) / fringe;
884 frag->strokeThr = strokeThr;
885
886 if (paint->image != 0) {
887 tex = glnvg__findTexture(gl, paint->image);
888 if (tex == NULL) return 0;
889 if ((tex->flags & NVG_IMAGE_FLIPY) != 0) {
890 float flipped[6];
891 nvgTransformScale(flipped, 1.0f, -1.0f);
892 nvgTransformMultiply(flipped, paint->xform);
893 nvgTransformInverse(invxform, flipped);
894 } else {
895 nvgTransformInverse(invxform, paint->xform);
896 }
897 frag->type = NSVG_SHADER_FILLIMG;
898
899 if (tex->type == NVG_TEXTURE_RGBA)
900 frag->texType = (tex->flags & NVG_IMAGE_PREMULTIPLIED) ? 0 : 1;
901 else
902 frag->texType = 2;
903 // printf("frag->texType = %d\n", frag->texType);
904 } else {
905 frag->type = NSVG_SHADER_FILLGRAD;
906 frag->radius = paint->radius;
907 frag->feather = paint->feather;
908 nvgTransformInverse(invxform, paint->xform);
909 }
910
911 glnvg__xformToMat3x4(frag->paintMat, invxform);
912
913 return 1;
914 }
915
916 static GLNVGfragUniforms* nvg__fragUniformPtr(GLNVGcontext* gl, int i);
917
glnvg__setUniforms(GLNVGcontext * gl,int uniformOffset,int image)918 static void glnvg__setUniforms(GLNVGcontext* gl, int uniformOffset, int image)
919 {
920 #if NANOVG_GL_USE_UNIFORMBUFFER
921 glBindBufferRange(GL_UNIFORM_BUFFER, GLNVG_FRAG_BINDING, gl->fragBuf, uniformOffset, sizeof(GLNVGfragUniforms));
922 #else
923 GLNVGfragUniforms* frag = nvg__fragUniformPtr(gl, uniformOffset);
924 glUniform4fv(gl->shader.loc[GLNVG_LOC_FRAG], NANOVG_GL_UNIFORMARRAY_SIZE, &(frag->uniformArray[0][0]));
925 #endif
926
927 if (image != 0) {
928 GLNVGtexture* tex = glnvg__findTexture(gl, image);
929 glnvg__bindTexture(gl, tex != NULL ? tex->tex : 0);
930 glnvg__checkError(gl, "tex paint tex");
931 } else {
932 glnvg__bindTexture(gl, 0);
933 }
934 }
935
glnvg__renderViewport(void * uptr,int width,int height)936 static void glnvg__renderViewport(void* uptr, int width, int height)
937 {
938 GLNVGcontext* gl = (GLNVGcontext*)uptr;
939 gl->view[0] = (float)width;
940 gl->view[1] = (float)height;
941 }
942
glnvg__fill(GLNVGcontext * gl,GLNVGcall * call)943 static void glnvg__fill(GLNVGcontext* gl, GLNVGcall* call)
944 {
945 GLNVGpath* paths = &gl->paths[call->pathOffset];
946 int i, npaths = call->pathCount;
947
948 // Draw shapes
949 glEnable(GL_STENCIL_TEST);
950 glnvg__stencilMask(gl, 0xff);
951 glnvg__stencilFunc(gl, GL_ALWAYS, 0, 0xff);
952 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
953
954 // set bindpoint for solid loc
955 glnvg__setUniforms(gl, call->uniformOffset, 0);
956 glnvg__checkError(gl, "fill simple");
957
958 glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP);
959 glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP);
960 glDisable(GL_CULL_FACE);
961 for (i = 0; i < npaths; i++)
962 glDrawArrays(GL_TRIANGLE_FAN, paths[i].fillOffset, paths[i].fillCount);
963 glEnable(GL_CULL_FACE);
964
965 // Draw anti-aliased pixels
966 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
967
968 glnvg__setUniforms(gl, call->uniformOffset + gl->fragSize, call->image);
969 glnvg__checkError(gl, "fill fill");
970
971 if (gl->flags & NVG_ANTIALIAS) {
972 glnvg__stencilFunc(gl, GL_EQUAL, 0x00, 0xff);
973 glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
974 // Draw fringes
975 for (i = 0; i < npaths; i++)
976 glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
977 }
978
979 // Draw fill
980 glnvg__stencilFunc(gl, GL_NOTEQUAL, 0x0, 0xff);
981 glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
982 glDrawArrays(GL_TRIANGLES, call->triangleOffset, call->triangleCount);
983
984 glDisable(GL_STENCIL_TEST);
985 }
986
glnvg__convexFill(GLNVGcontext * gl,GLNVGcall * call)987 static void glnvg__convexFill(GLNVGcontext* gl, GLNVGcall* call)
988 {
989 GLNVGpath* paths = &gl->paths[call->pathOffset];
990 int i, npaths = call->pathCount;
991
992 glnvg__setUniforms(gl, call->uniformOffset, call->image);
993 glnvg__checkError(gl, "convex fill");
994
995 for (i = 0; i < npaths; i++)
996 glDrawArrays(GL_TRIANGLE_FAN, paths[i].fillOffset, paths[i].fillCount);
997 if (gl->flags & NVG_ANTIALIAS) {
998 // Draw fringes
999 for (i = 0; i < npaths; i++)
1000 glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
1001 }
1002 }
1003
glnvg__stroke(GLNVGcontext * gl,GLNVGcall * call)1004 static void glnvg__stroke(GLNVGcontext* gl, GLNVGcall* call)
1005 {
1006 GLNVGpath* paths = &gl->paths[call->pathOffset];
1007 int npaths = call->pathCount, i;
1008
1009 if (gl->flags & NVG_STENCIL_STROKES) {
1010
1011 glEnable(GL_STENCIL_TEST);
1012 glnvg__stencilMask(gl, 0xff);
1013
1014 // Fill the stroke base without overlap
1015 glnvg__stencilFunc(gl, GL_EQUAL, 0x0, 0xff);
1016 glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
1017 glnvg__setUniforms(gl, call->uniformOffset + gl->fragSize, call->image);
1018 glnvg__checkError(gl, "stroke fill 0");
1019 for (i = 0; i < npaths; i++)
1020 glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
1021
1022 // Draw anti-aliased pixels.
1023 glnvg__setUniforms(gl, call->uniformOffset, call->image);
1024 glnvg__stencilFunc(gl, GL_EQUAL, 0x00, 0xff);
1025 glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
1026 for (i = 0; i < npaths; i++)
1027 glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
1028
1029 // Clear stencil buffer.
1030 glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1031 glnvg__stencilFunc(gl, GL_ALWAYS, 0x0, 0xff);
1032 glStencilOp(GL_ZERO, GL_ZERO, GL_ZERO);
1033 glnvg__checkError(gl, "stroke fill 1");
1034 for (i = 0; i < npaths; i++)
1035 glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
1036 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1037
1038 glDisable(GL_STENCIL_TEST);
1039
1040 // glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, strokeWidth, fringe, 1.0f - 0.5f/255.0f);
1041
1042 } else {
1043 glnvg__setUniforms(gl, call->uniformOffset, call->image);
1044 glnvg__checkError(gl, "stroke fill");
1045 // Draw Strokes
1046 for (i = 0; i < npaths; i++)
1047 glDrawArrays(GL_TRIANGLE_STRIP, paths[i].strokeOffset, paths[i].strokeCount);
1048 }
1049 }
1050
glnvg__triangles(GLNVGcontext * gl,GLNVGcall * call)1051 static void glnvg__triangles(GLNVGcontext* gl, GLNVGcall* call)
1052 {
1053 glnvg__setUniforms(gl, call->uniformOffset, call->image);
1054 glnvg__checkError(gl, "triangles fill");
1055
1056 glDrawArrays(GL_TRIANGLES, call->triangleOffset, call->triangleCount);
1057 }
1058
glnvg__renderCancel(void * uptr)1059 static void glnvg__renderCancel(void* uptr) {
1060 GLNVGcontext* gl = (GLNVGcontext*)uptr;
1061 gl->nverts = 0;
1062 gl->npaths = 0;
1063 gl->ncalls = 0;
1064 gl->nuniforms = 0;
1065 }
1066
glnvg__renderFlush(void * uptr)1067 static void glnvg__renderFlush(void* uptr)
1068 {
1069 GLNVGcontext* gl = (GLNVGcontext*)uptr;
1070 int i;
1071
1072 if (gl->ncalls > 0) {
1073
1074 // Setup require GL state.
1075 glUseProgram(gl->shader.prog);
1076
1077 glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1078 glEnable(GL_CULL_FACE);
1079 glCullFace(GL_BACK);
1080 glFrontFace(GL_CCW);
1081 glEnable(GL_BLEND);
1082 glDisable(GL_DEPTH_TEST);
1083 glDisable(GL_SCISSOR_TEST);
1084 glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1085 glStencilMask(0xffffffff);
1086 glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
1087 glStencilFunc(GL_ALWAYS, 0, 0xffffffff);
1088 glActiveTexture(GL_TEXTURE0);
1089 glBindTexture(GL_TEXTURE_2D, 0);
1090 #if NANOVG_GL_USE_STATE_FILTER
1091 gl->boundTexture = 0;
1092 gl->stencilMask = 0xffffffff;
1093 gl->stencilFunc = GL_ALWAYS;
1094 gl->stencilFuncRef = 0;
1095 gl->stencilFuncMask = 0xffffffff;
1096 #endif
1097
1098 #if NANOVG_GL_USE_UNIFORMBUFFER
1099 // Upload ubo for frag shaders
1100 glBindBuffer(GL_UNIFORM_BUFFER, gl->fragBuf);
1101 glBufferData(GL_UNIFORM_BUFFER, gl->nuniforms * gl->fragSize, gl->uniforms, GL_STREAM_DRAW);
1102 #endif
1103
1104 // Upload vertex data
1105 #if defined NANOVG_GL3
1106 glBindVertexArray(gl->vertArr);
1107 #endif
1108 glBindBuffer(GL_ARRAY_BUFFER, gl->vertBuf);
1109 glBufferData(GL_ARRAY_BUFFER, gl->nverts * sizeof(NVGvertex), gl->verts, GL_STREAM_DRAW);
1110 glEnableVertexAttribArray(0);
1111 glEnableVertexAttribArray(1);
1112 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(NVGvertex), (const GLvoid*)(size_t)0);
1113 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(NVGvertex), (const GLvoid*)(0 + 2*sizeof(float)));
1114
1115 // Set view and texture just once per frame.
1116 glUniform1i(gl->shader.loc[GLNVG_LOC_TEX], 0);
1117 glUniform2fv(gl->shader.loc[GLNVG_LOC_VIEWSIZE], 1, gl->view);
1118
1119 #if NANOVG_GL_USE_UNIFORMBUFFER
1120 glBindBuffer(GL_UNIFORM_BUFFER, gl->fragBuf);
1121 #endif
1122
1123 for (i = 0; i < gl->ncalls; i++) {
1124 GLNVGcall* call = &gl->calls[i];
1125 if (call->type == GLNVG_FILL)
1126 glnvg__fill(gl, call);
1127 else if (call->type == GLNVG_CONVEXFILL)
1128 glnvg__convexFill(gl, call);
1129 else if (call->type == GLNVG_STROKE)
1130 glnvg__stroke(gl, call);
1131 else if (call->type == GLNVG_TRIANGLES)
1132 glnvg__triangles(gl, call);
1133 }
1134
1135 glDisableVertexAttribArray(0);
1136 glDisableVertexAttribArray(1);
1137 #if defined NANOVG_GL3
1138 glBindVertexArray(0);
1139 #endif
1140 glDisable(GL_CULL_FACE);
1141 glBindBuffer(GL_ARRAY_BUFFER, 0);
1142 glUseProgram(0);
1143 glnvg__bindTexture(gl, 0);
1144 }
1145
1146 // Reset calls
1147 gl->nverts = 0;
1148 gl->npaths = 0;
1149 gl->ncalls = 0;
1150 gl->nuniforms = 0;
1151 }
1152
glnvg__maxVertCount(const NVGpath * paths,int npaths)1153 static int glnvg__maxVertCount(const NVGpath* paths, int npaths)
1154 {
1155 int i, count = 0;
1156 for (i = 0; i < npaths; i++) {
1157 count += paths[i].nfill;
1158 count += paths[i].nstroke;
1159 }
1160 return count;
1161 }
1162
glnvg__allocCall(GLNVGcontext * gl)1163 static GLNVGcall* glnvg__allocCall(GLNVGcontext* gl)
1164 {
1165 GLNVGcall* ret = NULL;
1166 if (gl->ncalls+1 > gl->ccalls) {
1167 GLNVGcall* calls;
1168 int ccalls = glnvg__maxi(gl->ncalls+1, 128) + gl->ccalls/2; // 1.5x Overallocate
1169 calls = (GLNVGcall*)realloc(gl->calls, sizeof(GLNVGcall) * ccalls);
1170 if (calls == NULL) return NULL;
1171 gl->calls = calls;
1172 gl->ccalls = ccalls;
1173 }
1174 ret = &gl->calls[gl->ncalls++];
1175 memset(ret, 0, sizeof(GLNVGcall));
1176 return ret;
1177 }
1178
glnvg__allocPaths(GLNVGcontext * gl,int n)1179 static int glnvg__allocPaths(GLNVGcontext* gl, int n)
1180 {
1181 int ret = 0;
1182 if (gl->npaths+n > gl->cpaths) {
1183 GLNVGpath* paths;
1184 int cpaths = glnvg__maxi(gl->npaths + n, 128) + gl->cpaths/2; // 1.5x Overallocate
1185 paths = (GLNVGpath*)realloc(gl->paths, sizeof(GLNVGpath) * cpaths);
1186 if (paths == NULL) return -1;
1187 gl->paths = paths;
1188 gl->cpaths = cpaths;
1189 }
1190 ret = gl->npaths;
1191 gl->npaths += n;
1192 return ret;
1193 }
1194
glnvg__allocVerts(GLNVGcontext * gl,int n)1195 static int glnvg__allocVerts(GLNVGcontext* gl, int n)
1196 {
1197 int ret = 0;
1198 if (gl->nverts+n > gl->cverts) {
1199 NVGvertex* verts;
1200 int cverts = glnvg__maxi(gl->nverts + n, 4096) + gl->cverts/2; // 1.5x Overallocate
1201 verts = (NVGvertex*)realloc(gl->verts, sizeof(NVGvertex) * cverts);
1202 if (verts == NULL) return -1;
1203 gl->verts = verts;
1204 gl->cverts = cverts;
1205 }
1206 ret = gl->nverts;
1207 gl->nverts += n;
1208 return ret;
1209 }
1210
glnvg__allocFragUniforms(GLNVGcontext * gl,int n)1211 static int glnvg__allocFragUniforms(GLNVGcontext* gl, int n)
1212 {
1213 int ret = 0, structSize = gl->fragSize;
1214 if (gl->nuniforms+n > gl->cuniforms) {
1215 unsigned char* uniforms;
1216 int cuniforms = glnvg__maxi(gl->nuniforms+n, 128) + gl->cuniforms/2; // 1.5x Overallocate
1217 uniforms = (unsigned char*)realloc(gl->uniforms, structSize * cuniforms);
1218 if (uniforms == NULL) return -1;
1219 gl->uniforms = uniforms;
1220 gl->cuniforms = cuniforms;
1221 }
1222 ret = gl->nuniforms * structSize;
1223 gl->nuniforms += n;
1224 return ret;
1225 }
1226
nvg__fragUniformPtr(GLNVGcontext * gl,int i)1227 static GLNVGfragUniforms* nvg__fragUniformPtr(GLNVGcontext* gl, int i)
1228 {
1229 return (GLNVGfragUniforms*)&gl->uniforms[i];
1230 }
1231
glnvg__vset(NVGvertex * vtx,float x,float y,float u,float v)1232 static void glnvg__vset(NVGvertex* vtx, float x, float y, float u, float v)
1233 {
1234 vtx->x = x;
1235 vtx->y = y;
1236 vtx->u = u;
1237 vtx->v = v;
1238 }
1239
glnvg__renderFill(void * uptr,NVGpaint * paint,NVGscissor * scissor,float fringe,const float * bounds,const NVGpath * paths,int npaths)1240 static void glnvg__renderFill(void* uptr, NVGpaint* paint, NVGscissor* scissor, float fringe,
1241 const float* bounds, const NVGpath* paths, int npaths)
1242 {
1243 GLNVGcontext* gl = (GLNVGcontext*)uptr;
1244 GLNVGcall* call = glnvg__allocCall(gl);
1245 NVGvertex* quad;
1246 GLNVGfragUniforms* frag;
1247 int i, maxverts, offset;
1248
1249 if (call == NULL) return;
1250
1251 call->type = GLNVG_FILL;
1252 call->pathOffset = glnvg__allocPaths(gl, npaths);
1253 if (call->pathOffset == -1) goto error;
1254 call->pathCount = npaths;
1255 call->image = paint->image;
1256
1257 if (npaths == 1 && paths[0].convex)
1258 call->type = GLNVG_CONVEXFILL;
1259
1260 // Allocate vertices for all the paths.
1261 maxverts = glnvg__maxVertCount(paths, npaths) + 6;
1262 offset = glnvg__allocVerts(gl, maxverts);
1263 if (offset == -1) goto error;
1264
1265 for (i = 0; i < npaths; i++) {
1266 GLNVGpath* copy = &gl->paths[call->pathOffset + i];
1267 const NVGpath* path = &paths[i];
1268 memset(copy, 0, sizeof(GLNVGpath));
1269 if (path->nfill > 0) {
1270 copy->fillOffset = offset;
1271 copy->fillCount = path->nfill;
1272 memcpy(&gl->verts[offset], path->fill, sizeof(NVGvertex) * path->nfill);
1273 offset += path->nfill;
1274 }
1275 if (path->nstroke > 0) {
1276 copy->strokeOffset = offset;
1277 copy->strokeCount = path->nstroke;
1278 memcpy(&gl->verts[offset], path->stroke, sizeof(NVGvertex) * path->nstroke);
1279 offset += path->nstroke;
1280 }
1281 }
1282
1283 // Quad
1284 call->triangleOffset = offset;
1285 call->triangleCount = 6;
1286 quad = &gl->verts[call->triangleOffset];
1287 glnvg__vset(&quad[0], bounds[0], bounds[3], 0.5f, 1.0f);
1288 glnvg__vset(&quad[1], bounds[2], bounds[3], 0.5f, 1.0f);
1289 glnvg__vset(&quad[2], bounds[2], bounds[1], 0.5f, 1.0f);
1290
1291 glnvg__vset(&quad[3], bounds[0], bounds[3], 0.5f, 1.0f);
1292 glnvg__vset(&quad[4], bounds[2], bounds[1], 0.5f, 1.0f);
1293 glnvg__vset(&quad[5], bounds[0], bounds[1], 0.5f, 1.0f);
1294
1295 // Setup uniforms for draw calls
1296 if (call->type == GLNVG_FILL) {
1297 call->uniformOffset = glnvg__allocFragUniforms(gl, 2);
1298 if (call->uniformOffset == -1) goto error;
1299 // Simple shader for stencil
1300 frag = nvg__fragUniformPtr(gl, call->uniformOffset);
1301 memset(frag, 0, sizeof(*frag));
1302 frag->strokeThr = -1.0f;
1303 frag->type = NSVG_SHADER_SIMPLE;
1304 // Fill shader
1305 glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, fringe, fringe, -1.0f);
1306 } else {
1307 call->uniformOffset = glnvg__allocFragUniforms(gl, 1);
1308 if (call->uniformOffset == -1) goto error;
1309 // Fill shader
1310 glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, fringe, fringe, -1.0f);
1311 }
1312
1313 return;
1314
1315 error:
1316 // We get here if call alloc was ok, but something else is not.
1317 // Roll back the last call to prevent drawing it.
1318 if (gl->ncalls > 0) gl->ncalls--;
1319 }
1320
glnvg__renderStroke(void * uptr,NVGpaint * paint,NVGscissor * scissor,float fringe,float strokeWidth,const NVGpath * paths,int npaths)1321 static void glnvg__renderStroke(void* uptr, NVGpaint* paint, NVGscissor* scissor, float fringe,
1322 float strokeWidth, const NVGpath* paths, int npaths)
1323 {
1324 GLNVGcontext* gl = (GLNVGcontext*)uptr;
1325 GLNVGcall* call = glnvg__allocCall(gl);
1326 int i, maxverts, offset;
1327
1328 if (call == NULL) return;
1329
1330 call->type = GLNVG_STROKE;
1331 call->pathOffset = glnvg__allocPaths(gl, npaths);
1332 if (call->pathOffset == -1) goto error;
1333 call->pathCount = npaths;
1334 call->image = paint->image;
1335
1336 // Allocate vertices for all the paths.
1337 maxverts = glnvg__maxVertCount(paths, npaths);
1338 offset = glnvg__allocVerts(gl, maxverts);
1339 if (offset == -1) goto error;
1340
1341 for (i = 0; i < npaths; i++) {
1342 GLNVGpath* copy = &gl->paths[call->pathOffset + i];
1343 const NVGpath* path = &paths[i];
1344 memset(copy, 0, sizeof(GLNVGpath));
1345 if (path->nstroke) {
1346 copy->strokeOffset = offset;
1347 copy->strokeCount = path->nstroke;
1348 memcpy(&gl->verts[offset], path->stroke, sizeof(NVGvertex) * path->nstroke);
1349 offset += path->nstroke;
1350 }
1351 }
1352
1353 if (gl->flags & NVG_STENCIL_STROKES) {
1354 // Fill shader
1355 call->uniformOffset = glnvg__allocFragUniforms(gl, 2);
1356 if (call->uniformOffset == -1) goto error;
1357
1358 glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, strokeWidth, fringe, -1.0f);
1359 glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset + gl->fragSize), paint, scissor, strokeWidth, fringe, 1.0f - 0.5f/255.0f);
1360
1361 } else {
1362 // Fill shader
1363 call->uniformOffset = glnvg__allocFragUniforms(gl, 1);
1364 if (call->uniformOffset == -1) goto error;
1365 glnvg__convertPaint(gl, nvg__fragUniformPtr(gl, call->uniformOffset), paint, scissor, strokeWidth, fringe, -1.0f);
1366 }
1367
1368 return;
1369
1370 error:
1371 // We get here if call alloc was ok, but something else is not.
1372 // Roll back the last call to prevent drawing it.
1373 if (gl->ncalls > 0) gl->ncalls--;
1374 }
1375
glnvg__renderTriangles(void * uptr,NVGpaint * paint,NVGscissor * scissor,const NVGvertex * verts,int nverts)1376 static void glnvg__renderTriangles(void* uptr, NVGpaint* paint, NVGscissor* scissor,
1377 const NVGvertex* verts, int nverts)
1378 {
1379 GLNVGcontext* gl = (GLNVGcontext*)uptr;
1380 GLNVGcall* call = glnvg__allocCall(gl);
1381 GLNVGfragUniforms* frag;
1382
1383 if (call == NULL) return;
1384
1385 call->type = GLNVG_TRIANGLES;
1386 call->image = paint->image;
1387
1388 // Allocate vertices for all the paths.
1389 call->triangleOffset = glnvg__allocVerts(gl, nverts);
1390 if (call->triangleOffset == -1) goto error;
1391 call->triangleCount = nverts;
1392
1393 memcpy(&gl->verts[call->triangleOffset], verts, sizeof(NVGvertex) * nverts);
1394
1395 // Fill shader
1396 call->uniformOffset = glnvg__allocFragUniforms(gl, 1);
1397 if (call->uniformOffset == -1) goto error;
1398 frag = nvg__fragUniformPtr(gl, call->uniformOffset);
1399 glnvg__convertPaint(gl, frag, paint, scissor, 1.0f, 1.0f, -1.0f);
1400 frag->type = NSVG_SHADER_IMG;
1401
1402 return;
1403
1404 error:
1405 // We get here if call alloc was ok, but something else is not.
1406 // Roll back the last call to prevent drawing it.
1407 if (gl->ncalls > 0) gl->ncalls--;
1408 }
1409
glnvg__renderDelete(void * uptr)1410 static void glnvg__renderDelete(void* uptr)
1411 {
1412 GLNVGcontext* gl = (GLNVGcontext*)uptr;
1413 int i;
1414 if (gl == NULL) return;
1415
1416 glnvg__deleteShader(&gl->shader);
1417
1418 #if NANOVG_GL3
1419 #if NANOVG_GL_USE_UNIFORMBUFFER
1420 if (gl->fragBuf != 0)
1421 glDeleteBuffers(1, &gl->fragBuf);
1422 #endif
1423 if (gl->vertArr != 0)
1424 glDeleteVertexArrays(1, &gl->vertArr);
1425 #endif
1426 if (gl->vertBuf != 0)
1427 glDeleteBuffers(1, &gl->vertBuf);
1428
1429 for (i = 0; i < gl->ntextures; i++) {
1430 if (gl->textures[i].tex != 0 && (gl->textures[i].flags & NVG_IMAGE_NODELETE) == 0)
1431 glDeleteTextures(1, &gl->textures[i].tex);
1432 }
1433 free(gl->textures);
1434
1435 free(gl->paths);
1436 free(gl->verts);
1437 free(gl->uniforms);
1438 free(gl->calls);
1439
1440 free(gl);
1441 }
1442
1443
1444 #if defined NANOVG_GL2
nvgCreateGL2(int flags)1445 NVGcontext* nvgCreateGL2(int flags)
1446 #elif defined NANOVG_GL3
1447 NVGcontext* nvgCreateGL3(int flags)
1448 #elif defined NANOVG_GLES2
1449 NVGcontext* nvgCreateGLES2(int flags)
1450 #elif defined NANOVG_GLES3
1451 NVGcontext* nvgCreateGLES3(int flags)
1452 #endif
1453 {
1454 NVGparams params;
1455 NVGcontext* ctx = NULL;
1456 GLNVGcontext* gl = (GLNVGcontext*)malloc(sizeof(GLNVGcontext));
1457 if (gl == NULL) goto error;
1458 memset(gl, 0, sizeof(GLNVGcontext));
1459
1460 memset(¶ms, 0, sizeof(params));
1461 params.renderCreate = glnvg__renderCreate;
1462 params.renderCreateTexture = glnvg__renderCreateTexture;
1463 params.renderDeleteTexture = glnvg__renderDeleteTexture;
1464 params.renderUpdateTexture = glnvg__renderUpdateTexture;
1465 params.renderGetTextureSize = glnvg__renderGetTextureSize;
1466 params.renderViewport = glnvg__renderViewport;
1467 params.renderCancel = glnvg__renderCancel;
1468 params.renderFlush = glnvg__renderFlush;
1469 params.renderFill = glnvg__renderFill;
1470 params.renderStroke = glnvg__renderStroke;
1471 params.renderTriangles = glnvg__renderTriangles;
1472 params.renderDelete = glnvg__renderDelete;
1473 params.userPtr = gl;
1474 params.edgeAntiAlias = flags & NVG_ANTIALIAS ? 1 : 0;
1475
1476 gl->flags = flags;
1477
1478 ctx = nvgCreateInternal(¶ms);
1479 if (ctx == NULL) goto error;
1480
1481 return ctx;
1482
1483 error:
1484 // 'gl' is freed by nvgDeleteInternal.
1485 if (ctx != NULL) nvgDeleteInternal(ctx);
1486 return NULL;
1487 }
1488
1489 #if defined NANOVG_GL2
nvgDeleteGL2(NVGcontext * ctx)1490 void nvgDeleteGL2(NVGcontext* ctx)
1491 #elif defined NANOVG_GL3
1492 void nvgDeleteGL3(NVGcontext* ctx)
1493 #elif defined NANOVG_GLES2
1494 void nvgDeleteGLES2(NVGcontext* ctx)
1495 #elif defined NANOVG_GLES3
1496 void nvgDeleteGLES3(NVGcontext* ctx)
1497 #endif
1498 {
1499 nvgDeleteInternal(ctx);
1500 }
1501
nvglCreateImageFromHandle(NVGcontext * ctx,GLuint textureId,int w,int h,int imageFlags)1502 int nvglCreateImageFromHandle(NVGcontext* ctx, GLuint textureId, int w, int h, int imageFlags)
1503 {
1504 GLNVGcontext* gl = (GLNVGcontext*)nvgInternalParams(ctx)->userPtr;
1505 GLNVGtexture* tex = glnvg__allocTexture(gl);
1506
1507 if (tex == NULL) return 0;
1508
1509 tex->type = NVG_TEXTURE_RGBA;
1510 tex->tex = textureId;
1511 tex->flags = imageFlags;
1512 tex->width = w;
1513 tex->height = h;
1514
1515 return tex->id;
1516 }
1517
nvglImageHandle(NVGcontext * ctx,int image)1518 GLuint nvglImageHandle(NVGcontext* ctx, int image)
1519 {
1520 GLNVGcontext* gl = (GLNVGcontext*)nvgInternalParams(ctx)->userPtr;
1521 GLNVGtexture* tex = glnvg__findTexture(gl, image);
1522 return tex->tex;
1523 }
1524
1525 #endif /* NANOVG_GL_IMPLEMENTATION */
1526