Scarfski/recastnavigation
1
0
Fork 0
mirror of https://github.com/recastnavigation/recastnavigation.git synced 2026-06-08 08:13:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed old imgui implementation

Browse Source
This commit is contained in:
Graham Pentheny
2025-07-07 13:38:48 -04:00
parent 03fbd56baa
commit 739cac20d8
4 changed files with 0 additions and 1518 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
RecastDemo/Include/imgui.h
View File

@@ -1,115 +0,0 @@
//
// Copyright (c) 2009-2010 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.
//
#pragma once
enum imguiMouseButton
{
IMGUI_MBUT_LEFT = 0x01,
IMGUI_MBUT_RIGHT = 0x02
};
enum imguiTextAlign
{
IMGUI_ALIGN_LEFT,
IMGUI_ALIGN_CENTER,
IMGUI_ALIGN_RIGHT
};
inline unsigned int imguiRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a = 255)
{
return (r) | (g << 8) | (b << 16) | (a << 24);
}
void imguiBeginFrame(int mx, int my, unsigned char mbut, int scroll);
void imguiEndFrame();
bool imguiBeginScrollArea(const char* name, int x, int y, int w, int h, int* scroll);
void imguiEndScrollArea();
void imguiIndent();
void imguiUnindent();
void imguiSeparator();
void imguiSeparatorLine();
bool imguiButton(const char* text, bool enabled = true);
bool imguiItem(const char* text, bool enabled = true);
bool imguiCheck(const char* text, bool checked, bool enabled = true);
bool imguiCollapse(const char* text, const char* subtext, bool checked, bool enabled = true);
void imguiLabel(const char* text);
void imguiValue(const char* text);
bool imguiSlider(const char* text, float* val, float vmin, float vmax, float vinc, bool enabled = true);
void imguiDrawText(int x, int y, int align, const char* text, unsigned int color);
void imguiDrawLine(float x0, float y0, float x1, float y1, float r, unsigned int color);
void imguiDrawRoundedRect(float x, float y, float w, float h, float r, unsigned int color);
void imguiDrawRect(float x, float y, float w, float h, unsigned int color);
// Pull render interface.
enum imguiGfxCmdType
{
IMGUI_GFXCMD_RECT,
IMGUI_GFXCMD_TRIANGLE,
IMGUI_GFXCMD_LINE,
IMGUI_GFXCMD_TEXT,
IMGUI_GFXCMD_SCISSOR
};
struct imguiGfxRect
{
short x;
short y;
short w;
short h;
short r;
};
struct imguiGfxText
{
short x;
short y;
short align;
const char* text;
};
struct imguiGfxLine
{
short x0;
short y0;
short x1;
short y1;
short r;
};
struct imguiGfxCmd
{
char type;
char flags;
char pad[2];
unsigned int col;
union
{
imguiGfxLine line;
imguiGfxRect rect;
imguiGfxText text;
};
};
const imguiGfxCmd* imguiGetRenderQueue();
int imguiGetRenderQueueSize();

24
RecastDemo/Include/imguiRenderGL.h
View File

@@ -1,24 +0,0 @@
//
// Copyright (c) 2009-2010 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.
//
#pragma once
bool imguiRenderGLInit(const char* fontpath);
void imguiRenderGLDestroy();
void imguiRenderGLDraw();

882
RecastDemo/Source/imgui.cpp
View File

@@ -1,882 +0,0 @@
//
// Copyright (c) 2009-2010 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.
//
#include "imgui.h"
#include <math.h>
#include <stdio.h>
#include <string.h>
#ifdef WIN32
# define snprintf _snprintf
#endif
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static const unsigned TEXT_POOL_SIZE = 50000;
static char g_textPool[TEXT_POOL_SIZE];
static unsigned g_textPoolSize = 0;
static const char* allocText(const char* text)
{
unsigned len = static_cast<unsigned>(strlen(text) + 1);
if (g_textPoolSize + len >= TEXT_POOL_SIZE) { return 0; }
char* dst = &g_textPool[g_textPoolSize];
memcpy(dst, text, len);
g_textPoolSize += len;
return dst;
}
static const unsigned GFXCMD_QUEUE_SIZE = 5000;
static imguiGfxCmd g_gfxCmdQueue[GFXCMD_QUEUE_SIZE];
static unsigned g_gfxCmdQueueSize = 0;
static void resetGfxCmdQueue()
{
g_gfxCmdQueueSize = 0;
g_textPoolSize = 0;
}
static void addGfxCmdScissor(int x, int y, int w, int h)
{
if (g_gfxCmdQueueSize >= GFXCMD_QUEUE_SIZE) { return; }
imguiGfxCmd& cmd = g_gfxCmdQueue[g_gfxCmdQueueSize++];
cmd.type = IMGUI_GFXCMD_SCISSOR;
cmd.flags = x < 0 ? 0 : 1; // on/off flag.
cmd.col = 0;
cmd.rect.x = (short)x;
cmd.rect.y = (short)y;
cmd.rect.w = (short)w;
cmd.rect.h = (short)h;
}
static void addGfxCmdRect(float x, float y, float w, float h, unsigned int color)
{
if (g_gfxCmdQueueSize >= GFXCMD_QUEUE_SIZE) { return; }
imguiGfxCmd& cmd = g_gfxCmdQueue[g_gfxCmdQueueSize++];
cmd.type = IMGUI_GFXCMD_RECT;
cmd.flags = 0;
cmd.col = color;
cmd.rect.x = (short)(x * 8.0f);
cmd.rect.y = (short)(y * 8.0f);
cmd.rect.w = (short)(w * 8.0f);
cmd.rect.h = (short)(h * 8.0f);
cmd.rect.r = 0;
}
static void addGfxCmdLine(float x0, float y0, float x1, float y1, float r, unsigned int color)
{
if (g_gfxCmdQueueSize >= GFXCMD_QUEUE_SIZE) { return; }
imguiGfxCmd& cmd = g_gfxCmdQueue[g_gfxCmdQueueSize++];
cmd.type = IMGUI_GFXCMD_LINE;
cmd.flags = 0;
cmd.col = color;
cmd.line.x0 = (short)(x0 * 8.0f);
cmd.line.y0 = (short)(y0 * 8.0f);
cmd.line.x1 = (short)(x1 * 8.0f);
cmd.line.y1 = (short)(y1 * 8.0f);
cmd.line.r = (short)(r * 8.0f);
}
static void addGfxCmdRoundedRect(float x, float y, float w, float h, float r, unsigned int color)
{
if (g_gfxCmdQueueSize >= GFXCMD_QUEUE_SIZE) { return; }
imguiGfxCmd& cmd = g_gfxCmdQueue[g_gfxCmdQueueSize++];
cmd.type = IMGUI_GFXCMD_RECT;
cmd.flags = 0;
cmd.col = color;
cmd.rect.x = (short)(x * 8.0f);
cmd.rect.y = (short)(y * 8.0f);
cmd.rect.w = (short)(w * 8.0f);
cmd.rect.h = (short)(h * 8.0f);
cmd.rect.r = (short)(r * 8.0f);
}
static void addGfxCmdTriangle(int x, int y, int w, int h, int flags, unsigned int color)
{
if (g_gfxCmdQueueSize >= GFXCMD_QUEUE_SIZE) { return; }
imguiGfxCmd& cmd = g_gfxCmdQueue[g_gfxCmdQueueSize++];
cmd.type = IMGUI_GFXCMD_TRIANGLE;
cmd.flags = (char)flags;
cmd.col = color;
cmd.rect.x = (short)(x * 8.0f);
cmd.rect.y = (short)(y * 8.0f);
cmd.rect.w = (short)(w * 8.0f);
cmd.rect.h = (short)(h * 8.0f);
}
static void addGfxCmdText(int x, int y, int align, const char* text, unsigned int color)
{
if (g_gfxCmdQueueSize >= GFXCMD_QUEUE_SIZE) { return; }
imguiGfxCmd& cmd = g_gfxCmdQueue[g_gfxCmdQueueSize++];
cmd.type = IMGUI_GFXCMD_TEXT;
cmd.flags = 0;
cmd.col = color;
cmd.text.x = (short)x;
cmd.text.y = (short)y;
cmd.text.align = (short)align;
cmd.text.text = allocText(text);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct GuiState
{
GuiState()
: left(false)
, leftPressed(false)
, leftReleased(false)
, mx(-1)
, my(-1)
, scroll(0)
, active(0)
, hot(0)
, hotToBe(0)
, isHot(false)
, isActive(false)
, wentActive(false)
, dragX(0)
, dragY(0)
, dragOrig(0)
, widgetX(0)
, widgetY(0)
, widgetW(100)
, insideCurrentScroll(false)
, areaId(0)
, widgetId(0)
{
}
bool left;
bool leftPressed, leftReleased;
int mx, my;
int scroll;
unsigned int active;
unsigned int hot;
unsigned int hotToBe;
bool isHot;
bool isActive;
bool wentActive;
int dragX, dragY;
float dragOrig;
int widgetX, widgetY, widgetW;
bool insideCurrentScroll;
unsigned int areaId;
unsigned int widgetId;
};
static GuiState g_state;
inline bool anyActive()
{
return g_state.active != 0;
}
inline bool isActive(unsigned int id)
{
return g_state.active == id;
}
inline bool isHot(unsigned int id)
{
return g_state.hot == id;
}
inline bool inRect(int x, int y, int w, int h, bool checkScroll = true)
{
return (!checkScroll || g_state.insideCurrentScroll)
&& g_state.mx >= x
&& g_state.mx <= x + w
&& g_state.my >= y
&& g_state.my <= y + h;
}
inline void clearInput()
{
g_state.leftPressed = false;
g_state.leftReleased = false;
g_state.scroll = 0;
}
inline void clearActive()
{
g_state.active = 0;
// mark all UI for this frame as processed
clearInput();
}
inline void setActive(unsigned int id)
{
g_state.active = id;
g_state.wentActive = true;
}
inline void setHot(unsigned int id)
{
g_state.hotToBe = id;
}
static bool buttonLogic(unsigned int id, bool over)
{
bool res = false;
// process down
if (!anyActive())
{
if (over)
{
setHot(id);
}
if (isHot(id) && g_state.leftPressed)
{
setActive(id);
}
}
// if button is active, then react on left up
if (isActive(id))
{
g_state.isActive = true;
if (over)
{
setHot(id);
}
if (g_state.leftReleased)
{
if (isHot(id))
{
res = true;
}
clearActive();
}
}
if (isHot(id))
{
g_state.isHot = true;
}
return res;
}
static void updateInput(int mx, int my, unsigned char mbut, int scroll)
{
bool left = (mbut & IMGUI_MBUT_LEFT) != 0;
g_state.mx = mx;
g_state.my = my;
g_state.leftPressed = !g_state.left && left;
g_state.leftReleased = g_state.left && !left;
g_state.left = left;
g_state.scroll = scroll;
}
void imguiBeginFrame(int mx, int my, unsigned char mbut, int scroll)
{
updateInput(mx, my, mbut, scroll);
g_state.hot = g_state.hotToBe;
g_state.hotToBe = 0;
g_state.wentActive = false;
g_state.isActive = false;
g_state.isHot = false;
g_state.widgetX = 0;
g_state.widgetY = 0;
g_state.widgetW = 0;
g_state.areaId = 1;
g_state.widgetId = 1;
resetGfxCmdQueue();
}
void imguiEndFrame()
{
clearInput();
}
const imguiGfxCmd* imguiGetRenderQueue()
{
return g_gfxCmdQueue;
}
int imguiGetRenderQueueSize()
{
return g_gfxCmdQueueSize;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static const int BUTTON_HEIGHT = 20;
static const int SLIDER_HEIGHT = 20;
static const int SLIDER_MARKER_WIDTH = 10;
static const int CHECK_SIZE = 8;
static const int DEFAULT_SPACING = 4;
static const int TEXT_HEIGHT = 8;
static const int SCROLL_AREA_PADDING = 6;
static const int INDENT_SIZE = 16;
static const int AREA_HEADER = 28;
static int g_scrollTop = 0;
static int g_scrollBottom = 0;
static int g_scrollRight = 0;
static int g_scrollAreaTop = 0;
static int* g_scrollVal = 0;
static int g_focusTop = 0;
static int g_focusBottom = 0;
static unsigned int g_scrollId = 0;
static bool g_insideScrollArea = false;
bool imguiBeginScrollArea(const char* name, int x, int y, int w, int h, int* scroll)
{
g_state.areaId++;
g_state.widgetId = 0;
g_scrollId = (g_state.areaId << 16) | g_state.widgetId;
g_state.widgetX = x + SCROLL_AREA_PADDING;
g_state.widgetY = y + h - AREA_HEADER + (*scroll);
g_state.widgetW = w - SCROLL_AREA_PADDING * 4;
g_scrollTop = y - AREA_HEADER + h;
g_scrollBottom = y + SCROLL_AREA_PADDING;
g_scrollRight = x + w - SCROLL_AREA_PADDING * 3;
g_scrollVal = scroll;
g_scrollAreaTop = g_state.widgetY;
g_focusTop = y - AREA_HEADER;
g_focusBottom = y - AREA_HEADER + h;
g_insideScrollArea = inRect(x, y, w, h, false);
g_state.insideCurrentScroll = g_insideScrollArea;
addGfxCmdRoundedRect(
(float)x,
(float)y,
(float)w,
(float)h,
6,
imguiRGBA(0, 0, 0, 192));
addGfxCmdText(
x + AREA_HEADER / 2,
y + h - AREA_HEADER / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
name,
imguiRGBA(255, 255, 255, 128));
addGfxCmdScissor(
x + SCROLL_AREA_PADDING,
y + SCROLL_AREA_PADDING,
w - SCROLL_AREA_PADDING * 4,
h - AREA_HEADER - SCROLL_AREA_PADDING);
return g_insideScrollArea;
}
void imguiEndScrollArea()
{
// Disable scissoring.
addGfxCmdScissor(-1, -1, -1, -1);
// Draw scroll bar
int x = g_scrollRight + SCROLL_AREA_PADDING / 2;
int y = g_scrollBottom;
int w = SCROLL_AREA_PADDING * 2;
int h = g_scrollTop - g_scrollBottom;
int stop = g_scrollAreaTop;
int sbot = g_state.widgetY;
int sh = stop - sbot; // The scrollable area height.
float barHeight = (float)h / (float)sh;
if (barHeight < 1)
{
float barY = (float)(y - sbot) / (float)sh;
if (barY < 0)
{
barY = 0;
}
if (barY > 1)
{
barY = 1;
}
// Handle scroll bar logic.
unsigned int hid = g_scrollId;
int hx = x;
int hy = y + (int)(barY * h);
int hw = w;
int hh = (int)(barHeight * h);
const int range = h - (hh - 1);
bool over = inRect(hx, hy, hw, hh);
buttonLogic(hid, over);
if (isActive(hid))
{
float u = (float)(hy - y) / (float)range;
if (g_state.wentActive)
{
g_state.dragY = g_state.my;
g_state.dragOrig = u;
}
if (g_state.dragY != g_state.my)
{
u = g_state.dragOrig + (g_state.my - g_state.dragY) / (float)range;
if (u < 0) { u = 0; }
if (u > 1) { u = 1; }
*g_scrollVal = (int)((1 - u) * (sh - h));
}
}
// BG
addGfxCmdRoundedRect(
(float)x,
(float)y,
(float)w,
(float)h,
(float)w / 2 - 1,
imguiRGBA(0, 0, 0, 196));
// Bar
if (isActive(hid))
{
addGfxCmdRoundedRect(
(float)hx,
(float)hy,
(float)hw,
(float)hh,
(float)w / 2 - 1,
imguiRGBA(255, 196, 0, 196));
}
else
{
addGfxCmdRoundedRect(
(float)hx,
(float)hy,
(float)hw,
(float)hh,
(float)w / 2 - 1,
isHot(hid) ? imguiRGBA(255, 196, 0, 96) : imguiRGBA(255, 255, 255, 64));
}
// Handle mouse scrolling.
if (g_insideScrollArea) // && !anyActive())
{
if (g_state.scroll)
{
*g_scrollVal += 20 * g_state.scroll;
if (*g_scrollVal < 0)
{
*g_scrollVal = 0;
}
if (*g_scrollVal > (sh - h))
{
*g_scrollVal = (sh - h);
}
}
}
}
g_state.insideCurrentScroll = false;
}
bool imguiButton(const char* text, bool enabled)
{
g_state.widgetId++;
unsigned int id = (g_state.areaId << 16) | g_state.widgetId;
int x = g_state.widgetX;
int y = g_state.widgetY - BUTTON_HEIGHT;
int w = g_state.widgetW;
int h = BUTTON_HEIGHT;
g_state.widgetY -= BUTTON_HEIGHT + DEFAULT_SPACING;
bool over = enabled && inRect(x, y, w, h);
bool res = buttonLogic(id, over);
addGfxCmdRoundedRect(
(float)x,
(float)y,
(float)w,
(float)h,
(float)BUTTON_HEIGHT / 2 - 1,
imguiRGBA(128, 128, 128, isActive(id) ? 196 : 96));
if (enabled)
{
addGfxCmdText(
x + BUTTON_HEIGHT / 2,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200));
}
else
{
addGfxCmdText(
x + BUTTON_HEIGHT / 2,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
imguiRGBA(128, 128, 128, 200));
}
return res;
}
bool imguiItem(const char* text, bool enabled)
{
g_state.widgetId++;
unsigned int id = (g_state.areaId << 16) | g_state.widgetId;
int x = g_state.widgetX;
int y = g_state.widgetY - BUTTON_HEIGHT;
int w = g_state.widgetW;
int h = BUTTON_HEIGHT;
g_state.widgetY -= BUTTON_HEIGHT + DEFAULT_SPACING;
bool over = enabled && inRect(x, y, w, h);
bool res = buttonLogic(id, over);
if (isHot(id))
{
addGfxCmdRoundedRect(
(float)x,
(float)y,
(float)w,
(float)h,
2.0f,
imguiRGBA(255, 196, 0, isActive(id) ? 196 : 96));
}
if (enabled)
{
addGfxCmdText(
x + BUTTON_HEIGHT / 2,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
imguiRGBA(255, 255, 255, 200));
}
else
{
addGfxCmdText(
x + BUTTON_HEIGHT / 2,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
imguiRGBA(128, 128, 128, 200));
}
return res;
}
bool imguiCheck(const char* text, bool checked, bool enabled)
{
g_state.widgetId++;
unsigned int id = (g_state.areaId << 16) | g_state.widgetId;
int x = g_state.widgetX;
int y = g_state.widgetY - BUTTON_HEIGHT;
int w = g_state.widgetW;
int h = BUTTON_HEIGHT;
g_state.widgetY -= BUTTON_HEIGHT + DEFAULT_SPACING;
bool over = enabled && inRect(x, y, w, h);
bool res = buttonLogic(id, over);
const int cx = x + BUTTON_HEIGHT / 2 - CHECK_SIZE / 2;
const int cy = y + BUTTON_HEIGHT / 2 - CHECK_SIZE / 2;
addGfxCmdRoundedRect(
(float)cx - 3,
(float)cy - 3,
(float)CHECK_SIZE + 6,
(float)CHECK_SIZE + 6,
4,
imguiRGBA(128, 128, 128, isActive(id) ? 196 : 96));
if (checked)
{
if (enabled)
{
addGfxCmdRoundedRect(
(float)cx,
(float)cy,
(float)CHECK_SIZE,
(float)CHECK_SIZE,
(float)CHECK_SIZE / 2 - 1,
imguiRGBA(255, 255, 255, isActive(id) ? 255 : 200));
}
else
{
addGfxCmdRoundedRect(
(float)cx,
(float)cy,
(float)CHECK_SIZE,
(float)CHECK_SIZE,
(float)CHECK_SIZE / 2 - 1,
imguiRGBA(128, 128, 128, 200));
}
}
if (enabled)
{
addGfxCmdText(
x + BUTTON_HEIGHT,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200));
}
else
{
addGfxCmdText(
x + BUTTON_HEIGHT,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
imguiRGBA(128, 128, 128, 200));
}
return res;
}
bool imguiCollapse(const char* text, const char* subtext, bool checked, bool enabled)
{
g_state.widgetId++;
unsigned int id = (g_state.areaId << 16) | g_state.widgetId;
int x = g_state.widgetX;
int y = g_state.widgetY - BUTTON_HEIGHT;
int w = g_state.widgetW;
int h = BUTTON_HEIGHT;
g_state.widgetY -= BUTTON_HEIGHT; // + DEFAULT_SPACING;
const int cx = x + BUTTON_HEIGHT / 2 - CHECK_SIZE / 2;
const int cy = y + BUTTON_HEIGHT / 2 - CHECK_SIZE / 2;
bool over = enabled && inRect(x, y, w, h);
bool res = buttonLogic(id, over);
if (checked) {
addGfxCmdTriangle(
cx,
cy,
CHECK_SIZE,
CHECK_SIZE,
2,
imguiRGBA(255, 255, 255, isActive(id) ? 255 : 200));
}
else
{
addGfxCmdTriangle(
cx,
cy,
CHECK_SIZE,
CHECK_SIZE,
1,
imguiRGBA(255, 255, 255, isActive(id) ? 255 : 200));
}
if (enabled)
{
addGfxCmdText(
x + BUTTON_HEIGHT,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200));
}
else
{
addGfxCmdText(
x + BUTTON_HEIGHT, y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2, IMGUI_ALIGN_LEFT, text, imguiRGBA(128, 128, 128, 200));
}
if (subtext)
{
addGfxCmdText(x + w - BUTTON_HEIGHT / 2,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_RIGHT,
subtext,
imguiRGBA(255, 255, 255, 128));
}
return res;
}
void imguiLabel(const char* text)
{
int x = g_state.widgetX;
int y = g_state.widgetY - BUTTON_HEIGHT;
g_state.widgetY -= BUTTON_HEIGHT;
addGfxCmdText(x, y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2, IMGUI_ALIGN_LEFT, text, imguiRGBA(255, 255, 255, 255));
}
void imguiValue(const char* text)
{
const int x = g_state.widgetX;
const int y = g_state.widgetY - BUTTON_HEIGHT;
const int w = g_state.widgetW;
g_state.widgetY -= BUTTON_HEIGHT;
addGfxCmdText(x + w - BUTTON_HEIGHT / 2,
y + BUTTON_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_RIGHT,
text,
imguiRGBA(255, 255, 255, 200));
}
bool imguiSlider(const char* text, float* val, float vmin, float vmax, float vinc, bool enabled)
{
g_state.widgetId++;
unsigned int id = (g_state.areaId << 16) | g_state.widgetId;
int x = g_state.widgetX;
int y = g_state.widgetY - BUTTON_HEIGHT;
int w = g_state.widgetW;
int h = SLIDER_HEIGHT;
g_state.widgetY -= SLIDER_HEIGHT + DEFAULT_SPACING;
addGfxCmdRoundedRect((float)x, (float)y, (float)w, (float)h, 4.0f, imguiRGBA(0, 0, 0, 128));
const int range = w - SLIDER_MARKER_WIDTH;
float u = (*val - vmin) / (vmax - vmin);
if (u < 0) { u = 0; }
if (u > 1) { u = 1; }
int m = (int)(u * range);
bool over = enabled && inRect(x + m, y, SLIDER_MARKER_WIDTH, SLIDER_HEIGHT);
bool res = buttonLogic(id, over);
bool valChanged = false;
if (isActive(id))
{
if (g_state.wentActive)
{
g_state.dragX = g_state.mx;
g_state.dragOrig = u;
}
if (g_state.dragX != g_state.mx)
{
u = g_state.dragOrig + (float)(g_state.mx - g_state.dragX) / (float)range;
if (u < 0) { u = 0; }
if (u > 1) { u = 1; }
*val = vmin + u * (vmax - vmin);
*val = floorf(*val / vinc + 0.5f) * vinc; // Snap to vinc
m = (int)(u * range);
valChanged = true;
}
}
if (isActive(id))
{
addGfxCmdRoundedRect((float)(x + m), (float)y, (float)SLIDER_MARKER_WIDTH, (float)SLIDER_HEIGHT, 4.0f, imguiRGBA(255, 255, 255, 255));
}
else
{
addGfxCmdRoundedRect((float)(x + m),
(float)y,
(float)SLIDER_MARKER_WIDTH,
(float)SLIDER_HEIGHT,
4.0f,
isHot(id) ? imguiRGBA(255, 196, 0, 128) : imguiRGBA(255, 255, 255, 64));
}
// TODO: fix this, take a look at 'nicenum'.
int digits = (int)(ceilf(log10f(vinc)));
char fmt[16];
snprintf(fmt, 16, "%%.%df", digits >= 0 ? 0 : -digits);
char msg[128];
snprintf(msg, 128, fmt, *val);
if (enabled)
{
addGfxCmdText(x + SLIDER_HEIGHT / 2,
y + SLIDER_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200));
addGfxCmdText(x + w - SLIDER_HEIGHT / 2,
y + SLIDER_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_RIGHT,
msg,
isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200));
}
else
{
addGfxCmdText(x + SLIDER_HEIGHT / 2,
y + SLIDER_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_LEFT,
text,
imguiRGBA(128, 128, 128, 200));
addGfxCmdText(x + w - SLIDER_HEIGHT / 2,
y + SLIDER_HEIGHT / 2 - TEXT_HEIGHT / 2,
IMGUI_ALIGN_RIGHT,
msg,
imguiRGBA(128, 128, 128, 200));
}
return res || valChanged;
}
void imguiIndent()
{
g_state.widgetX += INDENT_SIZE;
g_state.widgetW -= INDENT_SIZE;
}
void imguiUnindent()
{
g_state.widgetX -= INDENT_SIZE;
g_state.widgetW += INDENT_SIZE;
}
void imguiSeparator()
{
g_state.widgetY -= DEFAULT_SPACING * 3;
}
void imguiSeparatorLine()
{
int x = g_state.widgetX;
int y = g_state.widgetY - DEFAULT_SPACING * 2;
int w = g_state.widgetW;
int h = 1;
g_state.widgetY -= DEFAULT_SPACING * 4;
addGfxCmdRect((float)x, (float)y, (float)w, (float)h, imguiRGBA(255, 255, 255, 32));
}
void imguiDrawText(int x, int y, int align, const char* text, unsigned int color)
{
addGfxCmdText(x, y, align, text, color);
}
void imguiDrawLine(float x0, float y0, float x1, float y1, float r, unsigned int color)
{
addGfxCmdLine(x0, y0, x1, y1, r, color);
}
void imguiDrawRect(float x, float y, float w, float h, unsigned int color)
{
addGfxCmdRect(x, y, w, h, color);
}
void imguiDrawRoundedRect(float x, float y, float w, float h, float r, unsigned int color)
{
addGfxCmdRoundedRect(x, y, w, h, r, color);
}

497
RecastDemo/Source/imguiRenderGL.cpp
View File

@@ -1,497 +0,0 @@
//
// Copyright (c) 2009-2010 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.
//
#include "SDL.h"
#include "SDL_opengl.h"
#include "imgui.h"
#include <cmath>
#include <cstdio>
// 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; }
if (fseek(fp, 0, SEEK_END) != 0)
{
fclose(fp);
return false;
}
long size = ftell(fp);
if (size < 0)
{
fclose(fp);
return false;
}
if (fseek(fp, 0, SEEK_SET) != 0)
{
fclose(fp);
return false;
}
unsigned char* ttfBuffer = (unsigned char*)malloc(size);
if (!ttfBuffer)
{
fclose(fp);
return false;
}
size_t readLen = fread(ttfBuffer, 1, size, fp);
fclose(fp);
if (readLen != static_cast<size_t>(size))
{
free(ttfBuffer);
return false;
}
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
glGenTextures(1, &g_ftex);
glBindTexture(GL_TEXTURE_2D, g_ftex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512, 512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, bmap);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
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);
}