aboutsummaryrefslogtreecommitdiff
path: root/demo/opengl/imguiRenderGL.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'demo/opengl/imguiRenderGL.cpp')
-rw-r--r--demo/opengl/imguiRenderGL.cpp484
1 files changed, 484 insertions, 0 deletions
diff --git a/demo/opengl/imguiRenderGL.cpp b/demo/opengl/imguiRenderGL.cpp
new file mode 100644
index 0000000..bfb961e
--- /dev/null
+++ b/demo/opengl/imguiRenderGL.cpp
@@ -0,0 +1,484 @@
+//
+// Copyright (c) 2009-2010 Mikko Mononen [email protected]
+//
+// 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.
+//
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include <stdio.h>
+
+#include "../imgui.h"
+
+#include "shader.h"
+
+// Some math headers don't have PI defined.
+static const float PI = 3.14159265f;
+
+void imguifree(void* ptr, void* userptr);
+void* imguimalloc(size_t size, void* userptr);
+
+#define STBTT_malloc(x,y) imguimalloc(x,y)
+#define STBTT_free(x,y) imguifree(x,y)
+#define STB_TRUETYPE_IMPLEMENTATION
+#include "../stb_truetype.h"
+
+void imguifree(void* ptr, void* /*userptr*/)
+{
+ free(ptr);
+}
+
+void* imguimalloc(size_t size, void* /*userptr*/)
+{
+ return malloc(size);
+}
+
+static const unsigned TEMP_COORD_COUNT = 100;
+static float g_tempCoords[TEMP_COORD_COUNT*2];
+static float g_tempNormals[TEMP_COORD_COUNT*2];
+
+static const int CIRCLE_VERTS = 8*4;
+static float g_circleVerts[CIRCLE_VERTS*2];
+
+static stbtt_bakedchar g_cdata[96]; // ASCII 32..126 is 95 glyphs
+static GLuint g_ftex = 0;
+
+inline unsigned int RGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
+{
+ return (r) | (g << 8) | (b << 16) | (a << 24);
+}
+
+static void drawPolygon(const float* coords, unsigned numCoords, float r, unsigned int col)
+{
+ if (numCoords > TEMP_COORD_COUNT) numCoords = TEMP_COORD_COUNT;
+
+ for (unsigned i = 0, j = numCoords-1; i < numCoords; j=i++)
+ {
+ const float* v0 = &coords[j*2];
+ const float* v1 = &coords[i*2];
+ float dx = v1[0] - v0[0];
+ float dy = v1[1] - v0[1];
+ float d = sqrtf(dx*dx+dy*dy);
+ if (d > 0)
+ {
+ d = 1.0f/d;
+ dx *= d;
+ dy *= d;
+ }
+ g_tempNormals[j*2+0] = dy;
+ g_tempNormals[j*2+1] = -dx;
+ }
+
+ for (unsigned i = 0, j = numCoords-1; i < numCoords; j=i++)
+ {
+ float dlx0 = g_tempNormals[j*2+0];
+ float dly0 = g_tempNormals[j*2+1];
+ float dlx1 = g_tempNormals[i*2+0];
+ float dly1 = g_tempNormals[i*2+1];
+ float dmx = (dlx0 + dlx1) * 0.5f;
+ float dmy = (dly0 + dly1) * 0.5f;
+ float dmr2 = dmx*dmx + dmy*dmy;
+ if (dmr2 > 0.000001f)
+ {
+ float scale = 1.0f / dmr2;
+ if (scale > 10.0f) scale = 10.0f;
+ dmx *= scale;
+ dmy *= scale;
+ }
+ g_tempCoords[i*2+0] = coords[i*2+0]+dmx*r;
+ g_tempCoords[i*2+1] = coords[i*2+1]+dmy*r;
+ }
+
+ unsigned int colTrans = RGBA(col&0xff, (col>>8)&0xff, (col>>16)&0xff, 0);
+
+ glBegin(GL_TRIANGLES);
+
+ glColor4ubv((GLubyte*)&col);
+
+ for (unsigned i = 0, j = numCoords-1; i < numCoords; j=i++)
+ {
+ glVertex2fv(&coords[i*2]);
+ glVertex2fv(&coords[j*2]);
+ glColor4ubv((GLubyte*)&colTrans);
+ glVertex2fv(&g_tempCoords[j*2]);
+
+ glVertex2fv(&g_tempCoords[j*2]);
+ glVertex2fv(&g_tempCoords[i*2]);
+
+ glColor4ubv((GLubyte*)&col);
+ glVertex2fv(&coords[i*2]);
+ }
+
+ glColor4ubv((GLubyte*)&col);
+ for (unsigned i = 2; i < numCoords; ++i)
+ {
+ glVertex2fv(&coords[0]);
+ glVertex2fv(&coords[(i-1)*2]);
+ glVertex2fv(&coords[i*2]);
+ }
+
+ glEnd();
+}
+
+static void drawRect(float x, float y, float w, float h, float fth, unsigned int col)
+{
+ float verts[4*2] =
+ {
+ x+0.5f, y+0.5f,
+ x+w-0.5f, y+0.5f,
+ x+w-0.5f, y+h-0.5f,
+ x+0.5f, y+h-0.5f,
+ };
+ drawPolygon(verts, 4, fth, col);
+}
+
+/*
+static void drawEllipse(float x, float y, float w, float h, float fth, unsigned int col)
+{
+ float verts[CIRCLE_VERTS*2];
+ const float* cverts = g_circleVerts;
+ float* v = verts;
+
+ for (int i = 0; i < CIRCLE_VERTS; ++i)
+ {
+ *v++ = x + cverts[i*2]*w;
+ *v++ = y + cverts[i*2+1]*h;
+ }
+
+ drawPolygon(verts, CIRCLE_VERTS, fth, col);
+}
+*/
+
+static void drawRoundedRect(float x, float y, float w, float h, float r, float fth, unsigned int col)
+{
+ const unsigned n = CIRCLE_VERTS/4;
+ float verts[(n+1)*4*2];
+ const float* cverts = g_circleVerts;
+ float* v = verts;
+
+ for (unsigned i = 0; i <= n; ++i)
+ {
+ *v++ = x+w-r + cverts[i*2]*r;
+ *v++ = y+h-r + cverts[i*2+1]*r;
+ }
+
+ for (unsigned i = n; i <= n*2; ++i)
+ {
+ *v++ = x+r + cverts[i*2]*r;
+ *v++ = y+h-r + cverts[i*2+1]*r;
+ }
+
+ for (unsigned i = n*2; i <= n*3; ++i)
+ {
+ *v++ = x+r + cverts[i*2]*r;
+ *v++ = y+r + cverts[i*2+1]*r;
+ }
+
+ for (unsigned i = n*3; i < n*4; ++i)
+ {
+ *v++ = x+w-r + cverts[i*2]*r;
+ *v++ = y+r + cverts[i*2+1]*r;
+ }
+ *v++ = x+w-r + cverts[0]*r;
+ *v++ = y+r + cverts[1]*r;
+
+ drawPolygon(verts, (n+1)*4, fth, col);
+}
+
+
+static void drawLine(float x0, float y0, float x1, float y1, float r, float fth, unsigned int col)
+{
+ float dx = x1-x0;
+ float dy = y1-y0;
+ float d = sqrtf(dx*dx+dy*dy);
+ if (d > 0.0001f)
+ {
+ d = 1.0f/d;
+ dx *= d;
+ dy *= d;
+ }
+ float nx = dy;
+ float ny = -dx;
+ float verts[4*2];
+ r -= fth;
+ r *= 0.5f;
+ if (r < 0.01f) r = 0.01f;
+ dx *= r;
+ dy *= r;
+ nx *= r;
+ ny *= r;
+
+ verts[0] = x0-dx-nx;
+ verts[1] = y0-dy-ny;
+
+ verts[2] = x0-dx+nx;
+ verts[3] = y0-dy+ny;
+
+ verts[4] = x1+dx+nx;
+ verts[5] = y1+dy+ny;
+
+ verts[6] = x1+dx-nx;
+ verts[7] = y1+dy-ny;
+
+ drawPolygon(verts, 4, fth, col);
+}
+
+
+bool imguiRenderGLInit(const char* fontpath)
+{
+ for (int i = 0; i < CIRCLE_VERTS; ++i)
+ {
+ float a = (float)i / (float)CIRCLE_VERTS * PI * 2;
+ g_circleVerts[i * 2 + 0] = cosf(a);
+ g_circleVerts[i * 2 + 1] = sinf(a);
+ }
+
+ // Load font.
+ FILE* fp = fopen(fontpath, "rb");
+ if (!fp) return false;
+ fseek(fp, 0, SEEK_END);
+ int size = ftell(fp);
+ fseek(fp, 0, SEEK_SET);
+
+ unsigned char* ttfBuffer = (unsigned char*)malloc(size);
+ if (!ttfBuffer)
+ {
+ fclose(fp);
+ return false;
+ }
+
+ size_t len = fread(ttfBuffer, 1, size, fp);
+ (void)len;
+
+ fclose(fp);
+ fp = 0;
+
+ unsigned char* bmap = (unsigned char*)malloc(512 * 512);
+ if (!bmap)
+ {
+ free(ttfBuffer);
+ return false;
+ }
+
+ stbtt_BakeFontBitmap(ttfBuffer, 0, 15.0f, bmap, 512, 512, 32, 96, g_cdata);
+
+ // can free ttf_buffer at this point
+ glVerify(glGenTextures(1, &g_ftex));
+ glVerify(glBindTexture(GL_TEXTURE_2D, g_ftex));
+ glVerify(glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512, 512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, bmap));
+ glVerify(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
+ glVerify(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
+
+ free(ttfBuffer);
+ free(bmap);
+
+ return true;
+}
+
+void imguiRenderGLDestroy()
+{
+ if (g_ftex)
+ {
+ glDeleteTextures(1, &g_ftex);
+ g_ftex = 0;
+ }
+}
+
+static void getBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, int char_index,
+ float *xpos, float *ypos, stbtt_aligned_quad *q)
+{
+ stbtt_bakedchar *b = chardata + char_index;
+ int round_x = STBTT_ifloor(*xpos + b->xoff);
+ int round_y = STBTT_ifloor(*ypos - b->yoff);
+
+ q->x0 = (float)round_x;
+ q->y0 = (float)round_y;
+ q->x1 = (float)round_x + b->x1 - b->x0;
+ q->y1 = (float)round_y - b->y1 + b->y0;
+
+ q->s0 = b->x0 / (float)pw;
+ q->t0 = b->y0 / (float)pw;
+ q->s1 = b->x1 / (float)ph;
+ q->t1 = b->y1 / (float)ph;
+
+ *xpos += b->xadvance;
+}
+
+static const float g_tabStops[4] = {150, 210, 270, 330};
+
+static float getTextLength(stbtt_bakedchar *chardata, const char* text)
+{
+ float xpos = 0;
+ float len = 0;
+ while (*text)
+ {
+ int c = (unsigned char)*text;
+ if (c == '\t')
+ {
+ for (int i = 0; i < 4; ++i)
+ {
+ if (xpos < g_tabStops[i])
+ {
+ xpos = g_tabStops[i];
+ break;
+ }
+ }
+ }
+ else if (c >= 32 && c < 128)
+ {
+ stbtt_bakedchar *b = chardata + c-32;
+ int round_x = STBTT_ifloor((xpos + b->xoff) + 0.5);
+ len = round_x + b->x1 - b->x0 + 0.5f;
+ xpos += b->xadvance;
+ }
+ ++text;
+ }
+ return len;
+}
+
+static void drawText(float x, float y, const char *text, int align, unsigned int col)
+{
+ if (!g_ftex) return;
+ if (!text) return;
+
+ if (align == IMGUI_ALIGN_CENTER)
+ x -= getTextLength(g_cdata, text)/2;
+ else if (align == IMGUI_ALIGN_RIGHT)
+ x -= getTextLength(g_cdata, text);
+
+ glColor4ub(col&0xff, (col>>8)&0xff, (col>>16)&0xff, (col>>24)&0xff);
+
+ glEnable(GL_TEXTURE_2D);
+
+ // assume orthographic projection with units = screen pixels, origin at top left
+ glBindTexture(GL_TEXTURE_2D, g_ftex);
+
+ glBegin(GL_TRIANGLES);
+
+ const float ox = x;
+
+ while (*text)
+ {
+ int c = (unsigned char)*text;
+ if (c == '\t')
+ {
+ for (int i = 0; i < 4; ++i)
+ {
+ if (x < g_tabStops[i]+ox)
+ {
+ x = g_tabStops[i]+ox;
+ break;
+ }
+ }
+ }
+ else if (c >= 32 && c < 128)
+ {
+ stbtt_aligned_quad q;
+ getBakedQuad(g_cdata, 512,512, c-32, &x,&y,&q);
+
+ glTexCoord2f(q.s0, q.t0);
+ glVertex2f(q.x0, q.y0);
+ glTexCoord2f(q.s1, q.t1);
+ glVertex2f(q.x1, q.y1);
+ glTexCoord2f(q.s1, q.t0);
+ glVertex2f(q.x1, q.y0);
+
+ glTexCoord2f(q.s0, q.t0);
+ glVertex2f(q.x0, q.y0);
+ glTexCoord2f(q.s0, q.t1);
+ glVertex2f(q.x0, q.y1);
+ glTexCoord2f(q.s1, q.t1);
+ glVertex2f(q.x1, q.y1);
+ }
+ ++text;
+ }
+
+ glEnd();
+ glDisable(GL_TEXTURE_2D);
+}
+
+
+void imguiRenderGLDraw()
+{
+ const imguiGfxCmd* q = imguiGetRenderQueue();
+ int nq = imguiGetRenderQueueSize();
+
+ const float s = 1.0f/8.0f;
+
+ glDisable(GL_SCISSOR_TEST);
+ for (int i = 0; i < nq; ++i)
+ {
+ const imguiGfxCmd& cmd = q[i];
+ if (cmd.type == IMGUI_GFXCMD_RECT)
+ {
+ if (cmd.rect.r == 0)
+ {
+ drawRect((float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f,
+ (float)cmd.rect.w*s-1, (float)cmd.rect.h*s-1,
+ 1.0f, cmd.col);
+ }
+ else
+ {
+ drawRoundedRect((float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f,
+ (float)cmd.rect.w*s-1, (float)cmd.rect.h*s-1,
+ (float)cmd.rect.r*s, 1.0f, cmd.col);
+ }
+ }
+ else if (cmd.type == IMGUI_GFXCMD_LINE)
+ {
+ drawLine(cmd.line.x0*s, cmd.line.y0*s, cmd.line.x1*s, cmd.line.y1*s, cmd.line.r*s, 1.0f, cmd.col);
+ }
+ else if (cmd.type == IMGUI_GFXCMD_TRIANGLE)
+ {
+ if (cmd.flags == 1)
+ {
+ const float verts[3*2] =
+ {
+ (float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f,
+ (float)cmd.rect.x*s+0.5f+(float)cmd.rect.w*s-1, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s/2-0.5f,
+ (float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s-1,
+ };
+ drawPolygon(verts, 3, 1.0f, cmd.col);
+ }
+ if (cmd.flags == 2)
+ {
+ const float verts[3*2] =
+ {
+ (float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s-1,
+ (float)cmd.rect.x*s+0.5f+(float)cmd.rect.w*s/2-0.5f, (float)cmd.rect.y*s+0.5f,
+ (float)cmd.rect.x*s+0.5f+(float)cmd.rect.w*s-1, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s-1,
+ };
+ drawPolygon(verts, 3, 1.0f, cmd.col);
+ }
+ }
+ else if (cmd.type == IMGUI_GFXCMD_TEXT)
+ {
+ drawText(cmd.text.x, cmd.text.y, cmd.text.text, cmd.text.align, cmd.col);
+ }
+ else if (cmd.type == IMGUI_GFXCMD_SCISSOR)
+ {
+ if (cmd.flags)
+ {
+ glEnable(GL_SCISSOR_TEST);
+ glScissor(cmd.rect.x, cmd.rect.y, cmd.rect.w, cmd.rect.h);
+ }
+ else
+ {
+ glDisable(GL_SCISSOR_TEST);
+ }
+ }
+ }
+ glDisable(GL_SCISSOR_TEST);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-11 09:47:21 +0000