summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp')
-rw-r--r--3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp604
1 files changed, 532 insertions, 72 deletions
diff --git a/3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp b/3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp
index 368d503a1ba..8efddcc65f8 100644
--- a/3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp
+++ b/3rdparty/bgfx/examples/common/imgui/ocornut_imgui.cpp
@@ -3,87 +3,360 @@
* License: http://www.opensource.org/licenses/BSD-2-Clause
*/
-#include <bgfx.h>
+#include <bgfx/bgfx.h>
#include <bx/allocator.h>
#include <bx/fpumath.h>
+#include <bx/timer.h>
#include <ocornut-imgui/imgui.h>
+#include <ocornut-imgui/imgui_wm.h>
#include "imgui.h"
#include "ocornut_imgui.h"
#include <stb/stb_image.c>
+#ifndef USE_ENTRY
+# define USE_ENTRY defined(SCI_NAMESPACE)
+#endif // USE_ENTRY
+
+#if USE_ENTRY
+# include "../entry/entry.h"
+#endif // USE_ENTRY
+
+#if defined(SCI_NAMESPACE)
+# include "../entry/input.h"
+# include "scintilla.h"
+#endif // defined(SCI_NAMESPACE)
+
#include "vs_ocornut_imgui.bin.h"
#include "fs_ocornut_imgui.bin.h"
+void viewCallback(const ImDrawList* _parentList, const ImDrawCmd* _cmd);
+
+class PlatformWindow : public ImGuiWM::PlatformWindow
+{
+ typedef ImGuiWM::PlatformWindow Super;
+
+public:
+ PlatformWindow(bool _mainWindow, bool _isDragWindow)
+ : ImGuiWM::PlatformWindow(_mainWindow, _isDragWindow)
+ , m_pos(0.0f, 0.0f)
+ , m_size(0.0f, 0.0f)
+ , m_drag(false)
+ {
+#if USE_ENTRY
+ if (!_mainWindow
+ && !_isDragWindow)
+ {
+ m_window = entry::createWindow(0, 0, 640, 380);
+ extern void pwToWindow(entry::WindowHandle _handle, PlatformWindow* _pw);
+ pwToWindow(m_window, this);
+ }
+ else
+ {
+ m_window.idx = 0;
+ }
+#endif // USE_ENTRY
+ }
+
+ virtual ~PlatformWindow() BX_OVERRIDE
+ {
+ }
+
+ virtual bool Init(ImGuiWM::PlatformWindow* /*_parent*/) BX_OVERRIDE
+ {
+ return true;
+ }
+
+ virtual const ImVec2& GetPosition() const BX_OVERRIDE
+ {
+ return m_pos;
+ }
+
+ virtual const ImVec2& GetSize() const BX_OVERRIDE
+ {
+ return m_size;
+ }
+
+ virtual void Show() BX_OVERRIDE
+ {
+ }
+
+ virtual void Hide() BX_OVERRIDE
+ {
+ }
+
+ virtual void SetSize(const ImVec2& _size) BX_OVERRIDE
+ {
+#if USE_ENTRY
+ if (0 != m_window.idx
+ && m_size.x != _size.x
+ && m_size.y != _size.y)
+ {
+ entry::setWindowSize(m_window, int32_t(_size.x), int32_t(_size.y) );
+ }
+#endif // USE_ENTRY
+
+ m_size = _size;
+ }
+
+ virtual void SetPosition(const ImVec2& _pos) BX_OVERRIDE
+ {
+
+#if USE_ENTRY
+ if (0 != m_window.idx
+ && m_pos.x != _pos.x
+ && m_pos.y != _pos.y)
+ {
+ entry::setWindowPos(m_window, int32_t(_pos.x), int32_t(_pos.y) );
+ }
+#endif // USE_ENTRY
+
+ m_pos = _pos;
+ }
+
+ virtual void SetTitle(const char* _title) BX_OVERRIDE
+ {
+#if USE_ENTRY
+ entry::setWindowTitle(m_window, _title);
+#else
+ BX_UNUSED(_title);
+#endif // USE_ENTRY
+ }
+
+ virtual void PreUpdate() BX_OVERRIDE
+ {
+ }
+
+ virtual void PaintBegin()
+ {
+#if USE_ENTRY
+ if (!m_bIsDragWindow)
+ {
+ ImDrawList* drawList = ImGui::GetWindowDrawList();
+ union { entry::WindowHandle handle; void* ptr; } cast = { m_window };
+ drawList->AddCallback(viewCallback, cast.ptr);
+ drawList->PushClipRect(ImVec4(0.0f, 0.0f, m_size.x, m_size.y) );
+ }
+#endif // USE_ENTRY
+ }
+
+ virtual void Paint() BX_OVERRIDE
+ {
+ if (!m_bIsDragWindow)
+ {
+ Super::Paint();
+ }
+ }
+
+ virtual void PaintEnd()
+ {
+#if USE_ENTRY
+ if (!m_bIsDragWindow)
+ {
+ ImDrawList* drawList = ImGui::GetWindowDrawList();
+ drawList->PopClipRect();
+ drawList->AddCallback(viewCallback, NULL);
+ }
+#endif // USE_ENTRY
+ }
+
+ virtual void Destroy() BX_OVERRIDE
+ {
+ }
+
+ virtual void StartDrag() BX_OVERRIDE
+ {
+ m_drag = true;
+ }
+
+ virtual void StopDrag() BX_OVERRIDE
+ {
+ m_drag = false;
+ }
+
+ virtual bool IsDraging() BX_OVERRIDE
+ {
+ return m_drag;
+ }
+
+private:
+ ImVec2 m_pos;
+ ImVec2 m_size;
+ bool m_drag;
+
+#if USE_ENTRY
+ entry::WindowHandle m_window;
+#endif // USE_ENTRY
+};
+
+class WindowManager : public ImGuiWM::WindowManager
+{
+ typedef ImGuiWM::WindowManager Super;
+
+public:
+ WindowManager()
+ {
+ }
+
+ virtual ~WindowManager() BX_OVERRIDE
+ {
+ }
+
+protected:
+ virtual ImGuiWM::PlatformWindow* CreatePlatformWindow(bool _main, ImGuiWM::PlatformWindow* _parent, bool _isDragWindow) BX_OVERRIDE
+ {
+#if USE_ENTRY
+#else
+ if (!_main
+ && !_isDragWindow)
+ {
+ return NULL;
+ }
+#endif // USE_ENTRY
+
+ PlatformWindow* window = new (ImGui::MemAlloc(sizeof(PlatformWindow) ) ) PlatformWindow(_main, _isDragWindow);
+ window->Init(_parent);
+ return static_cast<ImGuiWM::PlatformWindow*>(window);
+ }
+
+ virtual void LogFormatted(const char* _str) BX_OVERRIDE
+ {
+ BX_TRACE("%s", _str); BX_UNUSED(_str);
+ }
+
+ virtual void InternalRun() BX_OVERRIDE
+ {
+ PreUpdate();
+ Update();
+ }
+};
+
struct OcornutImguiContext
{
static void* memAlloc(size_t _size);
static void memFree(void* _ptr);
- static void renderDrawLists(ImDrawList** const _lists, int _count);
+ static void renderDrawLists(ImDrawData* _drawData);
- void render(ImDrawList** const _lists, int _count)
+ void render(ImDrawData* _drawData)
{
- const float width = ImGui::GetIO().DisplaySize.x;
- const float height = ImGui::GetIO().DisplaySize.y;
+ const ImGuiIO& io = ImGui::GetIO();
+ const float width = io.DisplaySize.x;
+ const float height = io.DisplaySize.y;
- float ortho[16];
- bx::mtxOrtho(ortho, 0.0f, width, height, 0.0f, -1.0f, 1.0f);
+ {
+ float ortho[16];
+ bx::mtxOrtho(ortho, 0.0f, width, height, 0.0f, -1.0f, 1.0f);
+ bgfx::setViewTransform(m_viewId, NULL, ortho);
+ }
- bgfx::setViewTransform(m_viewId, NULL, ortho);
+#if USE_ENTRY
+ for (uint32_t ii = 1; ii < BX_COUNTOF(m_window); ++ii)
+ {
+ Window& window = m_window[ii];
+ if (bgfx::isValid(window.m_fbh) )
+ {
+ const uint8_t viewId = window.m_viewId;
+ bgfx::setViewClear(viewId
+ , BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH
+ , 0x303030ff + rand()
+ , 1.0f
+ , 0
+ );
+ bgfx::setViewFrameBuffer(viewId, window.m_fbh);
+ bgfx::setViewRect(viewId
+ , 0
+ , 0
+ , window.m_state.m_width
+ , window.m_state.m_height
+ );
+ float ortho[16];
+ bx::mtxOrtho(ortho
+ , 0.0f
+ , float(window.m_state.m_width)
+ , float(window.m_state.m_height)
+ , 0.0f
+ , -1.0f
+ , 1.0f
+ );
+ bgfx::setViewTransform(viewId
+ , NULL
+ , ortho
+ );
+ }
+ }
+#endif // USE_ENTRY
// Render command lists
- for (int32_t ii = 0; ii < _count; ++ii)
+ for (int32_t ii = 0, num = _drawData->CmdListsCount; ii < num; ++ii)
{
bgfx::TransientVertexBuffer tvb;
+ bgfx::TransientIndexBuffer tib;
- uint32_t vtx_size = 0;
+ const ImDrawList* drawList = _drawData->CmdLists[ii];
+ uint32_t numVertices = (uint32_t)drawList->VtxBuffer.size();
+ uint32_t numIndices = (uint32_t)drawList->IdxBuffer.size();
- const ImDrawList* cmd_list = _lists[ii];
- const ImDrawVert* vtx_buffer = cmd_list->vtx_buffer.begin();
-
- const ImDrawCmd* pcmd_begin = cmd_list->commands.begin();
- const ImDrawCmd* pcmd_end = cmd_list->commands.end();
- for (const ImDrawCmd* pcmd = pcmd_begin; pcmd != pcmd_end; pcmd++)
- {
- vtx_size += (uint32_t)pcmd->vtx_count;
- }
-
- if (!bgfx::checkAvailTransientVertexBuffer(vtx_size, m_decl))
+ if (!bgfx::checkAvailTransientVertexBuffer(numVertices, m_decl)
+ || !bgfx::checkAvailTransientIndexBuffer(numIndices) )
{
// not enough space in transient buffer just quit drawing the rest...
break;
}
- bgfx::allocTransientVertexBuffer(&tvb, vtx_size, m_decl);
+ bgfx::allocTransientVertexBuffer(&tvb, numVertices, m_decl);
+ bgfx::allocTransientIndexBuffer(&tib, numIndices);
ImDrawVert* verts = (ImDrawVert*)tvb.data;
- memcpy(verts, vtx_buffer, vtx_size * sizeof(ImDrawVert));
-
- uint32_t vtx_offset = 0;
- for (const ImDrawCmd* pcmd = pcmd_begin; pcmd != pcmd_end; pcmd++)
- {
- 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_STATE_MSAA
- );
- bgfx::setScissor(uint16_t(pcmd->clip_rect.x)
- , uint16_t(pcmd->clip_rect.y)
- , uint16_t(pcmd->clip_rect.z-pcmd->clip_rect.x)
- , uint16_t(pcmd->clip_rect.w-pcmd->clip_rect.y)
- );
- union { void* ptr; bgfx::TextureHandle handle; } texture = { pcmd->texture_id };
-
- bgfx::setTexture(0, s_tex, 0 != texture.handle.idx
- ? texture.handle
- : m_texture
- );
+ memcpy(verts, drawList->VtxBuffer.begin(), numVertices * sizeof(ImDrawVert) );
- bgfx::setVertexBuffer(&tvb, vtx_offset, pcmd->vtx_count);
- bgfx::setProgram(m_program);
- bgfx::submit(m_viewId);
+ ImDrawIdx* indices = (ImDrawIdx*)tib.data;
+ memcpy(indices, drawList->IdxBuffer.begin(), numIndices * sizeof(ImDrawIdx) );
- vtx_offset += pcmd->vtx_count;
+ uint32_t offset = 0;
+ for (const ImDrawCmd* cmd = drawList->CmdBuffer.begin(), *cmdEnd = drawList->CmdBuffer.end(); cmd != cmdEnd; ++cmd)
+ {
+ if (cmd->UserCallback)
+ {
+ cmd->UserCallback(drawList, cmd);
+ }
+ else if (0 != cmd->ElemCount)
+ {
+ uint64_t state = 0
+ | BGFX_STATE_RGB_WRITE
+ | BGFX_STATE_ALPHA_WRITE
+ | BGFX_STATE_MSAA
+ ;
+
+ bgfx::TextureHandle th = m_texture;
+
+ if (NULL != cmd->TextureId)
+ {
+ union { ImTextureID ptr; struct { uint16_t flags; bgfx::TextureHandle handle; } s; } texture = { cmd->TextureId };
+ state |= 0 != (IMGUI_FLAGS_ALPHA_BLEND & texture.s.flags)
+ ? BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA)
+ : BGFX_STATE_NONE
+ ;
+ th = texture.s.handle;
+ }
+ else
+ {
+ state |= BGFX_STATE_BLEND_FUNC(BGFX_STATE_BLEND_SRC_ALPHA, BGFX_STATE_BLEND_INV_SRC_ALPHA);
+ }
+
+ const uint16_t xx = uint16_t(bx::fmax(cmd->ClipRect.x, 0.0f) );
+ const uint16_t yy = uint16_t(bx::fmax(cmd->ClipRect.y, 0.0f) );
+ bgfx::setScissor(xx, yy
+ , uint16_t(bx::fmin(cmd->ClipRect.z, 65535.0f)-xx)
+ , uint16_t(bx::fmin(cmd->ClipRect.w, 65535.0f)-yy)
+ );
+
+ bgfx::setState(state);
+ bgfx::setTexture(0, s_tex, th);
+ bgfx::setVertexBuffer(&tvb, 0, numVertices);
+ bgfx::setIndexBuffer(&tib, offset, cmd->ElemCount);
+ bgfx::submit(m_viewId, m_program);
+ }
+
+ offset += cmd->ElemCount;
}
}
}
@@ -92,6 +365,8 @@ struct OcornutImguiContext
{
m_viewId = 255;
m_allocator = _allocator;
+ m_lastScroll = 0;
+ m_last = bx::getHPCounter();
ImGuiIO& io = ImGui::GetIO();
io.RenderDrawListsFn = renderDrawLists;
@@ -100,30 +375,55 @@ struct OcornutImguiContext
io.MemAllocFn = memAlloc;
io.MemFreeFn = memFree;
}
+
io.DisplaySize = ImVec2(1280.0f, 720.0f);
- io.DeltaTime = 1.0f / 60.0f;
+ io.DeltaTime = 1.0f / 60.0f;
io.IniFilename = NULL;
-// io.PixelCenterOffset = bgfx::RendererType::Direct3D9 == bgfx::getRendererType() ? -0.5f : 0.0f;
+
+#if defined(SCI_NAMESPACE)
+ io.KeyMap[ImGuiKey_Tab] = (int)entry::Key::Tab;
+ io.KeyMap[ImGuiKey_LeftArrow] = (int)entry::Key::Left;
+ io.KeyMap[ImGuiKey_RightArrow] = (int)entry::Key::Right;
+ io.KeyMap[ImGuiKey_UpArrow] = (int)entry::Key::Up;
+ io.KeyMap[ImGuiKey_DownArrow] = (int)entry::Key::Down;
+ io.KeyMap[ImGuiKey_Home] = (int)entry::Key::Home;
+ io.KeyMap[ImGuiKey_End] = (int)entry::Key::End;
+ io.KeyMap[ImGuiKey_Delete] = (int)entry::Key::Delete;
+ io.KeyMap[ImGuiKey_Backspace] = (int)entry::Key::Backspace;
+ io.KeyMap[ImGuiKey_Enter] = (int)entry::Key::Return;
+ io.KeyMap[ImGuiKey_Escape] = (int)entry::Key::Esc;
+ io.KeyMap[ImGuiKey_A] = (int)entry::Key::KeyA;
+ io.KeyMap[ImGuiKey_C] = (int)entry::Key::KeyC;
+ io.KeyMap[ImGuiKey_V] = (int)entry::Key::KeyV;
+ io.KeyMap[ImGuiKey_X] = (int)entry::Key::KeyX;
+ io.KeyMap[ImGuiKey_Y] = (int)entry::Key::KeyY;
+ io.KeyMap[ImGuiKey_Z] = (int)entry::Key::KeyZ;
+#endif // defined(SCI_NAMESPACE)
const bgfx::Memory* vsmem;
const bgfx::Memory* fsmem;
- switch (bgfx::getRendererType())
+ switch (bgfx::getRendererType() )
{
case bgfx::RendererType::Direct3D9:
- vsmem = bgfx::makeRef(vs_ocornut_imgui_dx9, sizeof(vs_ocornut_imgui_dx9));
- fsmem = bgfx::makeRef(fs_ocornut_imgui_dx9, sizeof(fs_ocornut_imgui_dx9));
+ vsmem = bgfx::makeRef(vs_ocornut_imgui_dx9, sizeof(vs_ocornut_imgui_dx9) );
+ fsmem = bgfx::makeRef(fs_ocornut_imgui_dx9, sizeof(fs_ocornut_imgui_dx9) );
break;
case bgfx::RendererType::Direct3D11:
case bgfx::RendererType::Direct3D12:
- vsmem = bgfx::makeRef(vs_ocornut_imgui_dx11, sizeof(vs_ocornut_imgui_dx11));
- fsmem = bgfx::makeRef(fs_ocornut_imgui_dx11, sizeof(fs_ocornut_imgui_dx11));
+ vsmem = bgfx::makeRef(vs_ocornut_imgui_dx11, sizeof(vs_ocornut_imgui_dx11) );
+ fsmem = bgfx::makeRef(fs_ocornut_imgui_dx11, sizeof(fs_ocornut_imgui_dx11) );
+ break;
+
+ case bgfx::RendererType::Metal:
+ vsmem = bgfx::makeRef(vs_ocornut_imgui_mtl, sizeof(vs_ocornut_imgui_mtl) );
+ fsmem = bgfx::makeRef(fs_ocornut_imgui_mtl, sizeof(fs_ocornut_imgui_mtl) );
break;
default:
- vsmem = bgfx::makeRef(vs_ocornut_imgui_glsl, sizeof(vs_ocornut_imgui_glsl));
- fsmem = bgfx::makeRef(fs_ocornut_imgui_glsl, sizeof(fs_ocornut_imgui_glsl));
+ vsmem = bgfx::makeRef(vs_ocornut_imgui_glsl, sizeof(vs_ocornut_imgui_glsl) );
+ fsmem = bgfx::makeRef(fs_ocornut_imgui_glsl, sizeof(fs_ocornut_imgui_glsl) );
break;
}
@@ -133,12 +433,12 @@ struct OcornutImguiContext
m_decl
.begin()
- .add(bgfx::Attrib::Position, 2, bgfx::AttribType::Float)
+ .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)
+ .add(bgfx::Attrib::Color0, 4, bgfx::AttribType::Uint8, true)
.end();
- s_tex = bgfx::createUniform("s_tex", bgfx::UniformType::Uniform1i);
+ s_tex = bgfx::createUniform("s_tex", bgfx::UniformType::Int1);
uint8_t* data;
int32_t width;
@@ -153,16 +453,67 @@ struct OcornutImguiContext
, (uint16_t)height
, 1
, bgfx::TextureFormat::BGRA8
- , BGFX_TEXTURE_MIN_POINT | BGFX_TEXTURE_MAG_POINT
+ , 0
, bgfx::copy(data, width*height*4)
);
ImGuiStyle& style = ImGui::GetStyle();
style.FrameRounding = 4.0f;
+
+ m_wm = BX_NEW(m_allocator, WindowManager);
+ m_wm->Init();
+
+#if 0
+ {
+ class Window : public ImGuiWM::Window
+ {
+ public:
+ Window(const char* _title)
+ : ImGuiWM::Window()
+ {
+ SetTitle(_title);
+ }
+
+ virtual void OnGui() BX_OVERRIDE
+ {
+ }
+ };
+
+ class WindowX : public ImGuiWM::Window
+ {
+ public:
+ WindowX(const char* _title)
+ : ImGuiWM::Window()
+ {
+ SetTitle(_title);
+ }
+
+ virtual void OnGui() BX_OVERRIDE
+ {
+#if defined(SCI_NAMESPACE) && 0
+ bool opened = true;
+ ImGuiScintilla("Scintilla Editor", &opened, ImVec2(640.0f, 480.0f) );
+#endif // 0
+ }
+ };
+
+ Window* w0 = new Window("test");
+ WindowX* w1 = new WindowX("abcd");
+ Window* w2 = new Window("xyzw");
+ Window* w3 = new Window("0123");
+
+ m_wm->Dock(w0);
+ m_wm->DockWith(w1, w0, ImGuiWM::E_DOCK_ORIENTATION_RIGHT);
+ m_wm->DockWith(w2, w1, ImGuiWM::E_DOCK_ORIENTATION_BOTTOM);
+ m_wm->DockWith(w3, w0, ImGuiWM::E_DOCK_ORIENTATION_BOTTOM);
+ }
+#endif // 0
}
void destroy()
{
+ m_wm->Exit();
+ BX_DELETE(m_allocator, m_wm);
ImGui::Shutdown();
bgfx::destroyUniform(s_tex);
@@ -172,23 +523,59 @@ struct OcornutImguiContext
m_allocator = NULL;
}
- void beginFrame(int32_t _mx, int32_t _my, uint8_t _button, int _width, int _height, char _inputChar, uint8_t _viewId)
+ void beginFrame(int32_t _mx, int32_t _my, uint8_t _button, int32_t _scroll, int _width, int _height, char _inputChar, uint8_t _viewId)
{
- m_viewId = _viewId;
+ m_viewId = _viewId;
+ m_defaultViewId = _viewId;
+
ImGuiIO& io = ImGui::GetIO();
- io.AddInputCharacter(_inputChar & 0x7f); // ASCII or GTFO! :)
- io.DisplaySize = ImVec2((float)_width, (float)_height);
- io.DeltaTime = 1.0f / 60.0f;
- io.MousePos = ImVec2((float)_mx, (float)_my);
+ if (_inputChar < 0x7f)
+ {
+ io.AddInputCharacter(_inputChar); // ASCII or GTFO! :(
+ }
+
+ io.DisplaySize = ImVec2( (float)_width, (float)_height);
+
+ const int64_t now = bx::getHPCounter();
+ const int64_t frameTime = now - m_last;
+ m_last = now;
+ const double freq = double(bx::getHPFrequency() );
+ io.DeltaTime = float(frameTime/freq);
+
+ io.MousePos = ImVec2( (float)_mx, (float)_my);
io.MouseDown[0] = 0 != (_button & IMGUI_MBUT_LEFT);
+ io.MouseDown[1] = 0 != (_button & IMGUI_MBUT_RIGHT);
+ io.MouseDown[2] = 0 != (_button & IMGUI_MBUT_MIDDLE);
+ io.MouseWheel = (float)(_scroll - m_lastScroll);
+ m_lastScroll = _scroll;
+
+#if defined(SCI_NAMESPACE)
+ uint8_t modifiers = inputGetModifiersState();
+ io.KeyShift = 0 != (modifiers & (entry::Modifier::LeftShift | entry::Modifier::RightShift) );
+ io.KeyCtrl = 0 != (modifiers & (entry::Modifier::LeftCtrl | entry::Modifier::RightCtrl ) );
+ io.KeyAlt = 0 != (modifiers & (entry::Modifier::LeftAlt | entry::Modifier::RightAlt ) );
+ for (int32_t ii = 0; ii < (int32_t)entry::Key::Count; ++ii)
+ {
+ io.KeysDown[ii] = inputGetKeyState(entry::Key::Enum(ii) );
+ }
+#endif // defined(SCI_NAMESPACE)
ImGui::NewFrame();
- //ImGui::ShowTestWindow(); //Debug only.
+#if 0
+ ImGui::ShowTestWindow(); //Debug only.
+#endif // 0
+
+#if 0
+ extern void ShowExampleAppCustomNodeGraph(bool* opened);
+ bool opened = true;
+ ShowExampleAppCustomNodeGraph(&opened);
+#endif // 0
}
void endFrame()
{
+ m_wm->Run();
ImGui::Render();
}
@@ -197,11 +584,84 @@ struct OcornutImguiContext
bgfx::ProgramHandle m_program;
bgfx::TextureHandle m_texture;
bgfx::UniformHandle s_tex;
+ WindowManager* m_wm;
+ int64_t m_last;
+ int32_t m_lastScroll;
uint8_t m_viewId;
+ uint8_t m_defaultViewId;
+
+#if USE_ENTRY
+ struct Window
+ {
+ Window()
+ {
+ m_fbh.idx = bgfx::invalidHandle;
+ }
+
+ entry::WindowState m_state;
+ PlatformWindow* m_pw;
+ bgfx::FrameBufferHandle m_fbh;
+ uint8_t m_viewId;
+ };
+
+ Window m_window[16];
+#endif // USE_ENTRY
};
static OcornutImguiContext s_ctx;
+#if USE_ENTRY
+
+void viewCallback(const ImDrawList* /*_parentList*/, const ImDrawCmd* _cmd)
+{
+ union { void* ptr; entry::WindowHandle handle; } cast = { _cmd->UserCallbackData };
+
+ if (0 != cast.handle.idx)
+ {
+ s_ctx.m_viewId = s_ctx.m_window[cast.handle.idx].m_viewId;
+ }
+ else
+ {
+ s_ctx.m_viewId = s_ctx.m_defaultViewId;
+ }
+}
+
+void pwToWindow(entry::WindowHandle _handle, PlatformWindow* _pw)
+{
+ s_ctx.m_window[_handle.idx].m_pw = _pw;
+}
+
+void imguiUpdateWindow(const entry::WindowState& _state)
+{
+ OcornutImguiContext::Window& window = s_ctx.m_window[_state.m_handle.idx];
+
+ if (window.m_state.m_nwh != _state.m_nwh
+ || (window.m_state.m_width != _state.m_width
+ || window.m_state.m_height != _state.m_height) )
+ {
+ // When window changes size or native window handle changed
+ // frame buffer must be recreated.
+ if (bgfx::isValid(window.m_fbh) )
+ {
+ bgfx::destroyFrameBuffer(window.m_fbh);
+ window.m_fbh.idx = bgfx::invalidHandle;
+ }
+
+ if (NULL != _state.m_nwh)
+ {
+ window.m_fbh = bgfx::createFrameBuffer(_state.m_nwh, _state.m_width, _state.m_height);
+ window.m_viewId = 200 + _state.m_handle.idx;
+ }
+ else
+ {
+ window.m_viewId = s_ctx.m_defaultViewId;
+ }
+ }
+
+ memcpy(&window.m_state, &_state, sizeof(entry::WindowState) );
+}
+#endif // USE_ENTRY
+
void* OcornutImguiContext::memAlloc(size_t _size)
{
return BX_ALLOC(s_ctx.m_allocator, _size);
@@ -212,9 +672,9 @@ void OcornutImguiContext::memFree(void* _ptr)
BX_FREE(s_ctx.m_allocator, _ptr);
}
-void OcornutImguiContext::renderDrawLists(ImDrawList** const _lists, int _count)
+void OcornutImguiContext::renderDrawLists(ImDrawData* draw_data)
{
- s_ctx.render(_lists, _count);
+ s_ctx.render(draw_data);
}
void IMGUI_create(const void* _data, uint32_t _size, float _fontSize, bx::AllocatorI* _allocator)
@@ -227,9 +687,9 @@ void IMGUI_destroy()
s_ctx.destroy();
}
-void IMGUI_beginFrame(int32_t _mx, int32_t _my, uint8_t _button, int _width, int _height, char _inputChar, uint8_t _viewId)
+void IMGUI_beginFrame(int32_t _mx, int32_t _my, uint8_t _button, int32_t _scroll, int _width, int _height, char _inputChar, uint8_t _viewId)
{
- s_ctx.beginFrame(_mx, _my, _button, _width, _height, _inputChar, _viewId);
+ s_ctx.beginFrame(_mx, _my, _button, _scroll, _width, _height, _inputChar, _viewId);
}
void IMGUI_endFrame()