diff options
Diffstat (limited to '3rdparty/bgfx/examples/common/imgui/imgui.cpp')
-rw-r--r-- | 3rdparty/bgfx/examples/common/imgui/imgui.cpp | 3369 |
1 files changed, 3369 insertions, 0 deletions
diff --git a/3rdparty/bgfx/examples/common/imgui/imgui.cpp b/3rdparty/bgfx/examples/common/imgui/imgui.cpp new file mode 100644 index 00000000000..163f18a81aa --- /dev/null +++ b/3rdparty/bgfx/examples/common/imgui/imgui.cpp @@ -0,0 +1,3369 @@ +/* + * Copyright 2011-2015 Branimir Karadzic. All rights reserved. + * License: http://www.opensource.org/licenses/BSD-2-Clause + */ + +// This code is based on: +// +// 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. +// +// Source altered and distributed from https://github.com/AdrienHerubel/imgui + +#include <stdio.h> +#include <bx/string.h> +#include <bx/uint32_t.h> +#include <bx/fpumath.h> +#include <bx/handlealloc.h> + +#include "../entry/dbg.h" +#include "imgui.h" +#include "ocornut_imgui.h" +#include "../nanovg/nanovg.h" + +// embedded shaders +#include "vs_imgui_color.bin.h" +#include "fs_imgui_color.bin.h" +#include "vs_imgui_texture.bin.h" +#include "fs_imgui_texture.bin.h" +#include "vs_imgui_cubemap.bin.h" +#include "fs_imgui_cubemap.bin.h" +#include "vs_imgui_image.bin.h" +#include "fs_imgui_image.bin.h" +#include "fs_imgui_image_swizz.bin.h" + +// embedded font +#include "droidsans.ttf.h" + +#define USE_NANOVG_FONT 0 + +#define IMGUI_CONFIG_MAX_FONTS 20 + +#define MAX_TEMP_COORDS 100 +#define NUM_CIRCLE_VERTS (8 * 4) + +static const int32_t BUTTON_HEIGHT = 20; +static const int32_t SLIDER_HEIGHT = 20; +static const int32_t SLIDER_MARKER_WIDTH = 10; +static const int32_t CHECK_SIZE = 8; +static const int32_t DEFAULT_SPACING = 4; +static const int32_t TEXT_HEIGHT = 8; +static const int32_t SCROLL_AREA_PADDING = 6; +static const int32_t AREA_HEADER = 20; +static const float s_tabStops[4] = {150, 210, 270, 330}; + +static void* imguiMalloc(size_t size, void* /*_userptr*/) +{ + return malloc(size); +} + +static void imguiFree(void* _ptr, void* /*_userptr*/) +{ + free(_ptr); +} + +#define IMGUI_MIN(_a, _b) (_a)<(_b)?(_a):(_b) +#define IMGUI_MAX(_a, _b) (_a)>(_b)?(_a):(_b) +#define IMGUI_CLAMP(_a, _min, _max) IMGUI_MIN(IMGUI_MAX(_a, _min), _max) + +#define STBTT_malloc(_x, _y) imguiMalloc(_x, _y) +#define STBTT_free(_x, _y) imguiFree(_x, _y) +#define STB_TRUETYPE_IMPLEMENTATION +#include <stb/stb_truetype.h> + +namespace +{ + static uint32_t addQuad(uint16_t* _indices, uint16_t _idx0, uint16_t _idx1, uint16_t _idx2, uint16_t _idx3) + { + _indices[0] = _idx0; + _indices[1] = _idx3; + _indices[2] = _idx1; + + _indices[3] = _idx1; + _indices[4] = _idx3; + _indices[5] = _idx2; + + return 6; + } + + float sign(float px, float py, float ax, float ay, float bx, float by) + { + return (px - bx) * (ay - by) - (ax - bx) * (py - by); + } + + bool pointInTriangle(float px, float py, float ax, float ay, float bx, float by, float cx, float cy) + { + const bool b1 = sign(px, py, ax, ay, bx, by) < 0.0f; + const bool b2 = sign(px, py, bx, by, cx, cy) < 0.0f; + const bool b3 = sign(px, py, cx, cy, ax, ay) < 0.0f; + + return ( (b1 == b2) && (b2 == b3) ); + } + + void closestPointOnLine(float& ox, float &oy, float px, float py, float ax, float ay, float bx, float by) + { + float dx = px - ax; + float dy = py - ay; + + float lx = bx - ax; + float ly = by - ay; + + float len = sqrtf(lx*lx+ly*ly); + + // Normalize. + float invLen = 1.0f/len; + lx*=invLen; + ly*=invLen; + + float dot = (dx*lx + dy*ly); + + if (dot < 0.0f) + { + ox = ax; + oy = ay; + } + else if (dot > len) + { + ox = bx; + oy = by; + } + else + { + ox = ax + lx*dot; + oy = ay + ly*dot; + } + } + + void closestPointOnTriangle(float& ox, float &oy, float px, float py, float ax, float ay, float bx, float by, float cx, float cy) + { + float abx, aby; + float bcx, bcy; + float cax, cay; + closestPointOnLine(abx, aby, px, py, ax, ay, bx, by); + closestPointOnLine(bcx, bcy, px, py, bx, by, cx, cy); + closestPointOnLine(cax, cay, px, py, cx, cy, ax, ay); + + const float pabx = px - abx; + const float paby = py - aby; + const float pbcx = px - bcx; + const float pbcy = py - bcy; + const float pcax = px - cax; + const float pcay = py - cay; + + const float lab = sqrtf(pabx*pabx+paby*paby); + const float lbc = sqrtf(pbcx*pbcx+pbcy*pbcy); + const float lca = sqrtf(pcax*pcax+pcay*pcay); + + const float m = bx::fmin3(lab, lbc, lca); + if (m == lab) + { + ox = abx; + oy = aby; + } + else if (m == lbc) + { + ox = bcx; + oy = bcy; + } + else// if (m == lca). + { + ox = cax; + oy = cay; + } + } + + inline float vec2Dot(const float* __restrict _a, const float* __restrict _b) + { + return _a[0]*_b[0] + _a[1]*_b[1]; + } + + void barycentric(float& _u, float& _v, float& _w + , float _ax, float _ay + , float _bx, float _by + , float _cx, float _cy + , float _px, float _py + ) + { + const float v0[2] = { _bx - _ax, _by - _ay }; + const float v1[2] = { _cx - _ax, _cy - _ay }; + const float v2[2] = { _px - _ax, _py - _ay }; + const float d00 = vec2Dot(v0, v0); + const float d01 = vec2Dot(v0, v1); + const float d11 = vec2Dot(v1, v1); + const float d20 = vec2Dot(v2, v0); + const float d21 = vec2Dot(v2, v1); + const float denom = d00 * d11 - d01 * d01; + _v = (d11 * d20 - d01 * d21) / denom; + _w = (d00 * d21 - d01 * d20) / denom; + _u = 1.0f - _v - _w; + } + + struct PosColorVertex + { + float m_x; + float m_y; + uint32_t m_abgr; + + static void init() + { + ms_decl + .begin() + .add(bgfx::Attrib::Position, 2, bgfx::AttribType::Float) + .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true) + .end(); + } + + static bgfx::VertexDecl ms_decl; + }; + + bgfx::VertexDecl PosColorVertex::ms_decl; + + struct PosColorUvVertex + { + float m_x; + float m_y; + float m_u; + float m_v; + uint32_t m_abgr; + + static void init() + { + ms_decl + .begin() + .add(bgfx::Attrib::Position, 2, bgfx::AttribType::Float) + .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float) + .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true) + .end(); + } + + static bgfx::VertexDecl ms_decl; + }; + + bgfx::VertexDecl PosColorUvVertex::ms_decl; + + struct PosUvVertex + { + float m_x; + float m_y; + float m_u; + float m_v; + + static void init() + { + ms_decl + .begin() + .add(bgfx::Attrib::Position, 2, bgfx::AttribType::Float) + .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float) + .end(); + } + + static bgfx::VertexDecl ms_decl; + }; + + bgfx::VertexDecl PosUvVertex::ms_decl; + + struct PosNormalVertex + { + float m_x; + float m_y; + float m_z; + float m_nx; + float m_ny; + float m_nz; + + static void init() + { + ms_decl.begin() + .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float) + .add(bgfx::Attrib::Normal, 3, bgfx::AttribType::Float) + .end(); + } + + void set(float _x, float _y, float _z, float _nx, float _ny, float _nz) + { + m_x = _x; + m_y = _y; + m_z = _z; + m_nx = _nx; + m_ny = _ny; + m_nz = _nz; + } + + static bgfx::VertexDecl ms_decl; + }; + + bgfx::VertexDecl PosNormalVertex::ms_decl; + +} // namespace + +#if !USE_NANOVG_FONT +static float getTextLength(stbtt_bakedchar* _chardata, const char* _text, uint32_t& _numVertices) +{ + float xpos = 0; + float len = 0; + uint32_t numVertices = 0; + + while (*_text) + { + int32_t ch = (uint8_t)*_text; + if (ch == '\t') + { + for (int32_t ii = 0; ii < 4; ++ii) + { + if (xpos < s_tabStops[ii]) + { + xpos = s_tabStops[ii]; + break; + } + } + } + else if (ch >= ' ' + && ch < 128) + { + stbtt_bakedchar* b = _chardata + ch - ' '; + int32_t round_x = STBTT_ifloor( (xpos + b->xoff) + 0.5); + len = round_x + b->x1 - b->x0 + 0.5f; + xpos += b->xadvance; + numVertices += 6; + } + + ++_text; + } + + _numVertices = numVertices; + + return len; +} +#endif // !USE_NANOVG_FONT + +struct Imgui +{ + Imgui() + : m_mx(-1) + , m_my(-1) + , m_scroll(0) + , m_active(0) + , m_hot(0) + , m_hotToBe(0) + , m_dragX(0) + , m_dragY(0) + , m_dragOrig(0) + , m_left(false) + , m_leftPressed(false) + , m_leftReleased(false) + , m_isHot(false) + , m_wentActive(false) + , m_insideArea(false) + , m_isActivePresent(false) + , m_checkActivePresence(false) + , m_widgetId(0) + , m_enabledAreaIds(0) + , m_textureWidth(512) + , m_textureHeight(512) + , m_halfTexel(0.0f) + , m_nvg(NULL) + , m_view(31) + , m_viewWidth(0) + , m_viewHeight(0) + , m_currentFontIdx(0) + { + m_areaId.reset(); + + m_invTextureWidth = 1.0f/m_textureWidth; + m_invTextureHeight = 1.0f/m_textureHeight; + + u_imageLodEnabled.idx = bgfx::invalidHandle; + u_imageSwizzle.idx = bgfx::invalidHandle; + s_texColor.idx = bgfx::invalidHandle; + m_missingTexture.idx = bgfx::invalidHandle; + + m_colorProgram.idx = bgfx::invalidHandle; + m_textureProgram.idx = bgfx::invalidHandle; + m_cubeMapProgram.idx = bgfx::invalidHandle; + m_imageProgram.idx = bgfx::invalidHandle; + m_imageSwizzProgram.idx = bgfx::invalidHandle; + } + + ImguiFontHandle createFont(const void* _data, float _fontSize) + { +#if !USE_NANOVG_FONT + const ImguiFontHandle handle = { m_fontHandle.alloc() }; + const bgfx::Memory* mem = bgfx::alloc(m_textureWidth * m_textureHeight); + stbtt_BakeFontBitmap( (uint8_t*)_data, 0, _fontSize, mem->data, m_textureWidth, m_textureHeight, 32, 96, m_fonts[handle.idx].m_cdata); + m_fonts[handle.idx].m_texture = bgfx::createTexture2D(m_textureWidth, m_textureHeight, 1, bgfx::TextureFormat::R8, BGFX_TEXTURE_NONE, mem); + m_fonts[handle.idx].m_size = _fontSize; +#else + const ImguiFontHandle handle = { bgfx::invalidHandle }; +#endif // !USE_NANOVG_FONT + return handle; + } + + void setFont(ImguiFontHandle _handle) + { + if (isValid(_handle) ) + { + m_currentFontIdx = _handle.idx; + } + } + + bgfx::TextureHandle genMissingTexture(uint32_t _width, uint32_t _height, float _lineWidth = 0.02f) + { + const bgfx::Memory* mem = bgfx::alloc(_width*_height*4); + uint32_t* bgra8 = (uint32_t*)mem->data; + + const float sx = 0.70710677f; + const float cx = 0.70710677f; + + for (uint32_t yy = 0; yy < _height; ++yy) + { + for (uint32_t xx = 0; xx < _width; ++xx) + { + float px = xx / float(_width) * 2.0f - 1.0f; + float py = yy / float(_height) * 2.0f - 1.0f; + + float sum = bx::fpulse(px * cx - py * sx, _lineWidth, -_lineWidth) + + bx::fpulse(px * sx + py * cx, _lineWidth, -_lineWidth) + ; + *bgra8++ = sum >= 1.0f ? 0xffff0000 : 0xffffffff; + } + } + + return bgfx::createTexture2D(_width, _height, 0, bgfx::TextureFormat::BGRA8, 0, mem); + } + + ImguiFontHandle create(const void* _data, uint32_t _size, float _fontSize) + { + if (NULL == _data) + { + _data = s_droidSansTtf; + _size = sizeof(s_droidSansTtf); + } + + IMGUI_create(_data, _size, _fontSize); + + m_nvg = nvgCreate(1, m_view); + nvgCreateFontMem(m_nvg, "default", (unsigned char*)_data, INT32_MAX, 0); + nvgFontSize(m_nvg, _fontSize); + nvgFontFace(m_nvg, "default"); + + for (int32_t ii = 0; ii < NUM_CIRCLE_VERTS; ++ii) + { + float a = (float)ii / (float)NUM_CIRCLE_VERTS * (float)(bx::pi * 2.0); + m_circleVerts[ii * 2 + 0] = cosf(a); + m_circleVerts[ii * 2 + 1] = sinf(a); + } + + PosColorVertex::init(); + PosColorUvVertex::init(); + PosUvVertex::init(); + PosNormalVertex::init(); + + u_imageLodEnabled = bgfx::createUniform("u_imageLodEnabled", bgfx::UniformType::Uniform4fv); + u_imageSwizzle = bgfx::createUniform("u_swizzle", bgfx::UniformType::Uniform4fv); + s_texColor = bgfx::createUniform("s_texColor", bgfx::UniformType::Uniform1i); + + const bgfx::Memory* vs_imgui_color; + const bgfx::Memory* fs_imgui_color; + const bgfx::Memory* vs_imgui_texture; + const bgfx::Memory* fs_imgui_texture; + const bgfx::Memory* vs_imgui_cubemap; + const bgfx::Memory* fs_imgui_cubemap; + const bgfx::Memory* vs_imgui_image; + const bgfx::Memory* fs_imgui_image; + const bgfx::Memory* fs_imgui_image_swizz; + + switch (bgfx::getRendererType() ) + { + case bgfx::RendererType::Direct3D9: + vs_imgui_color = bgfx::makeRef(vs_imgui_color_dx9, sizeof(vs_imgui_color_dx9) ); + fs_imgui_color = bgfx::makeRef(fs_imgui_color_dx9, sizeof(fs_imgui_color_dx9) ); + vs_imgui_texture = bgfx::makeRef(vs_imgui_texture_dx9, sizeof(vs_imgui_texture_dx9) ); + fs_imgui_texture = bgfx::makeRef(fs_imgui_texture_dx9, sizeof(fs_imgui_texture_dx9) ); + vs_imgui_cubemap = bgfx::makeRef(vs_imgui_cubemap_dx9, sizeof(vs_imgui_cubemap_dx9) ); + fs_imgui_cubemap = bgfx::makeRef(fs_imgui_cubemap_dx9, sizeof(fs_imgui_cubemap_dx9) ); + vs_imgui_image = bgfx::makeRef(vs_imgui_image_dx9, sizeof(vs_imgui_image_dx9) ); + fs_imgui_image = bgfx::makeRef(fs_imgui_image_dx9, sizeof(fs_imgui_image_dx9) ); + fs_imgui_image_swizz = bgfx::makeRef(fs_imgui_image_swizz_dx9, sizeof(fs_imgui_image_swizz_dx9) ); + m_halfTexel = 0.5f; + break; + + case bgfx::RendererType::Direct3D11: + vs_imgui_color = bgfx::makeRef(vs_imgui_color_dx11, sizeof(vs_imgui_color_dx11) ); + fs_imgui_color = bgfx::makeRef(fs_imgui_color_dx11, sizeof(fs_imgui_color_dx11) ); + vs_imgui_texture = bgfx::makeRef(vs_imgui_texture_dx11, sizeof(vs_imgui_texture_dx11) ); + fs_imgui_texture = bgfx::makeRef(fs_imgui_texture_dx11, sizeof(fs_imgui_texture_dx11) ); + vs_imgui_cubemap = bgfx::makeRef(vs_imgui_cubemap_dx11, sizeof(vs_imgui_cubemap_dx11) ); + fs_imgui_cubemap = bgfx::makeRef(fs_imgui_cubemap_dx11, sizeof(fs_imgui_cubemap_dx11) ); + vs_imgui_image = bgfx::makeRef(vs_imgui_image_dx11, sizeof(vs_imgui_image_dx11) ); + fs_imgui_image = bgfx::makeRef(fs_imgui_image_dx11, sizeof(fs_imgui_image_dx11) ); + fs_imgui_image_swizz = bgfx::makeRef(fs_imgui_image_swizz_dx11, sizeof(fs_imgui_image_swizz_dx11) ); + break; + + default: + vs_imgui_color = bgfx::makeRef(vs_imgui_color_glsl, sizeof(vs_imgui_color_glsl) ); + fs_imgui_color = bgfx::makeRef(fs_imgui_color_glsl, sizeof(fs_imgui_color_glsl) ); + vs_imgui_texture = bgfx::makeRef(vs_imgui_texture_glsl, sizeof(vs_imgui_texture_glsl) ); + fs_imgui_texture = bgfx::makeRef(fs_imgui_texture_glsl, sizeof(fs_imgui_texture_glsl) ); + vs_imgui_cubemap = bgfx::makeRef(vs_imgui_cubemap_glsl, sizeof(vs_imgui_cubemap_glsl) ); + fs_imgui_cubemap = bgfx::makeRef(fs_imgui_cubemap_glsl, sizeof(fs_imgui_cubemap_glsl) ); + vs_imgui_image = bgfx::makeRef(vs_imgui_image_glsl, sizeof(vs_imgui_image_glsl) ); + fs_imgui_image = bgfx::makeRef(fs_imgui_image_glsl, sizeof(fs_imgui_image_glsl) ); + fs_imgui_image_swizz = bgfx::makeRef(fs_imgui_image_swizz_glsl, sizeof(fs_imgui_image_swizz_glsl) ); + break; + } + + bgfx::ShaderHandle vsh; + bgfx::ShaderHandle fsh; + + vsh = bgfx::createShader(vs_imgui_color); + fsh = bgfx::createShader(fs_imgui_color); + m_colorProgram = bgfx::createProgram(vsh, fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); + + vsh = bgfx::createShader(vs_imgui_texture); + fsh = bgfx::createShader(fs_imgui_texture); + m_textureProgram = bgfx::createProgram(vsh, fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); + + vsh = bgfx::createShader(vs_imgui_cubemap); + fsh = bgfx::createShader(fs_imgui_cubemap); + m_cubeMapProgram = bgfx::createProgram(vsh, fsh); + bgfx::destroyShader(vsh); + bgfx::destroyShader(fsh); + + vsh = bgfx::createShader(vs_imgui_image); + fsh = bgfx::createShader(fs_imgui_image); + m_imageProgram = bgfx::createProgram(vsh, fsh); + bgfx::destroyShader(fsh); + + // Notice: using the same vsh. + fsh = bgfx::createShader(fs_imgui_image_swizz); + m_imageSwizzProgram = bgfx::createProgram(vsh, fsh); + bgfx::destroyShader(fsh); + bgfx::destroyShader(vsh); + + m_missingTexture = genMissingTexture(256, 256, 0.04f); + +#if !USE_NANOVG_FONT + const ImguiFontHandle handle = createFont(_data, _fontSize); + m_currentFontIdx = handle.idx; +#else + const ImguiFontHandle handle = { bgfx::invalidHandle }; +#endif // !USE_NANOVG_FONT + return handle; + } + + void destroy() + { + bgfx::destroyUniform(u_imageLodEnabled); + bgfx::destroyUniform(u_imageSwizzle); + bgfx::destroyUniform(s_texColor); +#if !USE_NANOVG_FONT + for (uint16_t ii = 0; ii < IMGUI_CONFIG_MAX_FONTS; ++ii) + { + if (bgfx::isValid(m_fonts[ii].m_texture) ) + { + bgfx::destroyTexture(m_fonts[ii].m_texture); + } + } +#endif // !USE_NANOVG_FONT + bgfx::destroyTexture(m_missingTexture); + bgfx::destroyProgram(m_colorProgram); + bgfx::destroyProgram(m_textureProgram); + bgfx::destroyProgram(m_cubeMapProgram); + bgfx::destroyProgram(m_imageProgram); + bgfx::destroyProgram(m_imageSwizzProgram); + nvgDelete(m_nvg); + + IMGUI_destroy(); + } + + bool anyActive() const + { + return m_active != 0; + } + + inline void updatePresence(uint32_t _id) + { + if (m_checkActivePresence && m_active == _id) + { + m_isActivePresent = true; + } + } + + uint32_t getId() + { + const uint32_t id = (m_areaId << 16) | m_widgetId++; + updatePresence(id); + return id; + } + + bool isActive(uint32_t _id) const + { + return m_active == _id; + } + + bool isActiveInputField(uint32_t _id) const + { + return m_inputField == _id; + } + + bool isHot(uint32_t _id) const + { + return m_hot == _id; + } + + bool inRect(int32_t _x, int32_t _y, int32_t _width, int32_t _height, bool _checkScroll = true) const + { + return (!_checkScroll || m_areas[m_areaId].m_inside) + && m_mx >= _x + && m_mx <= _x + _width + && m_my >= _y + && m_my <= _y + _height; + } + + bool isEnabled(uint16_t _areaId) + { + return (m_enabledAreaIds>>_areaId)&0x1; + } + + void setEnabled(uint16_t _areaId) + { + m_enabledAreaIds |= (UINT64_C(1)<<_areaId); + } + + void clearInput() + { + m_leftPressed = false; + m_leftReleased = false; + m_scroll = 0; + } + + void clearActive() + { + m_active = 0; + // mark all UI for this frame as processed + clearInput(); + } + + void clearActiveInputField() + { + m_inputField = 0; + } + + void setActive(uint32_t _id) + { + m_active = _id; + m_wentActive = true; + m_inputField = 0; + } + + void setActiveInputField(uint32_t _id) + { + m_inputField = _id; + } + + void setHot(uint32_t _id) + { + m_hotToBe = _id; + } + + bool buttonLogic(uint32_t _id, bool _over) + { + bool res = false; + // process down + if (!anyActive() ) + { + if (_over) + { + setHot(_id); + } + + if (isHot(_id) + && m_leftPressed) + { + setActive(_id); + } + } + + // if button is active, then react on left up + if (isActive(_id) ) + { + if (_over) + { + setHot(_id); + } + + if (m_leftReleased) + { + if (isHot(_id) ) + { + res = true; + } + + clearActive(); + } + } + + if (isHot(_id) ) + { + m_isHot = true; + } + + return res; + } + + void inputLogic(uint32_t _id, bool _over) + { + if (!anyActive() ) + { + if (_over) + { + setHot(_id); + } + + if (isHot(_id) + && m_leftPressed) + { + // Toggle active input. + if (isActiveInputField(_id)) + { + clearActiveInputField(); + } + else + { + setActiveInputField(_id); + } + } + } + + if (isHot(_id) ) + { + m_isHot = true; + } + + if (m_leftPressed + && !m_isHot + && m_inputField != 0) + { + clearActiveInputField(); + } + } + + void updateInput(int32_t _mx, int32_t _my, uint8_t _button, int32_t _scroll, char _inputChar) + { + bool left = (_button & IMGUI_MBUT_LEFT) != 0; + + m_mx = _mx; + m_my = _my; + m_leftPressed = !m_left && left; + m_leftReleased = m_left && !left; + m_left = left; + m_scroll = _scroll; + + _inputChar = _inputChar & 0x7f; // ASCII or GTFO! :) + m_lastChar = m_char; + m_char = _inputChar; + } + + void beginFrame(int32_t _mx, int32_t _my, uint8_t _button, int32_t _scroll, uint16_t _width, uint16_t _height, char _inputChar, uint8_t _view) + { + IMGUI_beginFrame(_mx, _my, _button, _width, _height, _inputChar, _view); + + m_view = _view; + m_viewWidth = _width; + m_viewHeight = _height; + bgfx::setViewName(_view, "IMGUI"); + bgfx::setViewSeq(_view, true); + + const bgfx::HMD* hmd = bgfx::getHMD(); + if (NULL != hmd) + { + m_viewWidth = _width / 2; + + float proj[16]; + bx::mtxProj(proj, hmd->eye[0].fov, 0.1f, 100.0f); + + static float time = 0.0f; + time += 0.05f; + + const float dist = 10.0f; + const float offset0 = -proj[8] + (hmd->eye[0].viewOffset[0] / dist * proj[0]); + const float offset1 = -proj[8] + (hmd->eye[1].viewOffset[0] / dist * proj[0]); + + float ortho[2][16]; + const float viewOffset = _width/4.0f; + const float viewWidth = _width/2.0f; + bx::mtxOrtho(ortho[0], viewOffset, viewOffset + viewWidth, (float)m_viewHeight, 0.0f, 0.0f, 1000.0f, offset0); + bx::mtxOrtho(ortho[1], viewOffset, viewOffset + viewWidth, (float)m_viewHeight, 0.0f, 0.0f, 1000.0f, offset1); + bgfx::setViewTransform(_view, NULL, ortho[0], BGFX_VIEW_STEREO, ortho[1]); + bgfx::setViewRect(_view, 0, 0, hmd->width, hmd->height); + } + else + { + float ortho[16]; + bx::mtxOrtho(ortho, 0.0f, (float)m_viewWidth, (float)m_viewHeight, 0.0f, 0.0f, 1000.0f); + bgfx::setViewTransform(_view, NULL, ortho); + bgfx::setViewRect(_view, 0, 0, _width, _height); + } + + updateInput(_mx, _my, _button, _scroll, _inputChar); + + m_hot = m_hotToBe; + m_hotToBe = 0; + + m_wentActive = false; + m_isHot = false; + + Area& area = getCurrentArea(); + area.m_widgetX = 0; + area.m_widgetY = 0; + area.m_widgetW = 0; + + m_areaId.reset(); + m_widgetId = 0; + m_enabledAreaIds = 0; + m_insideArea = false; + + m_isActivePresent = false; + } + + void endFrame() + { + if (m_checkActivePresence && !m_isActivePresent) + { + // The ui element is not present any more, reset active field. + m_active = 0; + } + m_checkActivePresence = (0 != m_active); + + clearInput(); + + IMGUI_endFrame(); + } + + bool beginScroll(int32_t _height, int32_t* _scroll, bool _enabled) + { + Area& parentArea = getCurrentArea(); + + m_areaId.next(); + const uint32_t scrollId = getId(); + + Area& area = getCurrentArea(); + + const uint16_t parentBottom = parentArea.m_scissorY + parentArea.m_scissorHeight; + const uint16_t childBottom = parentArea.m_widgetY + _height; + const uint16_t bottom = IMGUI_MIN(childBottom, parentBottom); + + const uint16_t top = IMGUI_MAX(parentArea.m_widgetY, parentArea.m_scissorY); + + area.m_contentX = parentArea.m_contentX; + area.m_contentY = parentArea.m_widgetY; + area.m_contentWidth = parentArea.m_contentWidth - (SCROLL_AREA_PADDING*3); + area.m_contentHeight = _height; + area.m_widgetX = parentArea.m_widgetX; + area.m_widgetY = parentArea.m_widgetY + (*_scroll); + area.m_widgetW = parentArea.m_widgetW - (SCROLL_AREA_PADDING*3); + + area.m_scissorX = area.m_contentX; + area.m_scissorWidth = area.m_contentWidth; + + area.m_scissorY = top - 1; + area.m_scissorHeight = bottom - top; + area.m_scissorEnabled = true; + + area.m_height = _height; + + area.m_scrollVal = _scroll; + area.m_scrollId = scrollId; + + area.m_inside = inRect(parentArea.m_scissorX + , area.m_scissorY + , parentArea.m_scissorWidth + , area.m_scissorHeight + , false + ); + area.m_didScroll = false; + + parentArea.m_widgetY += (_height + DEFAULT_SPACING); + + if (_enabled) + { + setEnabled(m_areaId); + } + + nvgScissor(m_nvg + , float(area.m_scissorX) + , float(area.m_scissorY-1) + , float(area.m_scissorWidth) + , float(area.m_scissorHeight+1) + ); + + m_insideArea |= area.m_inside; + + return area.m_inside; + } + + void endScroll(int32_t _r) + { + Area& area = getCurrentArea(); + area.m_scissorEnabled = false; + + const int32_t xx = area.m_contentX + area.m_contentWidth - 1; + const int32_t yy = area.m_contentY; + const int32_t width = SCROLL_AREA_PADDING * 2; + const int32_t height = area.m_height; + + const int32_t aa = area.m_contentY+area.m_height; + const int32_t bb = area.m_widgetY-DEFAULT_SPACING; + const int32_t sbot = IMGUI_MAX(aa, bb); + const int32_t stop = area.m_contentY + (*area.m_scrollVal); + const int32_t sh = IMGUI_MAX(1, sbot - stop); // The scrollable area height. + + const uint32_t hid = area.m_scrollId; + const float barHeight = (float)height / (float)sh; + const bool hasScrollBar = (barHeight < 1.0f); + + // Handle mouse scrolling. + if (area.m_inside && !area.m_didScroll && !anyActive() ) + { + if (m_scroll) + { + const int32_t diff = height - sh; + + const int32_t val = *area.m_scrollVal + 20*m_scroll; + const int32_t min = (diff < 0) ? diff : *area.m_scrollVal; + const int32_t max = 0; + const int32_t newVal = IMGUI_CLAMP(val, min, max); + *area.m_scrollVal = newVal; + + if (hasScrollBar) + { + area.m_didScroll = true; + } + } + } + + area.m_inside = false; + + int32_t* scroll = area.m_scrollVal; + + // This must be called here before drawing scroll bars + // so that scissor of parrent area applies. + m_areaId.pop(); + + // Propagate 'didScroll' to parrent area to avoid scrolling multiple areas at once. + Area& parentArea = getCurrentArea(); + parentArea.m_didScroll = (parentArea.m_didScroll || area.m_didScroll); + + // Draw and handle scroll click. + if (hasScrollBar) + { + const float barY = bx::fsaturate( (float)(-(*scroll) ) / (float)sh); + + // Handle scroll bar logic. + const int32_t hx = xx; + const int32_t hy = yy + (int)(barY * height); + const int32_t hw = width; + const int32_t hh = (int)(barHeight * height); + + const int32_t range = height - (hh - 1); + const bool over = inRect(hx, hy, hw, hh); + buttonLogic(hid, over); + if (isActive(hid) ) + { + float uu = (float)(hy - yy) / (float)range; + if (m_wentActive) + { + m_dragY = m_my; + m_dragOrig = uu; + } + + if (m_dragY != m_my) + { + const int32_t diff = height - sh; + + const int32_t drag = m_my - m_dragY; + const float dragFactor = float(sh)/float(height); + + const int32_t val = *scroll - int32_t(drag*dragFactor); + const int32_t min = (diff < 0) ? diff : *scroll; + const int32_t max = 0; + *scroll = IMGUI_CLAMP(val, min, max); + + m_dragY = m_my; + } + } + + // BG + drawRoundedRect( (float)xx + , (float)yy + , (float)width + , (float)height + , (float)_r + , imguiRGBA(0, 0, 0, 196) + ); + + // Bar + if (isActive(hid) ) + { + drawRoundedRect( (float)hx + , (float)hy + , (float)hw + , (float)hh + , (float)_r + , imguiRGBA(255, 196, 0, 196) + ); + } + else + { + drawRoundedRect( (float)hx + , (float)hy + , (float)hw + , (float)hh + , (float)_r + , isHot(hid) ? imguiRGBA(255, 196, 0, 96) : imguiRGBA(255, 255, 255, 64) + ); + } + } + else + { + // Clear active if scroll is selected but not visible any more. + if (isActive(hid)) + { + clearActive(); + } + } + + nvgScissor(m_nvg + , float(parentArea.m_scissorX) + , float(parentArea.m_scissorY-1) + , float(parentArea.m_scissorWidth) + , float(parentArea.m_scissorHeight+1) + ); + } + + bool beginArea(const char* _name, int32_t _x, int32_t _y, int32_t _width, int32_t _height, bool _enabled, int32_t _r) + { + m_areaId.next(); + const uint32_t scrollId = getId(); + + const bool hasTitle = (NULL != _name && '\0' != _name[0]); + const int32_t header = hasTitle ? AREA_HEADER : 0; + + Area& area = getCurrentArea(); + area.m_x = _x; + area.m_y = _y; + area.m_width = _width; + area.m_height = _height; + + area.m_contentX = area.m_x + SCROLL_AREA_PADDING; + area.m_contentY = area.m_y + SCROLL_AREA_PADDING + header; + area.m_contentWidth = area.m_width - SCROLL_AREA_PADDING; + area.m_contentHeight = area.m_height - SCROLL_AREA_PADDING*2 - header; + + area.m_scissorX = area.m_contentX; + area.m_scissorY = area.m_y + SCROLL_AREA_PADDING + header; + area.m_scissorHeight = area.m_height - SCROLL_AREA_PADDING*2 - header; + area.m_scissorWidth = area.m_contentWidth; + area.m_scissorEnabled = false; + + area.m_widgetX = area.m_contentX; + area.m_widgetY = area.m_contentY; + area.m_widgetW = area.m_width - SCROLL_AREA_PADDING*2; + + static int32_t s_zeroScroll = 0; + area.m_scrollVal = &s_zeroScroll; + area.m_scrollId = scrollId; + area.m_inside = inRect(area.m_scissorX, area.m_scissorY, area.m_scissorWidth, area.m_scissorHeight, false); + area.m_didScroll = false; + + if (_enabled) + { + setEnabled(m_areaId); + } + + if (0 == _r) + { + drawRect( (float)_x + , (float)_y + , (float)_width + 0.3f /*border fix for seamlessly joining two scroll areas*/ + , (float)_height + 0.3f /*border fix for seamlessly joining two scroll areas*/ + , imguiRGBA(0, 0, 0, 192) + ); + } + else + { + drawRoundedRect( (float)_x + , (float)_y + , (float)_width + , (float)_height + , (float)_r + , imguiRGBA(0, 0, 0, 192) + ); + } + + if (hasTitle) + { + drawText(_x + 10 + , _y + 18 + , ImguiTextAlign::Left + , _name + , imguiRGBA(255, 255, 255, 128) + ); + } + area.m_scissorEnabled = true; + + nvgBeginFrame(m_nvg, m_viewWidth, m_viewHeight, 1.0f); + nvgScissor(m_nvg + , float(area.m_scissorX) + , float(area.m_scissorY-1) + , float(area.m_scissorWidth) + , float(area.m_scissorHeight+1) + ); + + m_insideArea |= area.m_inside; + return area.m_inside; + } + + void endArea() + { + nvgResetScissor(m_nvg); + nvgEndFrame(m_nvg); + } + + bool button(const char* _text, bool _enabled, ImguiAlign::Enum _align, uint32_t _rgb0, int32_t _r) + { + const uint32_t id = getId(); + + Area& area = getCurrentArea(); + const int32_t yy = area.m_widgetY; + const int32_t height = BUTTON_HEIGHT; + area.m_widgetY += BUTTON_HEIGHT + DEFAULT_SPACING; + + int32_t xx; + int32_t width; + if (ImguiAlign::Left == _align) + { + xx = area.m_contentX + SCROLL_AREA_PADDING; + width = area.m_widgetW; + } + else if (ImguiAlign::LeftIndented == _align + || ImguiAlign::Right == _align) + { + xx = area.m_widgetX; + width = area.m_widgetW-1; //TODO: -1 ! + } + else //if (ImguiAlign::Center == _align + //|| ImguiAlign::CenterIndented == _align). + { + xx = area.m_widgetX; + width = area.m_widgetW - (area.m_widgetX-area.m_scissorX); + } + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, width, height); + const bool res = buttonLogic(id, over); + + const uint32_t rgb0 = _rgb0&0x00ffffff; + + drawRoundedRect( (float)xx + , (float)yy + , (float)width + , (float)height + , (float)_r + , rgb0 | imguiRGBA(0, 0, 0, isActive(id) ? 196 : 96) + ); + + if (enabled) + { + drawText(xx + BUTTON_HEIGHT / 2 + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200) + ); + } + else + { + drawText(xx + BUTTON_HEIGHT / 2 + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , imguiRGBA(128, 128, 128, 200) + ); + } + + return res; + } + + bool item(const char* _text, bool _enabled) + { + const uint32_t id = getId(); + + Area& area = getCurrentArea(); + const int32_t xx = area.m_widgetX; + const int32_t yy = area.m_widgetY; + const int32_t width = area.m_widgetW; + const int32_t height = BUTTON_HEIGHT; + area.m_widgetY += BUTTON_HEIGHT + DEFAULT_SPACING; + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, width, height); + const bool res = buttonLogic(id, over); + + if (isHot(id) ) + { + drawRoundedRect( (float)xx + , (float)yy + , (float)width + , (float)height + , 2.0f + , imguiRGBA(255, 196, 0, isActive(id) ? 196 : 96) + ); + } + + if (enabled) + { + drawText(xx + BUTTON_HEIGHT / 2 + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , imguiRGBA(255, 255, 255, 200) + ); + } + else + { + drawText(xx + BUTTON_HEIGHT / 2 + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , imguiRGBA(128, 128, 128, 200) + ); + } + + return res; + } + + bool check(const char* _text, bool _checked, bool _enabled) + { + const uint32_t id = getId(); + + Area& area = getCurrentArea(); + const int32_t xx = area.m_widgetX; + const int32_t yy = area.m_widgetY; + const int32_t width = area.m_widgetW; + const int32_t height = BUTTON_HEIGHT; + area.m_widgetY += BUTTON_HEIGHT + DEFAULT_SPACING; + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, width, height); + const bool res = buttonLogic(id, over); + + const int32_t cx = xx + BUTTON_HEIGHT / 2 - CHECK_SIZE / 2; + const int32_t cy = yy + BUTTON_HEIGHT / 2 - CHECK_SIZE / 2; + drawRoundedRect( (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) + { + drawRoundedRect( (float)cx + , (float)cy + , (float)CHECK_SIZE + , (float)CHECK_SIZE + , (float)CHECK_SIZE / 2 - 1 + , imguiRGBA(255, 255, 255, isActive(id) ? 255 : 200) + ); + } + else + { + drawRoundedRect( (float)cx + , (float)cy + , (float)CHECK_SIZE + , (float)CHECK_SIZE + , (float)CHECK_SIZE / 2 - 1 + , imguiRGBA(128, 128, 128, 200) + ); + } + } + + if (enabled) + { + drawText(xx + BUTTON_HEIGHT + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200) + ); + } + else + { + drawText(xx + BUTTON_HEIGHT + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , imguiRGBA(128, 128, 128, 200) + ); + } + + return res; + } + + void input(const char* _label, char* _str, uint32_t _len, bool _enabled, ImguiAlign::Enum _align, int32_t _r) + { + const uint32_t id = getId(); + + Area& area = getCurrentArea(); + const int32_t yy = area.m_widgetY; + area.m_widgetY += BUTTON_HEIGHT + DEFAULT_SPACING; + + int32_t xx; + int32_t width; + if (ImguiAlign::Left == _align) + { + xx = area.m_contentX + SCROLL_AREA_PADDING; + width = area.m_widgetW; + } + else if (ImguiAlign::LeftIndented == _align + || ImguiAlign::Right == _align) + { + xx = area.m_widgetX; + width = area.m_widgetW-1; //TODO: -1 ! + } + else //if (ImguiAlign::Center == _align + //|| ImguiAlign::CenterIndented == _align). + { + xx = area.m_widgetX; + width = area.m_widgetW - (area.m_widgetX-area.m_scissorX); + } + + const bool drawLabel = (NULL != _label && _label[0] != '\0'); + + if (drawLabel) + { + drawText(xx + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _label + , imguiRGBA(255, 255, 255, 200) + ); + } + + // Handle input. + if (isActiveInputField(id) ) + { + const size_t cursor = size_t(strlen(_str)); + + if (m_char == 0x08) //backspace + { + _str[cursor-1] = '\0'; + } + else if (m_char == 0x0d || m_char == 0x1b) //enter or escape + { + clearActiveInputField(); + } + else if (cursor < _len-1 + && 0 != m_char) + { + _str[cursor] = m_char; + _str[cursor+1] = '\0'; + } + } + + // Draw input area. + const int32_t height = BUTTON_HEIGHT; + if (drawLabel) + { + uint32_t numVertices = 0; //unused + const int32_t labelWidth = int32_t(getTextLength(m_fonts[m_currentFontIdx].m_cdata, _label, numVertices)); + xx += (labelWidth + 6); + width -= (labelWidth + 6); + } + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, width, height); + inputLogic(id, over); + + drawRoundedRect( (float)xx + , (float)yy + , (float)width + , (float)height + , (float)_r + , isActiveInputField(id)?imguiRGBA(255,196,0,255):imguiRGBA(128,128,128,96) + ); + + if (isActiveInputField(id) ) + { + drawText(xx + 6 + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _str + , imguiRGBA(0, 0, 0, 255) + ); + } + else + { + drawText(xx + 6 + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _str + , isHot(id) ? imguiRGBA(255,196,0,255) : imguiRGBA(255,255,255,255) + ); + } + } + + uint8_t tabs(uint8_t _selected, bool _enabled, ImguiAlign::Enum _align, int32_t _height, int32_t _r, uint8_t _nTabs, uint8_t _nEnabled, va_list _argList) + { + const char* titles[16]; + bool tabEnabled[16]; + const uint8_t tabCount = IMGUI_MIN(_nTabs, 16); + const uint8_t enabledCount = IMGUI_MIN(_nEnabled, 16); + + // Read titles. + { + uint8_t ii = 0; + for (; ii < tabCount; ++ii) + { + const char* str = va_arg(_argList, const char*); + titles[ii] = str; + } + for (; ii < _nTabs; ++ii) + { + const char* str = va_arg(_argList, const char*); + BX_UNUSED(str); + } + } + + // Read enabled tabs. + { + uint8_t ii = 0; + for (; ii < enabledCount; ++ii) + { + const bool enabled = (0 != va_arg(_argList, int) ); + tabEnabled[ii] = enabled; + } + for (; ii < _nEnabled; ++ii) + { + const int enabled = va_arg(_argList, int); + BX_UNUSED(enabled); + } + for (; ii < _nTabs; ++ii) + { + tabEnabled[ii] = true; + } + } + + Area& area = getCurrentArea(); + const int32_t yy = area.m_widgetY; + area.m_widgetY += _height + DEFAULT_SPACING; + + int32_t xx; + int32_t width; + if (ImguiAlign::Left == _align) + { + xx = area.m_contentX + SCROLL_AREA_PADDING; + width = area.m_widgetW; + } + else if (ImguiAlign::LeftIndented == _align + || ImguiAlign::Right == _align) + { + xx = area.m_widgetX; + width = area.m_widgetW-1; //TODO: -1 ! + } + else //if (ImguiAlign::Center == _align + //|| ImguiAlign::CenterIndented == _align). + { + xx = area.m_widgetX; + width = area.m_widgetW - (area.m_widgetX-area.m_scissorX); + } + + uint8_t selected = _selected; + const int32_t tabWidth = width / tabCount; + const int32_t tabWidthHalf = width / (tabCount*2); + const int32_t textY = yy + _height/2 + int32_t(m_fonts[m_currentFontIdx].m_size)/2 - 2; + + drawRoundedRect( (float)xx + , (float)yy + , (float)width + , (float)_height + , (float)_r + , _enabled?imguiRGBA(128,128,128,96):imguiRGBA(128,128,128,64) + ); + + for (uint8_t ii = 0; ii < tabCount; ++ii) + { + const uint32_t id = getId(); + + int32_t buttonX = xx + ii*width/tabCount; + int32_t textX = buttonX + tabWidthHalf; + + const bool enabled = _enabled && tabEnabled[ii] && isEnabled(m_areaId); + const bool over = enabled && inRect(buttonX, yy, tabWidth, _height); + const bool res = buttonLogic(id, over); + + const uint32_t textColor = (ii == selected) + ? (enabled ? imguiRGBA(0,0,0,255) : imguiRGBA(255,255,255,100) ) + : (isHot(id) ? imguiRGBA(255,196,0,enabled?255:100) : imguiRGBA(255,255,255,enabled?200:100) ) + ; + + if (ii == selected) + { + drawRoundedRect( (float)buttonX + , (float)yy + , (float)tabWidth + , (float)_height + , (float)_r + , enabled?imguiRGBA(255,196,0,200):imguiRGBA(128,128,128,32) + ); + } + else if (isActive(id)) + { + drawRoundedRect( (float)buttonX + , (float)yy + , (float)tabWidth + , (float)_height + , (float)_r + , imguiRGBA(128,128,128,196) + ); + } + + drawText(textX + , textY + , ImguiTextAlign::Center + , titles[ii] + , textColor + ); + + if (res) + { + selected = ii; + } + } + + return selected; + } + + bool image(bgfx::TextureHandle _image, float _lod, int32_t _width, int32_t _height, ImguiAlign::Enum _align, bool _enabled, bool _originBottomLeft) + { + const uint32_t id = getId(); + Area& area = getCurrentArea(); + + int32_t xx; + if (ImguiAlign::Left == _align) + { + xx = area.m_contentX + SCROLL_AREA_PADDING; + } + else if (ImguiAlign::LeftIndented == _align) + { + xx = area.m_widgetX; + } + else if (ImguiAlign::Center == _align) + { + xx = area.m_contentX + (area.m_widgetW-_width)/2; + } + else if (ImguiAlign::CenterIndented == _align) + { + xx = (area.m_widgetX + area.m_widgetW + area.m_contentX - _width)/2; + } + else //if (ImguiAlign::Right == _align). + { + xx = area.m_contentX + area.m_widgetW - _width; + } + + const int32_t yy = area.m_widgetY; + area.m_widgetY += _height + DEFAULT_SPACING; + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, _width, _height); + const bool res = buttonLogic(id, over); + + const float lodEnabled[4] = { _lod, float(enabled), 0.0f, 0.0f }; + + screenQuad(xx, yy, _width, _height, _originBottomLeft); + bgfx::setUniform(u_imageLodEnabled, lodEnabled); + bgfx::setTexture(0, s_texColor, bgfx::isValid(_image) ? _image : m_missingTexture); + bgfx::setState(BGFX_STATE_RGB_WRITE + |BGFX_STATE_ALPHA_WRITE + |BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA) + ); + bgfx::setProgram(m_imageProgram); + setCurrentScissor(); + bgfx::submit(m_view); + + return res; + } + + bool image(bgfx::TextureHandle _image, float _lod, float _width, float _aspect, ImguiAlign::Enum _align, bool _enabled, bool _originBottomLeft) + { + const float width = _width*float(getCurrentArea().m_widgetW); + const float height = width/_aspect; + + return image(_image, _lod, int32_t(width), int32_t(height), _align, _enabled, _originBottomLeft); + } + + bool imageChannel(bgfx::TextureHandle _image, uint8_t _channel, float _lod, int32_t _width, int32_t _height, ImguiAlign::Enum _align, bool _enabled) + { + BX_CHECK(_channel < 4, "Channel param must be from 0 to 3!"); + + const uint32_t id = getId(); + Area& area = getCurrentArea(); + + int32_t xx; + if (ImguiAlign::Left == _align) + { + xx = area.m_contentX + SCROLL_AREA_PADDING; + } + else if (ImguiAlign::LeftIndented == _align) + { + xx = area.m_widgetX; + } + else if (ImguiAlign::Center == _align) + { + xx = area.m_contentX + (area.m_widgetW-_width)/2; + } + else if (ImguiAlign::CenterIndented == _align) + { + xx = (area.m_widgetX + area.m_widgetW + area.m_contentX - _width)/2; + } + else //if (ImguiAlign::Right == _align). + { + xx = area.m_contentX + area.m_widgetW - _width; + } + + const int32_t yy = area.m_widgetY; + area.m_widgetY += _height + DEFAULT_SPACING; + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, _width, _height); + const bool res = buttonLogic(id, over); + + screenQuad(xx, yy, _width, _height); + + const float lodEnabled[4] = { _lod, float(enabled), 0.0f, 0.0f }; + bgfx::setUniform(u_imageLodEnabled, lodEnabled); + + float swizz[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; + swizz[_channel] = 1.0f; + bgfx::setUniform(u_imageSwizzle, swizz); + + bgfx::setTexture(0, s_texColor, bgfx::isValid(_image) ? _image : m_missingTexture); + bgfx::setState(BGFX_STATE_RGB_WRITE + |BGFX_STATE_ALPHA_WRITE + |BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA) + ); + bgfx::setProgram(m_imageSwizzProgram); + setCurrentScissor(); + bgfx::submit(m_view); + + return res; + } + + bool imageChannel(bgfx::TextureHandle _image, uint8_t _channel, float _lod, float _width, float _aspect, ImguiAlign::Enum _align, bool _enabled) + { + const float width = _width*float(getCurrentArea().m_widgetW); + const float height = width/_aspect; + + return imageChannel(_image, _channel, _lod, int32_t(width), int32_t(height), _align, _enabled); + } + + bool cubeMap(bgfx::TextureHandle _cubemap, float _lod, bool _cross, ImguiAlign::Enum _align, bool _enabled) + { + const uint32_t numVertices = 14; + const uint32_t numIndices = 36; + if (bgfx::checkAvailTransientBuffers(numVertices, PosNormalVertex::ms_decl, numIndices) ) + { + bgfx::TransientVertexBuffer tvb; + bgfx::allocTransientVertexBuffer(&tvb, numVertices, PosNormalVertex::ms_decl); + + bgfx::TransientIndexBuffer tib; + bgfx::allocTransientIndexBuffer(&tib, numIndices); + + PosNormalVertex* vertex = (PosNormalVertex*)tvb.data; + uint16_t* indices = (uint16_t*)tib.data; + + if (_cross) + { + vertex->set(0.0f, 0.5f, 0.0f, -1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(0.0f, 1.0f, 0.0f, -1.0f, -1.0f, -1.0f); ++vertex; + + vertex->set(0.5f, 0.0f, 0.0f, -1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(0.5f, 0.5f, 0.0f, -1.0f, 1.0f, 1.0f); ++vertex; + vertex->set(0.5f, 1.0f, 0.0f, -1.0f, -1.0f, 1.0f); ++vertex; + vertex->set(0.5f, 1.5f, 0.0f, -1.0f, -1.0f, -1.0f); ++vertex; + + vertex->set(1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(1.0f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f); ++vertex; + vertex->set(1.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f); ++vertex; + vertex->set(1.0f, 1.5f, 0.0f, 1.0f, -1.0f, -1.0f); ++vertex; + + vertex->set(1.5f, 0.5f, 0.0f, 1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(1.5f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f); ++vertex; + + vertex->set(2.0f, 0.5f, 0.0f, -1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(2.0f, 1.0f, 0.0f, -1.0f, -1.0f, -1.0f); ++vertex; + + indices += addQuad(indices, 0, 3, 4, 1); + indices += addQuad(indices, 2, 6, 7, 3); + indices += addQuad(indices, 3, 7, 8, 4); + indices += addQuad(indices, 4, 8, 9, 5); + indices += addQuad(indices, 7, 10, 11, 8); + indices += addQuad(indices, 10, 12, 13, 11); + } + else + { + vertex->set(0.0f, 0.25f, 0.0f, -1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(0.0f, 0.75f, 0.0f, -1.0f, -1.0f, -1.0f); ++vertex; + + vertex->set(0.5f, 0.00f, 0.0f, -1.0f, 1.0f, 1.0f); ++vertex; + vertex->set(0.5f, 0.50f, 0.0f, -1.0f, -1.0f, 1.0f); ++vertex; + vertex->set(0.5f, 1.00f, 0.0f, 1.0f, -1.0f, -1.0f); ++vertex; + + vertex->set(1.0f, 0.25f, 0.0f, 1.0f, 1.0f, 1.0f); ++vertex; + vertex->set(1.0f, 0.75f, 0.0f, 1.0f, -1.0f, 1.0f); ++vertex; + + vertex->set(1.0f, 0.25f, 0.0f, 1.0f, 1.0f, 1.0f); ++vertex; + vertex->set(1.0f, 0.75f, 0.0f, 1.0f, -1.0f, 1.0f); ++vertex; + + vertex->set(1.5f, 0.00f, 0.0f, -1.0f, 1.0f, 1.0f); ++vertex; + vertex->set(1.5f, 0.50f, 0.0f, 1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(1.5f, 1.00f, 0.0f, 1.0f, -1.0f, -1.0f); ++vertex; + + vertex->set(2.0f, 0.25f, 0.0f, -1.0f, 1.0f, -1.0f); ++vertex; + vertex->set(2.0f, 0.75f, 0.0f, -1.0f, -1.0f, -1.0f); ++vertex; + + indices += addQuad(indices, 0, 2, 3, 1); + indices += addQuad(indices, 1, 3, 6, 4); + indices += addQuad(indices, 2, 5, 6, 3); + indices += addQuad(indices, 7, 9, 12, 10); + indices += addQuad(indices, 7, 10, 11, 8); + indices += addQuad(indices, 10, 12, 13, 11); + } + + const uint32_t id = getId(); + + Area& area = getCurrentArea(); + int32_t xx; + int32_t width; + if (ImguiAlign::Left == _align) + { + xx = area.m_contentX + SCROLL_AREA_PADDING; + width = area.m_widgetW; + } + else if (ImguiAlign::LeftIndented == _align + || ImguiAlign::Right == _align) + { + xx = area.m_widgetX; + width = area.m_widgetW; + } + else //if (ImguiAlign::Center == _align + //|| ImguiAlign::CenterIndented == _align). + { + xx = area.m_widgetX; + width = area.m_widgetW - (area.m_widgetX-area.m_scissorX); + } + + const uint32_t height = _cross ? (width*3)/4 : (width/2); + const int32_t yy = area.m_widgetY; + area.m_widgetY += height + DEFAULT_SPACING; + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, width, height); + const bool res = buttonLogic(id, over); + + const float scale = float(width/2)+0.25f; + + float mtx[16]; + bx::mtxSRT(mtx, scale, scale, 1.0f, 0.0f, 0.0f, 0.0f, float(xx), float(yy), 0.0f); + + const float lodEnabled[4] = { _lod, float(enabled), 0.0f, 0.0f }; + bgfx::setUniform(u_imageLodEnabled, lodEnabled); + + bgfx::setTransform(mtx); + bgfx::setTexture(0, s_texColor, _cubemap); + bgfx::setProgram(m_cubeMapProgram); + bgfx::setVertexBuffer(&tvb); + bgfx::setIndexBuffer(&tib); + bgfx::setState(BGFX_STATE_RGB_WRITE + |BGFX_STATE_ALPHA_WRITE + |BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA) + ); + setCurrentScissor(); + bgfx::submit(m_view); + + return res; + } + + return false; + } + + bool collapse(const char* _text, const char* _subtext, bool _checked, bool _enabled) + { + const uint32_t id = getId(); + + Area& area = getCurrentArea(); + const int32_t xx = area.m_widgetX; + const int32_t yy = area.m_widgetY; + const int32_t width = area.m_widgetW; + const int32_t height = BUTTON_HEIGHT; + area.m_widgetY += BUTTON_HEIGHT + DEFAULT_SPACING; + + const int32_t cx = xx + BUTTON_HEIGHT/2 - CHECK_SIZE/2; + const int32_t cy = yy + BUTTON_HEIGHT/2 - CHECK_SIZE/2 + DEFAULT_SPACING/2; + + const int32_t textY = yy + BUTTON_HEIGHT/2 + TEXT_HEIGHT/2 + DEFAULT_SPACING/2; + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx, yy, width, height); + const bool res = buttonLogic(id, over); + + if (_checked) + { + drawTriangle(cx + , cy + , CHECK_SIZE + , CHECK_SIZE + , TriangleOrientation::Up + , imguiRGBA(255, 255, 255, isActive(id) ? 255 : 200) + ); + } + else + { + drawTriangle(cx-1 // With -1 is more aesthetically pleasing. + , cy + , CHECK_SIZE + , CHECK_SIZE + , TriangleOrientation::Right + , imguiRGBA(255, 255, 255, isActive(id) ? 255 : 200) + ); + } + + if (enabled) + { + drawText(xx + BUTTON_HEIGHT + , textY + , ImguiTextAlign::Left + , _text + , isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200) + ); + } + else + { + drawText(xx + BUTTON_HEIGHT + , textY + , ImguiTextAlign::Left + , _text + , imguiRGBA(128, 128, 128, 200) + ); + } + + if (_subtext) + { + drawText(xx + width - BUTTON_HEIGHT / 2 + , textY + , ImguiTextAlign::Right + , _subtext + , imguiRGBA(255, 255, 255, 128) + ); + } + + return res; + } + + bool borderButton(ImguiBorder::Enum _border, bool _checked, bool _enabled) + { + // Since border button isn't part of any area, just use this custom/unique areaId. + const uint16_t areaId = UINT16_MAX-1; + const uint32_t id = (areaId << 16) | m_widgetId++; + updatePresence(id); + + const int32_t triSize = 12; + const int32_t borderSize = 15; + + int32_t xx; + int32_t yy; + int32_t width; + int32_t height; + int32_t triX; + int32_t triY; + TriangleOrientation::Enum orientation; + + if (ImguiBorder::Left == _border) + { + xx = -borderSize; + yy = -1; + width = 2*borderSize+1; + height = m_viewHeight; + triX = 0; + triY = (m_viewHeight-triSize)/2; + orientation = _checked ? TriangleOrientation::Left : TriangleOrientation::Right; + } + else if (ImguiBorder::Right == _border) + { + xx = m_viewWidth - borderSize; + yy = -1; + width = 2*borderSize+1; + height = m_viewHeight; + triX = m_viewWidth - triSize - 2; + triY = (m_viewHeight-width)/2; + orientation = _checked ? TriangleOrientation::Right : TriangleOrientation::Left; + } + else if (ImguiBorder::Top == _border) + { + xx = 0; + yy = -borderSize; + width = m_viewWidth; + height = 2*borderSize; + triX = (m_viewWidth-triSize)/2; + triY = 0; + orientation = _checked ? TriangleOrientation::Up : TriangleOrientation::Down; + } + else //if (ImguiBorder::Bottom == _border). + { + xx = 0; + yy = m_viewHeight - borderSize; + width = m_viewWidth; + height = 2*borderSize; + triX = (m_viewWidth-triSize)/2; + triY = m_viewHeight-triSize; + orientation = _checked ? TriangleOrientation::Down : TriangleOrientation::Up; + } + + const bool over = _enabled && inRect(xx, yy, width, height, false); + const bool res = buttonLogic(id, over); + + drawRect( (float)xx + , (float)yy + , (float)width + , (float)height + , isActive(id) ? imguiRGBA(23, 23, 23, 192) : imguiRGBA(0, 0, 0, 222) + ); + + drawTriangle( triX + , triY + , triSize + , triSize + , orientation + , isHot(id) ? imguiRGBA(255, 196, 0, 222) : imguiRGBA(255, 255, 255, 192) + ); + + return res; + } + + void labelVargs(const char* _format, va_list _argList, uint32_t _rgba) + { + char temp[8192]; + char* out = temp; + int32_t len = bx::vsnprintf(out, sizeof(temp), _format, _argList); + if ( (int32_t)sizeof(temp) < len) + { + out = (char*)alloca(len+1); + len = bx::vsnprintf(out, len, _format, _argList); + } + out[len] = '\0'; + + Area& area = getCurrentArea(); + const int32_t xx = area.m_widgetX; + const int32_t yy = area.m_widgetY; + area.m_widgetY += BUTTON_HEIGHT; + drawText(xx + , yy + BUTTON_HEIGHT/2 + TEXT_HEIGHT/2 + , ImguiTextAlign::Left + , out + , _rgba + ); + } + + void value(const char* _text) + { + Area& area = getCurrentArea(); + const int32_t xx = area.m_widgetX; + const int32_t yy = area.m_widgetY; + const int32_t ww = area.m_widgetW; + area.m_widgetY += BUTTON_HEIGHT; + + drawText(xx + ww - BUTTON_HEIGHT / 2 + , yy + BUTTON_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Right + , _text + , imguiRGBA(255, 255, 255, 200) + ); + } + + bool slider(const char* _text, float& _val, float _vmin, float _vmax, float _vinc, bool _enabled, ImguiAlign::Enum _align) + { + const uint32_t id = getId(); + + Area& area = getCurrentArea(); + const int32_t yy = area.m_widgetY; + const int32_t height = SLIDER_HEIGHT; + area.m_widgetY += SLIDER_HEIGHT + DEFAULT_SPACING; + + int32_t xx; + int32_t width; + if (ImguiAlign::Left == _align) + { + xx = area.m_contentX + SCROLL_AREA_PADDING; + width = area.m_widgetW; + } + else if (ImguiAlign::LeftIndented == _align + || ImguiAlign::Right == _align) + { + xx = area.m_widgetX; + width = area.m_widgetW; + } + else //if (ImguiAlign::Center == _align + //|| ImguiAlign::CenterIndented == _align). + { + xx = area.m_widgetX; + width = area.m_widgetW - (area.m_widgetX-area.m_scissorX); + } + + drawRoundedRect( (float)xx, (float)yy, (float)width, (float)height, 4.0f, imguiRGBA(0, 0, 0, 128) ); + + const int32_t range = width - SLIDER_MARKER_WIDTH; + + float uu = bx::fsaturate( (_val - _vmin) / (_vmax - _vmin) ); + int32_t m = (int)(uu * range); + bool valChanged = false; + + const bool enabled = _enabled && isEnabled(m_areaId); + const bool over = enabled && inRect(xx + m, yy, SLIDER_MARKER_WIDTH, SLIDER_HEIGHT); + const bool res = buttonLogic(id, over); + + if (isActive(id) ) + { + if (m_wentActive) + { + m_dragX = m_mx; + m_dragOrig = uu; + } + + if (m_dragX != m_mx) + { + uu = bx::fsaturate(m_dragOrig + (float)(m_mx - m_dragX) / (float)range); + + _val = _vmin + uu * (_vmax - _vmin); + _val = floorf(_val / _vinc + 0.5f) * _vinc; // Snap to vinc + m = (int)(uu * range); + valChanged = true; + } + } + + if (isActive(id) ) + { + drawRoundedRect( (float)(xx + m) + , (float)yy + , (float)SLIDER_MARKER_WIDTH + , (float)SLIDER_HEIGHT + , 4.0f + , imguiRGBA(255, 255, 255, 255) + ); + } + else + { + drawRoundedRect( (float)(xx + m) + , (float)yy + , (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'. + int32_t digits = (int)(ceilf(log10f(_vinc) ) ); + char fmt[16]; + bx::snprintf(fmt, 16, "%%.%df", digits >= 0 ? 0 : -digits); + char msg[128]; + bx::snprintf(msg, 128, fmt, _val); + + if (enabled) + { + drawText(xx + SLIDER_HEIGHT / 2 + , yy + SLIDER_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200) + ); + + drawText(xx + width - SLIDER_HEIGHT / 2 + , yy + SLIDER_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Right + , msg + , isHot(id) ? imguiRGBA(255, 196, 0, 255) : imguiRGBA(255, 255, 255, 200) + ); + } + else + { + drawText(xx + SLIDER_HEIGHT / 2 + , yy + SLIDER_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Left + , _text + , imguiRGBA(128, 128, 128, 200) + ); + + drawText(xx + width - SLIDER_HEIGHT / 2 + , yy + SLIDER_HEIGHT / 2 + TEXT_HEIGHT / 2 + , ImguiTextAlign::Right + , msg + , imguiRGBA(128, 128, 128, 200) + ); + } + + return res || valChanged; + } + + void indent(uint16_t _width) + { + Area& area = getCurrentArea(); + area.m_widgetX += _width; + area.m_widgetW -= _width; + } + + void unindent(uint16_t _width) + { + Area& area = getCurrentArea(); + area.m_widgetX -= _width; + area.m_widgetW += _width; + } + + void separator(uint16_t _height) + { + Area& area = getCurrentArea(); + area.m_widgetY += _height; + } + + void separatorLine(uint16_t _height) + { + Area& area = getCurrentArea(); + const int32_t rectWidth = area.m_widgetW; + const int32_t rectHeight = 1; + const int32_t xx = area.m_widgetX; + const int32_t yy = area.m_widgetY + _height/2 - rectHeight; + area.m_widgetY += _height; + + drawRect( (float)xx + , (float)yy + , (float)rectWidth + , (float)rectHeight + , imguiRGBA(255, 255, 255, 32) + ); + } + + void drawPolygon(const float* _coords, uint32_t _numCoords, float _r, uint32_t _abgr) + { + _numCoords = bx::uint32_min(_numCoords, MAX_TEMP_COORDS); + + for (uint32_t ii = 0, jj = _numCoords - 1; ii < _numCoords; jj = ii++) + { + const float* v0 = &_coords[jj * 2]; + const float* v1 = &_coords[ii * 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; + } + + m_tempNormals[jj * 2 + 0] = dy; + m_tempNormals[jj * 2 + 1] = -dx; + } + + for (uint32_t ii = 0, jj = _numCoords - 1; ii < _numCoords; jj = ii++) + { + float dlx0 = m_tempNormals[jj * 2 + 0]; + float dly0 = m_tempNormals[jj * 2 + 1]; + float dlx1 = m_tempNormals[ii * 2 + 0]; + float dly1 = m_tempNormals[ii * 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; + } + + m_tempCoords[ii * 2 + 0] = _coords[ii * 2 + 0] + dmx * _r; + m_tempCoords[ii * 2 + 1] = _coords[ii * 2 + 1] + dmy * _r; + } + + uint32_t numVertices = _numCoords*6 + (_numCoords-2)*3; + if (bgfx::checkAvailTransientVertexBuffer(numVertices, PosColorVertex::ms_decl) ) + { + bgfx::TransientVertexBuffer tvb; + bgfx::allocTransientVertexBuffer(&tvb, numVertices, PosColorVertex::ms_decl); + uint32_t trans = _abgr&0xffffff; + + PosColorVertex* vertex = (PosColorVertex*)tvb.data; + for (uint32_t ii = 0, jj = _numCoords-1; ii < _numCoords; jj = ii++) + { + vertex->m_x = _coords[ii*2+0]; + vertex->m_y = _coords[ii*2+1]; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = _coords[jj*2+0]; + vertex->m_y = _coords[jj*2+1]; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = m_tempCoords[jj*2+0]; + vertex->m_y = m_tempCoords[jj*2+1]; + vertex->m_abgr = trans; + ++vertex; + + vertex->m_x = m_tempCoords[jj*2+0]; + vertex->m_y = m_tempCoords[jj*2+1]; + vertex->m_abgr = trans; + ++vertex; + + vertex->m_x = m_tempCoords[ii*2+0]; + vertex->m_y = m_tempCoords[ii*2+1]; + vertex->m_abgr = trans; + ++vertex; + + vertex->m_x = _coords[ii*2+0]; + vertex->m_y = _coords[ii*2+1]; + vertex->m_abgr = _abgr; + ++vertex; + } + + for (uint32_t ii = 2; ii < _numCoords; ++ii) + { + vertex->m_x = _coords[0]; + vertex->m_y = _coords[1]; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = _coords[(ii-1)*2+0]; + vertex->m_y = _coords[(ii-1)*2+1]; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = _coords[ii*2+0]; + vertex->m_y = _coords[ii*2+1]; + vertex->m_abgr = _abgr; + ++vertex; + } + + bgfx::setVertexBuffer(&tvb); + bgfx::setState(0 + | BGFX_STATE_RGB_WRITE + | BGFX_STATE_ALPHA_WRITE + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA) + ); + bgfx::setProgram(m_colorProgram); + setCurrentScissor(); + bgfx::submit(m_view); + } + } + + void drawRect(float _x, float _y, float _w, float _h, uint32_t _argb, float _fth = 1.0f) + { + 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, _argb); + } + + void drawRoundedRect(float _x, float _y, float _w, float _h, float _r, uint32_t _argb, float _fth = 1.0f) + { + if (0.0f == _r) + { + return drawRect(_x, _y, _w, _h, _argb, _fth); + } + + const uint32_t num = NUM_CIRCLE_VERTS / 4; + const float* cverts = m_circleVerts; + float verts[(num + 1) * 4 * 2]; + float* vv = verts; + + for (uint32_t ii = 0; ii <= num; ++ii) + { + *vv++ = _x + _w - _r + cverts[ii * 2] * _r; + *vv++ = _y + _h - _r + cverts[ii * 2 + 1] * _r; + } + + for (uint32_t ii = num; ii <= num * 2; ++ii) + { + *vv++ = _x + _r + cverts[ii * 2] * _r; + *vv++ = _y + _h - _r + cverts[ii * 2 + 1] * _r; + } + + for (uint32_t ii = num * 2; ii <= num * 3; ++ii) + { + *vv++ = _x + _r + cverts[ii * 2] * _r; + *vv++ = _y + _r + cverts[ii * 2 + 1] * _r; + } + + for (uint32_t ii = num * 3; ii < num * 4; ++ii) + { + *vv++ = _x + _w - _r + cverts[ii * 2] * _r; + *vv++ = _y + _r + cverts[ii * 2 + 1] * _r; + } + + *vv++ = _x + _w - _r + cverts[0] * _r; + *vv++ = _y + _r + cverts[1] * _r; + + drawPolygon(verts, (num + 1) * 4, _fth, _argb); + } + + void drawLine(float _x0, float _y0, float _x1, float _y1, float _r, uint32_t _abgr, float _fth = 1.0f) + { + 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, _abgr); + } + + struct TriangleOrientation + { + enum Enum + { + Left, + Right, + Up, + Down, + }; + }; + + void drawTriangle(int32_t _x, int32_t _y, int32_t _width, int32_t _height, TriangleOrientation::Enum _orientation, uint32_t _abgr) + { + if (TriangleOrientation::Left == _orientation) + { + const float verts[3 * 2] = + { + (float)_x + 0.5f + (float)_width * 1.0f, (float)_y + 0.5f, + (float)_x + 0.5f, (float)_y + 0.5f + (float)_height / 2.0f - 0.5f, + (float)_x + 0.5f + (float)_width * 1.0f, (float)_y + 0.5f + (float)_height - 1.0f, + }; + + drawPolygon(verts, 3, 1.0f, _abgr); + } + else if (TriangleOrientation::Right == _orientation) + { + const float verts[3 * 2] = + { + (float)_x + 0.5f, (float)_y + 0.5f, + (float)_x + 0.5f + (float)_width * 1.0f, (float)_y + 0.5f + (float)_height / 2.0f - 0.5f, + (float)_x + 0.5f, (float)_y + 0.5f + (float)_height - 1.0f, + }; + + drawPolygon(verts, 3, 1.0f, _abgr); + } + else if (TriangleOrientation::Up == _orientation) + { + const float verts[3 * 2] = + { + (float)_x + 0.5f, (float)_y + 0.5f + (float)_height - 1.0f, + (float)_x + 0.5f + (float)_width / 2.0f - 0.5f, (float)_y + 0.5f, + (float)_x + 0.5f + (float)_width - 1.0f, (float)_y + 0.5f + (float)_height - 1.0f, + }; + + drawPolygon(verts, 3, 1.0f, _abgr); + } + else //if (TriangleOrientation::Down == _orientation). + { + const float verts[3 * 2] = + { + (float)_x + 0.5f, (float)_y + 0.5f, + (float)_x + 0.5f + (float)_width / 2.0f - 0.5f, (float)_y + 0.5f + (float)_height - 1.0f, + (float)_x + 0.5f + (float)_width - 1.0f, (float)_y + 0.5f, + }; + + drawPolygon(verts, 3, 1.0f, _abgr); + } + } + +#if !USE_NANOVG_FONT + void getBakedQuad(stbtt_bakedchar* _chardata, int32_t char_index, float* _xpos, float* _ypos, stbtt_aligned_quad* _quad) + { + stbtt_bakedchar* b = _chardata + char_index; + int32_t round_x = STBTT_ifloor(*_xpos + b->xoff); + int32_t round_y = STBTT_ifloor(*_ypos + b->yoff); + + _quad->x0 = (float)round_x; + _quad->y0 = (float)round_y; + _quad->x1 = (float)round_x + b->x1 - b->x0; + _quad->y1 = (float)round_y + b->y1 - b->y0; + + _quad->s0 = (b->x0 + m_halfTexel) * m_invTextureWidth; + _quad->t0 = (b->y0 + m_halfTexel) * m_invTextureWidth; + _quad->s1 = (b->x1 + m_halfTexel) * m_invTextureHeight; + _quad->t1 = (b->y1 + m_halfTexel) * m_invTextureHeight; + + *_xpos += b->xadvance; + } +#endif // !USE_NANOVG_FONT + + void drawText(int32_t _x, int32_t _y, ImguiTextAlign::Enum _align, const char* _text, uint32_t _abgr) + { + drawText( (float)_x, (float)_y, _text, _align, _abgr); + } + + void drawText(float _x, float _y, const char* _text, ImguiTextAlign::Enum _align, uint32_t _abgr) + { + if (NULL == _text + || '\0' == _text[0]) + { + return; + } + +#if USE_NANOVG_FONT + static uint32_t textAlign[ImguiTextAlign::Count] = + { + NVG_ALIGN_LEFT, + NVG_ALIGN_CENTER, + NVG_ALIGN_RIGHT, + }; + + nvgTextAlign(m_nvg, textAlign[_align]); + + nvgFontBlur(m_nvg, 0.0f); + nvgFillColor(m_nvg, nvgRGBAu(_abgr) ); + nvgText(m_nvg, _x, _y, _text, NULL); +#else + uint32_t numVertices = 0; + if (_align == ImguiTextAlign::Center) + { + _x -= getTextLength(m_fonts[m_currentFontIdx].m_cdata, _text, numVertices) / 2; + } + else if (_align == ImguiTextAlign::Right) + { + _x -= getTextLength(m_fonts[m_currentFontIdx].m_cdata, _text, numVertices); + } + else // just count vertices + { + getTextLength(m_fonts[m_currentFontIdx].m_cdata, _text, numVertices); + } + + if (bgfx::checkAvailTransientVertexBuffer(numVertices, PosColorUvVertex::ms_decl) ) + { + bgfx::TransientVertexBuffer tvb; + bgfx::allocTransientVertexBuffer(&tvb, numVertices, PosColorUvVertex::ms_decl); + + PosColorUvVertex* vertex = (PosColorUvVertex*)tvb.data; + + const float ox = _x; + + while (*_text) + { + int32_t ch = (uint8_t)*_text; + if (ch == '\t') + { + for (int32_t i = 0; i < 4; ++i) + { + if (_x < s_tabStops[i] + ox) + { + _x = s_tabStops[i] + ox; + break; + } + } + } + else if (ch >= ' ' + && ch < 128) + { + stbtt_aligned_quad quad; + getBakedQuad(m_fonts[m_currentFontIdx].m_cdata, ch - 32, &_x, &_y, &quad); + + vertex->m_x = quad.x0; + vertex->m_y = quad.y0; + vertex->m_u = quad.s0; + vertex->m_v = quad.t0; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = quad.x1; + vertex->m_y = quad.y1; + vertex->m_u = quad.s1; + vertex->m_v = quad.t1; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = quad.x1; + vertex->m_y = quad.y0; + vertex->m_u = quad.s1; + vertex->m_v = quad.t0; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = quad.x0; + vertex->m_y = quad.y0; + vertex->m_u = quad.s0; + vertex->m_v = quad.t0; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = quad.x0; + vertex->m_y = quad.y1; + vertex->m_u = quad.s0; + vertex->m_v = quad.t1; + vertex->m_abgr = _abgr; + ++vertex; + + vertex->m_x = quad.x1; + vertex->m_y = quad.y1; + vertex->m_u = quad.s1; + vertex->m_v = quad.t1; + vertex->m_abgr = _abgr; + ++vertex; + } + + ++_text; + } + + bgfx::setTexture(0, s_texColor, m_fonts[m_currentFontIdx].m_texture); + bgfx::setVertexBuffer(&tvb); + bgfx::setState(0 + | BGFX_STATE_RGB_WRITE + | BGFX_STATE_ALPHA_WRITE + | BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA) + ); + bgfx::setProgram(m_textureProgram); + setCurrentScissor(); + bgfx::submit(m_view); + } +#endif // USE_NANOVG_FONT + } + + void screenQuad(int32_t _x, int32_t _y, int32_t _width, uint32_t _height, bool _originBottomLeft = false) + { + if (bgfx::checkAvailTransientVertexBuffer(6, PosUvVertex::ms_decl) ) + { + bgfx::TransientVertexBuffer vb; + bgfx::allocTransientVertexBuffer(&vb, 6, PosUvVertex::ms_decl); + PosUvVertex* vertex = (PosUvVertex*)vb.data; + + const float widthf = float(_width); + const float heightf = float(_height); + + const float minx = float(_x); + const float miny = float(_y); + const float maxx = minx+widthf; + const float maxy = miny+heightf; + + const float texelHalfW = m_halfTexel/widthf; + const float texelHalfH = m_halfTexel/heightf; + const float minu = texelHalfW; + const float maxu = 1.0f - texelHalfW; + const float minv = _originBottomLeft ? texelHalfH+1.0f : texelHalfH ; + const float maxv = _originBottomLeft ? texelHalfH : texelHalfH+1.0f; + + vertex[0].m_x = minx; + vertex[0].m_y = miny; + vertex[0].m_u = minu; + vertex[0].m_v = minv; + + vertex[1].m_x = maxx; + vertex[1].m_y = miny; + vertex[1].m_u = maxu; + vertex[1].m_v = minv; + + vertex[2].m_x = maxx; + vertex[2].m_y = maxy; + vertex[2].m_u = maxu; + vertex[2].m_v = maxv; + + vertex[3].m_x = maxx; + vertex[3].m_y = maxy; + vertex[3].m_u = maxu; + vertex[3].m_v = maxv; + + vertex[4].m_x = minx; + vertex[4].m_y = maxy; + vertex[4].m_u = minu; + vertex[4].m_v = maxv; + + vertex[5].m_x = minx; + vertex[5].m_y = miny; + vertex[5].m_u = minu; + vertex[5].m_v = minv; + + bgfx::setVertexBuffer(&vb); + } + } + + void colorWheelWidget(float _rgb[3], bool _respectIndentation, float _size, bool _enabled) + { + const uint32_t wheelId = getId(); + const uint32_t triangleId = getId(); + + Area& area = getCurrentArea(); + + const float areaX = float(_respectIndentation ? area.m_widgetX : area.m_contentX); + const float areaW = float(_respectIndentation ? area.m_widgetW : area.m_contentWidth); + + const float width = areaW*_size; + const float xx = areaX + areaW*0.5f; + const float yy = float(area.m_widgetY) + width*0.5f; + const float center[2] = { xx, yy }; + + area.m_widgetY += int32_t(width) + DEFAULT_SPACING; + + const float ro = width*0.5f - 5.0f; // radiusOuter. + const float rd = _size*25.0f; // radiusDelta. + const float ri = ro - rd; // radiusInner. + const float aeps = 0.5f / ro; // Half a pixel arc length in radians (2pi cancels out). + const float cmx = float(m_mx) - center[0]; + const float cmy = float(m_my) - center[1]; + + const float aa[2] = { ri - 6.0f, 0.0f }; // Hue point. + const float bb[2] = { cosf(-120.0f/180.0f*NVG_PI) * aa[0], sinf(-120.0f/180.0f*NVG_PI) * aa[0] }; // Black point. + const float cc[2] = { cosf( 120.0f/180.0f*NVG_PI) * aa[0], sinf( 120.0f/180.0f*NVG_PI) * aa[0] }; // White point. + + const float ca[2] = { aa[0] - cc[0], aa[1] - cc[1] }; + const float lenCa = sqrtf(ca[0]*ca[0]+ca[1]*ca[1]); + const float invLenCa = 1.0f/lenCa; + const float dirCa[2] = { ca[0]*invLenCa, ca[1]*invLenCa }; + + float sel[2]; + + float hsv[3]; + bx::rgbToHsv(hsv, _rgb); + + const bool enabled = _enabled && isEnabled(m_areaId); + if (enabled) + { + if (m_leftPressed) + { + const float len = sqrtf(cmx*cmx + cmy*cmy); + if (len > ri) + { + if (len < ro) + { + setActive(wheelId); + } + } + else + { + setActive(triangleId); + } + } + + if (m_leftReleased + && (isActive(wheelId) || isActive(triangleId) ) ) + { + clearActive(); + } + + // Set hue. + if (m_left + && isActive(wheelId) ) + { + hsv[0] = atan2f(cmy, cmx)/NVG_PI*0.5f; + if (hsv[0] < 0.0f) + { + hsv[0]+=1.0f; + } + } + + } + + if (enabled + && m_left + && isActive(triangleId) ) + { + float an = -hsv[0]*NVG_PI*2.0f; + float tmx = (cmx*cosf(an)-cmy*sinf(an) ); + float tmy = (cmx*sinf(an)+cmy*cosf(an) ); + + if (pointInTriangle(tmx, tmy, aa[0], aa[1], bb[0], bb[1], cc[0], cc[1]) ) + { + sel[0] = tmx; + sel[1] = tmy; + } + else + { + closestPointOnTriangle(sel[0], sel[1], tmx, tmy, aa[0], aa[1], bb[0], bb[1], cc[0], cc[1]); + } + } + else + { + /* + * bb (black) + * /\ + * / \ + * / \ + * / \ + * / \ + * / .sel \ + * / \ + * cc(white)/____.ss_______\aa (hue) + */ + const float ss[2] = + { + cc[0] + dirCa[0]*lenCa*hsv[1], + cc[1] + dirCa[1]*lenCa*hsv[1], + }; + + const float sb[2] = { bb[0]-ss[0], bb[1]-ss[1] }; + const float lenSb = sqrtf(sb[0]*sb[0]+sb[1]*sb[1]); + const float invLenSb = 1.0f/lenSb; + const float dirSb[2] = { sb[0]*invLenSb, sb[1]*invLenSb }; + + sel[0] = cc[0] + dirCa[0]*lenCa*hsv[1] + dirSb[0]*lenSb*(1.0f - hsv[2]); + sel[1] = cc[1] + dirCa[1]*lenCa*hsv[1] + dirSb[1]*lenSb*(1.0f - hsv[2]); + } + + float uu, vv, ww; + barycentric(uu, vv, ww + , aa[0], aa[1] + , bb[0], bb[1] + , cc[0], cc[1] + , sel[0], sel[1] + ); + + const float val = bx::fclamp(1.0f-vv, 0.0001f, 1.0f); + const float sat = bx::fclamp(uu/val, 0.0001f, 1.0f); + + const float out[3] = { hsv[0], sat, val }; + bx::hsvToRgb(_rgb, out); + + // Draw widget. + nvgSave(m_nvg); + { + float saturation; + uint8_t alpha0; + uint8_t alpha1; + if (enabled) + { + saturation = 1.0f; + alpha0 = 255; + alpha1 = 192; + } + else + { + saturation = 0.0f; + alpha0 = 10; + alpha1 = 10; + } + + // Circle. + for (uint8_t ii = 0; ii < 6; ii++) + { + const float a0 = float(ii)/6.0f * 2.0f*NVG_PI - aeps; + const float a1 = float(ii+1.0f)/6.0f * 2.0f*NVG_PI + aeps; + nvgBeginPath(m_nvg); + nvgArc(m_nvg, center[0], center[1], ri, a0, a1, NVG_CW); + nvgArc(m_nvg, center[0], center[1], ro, a1, a0, NVG_CCW); + nvgClosePath(m_nvg); + + const float ax = center[0] + cosf(a0) * (ri+ro)*0.5f; + const float ay = center[1] + sinf(a0) * (ri+ro)*0.5f; + const float bx = center[0] + cosf(a1) * (ri+ro)*0.5f; + const float by = center[1] + sinf(a1) * (ri+ro)*0.5f; + NVGpaint paint = nvgLinearGradient(m_nvg + , ax, ay + , bx, by + , nvgHSLA(a0/NVG_PI*0.5f,saturation,0.55f,alpha0) + , nvgHSLA(a1/NVG_PI*0.5f,saturation,0.55f,alpha0) + ); + + nvgFillPaint(m_nvg, paint); + nvgFill(m_nvg); + } + + // Circle stroke. + nvgBeginPath(m_nvg); + nvgCircle(m_nvg, center[0], center[1], ri-0.5f); + nvgCircle(m_nvg, center[0], center[1], ro+0.5f); + nvgStrokeColor(m_nvg, nvgRGBA(0,0,0,64) ); + nvgStrokeWidth(m_nvg, 1.0f); + nvgStroke(m_nvg); + + nvgSave(m_nvg); + { + // Hue selector. + nvgTranslate(m_nvg, center[0], center[1]); + nvgRotate(m_nvg, hsv[0]*NVG_PI*2.0f); + nvgStrokeWidth(m_nvg, 2.0f); + nvgBeginPath(m_nvg); + nvgRect(m_nvg, ri-1.0f,-3.0f,rd+2.0f,6.0f); + nvgStrokeColor(m_nvg, nvgRGBA(255,255,255,alpha1) ); + nvgStroke(m_nvg); + + // Hue selector drop shadow. + NVGpaint paint = nvgBoxGradient(m_nvg, ri-3.0f,-5.0f,ro-ri+6.0f,10.0f, 2.0f,4.0f, nvgRGBA(0,0,0,128), nvgRGBA(0,0,0,0) ); + nvgBeginPath(m_nvg); + nvgRect(m_nvg, ri-2.0f-10.0f,-4.0f-10.0f,ro-ri+4.0f+20.0f,8.0f+20.0f); + nvgRect(m_nvg, ri-2.0f,-4.0f,ro-ri+4.0f,8.0f); + nvgPathWinding(m_nvg, NVG_HOLE); + nvgFillPaint(m_nvg, paint); + nvgFill(m_nvg); + + // Center triangle stroke. + nvgBeginPath(m_nvg); + nvgMoveTo(m_nvg, aa[0], aa[1]); + nvgLineTo(m_nvg, bb[0], bb[1]); + nvgLineTo(m_nvg, cc[0], cc[1]); + nvgClosePath(m_nvg); + nvgStrokeColor(m_nvg, nvgRGBA(0,0,0,64) ); + nvgStroke(m_nvg); + + // Center triangle fill. + paint = nvgLinearGradient(m_nvg, aa[0], aa[1], bb[0], bb[1], nvgHSL(hsv[0],saturation,0.5f), nvgRGBA(0,0,0,alpha0) ); + nvgFillPaint(m_nvg, paint); + nvgFill(m_nvg); + paint = nvgLinearGradient(m_nvg, (aa[0]+bb[0])*0.5f, (aa[1]+bb[1])*0.5f, cc[0], cc[1], nvgRGBA(0,0,0,0), nvgRGBA(255,255,255,alpha0) ); + nvgFillPaint(m_nvg, paint); + nvgFill(m_nvg); + + // Color selector. + nvgStrokeWidth(m_nvg, 2.0f); + nvgBeginPath(m_nvg); + nvgCircle(m_nvg, sel[0], sel[1], 5); + nvgStrokeColor(m_nvg, nvgRGBA(255,255,255,alpha1) ); + nvgStroke(m_nvg); + + // Color selector stroke. + paint = nvgRadialGradient(m_nvg, sel[0], sel[1], 7.0f, 9.0f, nvgRGBA(0,0,0,64), nvgRGBA(0,0,0,0) ); + nvgBeginPath(m_nvg); + nvgRect(m_nvg, sel[0]-20.0f, sel[1]-20.0f, 40.0f, 40.0f); + nvgCircle(m_nvg, sel[0], sel[1], 7.0f); + nvgPathWinding(m_nvg, NVG_HOLE); + nvgFillPaint(m_nvg, paint); + nvgFill(m_nvg); + } + nvgRestore(m_nvg); + } + nvgRestore(m_nvg); + } + + struct Area + { + int32_t m_x; + int32_t m_y; + int32_t m_width; + int32_t m_height; + int16_t m_contentX; + int16_t m_contentY; + int16_t m_contentWidth; + int16_t m_contentHeight; + int16_t m_scissorX; + int16_t m_scissorY; + int16_t m_scissorHeight; + int16_t m_scissorWidth; + int32_t m_widgetX; + int32_t m_widgetY; + int32_t m_widgetW; + int32_t* m_scrollVal; + uint32_t m_scrollId; + bool m_inside; + bool m_didScroll; + bool m_scissorEnabled; + }; + + inline Area& getCurrentArea() + { + return m_areas[m_areaId]; + } + + inline void setCurrentScissor() + { + const Area& area = getCurrentArea(); + if (area.m_scissorEnabled) + { + bgfx::setScissor(uint16_t(IMGUI_MAX(0, area.m_scissorX) ) + , uint16_t(IMGUI_MAX(0, area.m_scissorY-1) ) + , area.m_scissorWidth + , area.m_scissorHeight+1 + ); + } + else + { + bgfx::setScissor(UINT16_MAX); + } + } + + template <typename Ty, uint16_t Max=64> + struct IdStack + { + IdStack() + { + reset(); + } + + void reset() + { + m_current = 0; + m_idGen = 0; + m_ids[0] = 0; + } + + void next() + { + BX_CHECK(Max > (m_current+1), "Param out of bounds!"); + + m_ids[++m_current] = ++m_idGen; + } + + void pop() + { + m_current = m_current > 0 ? m_current-1 : 0; + } + + Ty current() const + { + BX_CHECK(Max > (m_current), "Param out of bounds!"); + + return m_ids[m_current]; + } + + operator Ty() const + { + BX_CHECK(Max > (m_current), "Param out of bounds!"); + + return m_ids[m_current]; + } + + private: + uint16_t m_current; + Ty m_idGen; + Ty m_ids[Max]; + }; + + int32_t m_mx; + int32_t m_my; + int32_t m_scroll; + uint32_t m_active; + uint32_t m_hot; + uint32_t m_hotToBe; + char m_char; + char m_lastChar; + uint32_t m_inputField; + int32_t m_dragX; + int32_t m_dragY; + float m_dragOrig; + bool m_left; + bool m_leftPressed; + bool m_leftReleased; + bool m_isHot; + bool m_wentActive; + bool m_insideArea; + bool m_isActivePresent; + bool m_checkActivePresence; + + IdStack<uint16_t> m_areaId; + uint16_t m_widgetId; + uint64_t m_enabledAreaIds; + Area m_areas[64]; + + float m_tempCoords[MAX_TEMP_COORDS * 2]; + float m_tempNormals[MAX_TEMP_COORDS * 2]; + + float m_circleVerts[NUM_CIRCLE_VERTS * 2]; + + uint16_t m_textureWidth; + uint16_t m_textureHeight; + float m_invTextureWidth; + float m_invTextureHeight; + float m_halfTexel; + + NVGcontext* m_nvg; + + uint8_t m_view; + uint16_t m_viewWidth; + uint16_t m_viewHeight; + +#if !USE_NANOVG_FONT + struct Font + { + stbtt_bakedchar m_cdata[96]; // ASCII 32..126 is 95 glyphs + bgfx::TextureHandle m_texture; + float m_size; + }; + + uint16_t m_currentFontIdx; + bx::HandleAllocT<IMGUI_CONFIG_MAX_FONTS> m_fontHandle; + Font m_fonts[IMGUI_CONFIG_MAX_FONTS]; +#endif // !USE_NANOVG_FONT + + bgfx::UniformHandle u_imageLodEnabled; + bgfx::UniformHandle u_imageSwizzle; + bgfx::UniformHandle s_texColor; + bgfx::ProgramHandle m_colorProgram; + bgfx::ProgramHandle m_textureProgram; + bgfx::ProgramHandle m_cubeMapProgram; + bgfx::ProgramHandle m_imageProgram; + bgfx::ProgramHandle m_imageSwizzProgram; + bgfx::TextureHandle m_missingTexture; +}; + +static Imgui s_imgui; + +ImguiFontHandle imguiCreate(const void* _data, uint32_t _size, float _fontSize) +{ + return s_imgui.create(_data, _size, _fontSize); +} + +void imguiDestroy() +{ + s_imgui.destroy(); +} + +ImguiFontHandle imguiCreateFont(const void* _data, float _fontSize) +{ + return s_imgui.createFont(_data, _fontSize); +} + +void imguiSetFont(ImguiFontHandle _handle) +{ + s_imgui.setFont(_handle); +} + +ImguiFontHandle imguiGetCurrentFont() +{ + const ImguiFontHandle handle = { s_imgui.m_currentFontIdx }; + return handle; +} + +void imguiBeginFrame(int32_t _mx, int32_t _my, uint8_t _button, int32_t _scroll, uint16_t _width, uint16_t _height, char _inputChar, uint8_t _view) +{ + s_imgui.beginFrame(_mx, _my, _button, _scroll, _width, _height, _inputChar, _view); +} + +void imguiEndFrame() +{ + s_imgui.endFrame(); +} + +void imguiDrawText(int32_t _x, int32_t _y, ImguiTextAlign::Enum _align, const char* _text, uint32_t _argb) +{ + s_imgui.drawText(_x, _y, _align, _text, _argb); +} + +void imguiDrawLine(float _x0, float _y0, float _x1, float _y1, float _r, uint32_t _argb) +{ + s_imgui.drawLine(_x0, _y0, _x1, _y1, _r, _argb); +} + +void imguiDrawRoundedRect(float _x, float _y, float _width, float _height, float _r, uint32_t _argb) +{ + s_imgui.drawRoundedRect(_x, _y, _width, _height, _r, _argb); +} + +void imguiDrawRect(float _x, float _y, float _width, float _height, uint32_t _argb) +{ + s_imgui.drawRect(_x, _y, _width, _height, _argb); +} + +bool imguiBorderButton(ImguiBorder::Enum _border, bool _checked, bool _enabled) +{ + return s_imgui.borderButton(_border, _checked, _enabled); +} + +bool imguiBeginArea(const char* _name, int _x, int _y, int _width, int _height, bool _enabled, int32_t _r) +{ + return s_imgui.beginArea(_name, _x, _y, _width, _height, _enabled, _r); +} + +void imguiEndArea() +{ + return s_imgui.endArea(); +} + +bool imguiBeginScroll(int32_t _height, int32_t* _scroll, bool _enabled) +{ + return s_imgui.beginScroll(_height, _scroll, _enabled); +} + +void imguiEndScroll(int32_t _r) +{ + s_imgui.endScroll(_r); +} + +bool imguiBeginScrollArea(const char* _name, int32_t _x, int32_t _y, int32_t _width, int32_t _height, int32_t* _scroll, bool _enabled, int32_t _r) +{ + const bool result = s_imgui.beginArea(_name, _x, _y, _width, _height, _enabled, _r); + const bool hasTitle = (NULL != _name && '\0' != _name[0]); + const int32_t margins = int32_t(hasTitle)*(AREA_HEADER+2*SCROLL_AREA_PADDING-1); + s_imgui.beginScroll(_height - margins, _scroll, _enabled); + return result; +} + +void imguiEndScrollArea(int32_t _r) +{ + s_imgui.endScroll(_r); + s_imgui.endArea(); +} + +void imguiIndent(uint16_t _width) +{ + s_imgui.indent(_width); +} + +void imguiUnindent(uint16_t _width) +{ + s_imgui.unindent(_width); +} + +void imguiSeparator(uint16_t _height) +{ + s_imgui.separator(_height); +} + +void imguiSeparatorLine(uint16_t _height) +{ + s_imgui.separatorLine(_height); +} + +int32_t imguiGetWidgetX() +{ + return s_imgui.getCurrentArea().m_widgetX; +} + +int32_t imguiGetWidgetY() +{ + return s_imgui.getCurrentArea().m_widgetY; +} + +int32_t imguiGetWidgetW() +{ + return s_imgui.getCurrentArea().m_widgetW; +} + +void imguiSetCurrentScissor() +{ + return s_imgui.setCurrentScissor(); +} + +bool imguiButton(const char* _text, bool _enabled, ImguiAlign::Enum _align, uint32_t _rgb0, int32_t _r) +{ + return s_imgui.button(_text, _enabled, _align, _rgb0, _r); +} + +bool imguiItem(const char* _text, bool _enabled) +{ + return s_imgui.item(_text, _enabled); +} + +bool imguiCheck(const char* _text, bool _checked, bool _enabled) +{ + return s_imgui.check(_text, _checked, _enabled); +} + +void imguiBool(const char* _text, bool& _flag, bool _enabled) +{ + if (imguiCheck(_text, _flag, _enabled) ) + { + _flag = !_flag; + } +} + +bool imguiCollapse(const char* _text, const char* _subtext, bool _checked, bool _enabled) +{ + return s_imgui.collapse(_text, _subtext, _checked, _enabled); +} + +void imguiLabel(const char* _format, ...) +{ + va_list argList; + va_start(argList, _format); + s_imgui.labelVargs(_format, argList, imguiRGBA(255, 255, 255, 255) ); + va_end(argList); +} + +void imguiLabel(uint32_t _rgba, const char* _format, ...) +{ + va_list argList; + va_start(argList, _format); + s_imgui.labelVargs(_format, argList, _rgba); + va_end(argList); +} + +void imguiValue(const char* _text) +{ + s_imgui.value(_text); +} + +bool imguiSlider(const char* _text, float& _val, float _vmin, float _vmax, float _vinc, bool _enabled, ImguiAlign::Enum _align) +{ + return s_imgui.slider(_text, _val, _vmin, _vmax, _vinc, _enabled, _align); +} + +bool imguiSlider(const char* _text, int32_t& _val, int32_t _vmin, int32_t _vmax, bool _enabled, ImguiAlign::Enum _align) +{ + float val = (float)_val; + bool result = s_imgui.slider(_text, val, (float)_vmin, (float)_vmax, 1.0f, _enabled, _align); + _val = (int32_t)val; + return result; +} + +void imguiInput(const char* _label, char* _str, uint32_t _len, bool _enabled, ImguiAlign::Enum _align, int32_t _r) +{ + s_imgui.input(_label, _str, _len, _enabled, _align, _r); +} + +uint8_t imguiTabs(uint8_t _selected, bool _enabled, ImguiAlign::Enum _align, int32_t _height, int32_t _r, uint8_t _nTabs, uint8_t _nEnabled, ...) +{ + va_list argList; + va_start(argList, _nEnabled); + const uint8_t result = s_imgui.tabs(_selected, _enabled, _align, _height, _r, _nTabs, _nEnabled, argList); + va_end(argList); + + return result; +} + +uint8_t imguiTabs(uint8_t _selected, bool _enabled, ImguiAlign::Enum _align, int32_t _height, int32_t _r, uint8_t _nTabs, ...) +{ + va_list argList; + va_start(argList, _nTabs); + const uint8_t result = s_imgui.tabs(_selected, _enabled, _align, _height, _r, _nTabs, 0, argList); + va_end(argList); + + return result; +} + +uint32_t imguiChooseUseMacroInstead(uint32_t _selected, ...) +{ + va_list argList; + va_start(argList, _selected); + + const char* str = va_arg(argList, const char*); + for (uint32_t ii = 0; str != NULL; ++ii, str = va_arg(argList, const char*) ) + { + if (imguiCheck(str, ii == _selected) ) + { + _selected = ii; + } + } + + va_end(argList); + + return _selected; +} + +void imguiColorWheel(float _rgb[3], bool _respectIndentation, float _size, bool _enabled) +{ + s_imgui.colorWheelWidget(_rgb, _respectIndentation, _size, _enabled); +} + +void imguiColorWheel(const char* _text, float _rgb[3], bool& _activated, float _size, bool _enabled) +{ + char buf[128]; + bx::snprintf(buf, sizeof(buf), "[RGB %-2.2f %-2.2f %-2.2f]" + , _rgb[0] + , _rgb[1] + , _rgb[2] + ); + + if (imguiCollapse(_text, buf, _activated) ) + { + _activated = !_activated; + } + + if (_activated) + { + imguiColorWheel(_rgb, false, _size, _enabled); + } +} + +bool imguiImage(bgfx::TextureHandle _image, float _lod, int32_t _width, int32_t _height, ImguiAlign::Enum _align, bool _enabled, bool _originBottomLeft) +{ + return s_imgui.image(_image, _lod, _width, _height, _align, _enabled, _originBottomLeft); +} + +bool imguiImage(bgfx::TextureHandle _image, float _lod, float _width, float _aspect, ImguiAlign::Enum _align, bool _enabled, bool _originBottomLeft) +{ + return s_imgui.image(_image, _lod, _width, _aspect, _align, _enabled, _originBottomLeft); +} + +bool imguiImageChannel(bgfx::TextureHandle _image, uint8_t _channel, float _lod, int32_t _width, int32_t _height, ImguiAlign::Enum _align, bool _enabled) +{ + return s_imgui.imageChannel(_image, _channel, _lod, _width, _height, _align, _enabled); +} + +bool imguiImageChannel(bgfx::TextureHandle _image, uint8_t _channel, float _lod, float _width, float _aspect, ImguiAlign::Enum _align, bool _enabled) +{ + return s_imgui.imageChannel(_image, _channel, _lod, _width, _aspect, _align, _enabled); +} + +bool imguiCube(bgfx::TextureHandle _cubemap, float _lod, bool _cross, ImguiAlign::Enum _align, bool _enabled) +{ + return s_imgui.cubeMap(_cubemap, _lod, _cross, _align, _enabled); +} + +float imguiGetTextLength(const char* _text, ImguiFontHandle _handle) +{ +#if !USE_NANOVG_FONT + uint32_t numVertices = 0; //unused + return getTextLength(s_imgui.m_fonts[_handle.idx].m_cdata, _text, numVertices); +#else + return 0.0f; +#endif +} + +bool imguiMouseOverArea() +{ + return s_imgui.m_insideArea; +} |