Showing preview only (5,065K chars total). Download the full file or copy to clipboard to get everything.
Repository: VesCodes/ImGui
Branch: Main
Commit: 550798c6080a
Files: 60
Total size: 4.8 MB
Directory structure:
gitextract_ssp56e80/
├── .gitignore
├── ImGui.uplugin
├── LICENSE
├── README.md
└── Source/
├── ImGui/
│ ├── ImGui.Build.cs
│ ├── Private/
│ │ ├── ImGuiConfig.cpp
│ │ ├── ImGuiContext.cpp
│ │ ├── ImGuiModule.cpp
│ │ ├── SImGuiOverlay.cpp
│ │ ├── SImGuiOverlay.h
│ │ ├── SImGuiWindow.cpp
│ │ └── SImGuiWindow.h
│ └── Public/
│ ├── ImGuiConfig.h
│ ├── ImGuiConfig.inl
│ ├── ImGuiContext.h
│ └── ImGuiModule.h
└── ThirdParty/
├── ImGuiLibrary/
│ ├── ImGuiLibrary.Build.cs
│ ├── LICENSE.txt
│ ├── imconfig.h
│ ├── imgui.cpp
│ ├── imgui.h
│ ├── imgui.natstepfilter
│ ├── imgui.natvis
│ ├── imgui_demo.cpp
│ ├── imgui_draw.cpp
│ ├── imgui_internal.h
│ ├── imgui_tables.cpp
│ ├── imgui_widgets.cpp
│ ├── imstb_rectpack.h
│ ├── imstb_textedit.h
│ └── imstb_truetype.h
├── ImPlotLibrary/
│ ├── ImPlotLibrary.Build.cs
│ ├── LICENSE
│ ├── implot.cpp
│ ├── implot.h
│ ├── implot_demo.cpp
│ ├── implot_internal.h
│ └── implot_items.cpp
└── NetImGuiLibrary/
├── LICENSE.txt
├── NetImGuiLibrary.Build.cs
├── NetImgui_Api.h
├── NetImgui_Config.h
└── Private/
├── NetImgui_Api.cpp
├── NetImgui_Client.cpp
├── NetImgui_Client.h
├── NetImgui_Client.inl
├── NetImgui_CmdPackets.h
├── NetImgui_CmdPackets.inl
├── NetImgui_CmdPackets_DrawFrame.cpp
├── NetImgui_CmdPackets_DrawFrame.h
├── NetImgui_Network.h
├── NetImgui_NetworkPosix.cpp
├── NetImgui_NetworkUE4.cpp
├── NetImgui_NetworkWin32.cpp
├── NetImgui_Shared.h
├── NetImgui_Shared.inl
├── NetImgui_WarningDisable.h
├── NetImgui_WarningDisableImgui.h
├── NetImgui_WarningDisableStd.h
└── NetImgui_WarningReenable.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
Binaries/
Intermediate/
================================================
FILE: ImGui.uplugin
================================================
{
"FileVersion": 3,
"Version": 3,
"VersionName": "1.3",
"FriendlyName": "ImGui",
"Description": "",
"Category": "Other",
"CreatedBy": "VesCodes",
"CreatedByURL": "https://github.com/VesCodes",
"DocsURL": "",
"MarketplaceURL": "",
"Modules": [
{
"Name": "ImGui",
"Type": "Runtime",
"LoadingPhase": "Default"
}
]
}
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2023 Ves Georgiev
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
# ImGui for Unreal Engine
Supercharge your Unreal Engine development with [Dear ImGui](https://github.com/ocornut/imgui). This plugin is designed
to be as frictionless and easy to use as possible while seamlessly integrating all of ImGui's features into UE's
ecosystem.
## Features
* **Multi-viewports**: Pull ImGui windows out of the application's frame ([read more](https://github.com/ocornut/imgui/wiki/Multi-Viewports))
* **Docking**: Combine and tear apart ImGui windows to create custom layouts ([read more](https://github.com/ocornut/imgui/wiki/Docking))
* **Editor support**: Draw ImGui windows in Unreal Editor outside of game sessions
* **Play-in-Editor support**: Each PIE session has its own ImGui context
* **Program support**: Use ImGui in programs and standalone Slate applications
* **Remote drawing**: Connect to headless (e.g. dedicated server) or remote sessions
## Usage
1. Clone this repository into your project's `Plugins` directory
2. Add `ImGui` as a public or private dependency to your module's `Build.cs` file:
```c#
PublicDependencyModuleNames.Add("ImGui");
```
3. Include `imgui.h` and prior to using any ImGui functions create a local scoped context:
```c++
#pragma once
#include <GameFramework/Actor.h>
#include <imgui.h>
#include "ImGuiActor.generated.h"
UCLASS()
class AImGuiActor : public AActor
{
GENERATED_BODY()
public:
AImGuiActor()
{
PrimaryActorTick.bCanEverTick = true;
}
virtual void Tick(float DeltaTime) override
{
Super::Tick(DeltaTime);
const ImGui::FScopedContext ScopedContext;
if (ScopedContext)
{
// Your ImGui code goes here!
ImGui::ShowDemoWindow();
}
}
};
```
This "scoped context" mechanism will push the appropriate ImGui context and pop it once it's gone out of scope. It's
advised to check the `ScopedContext` like the example above to ensure that it's safe to draw.
## Remote drawing
A prebuilt binary of the [NetImGui Server](https://github.com/sammyfreg/netImgui) application is included in
`Source/ThirdParty/NetImGuiServer`. This application allows connecting to ImGui sessions either locally or on a remote
device (e.g. dedicated server, console, mobile device).
There are two command-line arguments allowing you to automatically connect to a NetImGui Server:
- Specifying `-ImGuiHost=Host` will attempt to automatically connect to a NetImGui Server on the specified host using
the default port (8888) though this can be overridden using `-ImGuiPort=Port`; note that the host must already be
running the NetImGui Server application otherwise this will be unsuccessful.
- Specifying just `-ImGuiPort=Port` will attempt to automatically listen for a NetImGui Server connection. This is often
the more convenient approach as you can then connect using NetImGui Server at any point in your session.
Alternatively you can drive this in code using `FImGuiContext::Connect` and `FImGuiContext::Listen` respectively:
```c++
const ImGui::FScopedContext ScopedContext;
if (ScopedContext.IsValid())
{
ScopedContext->Listen(8888);
}
```
## Usage in programs
You can utilise this plugin in Unreal programs and Slate applications, though for releases prior to UE 5.4 the latter
will require integrating [this PR](https://github.com/EpicGames/UnrealEngine/pull/11088).
You can either initialise an ImGui context manually using `FImGuiContext::Create` and use the remote drawing
functionality outlined in the section above, or attach ImGui to a Slate application using
`FImGuiModule::CreateWindowContext`.
Either way you will likely need to manually call `FImGuiContext::BeginFrame` and `FImGuiContext::EndFrame` at
appropriate points in your application's main loop, as they usually rely on delegates fired from `FEngineLoop::Tick`
which is often not executed in standalone programs for obvious reasons.
================================================
FILE: Source/ImGui/ImGui.Build.cs
================================================
using UnrealBuildTool;
public class ImGui : ModuleRules
{
protected virtual bool WithImPlot => true;
protected virtual bool WithNetImGui => true;
public ImGui(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new[]
{
"Core",
"ImGuiLibrary",
});
PrivateDependencyModuleNames.AddRange(new[]
{
"ApplicationCore",
"InputCore",
"Slate",
"SlateCore"
});
if (Target.bCompileAgainstEngine)
{
PrivateDependencyModuleNames.AddRange(new[]
{
"CoreUObject",
"Engine"
});
}
if (Target.bBuildEditor)
{
PrivateDependencyModuleNames.AddRange(new[]
{
"MainFrame",
"UnrealEd"
});
}
PublicDefinitions.Add("IMGUI_USER_CONFIG=\"ImGuiConfig.h\"");
if (WithImPlot)
{
PublicDependencyModuleNames.Add("ImPlotLibrary");
PublicDefinitions.Add("IMPLOT_API=IMGUI_API");
PublicDefinitions.Add("WITH_IMPLOT=1");
}
else
{
PublicDefinitions.Add("WITH_IMPLOT=0");
}
if (WithNetImGui)
{
PublicDependencyModuleNames.Add("NetImGuiLibrary");
PublicDefinitions.Add("NETIMGUI_API=IMGUI_API");
PublicDefinitions.Add("WITH_NETIMGUI=1");
}
else
{
PublicDefinitions.Add("WITH_NETIMGUI=0");
}
}
}
================================================
FILE: Source/ImGui/Private/ImGuiConfig.cpp
================================================
#include "ImGuiConfig.h"
#ifndef IMGUI_DISABLE
#include <InputCoreTypes.h>
#include <Framework/Commands/InputChord.h>
#include <HAL/PlatformFileManager.h>
#if WITH_ENGINE
#include <Engine/Texture2D.h>
#endif
// ReSharper disable CppUnusedIncludeDirective
THIRD_PARTY_INCLUDES_START
#include <imgui.cpp>
#include <imgui_demo.cpp>
#include <imgui_draw.cpp>
#include <imgui_tables.cpp>
#include <imgui_widgets.cpp>
#if WITH_IMPLOT
#include <implot.cpp>
MSVC_PRAGMA(warning(push))
MSVC_PRAGMA(warning(disable: 4756)) // overflow in constant arithmetic
#include <implot_demo.cpp>
MSVC_PRAGMA(warning(pop))
#include <implot_items.cpp>
#endif
THIRD_PARTY_INCLUDES_END
// ReSharper restore CppUnusedIncludeDirective
#include "ImGuiContext.h"
#include "ImGuiModule.h"
#ifdef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
ImFileHandle ImFileOpen(const char* FileName, const char* Mode)
{
IPlatformFile& PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
bool bRead = false;
bool bWrite = false;
bool bAppend = false;
bool bExtended = false;
for (; *Mode; ++Mode)
{
if (*Mode == 'r')
{
bRead = true;
}
else if (*Mode == 'w')
{
bWrite = true;
}
else if (*Mode == 'a')
{
bAppend = true;
}
else if (*Mode == '+')
{
bExtended = true;
}
}
if (bWrite || bAppend || bExtended)
{
return PlatformFile.OpenWrite(UTF8_TO_TCHAR(FileName), bAppend, bExtended);
}
if (bRead)
{
return PlatformFile.OpenRead(UTF8_TO_TCHAR(FileName), true);
}
return nullptr;
}
bool ImFileClose(ImFileHandle File)
{
if (!File)
{
return false;
}
delete File;
return true;
}
uint64 ImFileGetSize(ImFileHandle File)
{
if (!File)
{
return MAX_uint64;
}
const uint64 FileSize = File->Size();
return FileSize;
}
uint64 ImFileRead(void* Data, uint64 Size, uint64 Count, ImFileHandle File)
{
if (!File)
{
return 0;
}
const int64 StartPos = File->Tell();
File->Read(static_cast<uint8*>(Data), Size * Count);
const uint64 ReadSize = File->Tell() - StartPos;
return ReadSize;
}
uint64 ImFileWrite(const void* Data, uint64 Size, uint64 Count, ImFileHandle File)
{
if (!File)
{
return 0;
}
const int64 StartPos = File->Tell();
File->Write(static_cast<const uint8*>(Data), Size * Count);
const uint64 WriteSize = File->Tell() - StartPos;
return WriteSize;
}
#endif
ImGui::FScopedContext::FScopedContext(const int32 PieSessionId)
: FScopedContext(FImGuiModule::Get().FindOrCreateSessionContext(PieSessionId))
{
}
ImGui::FScopedContext::FScopedContext(const TSharedPtr<FImGuiContext>& InContext)
: Context(InContext)
{
PrevContext = GetCurrentContext();
#if WITH_IMPLOT
PrevPlotContext = ImPlot::GetCurrentContext();
#endif
if (Context.IsValid())
{
SetCurrentContext(*Context);
#if WITH_IMPLOT
ImPlot::SetCurrentContext(*Context);
#endif
}
else
{
SetCurrentContext(nullptr);
#if WITH_IMPLOT
ImPlot::SetCurrentContext(nullptr);
#endif
}
}
ImGui::FScopedContext::~FScopedContext()
{
SetCurrentContext(PrevContext);
#if WITH_IMPLOT
ImPlot::SetCurrentContext(PrevPlotContext);
#endif
}
ImGui::FScopedContext::operator bool() const
{
const ImGuiContext* CurrContext = GetCurrentContext();
return CurrContext && CurrContext->Initialized && CurrContext->WithinFrameScope;
}
bool ImGui::FScopedContext::IsValid() const
{
return Context.IsValid();
}
FImGuiContext* ImGui::FScopedContext::operator->() const
{
return Context.operator->();
}
ImGuiKey ImGui::ConvertKey(const FKey& Key)
{
static const TMap<FKey, ImGuiKey> KeyLookupMap = {
{ EKeys::Tab, ImGuiKey_Tab },
{ EKeys::Left, ImGuiKey_LeftArrow },
{ EKeys::Right, ImGuiKey_RightArrow },
{ EKeys::Up, ImGuiKey_UpArrow },
{ EKeys::Down, ImGuiKey_DownArrow },
{ EKeys::PageUp, ImGuiKey_PageUp },
{ EKeys::PageDown, ImGuiKey_PageDown },
{ EKeys::Home, ImGuiKey_Home },
{ EKeys::End, ImGuiKey_End },
{ EKeys::Insert, ImGuiKey_Insert },
{ EKeys::Delete, ImGuiKey_Delete },
{ EKeys::BackSpace, ImGuiKey_Backspace },
{ EKeys::SpaceBar, ImGuiKey_Space },
{ EKeys::Enter, ImGuiKey_Enter },
{ EKeys::Escape, ImGuiKey_Escape },
{ EKeys::LeftControl, ImGuiKey_LeftCtrl },
{ EKeys::LeftShift, ImGuiKey_LeftShift },
{ EKeys::LeftAlt, ImGuiKey_LeftAlt },
{ EKeys::LeftCommand, ImGuiKey_LeftSuper },
{ EKeys::RightControl, ImGuiKey_RightCtrl },
{ EKeys::RightShift, ImGuiKey_RightShift },
{ EKeys::RightAlt, ImGuiKey_RightAlt },
{ EKeys::RightCommand, ImGuiKey_RightSuper },
{ EKeys::Zero, ImGuiKey_0 },
{ EKeys::One, ImGuiKey_1 },
{ EKeys::Two, ImGuiKey_2 },
{ EKeys::Three, ImGuiKey_3 },
{ EKeys::Four, ImGuiKey_4 },
{ EKeys::Five, ImGuiKey_5 },
{ EKeys::Six, ImGuiKey_6 },
{ EKeys::Seven, ImGuiKey_7 },
{ EKeys::Eight, ImGuiKey_8 },
{ EKeys::Nine, ImGuiKey_9 },
{ EKeys::A, ImGuiKey_A },
{ EKeys::B, ImGuiKey_B },
{ EKeys::C, ImGuiKey_C },
{ EKeys::D, ImGuiKey_D },
{ EKeys::E, ImGuiKey_E },
{ EKeys::F, ImGuiKey_F },
{ EKeys::G, ImGuiKey_G },
{ EKeys::H, ImGuiKey_H },
{ EKeys::I, ImGuiKey_I },
{ EKeys::J, ImGuiKey_J },
{ EKeys::K, ImGuiKey_K },
{ EKeys::L, ImGuiKey_L },
{ EKeys::M, ImGuiKey_M },
{ EKeys::N, ImGuiKey_N },
{ EKeys::O, ImGuiKey_O },
{ EKeys::P, ImGuiKey_P },
{ EKeys::Q, ImGuiKey_Q },
{ EKeys::R, ImGuiKey_R },
{ EKeys::S, ImGuiKey_S },
{ EKeys::T, ImGuiKey_T },
{ EKeys::U, ImGuiKey_U },
{ EKeys::V, ImGuiKey_V },
{ EKeys::W, ImGuiKey_W },
{ EKeys::X, ImGuiKey_X },
{ EKeys::Y, ImGuiKey_Y },
{ EKeys::Z, ImGuiKey_Z },
{ EKeys::F1, ImGuiKey_F1 },
{ EKeys::F2, ImGuiKey_F2 },
{ EKeys::F3, ImGuiKey_F3 },
{ EKeys::F4, ImGuiKey_F4 },
{ EKeys::F5, ImGuiKey_F5 },
{ EKeys::F6, ImGuiKey_F6 },
{ EKeys::F7, ImGuiKey_F7 },
{ EKeys::F8, ImGuiKey_F8 },
{ EKeys::F9, ImGuiKey_F9 },
{ EKeys::F10, ImGuiKey_F10 },
{ EKeys::F11, ImGuiKey_F11 },
{ EKeys::F12, ImGuiKey_F12 },
{ EKeys::Apostrophe, ImGuiKey_Apostrophe },
{ EKeys::Comma, ImGuiKey_Comma },
{ EKeys::Hyphen, ImGuiKey_Minus },
{ EKeys::Period, ImGuiKey_Period },
{ EKeys::Slash, ImGuiKey_Slash },
{ EKeys::Semicolon, ImGuiKey_Semicolon },
{ EKeys::Equals, ImGuiKey_Equal },
{ EKeys::LeftBracket, ImGuiKey_LeftBracket },
{ EKeys::Backslash, ImGuiKey_Backslash },
{ EKeys::RightBracket, ImGuiKey_RightBracket },
{ EKeys::Tilde, ImGuiKey_GraveAccent },
{ EKeys::CapsLock, ImGuiKey_CapsLock },
{ EKeys::ScrollLock, ImGuiKey_ScrollLock },
{ EKeys::NumLock, ImGuiKey_NumLock },
// No mappable key for ImGuiKey_PrintScreen
{ EKeys::Pause, ImGuiKey_Pause },
{ EKeys::NumPadZero, ImGuiKey_Keypad0 },
{ EKeys::NumPadOne, ImGuiKey_Keypad1 },
{ EKeys::NumPadTwo, ImGuiKey_Keypad2 },
{ EKeys::NumPadThree, ImGuiKey_Keypad3 },
{ EKeys::NumPadFour, ImGuiKey_Keypad4 },
{ EKeys::NumPadFive, ImGuiKey_Keypad5 },
{ EKeys::NumPadSix, ImGuiKey_Keypad6 },
{ EKeys::NumPadSeven, ImGuiKey_Keypad7 },
{ EKeys::NumPadEight, ImGuiKey_Keypad8 },
{ EKeys::NumPadNine, ImGuiKey_Keypad9 },
{ EKeys::Decimal, ImGuiKey_KeypadDecimal },
{ EKeys::Divide, ImGuiKey_KeypadDivide },
{ EKeys::Multiply, ImGuiKey_KeypadMultiply },
{ EKeys::Subtract, ImGuiKey_KeypadSubtract },
{ EKeys::Add, ImGuiKey_KeypadAdd },
// No mappable key for ImGuiKey_KeypadEnter
// No mappable key for ImGuiKey_KeypadEqual
{ EKeys::Gamepad_Special_Right, ImGuiKey_GamepadStart },
{ EKeys::Gamepad_Special_Left, ImGuiKey_GamepadBack },
{ EKeys::Gamepad_FaceButton_Left, ImGuiKey_GamepadFaceLeft },
{ EKeys::Gamepad_FaceButton_Right, ImGuiKey_GamepadFaceRight },
{ EKeys::Gamepad_FaceButton_Top, ImGuiKey_GamepadFaceUp },
{ EKeys::Gamepad_FaceButton_Bottom, ImGuiKey_GamepadFaceDown },
{ EKeys::Gamepad_DPad_Left, ImGuiKey_GamepadDpadLeft },
{ EKeys::Gamepad_DPad_Right, ImGuiKey_GamepadDpadRight },
{ EKeys::Gamepad_DPad_Up, ImGuiKey_GamepadDpadUp },
{ EKeys::Gamepad_DPad_Down, ImGuiKey_GamepadDpadDown },
{ EKeys::Gamepad_LeftShoulder, ImGuiKey_GamepadL1 },
{ EKeys::Gamepad_RightShoulder, ImGuiKey_GamepadR1 },
{ EKeys::Gamepad_LeftTrigger, ImGuiKey_GamepadL2 },
{ EKeys::Gamepad_RightTrigger, ImGuiKey_GamepadR2 },
{ EKeys::Gamepad_LeftThumbstick, ImGuiKey_GamepadL3 },
{ EKeys::Gamepad_RightThumbstick, ImGuiKey_GamepadR3 },
{ EKeys::Gamepad_LeftStick_Left, ImGuiKey_GamepadLStickLeft },
{ EKeys::Gamepad_LeftStick_Right, ImGuiKey_GamepadLStickRight },
{ EKeys::Gamepad_LeftStick_Up, ImGuiKey_GamepadLStickUp },
{ EKeys::Gamepad_LeftStick_Down, ImGuiKey_GamepadLStickDown },
{ EKeys::Gamepad_RightStick_Left, ImGuiKey_GamepadRStickLeft },
{ EKeys::Gamepad_RightStick_Right, ImGuiKey_GamepadRStickRight },
{ EKeys::Gamepad_RightStick_Up, ImGuiKey_GamepadRStickUp },
{ EKeys::Gamepad_RightStick_Down, ImGuiKey_GamepadRStickDown }
};
return KeyLookupMap.FindRef(Key, ImGuiKey_None);
}
FKey ImGui::ConvertKey(const ImGuiKey Key)
{
static const TMap<ImGuiKey, FKey> KeyLookupMap = {
{ ImGuiKey_Tab, EKeys::Tab },
{ ImGuiKey_LeftArrow, EKeys::Left },
{ ImGuiKey_RightArrow, EKeys::Right },
{ ImGuiKey_UpArrow, EKeys::Up },
{ ImGuiKey_DownArrow, EKeys::Down },
{ ImGuiKey_PageUp, EKeys::PageUp },
{ ImGuiKey_PageDown, EKeys::PageDown },
{ ImGuiKey_Home, EKeys::Home },
{ ImGuiKey_End, EKeys::End },
{ ImGuiKey_Insert, EKeys::Insert },
{ ImGuiKey_Delete, EKeys::Delete },
{ ImGuiKey_Backspace, EKeys::BackSpace },
{ ImGuiKey_Space, EKeys::SpaceBar },
{ ImGuiKey_Enter, EKeys::Enter },
{ ImGuiKey_Escape, EKeys::Escape },
{ ImGuiKey_LeftCtrl, EKeys::LeftControl },
{ ImGuiKey_LeftShift, EKeys::LeftShift },
{ ImGuiKey_LeftAlt, EKeys::LeftAlt },
{ ImGuiKey_LeftSuper, EKeys::LeftCommand },
{ ImGuiKey_RightCtrl, EKeys::RightControl },
{ ImGuiKey_RightShift, EKeys::RightShift },
{ ImGuiKey_RightAlt, EKeys::RightAlt },
{ ImGuiKey_RightSuper, EKeys::RightCommand },
{ ImGuiKey_0, EKeys::Zero },
{ ImGuiKey_1, EKeys::One },
{ ImGuiKey_2, EKeys::Two },
{ ImGuiKey_3, EKeys::Three },
{ ImGuiKey_4, EKeys::Four },
{ ImGuiKey_5, EKeys::Five },
{ ImGuiKey_6, EKeys::Six },
{ ImGuiKey_7, EKeys::Seven },
{ ImGuiKey_8, EKeys::Eight },
{ ImGuiKey_9, EKeys::Nine },
{ ImGuiKey_A, EKeys::A },
{ ImGuiKey_B, EKeys::B },
{ ImGuiKey_C, EKeys::C },
{ ImGuiKey_D, EKeys::D },
{ ImGuiKey_E, EKeys::E },
{ ImGuiKey_F, EKeys::F },
{ ImGuiKey_G, EKeys::G },
{ ImGuiKey_H, EKeys::H },
{ ImGuiKey_I, EKeys::I },
{ ImGuiKey_J, EKeys::J },
{ ImGuiKey_K, EKeys::K },
{ ImGuiKey_L, EKeys::L },
{ ImGuiKey_M, EKeys::M },
{ ImGuiKey_N, EKeys::N },
{ ImGuiKey_O, EKeys::O },
{ ImGuiKey_P, EKeys::P },
{ ImGuiKey_Q, EKeys::Q },
{ ImGuiKey_R, EKeys::R },
{ ImGuiKey_S, EKeys::S },
{ ImGuiKey_T, EKeys::T },
{ ImGuiKey_U, EKeys::U },
{ ImGuiKey_V, EKeys::V },
{ ImGuiKey_W, EKeys::W },
{ ImGuiKey_X, EKeys::X },
{ ImGuiKey_Y, EKeys::Y },
{ ImGuiKey_Z, EKeys::Z },
{ ImGuiKey_F1, EKeys::F1 },
{ ImGuiKey_F2, EKeys::F2 },
{ ImGuiKey_F3, EKeys::F3 },
{ ImGuiKey_F4, EKeys::F4 },
{ ImGuiKey_F5, EKeys::F5 },
{ ImGuiKey_F6, EKeys::F6 },
{ ImGuiKey_F7, EKeys::F7 },
{ ImGuiKey_F8, EKeys::F8 },
{ ImGuiKey_F9, EKeys::F9 },
{ ImGuiKey_F10, EKeys::F10 },
{ ImGuiKey_F11, EKeys::F11 },
{ ImGuiKey_F12, EKeys::F12 },
{ ImGuiKey_Apostrophe, EKeys::Apostrophe },
{ ImGuiKey_Comma, EKeys::Comma },
{ ImGuiKey_Minus, EKeys::Hyphen },
{ ImGuiKey_Period, EKeys::Period },
{ ImGuiKey_Slash, EKeys::Slash },
{ ImGuiKey_Semicolon, EKeys::Semicolon },
{ ImGuiKey_Equal, EKeys::Equals },
{ ImGuiKey_LeftBracket, EKeys::LeftBracket },
{ ImGuiKey_Backslash, EKeys::Backslash },
{ ImGuiKey_RightBracket, EKeys::RightBracket },
{ ImGuiKey_GraveAccent, EKeys::Tilde },
{ ImGuiKey_CapsLock, EKeys::CapsLock },
{ ImGuiKey_ScrollLock, EKeys::ScrollLock },
{ ImGuiKey_NumLock, EKeys::NumLock },
// No mappable key for ImGuiKey_PrintScreen
{ ImGuiKey_Pause, EKeys::Pause },
{ ImGuiKey_Keypad0, EKeys::NumPadZero },
{ ImGuiKey_Keypad1, EKeys::NumPadOne },
{ ImGuiKey_Keypad2, EKeys::NumPadTwo },
{ ImGuiKey_Keypad3, EKeys::NumPadThree },
{ ImGuiKey_Keypad4, EKeys::NumPadFour },
{ ImGuiKey_Keypad5, EKeys::NumPadFive },
{ ImGuiKey_Keypad6, EKeys::NumPadSix },
{ ImGuiKey_Keypad7, EKeys::NumPadSeven },
{ ImGuiKey_Keypad8, EKeys::NumPadEight },
{ ImGuiKey_Keypad9, EKeys::NumPadNine },
{ ImGuiKey_KeypadDecimal, EKeys::Decimal },
{ ImGuiKey_KeypadDivide, EKeys::Divide },
{ ImGuiKey_KeypadMultiply, EKeys::Multiply },
{ ImGuiKey_KeypadSubtract, EKeys::Subtract },
{ ImGuiKey_KeypadAdd, EKeys::Add },
// No mappable key for ImGuiKey_KeypadEnter
// No mappable key for ImGuiKey_KeypadEqual
{ ImGuiKey_GamepadStart, EKeys::Gamepad_Special_Right },
{ ImGuiKey_GamepadBack, EKeys::Gamepad_Special_Left },
{ ImGuiKey_GamepadFaceLeft, EKeys::Gamepad_FaceButton_Left },
{ ImGuiKey_GamepadFaceRight, EKeys::Gamepad_FaceButton_Right },
{ ImGuiKey_GamepadFaceUp, EKeys::Gamepad_FaceButton_Top },
{ ImGuiKey_GamepadFaceDown, EKeys::Gamepad_FaceButton_Bottom },
{ ImGuiKey_GamepadDpadLeft, EKeys::Gamepad_DPad_Left },
{ ImGuiKey_GamepadDpadRight, EKeys::Gamepad_DPad_Right },
{ ImGuiKey_GamepadDpadUp, EKeys::Gamepad_DPad_Up },
{ ImGuiKey_GamepadDpadDown, EKeys::Gamepad_DPad_Down },
{ ImGuiKey_GamepadL1, EKeys::Gamepad_LeftShoulder },
{ ImGuiKey_GamepadR1, EKeys::Gamepad_RightShoulder },
{ ImGuiKey_GamepadL2, EKeys::Gamepad_LeftTrigger },
{ ImGuiKey_GamepadR2, EKeys::Gamepad_RightTrigger },
{ ImGuiKey_GamepadL3, EKeys::Gamepad_LeftThumbstick },
{ ImGuiKey_GamepadR3, EKeys::Gamepad_RightThumbstick },
{ ImGuiKey_GamepadLStickLeft, EKeys::Gamepad_LeftStick_Left },
{ ImGuiKey_GamepadLStickRight, EKeys::Gamepad_LeftStick_Right },
{ ImGuiKey_GamepadLStickUp, EKeys::Gamepad_LeftStick_Up },
{ ImGuiKey_GamepadLStickDown, EKeys::Gamepad_LeftStick_Down },
{ ImGuiKey_GamepadRStickLeft, EKeys::Gamepad_RightStick_Left },
{ ImGuiKey_GamepadRStickRight, EKeys::Gamepad_RightStick_Right },
{ ImGuiKey_GamepadRStickUp, EKeys::Gamepad_RightStick_Up },
{ ImGuiKey_GamepadRStickDown, EKeys::Gamepad_RightStick_Down }
};
return KeyLookupMap.FindRef(Key, EKeys::Invalid);
}
ImGuiKeyChord ImGui::ConvertKeyChord(const FInputChord& Chord)
{
ImGuiKeyChord Result = ConvertKey(Chord.Key);
Result |= Chord.bCtrl ? ImGuiMod_Ctrl : 0;
Result |= Chord.bShift ? ImGuiMod_Shift : 0;
Result |= Chord.bAlt ? ImGuiMod_Alt : 0;
Result |= Chord.bCmd ? ImGuiMod_Super : 0;
return Result;
}
FInputChord ImGui::ConvertKeyChord(const ImGuiKeyChord Chord)
{
FInputChord Result = ConvertKey(static_cast<ImGuiKey>(Chord & ~ImGuiMod_Mask_));
Result.bCtrl = (Chord & ImGuiMod_Ctrl) != 0;
Result.bShift = (Chord & ImGuiMod_Shift) != 0;
Result.bAlt = (Chord & ImGuiMod_Alt) != 0;
Result.bCmd = (Chord & ImGuiMod_Super) != 0;
return Result;
}
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Private/ImGuiContext.cpp
================================================
#include "ImGuiContext.h"
#ifndef IMGUI_DISABLE
#include <Framework/Application/SlateApplication.h>
#include <HAL/LowLevelMemTracker.h>
#include <HAL/PlatformApplicationMisc.h>
#include <HAL/PlatformProcess.h>
#include <HAL/PlatformString.h>
#include <HAL/UnrealMemory.h>
#include <Misc/App.h>
#include <Misc/EngineVersionComparison.h>
#include <Widgets/SWindow.h>
#if WITH_ENGINE
#include <RHITypes.h>
#include <UObject/Package.h>
#else
#include <Textures/SlateUpdatableTexture.h>
#endif
THIRD_PARTY_INCLUDES_START
#include <imgui.h>
#include <imgui_internal.h>
#if WITH_IMPLOT
#include <implot.h>
#endif
#if WITH_NETIMGUI
#define NETIMGUI_IMPLEMENTATION
#include <NetImgui_Api.h>
#endif
THIRD_PARTY_INCLUDES_END
#include "SImGuiOverlay.h"
#include "SImGuiWindow.h"
FImGuiViewportData* FImGuiViewportData::GetOrCreate(ImGuiViewport* Viewport)
{
if (!Viewport)
{
return nullptr;
}
FImGuiViewportData* ViewportData = static_cast<FImGuiViewportData*>(Viewport->PlatformUserData);
if (!ViewportData)
{
ViewportData = new FImGuiViewportData();
Viewport->PlatformUserData = ViewportData;
}
return ViewportData;
}
static void* ImGui_MemAlloc(size_t Size, void* UserData)
{
LLM_SCOPE_BYNAME(TEXT("ImGui"));
return FMemory::Malloc(Size);
}
static void ImGui_MemFree(void* Ptr, void* UserData)
{
FMemory::Free(Ptr);
}
static void ImGui_CreateWindow(ImGuiViewport* Viewport)
{
FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
const FImGuiViewportData* MainViewportData = FImGuiViewportData::GetOrCreate(ImGui::GetMainViewport());
const TSharedPtr<SWindow> ParentWindow = MainViewportData ? MainViewportData->Window.Pin() : nullptr;
const TSharedRef<SWindow> Window =
SAssignNew(ViewportData->Window, SImGuiWindow)
.Viewport(Viewport)
[
SAssignNew(ViewportData->Overlay, SImGuiOverlay)
.Context(FImGuiContext::Get(ImGui::GetCurrentContext()))
.HandleInput(false)
];
if (ParentWindow.IsValid())
{
FSlateApplication::Get().AddWindowAsNativeChild(Window, ParentWindow.ToSharedRef());
}
else
{
FSlateApplication::Get().AddWindow(Window);
}
if (!(Viewport->Flags & ImGuiViewportFlags_OwnedByApp))
{
FSlateThrottleManager::Get().DisableThrottle(true);
}
}
}
static void ImGui_DestroyWindow(ImGuiViewport* Viewport)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (!(Viewport->Flags & ImGuiViewportFlags_OwnedByApp))
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
Window->RequestDestroyWindow();
}
FSlateThrottleManager::Get().DisableThrottle(false);
}
Viewport->PlatformUserData = nullptr;
delete ViewportData;
}
}
static void ImGui_ShowWindow(ImGuiViewport* Viewport)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
Window->ShowWindow();
}
}
}
static void ImGui_SetWindowPos(ImGuiViewport* Viewport, ImVec2 Pos)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
Window->MoveWindowTo(FVector2f(Pos));
}
}
}
static ImVec2 ImGui_GetWindowPos(ImGuiViewport* Viewport)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SImGuiOverlay> Overlay = ViewportData->Overlay.Pin())
{
return Overlay->GetTickSpaceGeometry().GetAbsolutePosition();
}
}
return FVector2f::ZeroVector;
}
static void ImGui_SetWindowSize(ImGuiViewport* Viewport, ImVec2 Size)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
Window->Resize(FVector2f(Size));
}
}
}
static ImVec2 ImGui_GetWindowSize(ImGuiViewport* Viewport)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SImGuiOverlay> Overlay = ViewportData->Overlay.Pin())
{
return Overlay->GetTickSpaceGeometry().GetAbsoluteSize();
}
}
return FVector2f::ZeroVector;
}
static void ImGui_SetWindowFocus(ImGuiViewport* Viewport)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
if (const TSharedPtr<FGenericWindow> NativeWindow = Window->GetNativeWindow())
{
NativeWindow->BringToFront();
NativeWindow->SetWindowFocus();
}
}
}
}
static bool ImGui_GetWindowFocus(ImGuiViewport* Viewport)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
if (const TSharedPtr<FGenericWindow> NativeWindow = Window->GetNativeWindow())
{
return NativeWindow->IsForegroundWindow();
}
}
}
return false;
}
static bool ImGui_GetWindowMinimized(ImGuiViewport* Viewport)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
return Window->IsWindowMinimized();
}
}
return false;
}
static void ImGui_SetWindowTitle(ImGuiViewport* Viewport, const char* Title)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
Window->SetTitle(FText::FromString(UTF8_TO_TCHAR(Title)));
}
}
}
static void ImGui_SetWindowAlpha(ImGuiViewport* Viewport, float Alpha)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SWindow> Window = ViewportData->Window.Pin())
{
Window->SetOpacity(Alpha);
}
}
}
static void ImGui_RenderWindow(ImGuiViewport* Viewport, void* UserData)
{
const FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData)
{
if (const TSharedPtr<SImGuiOverlay> Overlay = ViewportData->Overlay.Pin())
{
Overlay->SetDrawData(Viewport->DrawData);
}
}
}
const char* ImGui_GetClipboardText(ImGuiContext* Context)
{
TArray<char>* ClipboardBuffer = static_cast<TArray<char>*>(Context->PlatformIO.Platform_ClipboardUserData);
if (ClipboardBuffer)
{
FString ClipboardText;
FPlatformApplicationMisc::ClipboardPaste(ClipboardText);
ClipboardBuffer->SetNumUninitialized(FPlatformString::ConvertedLength<UTF8CHAR>(*ClipboardText));
FPlatformString::Convert(reinterpret_cast<UTF8CHAR*>(ClipboardBuffer->GetData()), ClipboardBuffer->Num(), *ClipboardText, ClipboardText.Len() + 1);
return ClipboardBuffer->GetData();
}
return nullptr;
}
void ImGui_SetClipboardText(ImGuiContext* Context, const char* ClipboardText)
{
FPlatformApplicationMisc::ClipboardCopy(UTF8_TO_TCHAR(ClipboardText));
}
static bool ImGui_OpenInShell(ImGuiContext* Context, const char* Path)
{
return FPlatformProcess::LaunchFileInDefaultExternalApplication(UTF8_TO_TCHAR(Path));
}
TSharedRef<FImGuiContext> FImGuiContext::Create()
{
TSharedRef<FImGuiContext> Context = MakeShared<FImGuiContext>();
Context->Initialize();
return Context;
}
TSharedPtr<FImGuiContext> FImGuiContext::Get(const ImGuiContext* Context)
{
if (Context && Context->IO.UserData)
{
// Expects that the provided context is owned by a live FImGuiContext
return static_cast<FImGuiContext*>(Context->IO.UserData)->AsShared();
}
return nullptr;
}
void FImGuiContext::Initialize()
{
ImGui::SetAllocatorFunctions(ImGui_MemAlloc, ImGui_MemFree);
IMGUI_CHECKVERSION();
Context = ImGui::CreateContext();
#if WITH_IMPLOT
PlotContext = ImPlot::CreateContext();
#endif
ImGui::FScopedContext ScopedContext(AsShared());
#if WITH_NETIMGUI
NetImgui::Startup();
#endif
ImGuiIO& IO = ImGui::GetIO();
IO.UserData = this;
IO.ConfigNavMoveSetMousePos = true;
IO.ConfigDpiScaleViewports = true;
IO.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
IO.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
IO.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
IO.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;
IO.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;
IO.BackendFlags |= ImGuiBackendFlags_PlatformHasViewports;
IO.BackendFlags |= ImGuiBackendFlags_RendererHasViewports;
IO.BackendFlags |= ImGuiBackendFlags_RendererHasVtxOffset;
IO.BackendFlags |= ImGuiBackendFlags_RendererHasTextures;
#if UE_VERSION_OLDER_THAN(5, 5, 0)
const int32 PieSessionId = GPlayInEditorID;
#else
const int32 PieSessionId = UE::GetPlayInEditorID();
#endif
// Ensure each PIE session has a uniquely identifiable context
const FString ContextName = (PieSessionId > 0 ? FString::Printf(TEXT("ImGui_%d"), PieSessionId) : TEXT("ImGui"));
FPlatformString::Convert(reinterpret_cast<UTF8CHAR*>(Context->ContextName), UE_ARRAY_COUNT(Context->ContextName), *ContextName, ContextName.Len() + 1);
const FString IniFilename = FPaths::GeneratedConfigDir() / FPlatformProperties::PlatformName() / ContextName + TEXT(".ini");
FPlatformString::Convert(reinterpret_cast<UTF8CHAR*>(IniFilenameUtf8), UE_ARRAY_COUNT(IniFilenameUtf8), *IniFilename, IniFilename.Len() + 1);
IO.IniFilename = IniFilenameUtf8;
const FString LogFilename = FPaths::ProjectLogDir() / ContextName + TEXT(".log");
FPlatformString::Convert(reinterpret_cast<UTF8CHAR*>(LogFilenameUtf8), UE_ARRAY_COUNT(LogFilenameUtf8), *LogFilename, LogFilename.Len() + 1);
IO.LogFilename = LogFilenameUtf8;
ImGuiPlatformIO& PlatformIO = ImGui::GetPlatformIO();
PlatformIO.Platform_CreateWindow = ImGui_CreateWindow;
PlatformIO.Platform_DestroyWindow = ImGui_DestroyWindow;
PlatformIO.Platform_ShowWindow = ImGui_ShowWindow;
PlatformIO.Platform_SetWindowPos = ImGui_SetWindowPos;
PlatformIO.Platform_GetWindowPos = ImGui_GetWindowPos;
PlatformIO.Platform_SetWindowSize = ImGui_SetWindowSize;
PlatformIO.Platform_GetWindowSize = ImGui_GetWindowSize;
PlatformIO.Platform_SetWindowFocus = ImGui_SetWindowFocus;
PlatformIO.Platform_GetWindowFocus = ImGui_GetWindowFocus;
PlatformIO.Platform_GetWindowMinimized = ImGui_GetWindowMinimized;
PlatformIO.Platform_SetWindowTitle = ImGui_SetWindowTitle;
PlatformIO.Platform_SetWindowAlpha = ImGui_SetWindowAlpha;
PlatformIO.Platform_RenderWindow = ImGui_RenderWindow;
PlatformIO.Platform_ClipboardUserData = &ClipboardBuffer;
PlatformIO.Platform_GetClipboardTextFn = ImGui_GetClipboardText;
PlatformIO.Platform_SetClipboardTextFn = ImGui_SetClipboardText;
PlatformIO.Platform_OpenInShellFn = ImGui_OpenInShell;
const FString FontPath = FPaths::EngineContentDir() / TEXT("Slate/Fonts/Roboto-Regular.ttf");
if (FPaths::FileExists(*FontPath))
{
IO.Fonts->AddFontFromFileTTF(TCHAR_TO_UTF8(*FontPath), 16);
}
if (FSlateApplication::IsInitialized())
{
#if PLATFORM_DESKTOP
// Enable multi-viewports support for Slate applications
IO.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
#endif
if (const TSharedPtr<GenericApplication> PlatformApplication = FSlateApplication::Get().GetPlatformApplication())
{
FDisplayMetrics DisplayMetrics;
FDisplayMetrics::RebuildDisplayMetrics(DisplayMetrics);
PlatformApplication->OnDisplayMetricsChanged().AddSP(this, &FImGuiContext::OnDisplayMetricsChanged);
OnDisplayMetricsChanged(DisplayMetrics);
}
}
// Ensure main viewport data is created ahead of time
FImGuiViewportData::GetOrCreate(ImGui::GetMainViewport());
FCoreDelegates::OnBeginFrame.AddSP(this, &FImGuiContext::BeginFrame);
FCoreDelegates::OnEndFrame.AddSP(this, &FImGuiContext::EndFrame);
}
FImGuiContext::~FImGuiContext()
{
FCoreDelegates::OnBeginFrame.RemoveAll(this);
FCoreDelegates::OnEndFrame.RemoveAll(this);
if (FSlateApplication::IsInitialized())
{
if (const TSharedPtr<GenericApplication> PlatformApplication = FSlateApplication::Get().GetPlatformApplication())
{
PlatformApplication->OnDisplayMetricsChanged().RemoveAll(this);
}
}
#if WITH_NETIMGUI
NetImgui::Shutdown();
#endif
#if WITH_IMPLOT
if (PlotContext)
{
ImPlot::DestroyContext(PlotContext);
PlotContext = nullptr;
}
#endif
if (Context)
{
if (!GExitPurge)
{
for (ImTextureData* TextureData : Context->PlatformIO.Textures)
{
if (TextureData->RefCount == 1)
{
DestroyTexture(TextureData);
}
}
}
ImGuiContext* PrevContext = ImGui::GetCurrentContext();
ImGui::SetCurrentContext(Context);
ImGui::DestroyPlatformWindows();
ImGui::DestroyContext(Context);
ImGui::SetCurrentContext(PrevContext);
Context = nullptr;
}
}
#if WITH_NETIMGUI
bool FImGuiContext::Listen(uint16 Port)
{
ImGui::FScopedContext ScopedContext(AsShared());
TAnsiStringBuilder<128> ClientName;
ClientName << FApp::GetProjectName();
#if UE_VERSION_OLDER_THAN(5, 5, 0)
const int32 PieSessionId = GPlayInEditorID;
#else
const int32 PieSessionId = UE::GetPlayInEditorID();
#endif
if (PieSessionId > 0)
{
ClientName << " (" << PieSessionId << ")";
}
NetImgui::ConnectFromApp(ClientName.ToString(), Port);
bIsRemote = true;
return true;
}
bool FImGuiContext::Connect(const FString& Host, int16 Port)
{
ImGui::FScopedContext ScopedContext(AsShared());
TAnsiStringBuilder<128> ClientName;
ClientName << FApp::GetProjectName();
#if UE_VERSION_OLDER_THAN(5, 5, 0)
const int32 PieSessionId = GPlayInEditorID;
#else
const int32 PieSessionId = UE::GetPlayInEditorID();
#endif
if (PieSessionId > 0)
{
ClientName << " (" << PieSessionId << ")";
}
NetImgui::ConnectToApp(ClientName.ToString(), TCHAR_TO_ANSI(*Host), Port);
bIsRemote = true;
return true;
}
void FImGuiContext::Disconnect()
{
if (bIsRemote)
{
NetImgui::Disconnect();
bIsRemote = false;
}
}
#endif
FImGuiContext::operator ImGuiContext*() const
{
return Context;
}
#if WITH_IMPLOT
FImGuiContext::operator ImPlotContext*() const
{
return PlotContext;
}
#endif
void FImGuiContext::OnDisplayMetricsChanged(const FDisplayMetrics& DisplayMetrics)
{
ImGui::FScopedContext ScopedContext(AsShared());
ImGuiPlatformIO& PlatformIO = ImGui::GetPlatformIO();
PlatformIO.Monitors.resize(0);
if (DisplayMetrics.MonitorInfo.IsEmpty())
{
ImGuiPlatformMonitor ImGuiMonitor;
ImGuiMonitor.MainPos = FIntPoint(0, 0);
ImGuiMonitor.MainSize = FIntPoint(DisplayMetrics.PrimaryDisplayWidth, DisplayMetrics.PrimaryDisplayHeight);
ImGuiMonitor.WorkPos = FIntPoint(DisplayMetrics.PrimaryDisplayWorkAreaRect.Left, DisplayMetrics.PrimaryDisplayWorkAreaRect.Top);
ImGuiMonitor.WorkSize = FIntPoint(DisplayMetrics.PrimaryDisplayWorkAreaRect.Right - DisplayMetrics.PrimaryDisplayWorkAreaRect.Left, DisplayMetrics.PrimaryDisplayWorkAreaRect.Bottom - DisplayMetrics.PrimaryDisplayWorkAreaRect.Top);
ImGuiMonitor.DpiScale = 1.0f;
PlatformIO.Monitors.push_front(ImGuiMonitor);
}
else
{
for (const FMonitorInfo& Monitor : DisplayMetrics.MonitorInfo)
{
ImGuiPlatformMonitor ImGuiMonitor;
ImGuiMonitor.MainPos = FIntPoint(Monitor.DisplayRect.Left, Monitor.DisplayRect.Top);
ImGuiMonitor.MainSize = FIntPoint(Monitor.DisplayRect.Right - Monitor.DisplayRect.Left, Monitor.DisplayRect.Bottom - Monitor.DisplayRect.Top);
ImGuiMonitor.WorkPos = FIntPoint(Monitor.WorkArea.Left, Monitor.WorkArea.Top);
ImGuiMonitor.WorkSize = FIntPoint(Monitor.WorkArea.Right - Monitor.WorkArea.Left, Monitor.WorkArea.Bottom - Monitor.WorkArea.Top);
ImGuiMonitor.DpiScale = Monitor.DPI / 96.0f;
if (Monitor.bIsPrimary)
{
PlatformIO.Monitors.push_front(ImGuiMonitor);
}
else
{
PlatformIO.Monitors.push_back(ImGuiMonitor);
}
}
}
}
void FImGuiContext::CreateTexture(ImTextureData* TextureData)
{
const FName TextureName(WriteToString<32>("ImGuiTexture_", TextureData->UniqueID));
#if WITH_ENGINE
UTexture2D* Texture = UTexture2D::CreateTransient(
TextureData->Width, TextureData->Height, PF_B8G8R8A8,
MakeUniqueObjectName(GetTransientPackage(), UTexture2D::StaticClass(), TextureName),
MakeConstArrayView(static_cast<uint8*>(TextureData->GetPixels()), TextureData->GetSizeInBytes())
);
#if UE_VERSION_OLDER_THAN(5, 6, 0)
// Fix for tiled platforms prior to 5.6, see https://github.com/EpicGames/UnrealEngine/commit/f776b2b
Texture->bNotOfflineProcessed = true;
Texture->UpdateResource();
#endif
TextureData->SetTexID(Texture);
Textures.Emplace(Texture);
#else
FSlateUpdatableTexture* Texture = FSlateApplication::Get().GetRenderer()->CreateUpdatableTexture(TextureData->Width, TextureData->Height);
Texture->UpdateTextureThreadSafeRaw(TextureData->Width, TextureData->Height, TextureData->GetPixels());
// Create a Slate brush and swap its underlying resource to an updatable texture
TSharedPtr<FSlateBrush> Brush = MakeShared<FSlateDynamicImageBrush>(TextureName, FVector2D(TextureData->Width, TextureData->Height));
const FSlateResourceHandle& BrushResourceHandle = Brush->GetRenderingResource();
FSlateShaderResourceProxy* BrushResourceProxy = const_cast<FSlateShaderResourceProxy*>(BrushResourceHandle.GetResourceProxy());
BrushResourceProxy->Resource = Texture->GetSlateResource();
TextureData->SetTexID(Brush.Get());
TextureData->BackendUserData = Texture;
Textures.Emplace(MoveTemp(Brush));
#endif
TextureData->SetStatus(ImTextureStatus_OK);
}
void FImGuiContext::UpdateTexture(ImTextureData* TextureData)
{
#if WITH_ENGINE
UTexture2D* Texture = Cast<UTexture2D>(TextureData->GetTexID());
const int32 NumRegions = TextureData->Updates.size();
FUpdateTextureRegion2D* Regions = static_cast<FUpdateTextureRegion2D*>(FMemory::Malloc(sizeof(FUpdateTextureRegion2D) * NumRegions));
for (int32 RegionIdx = 0; RegionIdx < NumRegions; ++RegionIdx)
{
const ImTextureRect& Rect = TextureData->Updates[RegionIdx];
FUpdateTextureRegion2D& Region = Regions[RegionIdx];
Region.DestX = Region.SrcX = Rect.x;
Region.DestY = Region.SrcY = Rect.y;
Region.Width = Rect.w;
Region.Height = Rect.h;
}
Texture->UpdateTextureRegions(
0, NumRegions, Regions,
TextureData->GetPitch(), TextureData->BytesPerPixel,
static_cast<uint8*>(TextureData->GetPixels()),
[](uint8*, const FUpdateTextureRegion2D* Regions)
{
FMemory::Free(const_cast<FUpdateTextureRegion2D*>(Regions));
}
);
#else
FSlateUpdatableTexture* Texture = static_cast<FSlateUpdatableTexture*>(TextureData->BackendUserData);
const FIntRect Region(
TextureData->UpdateRect.x, TextureData->UpdateRect.y,
TextureData->UpdateRect.x + TextureData->UpdateRect.w,
TextureData->UpdateRect.y + TextureData->UpdateRect.h
);
Texture->UpdateTextureThreadSafeRaw(TextureData->Width, TextureData->Height, TextureData->GetPixels(), Region);
#endif
TextureData->SetStatus(ImTextureStatus_OK);
}
void FImGuiContext::DestroyTexture(ImTextureData* TextureData)
{
#if WITH_ENGINE
UTexture2D* Texture = Cast<UTexture2D>(TextureData->GetTexID());
// Release the texture resource immediately but let GC clean up the object
Texture->ReleaseResource();
#else
if (FSlateApplication::IsInitialized())
{
FSlateUpdatableTexture* Texture = static_cast<FSlateUpdatableTexture*>(TextureData->BackendUserData);
FSlateApplication::Get().GetRenderer()->ReleaseUpdatableTexture(Texture);
}
TextureData->BackendUserData = nullptr;
#endif
Textures.RemoveAllSwap([Texture = TextureData->GetTexID()](const FTextureRef& TextureRef)
{
return TextureRef.Get() == Texture;
});
TextureData->SetTexID(ImTextureID_Invalid);
TextureData->SetStatus(ImTextureStatus_Destroyed);
}
void FImGuiContext::BeginFrame()
{
if (Context->WithinFrameScope)
{
return;
}
#if WITH_NETIMGUI
if (bIsRemote && !NetImgui::IsConnected())
{
return;
}
#endif
ImGui::FScopedContext ScopedContext(AsShared());
ImGuiIO& IO = ImGui::GetIO();
IO.DeltaTime = FApp::GetDeltaTime();
IO.DisplaySize = ImGui_GetWindowSize(ImGui::GetMainViewport());
ImGui::NewFrame();
}
void FImGuiContext::EndFrame()
{
if (!Context->WithinFrameScope)
{
return;
}
ImGui::FScopedContext ScopedContext(AsShared());
ImGui::Render();
ImGui::UpdatePlatformWindows();
for (ImTextureData* TextureData : ImGui::GetPlatformIO().Textures)
{
if (TextureData->Status == ImTextureStatus_WantCreate)
{
CreateTexture(TextureData);
}
else if (TextureData->Status == ImTextureStatus_WantUpdates)
{
UpdateTexture(TextureData);
}
else if (TextureData->Status == ImTextureStatus_WantDestroy && TextureData->UnusedFrames > 0)
{
DestroyTexture(TextureData);
}
}
#if WITH_NETIMGUI
if (!bIsRemote)
#endif
{
ImGui_RenderWindow(ImGui::GetMainViewport(), nullptr);
ImGui::RenderPlatformWindowsDefault();
}
}
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Private/ImGuiModule.cpp
================================================
#include "ImGuiModule.h"
#ifndef IMGUI_DISABLE
#include <Widgets/SWindow.h>
#if WITH_ENGINE
#include <Engine/Engine.h>
#include <Engine/GameViewportClient.h>
#endif
#if WITH_EDITOR
#include <Editor.h>
#include <Interfaces/IMainFrameModule.h>
#endif
#include "ImGuiContext.h"
#include "SImGuiOverlay.h"
void FImGuiModule::StartupModule()
{
#if WITH_EDITOR
FEditorDelegates::EndPIE.AddRaw(this, &FImGuiModule::OnEndPIE);
#endif
#if WITH_ENGINE
UGameViewportClient::OnViewportCreated().AddRaw(this, &FImGuiModule::OnViewportCreated);
#endif
}
void FImGuiModule::ShutdownModule()
{
#if WITH_EDITOR
FEditorDelegates::EndPIE.RemoveAll(this);
#endif
#if WITH_ENGINE
UGameViewportClient::OnViewportCreated().RemoveAll(this);
#endif
SessionContexts.Reset();
}
FImGuiModule& FImGuiModule::Get()
{
static FImGuiModule& Module = FModuleManager::LoadModuleChecked<FImGuiModule>(UE_MODULE_NAME);
return Module;
}
TSharedPtr<FImGuiContext> FImGuiModule::FindOrCreateSessionContext(const int32 PieSessionId)
{
TSharedPtr<FImGuiContext> Context = SessionContexts.FindRef(PieSessionId);
if (!Context.IsValid())
{
#if WITH_EDITOR
if (GIsEditor && PieSessionId == INDEX_NONE)
{
const IMainFrameModule* MainFrameModule = FModuleManager::GetModulePtr<IMainFrameModule>("MainFrame");
const TSharedPtr<SWindow> MainFrameWindow = MainFrameModule ? MainFrameModule->GetParentWindow() : nullptr;
if (MainFrameWindow.IsValid())
{
Context = CreateWindowContext(MainFrameWindow.ToSharedRef());
}
}
else
#endif
{
#if WITH_ENGINE
const FWorldContext* WorldContext = GEngine->GetWorldContextFromPIEInstance(PieSessionId);
UGameViewportClient* GameViewport = WorldContext ? WorldContext->GameViewport : GEngine->GameViewport;
if (IsValid(GameViewport))
{
Context = CreateViewportContext(GameViewport);
}
else
{
Context = FImGuiContext::Create();
}
#endif
}
if (Context.IsValid())
{
#if WITH_NETIMGUI
FString Host;
const bool bShouldConnect = FParse::Value(FCommandLine::Get(), TEXT("-ImGuiHost="), Host) && !Host.IsEmpty();
uint16 Port = bShouldConnect ? 8888 : 8889;
const bool bShouldListen = FParse::Value(FCommandLine::Get(), TEXT("-ImGuiPort="), Port) && Port != 0;
if (!bShouldConnect)
{
// Bind consecutive listen ports for PIE sessions
Port += PieSessionId + 1;
}
if ((bShouldConnect && !Context->Connect(Host, Port)) || (bShouldListen && !Context->Listen(Port)))
{
Context.Reset();
Context = nullptr;
}
else
#endif
{
SessionContexts.Add(PieSessionId, Context);
}
}
}
return Context;
}
void FImGuiModule::OnEndPIE(bool bIsSimulating)
{
for (auto ContextIt = SessionContexts.CreateIterator(); ContextIt; ++ContextIt)
{
if (ContextIt->Key != INDEX_NONE)
{
ContextIt.RemoveCurrent();
}
}
}
void FImGuiModule::OnViewportCreated() const
{
#if WITH_ENGINE
UGameViewportClient* GameViewport = GEngine->GameViewport;
if (!IsValid(GameViewport))
{
return;
}
#if UE_VERSION_OLDER_THAN(5, 5, 0)
const int32 PieSessionId = GPlayInEditorID;
#else
const int32 PieSessionId = UE::GetPlayInEditorID();
#endif
const TSharedPtr<FImGuiContext> Context = SessionContexts.FindRef(PieSessionId);
if (!Context.IsValid())
{
return;
}
ImGui::FScopedContext ScopedContext(Context);
FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(ImGui::GetMainViewport());
if (ViewportData && !ViewportData->Overlay.IsValid())
{
const TSharedRef<SImGuiOverlay> Overlay = SNew(SImGuiOverlay).Context(Context);
ViewportData->Window = GameViewport->GetWindow();
ViewportData->Overlay = Overlay;
GameViewport->AddViewportWidgetContent(Overlay, TNumericLimits<int32>::Max());
}
#endif
}
TSharedPtr<FImGuiContext> FImGuiModule::CreateWindowContext(const TSharedRef<SWindow>& Window)
{
const TSharedRef<FImGuiContext> Context = FImGuiContext::Create();
ImGui::FScopedContext ScopedContext(Context);
FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(ImGui::GetMainViewport());
if (ViewportData)
{
const TSharedRef<SImGuiOverlay> Overlay = SNew(SImGuiOverlay).Context(Context);
ViewportData->Window = Window;
ViewportData->Overlay = Overlay;
Window->AddOverlaySlot(TNumericLimits<int32>::Max())[Overlay];
}
return Context;
}
TSharedPtr<FImGuiContext> FImGuiModule::CreateViewportContext(UGameViewportClient* GameViewport)
{
#if WITH_ENGINE
if (!IsValid(GameViewport))
{
return nullptr;
}
const TSharedRef<FImGuiContext> Context = FImGuiContext::Create();
ImGui::FScopedContext ScopedContext(Context);
FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(ImGui::GetMainViewport());
if (ViewportData)
{
const TSharedRef<SImGuiOverlay> Overlay = SNew(SImGuiOverlay).Context(Context);
ViewportData->Window = GameViewport->GetWindow();
ViewportData->Overlay = Overlay;
GameViewport->AddViewportWidgetContent(Overlay, TNumericLimits<int32>::Max());
}
return Context;
#else
return nullptr;
#endif
}
IMPLEMENT_MODULE(FImGuiModule, ImGui);
#else // #ifndef IMGUI_DISABLE
#include <Modules/ModuleManager.h>
IMPLEMENT_MODULE(FDefaultModuleImpl, ImGui);
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Private/SImGuiOverlay.cpp
================================================
#include "SImGuiOverlay.h"
#ifndef IMGUI_DISABLE
#include <Framework/Application/SlateApplication.h>
#include "ImGuiContext.h"
FImGuiDrawList::FImGuiDrawList(ImDrawList* Source)
{
VtxBuffer.swap(Source->VtxBuffer);
IdxBuffer.swap(Source->IdxBuffer);
CmdBuffer.swap(Source->CmdBuffer);
Flags = Source->Flags;
}
FImGuiDrawData::FImGuiDrawData(const ImDrawData* Source)
{
bValid = Source->Valid;
TotalIdxCount = Source->TotalIdxCount;
TotalVtxCount = Source->TotalVtxCount;
ImGui::CopyArray(Source->CmdLists, DrawLists);
DisplayPos = Source->DisplayPos;
DisplaySize = Source->DisplaySize;
FrameBufferScale = Source->FramebufferScale;
}
class FImGuiInputProcessor : public IInputProcessor
{
public:
explicit FImGuiInputProcessor(SImGuiOverlay* InOwner)
{
Owner = InOwner;
FSlateApplication::Get().OnApplicationActivationStateChanged().AddRaw(this, &FImGuiInputProcessor::OnApplicationActivationChanged);
FSlateApplication::Get().OnFocusChanging().AddRaw(this, &FImGuiInputProcessor::OnFocusChanging);
LastFocusedWindow = FSlateApplication::Get().GetActiveTopLevelRegularWindow();
}
virtual ~FImGuiInputProcessor() override
{
if (FSlateApplication::IsInitialized())
{
FSlateApplication::Get().OnApplicationActivationStateChanged().RemoveAll(this);
FSlateApplication::Get().OnFocusChanging().RemoveAll(this);
}
}
void OnApplicationActivationChanged(bool bIsActive) const
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
ImGuiIO& IO = ImGui::GetIO();
IO.AddFocusEvent(bIsActive);
}
void OnFocusChanging(const FFocusEvent& Event, const FWeakWidgetPath& OldWidgetPath, const TSharedPtr<SWidget>& OldWidget, const FWidgetPath& NewWidgetPath, const TSharedPtr<SWidget>& NewWidget)
{
if (NewWidgetPath.IsValid())
{
LastFocusedWindow = NewWidgetPath.GetDeepestWindow();
}
else
{
LastFocusedWindow.Reset();
}
}
virtual void Tick(const float DeltaTime, FSlateApplication& SlateApp, TSharedRef<ICursor> SlateCursor) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
ImGuiIO& IO = ImGui::GetIO();
const bool bHasGamepad = (IO.BackendFlags & ImGuiBackendFlags_HasGamepad);
if (bHasGamepad != SlateApp.IsGamepadAttached())
{
IO.BackendFlags ^= ImGuiBackendFlags_HasGamepad;
}
if (IO.WantSetMousePos)
{
FVector2f Position = IO.MousePos;
if (!(IO.ConfigFlags & ImGuiConfigFlags_ViewportsEnable))
{
// Mouse position for single viewport mode is in client space
Position += Owner->GetTickSpaceGeometry().AbsolutePosition;
}
SlateCursor->SetPosition(Position.X, Position.Y);
}
if (IO.WantTextInput && !Owner->HasKeyboardFocus())
{
// No HandleKeyCharEvent so punt focus to the widget for it to receive OnKeyChar events
SlateApp.SetKeyboardFocus(Owner->AsShared());
}
}
virtual bool HandleKeyDownEvent(FSlateApplication& SlateApp, const FKeyEvent& Event) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
if (!ShouldHandleEvent(SlateApp, Event))
{
return false;
}
ImGuiIO& IO = ImGui::GetIO();
IO.AddKeyEvent(ImGui::ConvertKey(Event.GetKey()), true);
const FModifierKeysState& ModifierKeys = Event.GetModifierKeys();
IO.AddKeyEvent(ImGuiMod_Ctrl, ModifierKeys.IsControlDown());
IO.AddKeyEvent(ImGuiMod_Shift, ModifierKeys.IsShiftDown());
IO.AddKeyEvent(ImGuiMod_Alt, ModifierKeys.IsAltDown());
IO.AddKeyEvent(ImGuiMod_Super, ModifierKeys.IsCommandDown());
return IO.WantCaptureKeyboard;
}
virtual bool HandleKeyUpEvent(FSlateApplication& SlateApp, const FKeyEvent& Event) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
if (!ShouldHandleEvent(SlateApp, Event))
{
return false;
}
ImGuiIO& IO = ImGui::GetIO();
IO.AddKeyEvent(ImGui::ConvertKey(Event.GetKey()), false);
const FModifierKeysState& ModifierKeys = Event.GetModifierKeys();
IO.AddKeyEvent(ImGuiMod_Ctrl, ModifierKeys.IsControlDown());
IO.AddKeyEvent(ImGuiMod_Shift, ModifierKeys.IsShiftDown());
IO.AddKeyEvent(ImGuiMod_Alt, ModifierKeys.IsAltDown());
IO.AddKeyEvent(ImGuiMod_Super, ModifierKeys.IsCommandDown());
return IO.WantCaptureKeyboard;
}
virtual bool HandleAnalogInputEvent(FSlateApplication& SlateApp, const FAnalogInputEvent& Event) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
if (!ShouldHandleEvent(SlateApp, Event))
{
return false;
}
ImGuiIO& IO = ImGui::GetIO();
const float Value = Event.GetAnalogValue();
IO.AddKeyAnalogEvent(ImGui::ConvertKey(Event.GetKey()), FMath::Abs(Value) > 0.1f, Value);
return IO.WantCaptureKeyboard;
}
virtual bool HandleMouseMoveEvent(FSlateApplication& SlateApp, const FPointerEvent& Event) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
if (!ShouldHandleEvent(SlateApp, Event))
{
return false;
}
ImGuiIO& IO = ImGui::GetIO();
const TSharedPtr<FSlateUser> SlateUser = SlateApp.GetUser(Event.GetUserIndex());
if (SlateUser.IsValid())
{
const FImGuiViewportData* TargetViewport = nullptr;
if (!SlateUser->HasCapture(Event.GetPointerIndex()))
{
const FWeakWidgetPath LastWidgetsUnderPointer = SlateUser->GetLastWidgetsUnderPointer(Event.GetPointerIndex());
TargetViewport = FindViewportForWindow(LastWidgetsUnderPointer.Window.Pin());
}
if (!TargetViewport && !ImGui::IsMouseDown(0))
{
IO.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
return false;
}
}
FVector2f Position = Event.GetScreenSpacePosition();
if (!(IO.ConfigFlags & ImGuiConfigFlags_ViewportsEnable))
{
// Mouse position for single viewport mode is in client space
Position -= Owner->GetTickSpaceGeometry().AbsolutePosition;
}
IO.AddMousePosEvent(Position.X, Position.Y);
return IO.WantCaptureMouse;
}
virtual bool HandleMouseButtonDownEvent(FSlateApplication& SlateApp, const FPointerEvent& Event) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
if (!ShouldHandleEvent(SlateApp, Event))
{
return false;
}
ImGuiIO& IO = ImGui::GetIO();
const FKey Button = Event.GetEffectingButton();
if (Button == EKeys::LeftMouseButton)
{
IO.AddMouseButtonEvent(ImGuiMouseButton_Left, true);
}
else if (Button == EKeys::RightMouseButton)
{
IO.AddMouseButtonEvent(ImGuiMouseButton_Right, true);
}
else if (Button == EKeys::MiddleMouseButton)
{
IO.AddMouseButtonEvent(ImGuiMouseButton_Middle, true);
}
return IO.WantCaptureMouse;
}
virtual bool HandleMouseButtonUpEvent(FSlateApplication& SlateApp, const FPointerEvent& Event) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
if (!ShouldHandleEvent(SlateApp, Event))
{
return false;
}
ImGuiIO& IO = ImGui::GetIO();
const FKey Button = Event.GetEffectingButton();
if (Button == EKeys::LeftMouseButton)
{
IO.AddMouseButtonEvent(ImGuiMouseButton_Left, false);
}
else if (Button == EKeys::RightMouseButton)
{
IO.AddMouseButtonEvent(ImGuiMouseButton_Right, false);
}
else if (Button == EKeys::MiddleMouseButton)
{
IO.AddMouseButtonEvent(ImGuiMouseButton_Middle, false);
}
return false;
}
virtual bool HandleMouseButtonDoubleClickEvent(FSlateApplication& SlateApp, const FPointerEvent& Event) override
{
// Treat as mouse down, ImGui handles double click internally
return HandleMouseButtonDownEvent(SlateApp, Event);
}
virtual bool HandleMouseWheelOrGestureEvent(FSlateApplication& SlateApp, const FPointerEvent& Event, const FPointerEvent* GestureEvent) override
{
ImGui::FScopedContext ScopedContext(Owner->GetContext());
if (!ShouldHandleEvent(SlateApp, Event))
{
return false;
}
ImGuiIO& IO = ImGui::GetIO();
IO.AddMouseWheelEvent(0.0f, Event.GetWheelDelta());
return IO.WantCaptureMouse;
}
bool ShouldHandleEvent(FSlateApplication& SlateApp, const FInputEvent& Event) const
{
#if WITH_EDITORONLY_DATA
if (GIntraFrameDebuggingGameThread)
{
// Discard input events when the game thread is paused for debugging
return false;
}
#endif
if (Event.IsKeyEvent())
{
const FImGuiViewportData* FocusedViewport = FindViewportForWindow(LastFocusedWindow.Pin());
return FocusedViewport != nullptr;
}
return true;
}
static FImGuiViewportData* FindViewportForWindow(const TSharedPtr<SWindow>& Window)
{
if (!Window.IsValid())
{
return nullptr;
}
for (ImGuiViewport* Viewport : ImGui::GetPlatformIO().Viewports)
{
FImGuiViewportData* ViewportData = FImGuiViewportData::GetOrCreate(Viewport);
if (ViewportData->Window == Window)
{
return ViewportData;
}
}
return nullptr;
}
private:
SImGuiOverlay* Owner = nullptr;
TWeakPtr<SWindow> LastFocusedWindow;
};
void SImGuiOverlay::Construct(const FArguments& Args)
{
SetVisibility(EVisibility::HitTestInvisible);
ForceVolatile(true);
Context = Args._Context.IsValid() ? Args._Context : FImGuiContext::Create();
if (Args._HandleInput)
{
InputProcessor = MakeShared<FImGuiInputProcessor>(this);
FSlateApplication::Get().RegisterInputPreProcessor(InputProcessor.ToSharedRef(), 0);
}
}
SImGuiOverlay::~SImGuiOverlay()
{
if (FSlateApplication::IsInitialized() && InputProcessor.IsValid())
{
FSlateApplication::Get().UnregisterInputPreProcessor(InputProcessor);
}
}
int32 SImGuiOverlay::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
if (!DrawData.bValid)
{
return LayerId;
}
const FSlateRenderTransform Transform(AllottedGeometry.GetAccumulatedRenderTransform().GetTranslation() - FVector2d(DrawData.DisplayPos));
TArray<FSlateVertex> Vertices;
TArray<SlateIndex> Indices;
FSlateBrush TextureBrush;
for (const FImGuiDrawList& DrawList : DrawData.DrawLists)
{
Vertices.SetNumUninitialized(DrawList.VtxBuffer.Size);
ImDrawVert* SrcVertex = DrawList.VtxBuffer.Data;
FSlateVertex* DstVertex = Vertices.GetData();
for (int32 BufferIdx = 0; BufferIdx < Vertices.Num(); ++BufferIdx, ++SrcVertex, ++DstVertex)
{
DstVertex->TexCoords[0] = SrcVertex->uv.x;
DstVertex->TexCoords[1] = SrcVertex->uv.y;
DstVertex->TexCoords[2] = 1;
DstVertex->TexCoords[3] = 1;
DstVertex->Position = TransformPoint(Transform, FVector2f(SrcVertex->pos));
DstVertex->Color.Bits = SrcVertex->col;
}
ImGui::CopyArray(DrawList.IdxBuffer, Indices);
for (const ImDrawCmd& DrawCmd : DrawList.CmdBuffer)
{
#if WITH_ENGINE
UTexture* Texture = DrawCmd.GetTexID();
if (TextureBrush.GetResourceObject() != Texture)
{
TextureBrush.SetResourceObject(Texture);
if (IsValid(Texture))
{
TextureBrush.ImageSize.X = Texture->GetSurfaceWidth();
TextureBrush.ImageSize.Y = Texture->GetSurfaceHeight();
TextureBrush.ImageType = ESlateBrushImageType::FullColor;
TextureBrush.DrawAs = ESlateBrushDrawType::Image;
}
else
{
TextureBrush.ImageSize.X = 0;
TextureBrush.ImageSize.Y = 0;
TextureBrush.ImageType = ESlateBrushImageType::NoImage;
TextureBrush.DrawAs = ESlateBrushDrawType::NoDrawType;
}
}
#else
FSlateBrush* Texture = DrawCmd.GetTexID();
if (Texture)
{
TextureBrush = *Texture;
}
else
{
TextureBrush.ImageSize.X = 0;
TextureBrush.ImageSize.Y = 0;
TextureBrush.ImageType = ESlateBrushImageType::NoImage;
TextureBrush.DrawAs = ESlateBrushDrawType::NoDrawType;
}
#endif
FSlateRect ClipRect(DrawCmd.ClipRect.x, DrawCmd.ClipRect.y, DrawCmd.ClipRect.z, DrawCmd.ClipRect.w);
ClipRect = TransformRect(Transform, ClipRect);
OutDrawElements.PushClip(FSlateClippingZone(ClipRect));
FSlateDrawElement::MakeCustomVerts(
OutDrawElements, LayerId, TextureBrush.GetRenderingResource(),
TArray(Vertices.GetData() + DrawCmd.VtxOffset, Vertices.Num() - DrawCmd.VtxOffset),
TArray(Indices.GetData() + DrawCmd.IdxOffset, DrawCmd.ElemCount),
nullptr, 0, 0
);
OutDrawElements.PopClip();
}
}
return LayerId;
}
FVector2D SImGuiOverlay::ComputeDesiredSize(float LayoutScaleMultiplier) const
{
return FVector2D::ZeroVector;
}
bool SImGuiOverlay::SupportsKeyboardFocus() const
{
return true;
}
FReply SImGuiOverlay::OnKeyChar(const FGeometry& MyGeometry, const FCharacterEvent& Event)
{
ImGui::FScopedContext ScopedContext(Context);
ImGuiIO& IO = ImGui::GetIO();
IO.AddInputCharacter(Event.GetCharacter());
return IO.WantTextInput ? FReply::Handled() : FReply::Unhandled();
}
TSharedPtr<FImGuiContext> SImGuiOverlay::GetContext() const
{
return Context;
}
void SImGuiOverlay::SetDrawData(const ImDrawData* InDrawData)
{
DrawData = FImGuiDrawData(InDrawData);
}
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Private/SImGuiOverlay.h
================================================
#pragma once
#ifndef IMGUI_DISABLE
#include <Framework/Application/IInputProcessor.h>
#include <Widgets/SLeafWidget.h>
THIRD_PARTY_INCLUDES_START
#include <imgui.h>
THIRD_PARTY_INCLUDES_END
struct FImGuiDrawList
{
FImGuiDrawList() = default;
explicit FImGuiDrawList(ImDrawList* Source);
ImVector<ImDrawVert> VtxBuffer;
ImVector<ImDrawIdx> IdxBuffer;
ImVector<ImDrawCmd> CmdBuffer;
ImDrawListFlags Flags = ImDrawListFlags_None;
};
struct FImGuiDrawData
{
FImGuiDrawData() = default;
explicit FImGuiDrawData(const ImDrawData* Source);
bool bValid = false;
int32 TotalIdxCount = 0;
int32 TotalVtxCount = 0;
TArray<FImGuiDrawList> DrawLists;
FVector2f DisplayPos = FVector2f::ZeroVector;
FVector2f DisplaySize = FVector2f::ZeroVector;
FVector2f FrameBufferScale = FVector2f::ZeroVector;
};
class SImGuiOverlay : public SLeafWidget
{
public:
SLATE_BEGIN_ARGS(SImGuiOverlay)
{
}
SLATE_ARGUMENT(TSharedPtr<FImGuiContext>, Context);
SLATE_ARGUMENT_DEFAULT(bool, HandleInput) = true;
SLATE_END_ARGS()
void Construct(const FArguments& Args);
virtual ~SImGuiOverlay() override;
virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override;
virtual FVector2D ComputeDesiredSize(float LayoutScaleMultiplier) const override;
virtual bool SupportsKeyboardFocus() const override;
virtual FReply OnKeyChar(const FGeometry& MyGeometry, const FCharacterEvent& Event) override;
TSharedPtr<FImGuiContext> GetContext() const;
void SetDrawData(const ImDrawData* InDrawData);
private:
TSharedPtr<FImGuiContext> Context = nullptr;
TSharedPtr<IInputProcessor> InputProcessor = nullptr;
FImGuiDrawData DrawData;
};
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Private/SImGuiWindow.cpp
================================================
#include "SImGuiWindow.h"
#ifndef IMGUI_DISABLE
THIRD_PARTY_INCLUDES_START
#include <imgui.h>
THIRD_PARTY_INCLUDES_END
void SImGuiWindow::Construct(const FArguments& Args)
{
const bool bTooltipWindow = (Args._Viewport->Flags & ImGuiViewportFlags_TopMost);
const bool bPopupWindow = (Args._Viewport->Flags & ImGuiViewportFlags_NoTaskBarIcon);
const bool bNoFocusOnAppearing = (Args._Viewport->Flags & ImGuiViewportFlags_NoFocusOnAppearing);
static FWindowStyle WindowStyle = FWindowStyle()
.SetActiveTitleBrush(FSlateNoResource())
.SetInactiveTitleBrush(FSlateNoResource())
.SetFlashTitleBrush(FSlateNoResource())
.SetOutlineBrush(FSlateNoResource())
.SetBorderBrush(FSlateNoResource())
.SetBackgroundBrush(FSlateNoResource())
.SetChildBackgroundBrush(FSlateNoResource());
SWindow::Construct(
SWindow::FArguments()
.Type(bTooltipWindow ? EWindowType::ToolTip : EWindowType::Normal)
.Style(&WindowStyle)
.ScreenPosition(FVector2f(Args._Viewport->Pos))
.ClientSize(FVector2f(Args._Viewport->Size))
.SupportsTransparency(EWindowTransparency::PerWindow)
.SizingRule(ESizingRule::UserSized)
.IsPopupWindow(bTooltipWindow || bPopupWindow)
.IsTopmostWindow(bTooltipWindow)
.FocusWhenFirstShown(!bNoFocusOnAppearing)
.ActivationPolicy(bNoFocusOnAppearing ? EWindowActivationPolicy::Never : EWindowActivationPolicy::Always)
.HasCloseButton(false)
.SupportsMaximize(false)
.SupportsMinimize(false)
.CreateTitleBar(false)
.LayoutBorder(0)
.UserResizeBorder(0)
.UseOSWindowBorder(false)
[
Args._Content.Widget
]
);
}
bool SImGuiWindow::OnIsActiveChanged(const FWindowActivateEvent& ActivateEvent)
{
// Force mouse activation to be handled as normal so focus is processed
if (ActivateEvent.GetActivationType() == FWindowActivateEvent::EA_ActivateByMouse)
{
const FWindowActivateEvent ModifiedActivateEvent(FWindowActivateEvent::EA_Activate, ActivateEvent.GetAffectedWindow());
return SWindow::OnIsActiveChanged(ModifiedActivateEvent);
}
return SWindow::OnIsActiveChanged(ActivateEvent);
}
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Private/SImGuiWindow.h
================================================
#pragma once
#ifndef IMGUI_DISABLE
#include <Widgets/SWindow.h>
struct ImGuiViewport;
class SImGuiWindow : public SWindow
{
SLATE_BEGIN_ARGS(SImGuiWindow)
{
}
SLATE_ARGUMENT(ImGuiViewport*, Viewport);
SLATE_DEFAULT_SLOT(FArguments, Content);
SLATE_END_ARGS()
void Construct(const FArguments& Args);
virtual bool OnIsActiveChanged(const FWindowActivateEvent& ActivateEvent) override;
};
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Public/ImGuiConfig.h
================================================
#pragma once
#ifndef IMGUI_DISABLE
#include <Math/Color.h>
#include <Math/IntPoint.h>
#include <Math/IntVector.h>
#include <Math/Vector2D.h>
#include <Math/Vector4.h>
#include <Misc/AssertionMacros.h>
#include <Misc/EngineVersionComparison.h>
class FImGuiContext;
class UTexture;
struct FInputChord;
struct FKey;
struct FSlateBrush;
enum ImGuiKey : int;
typedef int ImGuiKeyChord;
struct ImGuiContext;
struct ImPlotContext;
#define IM_ASSERT(Expr) ensure(Expr)
#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
#define IMGUI_DISABLE_WIN32_FUNCTIONS
#define IMGUI_DISABLE_DEFAULT_ALLOCATORS
#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
#define IMGUI_DISABLE_DEFAULT_SHELL_FUNCTIONS
#ifdef IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS
typedef IFileHandle* ImFileHandle;
ImFileHandle ImFileOpen(const char* FileName, const char* Mode);
bool ImFileClose(ImFileHandle File);
uint64 ImFileGetSize(ImFileHandle File);
uint64 ImFileRead(void* Data, uint64 Size, uint64 Count, ImFileHandle File);
uint64 ImFileWrite(const void* Data, uint64 Size, uint64 Count, ImFileHandle File);
#endif
#define IM_VEC2_CLASS_EXTRA \
operator FVector2f() const { return FVector2f(x, y); } \
constexpr ImVec2(const FVector2f& V) : x(V.X), y(V.Y) {} \
operator FVector2d() const { return FVector2d(x, y); } \
constexpr ImVec2(const FVector2d& V) : x(V.X), y(V.Y) {} \
operator FIntPoint() const { return FIntPoint(x, y); } \
constexpr ImVec2(const FIntPoint& V) : x(V.X), y(V.Y) {} \
operator FIntVector2() const { return FIntVector2(x, y); } \
constexpr ImVec2(const FIntVector2& V) : x(V.X), y(V.Y) {}
#define IM_VEC4_CLASS_EXTRA \
operator FVector4() const { return FVector4(x, y, z, w); } \
constexpr ImVec4(const FVector4& V) : x(V.X), y(V.Y), z(V.Z), w(V.W) {} \
operator FIntVector4() const { return FIntVector4(x, y, z, w); } \
constexpr ImVec4(const FIntVector4& V) : x(V.X), y(V.Y), z(V.Z), w(V.W) {} \
operator FLinearColor() const { return FLinearColor(x, y, z, w); } \
constexpr ImVec4(const FLinearColor& C) : x(C.R), y(C.G), z(C.B), w(C.A) {}
#define IM_COL32_R_SHIFT ImGui::ImCol32RShift
#define IM_COL32_G_SHIFT ImGui::ImCol32GShift
#define IM_COL32_B_SHIFT ImGui::ImCol32BShift
#define IM_COL32_A_SHIFT ImGui::ImCol32AShift
#define IM_COL32_A_MASK ImGui::ImCol32AMask
#if WITH_ENGINE
#define ImTextureID UTexture*
#else
#define ImTextureID FSlateBrush*
#endif
namespace ImGui
{
// Pack ImGui 32-bit colors so they're bit compatible with FColor
inline constexpr uint32 ImCol32RShift = offsetof(FColor, R) * 8;
inline constexpr uint32 ImCol32GShift = offsetof(FColor, G) * 8;
inline constexpr uint32 ImCol32BShift = offsetof(FColor, B) * 8;
inline constexpr uint32 ImCol32AShift = offsetof(FColor, A) * 8;
inline constexpr uint32 ImCol32AMask = (0xFF << ImCol32AShift);
/// Helper to safely scope ImGui drawing to a specific context; in most cases you should
/// use the default constructor to switch to the current game, editor, or PIE context:
/// @code
/// ImGui::FScopedContext ScopedContext;
/// if (ScopedContext)
/// {
/// ImGui::ShowDemoWindow();
/// }
/// @endcode
struct IMGUI_API FScopedContext
{
#if UE_VERSION_OLDER_THAN(5, 5, 0)
UE_NODISCARD_CTOR explicit FScopedContext(const int32 PieSessionId = GPlayInEditorID);
#else
UE_NODISCARD_CTOR explicit FScopedContext(const int32 PieSessionId = UE::GetPlayInEditorID());
#endif
UE_NODISCARD_CTOR explicit FScopedContext(const TSharedPtr<FImGuiContext>& InContext);
~FScopedContext();
/// Returns true if the underlying ImGui context is ready for drawing
explicit operator bool() const;
/// Returns true if the managed ImGui context is valid
bool IsValid() const;
/// Access to the managed ImGui context
FImGuiContext* operator->() const;
private:
TSharedPtr<FImGuiContext> Context = nullptr;
ImGuiContext* PrevContext = nullptr;
#if WITH_IMPLOT
ImPlotContext* PrevPlotContext = nullptr;
#endif
};
/// Converts from UE to ImGui key
IMGUI_API ImGuiKey ConvertKey(const FKey& Key);
/// Converts from ImGui to UE key
IMGUI_API FKey ConvertKey(const ImGuiKey Key);
/// Converts from UE to ImGui key chord
IMGUI_API ImGuiKeyChord ConvertKeyChord(const FInputChord& Chord);
/// Converts from ImGui to UE key chord
IMGUI_API FInputChord ConvertKeyChord(const ImGuiKeyChord Chord);
}
#define IMGUI_INCLUDE_IMGUI_USER_H
#define IMGUI_USER_H_FILENAME "ImGuiConfig.inl"
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Public/ImGuiConfig.inl
================================================
#pragma once
#ifndef IMGUI_DISABLE
namespace ImGui
{
/// Converts ImGui 32-bit color to UE color
IMGUI_API FORCEINLINE FColor ConvertColor(ImU32 Color)
{
return FColor(Color);
}
/// Copies ImGui array to UE array
template<typename SrcType, typename DstType UE_REQUIRES(std::is_constructible_v<DstType, SrcType>)>
void CopyArray(const ImVector<SrcType>& SrcArray, TArray<DstType>& DstArray)
{
DstArray = TArrayView<SrcType>(SrcArray.Data, SrcArray.Size);
}
}
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Public/ImGuiContext.h
================================================
#pragma once
#ifndef IMGUI_DISABLE
#include <Templates/SharedPointer.h>
#if WITH_ENGINE
#include <Engine/Texture2D.h>
#include <UObject/StrongObjectPtr.h>
#endif
class SWindow;
class SImGuiOverlay;
struct FDisplayMetrics;
struct FSlateBrush;
struct ImGuiContext;
struct ImGuiViewport;
struct ImPlotContext;
struct ImTextureData;
struct IMGUI_API FImGuiViewportData
{
/// Returns the existing viewport data or creates one
static FImGuiViewportData* GetOrCreate(ImGuiViewport* Viewport);
TWeakPtr<SWindow> Window = nullptr;
TWeakPtr<SImGuiOverlay> Overlay = nullptr;
};
class IMGUI_API FImGuiContext : public TSharedFromThis<FImGuiContext>
{
public:
/// Creates a managed ImGui context
static TSharedRef<FImGuiContext> Create();
/// Returns an existing managed ImGui context
static TSharedPtr<FImGuiContext> Get(const ImGuiContext* Context);
~FImGuiContext();
/// Begins a new frame
void BeginFrame();
/// Ends the current frame
void EndFrame();
#if WITH_NETIMGUI
/// Listens for remote connections
bool Listen(uint16 Port);
/// Connects to a remote host
bool Connect(const FString& Host, int16 Port);
/// Closes all remote connections
void Disconnect();
#endif
/// Access to the underlying ImGui context
operator ImGuiContext*() const;
#if WITH_IMPLOT
/// Access to the underlying ImPlot context
operator ImPlotContext*() const;
#endif
private:
void Initialize();
void OnDisplayMetricsChanged(const FDisplayMetrics& DisplayMetrics);
void CreateTexture(ImTextureData* TextureData);
void UpdateTexture(ImTextureData* TextureData);
void DestroyTexture(ImTextureData* TextureData);
ImGuiContext* Context = nullptr;
#if WITH_IMPLOT
ImPlotContext* PlotContext = nullptr;
#endif
char IniFilenameUtf8[1024] = {};
char LogFilenameUtf8[1024] = {};
TArray<char> ClipboardBuffer;
#if WITH_NETIMGUI
bool bIsRemote = false;
#endif
#if WITH_ENGINE
using FTextureRef = TStrongObjectPtr<UTexture>;
#else
using FTextureRef = TSharedPtr<FSlateBrush>;
#endif
TArray<FTextureRef> Textures;
};
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ImGui/Public/ImGuiModule.h
================================================
#pragma once
#ifndef IMGUI_DISABLE
#include <Misc/EngineVersionComparison.h>
#include <Modules/ModuleManager.h>
class FImGuiContext;
class SWindow;
class UGameViewportClient;
class IMGUI_API FImGuiModule : public IModuleInterface
{
public:
virtual void StartupModule() override;
virtual void ShutdownModule() override;
/// Returns this module's instance, loading it on demand if needed
/// @note Beware of calling this during the shutdown phase as the module might have been unloaded already
static FImGuiModule& Get();
/// Finds or creates an ImGui context for an editor or game session
/// @param PieSessionId Optional target Play-in-Editor instance, defaults to the current instance
#if UE_VERSION_OLDER_THAN(5, 5, 0)
TSharedPtr<FImGuiContext> FindOrCreateSessionContext(const int32 PieSessionId = GPlayInEditorID);
#else
TSharedPtr<FImGuiContext> FindOrCreateSessionContext(const int32 PieSessionId = UE::GetPlayInEditorID());
#endif
/// Creates an ImGui context for a Slate window
static TSharedPtr<FImGuiContext> CreateWindowContext(const TSharedRef<SWindow>& Window);
/// Creates an ImGui context for a game viewport
static TSharedPtr<FImGuiContext> CreateViewportContext(UGameViewportClient* GameViewport);
private:
void OnEndPIE(bool bIsSimulating);
void OnViewportCreated() const;
TMap<int32, TSharedPtr<FImGuiContext>> SessionContexts;
};
#endif // #ifndef IMGUI_DISABLE
================================================
FILE: Source/ThirdParty/ImGuiLibrary/ImGuiLibrary.Build.cs
================================================
using UnrealBuildTool;
public class ImGuiLibrary : ModuleRules
{
public ImGuiLibrary(ReadOnlyTargetRules Target) : base(Target)
{
Type = ModuleType.External;
PublicSystemIncludePaths.Add(ModuleDirectory);
}
}
================================================
FILE: Source/ThirdParty/ImGuiLibrary/LICENSE.txt
================================================
The MIT License (MIT)
Copyright (c) 2014-2026 Omar Cornut
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: Source/ThirdParty/ImGuiLibrary/imconfig.h
================================================
//-----------------------------------------------------------------------------
// DEAR IMGUI COMPILE-TIME OPTIONS
// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
//-----------------------------------------------------------------------------
// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
//-----------------------------------------------------------------------------
// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
// Call IMGUI_CHECKVERSION() from your .cpp file to verify that the data structures your files are using are matching the ones imgui.cpp is using.
//-----------------------------------------------------------------------------
#pragma once
//---- Define assertion handler. Defaults to calling assert().
// - If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
// - Compiling with NDEBUG will usually strip out assert() to nothing, which is NOT recommended because we use asserts to notify of programmer mistakes.
//#define IM_ASSERT(_EXPR) MyAssert(_EXPR)
//#define IM_ASSERT(_EXPR) ((void)(_EXPR)) // Disable asserts
//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
// - Windows DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
//#define IMGUI_API __declspec(dllexport) // MSVC Windows: DLL export
//#define IMGUI_API __declspec(dllimport) // MSVC Windows: DLL import
//#define IMGUI_API __attribute__((visibility("default"))) // GCC/Clang: override visibility when set is hidden
//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to clean your code of obsolete function/names.
//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
//---- Disable all of Dear ImGui or don't implement standard windows/tools.
// It is very strongly recommended to NOT disable the demo windows and debug tool during development. They are extremely useful in day to day work. Please read comments in imgui_demo.cpp.
//#define IMGUI_DISABLE // Disable everything: all headers and source files will be empty.
//#define IMGUI_DISABLE_DEMO_WINDOWS // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty.
//#define IMGUI_DISABLE_DEBUG_TOOLS // Disable metrics/debugger and other debug tools: ShowMetricsWindow(), ShowDebugLogWindow() and ShowIDStackToolWindow() will be empty.
//---- Don't implement some functions to reduce linkage requirements.
//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
//#define IMGUI_DISABLE_WIN32_FUNCTIONS // [Win32] Won't use and link with any Win32 function (clipboard, IME).
//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
//#define IMGUI_DISABLE_DEFAULT_SHELL_FUNCTIONS // Don't implement default platform_io.Platform_OpenInShellFn() handler (Win32: ShellExecute(), require shell32.lib/.a, Mac/Linux: use system("")).
//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
//#define IMGUI_DISABLE_FILE_FUNCTIONS // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
//#define IMGUI_DISABLE_DEFAULT_FONT // Disable default embedded fonts (ProggyClean/ProggyForever), remove ~9 KB + ~14 KB from output binary. AddFontDefaultXXX() functions will assert.
//#define IMGUI_DISABLE_SSE // Disable use of SSE intrinsics even if available
//---- Enable Test Engine / Automation features.
//#define IMGUI_ENABLE_TEST_ENGINE // Enable imgui_test_engine hooks. Generally set automatically by include "imgui_te_config.h", see Test Engine for details.
//---- Include imgui_user.h at the end of imgui.h as a convenience
// May be convenient for some users to only explicitly include vanilla imgui.h and have extra stuff included.
//#define IMGUI_INCLUDE_IMGUI_USER_H
//#define IMGUI_USER_H_FILENAME "my_folder/my_imgui_user.h"
//---- Pack vertex colors as BGRA8 instead of RGBA8 (to avoid converting from one to another). Need dedicated backend support.
//#define IMGUI_USE_BGRA_PACKED_COLOR
//---- Use legacy CRC32-adler tables (used before 1.91.6), in order to preserve old .ini data that you cannot afford to invalidate.
//#define IMGUI_USE_LEGACY_CRC32_ADLER
//---- Use 32-bit for ImWchar (default is 16-bit) to support Unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
//#define IMGUI_USE_WCHAR32
//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
//#define IMGUI_STB_TRUETYPE_FILENAME "my_folder/stb_truetype.h"
//#define IMGUI_STB_RECT_PACK_FILENAME "my_folder/stb_rect_pack.h"
//#define IMGUI_STB_SPRINTF_FILENAME "my_folder/stb_sprintf.h" // only used if IMGUI_USE_STB_SPRINTF is defined.
//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
//#define IMGUI_DISABLE_STB_SPRINTF_IMPLEMENTATION // only disabled if IMGUI_USE_STB_SPRINTF is defined.
//---- Use stb_sprintf.h for a faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
// Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by stb_sprintf.h.
//#define IMGUI_USE_STB_SPRINTF
//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
// Note that imgui_freetype.cpp may be used _without_ this define, if you manually call ImFontAtlas::SetFontLoader(). The define is simply a convenience.
// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
//#define IMGUI_ENABLE_FREETYPE
//---- Use FreeType + plutosvg or lunasvg to render OpenType SVG fonts (SVGinOT)
// Only works in combination with IMGUI_ENABLE_FREETYPE.
// - plutosvg is currently easier to install, as e.g. it is part of vcpkg. It will support more fonts and may load them faster. See misc/freetype/README for instructions.
// - Both require headers to be available in the include path + program to be linked with the library code (not provided).
// - (note: lunasvg implementation is based on Freetype's rsvg-port.c which is licensed under CeCILL-C Free Software License Agreement)
//#define IMGUI_ENABLE_FREETYPE_PLUTOSVG
//#define IMGUI_ENABLE_FREETYPE_LUNASVG
//---- Use stb_truetype to build and rasterize the font atlas (default)
// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
//#define IMGUI_ENABLE_STB_TRUETYPE
//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
// This will be inlined as part of ImVec2 and ImVec4 class declarations.
/*
#define IM_VEC2_CLASS_EXTRA \
constexpr ImVec2(const MyVec2& f) : x(f.x), y(f.y) {} \
operator MyVec2() const { return MyVec2(x,y); }
#define IM_VEC4_CLASS_EXTRA \
constexpr ImVec4(const MyVec4& f) : x(f.x), y(f.y), z(f.z), w(f.w) {} \
operator MyVec4() const { return MyVec4(x,y,z,w); }
*/
//---- ...Or use Dear ImGui's own very basic math operators.
//#define IMGUI_DEFINE_MATH_OPERATORS
//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
//#define ImDrawIdx unsigned int
//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
//struct ImDrawList;
//struct ImDrawCmd;
//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
//#define ImDrawCallback MyImDrawCallback
//---- Debug Tools: Macro to break in Debugger (we provide a default implementation of this in the codebase)
// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
//#define IM_DEBUG_BREAK IM_ASSERT(0)
//#define IM_DEBUG_BREAK __debugbreak()
//---- Debug Tools: Enable highlight ID conflicts _before_ hovering items. When io.ConfigDebugHighlightIdConflicts is set.
// (THIS WILL SLOW DOWN DEAR IMGUI. Only use occasionally and disable after use)
//#define IMGUI_DEBUG_HIGHLIGHT_ALL_ID_CONFLICTS
//---- Debug Tools: Enable slower asserts
//#define IMGUI_DEBUG_PARANOID
//---- Tip: You can add extra functions within the ImGui:: namespace from anywhere (e.g. your own sources/header files)
/*
namespace ImGui
{
void MyFunction(const char* name, MyMatrix44* mtx);
}
*/
================================================
FILE: Source/ThirdParty/ImGuiLibrary/imgui.cpp
================================================
// dear imgui, v1.92.6
// (main code and documentation)
// Help:
// - Call and read ImGui::ShowDemoWindow() in imgui_demo.cpp. All applications in examples/ are doing that.
// - Read top of imgui.cpp for more details, links and comments.
// - Add '#define IMGUI_DEFINE_MATH_OPERATORS' before including imgui.h (or in imconfig.h) to access courtesy maths operators for ImVec2 and ImVec4.
// Resources:
// - FAQ ........................ https://dearimgui.com/faq (in repository as docs/FAQ.md)
// - Homepage ................... https://github.com/ocornut/imgui
// - Releases & Changelog ....... https://github.com/ocornut/imgui/releases
// - Gallery .................... https://github.com/ocornut/imgui/issues?q=label%3Agallery (please post your screenshots/video there!)
// - Wiki ....................... https://github.com/ocornut/imgui/wiki (lots of good stuff there)
// - Getting Started https://github.com/ocornut/imgui/wiki/Getting-Started (how to integrate in an existing app by adding ~25 lines of code)
// - Third-party Extensions https://github.com/ocornut/imgui/wiki/Useful-Extensions (ImPlot & many more)
// - Bindings/Backends https://github.com/ocornut/imgui/wiki/Bindings (language bindings + backends for various tech/engines)
// - Debug Tools https://github.com/ocornut/imgui/wiki/Debug-Tools
// - Glossary https://github.com/ocornut/imgui/wiki/Glossary
// - Software using Dear ImGui https://github.com/ocornut/imgui/wiki/Software-using-dear-imgui
// - Issues & support ........... https://github.com/ocornut/imgui/issues
// - Test Engine & Automation ... https://github.com/ocornut/imgui_test_engine (test suite, test engine to automate your apps)
// - Web version of the Demo .... https://pthom.github.io/imgui_manual_online/manual/imgui_manual.html (w/ source code browser)
// For FIRST-TIME users having issues compiling/linking/running:
// please post in https://github.com/ocornut/imgui/discussions if you cannot find a solution in resources above.
// Everything else should be asked in 'Issues'! We are building a database of cross-linked knowledge there.
// Since 1.92, we encourage font loading questions to also be posted in 'Issues'.
// Copyright (c) 2014-2026 Omar Cornut
// Developed by Omar Cornut and every direct or indirect contributors to the GitHub.
// See LICENSE.txt for copyright and licensing details (standard MIT License).
// This library is free but needs your support to sustain development and maintenance.
// Businesses: you can support continued development via B2B invoiced technical support, maintenance and sponsoring contracts.
// PLEASE reach out at omar AT dearimgui DOT com. See https://github.com/ocornut/imgui/wiki/Funding
// Businesses: you can also purchase licenses for the Dear ImGui Automation/Test Engine.
// It is recommended that you don't modify imgui.cpp! It will become difficult for you to update the library.
// Note that 'ImGui::' being a namespace, you can add functions into the namespace from your own source files, without
// modifying imgui.h or imgui.cpp. You may include imgui_internal.h to access internal data structures, but it doesn't
// come with any guarantee of forward compatibility. Discussing your changes on the GitHub Issue Tracker may lead you
// to a better solution or official support for them.
/*
Index of this file:
DOCUMENTATION
- MISSION STATEMENT
- CONTROLS GUIDE
- PROGRAMMER GUIDE
- READ FIRST
- HOW TO UPDATE TO A NEWER VERSION OF DEAR IMGUI
- GETTING STARTED WITH INTEGRATING DEAR IMGUI IN YOUR CODE/ENGINE
- HOW A SIMPLE APPLICATION MAY LOOK LIKE
- USING CUSTOM BACKEND / CUSTOM ENGINE
- API BREAKING CHANGES (read me when you update!)
- FREQUENTLY ASKED QUESTIONS (FAQ)
- Read all answers online: https://www.dearimgui.com/faq, or in docs/FAQ.md (with a Markdown viewer)
CODE
(search for "[SECTION]" in the code to find them)
// [SECTION] INCLUDES
// [SECTION] FORWARD DECLARATIONS
// [SECTION] CONTEXT AND MEMORY ALLOCATORS
// [SECTION] USER FACING STRUCTURES (ImGuiStyle, ImGuiIO, ImGuiPlatformIO)
// [SECTION] MISC HELPERS/UTILITIES (Geometry functions)
// [SECTION] MISC HELPERS/UTILITIES (String, Format, Hash functions)
// [SECTION] MISC HELPERS/UTILITIES (File functions)
// [SECTION] MISC HELPERS/UTILITIES (ImText* functions)
// [SECTION] MISC HELPERS/UTILITIES (Color functions)
// [SECTION] ImGuiStorage
// [SECTION] ImGuiTextFilter
// [SECTION] ImGuiTextBuffer, ImGuiTextIndex
// [SECTION] ImGuiListClipper
// [SECTION] STYLING
// [SECTION] RENDER HELPERS
// [SECTION] INITIALIZATION, SHUTDOWN
// [SECTION] MAIN CODE (most of the code! lots of stuff, needs tidying up!)
// [SECTION] FONTS, TEXTURES
// [SECTION] ID STACK
// [SECTION] INPUTS
// [SECTION] ERROR CHECKING, STATE RECOVERY
// [SECTION] ITEM SUBMISSION
// [SECTION] LAYOUT
// [SECTION] SCROLLING
// [SECTION] TOOLTIPS
// [SECTION] POPUPS
// [SECTION] WINDOW FOCUS
// [SECTION] KEYBOARD/GAMEPAD NAVIGATION
// [SECTION] DRAG AND DROP
// [SECTION] LOGGING/CAPTURING
// [SECTION] SETTINGS
// [SECTION] LOCALIZATION
// [SECTION] VIEWPORTS, PLATFORM WINDOWS
// [SECTION] DOCKING
// [SECTION] PLATFORM DEPENDENT HELPERS
// [SECTION] METRICS/DEBUGGER WINDOW
// [SECTION] DEBUG LOG WINDOW
// [SECTION] OTHER DEBUG TOOLS (ITEM PICKER, ID STACK TOOL)
*/
//-----------------------------------------------------------------------------
// DOCUMENTATION
//-----------------------------------------------------------------------------
/*
MISSION STATEMENT
=================
- Easy to use to create code-driven and data-driven tools.
- Easy to use to create ad hoc short-lived tools and long-lived, more elaborate tools.
- Easy to hack and improve.
- Minimize setup and maintenance.
- Minimize state storage on user side.
- Minimize state synchronization.
- Portable, minimize dependencies, run on target (consoles, phones, etc.).
- Efficient runtime and memory consumption.
Designed primarily for developers and content-creators, not the typical end-user!
Some of the current weaknesses (which we aim to address in the future) includes:
- Doesn't look fancy by default.
- Limited layout features, intricate layouts are typically crafted in code.
CONTROLS GUIDE
==============
- MOUSE CONTROLS
- Mouse wheel: Scroll vertically.
- Shift+Mouse wheel: Scroll horizontally.
- Click [X]: Close a window, available when 'bool* p_open' is passed to ImGui::Begin().
- Click ^, Double-Click title: Collapse window.
- Drag on corner/border: Resize window (double-click to auto fit window to its contents).
- Drag on any empty space: Move window (unless io.ConfigWindowsMoveFromTitleBarOnly = true).
- Left-click outside popup: Close popup stack (right-click over underlying popup: Partially close popup stack).
- TEXT EDITOR
- Hold Shift or Drag Mouse: Select text.
- Ctrl+Left/Right: Word jump.
- Ctrl+Shift+Left/Right: Select words.
- Ctrl+A or Double-Click: Select All.
- Ctrl+X, Ctrl+C, Ctrl+V: Use OS clipboard.
- Ctrl+Z Undo.
- Ctrl+Y or Ctrl+Shift+Z: Redo.
- ESCAPE: Revert text to its original value.
- On macOS, controls are automatically adjusted to match standard macOS text editing and behaviors.
(for 99% of shortcuts, Ctrl is replaced by Cmd on macOS).
- KEYBOARD CONTROLS
- Basic:
- Tab, Shift+Tab Cycle through text editable fields.
- Ctrl+Tab, Ctrl+Shift+Tab Cycle through windows.
- Ctrl+Click Input text into a Slider or Drag widget.
- Extended features with `io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard`:
- Tab, Shift+Tab: Cycle through every items.
- Arrow keys Move through items using directional navigation. Tweak value.
- Arrow keys + Alt, Shift Tweak slower, tweak faster (when using arrow keys).
- Enter Activate item (prefer text input when possible).
- Space Activate item (prefer tweaking with arrows when possible).
- Escape Deactivate item, leave child window, close popup.
- Page Up, Page Down Previous page, next page.
- Home, End Scroll to top, scroll to bottom.
- Alt Toggle between scrolling layer and menu layer.
- Ctrl+Tab then Ctrl+Arrows Move window. Hold Shift to resize instead of moving.
- Output when ImGuiConfigFlags_NavEnableKeyboard set,
- io.WantCaptureKeyboard flag is set when keyboard is claimed.
- io.NavActive: true when a window is focused and it doesn't have the ImGuiWindowFlags_NoNavInputs flag set.
- io.NavVisible: true when the navigation cursor is visible (usually goes to back false when mouse is used).
- GAMEPAD CONTROLS
- Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
- Particularly useful to use Dear ImGui on a console system (e.g. PlayStation, Switch, Xbox) without a mouse!
- Download controller mapping PNG/PSD at http://dearimgui.com/controls_sheets
- Backend support: backend needs to:
- Set 'io.BackendFlags |= ImGuiBackendFlags_HasGamepad' + call io.AddKeyEvent/AddKeyAnalogEvent() with ImGuiKey_Gamepad_XXX keys.
- For analog values (0.0f to 1.0f), backend is responsible to handling a dead-zone and rescaling inputs accordingly.
Backend code will probably need to transform your raw inputs (such as e.g. remapping your 0.2..0.9 raw input range to 0.0..1.0 imgui range, etc.).
- If you need to share inputs between your game and the Dear ImGui interface, the easiest approach is to go all-or-nothing,
with a buttons combo to toggle the target. Please reach out if you think the game vs navigation input sharing could be improved.
- REMOTE INPUTS SHARING & MOUSE EMULATION
- PS4/PS5 users: Consider emulating a mouse cursor with DualShock touch pad or a spare analog stick as a mouse-emulation fallback.
- Consoles/Tablet/Phone users: Consider using a Synergy 1.x server (on your PC) + run examples/libs/synergy/uSynergy.c (on your console/tablet/phone app)
in order to share your PC mouse/keyboard.
- See https://github.com/ocornut/imgui/wiki/Useful-Extensions#remoting for other remoting solutions.
- On a TV/console system where readability may be lower or mouse inputs may be awkward, you may want to set the io.ConfigNavMoveSetMousePos flag.
Enabling io.ConfigNavMoveSetMousePos + ImGuiBackendFlags_HasSetMousePos instructs Dear ImGui to move your mouse cursor along with navigation movements.
When enabled, the NewFrame() function may alter 'io.MousePos' and set 'io.WantSetMousePos' to notify you that it wants the mouse cursor to be moved.
When that happens your backend NEEDS to move the OS or underlying mouse cursor on the next frame. Some of the backends in examples/ do that.
(If you set the NavEnableSetMousePos flag but don't honor 'io.WantSetMousePos' properly, Dear ImGui will misbehave as it will see your mouse moving back & forth!)
(In a setup when you may not have easy control over the mouse cursor, e.g. uSynergy.c doesn't expose moving remote mouse cursor, you may want
to set a boolean to ignore your other external mouse positions until the external source is moved again.)
PROGRAMMER GUIDE
================
READ FIRST
----------
- Remember to check the wonderful Wiki: https://github.com/ocornut/imgui/wiki
- Your code creates the UI every frame of your application loop, if your code doesn't run the UI is gone!
The UI can be highly dynamic, there are no construction or destruction steps, less superfluous
data retention on your side, less state duplication, less state synchronization, fewer bugs.
- Call and read ImGui::ShowDemoWindow() for demo code demonstrating most features.
Or browse https://pthom.github.io/imgui_manual_online/manual/imgui_manual.html for interactive web version.
- The library is designed to be built from sources. Avoid pre-compiled binaries and packaged versions. See imconfig.h to configure your build.
- Dear ImGui is an implementation of the IMGUI paradigm (immediate-mode graphical user interface, a term coined by Casey Muratori).
You can learn about IMGUI principles at http://www.johno.se/book/imgui.html, http://mollyrocket.com/861 & more links in Wiki.
- Dear ImGui is a "single pass" rasterizing implementation of the IMGUI paradigm, aimed at ease of use and high-performances.
For every application frame, your UI code will be called only once. This is in contrast to e.g. Unity's implementation of an IMGUI,
where the UI code is called multiple times ("multiple passes") from a single entry point. There are pros and cons to both approaches.
- Our origin is on the top-left. In axis aligned bounding boxes, Min = top-left, Max = bottom-right.
- Please make sure you have asserts enabled (IM_ASSERT redirects to assert() by default, but can be redirected).
If you get an assert, read the messages and comments around the assert.
- This codebase aims to be highly optimized:
- A typical idle frame should never call malloc/free.
- We rely on a maximum of constant-time or O(N) algorithms. Limiting searches/scans as much as possible.
- We put particular energy in making sure performances are decent with typical "Debug" build settings as well.
Which mean we tend to avoid over-relying on "zero-cost abstraction" as they aren't zero-cost at all.
- This codebase aims to be both highly opinionated and highly flexible:
- This code works because of the things it choose to solve or not solve.
- C++: this is a pragmatic C-ish codebase: we don't use fancy C++ features, we don't include C++ headers,
and ImGui:: is a namespace. We rarely use member functions (and when we did, I am mostly regretting it now).
This is to increase compatibility, increase maintainability and facilitate use from other languages.
- C++: ImVec2/ImVec4 do not expose math operators by default, because it is expected that you use your own math types.
See FAQ "How can I use my own math types instead of ImVec2/ImVec4?" for details about setting up imconfig.h for that.
We can can optionally export math operators for ImVec2/ImVec4 using IMGUI_DEFINE_MATH_OPERATORS, which we use internally.
- C++: pay attention that ImVector<> manipulates plain-old-data and does not honor construction/destruction
(so don't use ImVector in your code or at our own risk!).
- Building: We don't use nor mandate a build system for the main library.
This is in an effort to ensure that it works in the real world aka with any esoteric build setup.
This is also because providing a build system for the main library would be of little-value.
The build problems are almost never coming from the main library but from specific backends.
HOW TO UPDATE TO A NEWER VERSION OF DEAR IMGUI
----------------------------------------------
- Update submodule or copy/overwrite every file.
- About imconfig.h:
- You may modify your copy of imconfig.h, in this case don't overwrite it.
- or you may locally branch to modify imconfig.h and merge/rebase latest.
- or you may '#define IMGUI_USER_CONFIG "my_config_file.h"' globally from your build system to
specify a custom path for your imconfig.h file and instead not have to modify the default one.
- Overwrite all the sources files except for imconfig.h (if you have modified your copy of imconfig.h)
- Or maintain your own branch where you have imconfig.h modified as a top-most commit which you can regularly rebase over "master".
- You can also use '#define IMGUI_USER_CONFIG "my_config_file.h" to redirect configuration to your own file.
- Read the "API BREAKING CHANGES" section (below). This is where we list occasional API breaking changes.
If a function/type has been renamed / or marked obsolete, try to fix the name in your code before it is permanently removed
from the public API. If you have a problem with a missing function/symbols, search for its name in the code, there will
likely be a comment about it. Please report any issue to the GitHub page!
- To find out usage of old API, you can add '#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS' in your configuration file.
- Try to keep your copy of Dear ImGui reasonably up to date!
GETTING STARTED WITH INTEGRATING DEAR IMGUI IN YOUR CODE/ENGINE
---------------------------------------------------------------
- See https://github.com/ocornut/imgui/wiki/Getting-Started.
- Run and study the examples and demo in imgui_demo.cpp to get acquainted with the library.
- In the majority of cases you should be able to use unmodified backends files available in the backends/ folder.
- Add the Dear ImGui source files + selected backend source files to your projects or using your preferred build system.
It is recommended you build and statically link the .cpp files as part of your project and NOT as a shared library (DLL).
- You can later customize the imconfig.h file to tweak some compile-time behavior, such as integrating Dear ImGui types with your own maths types.
- When using Dear ImGui, your programming IDE is your friend: follow the declaration of variables, functions and types to find comments about them.
- Dear ImGui never touches or knows about your GPU state. The only function that knows about GPU is the draw function that you provide.
Effectively it means you can create widgets at any time in your code, regardless of considerations of being in "update" vs "render"
phases of your own application. All rendering information is stored into command-lists that you will retrieve after calling ImGui::Render().
- Refer to the backends and demo applications in the examples/ folder for instruction on how to setup your code.
- If you are running over a standard OS with a common graphics API, you should be able to use unmodified imgui_impl_*** files from the examples/ folder.
HOW A SIMPLE APPLICATION MAY LOOK LIKE
--------------------------------------
USING THE EXAMPLE BACKENDS (= imgui_impl_XXX.cpp files from the backends/ folder).
The sub-folders in examples/ contain examples applications following this structure.
// Application init: create a dear imgui context, setup some options, load fonts
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
// TODO: Set optional io.ConfigFlags values, e.g. 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard' to enable keyboard controls.
// TODO: Fill optional fields of the io structure later.
// TODO: Load TTF/OTF fonts if you don't want to use the default font.
// Initialize helper Platform and Renderer backends (here we are using imgui_impl_win32.cpp and imgui_impl_dx11.cpp)
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
// Application main loop
while (true)
{
// Feed inputs to dear imgui, start new frame
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
// Any application code here
ImGui::Text("Hello, world!");
// Render dear imgui into framebuffer
ImGui::Render();
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
g_pSwapChain->Present(1, 0);
}
// Shutdown
ImGui_ImplDX11_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
To decide whether to dispatch mouse/keyboard inputs to Dear ImGui to the rest of your application,
you should read the 'io.WantCaptureMouse', 'io.WantCaptureKeyboard' and 'io.WantTextInput' flags!
Please read the FAQ entry "How can I tell whether to dispatch mouse/keyboard to Dear ImGui or my application?" about this.
USING CUSTOM BACKEND / CUSTOM ENGINE
------------------------------------
IMPLEMENTING YOUR PLATFORM BACKEND:
-> see https://github.com/ocornut/imgui/blob/master/docs/BACKENDS.md for basic instructions.
-> the Platform backends in impl_impl_XXX.cpp files contain many implementations.
IMPLEMENTING YOUR RenderDrawData() function:
-> see https://github.com/ocornut/imgui/blob/master/docs/BACKENDS.md
-> the Renderer Backends in impl_impl_XXX.cpp files contain many implementations of a ImGui_ImplXXXX_RenderDrawData() function.
IMPLEMENTING SUPPORT for ImGuiBackendFlags_RendererHasTextures:
-> see https://github.com/ocornut/imgui/blob/master/docs/BACKENDS.md
-> the Renderer Backends in impl_impl_XXX.cpp files contain many implementations of a ImGui_ImplXXXX_UpdateTexture() function.
Basic application/backend skeleton:
// Application init: create a Dear ImGui context, setup some options, load fonts
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
// TODO: set io.ConfigXXX values, e.g.
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable keyboard controls
// TODO: Load TTF/OTF fonts if you don't want to use the default font.
io.Fonts->AddFontFromFileTTF("NotoSans.ttf");
// Application main loop
while (true)
{
// Setup low-level inputs, e.g. on Win32: calling GetKeyboardState(), or write to those fields from your Windows message handlers, etc.
// (In the examples/ app this is usually done within the ImGui_ImplXXX_NewFrame() function from one of the demo Platform Backends)
io.DeltaTime = 1.0f/60.0f; // set the time elapsed since the previous frame (in seconds)
io.DisplaySize.x = 1920.0f; // set the current display width
io.DisplaySize.y = 1280.0f; // set the current display height here
io.AddMousePosEvent(mouse_x, mouse_y); // update mouse position
io.AddMouseButtonEvent(0, mouse_b[0]); // update mouse button states
io.AddMouseButtonEvent(1, mouse_b[1]); // update mouse button states
// Call NewFrame(), after this point you can use ImGui::* functions anytime
// (So you want to try calling NewFrame() as early as you can in your main loop to be able to use Dear ImGui everywhere)
ImGui::NewFrame();
// Most of your application code here
ImGui::Text("Hello, world!");
MyGameUpdate(); // may use any Dear ImGui functions, e.g. ImGui::Begin("My window"); ImGui::Text("Hello, world!"); ImGui::End();
MyGameRender(); // may use any Dear ImGui functions as well!
// End the dear imgui frame
// (You want to try calling EndFrame/Render as late as you can, to be able to use Dear ImGui in your own game rendering code)
ImGui::EndFrame(); // this is automatically called by Render(), but available
ImGui::Render();
// Update textures
ImDrawData* draw_data = ImGui::GetDrawData();
for (ImTextureData* tex : *draw_data->Textures)
if (tex->Status != ImTextureStatus_OK)
MyImGuiBackend_UpdateTexture(tex);
// Render dear imgui contents, swap buffers
MyImGuiBackend_RenderDrawData(draw_data);
SwapBuffers();
}
// Shutdown
ImGui::DestroyContext();
API BREAKING CHANGES
====================
Occasionally introducing changes that are breaking the API. We try to make the breakage minor and easy to fix.
Below is a change-log of API breaking changes only. If you are using one of the functions listed, expect to have to fix some code.
When you are not sure about an old symbol or function name, try using the Search/Find function of your IDE to look for comments or references in all imgui files.
You can read releases logs https://github.com/ocornut/imgui/releases for more details.
(Docking/Viewport Branch)
- 2026/XX/XX (1.XXXX) - when multi-viewports are enabled, all positions will be in your natural OS coordinates space. It means that:
- reference to hard-coded positions such as in SetNextWindowPos(ImVec2(0,0)) are probably not what you want anymore.
you may use GetMainViewport()->Pos to offset hard-coded positions, e.g. SetNextWindowPos(GetMainViewport()->Pos)
- likewise io.MousePos and GetMousePos() will use OS coordinates.
If you query mouse positions to interact with non-imgui coordinates you will need to offset them, e.g. subtract GetWindowViewport()->Pos.
- 2026/01/08 (1.92.6) - Commented out legacy names obsoleted in 1.90 (Sept 2023): 'BeginChildFrame()' --> 'BeginChild()' with 'ImGuiChildFlags_FrameStyle'. 'EndChildFrame()' --> 'EndChild()'. 'ShowStackToolWindow()' --> 'ShowIDStackToolWindow()'. 'IM_OFFSETOF()' --> 'offsetof()'.
- 2026/01/07 (1.92.6) - Popups: changed compile-time 'ImGuiPopupFlags popup_flags = 1' default value to be '= 0' for BeginPopupContextItem(), BeginPopupContextWindow(), BeginPopupContextVoid(), OpenPopupOnItemClick(). Default value has same meaning before and after.
- Refer to GitHub topic #9157 if you have any question.
- Before this version, those functions had a 'ImGuiPopupFlags popup_flags = 1' default value in their function signature.
Explicitly passing a literal 0 meant ImGuiPopupFlags_MouseButtonLeft. The default literal 1 meant ImGuiPopupFlags_MouseButtonRight.
This was introduced by a change on 2020/06/23 (1.77) while changing the signature from 'int mouse_button' to 'ImGuiPopupFlags popup_flags' and trying to preserve then-legacy behavior.
We have now changed this behavior to cleanup a very old API quirk, facilitate use by bindings, and to remove the last and error-prone non-zero default value.
Also because we deemed it extremely rare to use those helper functions with the Left mouse button! As using the LMB would generally be triggered via another widget, e.g. a Button() + a OpenPopup()/BeginPopup() call.
- Before: The default = 1 means ImGuiPopupFlags_MouseButtonRight. Explicitly passing a literal 0 means ImGuiPopupFlags_MouseButtonLeft.
- After: The default = 0 means ImGuiPopupFlags_MouseButtonRight. Explicitly passing a literal 1 also means ImGuiPopupFlags_MouseButtonRight (if legacy behavior are enabled) or will assert (if legacy behavior are disabled).
- TL;DR: if you don't want to use right mouse button for popups, always specify it explicitly using a named ImGuiPopupFlags_MouseButtonXXXX value.
Recap:
- BeginPopupContextItem("foo"); // Behavior unchanged (use Right button)
- BeginPopupContextItem("foo", ImGuiPopupFlags_MouseButtonLeft); // Behavior unchanged (use Left button)
- BeginPopupContextItem("foo", ImGuiPopupFlags_MouseButtonLeft | xxx); // Behavior unchanged (use Left button + flags)
- BeginPopupContextItem("foo", ImGuiPopupFlags_MouseButtonRight | xxx); // Behavior unchanged (use Right button + flags)
- BeginPopupContextItem("foo", 1); // Behavior unchanged (as a courtesy we legacy interpret 1 as ImGuiPopupFlags_MouseButtonRight, will assert if disabling legacy behaviors.
- BeginPopupContextItem("foo", 0); // !! Behavior changed !! Was Left button. Now will defaults to Right button! --> Use ImGuiPopupFlags_MouseButtonLeft.
- BeginPopupContextItem("foo", ImGuiPopupFlags_NoReopen); // !! Behavior changed !! Was Left button + flags. Now will defaults to Right button! --> Use ImGuiPopupFlags_MouseButtonLeft | xxx.
- 2025/12/23 (1.92.6) - Fonts: AddFontDefault() now automatically selects an embedded font between the new scalable AddFontDefaultVector() and the classic pixel-clean AddFontDefaultBitmap().
The default selection is based on (style.FontSizeBase * FontScaleMain * FontScaleDpi) reaching a small threshold, but old codebases may not set any of them properly. As as a result, it is likely that old codebase may still default to AddFontDefaultBitmap().
Prefer calling either based on your own logic. You can call AddFontDefaultBitmap() to ensure legacy behavior.
- 2025/12/23 (1.92.6) - Fonts: removed ImFontConfig::PixelSnapV added in 1.92 which turns out is unnecessary (and misdocumented). Post-rescale GlyphOffset is always rounded.
- 2025/12/17 (1.92.6) - Renamed helper macro IM_ARRAYSIZE() -> IM_COUNTOF(). Kept redirection/legacy name for now.
- 2025/12/11 (1.92.6) - Hashing: handling of "###" operator to reset to seed within a string identifier doesn't include the "###" characters in the output hash anymore.
- Before: GetID("Hello###World") == GetID("###World") != GetID("World")
- After: GetID("Hello###World") == GetID("###World") == GetID("World")
- This has the property of facilitating concatenating and manipulating identifiers using "###", and will allow fixing other dangling issues.
- This will invalidate hashes (stored in .ini data) for Tables and Windows that are using the "###" operators. (#713, #1698)
- 2025/11/24 (1.92.6) - Fonts: Fixed handling of `ImFontConfig::FontDataOwnedByAtlas = false` which did erroneously make a copy of the font data, essentially defeating the purpose of this flag and wasting memory.
(trivia: undetected since July 2015, this is perhaps the oldest bug in Dear ImGui history, albeit for a rarely used feature, see #9086)
HOWEVER, fixing this bug is likely to surface bugs in user code using `FontDataOwnedByAtlas = false`.
- Prior to 1.92, font data only needed to be available during the atlas->AddFontXXX() call.
- Since 1.92, font data needs to available until atlas->RemoveFont(), or more typically until a shutdown of the owning context or font atlas.
- The fact that handling of `FontDataOwnedByAtlas = false` was broken bypassed the issue altogether.
- 2025/11/06 (1.92.5) - BeginChild: commented out some legacy names which were obsoleted in 1.90.0 (Nov 2023), 1.90.9 (July 2024), 1.91.1 (August 2024):
- ImGuiChildFlags_Border --> ImGuiChildFlags_Borders
- ImGuiWindowFlags_NavFlattened --> ImGuiChildFlags_NavFlattened (moved to ImGuiChildFlags). BeginChild(name, size, 0, ImGuiWindowFlags_NavFlattened) --> BeginChild(name, size, ImGuiChildFlags_NavFlattened, 0)
- ImGuiWindowFlags_AlwaysUseWindowPadding --> ImGuiChildFlags_AlwaysUseWindowPadding (moved to ImGuiChildFlags). BeginChild(name, size, 0, ImGuiWindowFlags_AlwaysUseWindowPadding) --> BeginChild(name, size, ImGuiChildFlags_AlwaysUseWindowPadding, 0)
- 2025/11/06 (1.92.5) - Keys: commented out legacy names which were obsoleted in 1.89.0 (August 2022):
- ImGuiKey_ModCtrl --> ImGuiMod_Ctrl
- ImGuiKey_ModShift --> ImGuiMod_Shift
- ImGuiKey_ModAlt --> ImGuiMod_Alt
- ImGuiKey_ModSuper --> ImGuiMod_Super
- 2025/11/06 (1.92.5) - IO: commented out legacy io.ClearInputCharacters() obsoleted in 1.89.8 (Aug 2023). Calling io.ClearInputKeys() is enough.
- 2025/11/06 (1.92.5) - Commented out legacy SetItemAllowOverlap() obsoleted in 1.89.7: this never worked right. Use SetNextItemAllowOverlap() _before_ item instead.
- 2025/10/14 (1.92.4) - TreeNode, Selectable, Clipper: commented out legacy names which were obsoleted in 1.89.7 (July 2023) and 1.89.9 (Sept 2023);
- ImGuiTreeNodeFlags_AllowItemOverlap --> ImGuiTreeNodeFlags_AllowOverlap
- ImGuiSelectableFlags_AllowItemOverlap --> ImGuiSelectableFlags_AllowOverlap
- ImGuiListClipper::IncludeRangeByIndices() --> ImGuiListClipper::IncludeItemsByIndex()
- 2025/09/22 (1.92.4) - Viewports: renamed io.ConfigViewportPlatformFocusSetsImGuiFocus to io.ConfigViewportsPlatformFocusSetsImGuiFocus. Was a typo in the first place. (#6299, #6462)
- 2025/08/08 (1.92.2) - Backends: SDL_GPU3: Changed ImTextureID type from SDL_GPUTextureSamplerBinding* to SDL_GPUTexture*, which is more natural and easier for user to manage. If you need to change the current sampler, you can access the ImGui_ImplSDLGPU3_RenderState struct. (#8866, #8163, #7998, #7988)
- 2025/07/31 (1.92.2) - Tabs: Renamed ImGuiTabBarFlags_FittingPolicyResizeDown to ImGuiTabBarFlags_FittingPolicyShrink. Kept inline redirection enum (will obsolete).
- 2025/06/25 (1.92.0) - Layout: commented out legacy ErrorCheckUsingSetCursorPosToExtendParentBoundaries() fallback obsoleted in 1.89 (August 2022) which allowed a SetCursorPos()/SetCursorScreenPos() call WITHOUT AN ITEM
to extend parent window/cell boundaries. Replaced with assert/tooltip that would already happens if previously using IMGUI_DISABLE_OBSOLETE_FUNCTIONS. (#5548, #4510, #3355, #1760, #1490, #4152, #150)
- Incorrect way to make a window content size 200x200:
Begin(...) + SetCursorScreenPos(GetCursorScreenPos() + ImVec2(200,200)) + End();
- Correct ways to make a window content size 200x200:
Begin(...) + SetCursorScreenPos(GetCursorScreenPos() + ImVec2(200,200)) + Dummy(ImVec2(0,0)) + End();
Begin(...) + Dummy(ImVec2(200,200)) + End();
- TL;DR; if the assert triggers, you can add a Dummy({0,0}) call to validate extending parent boundaries.
- 2025/06/11 (1.92.0) - Renamed/moved ImGuiConfigFlags_DpiEnableScaleFonts -> bool io.ConfigDpiScaleFonts.
- Renamed/moved ImGuiConfigFlags_DpiEnableScaleViewports -> bool io.ConfigDpiScaleViewports. **Neither of those flags are very useful in current code. They will be useful once we merge font changes.**
[there was a bug on 2025/06/12: when using the old config flags names, they were not imported correctly into the new ones, fixed on 2025/09/12]
- 2025/06/11 (1.92.0) - THIS VERSION CONTAINS THE LARGEST AMOUNT OF BREAKING CHANGES SINCE 2015! I TRIED REALLY HARD TO KEEP THEM TO A MINIMUM, REDUCE THE AMOUNT OF INTERFERENCES, BUT INEVITABLY SOME USERS WILL BE AFFECTED.
IN ORDER TO HELP US IMPROVE THE TRANSITION PROCESS, INCL. DOCUMENTATION AND COMMENTS, PLEASE REPORT **ANY** DOUBT, CONFUSION, QUESTIONS, FEEDBACK TO: https://github.com/ocornut/imgui/issues/
As part of the plan to reduce impact of API breaking changes, several unfinished changes/features/refactors related to font and text systems and scaling will be part of subsequent releases (1.92.1+).
If you are updating from an old version, and expecting a massive or difficult update, consider first updating to 1.91.9 to reduce the amount of changes.
- Hard to read? Refer to 'docs/Changelog.txt' for a less compact and more complete version of this!
- Fonts: **IMPORTANT**: if your app was solving the OSX/iOS Retina screen specific logical vs display scale problem by setting io.DisplayFramebufferScale (e.g. to 2.0f) + setting io.FontGlobalScale (e.g. to 1.0f/2.0f) + loading fonts at scaled sizes (e.g. size X * 2.0f):
This WILL NOT map correctly to the new system! Because font will rasterize as requested size.
- With a legacy backend (< 1.92): Instead of setting io.FontGlobalScale = 1.0f/N -> set ImFontCfg::RasterizerDensity = N. This already worked before, but is now pretty much required.
- With a new backend (1.92+): This should be all automatic. FramebufferScale is automatically used to set current font RasterizerDensity. FramebufferScale is a per-viewport property provided by backend through the Platform_GetWindowFramebufferScale() handler in 'docking' branch.
- Fonts: **IMPORTANT** on Font Sizing: Before 1.92, fonts were of a single size. They can now be dynamically sized.
- PushFont() API now has a REQUIRED size parameter.
- Before 1.92: PushFont() always used font "default" size specified in AddFont() call. It is equivalent to calling PushFont(font, font->LegacySize).
- Since 1.92: PushFont(font, 0.0f) preserve the current font size which is a shared value.
- To use old behavior: use 'ImGui::PushFont(font, font->LegacySize)' at call site.
- Kept inline single parameter function. Will obsolete.
- Fonts: **IMPORTANT** on Font Merging:
- When searching for a glyph in multiple merged fonts: we search for the FIRST font source which contains the desired glyph.
Because the user doesn't need to provide glyph ranges any more, it is possible that a glyph that you expected to fetch from a secondary/merged icon font may be erroneously fetched from the primary font.
- When searching for a glyph in multiple merged fonts: we now search for the FIRST font source which contains the desired glyph. This is technically a different behavior than before!
- e.g. If you are merging fonts you may have glyphs that you expected to load from Font Source 2 which exists in Font Source 1.
After the update and when using a new backend, those glyphs may now loaded from Font Source 1!
- We added `ImFontConfig::GlyphExcludeRanges[]` to specify ranges to exclude from a given font source:
// Add Font Source 1 but ignore ICON_MIN_FA..ICON_MAX_FA range
static ImWchar exclude_ranges[] = { ICON_MIN_FA, ICON_MAX_FA, 0 };
ImFontConfig cfg1;
cfg1.GlyphExcludeRanges = exclude_ranges;
io.Fonts->AddFontFromFileTTF("segoeui.ttf", 0.0f, &cfg1);
// Add Font Source 2, which expects to use the range above
ImFontConfig cfg2;
cfg2.MergeMode = true;
io.Fonts->AddFontFromFileTTF("FontAwesome4.ttf", 0.0f, &cfg2);
- You can use `Metrics/Debugger->Fonts->Font->Input Glyphs Overlap Detection Tool` to see list of glyphs available in multiple font sources. This can facilitate understanding which font input is providing which glyph.
- Fonts: **IMPORTANT** on Thread Safety:
- A few functions such as font->CalcTextSizeA() were, by sheer luck (== accidentally) thread-safe even though we had never provided that guarantee. They are definitively not thread-safe anymore as new glyphs may be loaded.
- Fonts: ImFont::FontSize was removed and does not make sense anymore. ImFont::LegacySize is the size passed to AddFont().
- Fonts: Removed support for PushFont(NULL) which was a shortcut for "default font".
- Fonts: Renamed/moved 'io.FontGlobalScale' to 'style.FontScaleMain'.
- Textures: all API functions taking a 'ImTextureID' parameter are now taking a 'ImTextureRef'. Affected functions are: ImGui::Image(), ImGui::ImageWithBg(), ImGui::ImageButton(), ImDrawList::AddImage(), ImDrawList::AddImageQuad(), ImDrawList::AddImageRounded().
- Fonts: obsoleted ImFontAtlas::GetTexDataAsRGBA32(), GetTexDataAsAlpha8(), Build(), SetTexID(), IsBuilt() functions. The new protocol for backends to handle textures doesn't need them. Kept redirection functions (will obsolete).
- Fonts: ImFontConfig::OversampleH/OversampleV default to automatic (== 0) since v1.91.8. It is quite important you keep it automatic until we decide if we want to provide a way to express finer policy, otherwise you will likely waste texture space when using large glyphs. Note that the imgui_freetype backend doesn't use and does not need oversampling.
- Fonts: specifying glyph ranges is now unnecessary. The value of ImFontConfig::GlyphRanges[] is only useful for legacy backends. All GetGlyphRangesXXXX() functions are now marked obsolete: GetGlyphRangesDefault(), GetGlyphRangesGreek(), GetGlyphRangesKorean(), GetGlyphRangesJapanese(), GetGlyphRangesChineseSimplifiedCommon(), GetGlyphRangesChineseFull(), GetGlyphRangesCyrillic(), GetGlyphRangesThai(), GetGlyphRangesVietnamese().
- Fonts: removed ImFontAtlas::TexDesiredWidth to enforce a texture width. (#327)
- Fonts: if you create and manage ImFontAtlas instances yourself (instead of relying on ImGuiContext to create one), you'll need to call ImFontAtlasUpdateNewFrame() yourself. An assert will trigger if you don't.
- Fonts: obsolete ImGui::SetWindowFontScale() which is not useful anymore. Prefer using 'PushFont(NULL, style.FontSizeBase * factor)' or to manipulate other scaling factors.
- Fonts: obsoleted ImFont::Scale which is not useful anymore.
- Fonts: generally reworked Internals of ImFontAtlas and ImFont. While in theory a vast majority of users shouldn't be affected, some use cases or extensions might be. Among other things:
- ImDrawCmd::TextureId has been changed to ImDrawCmd::TexRef.
- ImFontAtlas::TexID has been changed to ImFontAtlas::TexRef.
- ImFontAtlas::ConfigData[] has been renamed to ImFontAtlas::Sources[]
- ImFont::ConfigData[], ConfigDataCount has been renamed to Sources[], SourceCount.
- Each ImFont has a number of ImFontBaked instances corresponding to actively used sizes. ImFont::GetFontBaked(size) retrieves the one for a given size.
- Fields moved from ImFont to ImFontBaked: IndexAdvanceX[], Glyphs[], Ascent, Descent, FindGlyph(), FindGlyphNoFallback(), GetCharAdvance().
- Fields moved from ImFontAtlas to ImFontAtlas->Tex: ImFontAtlas::TexWidth => TexData->Width, ImFontAtlas::TexHeight => TexData->Height, ImFontAtlas::TexPixelsAlpha8/TexPixelsRGBA32 => TexData->GetPixels().
- Widget code may use ImGui::GetFontBaked() instead of ImGui::GetFont() to access font data for current font at current font size (and you may use font->GetFontBaked(size) to access it for any other size.)
- Fonts: (users of imgui_freetype): renamed ImFontAtlas::FontBuilderFlags to ImFontAtlas::FontLoaderFlags. Renamed ImFontConfig::FontBuilderFlags to ImFontConfig::FontLoaderFlags. Renamed ImGuiFreeTypeBuilderFlags to ImGuiFreeTypeLoaderFlags.
If you used runtime imgui_freetype selection rather than the default IMGUI_ENABLE_FREETYPE compile-time option: Renamed/reworked ImFontBuilderIO into ImFontLoader. Renamed ImGuiFreeType::GetBuilderForFreeType() to ImGuiFreeType::GetFontLoader().
- old: io.Fonts->FontBuilderIO = ImGuiFreeType::GetBuilderForFreeType()
- new: io.Fonts->FontLoader = ImGuiFreeType::GetFontLoader()
- new: io.Fonts->SetFontLoader(ImGuiFreeType::GetFontLoader()) to change dynamically at runtime [from 1.92.1]
- Fonts: (users of custom rectangles, see #8466): Renamed AddCustomRectRegular() to AddCustomRect(). Added GetCustomRect() as a replacement for GetCustomRectByIndex() + CalcCustomRectUV().
- The output type of GetCustomRect() is now ImFontAtlasRect, which include UV coordinates. X->x, Y->y, Width->w, Height->h.
- old:
const ImFontAtlasCustomRect* r = atlas->GetCustomRectByIndex(custom_rect_id);
ImVec2 uv0, uv1;
atlas->GetCustomRectUV(r, &uv0, &uv1);
ImGui::Image(atlas->TexRef, ImVec2(r->w, r->h), uv0, uv1);
- new;
ImFontAtlasRect r;
atlas->GetCustomRect(custom_rect_id, &r);
ImGui::Image(atlas->TexRef, ImVec2(r.w, r.h), r.uv0, r.uv1);
- We added a redirecting typedef but haven't attempted to magically redirect the field names, as this API is rarely used and the fix is simple.
- Obsoleted AddCustomRectFontGlyph() as the API does not make sense for scalable fonts. Kept existing function which uses the font "default size" (Sources[0]->LegacySize). Added a helper AddCustomRectFontGlyphForSize() which is immediately marked obsolete, but can facilitate transitioning old code.
- Prefer adding a font source (ImFontConfig) using a custom/procedural loader.
- DrawList: Renamed ImDrawList::PushTextureID()/PopTextureID() to PushTexture()/PopTexture().
- Backends: removed ImGui_ImplXXXX_CreateFontsTexture()/ImGui_ImplXXXX_DestroyFontsTexture() for all backends that had them. They should not be necessary any more.
- 2025/05/23 (1.92.0) - Fonts: changed ImFont::CalcWordWrapPositionA() to ImFont::CalcWordWrapPosition()
- old: const char* ImFont::CalcWordWrapPositionA(float scale, const char* text, ....);
- new: const char* ImFont::CalcWordWrapPosition (float size, const char* text, ....);
The leading 'float scale' parameters was changed to 'float size'. This was necessary as 'scale' is assuming standard font size which is a concept we aim to eliminate in an upcoming update. Kept inline redirection function.
- 2025/05/15 (1.92.0) - TreeNode: renamed ImGuiTreeNodeFlags_NavLeftJumpsBackHere to ImGuiTreeNodeFlags_NavLeftJumpsToParent for clarity. Kept inline redirection enum (will obsolete).
- 2025/05/15 (1.92.0) - Commented out PushAllowKeyboardFocus()/PopAllowKeyboardFocus() which was obsoleted in 1.89.4. Use PushItemFlag(ImGuiItemFlags_NoTabStop, !tab_stop)/PopItemFlag() instead. (#3092)
- 2025/05/15 (1.92.0) - Commented out ImGuiListClipper::ForceDisplayRangeByIndices() which was obsoleted in 1.89.6. Use ImGuiListClipper::IncludeItemsByIndex() instead.
- 2025/03/05 (1.91.9) - BeginMenu(): Internals: reworked mangling of menu windows to use "###Menu_00" etc. instead of "##Menu_00", allowing them to also store the menu name before it. This shouldn't affect code unless directly accessing menu window from their mangled name.
- 2025/04/16 (1.91.9) - Internals: RenderTextEllipsis() function removed the 'float clip_max_x' parameter directly preceding 'float ellipsis_max_x'. Values were identical for a vast majority of users. (#8387)
- 2025/02/27 (1.91.9) - Image(): removed 'tint_col' and 'border_col' parameter from Image() function. Added ImageWithBg() replacement. (#8131, #8238)
- old: void Image (ImTextureID tex_id, ImVec2 image_size, ImVec2 uv0 = (0,0), ImVec2 uv1 = (1,1), ImVec4 tint_col = (1,1,1,1), ImVec4 border_col = (0,0,0,0));
- new: void Image (ImTextureID tex_id, ImVec2 image_size, ImVec2 uv0 = (0,0), ImVec2 uv1 = (1,1));
- new: void ImageWithBg(ImTextureID tex_id, ImVec2 image_size, ImVec2 uv0 = (0,0), ImVec2 uv1 = (1,1), ImVec4 bg_col = (0,0,0,0), ImVec4 tint_col = (1,1,1,1));
- TL;DR: 'border_col' had misleading side-effect on layout, 'bg_col' was missing, parameter order couldn't be consistent with ImageButton().
- new behavior always use ImGuiCol_Border color + style.ImageBorderSize / ImGuiStyleVar_ImageBorderSize.
- old behavior altered border size (and therefore layout) based on border color's alpha, which caused variety of problems + old behavior a fixed 1.0f for border size which was not tweakable.
- kept legacy signature (will obsolete), which mimics the old behavior, but uses Max(1.0f, style.ImageBorderSize) when border_col is specified.
- added ImageWithBg() function which has both 'bg_col' (which was missing) and 'tint_col'. It was impossible to add 'bg_col' to Image() with a parameter order consistent with other functions, so we decided to remove 'tint_col' and introduce ImageWithBg().
- 2025/02/25 (1.91.9) - internals: fonts: ImFontAtlas::ConfigData[] has been renamed to ImFontAtlas::Sources[]. ImFont::ConfigData[], ConfigDataCount has been renamed to Sources[], SourcesCount.
- 2025/02/06 (1.91.9) - renamed ImFontConfig::GlyphExtraSpacing.x to ImFontConfig::GlyphExtraAdvanceX.
- 2025/01/22 (1.91.8) - removed ImGuiColorEditFlags_AlphaPreview (made value 0): it is now the default behavior.
prior to 1.91.8: alpha was made opaque in the preview by default _unless_ using ImGuiColorEditFlags_AlphaPreview. We now display the preview as transparent by default. You can use ImGuiColorEditFlags_AlphaOpaque to use old behavior.
the new flags (ImGuiColorEditFlags_AlphaOpaque, ImGuiColorEditFlags_AlphaNoBg + existing ImGuiColorEditFlags_AlphaPreviewHalf) may be combined better and allow finer controls:
- 2025/01/14 (1.91.7) - renamed ImGuiTreeNodeFlags_SpanTextWidth to ImGuiTreeNodeFlags_SpanLabelWidth for consistency with other names. Kept redirection enum (will obsolete). (#6937)
- 2024/11/27 (1.91.6) - changed CRC32 table from CRC32-adler to CRC32c polynomial in order to be compatible with the result of SSE 4.2 instructions.
As a result, old .ini data may be partially lost (docking and tables information particularly).
Because some users have crafted and storing .ini data as a way to workaround limitations of the docking API, we are providing a '#define IMGUI_USE_LEGACY_CRC32_ADLER' compile-time option to keep using old CRC32 tables if you cannot afford invalidating old .ini data.
- 2024/11/06 (1.91.5) - commented/obsoleted out pre-1.87 IO system (equivalent to using IMGUI_DISABLE_OBSOLETE_KEYIO or IMGUI_DISABLE_OBSOLETE_FUNCTIONS before)
- io.KeyMap[] and io.KeysDown[] are removed (obsoleted February 2022).
- io.NavInputs[] and ImGuiNavInput are removed (obsoleted July 2022).
- GetKeyIndex() is removed (obsoleted March 2022). The indirection is now unnecessary.
- pre-1.87 backends are not supported:
- backends need to call io.AddKeyEvent(), io.AddMouseEvent() instead of writing to io.KeysDown[], io.MouseDown[] fields.
- backends need to call io.AddKeyAnalogEvent() for gamepad values instead of writing to io.NavInputs[] fields.
- for more reference:
- read 1.87 and 1.88 part of this section or read Changelog for 1.87 and 1.88.
- read https://github.com/ocornut/imgui/issues/4921
- if you have trouble updating a very old codebase using legacy backend-specific key codes: consider updating to 1.91.4 first, then #define IMGUI_DISABLE_OBSOLETE_KEYIO, then update to latest.
- obsoleted ImGuiKey_COUNT (it is unusually error-prone/misleading since valid keys don't start at 0). probably use ImGuiKey_NamedKey_BEGIN/ImGuiKey_NamedKey_END?
- fonts: removed const qualifiers from most font functions in prevision for upcoming font improvements.
- 2024/10/18 (1.91.4) - renamed ImGuiCol_NavHighlight to ImGuiCol_NavCursor (for consistency with newly exposed and reworked features). Kept inline redirection enum (will obsolete).
- 2024/10/14 (1.91.4) - moved ImGuiConfigFlags_NavEnableSetMousePos to standalone io.ConfigNavMoveSetMousePos bool.
moved ImGuiConfigFlags_NavNoCaptureKeyboard to standalone io.ConfigNavCaptureKeyboard bool (note the inverted value!).
kept legacy names (will obsolete) + code that copies settings once the first time. Dynamically changing the old value won't work. Switch to using the new value!
- 2024/10/10 (1.91.4) - the typedef for ImTextureID now defaults to ImU64 instead of void*. (#1641)
this removes the requirement to redefine it for backends which are e.g. storing descriptor sets or other 64-bits structures when building on 32-bits archs. It therefore simplify various building scripts/helpers.
you may have compile-time issues if you were casting to 'void*' instead of 'ImTextureID' when passing your types to functions taking ImTextureID values, e.g. ImGui::Image().
in doubt it is almost always better to do an intermediate intptr_t cast, since it allows casting any pointer/integer type without warning:
- May warn: ImGui::Image((void*)MyTextureData, ...);
- May warn: ImGui::Image((void*)(intptr_t)MyTextureData, ...);
- Won't warn: ImGui::Image((ImTextureID)(intptr_t)MyTextureData, ...);
- note that you can always define ImTextureID to be your own high-level structures (with dedicated constructors) if you like.
- 2024/10/03 (1.91.3) - drags: treat v_min==v_max as a valid clamping range when != 0.0f. Zero is a still special value due to legacy reasons, unless using ImGuiSliderFlags_ClampZeroRange. (#7968, #3361, #76)
- drags: extended behavior of ImGuiSliderFlags_AlwaysClamp to include _ClampZeroRange. It considers v_min==v_max==0.0f as a valid clamping range (aka edits not allowed).
although unlikely, it you wish to only clamp on text input but want v_min==v_max==0.0f to mean unclamped drags, you can use _ClampOnInput instead of _AlwaysClamp. (#7968, #3361, #76)
- 2024/09/10 (1.91.2) - internals: using multiple overlaid ButtonBehavior() with same ID will now have io.ConfigDebugHighlightIdConflicts=true feature emit a warning. (#8030)
it was one of the rare case where using same ID is legal. workarounds: (1) use single ButtonBehavior() call with multiple _MouseButton flags, or (2) surround the calls with PushItemFlag(ImGuiItemFlags_AllowDuplicateId, true); ... PopItemFlag()
- 2024/08/23 (1.91.1) - renamed ImGuiChildFlags_Border to ImGuiChildFlags_Borders for consistency. kept inline redirection flag.
- 2024/08/22 (1.91.1) - moved some functions from ImGuiIO to ImGuiPlatformIO structure:
- io.GetClipboardTextFn -> platform_io.Platform_GetClipboardTextFn + changed 'void* user_data' to 'ImGuiContext* ctx'. Pull your user data from platform_io.ClipboardUserData.
- io.SetClipboardTextFn -> platform_io.Platform_SetClipboardTextFn + same as above line.
- io.PlatformOpenInShellFn -> platform_io.Platform_OpenInShellFn (#7660)
- io.PlatformSetImeDataFn -> platform_io.Platform_SetImeDataFn
- io.PlatformLocaleDecimalPoint -> platform_io.Platform_LocaleDecimalPoint (#7389, #6719, #2278)
- access those via GetPlatformIO() instead of GetIO().
some were introduced very recently and often automatically setup by core library and backends, so for those we are exceptionally not maintaining a legacy redirection symbol.
- commented the old ImageButton() signature obsoleted in 1.89 (~August 2022). As a reminder:
- old ImageButton() before 1.89 used ImTextureId as item id (created issue with e.g. multiple buttons in same scope, transient texture id values, opaque computation of ID)
- new ImageButton() since 1.89 requires an explicit 'const char* str_id'
- old ImageButton() before 1.89 had frame_padding' override argument.
- new ImageButton() since 1.89 always use style.FramePadding, which you can freely override with PushStyleVar()/PopStyleVar().
- 2024/07/25 (1.91.0) - obsoleted GetContentRegionMax(), GetWindowContentRegionMin() and GetWindowContentRegionMax(). (see #7838 on GitHub for more info)
you should never need those functions. you can do everything with GetCursorScreenPos() and GetContentRegionAvail() in a more simple way.
- instead of: GetWindowContentRegionMax().x - GetCursorPos().x
- you can use: GetContentRegionAvail().x
- instead of: GetWindowContentRegionMax().x + GetWindowPos().x
- you can use: GetCursorScreenPos().x + GetContentRegionAvail().x // when called from left edge of window
- instead of: GetContentRegionMax()
- you can use: GetContentRegionAvail() + GetCursorScreenPos() - GetWindowPos() // right edge in local coordinates
- instead of: GetWindowContentRegionMax().x - GetWindowContentRegionMin().x
- you can use: GetContentRegionAvail() // when called from left edge of window
- 2024/07/15 (1.91.0) - renamed ImGuiSelectableFlags_DontClosePopups to ImGuiSelectableFlags_NoAutoClosePopups. (#1379, #1468, #2200, #4936, #5216, #7302, #7573)
(internals: also renamed ImGuiItemFlags_SelectableDontClosePopup into ImGuiItemFlags_AutoClosePopups with inverted behaviors)
- 2024/07/15 (1.91.0) - obsoleted PushButtonRepeat()/PopButtonRepeat() in favor of using new PushItemFlag(ImGuiItemFlags_ButtonRepeat, ...)/PopItemFlag().
- 2024/07/02 (1.91.0) - commented out obsolete ImGuiModFlags (renamed to ImGuiKeyChord in 1.89). (#4921, #456)
- commented out obsolete ImGuiModFlags_XXX values (renamed to ImGuiMod_XXX in 1.89). (#4921, #456)
- ImGuiModFlags_Ctrl -> ImGuiMod_Ctrl, ImGuiModFlags_Shift -> ImGuiMod_Shift etc.
- 2024/07/02 (1.91.0) - IO, IME: renamed platform IME hook and added explicit context for consistency and future-proofness.
- old: io.SetPlatformImeDataFn(ImGuiViewport* viewport, ImGuiPlatformImeData* data);
- new: io.PlatformSetImeDataFn(ImGuiContext* ctx, ImGuiViewport* viewport, ImGuiPlatformImeData* data);
- 2024/06/21 (1.90.9) - BeginChild: added ImGuiChildFlags_NavFlattened as a replacement for the window flag ImGuiWindowFlags_NavFlattened: the feature only ever made sense for BeginChild() anyhow.
- old: BeginChild("Name", size, 0, ImGuiWindowFlags_NavFlattened);
- new: BeginChild("Name", size, ImGuiChildFlags_NavFlattened, 0);
- 2024/06/21 (1.90.9) - io: ClearInputKeys() (first exposed in 1.89.8) doesn't clear mouse data, newly added ClearInputMouse() does.
- 2024/06/20 (1.90.9) - renamed ImGuiDragDropFlags_SourceAutoExpirePayload to ImGuiDragDropFlags_PayloadAutoExpire.
- 2024/06/18 (1.90.9) - style: renamed ImGuiCol_TabActive -> ImGuiCol_TabSelected, ImGuiCol_TabUnfocused -> ImGuiCol_TabDimmed, ImGuiCol_TabUnfocusedActive -> ImGuiCol_TabDimmedSelected.
- 2024/06/10 (1.90.9) - removed old nested structure: renaming ImGuiStorage::ImGuiStoragePair type to ImGuiStoragePair (simpler for many languages).
- 2024/06/06 (1.90.8) - reordered ImGuiInputTextFlags values. This should not be breaking unless you are using generated headers that have values not matching the main library.
- 2024/06/06 (1.90.8) - removed 'ImGuiButtonFlags_MouseButtonDefault_ = ImGuiButtonFlags_MouseButtonLeft', was mostly unused and misleading.
- 2024/05/27 (1.90.7) - commented out obsolete symbols marked obsolete in 1.88 (May 2022):
- old: CaptureKeyboardFromApp(bool)
- new: SetNextFrameWantCaptureKeyboard(bool)
- old: CaptureMouseFromApp(bool)
- new: SetNextFrameWantCaptureMouse(bool)
- 2024/05/22 (1.90.7) - inputs (internals): renamed ImGuiKeyOwner_None to ImGuiKeyOwner_NoOwner, to make use more explicit and reduce confusion with the default it is a non-zero value and cannot be the default value (never made public, but disclosing as I expect a few users caught on owner-aware inputs).
- inputs (internals): renamed ImGuiInputFlags_RouteGlobalLow -> ImGuiInputFlags_RouteGlobal, ImGuiInputFlags_RouteGlobal -> ImGuiInputFlags_RouteGlobalOverFocused, ImGuiInputFlags_RouteGlobalHigh -> ImGuiInputFlags_RouteGlobalHighest.
- inputs (internals): Shortcut(), SetShortcutRouting(): swapped last two parameters order in function signatures:
- old: Shortcut(ImGuiKeyChord key_chord, ImGuiID owner_id = 0, ImGuiInputFlags flags = 0);
- new: Shortcut(ImGuiKeyChord key_chord, ImGuiInputFlags flags = 0, ImGuiID owner_id = 0);
- inputs (internals): owner-aware versions of IsKeyPressed(), IsKeyChordPressed(), IsMouseClicked(): swapped last two parameters order in function signatures.
- old: IsKeyPressed(ImGuiKey key, ImGuiID owner_id, ImGuiInputFlags flags = 0);
- new: IsKeyPressed(ImGuiKey key, ImGuiInputFlags flags, ImGuiID owner_id = 0);
- old: IsMouseClicked(ImGuiMouseButton button, ImGuiID owner_id, ImGuiInputFlags flags = 0);
- new: IsMouseClicked(ImGuiMouseButton button, ImGuiInputFlags flags, ImGuiID owner_id = 0);
for various reasons those changes makes sense. They are being made because making some of those API public.
only past users of imgui_internal.h with the extra parameters will be affected. Added asserts for valid flags in various functions to detect _some_ misuses, BUT NOT ALL.
- 2024/05/21 (1.90.7) - docking: changed signature of DockSpaceOverViewport() to add explicit dockspace id if desired. pass 0 to use old behavior. (#7611)
- old: DockSpaceOverViewport(const ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags flags = 0, ...);
- new: DockSpaceOverViewport(ImGuiID dockspace_id = 0, const ImGuiViewport* viewport = NULL, ImGuiDockNodeFlags flags = 0, ...);
- 2024/05/16 (1.90.7) - inputs: on macOS X, Cmd and Ctrl keys are now automatically swapped by io.AddKeyEvent() as this naturally align with how macOS X uses those keys.
- it shouldn't really affect you unless you had custom shortcut swapping in place for macOS X apps.
- removed ImGuiMod_Shortcut which was previously dynamically remapping to Ctrl or Cmd/Super. It is now unnecessary to specific cross-platform idiomatic shortcuts. (#2343, #4084, #5923, #456)
- 2024/05/14 (1.90.7) - backends: SDL_Renderer2 and SDL_Renderer3 backend now take a SDL_Renderer* in their RenderDrawData() functions.
- 2024/04/18 (1.90.6) - TreeNode: Fixed a layout inconsistency when using an empty/hidden label followed by a SameLine() call. (#7505, #282)
- old: TreeNode("##Hidden"); SameLine(); Text("Hello"); // <-- This was actually incorrect! BUT appeared to look ok with the default style where ItemSpacing.x == FramePadding.x * 2 (it didn't look aligned otherwise).
- new: TreeNode("##Hidden"); SameLine(0, 0); Text("Hello"); // <-- This is correct for all styles values.
with the fix, IF you were successfully using TreeNode("")+SameLine(); you will now have extra spacing between your TreeNode and the following item.
You'll need to change the SameLine() call to SameLine(0,0) to remove this extraneous spacing. This seemed like the more sensible fix that's not making things less consistent.
(Note: when using this idiom you are likely to also use ImGuiTreeNodeFlags_SpanAvailWidth).
- 2024/03/18 (1.90.5) - merged the radius_x/radius_y parameters in ImDrawList::AddEllipse(), AddEllipseFilled() and PathEllipticalArcTo() into a single ImVec2 parameter. Exceptionally, because those functions were added in 1.90, we are not adding inline redirection functions. The transition is easy and should affect few users. (#2743, #7417)
- 2024/03/08 (1.90.5) - inputs: more formally obsoleted GetKeyIndex() when IMGUI_DISABLE_OBSOLETE_FUNCTIONS is set. It has been unnecessary and a no-op since 1.87 (it returns the same value as passed when used with a 1.87+ backend using io.AddKeyEvent() function). (#4921)
- IsKeyPressed(GetKeyIndex(ImGuiKey_XXX)) -> use IsKeyPressed(ImGuiKey_XXX)
- 2024/01/15 (1.90.2) - commented out obsolete ImGuiIO::ImeWindowHandle marked obsolete in 1.87, favor of writing to 'void* ImGuiViewport::PlatformHandleRaw'.
- 2023/12/19 (1.90.1) - commented out obsolete ImGuiKey_KeyPadEnter redirection to ImGuiKey_KeypadEnter.
- 2023/11/06 (1.90.1) - removed CalcListClipping() marked obsolete in 1.86. Prefer using ImGuiListClipper which can return non-contiguous ranges.
- 2023/11/05 (1.90.1) - imgui_freetype: commented out ImGuiFreeType::BuildFontAtlas() obsoleted in 1.81. prefer using #define IMGUI_ENABLE_FREETYPE or see commented code for manual calls.
- 2023/11/05 (1.90.1) - internals,columns: commented out legacy ImGuiColumnsFlags_XXX symbols redirecting to ImGuiOldColumnsFlags_XXX, obsoleted from imgui_internal.h in 1.80.
- 2023/11/09 (1.90.0) - removed IM_OFFSETOF() macro in favor of using offsetof() available in C++11. Kept redirection define (will obsolete).
- 2023/11/07 (1.90.0) - removed BeginChildFrame()/EndChildFrame() in favor of using BeginChild() with the ImGuiChildFlags_FrameStyle flag. kept inline redirection function (will obsolete).
those functions were merely PushStyle/PopStyle helpers, the removal isn't so much motivated by needing to add the feature in BeginChild(), but by the necessity to avoid BeginChildFrame() signature mismatching BeginChild() signature and features.
- 2023/11/02 (1.90.0) - BeginChild: upgraded 'bool border = true' parameter to 'ImGuiChildFlags flags' type, added ImGuiChildFlags_Border equivalent. As with our prior "bool-to-flags" API updates, the ImGuiChildFlags_Border value is guaranteed to be == true forever to ensure a smoother transition, meaning all existing calls will still work.
- old: BeginChild("Name", size, true)
- new: BeginChild("Name", size, ImGuiChildFlags_Border)
- old: BeginChild("Name", size, false)
- new: BeginChild("Name", size) or BeginChild("Name", 0) or BeginChild("Name", size, ImGuiChildFlags_None)
**AMEND FROM THE FUTURE: from 1.91.1, 'ImGuiChildFlags_Border' is called 'ImGuiChildFlags_Borders'**
- 2023/11/02 (1.90.0) - BeginChild: added child-flag ImGuiChildFlags_AlwaysUseWindowPadding as a replacement for the window-flag ImGuiWindowFlags_AlwaysUseWindowPadding: the feature only ever made sense for BeginChild() anyhow.
- old: BeginChild("Name", size, 0, ImGuiWindowFlags_AlwaysUseWindowPadding);
- new: BeginChild("Name", size, ImGuiChildFlags_AlwaysUseWindowPadding, 0);
- 2023/09/27 (1.90.0) - io: removed io.MetricsActiveAllocations introduced in 1.63. Same as 'g.DebugMemAllocCount - g.DebugMemFreeCount' (still displayed in Metrics, unlikely to be accessed by end-user).
- 2023/09/26 (1.90.0) - debug tools: Renamed ShowStackToolWindow() ("Stack Tool") to ShowIDStackToolWindow() ("ID Stack Tool"), as earlier name was misleading. Kept inline redirection function. (#4631)
- 2023/09/15 (1.90.0) - ListBox, Combo: changed signature of "name getter" callback in old one-liner ListBox()/Combo() apis. kept inline redirection function (will obsolete).
- old: bool Combo(const char* label, int* current_item, bool (*getter)(void* user_data, int idx, const char** out_text), ...)
- new: bool Combo(const char* label, int* current_item, const char* (*getter)(void* user_data, int idx), ...);
- old: bool ListBox(const char* label, int* current_item, bool (*getting)(void* user_data, int idx, const char** out_text), ...);
- new: bool ListBox(const char* label, int* current_item, const char* (*getter)(void* user_data, int idx), ...);
- 2023/09/08 (1.90.0) - commented out obsolete redirecting functions:
- GetWindowContentRegionWidth() -> use GetWindowContentRegionMax().x - GetWindowContentRegionMin().x. Consider that generally 'GetContentRegionAvail().x' is more useful.
- ImDrawCornerFlags_XXX -> use ImDrawFlags_RoundCornersXXX flags. Read 1.82 Changelog for details + grep commented names in sources.
- commented out runtime support for hardcoded ~0 or 0x01..0x0F rounding flags values for AddRect()/AddRectFilled()/PathRect()/AddImageRounded() -> use ImDrawFlags_RoundCornersXXX flags. Read 1.82 Changelog for details
- 2023/08/25 (1.89.9) - clipper: Renamed IncludeRangeByIndices() (also called ForceDisplayRangeByIndices() before 1.89.6) to IncludeItemsByIndex(). Kept inline redirection function. Sorry!
- 2023/07/12 (1.89.8) - ImDrawData: CmdLists now owned, changed from ImDrawList** to ImVector<ImDrawList*>. Majority of users shouldn't be affected, but you cannot compare to NULL nor reassign manually anymore. Instead use AddDrawList(). (#6406, #4879, #1878)
- 2023/06/28 (1.89.7) - overlapping items: obsoleted 'SetItemAllowOverlap()' (called after item) in favor of calling 'SetNextItemAllowOverlap()' (called before item). 'SetItemAllowOverlap()' didn't and couldn't work reliably since 1.89 (2022-11-15).
- 2023/06/28 (1.89.7) - overlapping items: renamed 'ImGuiTreeNodeFlags_AllowItemOverlap' to 'ImGuiTreeNodeFlags_AllowOverlap', 'ImGuiSelectableFlags_AllowItemOverlap' to 'ImGuiSelectableFlags_AllowOverlap'. Kept redirecting enums (will obsolete).
- 2023/06/28 (1.89.7) - overlapping items: IsItemHovered() now by default return false when querying an item using AllowOverlap mode which is being overlapped. Use ImGuiHoveredFlags_AllowWhenOverlappedByItem to revert to old behavior.
- 2023/06/28 (1.89.7) - overlapping items: Selectable and TreeNode don't allow overlap when active so overlapping widgets won't appear as hovered. While this fixes a common small visual issue, it also means that calling IsItemHovered() after a non-reactive elements - e.g. Text() - overlapping an active one may fail if you don't use IsItemHovered(ImGuiHoveredFlags_AllowWhenBlockedByActiveItem). (#6610)
- 2023/06/20 (1.89.7) - moved io.HoverDelayShort/io.HoverDelayNormal to style.HoverDelayShort/style.HoverDelayNormal. As the fields were added in 1.89 and expected to be left unchanged by most users, or only tweaked once during app initialization, we are exceptionally accepting the breakage.
- 2023/05/30 (1.89.6) - backends: renamed "imgui_impl_sdlrenderer.cpp" to "imgui_impl_sdlrenderer2.cpp" and "imgui_impl_sdlrenderer.h" to "imgui_impl_sdlrenderer2.h". This is in prevision for the future release of SDL3.
- 2023/05/22 (1.89.6) - listbox: commented out obsolete/redirecting functions that were marked obsolete more than two years ago:
- ListBoxHeader() -> use BeginListBox() (note how two variants of ListBoxHeader() existed. Check commented versions in imgui.h for reference)
- ListBoxFooter() -> use EndListBox()
- 2023/05/15 (1.89.6) - clipper: commented out obsolete redirection constructor 'ImGuiListClipper(int items_count, float items_height = -1.0f)' that was marked obsolete in 1.79. Use default constructor + clipper.Begin().
- 2023/05/15 (1.89.6) - clipper: renamed ImGuiListClipper::ForceDisplayRangeByIndices() to ImGuiListClipper::IncludeRangeByIndices().
- 2023/03/14 (1.89.4) - commented out redirecting enums/functions names that were marked obsolete two years ago:
- ImGuiSliderFlags_ClampOnInput -> use ImGuiSliderFlags_AlwaysClamp
- ImGuiInputTextFlags_AlwaysInsertMode -> use ImGuiInputTextFlags_AlwaysOverwrite
- ImDrawList::AddBezierCurve() -> use ImDrawList::AddBezierCubic()
- ImDrawList::PathBezierCurveTo() -> use ImDrawList::PathBezierCubicCurveTo()
- 2023/03/09 (1.89.4) - renamed PushAllowKeyboardFocus()/PopAllowKeyboardFocus() to PushTabStop()/PopTabStop(). Kept inline redirection functions (will obsolete).
- 2023/03/09 (1.89.4) - tooltips: Added 'bool' return value to BeginTooltip() for API consistency. Please only submit contents and call EndTooltip() if BeginTooltip() returns true. In reality the function will _currently_ always return true, but further changes down the line may change this, best to clarify API sooner.
- 2023/02/15 (1.89.4) - moved the optional "courtesy maths operators" implementation from imgui_internal.h in imgui.h.
Even though we encourage using your own maths types and operators by setting up IM_VEC2_CLASS_EXTRA,
it has been frequently requested by people to use our own. We had an opt-in define which was
previously fulfilled in imgui_internal.h. It is now fulfilled in imgui.h. (#6164)
- OK: #define IMGUI_DEFINE_MATH_OPERATORS / #include "imgui.h" / #include "imgui_internal.h"
- Error: #include "imgui.h" / #define IMGUI_DEFINE_MATH_OPERATORS / #include "imgui_internal.h"
- 2023/02/07 (1.89.3) - backends: renamed "imgui_impl_sdl.cpp" to "imgui_impl_sdl2.cpp" and "imgui_impl_sdl.h" to "imgui_impl_sdl2.h". (#6146) This is in prevision for the future release of SDL3.
- 2022/10/26 (1.89) - commented out redirecting OpenPopupContextItem() which was briefly the name of OpenPopupOnItemClick() from 1.77 to 1.79.
- 2022/10/12 (1.89) - removed runtime patching of invalid "%f"/"%0.f" format strings for DragInt()/SliderInt(). This was obsoleted in 1.61 (May 2018). See 1.61 changelog for details.
- 2022/09/26 (1.89) - renamed and merged keyboard modifiers key enums and flags into a same set. Kept inline redirection enums (will obsolete).
- ImGuiKey_ModCtrl and ImGuiModFlags_Ctrl -> ImGuiMod_Ctrl
- ImGuiKey_ModShift and ImGuiModFlags_Shift -> ImGuiMod_Shift
- ImGuiKey_ModAlt and ImGuiModFlags_Alt -> ImGuiMod_Alt
- ImGuiKey_ModSuper and ImGuiModFlags_Super -> ImGuiMod_Super
the ImGuiKey_ModXXX were introduced in 1.87 and mostly used by backends.
the ImGuiModFlags_XXX have been exposed in imgui.h but not really used by any public api only by third-party extensions.
exceptionally commenting out the older ImGuiKeyModFlags_XXX names ahead of obsolescence schedule to reduce confusion and because they were not meant to be used anyway.
- 2022/09/20 (1.89) - ImGuiKey is now a typed enum, allowing ImGuiKey_XXX symbols to be named in debuggers.
this will require uses of legacy backend-dependent indices to be casted, e.g.
- with imgui_impl_glfw: IsKeyPressed(GLFW_KEY_A) -> IsKeyPressed((ImGuiKey)GLFW_KEY_A);
- with imgui_impl_win32: IsKeyPressed('A') -> IsKeyPressed((ImGuiKey)'A')
- etc. However if you are upgrading code you might well use the better, backend-agnostic IsKeyPressed(ImGuiKey_A) now!
- 2022/09/12 (1.89) - removed the bizarre legacy default argument for 'TreePush(const void* ptr = NULL)', always pass a pointer value explicitly. NULL/nullptr is ok but require cast, e.g. TreePush((void*)nullptr);
- 2022/09/05 (1.89) - commented out redirecting functions/enums names that were marked obsolete in 1.77 and 1.78 (June 2020):
- DragScalar(), DragScalarN(), DragFloat(), DragFloat2(), DragFloat3(), DragFloat4(): For old signatures ending with (..., const char* format, float power = 1.0f) -> use (..., format ImGuiSliderFlags_Logarithmic) if power != 1.0f.
- SliderScalar(), SliderScalarN(), SliderFloat(), SliderFloat2(), SliderFloat3(), SliderFloat4(): For old signatures ending with (..., const char* format, float power = 1.0f) -> use (..., format ImGuiSliderFlags_Logarithmic) if power != 1.0f.
- BeginPopupContextWindow(const char*, ImGuiMouseButton, bool) -> use BeginPopupContextWindow(const char*, ImGuiPopupFlags)
- 2022/09/02 (1.89) - obsoleted using SetCursorPos()/SetCursorScreenPos() to extend parent window/cell boundaries.
this relates to when moving the cursor position beyond current boundaries WITHOUT submitting an item.
- previously this would make the window content size ~200x200:
Begin(...) + SetCursorScreenPos(GetCursorScreenPos() + ImVec2(200,200)) + End();
- instead, please submit an item:
Begin(...) + SetCursorScreenPos(GetCursorScreenPos() + ImVec2(200,200)) + Dummy(ImVec2(0,0)) + End();
- alternative:
Begin(...) + Dummy(ImVec2(200,200)) + End();
- content size is now only extended when submitting an item!
- with '#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS' this will now be detected and assert.
- without '#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS' this will silently be fixed until we obsolete it.
- 2022/08/03 (1.89) - changed signature of ImageButton() function. Kept redirection function (will obsolete).
- added 'const char* str_id' parameter + removed 'int frame_padding = -1' parameter.
- old signature: bool ImageButton(ImTextureID tex_id, ImVec2 size, ImVec2 uv0 = ImVec2(0,0), ImVec2 uv1 = ImVec2(1,1), int frame_padding = -1, ImVec4 bg_col = ImVec4(0,0,0,0), ImVec4 tint_col = ImVec4(1,1,1,1));
- used the ImTextureID value to create an ID. This was inconsistent with other functions, led to ID conflicts, and caused problems with engines using transient ImTextureID values.
- had a FramePadding override which was inconsistent with other functions and made the already-long signature even longer.
- new signature: bool ImageButton(const char* str_id, ImTextureID tex_id, ImVec2 size, ImVec2 uv0 = ImVec2(0,0), ImVec2 uv1 = ImVec2(1,1), ImVec4 bg_col = ImVec4(0,0,0,0), ImVec4 tint_col = ImVec4(1,1,1,1));
- requires an explicit identifier. You may still use e.g. PushID() calls and then pass an empty identifier.
- always uses style.FramePadding for padding, to be consistent with other buttons. You may use PushStyleVar() to alter this.
- 2022/07/08 (1.89) - inputs: removed io.NavInputs[] and ImGuiNavInput enum (following 1.87 changes).
- Official backends from 1.87+ -> no issue.
- Official backends from 1.60 to 1.86 -> will build and convert gamepad inputs, unless IMGUI_DISABLE_OBSOLETE_KEYIO is defined. Need updating!
- Custom backends not writing to io.NavInputs[] -> no issue.
- Custom backends writing to io.NavInputs[] -> will build and convert gamepad inputs, unless IMGUI_DISABLE_OBSOLETE_KEYIO is defined. Need fixing!
- TL;DR: Backends should call io.AddKeyEvent()/io.AddKeyAnalogEvent() with ImGuiKey_GamepadXXX values instead of filling io.NavInput[].
- 2022/06/15 (1.88) - renamed IMGUI_DISABLE_METRICS_WINDOW to IMGUI_DISABLE_DEBUG_TOOLS for correctness. kept support for old define (will obsolete).
- 2022/05/03 (1.88) - backends: osx: removed ImGui_ImplOSX_HandleEvent() from backend API in favor of backend automatically handling event capture. All ImGui_ImplOSX_HandleEvent() calls should be removed as they are now unnecessary.
- 2022/04/05 (1.88) - inputs: renamed ImGuiKeyModFlags to ImGuiModFlags. Kept inline redirection enums (will obsolete). This was never used in public API functions but technically present in imgui.h and ImGuiIO.
- 2022/01/20 (1.87) - inputs: reworded gamepad IO.
- Backend writing to io.NavInputs[] -> backend should call io.AddKeyEvent()/io.AddKeyAnalogEvent() with ImGuiKey_GamepadXXX values.
- 2022/01/19 (1.87) - sliders, drags: removed support for legacy arithmetic operators (+,+-,*,/) when inputting text. This doesn't break any api/code but a feature that used to be accessible by end-users (which seemingly no one used).
- 2022/01/17 (1.87) - inputs: reworked mouse IO.
- Backend writing to io.MousePos -> backend should call io.AddMousePosEvent()
- Backend writing to io.MouseDown[] -> backend should call io.AddMouseButtonEvent()
- Backend writing to io.MouseWheel -> backend should call io.AddMouseWheelEvent()
- Backend writing to io.MouseHoveredViewport -> backend should call io.AddMouseViewportEvent() [Docking branch w/ multi-viewports only]
note: for all calls to IO new functions, the Dear ImGui context should be bound/current.
read https://github.com/ocornut/imgui/issues/4921 for details.
- 2022/01/10 (1.87) - inputs: reworked keyboard IO. Removed io.KeyMap[], io.KeysDown[] in favor of calling io.AddKeyEvent(), ImGui::IsKeyDown(). Removed GetKeyIndex(), now unnecessary. All IsKeyXXX() functions now take ImGuiKey values. All features are still functional until IMGUI_DISABLE_OBSOLETE_KEYIO is defined. Read Changelog and Release Notes for details.
- IsKeyPressed(MY_NATIVE_KEY_XXX) -> use IsKeyPressed(ImGuiKey_XXX)
- IsKeyPressed(GetKeyIndex(ImGuiKey_XXX)) -> use IsKeyPressed(ImGuiKey_XXX)
- Backend writing to io.KeyMap[],io.KeysDown[] -> backend should call io.AddKeyEvent() (+ call io.SetKeyEventNativeData() if you want legacy user code to still function with legacy key codes).
- Backend writing to io.KeyCtrl, io.KeyShift.. -> backend should call io.AddKeyEvent() with ImGuiMod_XXX values. *IF YOU PULLED CODE BETWEEN 2021/01/10 and 2021/01/27: We used to have a io.AddKeyModsEvent() function which was now replaced by io.AddKeyEvent() with ImGuiMod_XXX values.*
- one case won't work with backward compatibility: if your custom backend used ImGuiKey as mock native indices (e.g. "io.KeyMap[ImGuiKey_A] = ImGuiKey_A") because those values are now larger than the legacy KeyDown[] array. Will assert.
- inputs: added ImGuiKey_ModCtrl/ImGuiKey_ModShift/ImGuiKey_ModAlt/ImGuiKey_ModSuper values to submit keyboard modifiers using io.AddKeyEvent(), instead of writing directly to io.KeyCtrl, io.KeyShift, io.KeyAlt, io.KeySuper.
- 2022/01/05 (1.87) - inputs: renamed ImGuiKey_KeyPadEnter to ImGuiKey_KeypadEnter to align with new symbols. Kept redirection enum.
- 2022/01/05 (1.87) - removed io.ImeSetInputScreenPosFn() in favor of more flexible io.SetPlatformImeDataFn(). Removed 'void* io.ImeWindowHandle' in favor of writing to 'void* ImGuiViewport::PlatformHandleRaw'.
- 2022/01/01 (1.87) - commented out redirecting functions/enums names that were marked obsolete in 1.69, 1.70, 1.71, 1.72 (March-July 2019)
- ImGui::SetNextTreeNodeOpen() -> use ImGui::SetNextItemOpen()
- ImGui::GetContentRegionAvailWidth() -> use ImGui::GetContentRegionAvail().x
- ImGui::TreeAdvanceToLabelPos() -> use ImGui::SetCursorPosX(ImGui::GetCursorPosX() + ImGui::GetTreeNodeToLabelSpacing());
- ImFontAtlas::CustomRect -> use ImFontAtlasCustomRect
- ImGuiColorEditFlags_RGB/HSV/HEX -> use ImGuiColorEditFlags_DisplayRGB/HSV/Hex
- 2021/12/20 (1.86) - backends: removed obsolete Marmalade backend (imgui_impl_marmalade.cpp) + example. Find last supported version at https://github.com/ocornut/imgui/wiki/Bindings
- 2021/11/04 (1.86) - removed CalcListClipping() function. Prefer using ImGuiListClipper which can return non-contiguous ranges. Please open an issue if you think you really need this function.
- 2021/08/23 (1.85) - removed GetWindowContentRegionWidth() function. keep inline redirection helper. can use 'GetWindowContentRegionMax().x - GetWindowContentRegionMin().x' instead for generally 'GetContentRegionAvail().x' is more useful.
- 2021/07/26 (1.84) - commented out redirecting functions/enums names that were marked obsolete in 1.67 and 1.69 (March 2019):
- ImGui::GetOverlayDrawList() -> use ImGui::GetForegroundDrawList()
- ImFont::GlyphRangesBuilder -> use ImFontGlyphRangesBuilder
- 2021/05/19 (1.83) - backends: obsoleted direct access to ImDrawCmd::TextureId in favor of calling ImDrawCmd::GetTexID().
- if you are using official backends from the source tree: you have nothing to do.
- if you have copied old backend code or using your own: change access to draw_cmd->TextureId to draw_cmd->GetTexID().
- 2021/03/12 (1.82) - upgraded ImDrawList::AddRect(), AddRectFilled(), PathRect() to use ImDrawFlags instead of ImDrawCornersFlags.
- ImDrawCornerFlags_TopLeft -> use ImDrawFlags_RoundCornersTopLeft
- ImDrawCornerFlags_BotRight -> use ImDrawFlags_RoundCornersBottomRight
- ImDrawCornerFlags_None -> use ImDrawFlags_RoundCornersNone etc.
flags now sanely defaults to 0 instead of 0x0F, consistent with all other flags in the API.
breaking: the default with rounding > 0.0f is now "round all corners" vs old implicit "round no corners":
- rounding == 0.0f + flags == 0 --> meant no rounding --> unchanged (common use)
- rounding > 0.0f + flags != 0 --> meant rounding --> unchanged (common use)
- rounding == 0.0f + flags != 0 --> meant no rounding --> unchanged (unlikely use)
- rounding > 0.0f + flags == 0 --> meant no rounding --> BREAKING (unlikely use): will now round all corners --> use ImDrawFlags_RoundCornersNone or rounding == 0.0f.
this ONLY matters for hard coded use of 0 + rounding > 0.0f. Use of named ImDrawFlags_RoundCornersNone (new) or ImDrawCornerFlags_None (old) are ok.
the old ImDrawCornersFlags used awkward default values of ~0 or 0xF (4 lower bits set) to signify "round all corners" and we sometimes encouraged using them as shortcuts.
legacy path still support use of hard coded ~0 or any value from 0x1 or 0xF. They will behave the same with legacy paths enabled (will assert otherwise).
- 2021/03/11 (1.82) - removed redirecting functions/enums names that were marked obsolete in 1.66 (September 2018):
- ImGui::SetScrollHere() -> use ImGui::SetScrollHereY()
- 2021/03/11 (1.82) - clarified that ImDrawList::PathArcTo(), ImDrawList::PathArcToFast() won't render with radius < 0.0f. Previously it sorts of accidentally worked but would generally lead to counter-clockwise paths and have an effect on anti-aliasing.
- 2021/03/10 (1.82) - upgraded ImDrawList::AddPolyline() and PathStroke() "bool closed" parameter to "ImDrawFlags flags". The matching ImDrawFlags_Closed value is guaranteed to always stay == 1 in the future.
- 2021/02/22 (1.82) - (*undone in 1.84*) win32+mingw: Re-enabled IME functions by default even under MinGW. In July 2016, issue #738 had me incorrectly disable those default functions for MinGW. MinGW users should: either link with -limm32, either set their imconfig file with '#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS'.
- 2021/02/17 (1.82) - renamed rarely used style.CircleSegmentMaxError (old default = 1.60f) to style.CircleTessellationMaxError (new default = 0.30f) as the meaning of the value changed.
- 2021/02/03 (1.81) - renamed ListBoxHeader(const char* label, ImVec2 size) to BeginListBox(). Kept inline redirection function (will obsolete).
- removed ListBoxHeader(const char* label, int items_count, int height_in_items = -1) in favor of specifying size. Kept inline redirection function (will obsolete).
- renamed ListBoxFooter() to EndListBox(). Kept inline redirection function (will obsolete).
- 2021/01/26 (1.81) - removed ImGuiFreeType::BuildFontAtlas(). Kept inline redirection function. Prefer using '#define IMGUI_ENABLE_FREETYPE', but there's a runtime selection path available too. The shared extra flags parameters (very rarely used) are now stored in ImFontAtlas::FontBuilderFlags.
- renamed ImFontConfig::RasterizerFlags (used by FreeType) to ImFontConfig::FontBuilderFlags.
- renamed ImGuiFreeType::XXX flags to ImGuiFreeTypeBuilderFlags_XXX for consistency with other API.
- 2020/10/12 (1.80) - removed redirecting functions/enums that were marked obsolete in 1.63 (August 2018):
- ImGui::IsItemDeactivatedAfterChange() -> use ImGui::IsItemDeactivatedAfterEdit().
- ImGuiCol_ModalWindowDarkening -> use ImGuiCol_ModalWindowDimBg
- ImGuiInputTextCallback -> use ImGuiTextEditCallback
- ImGuiInputTextCallbackData -> use ImGuiTextEditCallbackData
- 2020/12/21 (1.80) - renamed ImDrawList::AddBezierCurve() to AddBezierCubic(), and PathBezierCurveTo() to PathBezierCubicCurveTo(). Kept inline redirection function (will obsolete).
- 2020/12/04 (1.80) - added imgui_tables.cpp file! Manually constructed project files will need the new file added!
- 2020/11/18 (1.80) - renamed undocumented/internals ImGuiColumnsFlags_* to ImGuiOldColumnFlags_* in prevision of incoming Tables API.
- 2020/11/03 (1.80) - renamed io.ConfigWindowsMemoryCompactTimer to io.ConfigMemoryCompactTimer as the feature will apply to other data structures
- 2020/10/14 (1.80) - backends: moved all backends files (imgui_impl_XXXX.cpp, imgui_impl_XXXX.h) from examples/ to backends/.
- 2020/10/12 (1.80) - removed redirecting functions/enums that were marked obsolete in 1.60 (April 2018):
- io.RenderDrawListsFn pointer -> use ImGui::GetDrawData() value and call the render function of your backend
- ImGui::IsAnyWindowFocused() -> use ImGui::IsWindowFocused(ImGuiFocusedFlags_AnyWindow)
- ImGui::IsAnyWindowHovered() -> use ImGui::IsWindowHovered(ImGuiHoveredFlags_AnyWindow)
- ImGuiStyleVar_Count_ -> use ImGuiStyleVar_COUNT
- ImGuiMouseCursor_Count_ -> use ImGuiMouseCursor_COUNT
- removed redirecting functions names that were marked obsolete in 1.61 (May 2018):
- InputFloat (... int decimal_precision ...) -> use InputFloat (... const char* format ...) with format = "%.Xf" where X is your value for decimal_precision.
- same for InputFloat2()/InputFloat3()/InputFloat4() variants taking a `int decimal_precision` parameter.
- 2020/10/05 (1.79) - removed ImGuiListClipper: Renamed constructor parameters which created an ambiguous alternative to using the ImGuiListClipper::Begin() function, with misleading edge cases (note: imgui_memory_editor <0.40 from imgui_club/ used this old clipper API. Update your copy if needed).
- 2020/09/25 (1.79) - renamed ImGuiSliderFlags_ClampOnInput to ImGuiSliderFlags_AlwaysClamp. Kept redirection enum (will obsolete sooner because previous name was added recently).
- 2020/09/25 (1.79) - renamed style.TabMinWidthForUnselectedCloseButton to style.TabMinWidthForCloseButton.
- 2020/09/21 (1.79) - renamed OpenPopupContextItem() back to OpenPopupOnItemClick(), reverting the change from 1.77. For varieties of reason this is more self-explanatory.
- 2020/09/21 (1.79) - removed return value from OpenPopupOnItemClick() - returned true on mouse release on an item - because it is inconsistent with other popup APIs and makes others misleading. It's also and unnecessary: you can use IsWindowAppearing() after BeginPopup() for a similar result.
- 2020/09/17 (1.79) - removed ImFont::DisplayOffset in favor of ImFontConfig::GlyphOffset. DisplayOffset was applied after scaling and not very meaningful/useful outside of being needed by the default ProggyClean font. If you scaled this value after calling AddFontDefault(), this is now done automatically. It was also getting in the way of better font scaling, so let's get rid of it now!
- 2020/08/17 (1.78) - obsoleted use of the trailing 'float power=1.0f' parameter for DragFloat(), DragFloat2(), DragFloat3(), DragFloat4(), DragFloatRange2(), DragScalar(), DragScalarN(), SliderFloat(), SliderFloat2(), SliderFloat3(), SliderFloat4(), SliderScalar(), SliderScalarN(), VSliderFloat() and VSliderScalar().
replaced the 'float power=1.0f' argument with integer-based flags defaulting to 0 (as with all our flags).
worked out a backward-compatibility scheme so hopefully most C++ codebase should not be affected. in short, when calling those functions:
- if you omitted the 'power' parameter (likely!), you are not affected.
- if you set the 'power' parameter to 1.0f (same as previous default value): 1/ your compiler may warn on float>int conversion, 2/ everything else will work. 3/ you can replace the 1.0f value with 0 to fix the warning, and be technically correct.
- if you set the 'power' parameter to >1.0f (to enable non-linear editing): 1/ your compiler may warn on float>int conversion, 2/ code will assert at runtime, 3/ in case asserts are disabled, the code will not crash and enable the _Logarithmic flag. 4/ you can replace the >1.0f value with ImGuiSliderFlags_Logarithmic to fix the warning/assert and get a _similar_ effect as previous uses of power >1.0f.
see https://github.com/ocornut/imgui/issues/3361 for all details.
kept inline redirection functions (will obsolete) apart for: DragFloatRange2(), VSliderFloat(), VSliderScalar(). For those three the 'float power=1.0f' version was removed directly as they were most unlikely ever used.
for shared code, you can version check at compile-time with `#if IMGUI_VERSION_NUM >= 17704`.
- obsoleted use of v_min > v_max in DragInt, DragFloat, DragScalar to lock edits (introduced in 1.73, was not demoed nor documented very), will be replaced by a more generic ReadOnly feature. You may use the ImGuiSliderFlags_ReadOnly internal flag in the meantime.
- 2020/06/23 (1.77) - removed BeginPopupContextWindow(const char*, int mouse_button, bool also_over_items) in favor of BeginPopupContextWindow(const char*, ImGuiPopupFlags flags) with ImGuiPopupFlags_NoOverItems.
- 2020/06/15 (1.77) - renamed OpenPopupOnItemClick() to OpenPopupContextItem(). Kept inline redirection function (will obsolete). [NOTE: THIS WAS REVERTED IN 1.79]
- 2020/06/15 (1.77) - removed CalcItemRectClosestPoint() entry point which was made obsolete and asserting in December 2017.
- 2020/04/23 (1.77) - removed unnecessary ID (first arg) of ImFontAtlas::AddCustomRectRegular().
- 2020/01/22 (1.75) - ImDrawList::AddCircle()/AddCircleFilled() functions don't accept negative radius any more.
- 2019/12/17 (1.75) - [undid this change in 1.76] made Columns() limited to 64 columns by asserting above that limit. While the current code technically supports it, future code may not so we're putting the restriction ahead.
- 2019/12/13 (1.75) - [imgui_internal.h] changed ImRect() default constructor initializes all fields to 0.0f instead of (FLT_MAX,FLT_MAX,-FLT_MAX,-FLT_MAX). If you used ImRect::Add() to create bounding boxes by adding multiple points into it, you may need to fix your initial value.
- 2019/12/08 (1.75) - removed redirecting functions/enums that were marked obsolete in 1.53 (December 2017):
- ShowTestWindow() -> use ShowDemoWindow()
- IsRootWindowFocused() -> use IsWindowFocused(ImGuiFocusedFlags_RootWindow)
- IsRootWindowOrAnyChildFocused() -> use IsWindowFocused(ImGuiFocusedFlags_RootAndChildWindows)
- SetNextWindowContentWidth(w) -> use SetNextWindowContentSize(ImVec2(w, 0.0f))
- GetItemsLineHeightWithSpacing() -> use GetFrameHeightWithSpacing()
- ImGuiCol_ChildWindowBg -> use ImGuiCol_ChildBg
- ImGuiStyleVar_ChildWindowRounding -> use ImGuiStyleVar_ChildRounding
- ImGuiTreeNodeFlags_AllowOverlapMode -> use ImGuiTreeNodeFlags_AllowItemOverlap
- IMGUI_DISABLE_TEST_WINDOWS -> use IMGUI_DISABLE_DEMO_WINDOWS
- 2019/12/08 (1.75) - obsoleted calling ImDrawList::PrimReserve() with a negative count (which was vaguely documented and rarely if ever used). Instead, we added an explicit PrimUnreserve() API.
- 2019/12/06 (1.75) - removed implicit default parameter to IsMouseDragging(int button = 0) to be consistent with other mouse functions (none of the other functions have it).
- 2019/11/21 (1.74) - ImFontAtlas::AddCustomRectRegular() now requires an ID larger than 0x110000 (instead of 0x10000) to conform with supporting Unicode planes 1-16 in a future update. ID below 0x110000 will now assert.
- 2019/11/19 (1.74) - renamed IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS to IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS for consistency.
- 2019/11/19 (1.74) - renamed IMGUI_DISABLE_MATH_FUNCTIONS to IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS for consistency.
- 2019/10/22 (1.74) - removed redirecting functions/enums that were marked obsolete in 1.52 (October 2017):
- Begin() [old 5 args version] -> use Begin() [3 args], use SetNextWindowSize() SetNextWindowBgAlpha() if needed
- IsRootWindowOrAnyChildHovered() -> use IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows)
- AlignFirstTextHeightToWidgets() -> use AlignTextToFramePadding()
- SetNextWindowPosCenter() -> use SetNextWindowPos() with a pivot of (0.5f, 0.5f)
- ImFont::Glyph -> use ImFontGlyph
- 2019/10/14 (1.74) - inputs: Fixed a miscalculation in the keyboard/mouse "typematic" repeat delay/rate calculation, used by keys and e.g. repeating mouse buttons as well as the GetKeyPressedAmount() function.
if you were using a non-default value for io.KeyRepeatRate (previous default was 0.250), you can add +io.KeyRepeatDelay to it to compensate for the fix.
The function was triggering on: 0.0 and (delay+rate*N) where (N>=1). Fixed formula responds to (N>=0). Effectively it made io.KeyRepeatRate behave like it was set to (io.KeyRepeatRate + io.KeyRepeatDelay).
If you never altered io.KeyRepeatRate nor used GetKeyPressedAmount() this won't affect you.
- 2019/07/15 (1.72) - removed TreeAdvanceToLabelPos() which is rarely used and only does SetCursorPosX(GetCursorPosX() + GetTreeNodeToLabelSpacing()). Kept redirection function (will obsolete).
- 2019/07/12 (1.72) - renamed ImFontAtlas::CustomRect to ImFontAtlasCustomRect. Kept redirection typedef (will obsolete).
- 2019/06/14 (1.72) - removed redirecting functions/enums names that were marked obsolete in 1.51 (June 2017): ImGuiCol_Column*, ImGuiSetCond_*, IsItemHoveredRect(), IsPosHoveringAnyWindow(), IsMouseHoveringAnyWindow(), IsMouseHoveringWindow(), IMGUI_ONCE_UPON_A_FRAME. Grep this log for details and new names, or see how they were implemented until 1.71.
- 2019/06/07 (1.71) - rendering of child window outer decorations (bg color, border, scrollbars) is now performed as part of the parent window. If you have
overlapping child windows in a same parent, and relied on their relative z-order to be mapped to their submission order, this will affect your rendering.
This optimization is disabled if the parent window has no visual output, because it appears to be the most common situation leading to the creation of overlapping child windows.
Please reach out if you are affected.
- 2019/05/13 (1.71) - renamed SetNextTreeNodeOpen() to SetNextItemOpen(). Kept inline redirection function (will obsolete).
- 2019/05/11 (1.71) - changed io.AddInputCharacter(unsigned short c) signature to io.AddInputCharacter(unsigned int c).
- 2019/04/29 (1.70) - improved ImDrawList thick strokes (>1.0f) preserving correct thickness up to 90 degrees angles (e.g. rectangles). If you have custom rendering using thick lines, they will appear thicker now.
- 2019/04/29 (1.70) - removed GetContentRegionAvailWidth(), use GetContentRegionAvail().x instead. Kept inline redirection function (will obsolete).
- 2019/03/04 (1.69) - renamed GetOverlayDrawList() to GetForegroundDrawList(). Kept redirection function (will obsolete).
- 2019/02/26 (1.69) - renamed ImGuiColorEditFlags_RGB/ImGuiColorEditFlags_HSV/ImGuiColorEditFlags_HEX to ImGuiColorEditFlags_DisplayRGB/ImGuiColorEditFlags_DisplayHSV/ImGuiColorEditFlags_DisplayHex. Kept redirection enums (will obsolete).
- 2019/02/14 (1.68) - made it illegal/assert when io.DisplayTime == 0.0f (with an exception for the first frame). If for some reason your time step calculation gives you a zero value, replace it with an arbitrarily small value!
- 2019/02/01 (1.68) - removed io.DisplayVisibleMin/DisplayVisibleMax (which were marked obsolete and removed from viewport/docking branch already).
- 2019/01/06 (1.67) - renamed io.InputCharacters[], marked internal as was always intended. Please don't access directly, and use AddInputCharacter() instead!
- 2019/01/06 (1.67) - renamed ImFontAtlas::GlyphRangesBuilder to ImFontGlyphRangesBuilder. Kept redirection typedef (will obsolete).
- 2018/12/20 (1.67) - made it illegal to call Begin("") with an empty string. This somehow half-worked before but had various undesirable side-effects.
- 2018/12/10 (1.67) - renamed io.ConfigResizeWindowsFromEdges to io.ConfigWindowsResizeFromEdges as we are doing a large pass on configuration flags.
- 2018/10/12 (1.66) - renamed misc/stl/imgui_stl.* to misc/cpp/imgui_stdlib.* in prevision for other C++ helper files.
- 2018/09/28 (1.66) - renamed SetScrollHere() to SetScrollHereY(). Kept redirection function (will obsolete).
- 2018/09/06 (1.65) - renamed stb_truetype.h to imstb_truetype.h, stb_textedit.h to imstb_textedit.h, and stb_rect_pack.h to imstb_rectpack.h.
If you were conveniently using the imgui copy of those STB headers in your project you will have to update your include paths.
- 2018/09/05 (1.65) - renamed io.OptCursorBlink/io.ConfigCursorBlink to io.ConfigInputTextCursorBlink. (#1427)
- 2018/08/31 (1.64) - added imgui_widgets.cpp file, extracted and moved widgets code out of imgui.cpp into imgui_widgets.cpp. Re-ordered some of the code remaining in imgui.cpp.
NONE OF THE FUNCTIONS HAVE CHANGED. THE CODE IS SEMANTICALLY 100% IDENTICAL, BUT _EVERY_ FUNCTION HAS BEEN MOVED.
Because of this, any local modifications to imgui.cpp will likely conflict when you update. Read docs/CHANGELOG.txt for suggestions.
- 2018/08/22 (1.63) - renamed IsItemDeactivatedAfterChange() to IsItemDeactivatedAfterEdit() for consistency with new IsItemEdited() API. Kept redirection function (will obsolete soonish as IsItemDeactivatedAfterChange() is very recent).
- 2018/08/21 (1.63) - renamed ImGuiTextEditCallback to ImGuiInputTextCallback, ImGuiTextEditCallbackData to ImGuiInputTextCallbackData for consistency. Kept redirection types (will obsolete).
- 2018/08/21 (1.63) - removed ImGuiInputTextCallbackData::ReadOnly since it is a duplication of (ImGuiInputTextCallbackData::Flags & ImGuiInputTextFlags_ReadOnly).
- 2018/08/01 (1.63) - removed per-window ImGuiWindowFlags_ResizeFromAnySide beta flag in favor of a global io.ConfigResizeWindowsFromEdges [update 1.67 renamed to ConfigWindowsResizeFromEdges] to enable the feature.
- 2018/08/01 (1.63) - renamed io.OptCursorBlink to io.ConfigCursorBlink [-> io.ConfigInputTextCursorBlink in 1.65], io.OptMacOSXBehaviors to ConfigMacOSXBehaviors for consistency.
- 2018/07/22 (1.63) - changed ImGui::GetTime() return value from float to double to avoid accumulating floating point imprecisions over time.
- 2018/07/08 (1.63) - style: renamed ImGuiCol_ModalWindowDarkening to ImGuiCol_ModalWindowDimBg for consistency with other features. Kept redirection enum (will obsolete).
- 2018/06/08 (1.62) - examples: the imgui_impl_XXX files have been split to separate platform (Win32, GLFW, SDL2, etc.) from renderer (DX11, OpenGL, Vulkan, etc.).
old backends will still work as is, however prefer using the separated backends as they will be updated to support multi-viewports.
when adopting new backends follow the main.cpp code of your preferred examples/ folder to know which functions to call.
in particular, note that old backends called ImGui::NewFrame() at the end of their ImGui_ImplXXXX_NewFrame() function.
- 2018/06/06 (1.62) - renamed GetGlyphRangesChinese() to GetGlyphRangesChineseFull() to distinguish other variants and discourage using the full set.
- 2018/06/06 (1.62) - TreeNodeEx()/TreeNodeBehavior(): the ImGuiTreeNodeFlags_CollapsingHeader helper now include the ImGuiTreeNodeFlags_NoTreePushOnOpen flag. See Changelog for details.
- 2018/05/03 (1.61) - DragInt(): the default compile-time format string has been changed from "%.0f" to "%d", as we are not using integers internally any more.
If you used DragInt() with custom format strings, make sure you change them to use %d or an integer-compatible format.
To honor backward-compatibility, the DragInt() code will currently parse and modify format strings to replace %*f with %d, giving time to users to upgrade their code.
If you have IMGUI_DISABLE_OBSOLETE_FUNCTIONS enabled, the code will instead assert! You may run a reg-exp search on your codebase for e.g. "DragInt.*%f" to help you find them.
- 2018/04/28 (1.61) - obsoleted InputFloat() functions taking an optional "int decimal_precision" in favor of an equivalent and more flexible "const char* format",
consistent with other functions. Kept redirection functions (will obsolete).
- 2018/04/09 (1.61) - IM_DELETE() helper function added in 1.60 doesn't clear the input _pointer_ reference, more consistent with expectation and allows passing r-value.
- 2018/03/20 (1.60) - renamed io.WantMoveMouse to io.WantSetMousePos for consistency and ease of understanding (was added in 1.52, _not_ used by core and only honored by some backend ahead of merging the Nav branch).
- 2018/03/12 (1.60) - removed ImGuiCol_CloseButton, ImGuiCol_CloseButtonActive, ImGuiCol_CloseButtonHovered as the closing cross uses regular button colors now.
- 2018/03/08 (1.60) - changed ImFont::DisplayOffset.y to default to 0 instead of +1. Fixed rounding of Ascent/Descent to match TrueType renderer. If you were adding or subtracting to ImFont::DisplayOffset check if your fonts are correctly aligned vertically.
- 2018/03/03 (1.60) - renamed ImGuiStyleVar_Count_ to ImGuiStyleVar_COUNT and ImGuiMouseCursor_Count_ to ImGuiMouseCursor_COUNT for consistency with other public enums.
- 2018/02/18 (1.60) - BeginDragDropSource(): temporarily removed the optional mouse_button=0 parameter because it is not really usable in many situations at the moment.
- 2018/02/16 (1.60) - obsoleted the io.RenderDrawListsFn callback, you can call your graphics engine render function after ImGui::Render(). Use ImGui::GetDrawData() to retrieve the ImDrawData* to display.
- 2018/02/07 (1.60) - reorganized context handling to be more explicit,
- YOU NOW NEED TO CALL ImGui::CreateContext() AT THE BEGINNING OF YOUR APP, AND CALL ImGui::DestroyContext() AT THE END.
- removed Shutdown() function, as DestroyContext() serve this purpose.
- you may pass a ImFontAtlas* pointer to CreateContext() to share a font atlas between contexts. Otherwise CreateContext() will create its own font atlas instance.
- removed allocator parameters from CreateContext(), they are now
gitextract_ssp56e80/
├── .gitignore
├── ImGui.uplugin
├── LICENSE
├── README.md
└── Source/
├── ImGui/
│ ├── ImGui.Build.cs
│ ├── Private/
│ │ ├── ImGuiConfig.cpp
│ │ ├── ImGuiContext.cpp
│ │ ├── ImGuiModule.cpp
│ │ ├── SImGuiOverlay.cpp
│ │ ├── SImGuiOverlay.h
│ │ ├── SImGuiWindow.cpp
│ │ └── SImGuiWindow.h
│ └── Public/
│ ├── ImGuiConfig.h
│ ├── ImGuiConfig.inl
│ ├── ImGuiContext.h
│ └── ImGuiModule.h
└── ThirdParty/
├── ImGuiLibrary/
│ ├── ImGuiLibrary.Build.cs
│ ├── LICENSE.txt
│ ├── imconfig.h
│ ├── imgui.cpp
│ ├── imgui.h
│ ├── imgui.natstepfilter
│ ├── imgui.natvis
│ ├── imgui_demo.cpp
│ ├── imgui_draw.cpp
│ ├── imgui_internal.h
│ ├── imgui_tables.cpp
│ ├── imgui_widgets.cpp
│ ├── imstb_rectpack.h
│ ├── imstb_textedit.h
│ └── imstb_truetype.h
├── ImPlotLibrary/
│ ├── ImPlotLibrary.Build.cs
│ ├── LICENSE
│ ├── implot.cpp
│ ├── implot.h
│ ├── implot_demo.cpp
│ ├── implot_internal.h
│ └── implot_items.cpp
└── NetImGuiLibrary/
├── LICENSE.txt
├── NetImGuiLibrary.Build.cs
├── NetImgui_Api.h
├── NetImgui_Config.h
└── Private/
├── NetImgui_Api.cpp
├── NetImgui_Client.cpp
├── NetImgui_Client.h
├── NetImgui_Client.inl
├── NetImgui_CmdPackets.h
├── NetImgui_CmdPackets.inl
├── NetImgui_CmdPackets_DrawFrame.cpp
├── NetImgui_CmdPackets_DrawFrame.h
├── NetImgui_Network.h
├── NetImgui_NetworkPosix.cpp
├── NetImgui_NetworkUE4.cpp
├── NetImgui_NetworkWin32.cpp
├── NetImgui_Shared.h
├── NetImgui_Shared.inl
├── NetImgui_WarningDisable.h
├── NetImgui_WarningDisableImgui.h
├── NetImgui_WarningDisableStd.h
└── NetImgui_WarningReenable.h
Showing preview only (214K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (2240 symbols across 41 files)
FILE: Source/ImGui/ImGui.Build.cs
class ImGui (line 3) | public class ImGui : ModuleRules
method ImGui (line 8) | public ImGui(ReadOnlyTargetRules Target) : base(Target)
FILE: Source/ImGui/Private/ImGuiConfig.cpp
function ImFileHandle (line 35) | ImFileHandle ImFileOpen(const char* FileName, const char* Mode)
function ImFileClose (line 77) | bool ImFileClose(ImFileHandle File)
function uint64 (line 88) | uint64 ImFileGetSize(ImFileHandle File)
function uint64 (line 99) | uint64 ImFileRead(void* Data, uint64 Size, uint64 Count, ImFileHandle File)
function uint64 (line 113) | uint64 ImFileWrite(const void* Data, uint64 Size, uint64 Count, ImFileHa...
function FImGuiContext (line 176) | FImGuiContext* ImGui::FScopedContext::operator->() const
function ImGuiKey (line 181) | ImGuiKey ImGui::ConvertKey(const FKey& Key)
function FKey (line 329) | FKey ImGui::ConvertKey(const ImGuiKey Key)
function ImGuiKeyChord (line 477) | ImGuiKeyChord ImGui::ConvertKeyChord(const FInputChord& Chord)
function FInputChord (line 489) | FInputChord ImGui::ConvertKeyChord(const ImGuiKeyChord Chord)
FILE: Source/ImGui/Private/ImGuiContext.cpp
function FImGuiViewportData (line 37) | FImGuiViewportData* FImGuiViewportData::GetOrCreate(ImGuiViewport* Viewp...
function ImGui_MemFree (line 60) | static void ImGui_MemFree(void* Ptr, void* UserData)
function ImGui_CreateWindow (line 65) | static void ImGui_CreateWindow(ImGuiViewport* Viewport)
function ImGui_DestroyWindow (line 98) | static void ImGui_DestroyWindow(ImGuiViewport* Viewport)
function ImGui_ShowWindow (line 118) | static void ImGui_ShowWindow(ImGuiViewport* Viewport)
function ImGui_SetWindowPos (line 130) | static void ImGui_SetWindowPos(ImGuiViewport* Viewport, ImVec2 Pos)
function ImVec2 (line 142) | static ImVec2 ImGui_GetWindowPos(ImGuiViewport* Viewport)
function ImGui_SetWindowSize (line 156) | static void ImGui_SetWindowSize(ImGuiViewport* Viewport, ImVec2 Size)
function ImVec2 (line 168) | static ImVec2 ImGui_GetWindowSize(ImGuiViewport* Viewport)
function ImGui_SetWindowFocus (line 182) | static void ImGui_SetWindowFocus(ImGuiViewport* Viewport)
function ImGui_GetWindowFocus (line 198) | static bool ImGui_GetWindowFocus(ImGuiViewport* Viewport)
function ImGui_GetWindowMinimized (line 215) | static bool ImGui_GetWindowMinimized(ImGuiViewport* Viewport)
function ImGui_SetWindowTitle (line 229) | static void ImGui_SetWindowTitle(ImGuiViewport* Viewport, const char* Ti...
function ImGui_SetWindowAlpha (line 241) | static void ImGui_SetWindowAlpha(ImGuiViewport* Viewport, float Alpha)
function ImGui_RenderWindow (line 253) | static void ImGui_RenderWindow(ImGuiViewport* Viewport, void* UserData)
function ImGui_SetClipboardText (line 282) | void ImGui_SetClipboardText(ImGuiContext* Context, const char* Clipboard...
function ImGui_OpenInShell (line 287) | static bool ImGui_OpenInShell(ImGuiContext* Context, const char* Path)
FILE: Source/ImGui/Private/ImGuiModule.cpp
function FImGuiModule (line 44) | FImGuiModule& FImGuiModule::Get()
FILE: Source/ImGui/Private/SImGuiOverlay.cpp
class FImGuiInputProcessor (line 31) | class FImGuiInputProcessor : public IInputProcessor
method FImGuiInputProcessor (line 34) | explicit FImGuiInputProcessor(SImGuiOverlay* InOwner)
method OnApplicationActivationChanged (line 53) | void OnApplicationActivationChanged(bool bIsActive) const
method OnFocusChanging (line 62) | void OnFocusChanging(const FFocusEvent& Event, const FWeakWidgetPath& ...
method Tick (line 74) | virtual void Tick(const float DeltaTime, FSlateApplication& SlateApp, ...
method HandleKeyDownEvent (line 105) | virtual bool HandleKeyDownEvent(FSlateApplication& SlateApp, const FKe...
method HandleKeyUpEvent (line 127) | virtual bool HandleKeyUpEvent(FSlateApplication& SlateApp, const FKeyE...
method HandleAnalogInputEvent (line 149) | virtual bool HandleAnalogInputEvent(FSlateApplication& SlateApp, const...
method HandleMouseMoveEvent (line 166) | virtual bool HandleMouseMoveEvent(FSlateApplication& SlateApp, const F...
method HandleMouseButtonDownEvent (line 207) | virtual bool HandleMouseButtonDownEvent(FSlateApplication& SlateApp, c...
method HandleMouseButtonUpEvent (line 235) | virtual bool HandleMouseButtonUpEvent(FSlateApplication& SlateApp, con...
method HandleMouseButtonDoubleClickEvent (line 263) | virtual bool HandleMouseButtonDoubleClickEvent(FSlateApplication& Slat...
method HandleMouseWheelOrGestureEvent (line 269) | virtual bool HandleMouseWheelOrGestureEvent(FSlateApplication& SlateAp...
method ShouldHandleEvent (line 285) | bool ShouldHandleEvent(FSlateApplication& SlateApp, const FInputEvent&...
method FImGuiViewportData (line 304) | static FImGuiViewportData* FindViewportForWindow(const TSharedPtr<SWin...
function int32 (line 349) | int32 SImGuiOverlay::OnPaint(const FPaintArgs& Args, const FGeometry& Al...
function FVector2D (line 437) | FVector2D SImGuiOverlay::ComputeDesiredSize(float LayoutScaleMultiplier)...
function FReply (line 447) | FReply SImGuiOverlay::OnKeyChar(const FGeometry& MyGeometry, const FChar...
FILE: Source/ImGui/Private/SImGuiOverlay.h
function THIRD_PARTY_INCLUDES_END (line 10) | THIRD_PARTY_INCLUDES_END
type FImGuiDrawData (line 23) | struct FImGuiDrawData
function class (line 40) | class SImGuiOverlay : public SLeafWidget
FILE: Source/ImGui/Private/SImGuiWindow.cpp
function THIRD_PARTY_INCLUDES_END (line 7) | THIRD_PARTY_INCLUDES_END
FILE: Source/ImGui/Private/SImGuiWindow.h
type ImGuiViewport (line 7) | struct ImGuiViewport
function class (line 9) | class SImGuiWindow : public SWindow
FILE: Source/ImGui/Public/ImGuiConfig.h
type FInputChord (line 15) | struct FInputChord
type FKey (line 16) | struct FKey
type FSlateBrush (line 17) | struct FSlateBrush
type ImGuiKey (line 18) | enum ImGuiKey : int
type ImGuiKeyChord (line 19) | typedef int ImGuiKeyChord;
type ImGuiContext (line 20) | struct ImGuiContext
type ImPlotContext (line 21) | struct ImPlotContext
type IFileHandle (line 32) | typedef IFileHandle* ImFileHandle;
type IMGUI_API (line 88) | struct IMGUI_API
FILE: Source/ImGui/Public/ImGuiContext.h
type FDisplayMetrics (line 14) | struct FDisplayMetrics
type FSlateBrush (line 15) | struct FSlateBrush
type ImGuiContext (line 16) | struct ImGuiContext
type ImGuiViewport (line 17) | struct ImGuiViewport
type ImPlotContext (line 18) | struct ImPlotContext
type ImTextureData (line 19) | struct ImTextureData
function FImGuiViewportData (line 21) | struct IMGUI_API FImGuiViewportData
FILE: Source/ThirdParty/ImGuiLibrary/ImGuiLibrary.Build.cs
class ImGuiLibrary (line 3) | public class ImGuiLibrary : ModuleRules
method ImGuiLibrary (line 5) | public ImGuiLibrary(ReadOnlyTargetRules Target) : base(Target)
FILE: Source/ThirdParty/ImGuiLibrary/imgui.cpp
type ImGui (line 1346) | namespace ImGui
function FreeWrapper (line 1457) | static void FreeWrapper(void* ptr, void* user_data) { IM_UNUSE...
function FreeWrapper (line 1460) | static void FreeWrapper(void* ptr, void* user_data) { IM_UNUSE...
function ImGuiInputEvent (line 1808) | static ImGuiInputEvent* FindLatestInputEvent(ImGuiContext* ctx, ImGuiInp...
function ImVec2 (line 2053) | ImVec2 ImBezierCubicClosestPoint(const ImVec2& p1, const ImVec2& p2, con...
function ImBezierCubicClosestPointCasteljauStep (line 2076) | static void ImBezierCubicClosestPointCasteljauStep(const ImVec2& p, ImVe...
function ImVec2 (line 2111) | ImVec2 ImBezierCubicClosestPointCasteljau(const ImVec2& p1, const ImVec2...
function ImVec2 (line 2121) | ImVec2 ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2...
function ImTriangleContainsPoint (line 2134) | bool ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImV...
function ImTriangleBarycentricCoords (line 2142) | void ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const...
function ImVec2 (line 2153) | ImVec2 ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const Im...
function ImStricmp (line 2174) | int ImStricmp(const char* str1, const char* str2)
function ImStrnicmp (line 2181) | int ImStrnicmp(const char* str1, const char* str2, size_t count)
function ImStrncpy (line 2188) | void ImStrncpy(char* dst, const char* src, size_t count)
function ImStrlenW (line 2230) | int ImStrlenW(const ImWchar* str)
function ImStrTrimBlanks (line 2276) | void ImStrTrimBlanks(char* buf)
function ImFormatString (line 2322) | int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...)
function ImFormatStringV (line 2340) | int ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list...
function ImFormatStringToTempBuffer (line 2356) | void ImFormatStringToTempBuffer(const char** out_buf, const char** out_b...
function ImFormatStringToTempBufferV (line 2368) | void ImFormatStringToTempBufferV(const char** out_buf, const char** out_...
function ImGuiID (line 2448) | ImGuiID ImHashData(const void* data_p, size_t data_size, ImGuiID seed)
function ImGuiID (line 2473) | ImGuiID ImHashStr(const char* data_p, size_t data_size, ImGuiID seed)
function ImFileHandle (line 2538) | ImFileHandle ImFileOpen(const char* filename, const char* mode)
function ImFileClose (line 2563) | bool ImFileClose(ImFileHandle f) { return fclose(f) == 0; }
function ImU64 (line 2564) | ImU64 ImFileGetSize(ImFileHandle f) { long off = 0, sz = 0; return (...
function ImU64 (line 2565) | ImU64 ImFileRead(void* data, ImU64 sz, ImU64 count, ImFileHandle f) ...
function ImU64 (line 2566) | ImU64 ImFileWrite(const void* data, ImU64 sz, ImU64 count, ImFileHandl...
function IM_MSVC_RUNTIME_CHECKS_OFF (line 2615) | IM_MSVC_RUNTIME_CHECKS_OFF
function ImTextStrFromUtf8 (line 2673) | int ImTextStrFromUtf8(ImWchar* buf, int buf_size, const char* in_text, c...
function ImTextCountCharsFromUtf8 (line 2689) | int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end)
function ImTextCharToUtf8_inline (line 2702) | static inline int ImTextCharToUtf8_inline(char* buf, int buf_size, unsig...
function ImTextCharToUtf8 (line 2737) | int ImTextCharToUtf8(char out_buf[5], unsigned int c)
function ImTextCountUtf8BytesFromChar (line 2745) | int ImTextCountUtf8BytesFromChar(const char* in_text, const char* in_tex...
function ImTextCountUtf8BytesFromChar (line 2751) | static inline int ImTextCountUtf8BytesFromChar(unsigned int c)
function ImTextStrToUtf8 (line 2760) | int ImTextStrToUtf8(char* out_buf, int out_buf_size, const ImWchar* in_t...
function ImTextCountUtf8BytesFromStr (line 2776) | int ImTextCountUtf8BytesFromStr(const ImWchar* in_text, const ImWchar* i...
function ImTextCountLines (line 2813) | int ImTextCountLines(const char* in_text, const char* in_text_end)
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 2827) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function ImVec4 (line 2843) | ImVec4 ImGui::ColorConvertU32ToFloat4(ImU32 in)
function ImU32 (line 2853) | ImU32 ImGui::ColorConvertFloat4ToU32(const ImVec4& in)
function ImGuiStoragePair (line 2920) | ImGuiStoragePair* ImLowerBound(ImGuiStoragePair* in_begin, ImGuiStorageP...
function IM_MSVC_RUNTIME_CHECKS_OFF (line 2940) | IM_MSVC_RUNTIME_CHECKS_OFF
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 3052) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function IM_MSVC_RUNTIME_CHECKS_OFF (line 3220) | IM_MSVC_RUNTIME_CHECKS_OFF
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 3234) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function ImGuiListClipper_SortAndFuseRanges (line 3248) | static void ImGuiListClipper_SortAndFuseRanges(ImVector<ImGuiListClipper...
function ImGuiListClipper_SeekCursorAndSetupPrevLine (line 3272) | static void ImGuiListClipper_SeekCursorAndSetupPrevLine(ImGuiListClipper...
function ImGuiListClipper_StepInternal (line 3382) | static bool ImGuiListClipper_StepInternal(ImGuiListClipper* clipper)
function ImGuiStyle (line 3574) | ImGuiStyle& ImGui::GetStyle()
function ImU32 (line 3580) | ImU32 ImGui::GetColorU32(ImGuiCol idx, float alpha_mul)
function ImU32 (line 3588) | ImU32 ImGui::GetColorU32(const ImVec4& col)
function ImVec4 (line 3596) | const ImVec4& ImGui::GetStyleColorVec4(ImGuiCol idx)
function ImU32 (line 3602) | ImU32 ImGui::GetColorU32(ImU32 col, float alpha_mul)
function ImGuiStyleVarInfo (line 3703) | const ImGuiStyleVarInfo* ImGui::GetStyleVarInfo(ImGuiStyleVar idx)
function ImGuiContext (line 4113) | ImGuiContext* ImGui::GetCurrentContext()
function ImGuiContext (line 4142) | ImGuiContext* ImGui::CreateContext(ImFontAtlas* shared_font_atlas)
function ImGuiID (line 4597) | ImGuiID ImGui::AddContextHook(ImGuiContext* ctx, const ImGuiContextHook*...
function SetCurrentWindow (line 4670) | static void SetCurrentWindow(ImGuiWindow* window)
function ImGuiID (line 4809) | ImGuiID ImGui::GetHoveredID()
function CalcDelayFromHoveredFlags (line 4871) | static inline float CalcDelayFromHoveredFlags(ImGuiHoveredFlags flags)
function ImGuiHoveredFlags (line 4881) | static ImGuiHoveredFlags ApplyHoverFlagsForTooltip(ImGuiHoveredFlags use...
function ImGuiIO (line 5219) | ImGuiIO& ImGui::GetIO()
function ImGuiIO (line 5226) | ImGuiIO& ImGui::GetIO(ImGuiContext* ctx)
function ImGuiPlatformIO (line 5232) | ImGuiPlatformIO& ImGui::GetPlatformIO()
function ImGuiPlatformIO (line 5239) | ImGuiPlatformIO& ImGui::GetPlatformIO(ImGuiContext* ctx)
function ImDrawData (line 5246) | ImDrawData* ImGui::GetDrawData()
function ImDrawList (line 5263) | static ImDrawList* GetViewportBgFgDrawList(ImGuiViewportP* viewport, siz...
function ImDrawList (line 5287) | ImDrawList* ImGui::GetBackgroundDrawList(ImGuiViewport* viewport)
function ImDrawList (line 5294) | ImDrawList* ImGui::GetForegroundDrawList(ImGuiViewport* viewport)
function ImDrawListSharedData (line 5301) | ImDrawListSharedData* ImGui::GetDrawListSharedData()
function TranslateWindow (line 5499) | static void TranslateWindow(ImGuiWindow* window, const ImVec2& delta)
function ScaleWindow (line 5511) | static void ScaleWindow(ImGuiWindow* window, float scale)
function IsWindowActiveAndVisible (line 5520) | static bool IsWindowActiveAndVisible(ImGuiWindow* window)
function SetupDrawListSharedData (line 5613) | static void SetupDrawListSharedData()
function AddWindowToSortBuffer (line 5940) | static void AddWindowToSortBuffer(ImVector<ImGuiWindow*>* out_sorted_win...
function AddWindowToDrawData (line 5956) | static void AddWindowToDrawData(ImGuiWindow* window, int layer)
function GetWindowDisplayLayer (line 5970) | static inline int GetWindowDisplayLayer(ImGuiWindow* window)
function AddRootWindowToDrawData (line 5976) | static inline void AddRootWindowToDrawData(ImGuiWindow* window)
function FlattenDrawDataIntoSingleLayer (line 5981) | static void FlattenDrawDataIntoSingleLayer(ImDrawDataBuilder* builder)
function InitViewportDrawData (line 5999) | static void InitViewportDrawData(ImGuiViewportP* viewport)
function ImGuiWindow (line 6049) | static ImGuiWindow* FindFrontMostVisibleChildWindow(ImGuiWindow* window)
function ImGuiWindow (line 6097) | ImGuiWindow* ImGui::FindBottomMostVisibleWindowWithinBeginStack(ImGuiWin...
function ImVec2 (line 6360) | ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool ...
function ImGuiID (line 6600) | ImGuiID ImGui::GetItemID()
function ImVec2 (line 6606) | ImVec2 ImGui::GetItemRectMin()
function ImVec2 (line 6612) | ImVec2 ImGui::GetItemRectMax()
function ImVec2 (line 6618) | ImVec2 ImGui::GetItemRectSize()
function ImGuiItemFlags (line 6624) | ImGuiItemFlags ImGui::GetItemFlags()
function SetWindowConditionAllowFlags (line 6821) | static void SetWindowConditionAllowFlags(ImGuiWindow* window, ImGuiCond ...
function ImGuiWindow (line 6829) | ImGuiWindow* ImGui::FindWindowByID(ImGuiID id)
function ImGuiWindow (line 6835) | ImGuiWindow* ImGui::FindWindowByName(const char* name)
function ApplyWindowSettings (line 6841) | static void ApplyWindowSettings(ImGuiWindow* window, ImGuiWindowSettings...
function InitOrLoadWindowSettings (line 6858) | static void InitOrLoadWindowSettings(ImGuiWindow* window, ImGuiWindowSet...
function ImGuiWindow (line 6890) | static ImGuiWindow* CreateNewWindow(const char* name, ImGuiWindowFlags f...
function ImGuiWindow (line 6914) | static ImGuiWindow* GetWindowForTitleDisplay(ImGuiWindow* window)
function ImGuiWindow (line 6919) | static ImGuiWindow* GetWindowForTitleAndMenuHeight(ImGuiWindow* window)
function ImVec2 (line 6924) | static inline ImVec2 CalcWindowMinSize(ImGuiWindow* window)
function ImVec2 (line 6948) | static ImVec2 CalcWindowSizeAfterConstraint(ImGuiWindow* window, const I...
function CalcWindowContentSizes (line 6977) | static void CalcWindowContentSizes(ImGuiWindow* window, ImVec2* content_...
function ImVec2 (line 6997) | static ImVec2 CalcWindowAutoFitSize(ImGuiWindow* window, const ImVec2& s...
function ImVec2 (line 7043) | ImVec2 ImGui::CalcWindowNextAutoFitSize(ImGuiWindow* window)
function ImGuiCol (line 7053) | static ImGuiCol GetWindowBgColorIdx(ImGuiWindow* window)
function CalcResizePosSizeFromAnyCorner (line 7062) | static void CalcResizePosSizeFromAnyCorner(ImGuiWindow* window, const Im...
type ImGuiResizeGripDef (line 7089) | struct ImGuiResizeGripDef
type ImGuiResizeBorderDef (line 7104) | struct ImGuiResizeBorderDef
function ImRect (line 7118) | static ImRect GetResizeBorderRect(ImGuiWindow* window, int border_n, flo...
function ImGuiID (line 7132) | ImGuiID ImGui::GetWindowResizeCornerID(ImGuiWindow* window, int n)
function ImGuiID (line 7142) | ImGuiID ImGui::GetWindowResizeBorderID(ImGuiWindow* window, ImGuiDir dir)
function ClampWindowPos (line 7370) | static inline void ClampWindowPos(ImGuiWindow* window, const ImRect& vis...
function RenderWindowOuterSingleBorder (line 7381) | static void RenderWindowOuterSingleBorder(ImGuiWindow* window, int borde...
function SetWindowActiveForSkipRefresh (line 7721) | static void SetWindowActiveForSkipRefresh(ImGuiWindow* window)
function ImGuiWindow (line 8870) | static ImGuiWindow* GetCombinedRootWindow(ImGuiWindow* window, bool popu...
function ImGuiID (line 8993) | ImGuiID ImGui::GetWindowDockID()
function ImVec2 (line 9017) | ImVec2 ImGui::GetWindowPos()
function ImVec2 (line 9060) | ImVec2 ImGui::GetWindowSize()
function ImDrawList (line 9251) | ImDrawList* ImGui::GetWindowDrawList()
function ImGuiViewport (line 9263) | ImGuiViewport* ImGui::GetWindowViewport()
function ImFont (line 9270) | ImFont* ImGui::GetFont()
function ImFontBaked (line 9275) | ImFontBaked* ImGui::GetFontBaked()
function ImVec2 (line 9288) | ImVec2 ImGui::GetFontTexUvWhitePixel()
function ImGuiStorage (line 9434) | ImGuiStorage* ImGui::GetStateStorage()
function ImFont (line 9547) | ImFont* ImGui::GetDefaultFont()
function IM_MSVC_RUNTIME_CHECKS_OFF (line 9724) | IM_MSVC_RUNTIME_CHECKS_OFF
function ImGuiID (line 9737) | ImGuiID ImGuiWindow::GetID(const void* ptr)
function ImGuiID (line 9749) | ImGuiID ImGuiWindow::GetID(int n)
function ImGuiID (line 9763) | ImGuiID ImGuiWindow::GetIDFromPos(const ImVec2& p_abs)
function ImGuiID (line 9772) | ImGuiID ImGuiWindow::GetIDFromRectangle(const ImRect& r_abs)
function ImGuiID (line 9827) | ImGuiID ImGui::GetIDWithSeed(const char* str, const char* str_end, ImGui...
function ImGuiID (line 9838) | ImGuiID ImGui::GetIDWithSeed(int n, ImGuiID seed)
function ImGuiID (line 9856) | ImGuiID ImGui::GetID(const char* str_id)
function ImGuiID (line 9862) | ImGuiID ImGui::GetID(const char* str_id_begin, const char* str_id_end)
function ImGuiID (line 9868) | ImGuiID ImGui::GetID(const void* ptr_id)
function ImGuiID (line 9874) | ImGuiID ImGui::GetID(int int_id)
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 9879) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function ImGuiKeyChord (line 9960) | ImGuiKeyChord ImGui::FixupKeyChord(ImGuiKeyChord key_chord)
function ImGuiKeyData (line 9969) | ImGuiKeyData* ImGui::GetKeyData(ImGuiContext* ctx, ImGuiKey key)
function ImVec2 (line 10085) | ImVec2 ImGui::GetKeyMagnitude2d(ImGuiKey key_left, ImGuiKey key_right, I...
function ImGuiID (line 10137) | static inline ImGuiID GetRoutingIdFromOwnerId(ImGuiID owner_id)
function ImGuiKeyRoutingData (line 10143) | ImGuiKeyRoutingData* ImGui::GetShortcutRoutingData(ImGuiKeyChord key_chord)
function CalcRoutingScore (line 10188) | static int CalcRoutingScore(ImGuiID focus_scope_id, ImGuiID owner_id, Im...
function IsKeyChordPotentiallyCharInput (line 10240) | static bool IsKeyChordPotentiallyCharInput(ImGuiKeyChord key_chord)
function ImVec2 (line 10562) | ImVec2 ImGui::GetMousePos()
function ImVec2 (line 10580) | ImVec2 ImGui::GetMousePosOnOpeningCurrentPopup()
function ImVec2 (line 10612) | ImVec2 ImGui::GetMouseDragDelta(ImGuiMouseButton button, float lock_thre...
function ImGuiMouseCursor (line 10637) | ImGuiMouseCursor ImGui::GetMouseCursor()
function UpdateAliasKey (line 10652) | static void UpdateAliasKey(ImGuiKey key, bool v, float analog_value)
function ImGuiKeyChord (line 10661) | static ImGuiKeyChord GetMergedModsFromKeys()
function LockWheelingWindow (line 10817) | static void LockWheelingWindow(ImGuiWindow* window, float wheel_amount)
function ImGuiWindow (line 10836) | static ImGuiWindow* FindBestWheelingWindow(const ImVec2& wheel)
function DebugPrintInputEvent (line 10994) | static void DebugPrintInputEvent(const char* prefix, const ImGuiInputEve...
function ImGuiID (line 11154) | ImGuiID ImGui::GetKeyOwner(ImGuiKey key)
function IM_MSVC_RUNTIME_CHECKS_OFF (line 11852) | IM_MSVC_RUNTIME_CHECKS_OFF
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 11955) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 12026) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function ImVec2 (line 12059) | ImVec2 ImGui::GetCursorScreenPos()
function ImVec2 (line 12075) | ImVec2 ImGui::GetCursorPos()
function ImVec2 (line 12117) | ImVec2 ImGui::GetCursorStartPos()
function ImVec2 (line 12213) | ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_w, float default_h)
function ImVec2 (line 12256) | ImVec2 ImGui::GetContentRegionAvail()
function ImVec2 (line 12268) | ImVec2 ImGui::GetContentRegionMax()
function ImVec2 (line 12273) | ImVec2 ImGui::GetWindowContentRegionMin()
function ImVec2 (line 12279) | ImVec2 ImGui::GetWindowContentRegionMax()
function CalcScrollEdgeSnap (line 12394) | static float CalcScrollEdgeSnap(float target, float snap_min, float snap...
function ImVec2 (line 12403) | static ImVec2 CalcNextScrollFromScrollTargetAndClamp(ImGuiWindow* window)
function ImVec2 (line 12441) | ImVec2 ImGui::ScrollToRectEx(ImGuiWindow* window, const ImRect& item_rec...
function ImGuiWindow (line 12776) | ImGuiWindow* ImGui::GetTopMostPopupModal()
function ImGuiWindow (line 12787) | ImGuiWindow* ImGui::GetTopMostAndVisiblePopupModal()
function ImGuiWindow (line 12811) | ImGuiWindow* ImGui::FindBlockingModal(ImGuiWindow* window)
function ImGuiMouseButton (line 13133) | ImGuiMouseButton ImGui::GetMouseButtonFromPopupFlags(ImGuiPopupFlags flags)
function ImVec2 (line 13224) | ImVec2 ImGui::FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const I...
function ImRect (line 13299) | ImRect ImGui::GetPopupAllowedExtentRect(ImGuiWindow* window)
function ImVec2 (line 13320) | ImVec2 ImGui::FindBestWindowPosForPopup(ImGuiWindow* window)
function ImGuiDir (line 13764) | static ImGuiDir ImGetDirQuadrantFromDelta(float dx, float dy)
function NavScoreItemDistInterval (line 13771) | static float inline NavScoreItemDistInterval(float cand_min, float cand_...
function ImGuiWindow (line 14194) | static ImGuiWindow* ImGui::NavRestoreLastChildNavWindow(ImGuiWindow* win...
function ImGuiInputSource (line 14270) | static ImGuiInputSource ImGui::NavCalcPreferredRefPosSource(ImGuiWindowF...
function ImVec2 (line 14285) | static ImVec2 ImGui::NavCalcPreferredRefPos(ImGuiWindowFlags window_type)
function NavBiasScoringRect (line 14549) | static void NavBiasScoringRect(ImRect& r, ImVec2& preferred_pos_rel, ImG...
function ImGuiWindow (line 15058) | static ImGuiWindow* FindWindowNavFocusable(int i_start, int i_stop, int ...
function NavUpdateWindowingTarget (line 15067) | static void NavUpdateWindowingTarget(int focus_change_dir)
function ImGuiPayload (line 15675) | const ImGuiPayload* ImGui::AcceptDragDropPayload(const char* type, ImGui...
function ImGuiPayload (line 15750) | const ImGuiPayload* ImGui::GetDragDropPayload()
function LogTextV (line 15776) | static inline void LogTextV(ImGuiContext& g, const char* fmt, va_list args)
function ImGuiSettingsHandler (line 16092) | ImGuiSettingsHandler* ImGui::FindSettingsHandler(const char* type_name)
function ImGuiWindowSettings (line 16225) | ImGuiWindowSettings* ImGui::CreateNewWindowSettings(const char* name)
function ImGuiWindowSettings (line 16246) | ImGuiWindowSettings* ImGui::FindWindowSettingsByID(ImGuiID id)
function ImGuiWindowSettings (line 16256) | ImGuiWindowSettings* ImGui::FindWindowSettingsByWindow(ImGuiWindow* window)
function WindowSettingsHandler_ClearAll (line 16281) | static void WindowSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSetti...
function WindowSettingsHandler_ReadLine (line 16302) | static void WindowSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsH...
function WindowSettingsHandler_ApplyAll (line 16320) | static void WindowSettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSetti...
function WindowSettingsHandler_WriteAll (line 16332) | static void WindowSettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSetti...
function ImGuiViewport (line 16472) | ImGuiViewport* ImGui::GetMainViewport()
function ImGuiViewport (line 16479) | ImGuiViewport* ImGui::FindViewportByID(ImGuiID viewport_id)
function ImGuiViewport (line 16488) | ImGuiViewport* ImGui::FindViewportByPlatformHandle(void* platform_handle)
function IsViewportAbove (line 16546) | static bool IsViewportAbove(ImGuiViewportP* potential_above, ImGuiViewpo...
function ImGuiViewportP (line 16654) | ImGuiViewportP* ImGui::FindHoveredViewportFromPlatformWindowStack(const ...
function ImGuiViewportP (line 16937) | ImGuiViewportP* ImGui::AddUpdateViewport(ImGuiWindow* window, ImGuiID id...
function ImGuiPlatformMonitor (line 17454) | const ImGuiPlatformMonitor* ImGui::GetViewportPlatformMonitor(ImGuiViewp...
type ImGuiDockRequestType (line 17575) | enum ImGuiDockRequestType
type ImGuiDockRequest (line 17583) | struct ImGuiDockRequest
method ImGuiDockRequest (line 17595) | ImGuiDockRequest()
type ImGuiDockPreviewData (line 17606) | struct ImGuiDockPreviewData
method ImGuiDockPreviewData (line 17618) | ImGuiDockPreviewData() : FutureNode(0) { IsDropAllowed = IsCenterAvail...
type ImGuiDockNodeSettings (line 17622) | struct ImGuiDockNodeSettings
method ImGuiDockNodeSettings (line 17634) | ImGuiDockNodeSettings() { memset((void*)this, 0, sizeof(*this)); Split...
type ImGui (line 17641) | namespace ImGui
function ImGuiDockNode (line 17870) | ImGuiDockNode* ImGui::DockContextFindNodeByID(ImGuiContext* ctx, ImGuiID...
function ImGuiID (line 17875) | ImGuiID ImGui::DockContextGenNodeID(ImGuiContext* ctx)
function ImGuiDockNode (line 17886) | static ImGuiDockNode* ImGui::DockContextAddNode(ImGuiContext* ctx, ImGui...
type ImGuiDockContextPruneNodeData (line 17950) | struct ImGuiDockContextPruneNodeData
method ImGuiDockContextPruneNodeData (line 17954) | ImGuiDockContextPruneNodeData() { CountWindows = CountChildWindows = C...
function ImVec2 (line 18285) | static ImVec2 FixLargeWindowsWhenUndocking(const ImVec2& size, ImGuiView...
function DockNodeHideWindowDuringHostWindowCreation (line 18449) | static void DockNodeHideWindowDuringHostWindowCreation(ImGuiWindow* window)
type ImGuiDockNodeTreeInfo (line 18659) | struct ImGuiDockNodeTreeInfo
method ImGuiDockNodeTreeInfo (line 18666) | ImGuiDockNodeTreeInfo() { memset((void*)this, 0, sizeof(*this)); }
function DockNodeFindInfo (line 18669) | static void DockNodeFindInfo(ImGuiDockNode* node, ImGuiDockNodeTreeInfo*...
function ImGuiWindow (line 18691) | static ImGuiWindow* ImGui::DockNodeFindWindowByID(ImGuiDockNode* node, I...
function DockNodeSetupHostWindow (line 18852) | static void DockNodeSetupHostWindow(ImGuiDockNode* node, ImGuiWindow* ho...
function IsDockNodeTitleBarHighlighted (line 19256) | static bool IsDockNodeTitleBarHighlighted(ImGuiDockNode* node, ImGuiDock...
function DockNodeIsDropAllowedOne (line 19573) | static bool DockNodeIsDropAllowedOne(ImGuiWindow* payload, ImGuiWindow* ...
function DockNodeTreeUpdateSplitterFindTouchingNode (line 20147) | static void DockNodeTreeUpdateSplitterFindTouchingNode(ImGuiDockNode* no...
function ImGuiDockNode (line 20280) | ImGuiDockNode* ImGui::DockNodeTreeFindFallbackLeafNode(ImGuiDockNode* node)
function ImGuiDockNode (line 20291) | ImGuiDockNode* ImGui::DockNodeTreeFindVisibleNodeByPos(ImGuiDockNode* no...
function ImGuiID (line 20363) | ImGuiID ImGui::DockSpace(ImGuiID dockspace_id, const ImVec2& size_arg, I...
function ImGuiID (line 20473) | ImGuiID ImGui::DockSpaceOverViewport(ImGuiID dockspace_id, const ImGuiVi...
function ImGuiDockNode (line 20562) | ImGuiDockNode* ImGui::DockBuilderGetNode(ImGuiID node_id)
function ImGuiID (line 20596) | ImGuiID ImGui::DockBuilderAddNode(ImGuiID node_id, ImGuiDockNodeFlags fl...
function ImGuiID (line 20746) | ImGuiID ImGui::DockBuilderSplitNode(ImGuiID id, ImGuiDir split_dir, floa...
function ImGuiDockNode (line 20778) | static ImGuiDockNode* DockBuilderCopyNodeRec(ImGuiDockNode* src_node, Im...
type DockRemainingWindowTask (line 20914) | struct DockRemainingWindowTask { ImGuiWindow* Window; ImGuiID DockId; Do...
method DockRemainingWindowTask (line 20914) | DockRemainingWindowTask(ImGuiWindow* window, ImGuiID dock_id) { Window...
function ImGuiDockNode (line 20964) | static ImGuiDockNode* ImGui::DockContextBindNodeToWindow(ImGuiContext* c...
function StoreDockStyleForWindow (line 21007) | static void StoreDockStyleForWindow(ImGuiWindow* window)
function ImGuiDockNodeSettings (line 21306) | static ImGuiDockNodeSettings* ImGui::DockSettingsFindNodeSettings(ImGuiC...
method ImGuiDockNodeSettings (line 17634) | ImGuiDockNodeSettings() { memset((void*)this, 0, sizeof(*this)); Split...
function DockSettingsHandler_DockNodeToSettings (line 21383) | static void DockSettingsHandler_DockNodeToSettings(ImGuiDockContext* dc,...
function Platform_SetClipboardTextFn_DefaultImpl (line 21523) | static void Platform_SetClipboardTextFn_DefaultImpl(ImGuiContext*, const...
function Platform_SetClipboardTextFn_DefaultImpl (line 21550) | static void Platform_SetClipboardTextFn_DefaultImpl(ImGuiContext*, const...
function Platform_SetClipboardTextFn_DefaultImpl (line 21605) | static void Platform_SetClipboardTextFn_DefaultImpl(ImGuiContext* ctx, c...
function Platform_OpenInShellFn_DefaultImpl (line 21637) | static bool Platform_OpenInShellFn_DefaultImpl(ImGuiContext*, const char...
function Platform_OpenInShellFn_DefaultImpl (line 21648) | static bool Platform_OpenInShellFn_DefaultImpl(ImGuiContext*, const char...
function Platform_OpenInShellFn_DefaultImpl (line 21672) | static bool Platform_OpenInShellFn_DefaultImpl(ImGuiContext*, const char...
function Platform_SetImeDataFn_DefaultImpl (line 21685) | static void Platform_SetImeDataFn_DefaultImpl(ImGuiContext*, ImGuiViewpo...
function Platform_SetImeDataFn_DefaultImpl (line 21711) | static void Platform_SetImeDataFn_DefaultImpl(ImGuiContext*, ImGuiViewpo...
function MetricsHelpMarker (line 21747) | static void MetricsHelpMarker(const char* desc)
function RenderViewportsThumbnails (line 21795) | static void RenderViewportsThumbnails()
type KeyLayoutData (line 21847) | struct KeyLayoutData { int Row, Col; const char* Label; ImGuiKey Key; }
function DebugFlashStyleColorStop (line 21919) | static void DebugFlashStyleColorStop()
function ImU64 (line 21948) | ImU64 ImGui::DebugTextureIDToU64(ImTextureID tex_id)
type ImGuiFreeType (line 21966) | namespace ImGuiFreeType { IMGUI_API const ImFontLoader* GetFontLoader();...
type Funcs (line 22199) | struct Funcs
method ImRect (line 22201) | static ImRect GetTableRect(ImGuiTable* table, int rect_type, int n)
method ImRect (line 22221) | static ImRect GetWindowRect(ImGuiWindow* window, int rect_type)
type Func (line 22360) | struct Func { static int IMGUI_CDECL WindowComparerByBeginOrder(const vo...
method WindowComparerByBeginOrder (line 22360) | WindowComparerByBeginOrder(const void* lhs, const void* rhs) { return ...
function DebugNodeDockNodeFlags (line 22907) | static void DebugNodeDockNodeFlags(ImGuiDockNodeFlags* p_flags, const ch...
function CalcFontGlyphSrcOverlapMask (line 23121) | static int CalcFontGlyphSrcOverlapMask(ImFontAtlas* atlas, ImFont* font,...
function SameLineOrWrap (line 23615) | static void SameLineOrWrap(const ImVec2& size)
function ShowDebugLogFlag (line 23624) | static void ShowDebugLogFlag(const char* name, ImGuiDebugLogFlags flags)
function ImGuiID (line 23868) | static ImGuiID DebugItemPathQuery_UpdateAndGetHookId(ImGuiDebugItemPathQ...
function DebugItemPathQuery_FormatLevelInfo (line 23975) | static int DebugItemPathQuery_FormatLevelInfo(ImGuiDebugItemPathQuery* q...
FILE: Source/ThirdParty/ImGuiLibrary/imgui.h
type ImGuiID (line 162) | typedef unsigned int ImGuiID;
type ImS8 (line 163) | typedef signed char ImS8;
type ImU8 (line 164) | typedef unsigned char ImU8;
type ImS16 (line 165) | typedef signed short ImS16;
type ImU16 (line 166) | typedef unsigned short ImU16;
type ImS32 (line 167) | typedef signed int ImS32;
type ImU32 (line 168) | typedef unsigned int ImU32;
type ImS64 (line 169) | typedef signed long long ImS64;
type ImU64 (line 170) | typedef unsigned long long ImU64;
type ImDrawChannel (line 173) | struct ImDrawChannel
type ImDrawCmd (line 174) | struct ImDrawCmd
type ImDrawData (line 175) | struct ImDrawData
type ImDrawList (line 176) | struct ImDrawList
type ImDrawListSharedData (line 177) | struct ImDrawListSharedData
type ImDrawListSplitter (line 178) | struct ImDrawListSplitter
type ImDrawVert (line 179) | struct ImDrawVert
type ImFont (line 180) | struct ImFont
type ImFontAtlas (line 181) | struct ImFontAtlas
type ImFontAtlasBuilder (line 182) | struct ImFontAtlasBuilder
type ImFontAtlasRect (line 183) | struct ImFontAtlasRect
type ImFontBaked (line 184) | struct ImFontBaked
type ImFontConfig (line 185) | struct ImFontConfig
type ImFontGlyph (line 186) | struct ImFontGlyph
type ImFontGlyphRangesBuilder (line 187) | struct ImFontGlyphRangesBuilder
type ImFontLoader (line 188) | struct ImFontLoader
type ImTextureData (line 189) | struct ImTextureData
type ImTextureRect (line 190) | struct ImTextureRect
type ImColor (line 191) | struct ImColor
type ImGuiContext (line 194) | struct ImGuiContext
type ImGuiIO (line 195) | struct ImGuiIO
type ImGuiInputTextCallbackData (line 196) | struct ImGuiInputTextCallbackData
type ImGuiKeyData (line 197) | struct ImGuiKeyData
type ImGuiListClipper (line 198) | struct ImGuiListClipper
type ImGuiMultiSelectIO (line 199) | struct ImGuiMultiSelectIO
type ImGuiOnceUponAFrame (line 200) | struct ImGuiOnceUponAFrame
type ImGuiPayload (line 201) | struct ImGuiPayload
type ImGuiPlatformIO (line 202) | struct ImGuiPlatformIO
type ImGuiPlatformImeData (line 203) | struct ImGuiPlatformImeData
type ImGuiPlatformMonitor (line 204) | struct ImGuiPlatformMonitor
type ImGuiSelectionBasicStorage (line 205) | struct ImGuiSelectionBasicStorage
type ImGuiSelectionExternalStorage (line 206) | struct ImGuiSelectionExternalStorage
type ImGuiSelectionRequest (line 207) | struct ImGuiSelectionRequest
type ImGuiSizeCallbackData (line 208) | struct ImGuiSizeCallbackData
type ImGuiStorage (line 209) | struct ImGuiStorage
type ImGuiStoragePair (line 210) | struct ImGuiStoragePair
type ImGuiStyle (line 211) | struct ImGuiStyle
type ImGuiTableSortSpecs (line 212) | struct ImGuiTableSortSpecs
type ImGuiTableColumnSortSpecs (line 213) | struct ImGuiTableColumnSortSpecs
type ImGuiTextBuffer (line 214) | struct ImGuiTextBuffer
type ImGuiTextFilter (line 215) | struct ImGuiTextFilter
type ImGuiViewport (line 216) | struct ImGuiViewport
type ImGuiWindowClass (line 217) | struct ImGuiWindowClass
type ImGuiDir (line 225) | enum ImGuiDir : int
type ImGuiKey (line 226) | enum ImGuiKey : int
type ImGuiMouseSource (line 227) | enum ImGuiMouseSource : int
type ImGuiSortDirection (line 228) | enum ImGuiSortDirection
type ImGuiCol (line 229) | typedef int ImGuiCol;
type ImGuiCond (line 230) | typedef int ImGuiCond;
type ImGuiDataType (line 231) | typedef int ImGuiDataType;
type ImGuiMouseButton (line 232) | typedef int ImGuiMouseButton;
type ImGuiMouseCursor (line 233) | typedef int ImGuiMouseCursor;
type ImGuiStyleVar (line 234) | typedef int ImGuiStyleVar;
type ImGuiTableBgTarget (line 235) | typedef int ImGuiTableBgTarget;
type ImDrawFlags (line 242) | typedef int ImDrawFlags;
type ImDrawListFlags (line 243) | typedef int ImDrawListFlags;
type ImDrawTextFlags (line 244) | typedef int ImDrawTextFlags;
type ImFontFlags (line 245) | typedef int ImFontFlags;
type ImFontAtlasFlags (line 246) | typedef int ImFontAtlasFlags;
type ImGuiBackendFlags (line 247) | typedef int ImGuiBackendFlags;
type ImGuiButtonFlags (line 248) | typedef int ImGuiButtonFlags;
type ImGuiChildFlags (line 249) | typedef int ImGuiChildFlags;
type ImGuiColorEditFlags (line 250) | typedef int ImGuiColorEditFlags;
type ImGuiConfigFlags (line 251) | typedef int ImGuiConfigFlags;
type ImGuiComboFlags (line 252) | typedef int ImGuiComboFlags;
type ImGuiDockNodeFlags (line 253) | typedef int ImGuiDockNodeFlags;
type ImGuiDragDropFlags (line 254) | typedef int ImGuiDragDropFlags;
type ImGuiFocusedFlags (line 255) | typedef int ImGuiFocusedFlags;
type ImGuiHoveredFlags (line 256) | typedef int ImGuiHoveredFlags;
type ImGuiInputFlags (line 257) | typedef int ImGuiInputFlags;
type ImGuiInputTextFlags (line 258) | typedef int ImGuiInputTextFlags;
type ImGuiItemFlags (line 259) | typedef int ImGuiItemFlags;
type ImGuiKeyChord (line 260) | typedef int ImGuiKeyChord;
type ImGuiListClipperFlags (line 261) | typedef int ImGuiListClipperFlags;
type ImGuiPopupFlags (line 262) | typedef int ImGuiPopupFlags;
type ImGuiMultiSelectFlags (line 263) | typedef int ImGuiMultiSelectFlags;
type ImGuiSelectableFlags (line 264) | typedef int ImGuiSelectableFlags;
type ImGuiSliderFlags (line 265) | typedef int ImGuiSliderFlags;
type ImGuiTabBarFlags (line 266) | typedef int ImGuiTabBarFlags;
type ImGuiTabItemFlags (line 267) | typedef int ImGuiTabItemFlags;
type ImGuiTableFlags (line 268) | typedef int ImGuiTableFlags;
type ImGuiTableColumnFlags (line 269) | typedef int ImGuiTableColumnFlags;
type ImGuiTableRowFlags (line 270) | typedef int ImGuiTableRowFlags;
type ImGuiTreeNodeFlags (line 271) | typedef int ImGuiTreeNodeFlags;
type ImGuiViewportFlags (line 272) | typedef int ImGuiViewportFlags;
type ImGuiWindowFlags (line 273) | typedef int ImGuiWindowFlags;
type ImWchar32 (line 277) | typedef unsigned int ImWchar32;
type ImWchar16 (line 278) | typedef unsigned short ImWchar16;
type ImWchar32 (line 280) | typedef ImWchar32 ImWchar;
type ImWchar16 (line 282) | typedef ImWchar16 ImWchar;
type ImS64 (line 288) | typedef ImS64 ImGuiSelectionUserData;
function IM_MSVC_RUNTIME_CHECKS_OFF (line 299) | IM_MSVC_RUNTIME_CHECKS_OFF
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 2351) | IM_MSVC_RUNTIME_CHECKS_RESTORE
type ImGuiKeyData (line 2472) | struct ImGuiKeyData
type ImGuiIO (line 2480) | struct ImGuiIO
function SetSelection (line 2743) | struct ImGuiInputTextCallbackData
function ClearSelection (line 2774) | void ClearSelection() { SelectionStart = Selec...
type ImGuiSizeCallbackData (line 2780) | struct ImGuiSizeCallbackData
type ImGuiWindowClass (line 2795) | struct ImGuiWindowClass
function Clear (line 2811) | struct ImGuiPayload
function IsDataType (line 2827) | bool IsDataType(const char* type) const { return DataFrameCount != -1 &&...
type ImGuiOnceUponAFrame (line 2846) | struct ImGuiOnceUponAFrame
function IsActive (line 2854) | struct ImGuiTextFilter
type ImGuiTextBuffer (line 2881) | struct ImGuiTextBuffer
function clear (line 2892) | void clear() { Buf.clear(); }
function resize (line 2893) | void resize(int size) { if (Buf.Size > size) Buf.D...
function reserve (line 2894) | void reserve(int capacity) { Buf.reserve(capacity); }
function ImGuiStoragePair (line 2902) | struct ImGuiStoragePair
type ImGuiStorage (line 2919) | struct ImGuiStorage
type ImGuiListClipperFlags_ (line 2957) | enum ImGuiListClipperFlags_
type ImGuiListClipper (line 2983) | struct ImGuiListClipper
function ImColor (line 3084) | struct ImColor
function Value (line 3092) | constexpr ImColor(ImU32 rgba) : Value(...
function operator (line 3093) | inline operator ImU32() const { return...
type ImGuiMultiSelectFlags_ (line 3142) | enum ImGuiMultiSelectFlags_
type ImGuiMultiSelectIO (line 3170) | struct ImGuiMultiSelectIO
type ImGuiSelectionRequestType (line 3182) | enum ImGuiSelectionRequestType
type ImGuiSelectionRequest (line 3190) | struct ImGuiSelectionRequest
type ImGuiSelectionBasicStorage (line 3216) | struct ImGuiSelectionBasicStorage
type ImGuiSelectionExternalStorage (line 3239) | struct ImGuiSelectionExternalStorage
type ImDrawIdx (line 3264) | typedef unsigned short ImDrawIdx;
function GetTexID (line 3289) | struct ImDrawCmd
type ImDrawFlags_ (line 3358) | enum ImDrawFlags_
type ImDrawListFlags_ (line 3378) | enum ImDrawListFlags_
function GetClipRectMax (line 3396) | struct ImDrawList
function PathLineTo (line 3476) | inline void PathLineTo(const ImVec2& pos) ...
function PathLineToMergeDuplicate (line 3477) | inline void PathLineToMergeDuplicate(const ImVec2& pos) ...
function PathFillConvex (line 3478) | inline void PathFillConvex(ImU32 col) ...
function PathFillConcave (line 3479) | inline void PathFillConcave(ImU32 col) ...
function ChannelsSplit (line 3509) | inline void ChannelsSplit(int count) { _Splitter.Split(this, coun...
function ChannelsMerge (line 3510) | inline void ChannelsMerge() { _Splitter.Merge(this); }
function ChannelsSetCurrent (line 3511) | inline void ChannelsSetCurrent(int n) { _Splitter.SetCurrentChanne...
function PrimWriteVtx (line 3521) | inline void PrimWriteVtx(const ImVec2& pos, const ImVec2& uv, ImU32 ...
function PrimWriteIdx (line 3522) | inline void PrimWriteIdx(ImDrawIdx idx) ...
function PrimVtx (line 3523) | inline void PrimVtx(const ImVec2& pos, const ImVec2& uv, ImU32 col) ...
function PushTextureID (line 3527) | inline void PushTextureID(ImTextureRef tex_ref) { PushTexture(tex_re...
function PopTextureID (line 3528) | inline void PopTextureID() { PopTexture(); }
type ImDrawData (line 3554) | struct ImDrawData
type ImTextureFormat (line 3587) | enum ImTextureFormat
type ImTextureStatus (line 3594) | enum ImTextureStatus
type ImTextureRect (line 3606) | struct ImTextureRect
type ImTextureData (line 3619) | struct ImTextureData
function ImTextureRef (line 3648) | ImTextureRef GetTexRef() { ImTextureRef tex_ref; ...
function SetTexID (line 3654) | void SetTexID(ImTextureID tex_id) { TexID = tex_id; }
function SetStatus (line 3655) | void SetStatus(ImTextureStatus status) { Status = status; if (s...
type ImFontConfig (line 3663) | struct ImFontConfig
type ImFontGlyph (line 3706) | struct ImFontGlyph
function Clear (line 3722) | struct ImFontGlyphRangesBuilder
function GetBit (line 3728) | inline bool GetBit(size_t n) const { int off = (int)(n >> 5); ImU32...
function SetBit (line 3729) | inline void SetBit(size_t n) { int off = (int)(n >> 5); ImU32...
function AddChar (line 3730) | inline void AddChar(ImWchar c) { SetBit(c); }
type ImFontAtlasRectId (line 3738) | typedef int ImFontAtlasRectId;
type ImFontAtlasRect (line 3744) | struct ImFontAtlasRect
type ImFontAtlasFlags_ (line 3754) | enum ImFontAtlasFlags_
type ImFontAtlas (line 3781) | struct ImFontAtlas
type ImFontBaked (line 3932) | struct ImFontBaked
type ImFontFlags_ (line 3967) | enum ImFontFlags_
type ImFont (line 3980) | struct ImFont
type ImGuiViewportFlags_ (line 4050) | enum ImGuiViewportFlags_
function ImGuiViewport (line 4078) | struct ImGuiViewport
type ImGuiPlatformIO (line 4165) | struct ImGuiPlatformIO
type ImGuiPlatformMonitor (line 4277) | struct ImGuiPlatformMonitor
type ImGuiPlatformImeData (line 4287) | struct ImGuiPlatformImeData
function namespace (line 4305) | namespace ImGui
type ImFontAtlasRect (line 4404) | typedef ImFontAtlasRect ImFontAtlasCustomRect;
FILE: Source/ThirdParty/ImGuiLibrary/imgui_demo.cpp
type ImGuiDemoWindowData (line 236) | struct ImGuiDemoWindowData
type ExampleTreeNode (line 265) | struct ExampleTreeNode
function HelpMarker (line 275) | static void HelpMarker(const char* desc)
function ShowDockingDisabledMessage (line 287) | static void ShowDockingDisabledMessage()
type ImGuiDemoWindowData (line 310) | struct ImGuiDemoWindowData
function DemoWindowMenuBar (line 722) | static void DemoWindowMenuBar(ImGuiDemoWindowData* demo_data)
type ExampleTreeNode (line 800) | struct ExampleTreeNode
type ExampleMemberInfo (line 818) | struct ExampleMemberInfo
function ExampleTreeNode (line 835) | static ExampleTreeNode* ExampleTree_CreateNode(const char* name, int uid...
function ExampleTree_DestroyNode (line 847) | static void ExampleTree_DestroyNode(ExampleTreeNode* node)
function ExampleTreeNode (line 856) | static ExampleTreeNode* ExampleTree_CreateDemoTree()
function DemoWindowWidgetsBasic (line 889) | static void DemoWindowWidgetsBasic()
function DemoWindowWidgetsBullets (line 1104) | static void DemoWindowWidgetsBullets()
function DemoWindowWidgetsCollapsingHeaders (line 1126) | static void DemoWindowWidgetsCollapsingHeaders()
function DemoWindowWidgetsColorAndPickers (line 1157) | static void DemoWindowWidgetsColorAndPickers()
function DemoWindowWidgetsComboBoxes (line 1358) | static void DemoWindowWidgetsComboBoxes()
function DemoWindowWidgetsDataTypes (line 1455) | static void DemoWindowWidgetsDataTypes()
function DemoWindowWidgetsDisableBlocks (line 1590) | static void DemoWindowWidgetsDisableBlocks(ImGuiDemoWindowData* demo_data)
function DemoWindowWidgetsDragAndDrop (line 1605) | static void DemoWindowWidgetsDragAndDrop()
function DemoWindowWidgetsDragsAndSliders (line 1763) | static void DemoWindowWidgetsDragsAndSliders()
type ImGui (line 1821) | namespace ImGui { IMGUI_API void ShowFontAtlas(ImFontAtlas* atlas); }
function DemoWindowWidgetsFonts (line 1823) | static void DemoWindowWidgetsFonts()
function DemoWindowWidgetsImages (line 1839) | static void DemoWindowWidgetsImages()
function DemoWindowWidgetsListBoxes (line 1932) | static void DemoWindowWidgetsListBoxes()
function DemoWindowWidgetsMultiComponents (line 1997) | static void DemoWindowWidgetsMultiComponents()
function DemoWindowWidgetsPlotting (line 2044) | static void DemoWindowWidgetsPlotting()
function DemoWindowWidgetsProgressBars (line 2120) | static void DemoWindowWidgetsProgressBars()
function DemoWindowWidgetsQueryingStatuses (line 2157) | static void DemoWindowWidgetsQueryingStatuses()
function DemoWindowWidgetsSelectables (line 2373) | static void DemoWindowWidgetsSelectables()
type ExampleSelectionWithDeletion (line 2554) | struct ExampleSelectionWithDeletion : ImGuiSelectionBasicStorage
method ApplyDeletionPreLoop (line 2563) | int ApplyDeletionPreLoop(ImGuiMultiSelectIO* ms_io, int items_count)
method ApplyDeletionPostLoop (line 2593) | void ApplyDeletionPostLoop(ImGuiMultiSelectIO* ms_io, ImVector<ITEM_TY...
type ExampleDualListBox (line 2617) | struct ExampleDualListBox
method MoveAll (line 2623) | void MoveAll(int src, int dst)
method MoveSelected (line 2633) | void MoveSelected(int src, int dst)
method ApplySelectionRequests (line 2649) | void ApplySelectionRequests(ImGuiMultiSelectIO* ms_io, int side)
method CompareItemsByValue (line 2656) | CompareItemsByValue(const void* lhs, const void* rhs)
method SortItems (line 2662) | void SortItems(int n)
method Show (line 2666) | void Show()
function DemoWindowWidgetsSelectionAndMultiSelect (line 2771) | static void DemoWindowWidgetsSelectionAndMultiSelect(ImGuiDemoWindowData...
function EditTabBarFittingPolicyFlags (line 3517) | static void EditTabBarFittingPolicyFlags(ImGuiTabBarFlags* p_flags)
function DemoWindowWidgetsTabs (line 3529) | static void DemoWindowWidgetsTabs()
function DemoWindowWidgetsText (line 3673) | static void DemoWindowWidgetsText()
function DemoWindowWidgetsTextFilter (line 3792) | static void DemoWindowWidgetsTextFilter()
function DemoWindowWidgetsTextInput (line 3819) | static void DemoWindowWidgetsTextInput()
function DemoWindowWidgetsTooltips (line 4039) | static void DemoWindowWidgetsTooltips()
function DemoWindowWidgetsTreeNodes (line 4138) | static void DemoWindowWidgetsTreeNodes()
function DemoWindowWidgetsVerticalSliders (line 4308) | static void DemoWindowWidgetsVerticalSliders()
function DemoWindowWidgets (line 4380) | static void DemoWindowWidgets(ImGuiDemoWindowData* demo_data)
function DemoWindowLayout (line 4431) | static void DemoWindowLayout()
function DemoWindowPopups (line 5318) | static void DemoWindowPopups()
type MyItemColumnID (line 5624) | enum MyItemColumnID
type MyItem (line 5633) | struct MyItem
method SortWithSortSpecs (line 5648) | static void SortWithSortSpecs(ImGuiTableSortSpecs* sort_specs, MyItem*...
method CompareWithSortSpecs (line 5657) | CompareWithSortSpecs(const void* lhs, const void* rhs)
function PushStyleCompact (line 5691) | static void PushStyleCompact()
function PopStyleCompact (line 5698) | static void PopStyleCompact()
function EditTableSizingFlags (line 5704) | static void EditTableSizingFlags(ImGuiTableFlags* p_flags)
function EditTableColumnsFlags (line 5745) | static void EditTableColumnsFlags(ImGuiTableColumnFlags* p_flags)
function ShowTableColumnsStatusFlags (line 5770) | static void ShowTableColumnsStatusFlags(ImGuiTableColumnFlags flags)
function DemoWindowTables (line 5782) | static void DemoWindowTables()
function ShowExampleAppConsole (line 9319) | static void ShowExampleAppConsole(bool* p_open)
function Draw (line 9333) | struct ExampleAppLog
function ShowExampleAppLog (line 9457) | static void ShowExampleAppLog(bool* p_open)
function ShowExampleAppLayout (line 9492) | static void ShowExampleAppLayout(bool* p_open)
type ExampleAppPropertyEditor (line 9562) | struct ExampleAppPropertyEditor
method Draw (line 9567) | void Draw(ExampleTreeNode* root_node)
method DrawTreeNode (line 9657) | void DrawTreeNode(ExampleTreeNode* node)
function ShowExampleAppPropertyEditor (line 9689) | static void ShowExampleAppPropertyEditor(bool* p_open, ImGuiDemoWindowDa...
function ShowExampleAppLongText (line 9712) | static void ShowExampleAppLongText(bool* p_open)
function ShowExampleAppAutoResize (line 9775) | static void ShowExampleAppAutoResize(bool* p_open)
function ShowExampleAppConstrainedResize (line 9801) | static void ShowExampleAppConstrainedResize(bool* p_open)
function ShowExampleAppSimpleOverlay (line 9902) | static void ShowExampleAppSimpleOverlay(bool* p_open)
function ShowExampleAppFullscreen (line 9958) | static void ShowExampleAppFullscreen(bool* p_open)
function ShowExampleAppWindowTitles (line 9996) | static void ShowExampleAppWindowTitles(bool*)
function PathConcaveShape (line 10030) | static void PathConcaveShape(ImDrawList* draw_list, float x, float y, fl...
function ShowExampleAppCustomRendering (line 10038) | static void ShowExampleAppCustomRendering(bool* p_open)
type ImGuiDemoDockspaceArgs (line 10343) | struct ImGuiDemoDockspaceArgs
function ShowExampleAppDockSpaceAdvanced (line 10363) | static void ShowExampleAppDockSpaceAdvanced(ImGuiDemoDockspaceArgs* args...
function ShowExampleAppDockSpaceBasic (line 10412) | static void ShowExampleAppDockSpaceBasic(ImGuiDockNodeFlags flags)
function ShowExampleAppDockSpace (line 10426) | void ShowExampleAppDockSpace(bool* p_open)
type MyDocument (line 10502) | struct MyDocument
method MyDocument (line 10511) | MyDocument(int uid, const char* name, bool open = true, const ImVec4& ...
method DoOpen (line 10519) | void DoOpen() { Open = true; }
method DoForceClose (line 10520) | void DoForceClose() { Open = false; Dirty = false; }
method DoSave (line 10521) | void DoSave() { Dirty = false; }
type ExampleAppDocuments (line 10524) | struct ExampleAppDocuments
method ExampleAppDocuments (line 10531) | ExampleAppDocuments()
method GetTabName (line 10542) | void GetTabName(MyDocument* doc, char* out_buf, size_t out_buf_size)
method DisplayDocContents (line 10548) | void DisplayDocContents(MyDocument* doc)
method DisplayDocContextMenu (line 10582) | void DisplayDocContextMenu(MyDocument* doc)
method NotifyOfDocumentsClosedElsewhere (line 10606) | void NotifyOfDocumentsClosedElsewhere()
function ShowExampleAppDocuments (line 10617) | void ShowExampleAppDocuments(bool* p_open)
type ExampleAsset (line 10888) | struct ExampleAsset
method ExampleAsset (line 10893) | ExampleAsset(ImGuiID id, int type) { ID = id; Type = type; }
method SortWithSortSpecs (line 10897) | static void SortWithSortSpecs(ImGuiTableSortSpecs* sort_specs, Example...
method CompareWithSortSpecs (line 10906) | CompareWithSortSpecs(const void* lhs, const void* rhs)
type ExampleAssetsBrowser (line 10928) | struct ExampleAssetsBrowser
method ExampleAssetsBrowser (line 10958) | ExampleAssetsBrowser()
method AddItems (line 10962) | void AddItems(int count)
method ClearItems (line 10971) | void ClearItems()
method UpdateLayoutSizes (line 10979) | void UpdateLayoutSizes(float avail_width)
method Draw (line 11000) | void Draw(const char* title, bool* p_open)
function ShowExampleAppAssetsBrowser (line 11273) | void ShowExampleAppAssetsBrowser(bool* p_open)
FILE: Source/ThirdParty/ImGuiLibrary/imgui_draw.cpp
type IMGUI_STB_NAMESPACE (line 100) | namespace IMGUI_STB_NAMESPACE
function ImDrawList (line 500) | ImDrawList* ImDrawList::CloneOutput() const
function ImVec2 (line 1346) | ImVec2 ImBezierCubicCalc(const ImVec2& p1, const ImVec2& p2, const ImV...
function ImVec2 (line 1356) | ImVec2 ImBezierQuadraticCalc(const ImVec2& p1, const ImVec2& p2, const...
function PathBezierCubicCurveToCasteljau (line 1366) | static void PathBezierCubicCurveToCasteljau(ImVector<ImVec2>* path, fl...
function PathBezierQuadraticCurveToCasteljau (line 1391) | static void PathBezierQuadraticCurveToCasteljau(ImVector<ImVec2>* path...
function ImDrawFlags (line 1441) | static inline ImDrawFlags FixRectCornerFlags(ImDrawFlags flags)
type ImTriangulatorNodeType (line 1817) | enum ImTriangulatorNodeType
type ImTriangulatorNode (line 1824) | struct ImTriangulatorNode
method Unlink (line 1832) | void Unlink() { Next->Prev = Prev; Prev->Next = Next; }
type ImTriangulatorNodeSpan (line 1835) | struct ImTriangulatorNodeSpan
method push_back (line 1840) | void push_back(ImTriangulatorNode* node) { Data[Size++] = node; }
method find_erase_unsorted (line 1841) | void find_erase_unsorted(int idx) { for (int i = Size - 1;...
type ImTriangulator (line 1844) | struct ImTriangulator
method EstimateTriangleCount (line 1846) | static int EstimateTriangleCount(int points_count) { return (po...
method EstimateScratchBufferSize (line 1847) | static int EstimateScratchBufferSize(int points_count) { return siz...
function ImTextureDataGetFormatBytesPerPixel (line 2444) | int ImTextureDataGetFormatBytesPerPixel(ImTextureFormat format)
function ImFontAtlasBuildUpdateRendererHasTexturesFromContext (line 2739) | static void ImFontAtlasBuildUpdateRendererHasTexturesFromContext(ImFon...
function ImFontAtlasUpdateNewFrame (line 2758) | void ImFontAtlasUpdateNewFrame(ImFontAtlas* atlas, int frame_count, bo...
function ImFontAtlasTextureBlockConvert (line 2859) | void ImFontAtlasTextureBlockConvert(const unsigned char* src_pixels, I...
function ImFontAtlasTextureBlockPostProcess (line 2896) | void ImFontAtlasTextureBlockPostProcess(ImFontAtlasPostProcessData* data)
function ImFontAtlasTextureBlockPostProcessMultiply (line 2903) | void ImFontAtlasTextureBlockPostProcessMultiply(ImFontAtlasPostProcess...
function ImFontAtlasTextureBlockFill (line 2938) | void ImFontAtlasTextureBlockFill(ImTextureData* dst_tex, int dst_x, in...
function ImFontAtlasTextureBlockCopy (line 2958) | void ImFontAtlasTextureBlockCopy(ImTextureData* src_tex, int src_x, in...
function ImFontAtlasTextureBlockQueueUpload (line 2971) | void ImFontAtlasTextureBlockQueueUpload(ImFontAtlas* atlas, ImTextureD...
function GetTexDataAsFormat (line 2999) | static void GetTexDataAsFormat(ImFontAtlas* atlas, ImTextureFormat for...
function ImFont (line 3031) | ImFont* ImFontAtlas::AddFont(const ImFontConfig* font_cfg_in)
function Decode85Byte (line 3112) | static unsigned int Decode85Byte(char c) ...
function Decode85 (line 3113) | static void Decode85(const unsigned char* src, unsigned char* ...
function GetExpectedContextFontSize (line 3129) | static float GetExpectedContextFontSize(ImGuiContext* ctx)
function ImFont (line 3137) | ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg)
function ImFont (line 3147) | ImFont* ImFontAtlas::AddFontDefaultBitmap(const ImFontConfig* font_cfg...
function ImFont (line 3172) | ImFont* ImFontAtlas::AddFontDefaultVector(const ImFontConfig* font_cfg...
function ImFont (line 3195) | ImFont* ImFontAtlas::AddFontFromFileTTF(const char* filename, float si...
function ImFont (line 3221) | ImFont* ImFontAtlas::AddFontFromMemoryTTF(void* font_data, int font_da...
function ImFont (line 3235) | ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compre...
function ImFont (line 3247) | ImFont* ImFontAtlas::AddFontFromMemoryCompressedBase85TTF(const char* ...
function ImFontAtlasBuildNotifySetFont (line 3259) | void ImFontAtlasBuildNotifySetFont(ImFontAtlas* atlas, ImFont* old_fon...
function ImFontAtlasRectId (line 3315) | ImFontAtlasRectId ImFontAtlas::AddCustomRect(int width, int height, Im...
function ImFontAtlasRectId (line 3351) | ImFontAtlasRectId ImFontAtlas::AddCustomRectFontGlyph(ImFont* font, Im...
function ImFontAtlasRectId (line 3358) | ImFontAtlasRectId ImFontAtlas::AddCustomRectFontGlyphForSize(ImFont* f...
function ImFontAtlasGetMouseCursorTexData (line 3411) | bool ImFontAtlasGetMouseCursorTexData(ImFontAtlas* atlas, ImGuiMouseCu...
function ImFontAtlasBuildMain (line 3432) | void ImFontAtlasBuildMain(ImFontAtlas* atlas)
function ImFontAtlasBuildGetOversampleFactors (line 3452) | void ImFontAtlasBuildGetOversampleFactors(ImFontConfig* src, ImFontBak...
function ImFontAtlasBuildSetupFontLoader (line 3463) | void ImFontAtlasBuildSetupFontLoader(ImFontAtlas* atlas, const ImFontL...
function ImFontAtlasBuildLegacyPreloadAllGlyphRanges (line 3489) | void ImFontAtlasBuildLegacyPreloadAllGlyphRanges(ImFontAtlas* atlas)
function ImFontAtlasBuildUpdatePointers (line 3510) | void ImFontAtlasBuildUpdatePointers(ImFontAtlas* atlas)
function ImFontAtlasBuildRenderBitmapFromString (line 3519) | void ImFontAtlasBuildRenderBitmapFromString(ImFontAtlas* atlas, int x,...
function ImFontAtlasBuildUpdateBasicTexData (line 3546) | static void ImFontAtlasBuildUpdateBasicTexData(ImFontAtlas* atlas)
function ImFontAtlasBuildUpdateLinesTexData (line 3580) | static void ImFontAtlasBuildUpdateLinesTexData(ImFontAtlas* atlas)
function ImFontAtlasFontInitOutput (line 3647) | bool ImFontAtlasFontInitOutput(ImFontAtlas* atlas, ImFont* font)
function ImFontAtlasFontDestroyOutput (line 3658) | void ImFontAtlasFontDestroyOutput(ImFontAtlas* atlas, ImFont* font)
function ImFontAtlasFontRebuildOutput (line 3669) | void ImFontAtlasFontRebuildOutput(ImFontAtlas* atlas, ImFont* font)
function ImFontAtlasFontSourceInit (line 3677) | bool ImFontAtlasFontSourceInit(ImFontAtlas* atlas, ImFontConfig* src)
function ImFontAtlasFontSourceAddToFont (line 3685) | void ImFontAtlasFontSourceAddToFont(ImFontAtlas* atlas, ImFont* font, ...
function ImFontAtlasFontDestroySourceData (line 3698) | void ImFontAtlasFontDestroySourceData(ImFontAtlas* atlas, ImFontConfig...
function ImFontGlyph (line 3717) | static ImFontGlyph* ImFontAtlasBuildSetupFontBakedEllipsis(ImFontAtlas...
function ImFontAtlasBuildSetupFontBakedFallback (line 3761) | static void ImFontAtlasBuildSetupFontBakedFallback(ImFontBaked* baked)
function ImFontAtlasBuildSetupFontBakedBlanks (line 3781) | static void ImFontAtlasBuildSetupFontBakedBlanks(ImFontAtlas* atlas, I...
function ImFontAtlasBuildSetupFontSpecialGlyphs (line 3801) | void ImFontAtlasBuildSetupFontSpecialGlyphs(ImFontAtlas* atlas, ImFont...
function ImFontAtlasBakedDiscardFontGlyph (line 3834) | void ImFontAtlasBakedDiscardFontGlyph(ImFontAtlas* atlas, ImFont* font...
function ImFontBaked (line 3849) | ImFontBaked* ImFontAtlasBakedAdd(ImFontAtlas* atlas, ImFont* font, flo...
function ImFontBaked (line 3881) | ImFontBaked* ImFontAtlasBakedGetClosestMatch(ImFontAtlas* atlas, ImFon...
function ImFontAtlasBakedDiscard (line 3909) | void ImFontAtlasBakedDiscard(ImFontAtlas* atlas, ImFont* font, ImFontB...
function ImFontAtlasFontDiscardBakes (line 3939) | void ImFontAtlasFontDiscardBakes(ImFontAtlas* atlas, ImFont* font, int...
function ImFontAtlasBuildDiscardBakes (line 3954) | void ImFontAtlasBuildDiscardBakes(ImFontAtlas* atlas, int unused_frames)
function ImFontAtlasAddDrawListSharedData (line 3969) | void ImFontAtlasAddDrawListSharedData(ImFontAtlas* atlas, ImDrawListSh...
function ImFontAtlasRemoveDrawListSharedData (line 3975) | void ImFontAtlasRemoveDrawListSharedData(ImFontAtlas* atlas, ImDrawLis...
function ImFontAtlasUpdateDrawListsTextures (line 3982) | void ImFontAtlasUpdateDrawListsTextures(ImFontAtlas* atlas, ImTextureR...
function ImFontAtlasUpdateDrawListsSharedData (line 4008) | void ImFontAtlasUpdateDrawListsSharedData(ImFontAtlas* atlas)
function ImFontAtlasBuildSetTexture (line 4019) | static void ImFontAtlasBuildSetTexture(ImFontAtlas* atlas, ImTextureDa...
function ImTextureData (line 4030) | ImTextureData* ImFontAtlasTextureAdd(ImFontAtlas* atlas, int w, int h)
function ImFontAtlasDebugWriteTexToDisk (line 4070) | static void ImFontAtlasDebugWriteTexToDisk(ImTextureData* tex, const c...
function ImFontAtlasTextureRepack (line 4079) | void ImFontAtlasTextureRepack(ImFontAtlas* atlas, int w, int h)
function ImFontAtlasTextureGrow (line 4151) | void ImFontAtlasTextureGrow(ImFontAtlas* atlas, int old_tex_w, int old...
function ImFontAtlasTextureMakeSpace (line 4183) | void ImFontAtlasTextureMakeSpace(ImFontAtlas* atlas)
function ImVec2i (line 4197) | ImVec2i ImFontAtlasTextureGetSizeEstimate(ImFontAtlas* atlas)
function ImFontAtlasBuildClear (line 4232) | void ImFontAtlasBuildClear(ImFontAtlas* atlas)
function ImFontAtlasTextureCompact (line 4247) | void ImFontAtlasTextureCompact(ImFontAtlas* atlas)
function ImFontAtlasBuildInit (line 4262) | void ImFontAtlasBuildInit(ImFontAtlas* atlas)
function ImFontAtlasBuildDestroy (line 4310) | void ImFontAtlasBuildDestroy(ImFontAtlas* atlas)
function ImFontAtlasPackInit (line 4323) | void ImFontAtlasPackInit(ImFontAtlas * atlas)
function ImFontAtlasRectId (line 4339) | static ImFontAtlasRectId ImFontAtlasPackAllocRectEntry(ImFontAtlas* at...
function ImFontAtlasRectId (line 4364) | static ImFontAtlasRectId ImFontAtlasPackReuseRectEntry(ImFontAtlas* at...
function ImFontAtlasPackDiscardRect (line 4373) | void ImFontAtlasPackDiscardRect(ImFontAtlas* atlas, ImFontAtlasRectId id)
function ImFontAtlasRectId (line 4400) | ImFontAtlasRectId ImFontAtlasPackAddRect(ImFontAtlas* atlas, int w, in...
function ImTextureRect (line 4448) | ImTextureRect* ImFontAtlasPackGetRect(ImFontAtlas* atlas, ImFontAtlasR...
function ImTextureRect (line 4461) | ImTextureRect* ImFontAtlasPackGetRectSafe(ImFontAtlas* atlas, ImFontAt...
function ImFontAtlasBuildAcceptCodepointForSource (line 4480) | static bool ImFontAtlasBuildAcceptCodepointForSource(ImFontConfig* src...
function ImFontBaked_BuildGrowIndex (line 4489) | static void ImFontBaked_BuildGrowIndex(ImFontBaked* baked, int new_size)
function ImFontAtlas_FontHookRemapCodepoint (line 4498) | static void ImFontAtlas_FontHookRemapCodepoint(ImFontAtlas* atlas, ImF...
function ImFontGlyph (line 4505) | static ImFontGlyph* ImFontBaked_BuildLoadGlyph(ImFontBaked* baked, ImW...
function ImFontBaked_BuildLoadGlyphAdvanceX (line 4576) | static float ImFontBaked_BuildLoadGlyphAdvanceX(ImFontBaked* baked, Im...
function IM_MSVC_RUNTIME_CHECKS_OFF (line 4593) | IM_MSVC_RUNTIME_CHECKS_OFF
function ImFontAtlasDebugLogTextureRequests (line 4601) | void ImFontAtlasDebugLogTextureRequests(ImFontAtlas* atlas)
type ImGui_ImplStbTrueType_FontSrcData (line 4638) | struct ImGui_ImplStbTrueType_FontSrcData
function ImGui_ImplStbTrueType_FontSrcInit (line 4644) | static bool ImGui_ImplStbTrueType_FontSrcInit(ImFontAtlas* atlas, ImFo...
function ImGui_ImplStbTrueType_FontSrcDestroy (line 4679) | static void ImGui_ImplStbTrueType_FontSrcDestroy(ImFontAtlas* atlas, I...
function ImGui_ImplStbTrueType_FontSrcContainsGlyph (line 4687) | static bool ImGui_ImplStbTrueType_FontSrcContainsGlyph(ImFontAtlas* at...
function ImGui_ImplStbTrueType_FontBakedInit (line 4698) | static bool ImGui_ImplStbTrueType_FontBakedInit(ImFontAtlas* atlas, Im...
function ImGui_ImplStbTrueType_FontBakedLoadGlyph (line 4716) | static bool ImGui_ImplStbTrueType_FontBakedLoadGlyph(ImFontAtlas* atla...
function ImFontLoader (line 4804) | const ImFontLoader* ImFontAtlasGetFontLoaderForStbTruetype()
function ImWchar (line 4835) | const ImWchar* ImFontAtlas::GetGlyphRangesDefault()
function ImWchar (line 4846) | const ImWchar* ImFontAtlas::GetGlyphRangesGreek()
function ImWchar (line 4857) | const ImWchar* ImFontAtlas::GetGlyphRangesKorean()
function ImWchar (line 4870) | const ImWchar* ImFontAtlas::GetGlyphRangesChineseFull()
function UnpackAccumulativeOffsetsIntoRanges (line 4886) | static void UnpackAccumulativeOffsetsIntoRanges(int base_codepoint, co...
function ImWchar (line 4896) | const ImWchar* ImFontAtlas::GetGlyphRangesChineseSimplifiedCommon()
function ImWchar (line 4964) | const ImWchar* ImFontAtlas::GetGlyphRangesJapanese()
function ImWchar (line 5054) | const ImWchar* ImFontAtlas::GetGlyphRangesCyrillic()
function ImWchar (line 5067) | const ImWchar* ImFontAtlas::GetGlyphRangesThai()
function ImWchar (line 5079) | const ImWchar* ImFontAtlas::GetGlyphRangesVietnamese()
function ImFontGlyph (line 5196) | ImFontGlyph* ImFontAtlasBakedAddFontGlyph(ImFontAtlas* atlas, ImFontBa...
function ImFontAtlasBakedAddFontGlyphAdvancedX (line 5250) | void ImFontAtlasBakedAddFontGlyphAdvancedX(ImFontAtlas* atlas, ImFontB...
function ImFontAtlasBakedSetFontGlyphBitmap (line 5273) | void ImFontAtlasBakedSetFontGlyphBitmap(ImFontAtlas* atlas, ImFontBake...
function ImFontGlyph (line 5289) | ImFontGlyph* ImFontBaked::FindGlyph(ImWchar c)
function ImFontGlyph (line 5304) | ImFontGlyph* ImFontBaked::FindGlyphNoFallback(ImWchar c)
function IM_MSVC_RUNTIME_CHECKS_OFF (line 5348) | IM_MSVC_RUNTIME_CHECKS_OFF
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 5360) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function ImFontBaked (line 5372) | ImFontBaked* ImFont::GetFontBaked(float size, float density)
function ImFontBaked (line 5395) | ImFontBaked* ImFontAtlasBakedGetOrAdd(ImFontAtlas* atlas, ImFont* font, ...
function ImTextClassifierClear (line 5441) | void ImTextClassifierClear(ImU32* bits, unsigned int codepoint_min, unsi...
function ImTextClassifierSetCharClass (line 5447) | void ImTextClassifierSetCharClass(ImU32* bits, unsigned int codepoint_mi...
function ImTextClassifierSetCharClassFromStr (line 5456) | void ImTextClassifierSetCharClassFromStr(ImU32* bits, unsigned int codep...
function ImTextInitClassifiers (line 5473) | void ImTextInitClassifiers()
function ImVec2 (line 5613) | ImVec2 ImFontCalcTextSizeEx(ImFont* font, float size, float max_width, f...
function ImVec2 (line 5704) | ImVec2 ImFont::CalcTextSizeA(float size, float max_width, float wrap_wid...
function ImAcos01 (line 6046) | static inline float ImAcos01(float x)
function ImDrawFlags (line 6131) | ImDrawFlags ImGui::CalcRoundingFlagsForRectInRect(const ImRect& r_in, co...
function stb_decompress_length (line 6192) | static unsigned int stb_decompress_length(const unsigned char *input)
function stb__match (line 6200) | static void stb__match(const unsigned char *data, unsigned int length)
function stb__lit (line 6209) | static void stb__lit(const unsigned char *data, unsigned int length)
function stb_adler32 (line 6239) | static unsigned int stb_adler32(unsigned int adler32, unsigned char *buf...
function stb_decompress (line 6270) | static unsigned int stb_decompress(unsigned char *output, const unsigned...
FILE: Source/ThirdParty/ImGuiLibrary/imgui_internal.h
type ImBitVector (line 138) | struct ImBitVector
type ImRect (line 139) | struct ImRect
type ImGuiTextIndex (line 140) | struct ImGuiTextIndex
type ImDrawDataBuilder (line 143) | struct ImDrawDataBuilder
type ImDrawListSharedData (line 144) | struct ImDrawListSharedData
type ImFontAtlasBuilder (line 145) | struct ImFontAtlasBuilder
type ImFontAtlasPostProcessData (line 146) | struct ImFontAtlasPostProcessData
type ImFontAtlasRectEntry (line 147) | struct ImFontAtlasRectEntry
type ImGuiBoxSelectState (line 150) | struct ImGuiBoxSelectState
type ImGuiColorMod (line 151) | struct ImGuiColorMod
type ImGuiContext (line 152) | struct ImGuiContext
type ImGuiContextHook (line 153) | struct ImGuiContextHook
type ImGuiDataTypeInfo (line 154) | struct ImGuiDataTypeInfo
type ImGuiDeactivatedItemData (line 155) | struct ImGuiDeactivatedItemData
type ImGuiDockContext (line 156) | struct ImGuiDockContext
type ImGuiDockRequest (line 157) | struct ImGuiDockRequest
type ImGuiDockNode (line 158) | struct ImGuiDockNode
type ImGuiDockNodeSettings (line 159) | struct ImGuiDockNodeSettings
type ImGuiErrorRecoveryState (line 160) | struct ImGuiErrorRecoveryState
type ImGuiGroupData (line 161) | struct ImGuiGroupData
type ImGuiInputTextState (line 162) | struct ImGuiInputTextState
type ImGuiInputTextDeactivateData (line 163) | struct ImGuiInputTextDeactivateData
type ImGuiLastItemData (line 164) | struct ImGuiLastItemData
type ImGuiLocEntry (line 165) | struct ImGuiLocEntry
type ImGuiMenuColumns (line 166) | struct ImGuiMenuColumns
type ImGuiMultiSelectState (line 167) | struct ImGuiMultiSelectState
type ImGuiMultiSelectTempData (line 168) | struct ImGuiMultiSelectTempData
type ImGuiNavItemData (line 169) | struct ImGuiNavItemData
type ImGuiMetricsConfig (line 170) | struct ImGuiMetricsConfig
type ImGuiNextWindowData (line 171) | struct ImGuiNextWindowData
type ImGuiNextItemData (line 172) | struct ImGuiNextItemData
type ImGuiOldColumnData (line 173) | struct ImGuiOldColumnData
type ImGuiOldColumns (line 174) | struct ImGuiOldColumns
type ImGuiPopupData (line 175) | struct ImGuiPopupData
type ImGuiSettingsHandler (line 176) | struct ImGuiSettingsHandler
type ImGuiStyleMod (line 177) | struct ImGuiStyleMod
type ImGuiStyleVarInfo (line 178) | struct ImGuiStyleVarInfo
type ImGuiTabBar (line 179) | struct ImGuiTabBar
type ImGuiTabItem (line 180) | struct ImGuiTabItem
type ImGuiTable (line 181) | struct ImGuiTable
type ImGuiTableHeaderData (line 182) | struct ImGuiTableHeaderData
type ImGuiTableColumn (line 183) | struct ImGuiTableColumn
type ImGuiTableInstanceData (line 184) | struct ImGuiTableInstanceData
type ImGuiTableTempData (line 185) | struct ImGuiTableTempData
type ImGuiTableSettings (line 186) | struct ImGuiTableSettings
type ImGuiTableColumnsSettings (line 187) | struct ImGuiTableColumnsSettings
type ImGuiTreeNodeStackData (line 188) | struct ImGuiTreeNodeStackData
type ImGuiTypingSelectState (line 189) | struct ImGuiTypingSelectState
type ImGuiTypingSelectRequest (line 190) | struct ImGuiTypingSelectRequest
type ImGuiWindow (line 191) | struct ImGuiWindow
type ImGuiWindowDockStyle (line 192) | struct ImGuiWindowDockStyle
type ImGuiWindowTempData (line 193) | struct ImGuiWindowTempData
type ImGuiWindowSettings (line 194) | struct ImGuiWindowSettings
type ImGuiLocKey (line 198) | enum ImGuiLocKey : int
type ImGuiDataAuthority (line 199) | typedef int ImGuiDataAuthority;
type ImGuiLayoutType (line 200) | typedef int ImGuiLayoutType;
type ImDrawTextFlags (line 203) | typedef int ImDrawTextFlags;
type ImGuiActivateFlags (line 204) | typedef int ImGuiActivateFlags;
type ImGuiDebugLogFlags (line 205) | typedef int ImGuiDebugLogFlags;
type ImGuiFocusRequestFlags (line 206) | typedef int ImGuiFocusRequestFlags;
type ImGuiItemStatusFlags (line 207) | typedef int ImGuiItemStatusFlags;
type ImGuiOldColumnFlags (line 208) | typedef int ImGuiOldColumnFlags;
type ImGuiLogFlags (line 209) | typedef int ImGuiLogFlags;
type ImGuiNavRenderCursorFlags (line 210) | typedef int ImGuiNavRenderCursorFlags;
type ImGuiNavMoveFlags (line 211) | typedef int ImGuiNavMoveFlags;
type ImGuiNextItemDataFlags (line 212) | typedef int ImGuiNextItemDataFlags;
type ImGuiNextWindowDataFlags (line 213) | typedef int ImGuiNextWindowDataFlags;
type ImGuiScrollFlags (line 214) | typedef int ImGuiScrollFlags;
type ImGuiSeparatorFlags (line 215) | typedef int ImGuiSeparatorFlags;
type ImGuiTextFlags (line 216) | typedef int ImGuiTextFlags;
type ImGuiTooltipFlags (line 217) | typedef int ImGuiTooltipFlags;
type ImGuiTypingSelectFlags (line 218) | typedef int ImGuiTypingSelectFlags;
type ImGuiWindowBgClickFlags (line 219) | typedef int ImGuiWindowBgClickFlags;
type ImGuiWindowRefreshFlags (line 220) | typedef int ImGuiWindowRefreshFlags;
type ImS16 (line 223) | typedef ImS16 ImGuiTableColumnIdx;
type ImU16 (line 224) | typedef ImU16 ImGuiTableDrawChannelIdx;
function ImQsort (line 383) | inline void ImQsort(void* base, size_t count, size_t size_of...
function ImIsPowerOfTwo (line 390) | inline bool ImIsPowerOfTwo(int v) { return v !...
function ImIsPowerOfTwo (line 391) | inline bool ImIsPowerOfTwo(ImU64 v) { return v !...
function ImUpperPowerOfTwo (line 392) | inline int ImUpperPowerOfTwo(int v) { v--; v |= ...
function ImCountSetBits (line 393) | inline unsigned int ImCountSetBits(unsigned int v) { unsigned i...
function IM_MSVC_RUNTIME_CHECKS_OFF (line 411) | IM_MSVC_RUNTIME_CHECKS_OFF
function ImCharIsBlankA (line 413) | inline bool ImCharIsBlankA(char c) { return c == ' ...
function ImCharIsBlankW (line 414) | inline bool ImCharIsBlankW(unsigned int c) { return c == ' ...
function ImCharIsXdigitA (line 415) | inline bool ImCharIsXdigitA(char c) { return (c >= '...
type ImDrawTextFlags_ (line 443) | enum ImDrawTextFlags_
type ImWcharClass (line 455) | enum ImWcharClass
function ImFileHandle (line 468) | inline ImFileHandle ImFileOpen(const char*, const char*) ...
function ImFileClose (line 469) | inline bool ImFileClose(ImFileHandle) ...
function ImU64 (line 470) | inline ImU64 ImFileGetSize(ImFileHandle) ...
function ImU64 (line 471) | inline ImU64 ImFileRead(void*, ImU64, ImU64, ImFileHandle...
function ImU64 (line 472) | inline ImU64 ImFileWrite(const void*, ImU64, ImU64, ImFil...
type FILE (line 475) | typedef FILE* ImFileHandle;
function ImPow (line 499) | inline float ImPow(float x, float y) { return powf(x, y); }
function ImPow (line 500) | inline double ImPow(double x, double y) { return pow(x, y); }
function ImLog (line 501) | inline float ImLog(float x) { return logf(x); }
function ImLog (line 502) | inline double ImLog(double x) { return log(x); }
function ImAbs (line 503) | inline int ImAbs(int x) { return x < 0 ? -x : x; }
function ImAbs (line 504) | inline float ImAbs(float x) { return fabsf(x); }
function ImAbs (line 505) | inline double ImAbs(double x) { return fabs(x); }
function ImSign (line 506) | inline float ImSign(float x) { return (x < 0.0f) ? -1.0f : (...
function ImSign (line 507) | inline double ImSign(double x) { return (x < 0.0) ? -1.0 : (x ...
function ImRsqrt (line 509) | inline float ImRsqrt(float x) { return _mm_cvtss_f32(_mm_rsqr...
function ImRsqrt (line 511) | inline float ImRsqrt(float x) { return 1.0f / sqrtf(x); }
function ImRsqrt (line 513) | inline double ImRsqrt(double x) { return 1.0 / sqrt(x); }
function ImVec2 (line 525) | inline ImVec2 ImMin(const ImVec2& lhs, const ImVec2& rhs) ...
function ImVec2 (line 526) | inline ImVec2 ImMax(const ImVec2& lhs, const ImVec2& rhs) ...
function ImVec2 (line 527) | inline ImVec2 ImClamp(const ImVec2& v, const ImVec2&mn, const ImVec2&mx)...
function ImVec2 (line 528) | inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t) ...
function ImVec2 (line 529) | inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t) ...
function ImVec4 (line 530) | inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t) ...
function ImSaturate (line 531) | inline float ImSaturate(float f) ...
function ImLengthSqr (line 532) | inline float ImLengthSqr(const ImVec2& lhs) ...
function ImLengthSqr (line 533) | inline float ImLengthSqr(const ImVec4& lhs) ...
function ImInvLength (line 534) | inline float ImInvLength(const ImVec2& lhs, float fail_value) ...
function ImTrunc (line 535) | inline float ImTrunc(float f) ...
function ImVec2 (line 536) | inline ImVec2 ImTrunc(const ImVec2& v) ...
function ImFloor (line 537) | inline float ImFloor(float f) ...
function ImVec2 (line 538) | inline ImVec2 ImFloor(const ImVec2& v) ...
function ImTrunc64 (line 539) | inline float ImTrunc64(float f) ...
function ImRound64 (line 540) | inline float ImRound64(float f) ...
function ImModPositive (line 541) | inline int ImModPositive(int a, int b) ...
function ImDot (line 542) | inline float ImDot(const ImVec2& a, const ImVec2& b) ...
function ImVec2 (line 543) | inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a) ...
function ImLinearSweep (line 544) | inline float ImLinearSweep(float current, float target, float speed) ...
function ImLinearRemapClamp (line 545) | inline float ImLinearRemapClamp(float s0, float s1, float d0, float d1,...
function ImVec2 (line 546) | inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs) ...
function ImIsFloatAboveGuaranteedIntegerPrecision (line 547) | inline bool ImIsFloatAboveGuaranteedIntegerPrecision(float f) ...
function ImExponentialMovingAverage (line 548) | inline float ImExponentialMovingAverage(float avg, float sample, int n)...
function ImTriangleArea (line 560) | inline float ImTriangleArea(const ImVec2& a, const ImVec2& b, co...
function ImTriangleIsClockwise (line 561) | inline bool ImTriangleIsClockwise(const ImVec2& a, const ImVec2...
function IM_MSVC_RUNTIME_CHECKS_OFF (line 565) | IM_MSVC_RUNTIME_CHECKS_OFF
function ImBitArrayGetStorageSizeInBytes (line 632) | inline size_t ImBitArrayGetStorageSizeInBytes(int bitcount) { return...
function ImBitArrayClearAllBits (line 633) | inline void ImBitArrayClearAllBits(ImU32* arr, int bitcount){ memset...
function ImBitArrayTestBit (line 634) | inline bool ImBitArrayTestBit(const ImU32* arr, int n) { ImU32 ...
function ImBitArrayClearBit (line 635) | inline void ImBitArrayClearBit(ImU32* arr, int n) { ImU32 ...
function ImBitArraySetBit (line 636) | inline void ImBitArraySetBit(ImU32* arr, int n) { ImU32 ...
function ImBitArraySetBitRange (line 637) | inline void ImBitArraySetBitRange(ImU32* arr, int n, int n2) // Work...
type ImU32 (line 650) | typedef ImU32* ImBitArrayPtr;
function ClearAllBits (line 659) | void ClearAllBits() { memset(Data, 0, sizeof(Dat...
function SetAllBits (line 660) | void SetAllBits() { memset(Data, 255, sizeof(D...
function TestBit (line 661) | bool TestBit(int n) const { n += OFFSET; IM_ASSERT(n >...
function SetBit (line 662) | void SetBit(int n) { n += OFFSET; IM_ASSERT(n >...
function ClearBit (line 663) | void ClearBit(int n) { n += OFFSET; IM_ASSERT(n >...
function SetBitRange (line 664) | void SetBitRange(int n, int n2) { n += OFFSET; n2 += OFFSET;...
function const (line 665) | bool operator[](int n) const { n += OFFSET; IM_ASSERT(n >...
function ImBitVector (line 670) | struct IMGUI_API ImBitVector
function IM_MSVC_RUNTIME_CHECKS_RESTORE (line 679) | IM_MSVC_RUNTIME_CHECKS_RESTORE
function set (line 694) | inline void set(T* data, int size) { Data = data; DataEnd =...
function set (line 695) | inline void set(T* data, T* data_end) { Data = data; DataEnd =...
function T (line 698) | inline T& operator[](int i) { T* p = Data + i; IM_AS...
function T (line 699) | inline const T& operator[](int i) const { const T* p = Data + i;...
function T (line 701) | inline T* begin() { return Data; }
function T (line 702) | inline const T* begin() const { return Data; }
function T (line 703) | inline T* end() { return DataEnd; }
function T (line 704) | inline const T* end() const { return DataEnd; }
function index_from_ptr (line 707) | inline int index_from_ptr(const T* it) const { IM_ASSERT(it >= Data &...
function GetArenaSizeInBytes (line 724) | inline int GetArenaSizeInBytes() { return CurrOff; }
function SetArenaBasePtr (line 725) | inline void SetArenaBasePtr(void* base_ptr) { BasePtr = (char*)base_...
function GetSpan (line 729) | void GetSpan(int n, ImSpan<T>* span) { span->set((T*)GetSpanPtrBegin...
function clear (line 746) | inline void clear() { Size = Capacity = 0; B...
function resize (line 747) | inline void resize(int new_size) { if (new_size > Capacit...
function reserve (line 748) | inline void reserve(int new_cap)
function T (line 760) | inline T& operator[](int i) { IM_ASSERT(i >= 0 && i ...
function T (line 761) | inline const T& operator[](int i) const { IM_ASSERT(i >= 0 && i ...
function T (line 762) | inline T* push_back(const T& v) { int i = Size; IM_ASSER...
type ImPoolIdx (line 768) | typedef int ImPoolIdx;
function T (line 779) | T* GetByKey(ImGuiID key) { int idx = Map.GetInt(k...
function T (line 780) | T* GetByIndex(ImPoolIdx n) { return &Buf[n]; }
function ImPoolIdx (line 781) | ImPoolIdx GetIndex(const T* p) const { IM_ASSERT(p >= Buf.Dat...
function T (line 782) | T* GetOrAddByKey(ImGuiID key) { int* p_idx = Map.GetIn...
function Contains (line 783) | bool Contains(const T* p) const { return (p >= Buf.Data ...
function Clear (line 784) | void Clear() { for (int n = 0; n < Ma...
function T (line 785) | T* Add() { int idx = FreeIdx; if ...
function Remove (line 786) | void Remove(ImGuiID key, const T* p) { Remove(key, GetIndex(p...
function Remove (line 787) | void Remove(ImGuiID key, ImPoolIdx idx) { Buf[idx].~T(); *(int*)...
function Reserve (line 788) | void Reserve(int capacity) { Buf.reserve(capacity);...
function T (line 795) | T* TryGetMapData(ImPoolIdx n) { int idx = Map.Data[n]....
function clear (line 808) | void clear() { Buf.clear(); }
function T (line 811) | T* alloc_chunk(size_t sz) { size_t HDR_SZ = 4; sz = IM_MEMALIG...
function T (line 812) | T* begin() { size_t HDR_SZ = 4; if (!Buf.Data) ...
function T (line 813) | T* next_chunk(T* p) { size_t HDR_SZ = 4; IM_ASSERT(p >= ...
function chunk_size (line 814) | int chunk_size(const T* p) { return ((const int*)p)[-1]; }
function T (line 815) | T* end() { return (T*)(void*)(Buf.Data + Buf....
function offset_from_ptr (line 816) | int offset_from_ptr(const T* p) { IM_ASSERT(p >= begin() && p < end(...
function T (line 817) | T* ptr_from_offset(int off) { IM_ASSERT(off >= 4 && off < Buf.Si...
function swap (line 818) | void swap(ImChunkStream<T>& rhs) { rhs.Buf.swap(Buf); }
function size (line 823) | struct ImGuiTextIndex
function ImDrawListSharedData (line 871) | struct IMGUI_API ImDrawListSharedData
type ImDrawDataBuilder (line 898) | struct ImDrawDataBuilder
type ImFontStackData (line 906) | struct ImFontStackData
type ImGuiStyleVarInfo (line 917) | struct ImGuiStyleVarInfo
type ImGuiColorMod (line 926) | struct ImGuiColorMod
function ImGuiStyleMod (line 933) | struct ImGuiStyleMod
type ImGuiDataTypeStorage (line 946) | struct ImGuiDataTypeStorage
type ImGuiDataTypeInfo (line 952) | struct ImGuiDataTypeInfo
type ImGuiDataTypePrivate_ (line 961) | enum ImGuiDataTypePrivate_
type ImGuiItemFlagsPrivate_ (line 974) | enum ImGuiItemFlagsPrivate_
type ImGuiItemStatusFlags_ (line 998) | enum ImGuiItemStatusFlags_
type ImGuiHoveredFlagsPrivate_ (line 1025) | enum ImGuiHoveredFlagsPrivate_
type ImGuiInputTextFlagsPrivate_ (line 1033) | enum ImGuiInputTextFlagsPrivate_
type ImGuiButtonFlagsPrivate_ (line 1042) | enum ImGuiButtonFlagsPrivate_
type ImGuiComboFlagsPrivate_ (line 1069) | enum ImGuiComboFlagsPrivate_
type ImGuiSliderFlagsPrivate_ (line 1075) | enum ImGuiSliderFlagsPrivate_
type ImGuiSelectableFlagsPrivate_ (line 1082) | enum ImGuiSelectableFlagsPrivate_
type ImGuiTreeNodeFlagsPrivate_ (line 1095) | enum ImGuiTreeNodeFlagsPrivate_
type ImGuiSeparatorFlags_ (line 1104) | enum ImGuiSeparatorFlags_
type ImGuiFocusRequestFlags_ (line 1115) | enum ImGuiFocusRequestFlags_
type ImGuiTextFlags_ (line 1122) | enum ImGuiTextFlags_
type ImGuiTooltipFlags_ (line 1128) | enum ImGuiTooltipFlags_
type ImGuiLayoutType_ (line 1136) | enum ImGuiLayoutType_
type ImGuiLogFlags_ (line 1143) | enum ImGuiLogFlags_
type ImGuiAxis (line 1155) | enum ImGuiAxis
type ImGuiPlotType (line 1162) | enum ImGuiPlotType
function ImGuiComboPreviewData (line 1169) | struct IMGUI_API ImGuiComboPreviewData
function ImGuiGroupData (line 1182) | struct IMGUI_API ImGuiGroupData
function ImGuiMenuColumns (line 1201) | struct IMGUI_API ImGuiMenuColumns
function ImGuiInputTextDeactivatedState (line 1219) | struct IMGUI_API ImGuiInputTextDeactivatedState
function namespace (line 1236) | namespace ImStb { struct STB_TexteditState; }
type ImStb (line 1237) | typedef ImStb::STB_TexteditState ImStbTexteditState;
function ImGuiInputTextState (line 1241) | struct IMGUI_API ImGuiInputTextState
type ImGuiDeactivatedItemData (line 1470) | struct ImGuiDeactivatedItemData
type ImGuiPopupPositionPolicy (line 1482) | enum ImGuiPopupPositionPolicy
type ImGuiPopupData (line 1490) | struct ImGuiPopupData
type ImGuiInputEventType (line 1533) | enum ImGuiInputEventType
type ImGuiInputSource (line 1546) | enum ImGuiInputSource : int
type ImGuiInputEventMousePos (line 1557) | struct ImGuiInputEventMousePos { float PosX, PosY; ImGuiMouseSource...
type ImGuiInputEventMouseWheel (line 1558) | struct ImGuiInputEventMouseWheel { float WheelX, WheelY; ImGuiMouseSo...
type ImGuiInputEventMouseButton (line 1559) | struct ImGuiInputEventMouseButton { int Button; bool Down; ImGuiMouseS...
type ImGuiInputEventMouseViewport (line 1560) | struct ImGuiInputEventMouseViewport { ImGuiID HoveredViewportID; }
type ImGuiInputEventKey (line 1561) | struct ImGuiInputEventKey { ImGuiKey Key; bool Down; float Ana...
type ImGuiInputEventText (line 1562) | struct ImGuiInputEventText { unsigned int Char; }
type ImGuiInputEventAppFocused (line 1563) | struct ImGuiInputEventAppFocused { bool Focused; }
type ImGuiInputEvent (line 1565) | struct ImGuiInputEvent
type ImS16 (line 1590) | typedef ImS16 ImGuiKeyRoutingIndex;
function Clear (line 1607) | struct ImGuiKeyRoutingTable
type ImGuiKeyOwnerData (line 1619) | struct ImGuiKeyOwnerData
type ImGuiInputFlagsPrivate_ (line 1632) | enum ImGuiInputFlagsPrivate_
function FromPositions (line 1676) | struct ImGuiListClipperRange
function Reset (line 1689) | struct ImGuiListClipperData
type ImGuiActivateFlags_ (line 1705) | enum ImGuiActivateFlags_
type ImGuiScrollFlags_ (line 1717) | enum ImGuiScrollFlags_
type ImGuiNavRenderCursorFlags_ (line 1731) | enum ImGuiNavRenderCursorFlags_
type ImGuiNavMoveFlags_ (line 1746) | enum ImGuiNavMoveFlags_
type ImGuiNavLayer (line 1768) | enum ImGuiNavLayer
function Clear (line 1776) | struct ImGuiNavItemData
type ImGuiFocusScopeData (line 1793) | struct ImGuiFocusScopeData
type ImGuiTypingSelectFlags_ (line 1804) | enum ImGuiTypingSelectFlags_
function ImGuiTypingSelectRequest (line 1812) | struct IMGUI_API ImGuiTypingSelectRequest
function ImGuiTypingSelectState (line 1823) | struct IMGUI_API ImGuiTypingSelectState
type ImGuiOldColumnFlags_ (line 1841) | enum ImGuiOldColumnFlags_
type ImGuiOldColumnData (line 1861) | struct ImGuiOldColumnData
type ImGuiOldColumns (line 1871) | struct ImGuiOldColumns
type ImGuiBoxSelectState (line 1896) | struct ImGuiBoxSelectState
function ImGuiMultiSelectTempData (line 1928) | struct IMGUI_API ImGuiMultiSelectTempData
function ImGuiMultiSelectState (line 1953) | struct IMGUI_API ImGuiMultiSelectState
type ImGuiDockNodeFlagsPrivate_ (line 1977) | enum ImGuiDockNodeFlagsPrivate_
type ImGuiDataAuthority_ (line 2009) | enum ImGuiDataAuthority_
type ImGuiDockNodeState (line 2016) | enum ImGuiDockNodeState
function ImGuiDockNode (line 2025) | struct IMGUI_API ImGuiDockNode
type ImGuiWindowDockStyleCol (line 2092) | enum ImGuiWindowDockStyleCol
type ImGuiWindowDockStyle (line 2107) | struct ImGuiWindowDockStyle
type ImGuiDockContext (line 2112) | struct ImGuiDockContext
function ImGuiViewport (line 2129) | struct ImGuiViewportP : public ImGuiViewport
type ImGuiWindowSettings (line 2181) | struct ImGuiWindowSettings
type ImGuiSettingsHandler (line 2200) | struct ImGuiSettingsHandler
type ImGuiLocKey (line 2220) | enum ImGuiLocKey : int
type ImGuiLocEntry (line 2238) | struct ImGuiLocEntry
type ImGuiDebugLogFlags_ (line 2267) | enum ImGuiDebugLogFlags_
type ImGuiDebugAllocEntry (line 2290) | struct ImGuiDebugAllocEntry
type ImGuiDebugAllocInfo (line 2297) | struct ImGuiDebugAllocInfo
type ImGuiMetricsConfig (line 2307) | struct ImGuiMetricsConfig
type ImGuiStackLevelInfo (line 2326) | struct ImGuiStackLevelInfo
type ImGuiTabBarFlagsPrivate_ (line 3009) | enum ImGuiTabBarFlagsPrivate_
type ImGuiTabItemFlagsPrivate_ (line 3017) | enum ImGuiTabItemFlagsPrivate_
function ImGuiTabBar (line 3047) | struct IMGUI_API ImGuiTabBar
type ImGuiTableCellData (line 3161) | struct ImGuiTableCellData
type ImGuiTableHeaderData (line 3170) | struct ImGuiTableHeaderData
type ImGuiTableInstanceData (line 3180) | struct ImGuiTableInstanceData
function ImGuiTable (line 3193) | struct IMGUI_API ImGuiTable
function ImGuiTableTempData (line 3318) | struct IMGUI_API ImGuiTableTempData
type ImGuiTableSettings (line 3366) | struct ImGuiTableSettings
function namespace (line 3384) | namespace ImGui
function IsNamedKey (line 3607) | inline bool IsNamedKey(ImGuiKey key) { re...
function IsNamedKeyOrMod (line 3608) | inline bool IsNamedKeyOrMod(ImGuiKey key) { re...
function IsLegacyKey (line 3609) | inline bool IsLegacyKey(ImGuiKey key) { re...
function IsKeyboardKey (line 3610) | inline bool IsKeyboardKey(ImGuiKey key) { re...
function IsGamepadKey (line 3611) | inline bool IsGamepadKey(ImGuiKey key) { re...
function IsMouseKey (line 3612) | inline bool IsMouseKey(ImGuiKey key) { re...
function IsAliasKey (line 3613) | inline bool IsAliasKey(ImGuiKey key) { re...
function IsLRModKey (line 3614) | inline bool IsLRModKey(ImGuiKey key) { re...
function ImGuiKey (line 3616) | inline ImGuiKey ConvertSingleModFlagToKey(ImGuiKey key)
function ImGuiKeyData (line 3626) | inline ImGuiKeyData* GetKeyData(ImGuiKey key) ...
function ImGuiKey (line 3628) | inline ImGuiKey MouseButtonToKey(ImGuiMouseButton button) ...
function IsActiveIdUsingNavDir (line 3636) | inline bool IsActiveIdUsingNavDir(ImGuiDir dir) ...
function ImGuiKeyOwnerData (line 3654) | inline ImGuiKeyOwnerData* GetKeyOwnerData(ImGuiContext* ctx, ImGuiKey ke...
function ImGuiDockNode (line 3710) | inline ImGuiDockNode* DockNodeGetRootNode(ImGuiDockNode* node) ...
function DockNodeIsInHierarchyOf (line 3711) | inline bool DockNodeIsInHierarchyOf(ImGuiDockNode* node, ImG...
function DockNodeGetDepth (line 3712) | inline int DockNodeGetDepth(const ImGuiDockNode* node) ...
function ImGuiID (line 3713) | inline ImGuiID DockNodeGetWindowMenuButtonId(const ImGuiDockNod...
function ImGuiDockNode (line 3714) | inline ImGuiDockNode* GetWindowDockNode() ...
function ImGuiDockNode (line 3732) | inline ImGuiDockNode* DockBuilderGetCentralNode(ImGuiID node_id) ...
function ImGuiID (line 3755) | inline ImGuiID GetCurrentFocusScope() { ImGuiContext& g = *GImG...
function ImGuiBoxSelectState (line 3783) | inline ImGuiBoxSelectState* GetBoxSelectState(ImGuiID id) { ImGuiC...
function ImGuiMultiSelectState (line 3784) | inline ImGuiMultiSelectState* GetMultiSelectState(ImGuiID id) { ImGuiC...
function ImGuiTable (line 3812) | inline ImGuiTable* GetCurrentTable() { ImGuiContext& g = *GImGui; r...
function ImGuiTableInstanceData (line 3825) | inline ImGuiTableInstanceData* TableGetInstanceData(ImGuiTable* table, ...
function ImGuiID (line 3826) | inline ImGuiID TableGetInstanceID(ImGuiTable* table, in...
function ImGuiTabBar (line 3859) | inline ImGuiTabBar* GetCurrentTabBar() { ImGuiContext& g = *GImGui; ...
function TabBarGetTabOrder (line 3867) | inline int TabBarGetTabOrder(ImGuiTabBar* tab_bar, ImGuiTab...
function RenderNavHighlight (line 3898) | inline void RenderNavHighlight(const ImRect& bb, ImGuiID id,...
function TempInputIsActive (line 3976) | inline bool TempInputIsActive(ImGuiID id) { ImGuiConte...
function ImGuiInputTextState (line 3977) | inline ImGuiInputTextState* GetInputTextState(ImGuiID id) { ImGuiConte...
function IsItemActiveAsInputText (line 3979) | inline bool IsItemActiveAsInputText() { ImGuiContext& g = *G...
function SetNextItemColorMarker (line 3985) | inline void SetNextItemColorMarker(ImU32 col) { ImGuiContext...
type ImFontLoader (line 4073) | struct ImFontLoader
type ImFontLoader (line 4096) | typedef ImFontLoader ImFontBuilderIO;
function ImFontAtlasRectId_GetIndex (line 4115) | inline int ImFontAtlasRectId_GetIndex(ImFontAtlasRectId id...
function ImFontAtlasRectId_GetGeneration (line 4116) | inline unsigned int ImFontAtlasRectId_GetGeneration(ImFontAtlasRect...
function ImFontAtlasRectId (line 4117) | inline ImFontAtlasRectId ImFontAtlasRectId_Make(int index_idx, int gen_i...
type ImFontAtlasRectEntry (line 4124) | struct ImFontAtlasRectEntry
type ImFontAtlasPostProcessData (line 4132) | struct ImFontAtlasPostProcessData
function namespace (line 4150) | namespace IMGUI_STB_NAMESPACE { struct stbrp_node; }
type IMGUI_STB_NAMESPACE (line 4151) | typedef IMGUI_STB_NAMESPACE::stbrp_node stbrp_node_im;
type stbrp_node (line 4153) | struct stbrp_node
type stbrp_node (line 4154) | typedef stbrp_node stbrp_node_im;
type stbrp_context_opaque (line 4156) | struct stbrp_context_opaque { char data[80]; }
type ImFontAtlasBuilder (line 4159) | struct ImFontAtlasBuilder
FILE: Source/ThirdParty/ImGuiLibrary/imgui_tables.cpp
function ImGuiTableFlags (line 272) | inline ImGuiTableFlags TableFixFlags(ImGuiTableFlags flags, ImGuiWindow*...
function ImGuiTable (line 305) | ImGuiTable* ImGui::TableFindByID(ImGuiID id)
function TableSetupColumnFlags (line 759) | static void TableSetupColumnFlags(ImGuiTable* table, ImGuiTableColumn* c...
function TableInitColumnDefaults (line 1585) | static void TableInitColumnDefaults(ImGuiTable* table, ImGuiTableColumn*...
function ImGuiTableColumnFlags (line 1754) | ImGuiTableColumnFlags ImGui::TableGetColumnFlags(int column_n)
function ImRect (line 1773) | ImRect ImGui::TableGetCellBgRect(const ImGuiTable* table, int column_n)
function ImGuiID (line 1788) | ImGuiID ImGui::TableGetColumnResizeID(ImGuiTable* table, int column_n, i...
type MergeGroup (line 2599) | struct MergeGroup
function ImU32 (line 2760) | static ImU32 TableGetColumnBorderCol(ImGuiTable* table, int order_n, int...
function ImGuiTableSortSpecs (line 2878) | ImGuiTableSortSpecs* ImGui::TableGetSortSpecs()
function ImGuiSortDirection (line 2893) | static inline ImGuiSortDirection TableGetColumnAvailSortDirection(ImGuiT...
function ImGuiSortDirection (line 2912) | ImGuiSortDirection ImGui::TableGetColumnNextSortDirection(ImGuiTableColu...
function TableSettingsInit (line 3617) | static void TableSettingsInit(ImGuiTableSettings* settings, ImGuiID id, ...
function TableSettingsCalcChunkSize (line 3629) | static size_t TableSettingsCalcChunkSize(int columns_count)
function ImGuiTableSettings (line 3634) | ImGuiTableSettings* ImGui::TableSettingsCreate(ImGuiID id, int columns_c...
function ImGuiTableSettings (line 3643) | ImGuiTableSettings* ImGui::TableSettingsFindByID(ImGuiID id)
function ImGuiTableSettings (line 3654) | ImGuiTableSettings* ImGui::TableGetBoundSettings(ImGuiTable* table)
type ImGuiTableFixDisplayOrderColumnData (line 3797) | struct ImGuiTableFixDisplayOrderColumnData
function TableSettingsHandler_ClearAll (line 3829) | static void TableSettingsHandler_ClearAll(ImGuiContext* ctx, ImGuiSettin...
function TableSettingsHandler_ApplyAll (line 3839) | static void TableSettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettin...
function TableSettingsHandler_ReadLine (line 3869) | static void TableSettingsHandler_ReadLine(ImGuiContext*, ImGuiSettingsHa...
function TableSettingsHandler_WriteAll (line 3895) | static void TableSettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettin...
function GetDraggedColumnOffset (line 4187) | static float GetDraggedColumnOffset(ImGuiOldColumns* columns, int column...
function GetColumnWidthEx (line 4220) | static float GetColumnWidthEx(ImGuiOldColumns* columns, int column_index...
function ImGuiOldColumns (line 4316) | ImGuiOldColumns* ImGui::FindOrCreateColumns(ImGuiWindow* window, ImGuiID...
function ImGuiID (line 4329) | ImGuiID ImGui::GetColumnsID(const char* str_id, int columns_count)
FILE: Source/ThirdParty/ImGuiLibrary/imgui_widgets.cpp
function ImGuiID (line 962) | ImGuiID ImGui::GetWindowScrollbarID(ImGuiWindow* window, ImGuiAxis axis)
function ImRect (line 968) | ImRect ImGui::GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis)
function CalcMaxPopupHeightFromItemCount (line 1904) | static float CalcMaxPopupHeightFromItemCount(int items_count)
type ImGuiGetNameFromIndexOldToNewCallbackData (line 2214) | struct ImGuiGetNameFromIndexOldToNewCallbackData { void* UserData; bool ...
function ImGuiDataTypeInfo (line 2276) | const ImGuiDataTypeInfo* ImGui::DataTypeGetInfo(ImGuiDataType data_type)
function DataTypeCompareT (line 2407) | static int DataTypeCompareT(const T* lhs, const T* rhs)
function DataTypeClampT (line 2435) | static bool DataTypeClampT(T* v, const T* v_min, const T* v_max)
function GetMinimumStepAtDecimalPrecision (line 2469) | static float GetMinimumStepAtDecimalPrecision(int decimal_precision)
function TYPE (line 2478) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType dat...
function TYPE (line 3021) | TYPE ImGui::ScaleValueFromRatioT(ImGuiDataType data_type, float t, TYPE ...
function ImParseFormatSanitizeForPrinting (line 3625) | void ImParseFormatSanitizeForPrinting(const char* fmt_in, char* fmt_out,...
function ImParseFormatPrecision (line 3675) | int ImParseFormatPrecision(const char* fmt, int default_precision)
type ImStb (line 3953) | namespace ImStb
function STB_TEXTEDIT_STRINGLEN (line 3991) | static int STB_TEXTEDIT_STRINGLEN(const ImGuiInputTextState* obj) ...
function STB_TEXTEDIT_GETCHAR (line 3992) | static char STB_TEXTEDIT_GETCHAR(const ImGuiInputTextState* obj, in...
function STB_TEXTEDIT_GETWIDTH (line 3993) | static float STB_TEXTEDIT_GETWIDTH(ImGuiInputTextState* obj, int lin...
function STB_TEXTEDIT_LAYOUTROW (line 3995) | static void STB_TEXTEDIT_LAYOUTROW(StbTexteditRow* r, ImGuiInputTex...
function IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL (line 4011) | static int IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL(ImGuiInputTextState* o...
function IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL (line 4019) | static int IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL(ImGuiInputTextState* o...
function ImCharIsSeparatorW (line 4027) | static bool ImCharIsSeparatorW(unsigned int c)
function is_word_boundary_from_right (line 4041) | static int is_word_boundary_from_right(ImGuiInputTextState* obj, int idx)
function is_word_boundary_from_left (line 4058) | static int is_word_boundary_from_left(ImGuiInputTextState* obj, int idx)
function STB_TEXTEDIT_MOVEWORDLEFT_IMPL (line 4074) | static int STB_TEXTEDIT_MOVEWORDLEFT_IMPL(ImGuiInputTextState* obj, i...
function STB_TEXTEDIT_MOVEWORDRIGHT_MAC (line 4081) | static int STB_TEXTEDIT_MOVEWORDRIGHT_MAC(ImGuiInputTextState* obj, i...
function STB_TEXTEDIT_MOVEWORDRIGHT_WIN (line 4089) | static int STB_TEXTEDIT_MOVEWORDRIGHT_WIN(ImGuiInputTextState* obj, i...
function STB_TEXTEDIT_MOVEWORDRIGHT_IMPL (line 4097) | static int STB_TEXTEDIT_MOVEWORDRIGHT_IMPL(ImGuiInputTextState* obj, ...
function STB_TEXTEDIT_MOVELINESTART_IMPL (line 4102) | static int STB_TEXTEDIT_MOVELINESTART_IMPL(ImGuiInputTextState* obj, I...
function STB_TEXTEDIT_MOVELINEEND_IMPL (line 4138) | static int STB_TEXTEDIT_MOVELINEEND_IMPL(ImGuiInputTextState* obj, ImS...
function STB_TEXTEDIT_DELETECHARS (line 4170) | static void STB_TEXTEDIT_DELETECHARS(ImGuiInputTextState* obj, int pos...
function STB_TEXTEDIT_INSERTCHARS (line 4181) | static int STB_TEXTEDIT_INSERTCHARS(ImGuiInputTextState* obj, int pos,...
function stb_textedit_replace (line 4239) | static void stb_textedit_replace(ImGuiInputTextState* str, STB_Textedi...
function ImVec2 (line 3976) | static ImVec2 InputTextCalcTextSize(ImGuiContext* ctx, const char* text_...
type ImStb (line 3989) | namespace ImStb
function STB_TEXTEDIT_STRINGLEN (line 3991) | static int STB_TEXTEDIT_STRINGLEN(const ImGuiInputTextState* obj) ...
function STB_TEXTEDIT_GETCHAR (line 3992) | static char STB_TEXTEDIT_GETCHAR(const ImGuiInputTextState* obj, in...
function STB_TEXTEDIT_GETWIDTH (line 3993) | static float STB_TEXTEDIT_GETWIDTH(ImGuiInputTextState* obj, int lin...
function STB_TEXTEDIT_LAYOUTROW (line 3995) | static void STB_TEXTEDIT_LAYOUTROW(StbTexteditRow* r, ImGuiInputTex...
function IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL (line 4011) | static int IMSTB_TEXTEDIT_GETNEXTCHARINDEX_IMPL(ImGuiInputTextState* o...
function IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL (line 4019) | static int IMSTB_TEXTEDIT_GETPREVCHARINDEX_IMPL(ImGuiInputTextState* o...
function ImCharIsSeparatorW (line 4027) | static bool ImCharIsSeparatorW(unsigned int c)
function is_word_boundary_from_right (line 4041) | static int is_word_boundary_from_right(ImGuiInputTextState* obj, int idx)
function is_word_boundary_from_left (line 4058) | static int is_word_boundary_from_left(ImGuiInputTextState* obj, int idx)
function STB_TEXTEDIT_MOVEWORDLEFT_IMPL (line 4074) | static int STB_TEXTEDIT_MOVEWORDLEFT_IMPL(ImGuiInputTextState* obj, i...
function STB_TEXTEDIT_MOVEWORDRIGHT_MAC (line 4081) | static int STB_TEXTEDIT_MOVEWORDRIGHT_MAC(ImGuiInputTextState* obj, i...
function STB_TEXTEDIT_MOVEWORDRIGHT_WIN (line 4089) | static int STB_TEXTEDIT_MOVEWORDRIGHT_WIN(ImGuiInputTextState* obj, i...
function STB_TEXTEDIT_MOVEWORDRIGHT_IMPL (line 4097) | static int STB_TEXTEDIT_MOVEWORDRIGHT_IMPL(ImGuiInputTextState* obj, ...
function STB_TEXTEDIT_MOVELINESTART_IMPL (line 4102) | static int STB_TEXTEDIT_MOVELINESTART_IMPL(ImGuiInputTextState* obj, I...
function STB_TEXTEDIT_MOVELINEEND_IMPL (line 4138) | static int STB_TEXTEDIT_MOVELINEEND_IMPL(ImGuiInputTextState* obj, ImS...
function STB_TEXTEDIT_DELETECHARS (line 4170) | static void STB_TEXTEDIT_DELETECHARS(ImGuiInputTextState* obj, int pos...
function STB_TEXTEDIT_INSERTCHARS (line 4181) | static int STB_TEXTEDIT_INSERTCHARS(ImGuiInputTextState* obj, int pos,...
function stb_textedit_replace (line 4239) | static void stb_textedit_replace(ImGuiInputTextState* str, STB_Textedi...
function InputTextFilterCharacter (line 4407) | static bool InputTextFilterCharacter(ImGuiContext* ctx, ImGuiInputTextSt...
function InputTextReconcileUndoState (line 4519) | static void InputTextReconcileUndoState(ImGuiInputTextState* state, cons...
function InputTextLineIndexBuild (line 4589) | static int InputTextLineIndexBuild(ImGuiInputTextFlags flags, ImGuiTextI...
function ImVec2 (line 4640) | static ImVec2 InputTextLineIndexGetPosOffset(ImGuiContext& g, ImGuiInput...
function ColorEditRestoreH (line 5717) | static void ColorEditRestoreH(const float* col, float* H)
function ColorEditRestoreHS (line 5728) | static void ColorEditRestoreHS(const float* col, float* H, float* S, flo...
function RenderArrowsForVerticalBar (line 6011) | static void RenderArrowsForVerticalBar(ImDrawList* draw_list, ImVec2 pos...
function TreeNodeStoreStackData (line 6798) | static void TreeNodeStoreStackData(ImGuiTreeNodeFlags flags, float x1)
function ImGuiTypingSelectRequest (line 7508) | ImGuiTypingSelectRequest* ImGui::GetTypingSelectRequest(ImGuiTypingSelec...
function ImStrimatchlen (line 7604) | static int ImStrimatchlen(const char* s1, const char* s1_end, const char...
function BoxSelectPreStartDrag (line 7702) | static void BoxSelectPreStartDrag(ImGuiID id, ImGuiSelectionUserData cli...
function BoxSelectActivateDrag (line 7715) | static void BoxSelectActivateDrag(ImGuiBoxSelectState* bs, ImGuiWindow* ...
function BoxSelectDeactivateDrag (line 7728) | static void BoxSelectDeactivateDrag(ImGuiBoxSelectState* bs)
function BoxSelectScrollWithMouseDrag (line 7740) | static void BoxSelectScrollWithMouseDrag(ImGuiBoxSelectState* bs, ImGuiW...
function DebugLogMultiSelectRequests (line 7854) | static void DebugLogMultiSelectRequests(const char* function, const ImGu...
function ImRect (line 7865) | static ImRect CalcScopeRect(ImGuiMultiSelectTempData* ms, ImGuiWindow* w...
function ImGuiMultiSelectIO (line 7894) | ImGuiMultiSelectIO* ImGui::BeginMultiSelect(ImGuiMultiSelectFlags flags,...
function ImGuiMultiSelectIO (line 8017) | ImGuiMultiSelectIO* ImGui::EndMultiSelect()
function ImGuiSelectionBasicStorage_BatchSetItemSelected (line 8501) | static void ImGuiSelectionBasicStorage_BatchSetItemSelected(ImGuiSelecti...
function ImGuiSelectionBasicStorage_BatchFinish (line 8515) | static void ImGuiSelectionBasicStorage_BatchFinish(ImGuiSelectionBasicSt...
type ImGuiPlotArrayGetterData (line 8868) | struct ImGuiPlotArrayGetterData
method ImGuiPlotArrayGetterData (line 8873) | ImGuiPlotArrayGetterData(const float* values, int stride) { Values = v...
function Plot_ArrayGetter (line 8876) | static float Plot_ArrayGetter(void* data, int idx)
function IsRootOfOpenMenuSet (line 9175) | static bool IsRootOfOpenMenuSet()
type ImGuiTabBarSection (line 9557) | struct ImGuiTabBarSection
method ImGuiTabBarSection (line 9564) | ImGuiTabBarSection() { memset((void*)this, 0, sizeof(*this)); }
type ImGui (line 9567) | namespace ImGui
function TabItemGetSectionIdx (line 9585) | static inline int TabItemGetSectionIdx(const ImGuiTabItem* tab)
function ImGuiTabBar (line 9608) | static ImGuiTabBar* GetTabBarFromTabBarRef(const ImGuiPtrOrIndex& ref)
function ImGuiPtrOrIndex (line 9614) | static ImGuiPtrOrIndex GetTabBarRefFromTabBar(ImGuiTabBar* tab_bar)
function ImGuiTabBar (line 9622) | ImGuiTabBar* ImGui::TabBarFindByID(ImGuiID id)
function TabBarCalcScrollableWidth (line 9752) | static float TabBarCalcScrollableWidth(ImGuiTabBar* tab_bar, ImGuiTabBar...
function ImU32 (line 10033) | static ImU32 ImGui::TabBarCalcTabID(ImGuiTabBar* tab_bar, const char* ...
function ImGuiTabItem (line 10056) | ImGuiTabItem* ImGui::TabBarFindTabByID(ImGuiTabBar* tab_bar, ImGuiID tab...
function ImGuiTabItem (line 10066) | ImGuiTabItem* ImGui::TabBarFindTabByOrder(ImGuiTabBar* tab_bar, int order)
function ImGuiTabItem (line 10074) | ImGuiTabItem* ImGui::TabBarFindMostRecentlySelectedTabForActiveWindow(Im...
function ImGuiTabItem (line 10087) | ImGuiTabItem* ImGui::TabBarGetCurrentTab(ImGuiTabBar* tab_bar)
function ImGuiTabItem (line 10288) | static ImGuiTabItem* ImGui::TabBarScrollingButtons(ImGuiTabBar* tab_bar)
function ImGuiTabItem (line 10351) | static ImGuiTabItem* ImGui::TabBarTabListPopupButton(ImGuiTabBar* tab_bar)
function ImVec2 (line 10795) | ImVec2 ImGui::TabItemCalcSize(const char* label, bool has_close_button_o...
function ImVec2 (line 10807) | ImVec2 ImGui::TabItemCalcSize(ImGuiWindow* window)
FILE: Source/ThirdParty/ImGuiLibrary/imstb_rectpack.h
type stbrp_context (line 85) | typedef struct stbrp_context stbrp_context;
type stbrp_node (line 86) | typedef struct stbrp_node stbrp_node;
type stbrp_rect (line 87) | typedef struct stbrp_rect stbrp_rect;
type stbrp_coord (line 89) | typedef int stbrp_coord;
type stbrp_rect (line 119) | struct stbrp_rect
type stbrp_node (line 179) | struct stbrp_node
type stbrp_context (line 185) | struct stbrp_context
function STBRP_DEF (line 233) | STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
function STBRP_DEF (line 245) | STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int ...
function STBRP_DEF (line 265) | STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int ...
function stbrp__skyline_find_min_y (line 291) | static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first...
type stbrp__findresult (line 341) | typedef struct
function stbrp__findresult (line 347) | static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, ...
function stbrp__findresult (line 449) | static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *co...
function rect_height_compare (line 528) | static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
function rect_original_order (line 539) | static int STBRP__CDECL rect_original_order(const void *a, const void *b)
function STBRP_DEF (line 546) | STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects...
FILE: Source/ThirdParty/ImGuiLibrary/imstb_textedit.h
type StbUndoRecord (line 324) | typedef struct
type StbUndoState (line 333) | typedef struct
type STB_TexteditState (line 342) | typedef struct STB_TexteditState
type StbTexteditRow (line 389) | typedef struct
function stb_text_locate_coord (line 433) | static int stb_text_locate_coord(IMSTB_TEXTEDIT_STRING *str, float x, fl...
function stb_textedit_click (line 499) | static void stb_textedit_click(IMSTB_TEXTEDIT_STRING *str, STB_TexteditS...
function stb_textedit_drag (line 519) | static void stb_textedit_drag(IMSTB_TEXTEDIT_STRING *str, STB_TexteditSt...
type StbFindState (line 553) | typedef struct
function stb_textedit_find_charpos (line 563) | static void stb_textedit_find_charpos(StbFindState *find, IMSTB_TEXTEDIT...
function stb_textedit_clamp (line 616) | static void stb_textedit_clamp(IMSTB_TEXTEDIT_STRING *str, STB_TexteditS...
function stb_textedit_delete (line 630) | static void stb_textedit_delete(IMSTB_TEXTEDIT_STRING *str, STB_Textedit...
function stb_textedit_delete_selection (line 638) | static void stb_textedit_delete_selection(IMSTB_TEXTEDIT_STRING *str, ST...
function stb_textedit_sortselection (line 654) | static void stb_textedit_sortselection(STB_TexteditState *state)
function stb_textedit_move_to_first (line 664) | static void stb_textedit_move_to_first(STB_TexteditState *state)
function stb_textedit_move_to_last (line 675) | static void stb_textedit_move_to_last(IMSTB_TEXTEDIT_STRING *str, STB_Te...
function stb_textedit_move_line_start (line 688) | static int stb_textedit_move_line_start(IMSTB_TEXTEDIT_STRING *str, STB_...
function stb_textedit_move_line_end (line 703) | static int stb_textedit_move_line_end(IMSTB_TEXTEDIT_STRING *str, STB_Te...
function is_word_boundary (line 716) | static int is_word_boundary( IMSTB_TEXTEDIT_STRING *str, int idx )
function stb_textedit_move_to_word_previous (line 722) | static int stb_textedit_move_to_word_previous( IMSTB_TEXTEDIT_STRING *st...
function stb_textedit_move_to_word_next (line 737) | static int stb_textedit_move_to_word_next( IMSTB_TEXTEDIT_STRING *str, i...
function stb_textedit_prep_selection_at_cursor (line 755) | static void stb_textedit_prep_selection_at_cursor(STB_TexteditState *state)
function stb_textedit_cut (line 764) | static int stb_textedit_cut(IMSTB_TEXTEDIT_STRING *str, STB_TexteditStat...
function stb_textedit_paste_internal (line 775) | static int stb_textedit_paste_internal(IMSTB_TEXTEDIT_STRING *str, STB_T...
function stb_textedit_text (line 798) | static void stb_textedit_text(IMSTB_TEXTEDIT_STRING* str, STB_TexteditSt...
function stb_textedit_key (line 824) | static void stb_textedit_key(IMSTB_TEXTEDIT_STRING *str, STB_TexteditSta...
function stb_textedit_flush_redo (line 1200) | static void stb_textedit_flush_redo(StbUndoState *state)
function stb_textedit_discard_undo (line 1207) | static void stb_textedit_discard_undo(StbUndoState *state)
function stb_textedit_discard_redo (line 1229) | static void stb_textedit_discard_redo(StbUndoState *state)
function StbUndoRecord (line 1259) | static StbUndoRecord *stb_text_create_undo_record(StbUndoState *state, i...
function IMSTB_TEXTEDIT_CHARTYPE (line 1283) | static IMSTB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state,...
function stb_text_undo (line 1303) | static void stb_text_undo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState ...
function stb_text_redo (line 1371) | static void stb_text_redo(IMSTB_TEXTEDIT_STRING *str, STB_TexteditState ...
function stb_text_makeundo_insert (line 1422) | static void stb_text_makeundo_insert(STB_TexteditState *state, int where...
function stb_text_makeundo_delete (line 1427) | static void stb_text_makeundo_delete(IMSTB_TEXTEDIT_STRING *str, STB_Tex...
function stb_text_makeundo_replace (line 1437) | static void stb_text_makeundo_replace(IMSTB_TEXTEDIT_STRING *str, STB_Te...
function stb_textedit_clear_state (line 1448) | static void stb_textedit_clear_state(STB_TexteditState *state, int is_si...
function stb_textedit_initialize_state (line 1466) | static void stb_textedit_initialize_state(STB_TexteditState *state, int ...
function stb_textedit_paste (line 1476) | static int stb_textedit_paste(IMSTB_TEXTEDIT_STRING *str, STB_TexteditSt...
FILE: Source/ThirdParty/ImGuiLibrary/imstb_truetype.h
function my_stbtt_initfont (line 292) | void my_stbtt_initfont(void)
function my_stbtt_print (line 304) | void my_stbtt_print(float x, float y, char *text)
function main (line 339) | int main(int argc, char **argv)
function main (line 380) | int main(int arg, char **argv)
type stbtt_uint8 (line 433) | typedef unsigned char stbtt_uint8;
type stbtt_int8 (line 434) | typedef signed char stbtt_int8;
type stbtt_uint16 (line 435) | typedef unsigned short stbtt_uint16;
type stbtt_int16 (line 436) | typedef signed short stbtt_int16;
type stbtt_uint32 (line 437) | typedef unsigned int stbtt_uint32;
type stbtt_int32 (line 438) | typedef signed int stbtt_int32;
type stbtt__buf (line 518) | typedef struct
type stbtt_bakedchar (line 532) | typedef struct
type stbtt_aligned_quad (line 548) | typedef struct
type stbtt_packedchar (line 580) | typedef struct
type stbtt_pack_context (line 587) | typedef struct stbtt_pack_context stbtt_pack_context;
type stbtt_fontinfo (line 588) | typedef struct stbtt_fontinfo stbtt_fontinfo;
type stbrp_rect (line 590) | typedef struct stbrp_rect stbrp_rect;
type stbtt_pack_range (line 624) | typedef struct
type stbtt_pack_context (line 683) | struct stbtt_pack_context {
type stbtt_fontinfo (line 718) | struct stbtt_fontinfo
type stbtt_kerningentry (line 809) | typedef struct stbtt_kerningentry
type stbtt_vertex (line 840) | typedef struct
type stbtt__bitmap (line 929) | typedef struct
function stbtt_uint8 (line 1138) | static stbtt_uint8 stbtt__buf_get8(stbtt__buf *b)
function stbtt_uint8 (line 1145) | static stbtt_uint8 stbtt__buf_peek8(stbtt__buf *b)
function stbtt__buf_seek (line 1152) | static void stbtt__buf_seek(stbtt__buf *b, int o)
function stbtt__buf_skip (line 1158) | static void stbtt__buf_skip(stbtt__buf *b, int o)
function stbtt_uint32 (line 1163) | static stbtt_uint32 stbtt__buf_get(stbtt__buf *b, int n)
function stbtt__buf (line 1173) | static stbtt__buf stbtt__new_buf(const void *p, size_t size)
function stbtt__buf (line 1186) | static stbtt__buf stbtt__buf_range(const stbtt__buf *b, int o, int s)
function stbtt__buf (line 1195) | static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
function stbtt_uint32 (line 1209) | static stbtt_uint32 stbtt__cff_int(stbtt__buf *b)
function stbtt__cff_skip_operand (line 1221) | static void stbtt__cff_skip_operand(stbtt__buf *b) {
function stbtt__buf (line 1236) | static stbtt__buf stbtt__dict_get(stbtt__buf *b, int key)
function stbtt__dict_get_ints (line 1251) | static void stbtt__dict_get_ints(stbtt__buf *b, int key, int outcount, s...
function stbtt__cff_index_count (line 1259) | static int stbtt__cff_index_count(stbtt__buf *b)
function stbtt__buf (line 1265) | static stbtt__buf stbtt__cff_index_get(stbtt__buf b, int i)
function stbtt_uint16 (line 1291) | static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }
function stbtt_int16 (line 1292) | static stbtt_int16 ttSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }
function stbtt_uint32 (line 1293) | static stbtt_uint32 ttULONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]...
function stbtt_int32 (line 1294) | static stbtt_int32 ttLONG(stbtt_uint8 *p) { return (p[0]<<24) + (p[1]...
function stbtt__isfont (line 1299) | static int stbtt__isfont(stbtt_uint8 *font)
function stbtt_uint32 (line 1311) | static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fo...
function stbtt_GetFontOffsetForIndex_internal (line 1324) | static int stbtt_GetFontOffsetForIndex_internal(unsigned char *font_coll...
function stbtt_GetNumberOfFonts_internal (line 1343) | static int stbtt_GetNumberOfFonts_internal(unsigned char *font_collection)
function stbtt__buf (line 1359) | static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
function stbtt__get_svg (line 1373) | static int stbtt__get_svg(stbtt_fontinfo *info)
function stbtt_InitFont_internal (line 1388) | static int stbtt_InitFont_internal(stbtt_fontinfo *info, unsigned char *...
function STBTT_DEF (line 1501) | STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unico...
function STBTT_DEF (line 1594) | STBTT_DEF int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int un...
function stbtt_setvertex (line 1599) | static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int...
function stbtt__GetGlyfOffset (line 1608) | static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_in...
function STBTT_DEF (line 1630) | STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_in...
function STBTT_DEF (line 1646) | STBTT_DEF int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int code...
function STBTT_DEF (line 1651) | STBTT_DEF int stbtt_IsGlyphEmpty(const stbtt_fontinfo *info, int glyph_i...
function stbtt__close_shape (line 1663) | static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, ...
function stbtt__GetGlyphShapeTT (line 1679) | static int stbtt__GetGlyphShapeTT(const stbtt_fontinfo *info, int glyph_...
type stbtt__csctx (line 1902) | typedef struct
function stbtt__track_vertex (line 1916) | static void stbtt__track_vertex(stbtt__csctx *c, stbtt_int32 x, stbtt_in...
function stbtt__csctx_v (line 1925) | static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int3...
function stbtt__csctx_close_shape (line 1941) | static void stbtt__csctx_close_shape(stbtt__csctx *ctx)
function stbtt__csctx_rmove_to (line 1947) | static void stbtt__csctx_rmove_to(stbtt__csctx *ctx, float dx, float dy)
function stbtt__csctx_rline_to (line 1955) | static void stbtt__csctx_rline_to(stbtt__csctx *ctx, float dx, float dy)
function stbtt__csctx_rccurve_to (line 1962) | static void stbtt__csctx_rccurve_to(stbtt__csctx *ctx, float dx1, float ...
function stbtt__buf (line 1973) | static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
function stbtt__buf (line 1987) | static stbtt__buf stbtt__cid_get_glyph_subrs(const stbtt_fontinfo *info,...
function stbtt__run_charstring (line 2015) | static int stbtt__run_charstring(const stbtt_fontinfo *info, int glyph_i...
function stbtt__GetGlyphShapeT2 (line 2274) | static int stbtt__GetGlyphShapeT2(const stbtt_fontinfo *info, int glyph_...
function stbtt__GetGlyphInfoT2 (line 2291) | static int stbtt__GetGlyphInfoT2(const stbtt_fontinfo *info, int glyph_i...
function STBTT_DEF (line 2302) | STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_...
function STBTT_DEF (line 2310) | STBTT_DEF void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int gl...
function STBTT_DEF (line 2322) | STBTT_DEF int stbtt_GetKerningTableLength(const stbtt_fontinfo *info)
function STBTT_DEF (line 2337) | STBTT_DEF int stbtt_GetKerningTable(const stbtt_fontinfo *info, stbtt_ke...
function stbtt__GetGlyphKernInfoAdvance (line 2364) | static int stbtt__GetGlyphKernInfoAdvance(const stbtt_fontinfo *info, in...
function stbtt_int32 (line 2394) | static stbtt_int32 stbtt__GetCoverageIndex(stbtt_uint8 *coverageTable, i...
function stbtt_int32 (line 2452) | static stbtt_int32 stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int...
function stbtt_int32 (line 2501) | static stbtt_int32 stbtt__GetGlyphGPOSInfoAdvance(const stbtt_fontinfo *...
function STBTT_DEF (line 2615) | STBTT_DEF int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int...
function STBTT_DEF (line 2627) | STBTT_DEF int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info,...
function STBTT_DEF (line 2634) | STBTT_DEF void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, in...
function STBTT_DEF (line 2639) | STBTT_DEF void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *as...
function STBTT_DEF (line 2646) | STBTT_DEF int stbtt_GetFontVMetricsOS2(const stbtt_fontinfo *info, int ...
function STBTT_DEF (line 2657) | STBTT_DEF void stbtt_GetFontBoundingBox(const stbtt_fontinfo *info, int ...
function STBTT_DEF (line 2665) | STBTT_DEF float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, fl...
function STBTT_DEF (line 2671) | STBTT_DEF float stbtt_ScaleForMappingEmToPixels(const stbtt_fontinfo *in...
function STBTT_DEF (line 2677) | STBTT_DEF void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v)
function STBTT_DEF (line 2682) | STBTT_DEF stbtt_uint8 *stbtt_FindSVGDoc(const stbtt_fontinfo *info, int gl)
function STBTT_DEF (line 2699) | STBTT_DEF int stbtt_GetGlyphSVG(const stbtt_fontinfo *info, int gl, cons...
function STBTT_DEF (line 2716) | STBTT_DEF int stbtt_GetCodepointSVG(const stbtt_fontinfo *info, int unic...
function STBTT_DEF (line 2726) | STBTT_DEF void stbtt_GetGlyphBitmapBoxSubpixel(const stbtt_fontinfo *fon...
function STBTT_DEF (line 2744) | STBTT_DEF void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int g...
function STBTT_DEF (line 2749) | STBTT_DEF void stbtt_GetCodepointBitmapBoxSubpixel(const stbtt_fontinfo ...
function STBTT_DEF (line 2754) | STBTT_DEF void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, i...
type stbtt__hheap_chunk (line 2763) | typedef struct stbtt__hheap_chunk
type stbtt__hheap (line 2768) | typedef struct stbtt__hheap
function stbtt__hheap_free (line 2796) | static void stbtt__hheap_free(stbtt__hheap *hh, void *p)
function stbtt__hheap_cleanup (line 2802) | static void stbtt__hheap_cleanup(stbtt__hheap *hh, void *userdata)
type stbtt__edge (line 2812) | typedef struct stbtt__edge {
type stbtt__active_edge (line 2818) | typedef struct stbtt__active_edge
function stbtt__active_edge (line 2840) | static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__ed...
function stbtt__active_edge (line 2862) | static stbtt__active_edge *stbtt__new_active(stbtt__hheap *hh, stbtt__ed...
function stbtt__fill_active_edges (line 2887) | static void stbtt__fill_active_edges(unsigned char *scanline, int len, s...
function stbtt__rasterize_sorted_edges (line 2929) | static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__...
function stbtt__handle_clipped_edge (line 3033) | static void stbtt__handle_clipped_edge(float *scanline, int x, stbtt__ac...
function stbtt__sized_trapezoid_area (line 3070) | static float stbtt__sized_trapezoid_area(float height, float top_width, ...
function stbtt__position_trapezoid_area (line 3077) | static float stbtt__position_trapezoid_area(float height, float tx0, flo...
function stbtt__sized_triangle_area (line 3082) | static float stbtt__sized_triangle_area(float height, float width)
function stbtt__fill_active_edges_new (line 3087) | static void stbtt__fill_active_edges_new(float *scanline, float *scanlin...
function stbtt__rasterize_sorted_edges (line 3305) | static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__...
function stbtt__sort_edges_ins_sort (line 3407) | static void stbtt__sort_edges_ins_sort(stbtt__edge *p, int n)
function stbtt__sort_edges_quicksort (line 3425) | static void stbtt__sort_edges_quicksort(stbtt__edge *p, int n)
function stbtt__sort_edges (line 3487) | static void stbtt__sort_edges(stbtt__edge *p, int n)
type stbtt__point (line 3493) | typedef struct
function stbtt__rasterize (line 3498) | static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, i...
function stbtt__add_point (line 3555) | static void stbtt__add_point(stbtt__point *points, int n, float x, float y)
function stbtt__tesselate_curve (line 3563) | static int stbtt__tesselate_curve(stbtt__point *points, int *num_points,...
function stbtt__tesselate_cubic (line 3583) | static void stbtt__tesselate_cubic(stbtt__point *points, int *num_points...
function stbtt__point (line 3626) | static stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num...
function STBTT_DEF (line 3703) | STBTT_DEF void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_...
function STBTT_DEF (line 3716) | STBTT_DEF void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata)
function STBTT_DEF (line 3766) | STBTT_DEF void stbtt_MakeGlyphBitmapSubpixel(const stbtt_fontinfo *info,...
function STBTT_DEF (line 3785) | STBTT_DEF void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigne...
function STBTT_DEF (line 3795) | STBTT_DEF void stbtt_MakeCodepointBitmapSubpixelPrefilter(const stbtt_fo...
function STBTT_DEF (line 3800) | STBTT_DEF void stbtt_MakeCodepointBitmapSubpixel(const stbtt_fontinfo *i...
function STBTT_DEF (line 3810) | STBTT_DEF void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, uns...
function stbtt_BakeFontBitmap_internal (line 3821) | static int stbtt_BakeFontBitmap_internal(unsigned char *data, int offset...
function STBTT_DEF (line 3867) | STBTT_DEF void stbtt_GetBakedQuad(const stbtt_bakedchar *chardata, int p...
type stbrp_coord (line 3895) | typedef int stbrp_coord;
type stbrp_context (line 3908) | typedef struct
type stbrp_node (line 3914) | typedef struct
type stbrp_rect (line 3919) | struct stbrp_rect
function stbrp_init_target (line 3925) | static void stbrp_init_target(stbrp_context *con, int pw, int ph, stbrp_...
function stbrp_pack_rects (line 3936) | static void stbrp_pack_rects(stbrp_context *con, stbrp_rect *rects, int ...
function STBTT_DEF (line 3965) | STBTT_DEF int stbtt_PackBegin(stbtt_pack_context *spc, unsigned char *pi...
function STBTT_DEF (line 3997) | STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc)
function STBTT_DEF (line 4003) | STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc, unsign...
function STBTT_DEF (line 4013) | STBTT_DEF void stbtt_PackSetSkipMissingCodepoints(stbtt_pack_context *sp...
function stbtt__h_prefilter (line 4020) | static void stbtt__h_prefilter(unsigned char *pixels, int w, int h, int ...
function stbtt__v_prefilter (line 4082) | static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int ...
function stbtt__oversample_shift (line 4144) | static float stbtt__oversample_shift(int oversample)
function STBTT_DEF (line 4157) | STBTT_DEF int stbtt_PackFontRangesGatherRects(stbtt_pack_context *spc, c...
function STBTT_DEF (line 4192) | STBTT_DEF void stbtt_MakeGlyphBitmapSubpixelPrefilter(const stbtt_fontin...
function STBTT_DEF (line 4216) | STBTT_DEF int stbtt_PackFontRangesRenderIntoRects(stbtt_pack_context *sp...
function STBTT_DEF (line 4305) | STBTT_DEF void stbtt_PackFontRangesPackRects(stbtt_pack_context *spc, st...
function STBTT_DEF (line 4310) | STBTT_DEF int stbtt_PackFontRanges(stbtt_pack_context *spc, const unsign...
function STBTT_DEF (line 4346) | STBTT_DEF int stbtt_PackFontRange(stbtt_pack_context *spc, const unsigne...
function STBTT_DEF (line 4358) | STBTT_DEF void stbtt_GetScaledFontVMetrics(const unsigned char *fontdata...
function STBTT_DEF (line 4371) | STBTT_DEF void stbtt_GetPackedQuad(const stbtt_packedchar *chardata, int...
function stbtt__ray_intersect_bezier (line 4406) | static int stbtt__ray_intersect_bezier(float orig[2], float ray[2], floa...
function equal (line 4470) | static int equal(float *a, float *b)
function stbtt__compute_crossings_x (line 4475) | static int stbtt__compute_crossings_x(float x, float y, int nverts, stbt...
function stbtt__cuberoot (line 4543) | static float stbtt__cuberoot( float x )
function stbtt__solve_cubic (line 4552) | static int stbtt__solve_cubic(float a, float b, float c, float* r)
function STBTT_DEF (line 4773) | STBTT_DEF void stbtt_FreeSDF(unsigned char *bitmap, void *userdata)
function stbtt_int32 (line 4784) | static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint...
function stbtt_CompareUTF8toUTF16_bigendian_internal (line 4823) | static int stbtt_CompareUTF8toUTF16_bigendian_internal(char *s1, int len...
function STBTT_DEF (line 4830) | STBTT_DEF const char *stbtt_GetFontNameString(const stbtt_fontinfo *font...
function stbtt__matchpair (line 4851) | static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint...
function stbtt__matches (line 4898) | static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_ui...
function stbtt_FindMatchingFont_internal (line 4927) | static int stbtt_FindMatchingFont_internal(unsigned char *font_collectio...
function STBTT_DEF (line 4943) | STBTT_DEF int stbtt_BakeFontBitmap(const unsigned char *data, int offset,
function STBTT_DEF (line 4950) | STBTT_DEF int stbtt_GetFontOffsetForIndex(const unsigned char *data, int...
function STBTT_DEF (line 4955) | STBTT_DEF int stbtt_GetNumberOfFonts(const unsigned char *data)
function STBTT_DEF (line 4960) | STBTT_DEF int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *...
function STBTT_DEF (line 4965) | STBTT_DEF int stbtt_FindMatchingFont(const unsigned char *fontdata, cons...
function STBTT_DEF (line 4970) | STBTT_DEF int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len...
FILE: Source/ThirdParty/ImPlotLibrary/ImPlotLibrary.Build.cs
class ImPlotLibrary (line 3) | public class ImPlotLibrary : ModuleRules
method ImPlotLibrary (line 5) | public ImPlotLibrary(ReadOnlyTargetRules Target) : base(Target)
FILE: Source/ThirdParty/ImPlotLibrary/implot.cpp
type ImPlot (line 216) | namespace ImPlot {
function ImVec4 (line 262) | ImVec4 GetAutoColor(ImPlotCol idx) {
type ImPlotStyleVarInfo (line 290) | struct ImPlotStyleVarInfo {
function ImPlotStyleVarInfo (line 330) | static const ImPlotStyleVarInfo* GetPlotStyleVarInfo(ImPlotStyleVar id...
function AddTextVertical (line 340) | void AddTextVertical(ImDrawList *DrawList, ImVec2 pos, ImU32 col, cons...
function AddTextCentered (line 388) | void AddTextCentered(ImDrawList* DrawList, ImVec2 top_center, ImU32 co...
function NiceNum (line 403) | double NiceNum(double x, bool round) {
function SetImGuiContext (line 432) | void SetImGuiContext(ImGuiContext* ctx) {
function ImPlotContext (line 436) | ImPlotContext* CreateContext() {
function DestroyContext (line 444) | void DestroyContext(ImPlotContext* ctx) {
function ImPlotContext (line 452) | ImPlotContext* GetCurrentContext() {
function SetCurrentContext (line 456) | void SetCurrentContext(ImPlotContext* ctx) {
function Initialize (line 463) | void Initialize(ImPlotContext* ctx) {
function ResetCtxForNextPlot (line 503) | void ResetCtxForNextPlot(ImPlotContext* ctx) {
function ResetCtxForNextAlignedPlots (line 521) | void ResetCtxForNextAlignedPlots(ImPlotContext* ctx) {
function ResetCtxForNextSubplot (line 526) | void ResetCtxForNextSubplot(ImPlotContext* ctx) {
function ImPlotPlot (line 536) | ImPlotPlot* GetPlot(const char* title) {
function ImPlotPlot (line 542) | ImPlotPlot* GetCurrentPlot() {
function BustPlotCache (line 546) | void BustPlotCache() {
function ImVec2 (line 556) | ImVec2 GetLocationPos(const ImRect& outer_rect, const ImVec2& inner_si...
function ImVec2 (line 576) | ImVec2 CalcLegendSize(ImPlotItemGroup& items, const ImVec2& pad, const...
function ClampLegendRect (line 597) | bool ClampLegendRect(ImRect& legend_rect, const ImRect& outer_rect, co...
function LegendSortingComp (line 619) | int LegendSortingComp(const void* _a, const void* _b) {
function ShowLegendEntries (line 628) | bool ShowLegendEntries(ImPlotItemGroup& items, const ImRect& legend_bb...
function Locator_Default (line 722) | void Locator_Default(ImPlotTicker& ticker, const ImPlotRange& range, f...
function CalcLogarithmicExponents (line 762) | bool CalcLogarithmicExponents(const ImPlotRange& range, float pix, boo...
function AddTicksLogarithmic (line 781) | void AddTicksLogarithmic(const ImPlotRange& range, int exp_min, int ex...
function Locator_Log10 (line 802) | void Locator_Log10(ImPlotTicker& ticker, const ImPlotRange& range, flo...
function CalcSymLogPixel (line 808) | float CalcSymLogPixel(double plt, const ImPlotRange& range, float pixe...
function Locator_SymLog (line 819) | void Locator_SymLog(ImPlotTicker& ticker, const ImPlotRange& range, fl...
function AddTicksCustom (line 842) | void AddTicksCustom(const double* values, const char* const labels[], ...
function ImPlotTimeUnit (line 867) | inline ImPlotTimeUnit GetUnitForRange(double range) {
function LowerBoundStep (line 876) | inline int LowerBoundStep(int max_divs, const int* divs, const int* st...
function GetTimeStep (line 886) | inline int GetTimeStep(int max_divs, ImPlotTimeUnit unit) {
function ImPlotTime (line 915) | ImPlotTime MkGmtTime(struct tm *ptm) {
function tm (line 927) | tm* GetGmtTime(const ImPlotTime& t, tm* ptm)
function ImPlotTime (line 939) | ImPlotTime MkLocTime(struct tm *ptm) {
function tm (line 947) | tm* GetLocTime(const ImPlotTime& t, tm* ptm) {
function ImPlotTime (line 958) | ImPlotTime MakeTime(int year, int month, int day, int hour, int min, i...
function GetYear (line 981) | int GetYear(const ImPlotTime& t) {
function GetMonth (line 987) | int GetMonth(const ImPlotTime& t) {
function ImPlotTime (line 993) | ImPlotTime AddTime(const ImPlotTime& t, ImPlotTimeUnit unit, int count) {
function ImPlotTime (line 1025) | ImPlotTime FloorTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
function ImPlotTime (line 1042) | ImPlotTime CeilTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
function ImPlotTime (line 1046) | ImPlotTime RoundTime(const ImPlotTime& t, ImPlotTimeUnit unit) {
function ImPlotTime (line 1054) | ImPlotTime CombineDateTime(const ImPlotTime& date_part, const ImPlotTi...
function FormatTime (line 1075) | int FormatTime(const ImPlotTime& t, char* buffer, int size, ImPlotTime...
function FormatDate (line 1115) | int FormatDate(const ImPlotTime& t, char* buffer, int size, ImPlotDate...
function FormatDateTime (line 1144) | int FormatDateTime(const ImPlotTime& t, char* buffer, int size, ImPlot...
function GetDateTimeWidth (line 1156) | inline float GetDateTimeWidth(ImPlotDateTimeSpec fmt) {
function TimeLabelSame (line 1163) | inline bool TimeLabelSame(const char* l1, const char* l2) {
function ImPlotDateTimeSpec (line 1214) | inline ImPlotDateTimeSpec GetDateTimeFmt(const ImPlotDateTimeSpec* ctx...
function Locator_Time (line 1222) | void Locator_Time(ImPlotTicker& ticker, const ImPlotRange& range, floa...
function DragFloat (line 1319) | bool DragFloat(const char*, F*, float, F, F) {
function BeginDisabledControls (line 1333) | inline void BeginDisabledControls(bool cond) {
function EndDisabledControls (line 1340) | inline void EndDisabledControls(bool cond) {
function ShowAxisContextMenu (line 1347) | void ShowAxisContextMenu(ImPlotAxis& axis, ImPlotAxis* equal_axis, boo...
function ShowLegendContextMenu (line 1462) | bool ShowLegendContextMenu(ImPlotLegend& legend, bool visible) {
function ShowSubplotsContextMenu (line 1488) | void ShowSubplotsContextMenu(ImPlotSubplot& subplot) {
function ShowPlotContextMenu (line 1515) | void ShowPlotContextMenu(ImPlotPlot& plot) {
function AxisPrecision (line 1590) | static inline int AxisPrecision(const ImPlotAxis& axis) {
function RoundAxisValue (line 1595) | static inline double RoundAxisValue(const ImPlotAxis& axis, double val...
function LabelAxisValue (line 1599) | void LabelAxisValue(const ImPlotAxis& axis, double value, char* buff, ...
function UpdateAxisColors (line 1617) | void UpdateAxisColors(ImPlotAxis& axis) {
function PadAndDatumAxesX (line 1629) | void PadAndDatumAxesX(ImPlotPlot& plot, float& pad_T, float& pad_B, Im...
function PadAndDatumAxesY (line 1694) | void PadAndDatumAxesY(ImPlotPlot& plot, float& pad_L, float& pad_R, Im...
function RenderGridLinesX (line 1780) | static inline void RenderGridLinesX(ImDrawList& DrawList, const ImPlot...
function RenderGridLinesY (line 1798) | static inline void RenderGridLinesY(ImDrawList& DrawList, const ImPlot...
function RenderSelectionRect (line 1814) | static inline void RenderSelectionRect(ImDrawList& DrawList, const ImV...
function UpdateInput (line 1828) | bool UpdateInput(ImPlotPlot& plot) {
function ApplyNextPlotData (line 2099) | void ApplyNextPlotData(ImAxis idx) {
function SetupAxis (line 2125) | void SetupAxis(ImAxis idx, const char* label, ImPlotAxisFlags flags) {
function SetupAxisLimits (line 2146) | void SetupAxisLimits(ImAxis idx, double min_lim, double max_lim, ImPlo...
function SetupAxisFormat (line 2159) | void SetupAxisFormat(ImAxis idx, const char* fmt) {
function SetupAxisLinks (line 2171) | void SetupAxisLinks(ImAxis idx, double* min_lnk, double* max_lnk) {
function SetupAxisFormat (line 2183) | void SetupAxisFormat(ImAxis idx, ImPlotFormatter formatter, void* data) {
function SetupAxisTicks (line 2194) | void SetupAxisTicks(ImAxis idx, const double* values, int n_ticks, con...
function SetupAxisTicks (line 2210) | void SetupAxisTicks(ImAxis idx, double v_min, double v_max, int n_tick...
function SetupAxisScale (line 2219) | void SetupAxisScale(ImAxis idx, ImPlotScale scale) {
function SetupAxisScale (line 2261) | void SetupAxisScale(ImAxis idx, ImPlotTransform fwd, ImPlotTransform i...
function SetupAxisLimitsConstraints (line 2274) | void SetupAxisLimitsConstraints(ImAxis idx, double v_min, double v_max) {
function SetupAxisZoomConstraints (line 2285) | void SetupAxisZoomConstraints(ImAxis idx, double z_min, double z_max) {
function SetupAxes (line 2296) | void SetupAxes(const char* x_label, const char* y_label, ImPlotAxisFla...
function SetupAxesLimits (line 2301) | void SetupAxesLimits(double x_min, double x_max, double y_min, double ...
function SetupLegend (line 2306) | void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags) {
function SetupMouseText (line 2323) | void SetupMouseText(ImPlotLocation location, ImPlotMouseTextFlags flag...
function SetNextAxisLimits (line 2335) | void SetNextAxisLimits(ImAxis axis, double v_min, double v_max, ImPlot...
function SetNextAxisLinks (line 2345) | void SetNextAxisLinks(ImAxis axis, double* link_min, double* link_max) {
function SetNextAxisToFit (line 2352) | void SetNextAxisToFit(ImAxis axis) {
function SetNextAxesLimits (line 2358) | void SetNextAxesLimits(double x_min, double x_max, double y_min, doubl...
function SetNextAxesToFit (line 2363) | void SetNextAxesToFit() {
function BeginPlot (line 2372) | bool BeginPlot(const char* title_id, const ImVec2& size, ImPlotFlags f...
function SetupFinish (line 2466) | void SetupFinish() {
function EndPlot (line 2766) | void EndPlot() {
function SubplotSetCell (line 3277) | void SubplotSetCell(int row, int col) {
function SubplotSetCell (line 3318) | void SubplotSetCell(int idx) {
function SubplotNextCell (line 3335) | void SubplotNextCell() {
function BeginSubplots (line 3341) | bool BeginSubplots(const char* title, int rows, int cols, const ImVec2...
function EndSubplots (line 3543) | void EndSubplots() {
function SetAxis (line 3652) | void SetAxis(ImAxis axis) {
function SetAxes (line 3664) | void SetAxes(ImAxis x_idx, ImAxis y_idx) {
function ImPlotPoint (line 3676) | ImPlotPoint PixelsToPlot(float x, float y, ImAxis x_idx, ImAxis y_idx) {
function ImPlotPoint (line 3688) | ImPlotPoint PixelsToPlot(const ImVec2& pix, ImAxis x_idx, ImAxis y_idx) {
function ImVec2 (line 3692) | ImVec2 PlotToPixels(double x, double y, ImAxis x_idx, ImAxis y_idx) {
function ImVec2 (line 3704) | ImVec2 PlotToPixels(const ImPlotPoint& plt, ImAxis x_idx, ImAxis y_idx) {
function ImVec2 (line 3708) | ImVec2 GetPlotPos() {
function ImVec2 (line 3715) | ImVec2 GetPlotSize() {
function ImPlotPoint (line 3722) | ImPlotPoint GetPlotMousePos(ImAxis x_idx, ImAxis y_idx) {
function ImPlotRect (line 3728) | ImPlotRect GetPlotLimits(ImAxis x_idx, ImAxis y_idx) {
function IsPlotHovered (line 3743) | bool IsPlotHovered() {
function IsAxisHovered (line 3750) | bool IsAxisHovered(ImAxis axis) {
function IsSubplotsHovered (line 3757) | bool IsSubplotsHovered() {
function IsPlotSelected (line 3763) | bool IsPlotSelected() {
function ImPlotRect (line 3770) | ImPlotRect GetPlotSelection(ImAxis x_idx, ImAxis y_idx) {
function CancelPlotSelection (line 3787) | void CancelPlotSelection() {
function HideNextItem (line 3796) | void HideNextItem(bool hidden, ImPlotCond cond) {
function Annotation (line 3807) | void Annotation(double x, double y, const ImVec4& col, const ImVec2& o...
function AnnotationV (line 3820) | void AnnotationV(double x, double y, const ImVec4& col, const ImVec2& ...
function Annotation (line 3830) | void Annotation(double x, double y, const ImVec4& col, const ImVec2& o...
function TagV (line 3837) | void TagV(ImAxis axis, double v, const ImVec4& col, const char* fmt, v...
function Tag (line 3845) | void Tag(ImAxis axis, double v, const ImVec4& col, const char* fmt, .....
function Tag (line 3852) | void Tag(ImAxis axis, double v, const ImVec4& color, bool round) {
function IMPLOT_API (line 3861) | IMPLOT_API void TagX(double x, const ImVec4& color, bool round) {
function IMPLOT_API (line 3867) | IMPLOT_API void TagX(double x, const ImVec4& color, const char* fmt, ....
function IMPLOT_API (line 3876) | IMPLOT_API void TagXV(double x, const ImVec4& color, const char* fmt, ...
function IMPLOT_API (line 3882) | IMPLOT_API void TagY(double y, const ImVec4& color, bool round) {
function IMPLOT_API (line 3888) | IMPLOT_API void TagY(double y, const ImVec4& color, const char* fmt, ....
function IMPLOT_API (line 3897) | IMPLOT_API void TagYV(double y, const ImVec4& color, const char* fmt, ...
function DragPoint (line 3905) | bool DragPoint(int n_id, double* x, double* y, const ImVec4& col, floa...
function DragLineX (line 3954) | bool DragLineX(int n_id, double* value, const ImVec4& col, float thick...
function DragLineY (line 4009) | bool DragLineY(int n_id, double* value, const ImVec4& col, float thick...
function DragRect (line 4065) | bool DragRect(int n_id, double* x_min, double* y_min, double* x_max, d...
function DragRect (line 4208) | bool DragRect(int id, ImPlotRect* bounds, const ImVec4& col, ImPlotDra...
function IsLegendEntryHovered (line 4216) | bool IsLegendEntryHovered(const char* label_id) {
function BeginLegendPopup (line 4225) | bool BeginLegendPopup(const char* label_id, ImGuiMouseButton mouse_but...
function EndLegendPopup (line 4241) | void EndLegendPopup() {
function ShowAltLegend (line 4246) | void ShowAltLegend(const char* title_id, bool vertical, const ImVec2 s...
function BeginDragDropTargetPlot (line 4286) | bool BeginDragDropTargetPlot() {
function BeginDragDropTargetAxis (line 4293) | bool BeginDragDropTargetAxis(ImAxis axis) {
function BeginDragDropTargetLegend (line 4302) | bool BeginDragDropTargetLegend() {
function EndDragDropTarget (line 4309) | void EndDragDropTarget() {
function BeginDragDropSourcePlot (line 4314) | bool BeginDragDropSourcePlot(ImGuiDragDropFlags flags) {
function BeginDragDropSourceAxis (line 4323) | bool BeginDragDropSourceAxis(ImAxis idx, ImGuiDragDropFlags flags) {
function BeginDragDropSourceItem (line 4332) | bool BeginDragDropSourceItem(const char* label_id, ImGuiDragDropFlags ...
function EndDragDropSource (line 4344) | void EndDragDropSource() {
function BeginAlignedPlots (line 4353) | bool BeginAlignedPlots(const char* group_id, bool vertical) {
function EndAlignedPlots (line 4374) | void EndAlignedPlots() {
function ImPlotStyle (line 4388) | ImPlotStyle& GetStyle() {
function PushStyleColor (line 4394) | void PushStyleColor(ImPlotCol idx, ImU32 col) {
function PushStyleColor (line 4403) | void PushStyleColor(ImPlotCol idx, const ImVec4& col) {
function PopStyleColor (line 4412) | void PopStyleColor(int count) {
function PushStyleVar (line 4424) | void PushStyleVar(ImPlotStyleVar idx, float val) {
function PushStyleVar (line 4436) | void PushStyleVar(ImPlotStyleVar idx, int val) {
function PushStyleVar (line 4454) | void PushStyleVar(ImPlotStyleVar idx, const ImVec2& val)
function PopStyleVar (line 4468) | void PopStyleVar(int count) {
function ImPlotColormap (line 4494) | ImPlotColormap AddColormap(const char* name, const ImVec4* colormap, i...
function ImPlotColormap (line 4505) | ImPlotColormap AddColormap(const char* name, const ImU32* colormap, i...
function GetColormapCount (line 4512) | int GetColormapCount() {
function ImPlotColormap (line 4522) | ImPlotColormap GetColormapIndex(const char* name) {
function PushColormap (line 4527) | void PushColormap(ImPlotColormap colormap) {
function PushColormap (line 4534) | void PushColormap(const char* name) {
function PopColormap (line 4541) | void PopColormap(int count) {
function ImU32 (line 4552) | ImU32 NextColormapColorU32() {
function ImVec4 (line 4561) | ImVec4 NextColormapColor() {
function GetColormapSize (line 4565) | int GetColormapSize(ImPlotColormap cmap) {
function ImU32 (line 4572) | ImU32 GetColormapColorU32(int idx, ImPlotColormap cmap) {
function ImVec4 (line 4580) | ImVec4 GetColormapColor(int idx, ImPlotColormap cmap) {
function ImU32 (line 4584) | ImU32 SampleColormapU32(float t, ImPlotColormap cmap) {
function ImVec4 (line 4591) | ImVec4 SampleColormap(float t, ImPlotColormap cmap) {
function RenderColorBar (line 4595) | void RenderColorBar(const ImU32* colors, int size, ImDrawList& DrawLis...
function ColormapScale (line 4632) | void ColormapScale(const char* label, double scale_min, double scale_m...
function ColormapSlider (line 4721) | bool ColormapSlider(const char* label, float* t, ImVec4* out, const ch...
function ColormapButton (line 4755) | bool ColormapButton(const char* label, const ImVec2& size_arg, ImPlotC...
function ImPlotInputMap (line 4788) | ImPlotInputMap& GetInputMap() {
function MapInputDefault (line 4794) | void MapInputDefault(ImPlotInputMap* dst) {
function MapInputReverse (line 4810) | void MapInputReverse(ImPlotInputMap* dst) {
function ItemIcon (line 4830) | void ItemIcon(const ImVec4& col) {
function ItemIcon (line 4834) | void ItemIcon(ImU32 col) {
function ColormapIcon (line 4843) | void ColormapIcon(ImPlotColormap cmap) {
function ImDrawList (line 4855) | ImDrawList* GetPlotDrawList() {
function PushPlotClipRect (line 4859) | void PushPlotClipRect(float expand) {
function PopPlotClipRect (line 4868) | void PopPlotClipRect() {
function HelpMarker (line 4873) | static void HelpMarker(const char* desc) {
function ShowStyleSelector (line 4884) | bool ShowStyleSelector(const char* label)
function ShowColormapSelector (line 4901) | bool ShowColormapSelector(const char* label) {
function ShowInputMapSelector (line 4918) | bool ShowInputMapSelector(const char* label) {
function ShowStyleEditor (line 4933) | void ShowStyleEditor(ImPlotStyle* ref) {
function ShowUserGuide (line 5183) | void ShowUserGuide() {
function ShowTicksMetrics (line 5209) | void ShowTicksMetrics(const ImPlotTicker& ticker) {
function ShowAxisMetrics (line 5214) | void ShowAxisMetrics(const ImPlotPlot& plot, const ImPlotAxis& axis) {
function ShowMetricsWindow (line 5241) | void ShowMetricsWindow(bool* p_popen) {
function ShowDatePicker (line 5451) | bool ShowDatePicker(const char* id, int* level, ImPlotTime* t, const I...
function ShowTimePicker (line 5662) | bool ShowTimePicker(const char* id, ImPlotTime* t) {
function StyleColorsAuto (line 5759) | void StyleColorsAuto(ImPlotStyle* dst) {
function StyleColorsClassic (line 5789) | void StyleColorsClassic(ImPlotStyle* dst) {
function StyleColorsDark (line 5818) | void StyleColorsDark(ImPlotStyle* dst) {
function StyleColorsLight (line 5847) | void StyleColorsLight(ImPlotStyle* dst) {
function BeginPlot (line 5882) | bool BeginPlot(const char* title, const char* x_label, const char* y1_...
FILE: Source/ThirdParty/ImPlotLibrary/implot.h
type ImPlotContext (line 77) | struct ImPlotContext
type ImAxis (line 80) | typedef int ImAxis;
type ImPlotFlags (line 81) | typedef int ImPlotFlags;
type ImPlotAxisFlags (line 82) | typedef int ImPlotAxisFlags;
type ImPlotSubplotFlags (line 83) | typedef int ImPlotSubplotFlags;
type ImPlotLegendFlags (line 84) | typedef int ImPlotLegendFlags;
type ImPlotMouseTextFlags (line 85) | typedef int ImPlotMouseTextFlags;
type ImPlotDragToolFlags (line 86) | typedef int ImPlotDragToolFlags;
type ImPlotColormapScaleFlags (line 87) | typedef int ImPlotColormapScaleFlags;
type ImPlotItemFlags (line 89) | typedef int ImPlotItemFlags;
type ImPlotLineFlags (line 90) | typedef int ImPlotLineFlags;
type ImPlotScatterFlags (line 91) | typedef int ImPlotScatterFlags;
type ImPlotStairsFlags (line 92) | typedef int ImPlotStairsFlags;
type ImPlotShadedFlags (line 93) | typedef int ImPlotShadedFlags;
type ImPlotBarsFlags (line 94) | typedef int ImPlotBarsFlags;
type ImPlotBarGroupsFlags (line 95) | typedef int ImPlotBarGroupsFlags;
type ImPlotErrorBarsFlags (line 96) | typedef int ImPlotErrorBarsFlags;
type ImPlotStemsFlags (line 97) | typedef int ImPlotStemsFlags;
type ImPlotInfLinesFlags (line 98) | typedef int ImPlotInfLinesFlags;
type ImPlotPieChartFlags (line 99) | typedef int ImPlotPieChartFlags;
type ImPlotHeatmapFlags (line 100) | typedef int ImPlotHeatmapFlags;
type ImPlotHistogramFlags (line 101) | typedef int ImPlotHistogramFlags;
type ImPlotDigitalFlags (line 102) | typedef int ImPlotDigitalFlags;
type ImPlotImageFlags (line 103) | typedef int ImPlotImageFlags;
type ImPlotTextFlags (line 104) | typedef int ImPlotTextFlags;
type ImPlotDummyFlags (line 105) | typedef int ImPlotDummyFlags;
type ImPlotCond (line 107) | typedef int ImPlotCond;
type ImPlotCol (line 108) | typedef int ImPlotCol;
type ImPlotStyleVar (line 109) | typedef int ImPlotStyleVar;
type ImPlotScale (line 110) | typedef int ImPlotScale;
type ImPlotMarker (line 111) | typedef int ImPlotMarker;
type ImPlotColormap (line 112) | typedef int ImPlotColormap;
type ImPlotLocation (line 113) | typedef int ImPlotLocation;
type ImPlotBin (line 114) | typedef int ImPlotBin;
type ImAxis_ (line 117) | enum ImAxis_ {
type ImPlotFlags_ (line 131) | enum ImPlotFlags_ {
type ImPlotAxisFlags_ (line 146) | enum ImPlotAxisFlags_ {
type ImPlotSubplotFlags_ (line 170) | enum ImPlotSubplotFlags_ {
type ImPlotLegendFlags_ (line 186) | enum ImPlotLegendFlags_ {
type ImPlotMouseTextFlags_ (line 198) | enum ImPlotMouseTextFlags_ {
type ImPlotDragToolFlags_ (line 206) | enum ImPlotDragToolFlags_ {
type ImPlotColormapScaleFlags_ (line 215) | enum ImPlotColormapScaleFlags_ {
type ImPlotItemFlags_ (line 223) | enum ImPlotItemFlags_ {
type ImPlotLineFlags_ (line 230) | enum ImPlotLineFlags_ {
type ImPlotScatterFlags_ (line 240) | enum ImPlotScatterFlags_ {
type ImPlotStairsFlags_ (line 246) | enum ImPlotStairsFlags_ {
type ImPlotShadedFlags_ (line 253) | enum ImPlotShadedFlags_ {
type ImPlotBarsFlags_ (line 258) | enum ImPlotBarsFlags_ {
type ImPlotBarGroupsFlags_ (line 264) | enum ImPlotBarGroupsFlags_ {
type ImPlotErrorBarsFlags_ (line 271) | enum ImPlotErrorBarsFlags_ {
type ImPlotStemsFlags_ (line 277) | enum ImPlotStemsFlags_ {
type ImPlotInfLinesFlags_ (line 283) | enum ImPlotInfLinesFlags_ {
type ImPlotPieChartFlags_ (line 289) | enum ImPlotPieChartFlags_ {
type ImPlotHeatmapFlags_ (line 297) | enum ImPlotHeatmapFlags_ {
type ImPlotHistogramFlags_ (line 303) | enum ImPlotHistogramFlags_ {
type ImPlotDigitalFlags_ (line 313) | enum ImPlotDigitalFlags_ {
type ImPlotImageFlags_ (line 318) | enum ImPlotImageFlags_ {
type ImPlotTextFlags_ (line 323) | enum ImPlotTextFlags_ {
type ImPlotDummyFlags_ (line 329) | enum ImPlotDummyFlags_ {
type ImPlotCond_ (line 334) | enum ImPlotCond_
type ImPlotCol_ (line 342) | enum ImPlotCol_ {
type ImPlotStyleVar_ (line 370) | enum ImPlotStyleVar_ {
type ImPlotScale_ (line 404) | enum ImPlotScale_ {
type ImPlotMarker_ (line 412) | enum ImPlotMarker_ {
type ImPlotColormap_ (line 428) | enum ImPlotColormap_ {
type ImPlotLocation_ (line 448) | enum ImPlotLocation_ {
type ImPlotBin_ (line 461) | enum ImPlotBin_ {
function IM_MSVC_RUNTIME_CHECKS_OFF (line 469) | IM_MSVC_RUNTIME_CHECKS_OFF
type ImPlotStyle (line 509) | struct ImPlotStyle {
type ImPlotInputMap (line 566) | struct ImPlotInputMap {
type ImPlotPoint (line 590) | typedef ImPlotPoint (*ImPlotGetter)(int idx, void* user_data);
function namespace (line 595) | namespace ImPlot {
type ImPlotFlagsObsolete_ (line 1281) | enum ImPlotFlagsObsolete_ {
function namespace (line 1286) | namespace ImPlot {
FILE: Source/ThirdParty/ImPlotLibrary/implot_demo.cpp
type MyImPlot (line 50) | namespace MyImPlot {
type Vector2f (line 53) | struct Vector2f {
method Vector2f (line 54) | Vector2f(float _x, float _y) { x = _x; y = _y; }
type WaveData (line 59) | struct WaveData {
method WaveData (line 61) | WaveData(double x, double amp, double freq, double offset) { X = x; ...
function ImPlotPoint (line 2317) | ImPlotPoint SineWave(int idx, void* data) {
function ImPlotPoint (line 2323) | ImPlotPoint SawWave(int idx, void* data) {
function ImPlotPoint (line 2329) | ImPlotPoint Spiral(int idx, void*) {
function Sparkline (line 2340) | void Sparkline(const char* id, const float* values, int count, float m...
function StyleSeaborn (line 2353) | void StyleSeaborn() {
function BinarySearch (line 2417) | int BinarySearch(const T* arr, int l, int r, T x) {
function PlotCandlestick (line 2429) | void PlotCandlestick(const char* label_id, const double* xs, const dou...
type ImPlot (line 78) | namespace ImPlot {
function T (line 81) | inline T RandomRange(T min, T max) {
function ImVec4 (line 86) | ImVec4 RandomColor() {
function RandomGauss (line 95) | double RandomGauss() {
type NormalDistribution (line 116) | struct NormalDistribution {
method NormalDistribution (line 117) | NormalDistribution(double mean, double sd) {
type ScrollingBuffer (line 125) | struct ScrollingBuffer {
method ScrollingBuffer (line 129) | ScrollingBuffer(int max_size = 2000) {
method AddPoint (line 134) | void AddPoint(float x, float y) {
method Erase (line 142) | void Erase() {
type RollingBuffer (line 151) | struct RollingBuffer {
method RollingBuffer (line 154) | RollingBuffer() {
method AddPoint (line 158) | void AddPoint(float x, float y) {
type HugeTimeData (line 167) | struct HugeTimeData {
method HugeTimeData (line 168) | HugeTimeData(double min) {
method GetY (line 177) | static double GetY(double t) {
function Demo_Help (line 189) | void Demo_Help() {
function ButtonSelector (line 214) | void ButtonSelector(const char* label, ImGuiMouseButton* b) {
function ModSelector (line 227) | void ModSelector(const char* label, int* k) {
function InputMapping (line 236) | void InputMapping(const char* label, ImGuiMouseButton* b, int* k) {
function ShowInputMapping (line 248) | void ShowInputMapping() {
function Demo_Config (line 262) | void Demo_Config() {
function Demo_LinePlots (line 290) | void Demo_LinePlots() {
function Demo_FilledLinePlots (line 312) | void Demo_FilledLinePlots() {
function Demo_ShadedPlots (line 366) | void Demo_ShadedPlots() {
function Demo_ScatterPlots (line 394) | void Demo_ScatterPlots() {
function Demo_StairstepPlots (line 419) | void Demo_StairstepPlots() {
function Demo_BarPlots (line 449) | void Demo_BarPlots() {
function Demo_BarGroups (line 460) | void Demo_BarGroups() {
function Demo_BarStacks (line 501) | void Demo_BarStacks() {
function Demo_ErrorBars (line 549) | void Demo_ErrorBars() {
function Demo_StemPlots (line 579) | void Demo_StemPlots() {
function Demo_InfiniteLines (line 598) | void Demo_InfiniteLines() {
function Demo_PieCharts (line 610) | void Demo_PieCharts() {
function Demo_Heatmaps (line 644) | void Demo_Heatmaps() {
function Demo_Histogram (line 711) | void Demo_Histogram() {
function Demo_Histogram2D (line 776) | void Demo_Histogram2D() {
function Demo_DigitalPlots (line 805) | void Demo_DigitalPlots() {
function Demo_Images (line 859) | void Demo_Images() {
function Demo_RealtimePlots (line 888) | void Demo_RealtimePlots() {
function Demo_MarkersAndText (line 929) | void Demo_MarkersAndText() {
function Demo_NaNValues (line 974) | void Demo_NaNValues() {
function Demo_LogScale (line 999) | void Demo_LogScale() {
function Demo_SymmetricLogScale (line 1020) | void Demo_SymmetricLogScale() {
function Demo_TimeScale (line 1037) | void Demo_TimeScale() {
function TransformForward_Sqrt (line 1086) | static inline double TransformForward_Sqrt(double v, void*) {
function TransformInverse_Sqrt (line 1090) | static inline double TransformInverse_Sqrt(double v, void*) {
function Demo_CustomScale (line 1094) | void Demo_CustomScale() {
function Demo_MultipleAxes (line 1111) | void Demo_MultipleAxes() {
function Demo_LinkedAxes (line 1169) | void Demo_LinkedAxes() {
function Demo_AxisConstraints (line 1198) | void Demo_AxisConstraints() {
function Demo_EqualAxes (line 1217) | void Demo_EqualAxes() {
function Demo_AutoFittingData (line 1238) | void Demo_AutoFittingData() {
function ImPlotPoint (line 1269) | ImPlotPoint SinewaveGetter(int i, void* data) {
function Demo_SubplotsSizing (line 1274) | void Demo_SubplotsSizing() {
function Demo_SubplotItemSharing (line 1313) | void Demo_SubplotItemSharing() {
function Demo_SubplotAxisLinking (line 1357) | void Demo_SubplotAxisLinking() {
function Demo_LegendOptions (line 1381) | void Demo_LegendOptions() {
function Demo_DragPoints (line 1426) | void Demo_DragPoints() {
function Demo_DragLines (line 1469) | void Demo_DragLines() {
function Demo_DragRects (line 1503) | void Demo_DragRects() {
function ImPlotPoint (line 1555) | ImPlotPoint FindCentroid(const ImVector<ImPlotPoint>& data, const ImPl...
function Demo_Querying (line 1579) | void Demo_Querying() {
function Demo_Annotations (line 1636) | void Demo_Annotations() {
function Demo_Tags (line 1663) | void Demo_Tags() {
function Demo_DragAndDrop (line 1685) | void Demo_DragAndDrop() {
function Demo_Tables (line 1858) | void Demo_Tables() {
function Demo_OffsetAndStride (line 1899) | void Demo_OffsetAndStride() {
function Demo_CustomDataAndGetters (line 1934) | void Demo_CustomDataAndGetters() {
function MetricFormatter (line 1971) | int MetricFormatter(double value, char* buff, int size, void* data) {
function Demo_TickLabels (line 1986) | void Demo_TickLabels() {
function Demo_CustomStyles (line 2025) | void Demo_CustomStyles() {
function Demo_CustomRendering (line 2048) | void Demo_CustomRendering() {
function Demo_LegendPopups (line 2063) | void Demo_LegendPopups() {
function Demo_ColormapWidgets (line 2116) | void Demo_ColormapWidgets() {
function Demo_CustomPlottersAndTooltips (line 2142) | void Demo_CustomPlottersAndTooltips() {
function DemoHeader (line 2174) | void DemoHeader(const char* label, void(*demo)()) {
function ShowDemoWindow (line 2181) | void ShowDemoWindow(bool* p_open) {
type MyImPlot (line 2315) | namespace MyImPlot {
type Vector2f (line 53) | struct Vector2f {
method Vector2f (line 54) | Vector2f(float _x, float _y) { x = _x; y = _y; }
type WaveData (line 59) | struct WaveData {
method WaveData (line 61) | WaveData(double x, double amp, double freq, double offset) { X = x; ...
function ImPlotPoint (line 2317) | ImPlotPoint SineWave(int idx, void* data) {
function ImPlotPoint (line 2323) | ImPlotPoint SawWave(int idx, void* data) {
function ImPlotPoint (line 2329) | ImPlotPoint Spiral(int idx, void*) {
function Sparkline (line 2340) | void Sparkline(const char* id, const float* values, int count, float m...
function StyleSeaborn (line 2353) | void StyleSeaborn() {
function BinarySearch (line 2417) | int BinarySearch(const T* arr, int l, int r, T x) {
function PlotCandlestick (line 2429) | void PlotCandlestick(const char* label_id, const double* xs, const dou...
type MyImPlot (line 2414) | namespace MyImPlot {
type Vector2f (line 53) | struct Vector2f {
method Vector2f (line 54) | Vector2f(float _x, float _y) { x = _x; y = _y; }
type WaveData (line 59) | struct WaveData {
method WaveData (line 61) | WaveData(double x, double amp, double freq, double offset) { X = x; ...
function ImPlotPoint (line 2317) | ImPlotPoint SineWave(int idx, void* data) {
function ImPlotPoint (line 2323) | ImPlotPoint SawWave(int idx, void* data) {
function ImPlotPoint (line 2329) | ImPlotPoint Spiral(int idx, void*) {
function Sparkline (line 2340) | void Sparkline(const char* id, const float* values, int count, float m...
function StyleSeaborn (line 2353) | void StyleSeaborn() {
function BinarySearch (line 2417) | int BinarySearch(const T* arr, int l, int r, T x) {
function PlotCandlestick (line 2429) | void PlotCandlestick(const char* label_id, const double* xs, const dou...
FILE: Source/ThirdParty/ImPlotLibrary/implot_internal.h
type ImPlotTick (line 80) | struct ImPlotTick
type ImPlotAxis (line 81) | struct ImPlotAxis
type ImPlotAxisColor (line 82) | struct ImPlotAxisColor
type ImPlotItem (line 83) | struct ImPlotItem
type ImPlotLegend (line 84) | struct ImPlotLegend
type ImPlotPlot (line 85) | struct ImPlotPlot
type ImPlotNextPlotData (line 86) | struct ImPlotNextPlotData
type ImPlotTicker (line 87) | struct ImPlotTicker
function ImLog10 (line 102) | static inline float ImLog10(float x) { return log10f(x); }
function ImLog10 (line 103) | static inline double ImLog10(double x) { return log10(x); }
function ImSinh (line 104) | static inline float ImSinh(float x) { return sinhf(x); }
function ImSinh (line 105) | static inline double ImSinh(double x) { return sinh(x); }
function ImAsinh (line 106) | static inline float ImAsinh(float x) { return asinhf(x); }
function ImAsinh (line 107) | static inline double ImAsinh(double x) { return asinh(x); }
function ImHasFlag (line 110) | inline bool ImHasFlag(TSet set, TFlag flag) { return (set & flag) == fla...
function ImFlipFlag (line 113) | inline void ImFlipFlag(TSet& set, TFlag flag) { ImHasFlag(set, flag) ? s...
function T (line 116) | inline T ImRemap(T x, T x0, T x1, T y0, T y1) { return y0 + (x - x0) * (...
function T (line 119) | inline T ImRemap01(T x, T x0, T x1) { return (x - x0) / (x1 - x0); }
function ImPosMod (line 121) | static inline int ImPosMod(int l, int r) { return (l % r + r) % r; }
function ImNan (line 123) | static inline bool ImNan(double val) { return isnan(val); }
function ImNanOrInf (line 125) | static inline bool ImNanOrInf(double val) { return !(val >= -DBL_MAX && ...
function ImConstrainNan (line 127) | static inline double ImConstrainNan(double val) { return ImNan(val) ? 0 ...
function ImConstrainInf (line 129) | static inline double ImConstrainInf(double val) { return val >= DBL_MAX ...
function ImConstrainLog (line 131) | static inline double ImConstrainLog(double val) { return val <= 0 ? 0.00...
function ImConstrainTime (line 133) | static inline double ImConstrainTime(double val) { return val < IMPLOT_M...
function T (line 138) | inline T ImMinArray(const T* values, int count) { T m = values[0]; for (...
function T (line 141) | inline T ImMaxArray(const T* values, int count) { T m = values[0]; for (...
function ImMinMaxArray (line 144) | inline void ImMinMaxArray(const T* values, int count, T* min_out, T* max...
function T (line 154) | inline T ImSum(const T* values, int count) {
function ImMean (line 162) | inline double ImMean(const T* values, int count) {
function ImStdDev (line 171) | inline double ImStdDev(const T* values, int count) {
function ImU32 (line 180) | static inline ImU32 ImMixU32(ImU32 a, ImU32 b, ImU32 s) {
function ImU32 (line 202) | static inline ImU32 ImLerpU32(const ImU32* colors, int size, float t) {
function ImU32 (line 215) | static inline ImU32 ImAlphaU32(ImU32 col, float alpha) {
function ImOverlaps (line 221) | inline bool ImOverlaps(T min_a, T max_a, T min_b, T max_b) {
type ImPlotTimeUnit (line 229) | typedef int ImPlotTimeUnit;
type ImPlotDateFmt (line 230) | typedef int ImPlotDateFmt;
type ImPlotTimeFmt (line 231) | typedef int ImPlotTimeFmt;
type ImPlotTimeUnit_ (line 233) | enum ImPlotTimeUnit_ {
type ImPlotDateFmt_ (line 245) | enum ImPlotDateFmt_ { // default [ ISO 8601 ]
type ImPlotTimeFmt_ (line 254) | enum ImPlotTimeFmt_ { // default [ 24 Hour Clock ]
type ImPlotDateTimeSpec (line 278) | struct ImPlotDateTimeSpec {
type ImPlotTime (line 293) | struct ImPlotTime {
function RollOver (line 298) | void RollOver() { S = S + Us / 1000000; Us = Us % 1000000; }
function ImPlotTime (line 300) | static ImPlotTime FromDouble(double t) { return ImPlotTime((time_t)t, (i...
function _AppendTable (line 319) | struct ImPlotColormapData {
function RebuildTables (line 391) | void RebuildTables() {
function IsQual (line 399) | inline bool IsQual(ImPlotColormap cmap) const ...
function ImPlotColormap (line 401) | inline ImPlotColormap GetIndex(const char* name) const ...
function ImU32 (line 403) | inline const ImU32* GetKeys(ImPlotColormap cmap) const ...
function GetKeyCount (line 404) | inline int GetKeyCount(ImPlotColormap cmap) const ...
function ImU32 (line 405) | inline ImU32 GetKeyColor(ImPlotColormap cmap, int idx) const ...
function SetKeyColor (line 406) | inline void SetKeyColor(ImPlotColormap cmap, int idx, ImU32 va...
function ImU32 (line 408) | inline const ImU32* GetTable(ImPlotColormap cmap) const ...
function GetTableSize (line 409) | inline int GetTableSize(ImPlotColormap cmap) const ...
function ImU32 (line 410) | inline ImU32 GetTableColor(ImPlotColormap cmap, int idx) const ...
function ImU32 (line 412) | inline ImU32 LerpTable(ImPlotColormap cmap, float t) const {
type ImPlotPointError (line 421) | struct ImPlotPointError {
type ImPlotAnnotation (line 429) | struct ImPlotAnnotation {
function AppendV (line 444) | struct ImPlotAnnotationCollection {
function Append (line 465) | void Append(const ImVec2& pos, const ImVec2& off, ImU32 bg, ImU32 fg, bo...
function Reset (line 476) | void Reset() {
type ImPlotTag (line 483) | struct ImPlotTag {
function AppendV (line 491) | struct ImPlotTagCollection {
function Append (line 513) | void Append(ImAxis axis, double value, ImU32 bg, ImU32 fg, const char* f...
function Reset (line 524) | void Reset() {
type ImPlotTick (line 532) | struct ImPlotTick
function AddTick (line 554) | struct ImPlotTicker {
function ImPlotTick (line 587) | inline ImPlotTick& AddTick(ImPlotTick tick) {
function OverrideSizeLate (line 605) | void OverrideSizeLate(const ImVec2& size) {
function Reset (line 610) | void Reset() {
function Reset (line 697) | inline void Reset() {
function SetRange (line 755) | inline void SetRange(double v1, double v2) {
function SetRange (line 764) | inline void SetRange(const ImPlotRange& range) {
function SetAspect (line 768) | inline void SetAspect(double unit_per_pix) {
function Constrain (line 785) | inline void Constrain() {
function UpdateTransformCache (line 807) | inline void UpdateTransformCache() {
function PlotToPixels (line 819) | inline float PlotToPixels(double plt) const {
function PixelsToPlot (line 829) | inline double PixelsToPlot(float pix) const {
function ExtendFit (line 839) | inline void ExtendFit(double v) {
function ExtendFitWith (line 846) | inline void ExtendFitWith(ImPlotAxis& alt, double v, double v_alt) {
function ApplyFit (line 855) | inline void ApplyFit(float padding) {
function IsPanLocked (line 890) | inline bool IsPanLocked(bool increasing) {
function PushLinks (line 904) | void PushLinks() {
function PullLinks (line 909) | void PullLinks() {
type ImPlotAlignmentData (line 917) | struct ImPlotAlignmentData {
function End (line 935) | void End() { PadA = PadAMax; PadB = PadBMax; }
function Reset (line 936) | void Reset() { PadA = PadB = PadAMax = PadBMax = 0; }
function Reset (line 986) | void Reset() { Indices.shrink(0); Labels.Buf.shrink(0); }
function GetItemID (line 990) | struct ImPlotItemGroup
function ImPlotItem (line 1001) | ImPlotItem* GetItem(ImGuiID id) { return ItemPool.GetByKey(...
function ImPlotItem (line 1002) | ImPlotItem* GetItem(const char* label_id) { return GetItem(GetItemID(...
function ImPlotItem (line 1003) | ImPlotItem* GetOrAddItem(ImGuiID id) { return ItemPool.GetOrAddB...
function ImPlotItem (line 1004) | ImPlotItem* GetItemByIndex(int i) { return ItemPool.GetByInde...
function GetItemIndex (line 1005) | int GetItemIndex(ImPlotItem* item) { return ItemPool.GetIndex(...
function ImPlotItem (line 1007) | ImPlotItem* GetLegendItem(int i) { return ItemPool.GetByInde...
function Reset (line 1009) | void Reset() { ItemPool.Clear(); Legend....
type ImPlotPlot (line 1013) | struct ImPlotPlot
function ClearTextBuffer (line 1071) | inline void ClearTextBuffer() { TextBuffer.Buf.shrink(0); }
function SetTitle (line 1073) | inline void SetTitle(const char* title) {
function ImPlotAxis (line 1085) | inline ImPlotAxis& XAxis(int i) { return Axes[ImAxis_X1 + i]; }
function ImPlotAxis (line 1086) | inline const ImPlotAxis& XAxis(int i) const { return Axes[ImAxis_X1 + i]; }
function ImPlotAxis (line 1087) | inline ImPlotAxis& YAxis(int i) { return Axes[ImAxis_Y1 + i]; }
function ImPlotAxis (line 1088) | inline const ImPlotAxis& YAxis(int i) const { return Axes[ImAxis_Y1 + i]; }
function EnabledAxesX (line 1090) | inline int EnabledAxesX() {
function EnabledAxesY (line 1097) | inline int EnabledAxesY() {
function SetAxisLabel (line 1104) | inline void SetAxisLabel(ImPlotAxis& axis, const char* label) {
function Reset (line 1153) | struct ImPlotNextPlotData
function Reset (line 1175) | struct ImPlotNextItemData {
type ImPlotContext (line 1204) | struct ImPlotContext {
function namespace (line 1256) | namespace ImPlot {
function AnyAxesInputLocked (line 1343) | static inline bool AnyAxesInputLocked(ImPlotAxis* axes, int count) {
function AllAxesInputLocked (line 1352) | static inline bool AllAxesInputLocked(ImPlotAxis* axes, int count) {
function AnyAxesHeld (line 1360) | static inline bool AnyAxesHeld(ImPlotAxis* axes, int count) {
function AnyAxesHovered (line 1368) | static inline bool AnyAxesHovered(ImPlotAxis* axes, int count) {
function FitThisFrame (line 1377) | static inline bool FitThisFrame() {
function FitPointX (line 1382) | static inline void FitPointX(double x) {
function FitPointY (line 1389) | static inline void FitPointY(double y) {
function FitPoint (line 1396) | static inline void FitPoint(const ImPlotPoint& p) {
function RangesOverlap (line 1405) | static inline bool RangesOverlap(const ImPlotRange& r1, const ImPlotRang...
function ImPlotNextItemData (line 1440) | static inline const ImPlotNextItemData& GetItemData() { return GImPlot->...
function IsColorAuto (line 1443) | static inline bool IsColorAuto(const ImVec4& col) { return col.w == -1; }
function IsColorAuto (line 1445) | static inline bool IsColorAuto(ImPlotCol idx) { return IsColorAuto(GImPl...
function ImVec4 (line 1450) | static inline ImVec4 GetStyleColorVec4(ImPlotCol idx) { return IsColorAu...
function ImU32 (line 1451) | static inline ImU32 GetStyleColorU32(ImPlotCol idx) { return ImGui::Co...
function ImVec2 (line 1458) | static inline ImVec2 CalcTextSizeVertical(const char *text) {
function ImU32 (line 1463) | static inline ImU32 CalcTextColor(const ImVec4& bg) { return (bg.x * 0.2...
function ImU32 (line 1464) | static inline ImU32 CalcTextColor(ImU32 bg) { return CalcTextCol...
function ImU32 (line 1466) | static inline ImU32 CalcHoverColor(ImU32 col) { return ImMixU32(c...
function ImVec2 (line 1469) | static inline ImVec2 ClampLabelPos(ImVec2 pos, const ImVec2& size, const...
function OrderOfMagnitude (line 1494) | static inline int OrderOfMagnitude(double val) { return val == 0 ? 0 : (...
function OrderToPrecision (line 1496) | static inline int OrderToPrecision(int order) { return order > 0 ? 0 : 1...
function Precision (line 1498) | static inline int Precision(double val) { return OrderToPrecision(OrderO...
function RoundTo (line 1500) | static inline double RoundTo(double val, int prec) { double p = pow(10,(...
function ImVec2 (line 1503) | static inline ImVec2 Intersection(const ImVec2& a1, const ImVec2& a2, co...
function CalculateBins (line 1521) | inline void CalculateBins(const T* values, int count, ImPlotBin meth, co...
function IsLeapYear (line 1545) | static inline bool IsLeapYear(int year) {
function GetDaysInMonth (line 1549) | static inline int GetDaysInMonth(int year, int month) {
type tm (line 1555) | struct tm
type tm (line 1560) | struct tm
function ImPlotTime (line 1568) | static inline ImPlotTime MkTime(struct tm *ptm) {
function tm (line 1573) | static inline tm* GetTime(const ImPlotTime& t, tm* ptm) {
function ImPlotTime (line 1598) | static inline ImPlotTime Now() { return ImPlotTime::FromDouble((double)t...
function ImPlotTime (line 1600) | static inline ImPlotTime Today() { return ImPlot::FloorTime(Now(), ImPlo...
function TransformForward_Log10 (line 1622) | static inline double TransformForward_Log10(double v, void*) {
function TransformInverse_Log10 (line 1627) | static inline double TransformInverse_Log10(double v, void*) {
function TransformForward_SymLog (line 1631) | static inline double TransformForward_SymLog(double v, void*) {
function TransformInverse_SymLog (line 1635) | static inline double TransformInverse_SymLog(double v, void*) {
function TransformForward_Logit (line 1639) | static inline double TransformForward_Logit(double v, void*) {
function TransformInverse_Logit (line 1644) | static inline double TransformInverse_Logit(double v, void*) {
function Formatter_Default (line 1652) | static inline int Formatter_Default(double value, char* buff, int size, ...
function Formatter_Logit (line 1657) | static inline int Formatter_Logit(double value, char* buff, int size, vo...
type Formatter_Time_Data (line 1666) | struct Formatter_Time_Data {
function Formatter_Time (line 1673) | static inline int Formatter_Time(double, char* buff, int size, void* dat...
FILE: Source/ThirdParty/ImPlotLibrary/implot_items.cpp
function IMPLOT_INLINE (line 61) | static IMPLOT_INLINE float ImInvSqrt(float x) { return _mm_cvtss_f32(_m...
function IMPLOT_INLINE (line 63) | static IMPLOT_INLINE float ImInvSqrt(float x) { return 1.0f / sqrtf(x); }
type MaxIdx (line 118) | struct MaxIdx { static const unsigned int Value; }
function IMPLOT_INLINE (line 122) | IMPLOT_INLINE void GetLineRenderProps(const ImDrawList& draw_list, float...
function IMPLOT_INLINE (line 136) | IMPLOT_INLINE void PrimLine(ImDrawList& draw_list, const ImVec2& P1, con...
function IMPLOT_INLINE (line 169) | IMPLOT_INLINE void PrimRectFill(ImDrawList& draw_list, const ImVec2& Pmi...
function IMPLOT_INLINE (line 195) | IMPLOT_INLINE void PrimRectLine(ImDrawList& draw_list, const ImVec2& Pmi...
function ImPlotItem (line 287) | ImPlotItem* RegisterOrGetItem(const char* label_id, ImPlotItemFlags flag...
function ImPlotItem (line 310) | ImPlotItem* GetItem(const char* label_id) {
function IsItemHidden (line 315) | bool IsItemHidden(const char* label_id) {
function ImPlotItem (line 320) | ImPlotItem* GetCurrentItem() {
function SetNextLineStyle (line 325) | void SetNextLineStyle(const ImVec4& col, float weight) {
function SetNextFillStyle (line 331) | void SetNextFillStyle(const ImVec4& col, float alpha) {
function SetNextMarkerStyle (line 337) | void SetNextMarkerStyle(ImPlotMarker marker, float size, const ImVec4& f...
function SetNextErrorBarStyle (line 346) | void SetNextErrorBarStyle(const ImVec4& col, float size, float weight) {
function ImVec4 (line 353) | ImVec4 GetLastItemColor() {
function BustItemCache (line 360) | void BustItemCache() {
function BustColorCache (line 372) | void BustColorCache(const char* plot_title_id) {
function BeginItem (line 398) | bool BeginItem(const char* label_id, ImPlotItemFlags flags, ImPlotCol re...
function EndItem (line 479) | void EndItem() {
function IMPLOT_INLINE (line 495) | IMPLOT_INLINE T IndexData(const T* data, int idx, int count, int offset,...
type IndexerIdx (line 507) | struct IndexerIdx {
method IndexerIdx (line 508) | IndexerIdx(const T* data, int count, int offset = 0, int stride = size...
method IMPLOT_INLINE (line 514) | IMPLOT_INLINE double operator()(I idx) const {
type IndexerAdd (line 524) | struct IndexerAdd {
method IndexerAdd (line 525) | IndexerAdd(const _Indexer1& indexer1, const _Indexer2& indexer2, doubl...
method IMPLOT_INLINE (line 532) | IMPLOT_INLINE double operator()(I idx) const {
type IndexerLin (line 542) | struct IndexerLin {
method IndexerLin (line 543) | IndexerLin(double m, double b) : M(m), B(b) { }
method IMPLOT_INLINE (line 544) | IMPLOT_INLINE double operator()(I idx) const {
type IndexerConst (line 551) | struct IndexerConst {
method IndexerConst (line 552) | IndexerConst(double ref) : Ref(ref) { }
method IMPLOT_INLINE (line 553) | IMPLOT_INLINE double operator()(I) const { return Ref; }
type GetterXY (line 562) | struct GetterXY {
method GetterXY (line 563) | GetterXY(_IndexerX x, _IndexerY y, int count) : IndxerX(x), IndxerY(y)...
method IMPLOT_INLINE (line 564) | IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
type GetterFuncPtr (line 573) | struct GetterFuncPtr {
method GetterFuncPtr (line 574) | GetterFuncPtr(ImPlotGetter getter, void* data, int count) :
method IMPLOT_INLINE (line 579) | IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
type GetterOverrideX (line 588) | struct GetterOverrideX {
method GetterOverrideX (line 589) | GetterOverrideX(_Getter getter, double x) : Getter(getter), X(x), Coun...
method IMPLOT_INLINE (line 590) | IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
type GetterOverrideY (line 601) | struct GetterOverrideY {
method GetterOverrideY (line 602) | GetterOverrideY(_Getter getter, double y) : Getter(getter), Y(y), Coun...
method IMPLOT_INLINE (line 603) | IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
type GetterLoop (line 614) | struct GetterLoop {
method GetterLoop (line 615) | GetterLoop(_Getter getter) : Getter(getter), Count(getter.Count + 1) { }
method IMPLOT_INLINE (line 616) | IMPLOT_INLINE ImPlotPoint operator()(I idx) const {
type GetterError (line 625) | struct GetterError {
method GetterError (line 626) | GetterError(const T* xs, const T* ys, const T* neg, const T* pos, int ...
method IMPLOT_INLINE (line 635) | IMPLOT_INLINE ImPlotPointError operator()(I idx) const {
type Fitter1 (line 655) | struct Fitter1 {
method Fitter1 (line 656) | Fitter1(const _Getter1& getter) : Getter(getter) { }
method Fit (line 657) | void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
type FitterX (line 668) | struct FitterX {
method FitterX (line 669) | FitterX(const _Getter1& getter) : Getter(getter) { }
method Fit (line 670) | void Fit(ImPlotAxis& x_axis, ImPlotAxis&) const {
type FitterY (line 680) | struct FitterY {
method FitterY (line 681) | FitterY(const _Getter1& getter) : Getter(getter) { }
method Fit (line 682) | void Fit(ImPlotAxis&, ImPlotAxis& y_axis) const {
type Fitter2 (line 692) | struct Fitter2 {
method Fitter2 (line 693) | Fitter2(const _Getter1& getter1, const _Getter2& getter2) : Getter1(ge...
method Fit (line 694) | void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
type FitterBarV (line 711) | struct FitterBarV {
method FitterBarV (line 712) | FitterBarV(const _Getter1& getter1, const _Getter2& getter2, double wi...
method Fit (line 717) | void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
type FitterBarH (line 734) | struct FitterBarH {
method FitterBarH (line 735) | FitterBarH(const _Getter1& getter1, const _Getter2& getter2, double he...
method Fit (line 740) | void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
type FitterRect (line 756) | struct FitterRect {
method FitterRect (line 757) | FitterRect(const ImPlotPoint& pmin, const ImPlotPoint& pmax) :
method FitterRect (line 761) | FitterRect(const ImPlotRect& rect) :
method Fit (line 764) | void Fit(ImPlotAxis& x_axis, ImPlotAxis& y_axis) const {
type Transformer1 (line 778) | struct Transformer1 {
method Transformer1 (line 779) | Transformer1(double pixMin, double pltMin, double pltMax, double m, do...
method IMPLOT_INLINE (line 790) | IMPLOT_INLINE float operator()(T p) const {
type Transformer2 (line 804) | struct Transformer2 {
method Transformer2 (line 805) | Transformer2(const ImPlotAxis& x_axis, const ImPlotAxis& y_axis) :
method Transformer2 (line 824) | Transformer2(const ImPlotPlot& plot) :
method Transformer2 (line 828) | Transformer2() :
method IMPLOT_INLINE (line 832) | IMPLOT_INLINE ImVec2 operator()(const P& plt) const {
method IMPLOT_INLINE (line 839) | IMPLOT_INLINE ImVec2 operator()(T x, T y) const {
type RendererBase (line 854) | struct RendererBase {
method RendererBase (line 855) | RendererBase(int prims, int idx_consumed, int vtx_consumed) :
type RendererLineStrip (line 867) | struct RendererLineStrip : RendererBase {
method RendererLineStrip (line 868) | RendererLineStrip(const _Getter& getter, ImU32 col, float weight) :
method Init (line 876) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 879) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererLineStripSkip (line 898) | struct RendererLineStripSkip : RendererBase {
method RendererLineStripSkip (line 899) | RendererLineStripSkip(const _Getter& getter, ImU32 col, float weight) :
method Init (line 907) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 910) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererLineSegments1 (line 931) | struct RendererLineSegments1 : RendererBase {
method RendererLineSegments1 (line 932) | RendererLineSegments1(const _Getter& getter, ImU32 col, float weight) :
method Init (line 938) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 941) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererLineSegments2 (line 957) | struct RendererLineSegments2 : RendererBase {
method RendererLineSegments2 (line 958) | RendererLineSegments2(const _Getter1& getter1, const _Getter2& getter2...
method Init (line 965) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 968) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererBarsFillV (line 985) | struct RendererBarsFillV : RendererBase {
method RendererBarsFillV (line 986) | RendererBarsFillV(const _Getter1& getter1, const _Getter2& getter2, Im...
method Init (line 993) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 996) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererBarsFillH (line 1023) | struct RendererBarsFillH : RendererBase {
method RendererBarsFillH (line 1024) | RendererBarsFillH(const _Getter1& getter1, const _Getter2& getter2, Im...
method Init (line 1031) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1034) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererBarsLineV (line 1061) | struct RendererBarsLineV : RendererBase {
method RendererBarsLineV (line 1062) | RendererBarsLineV(const _Getter1& getter1, const _Getter2& getter2, Im...
method Init (line 1070) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1073) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererBarsLineH (line 1101) | struct RendererBarsLineH : RendererBase {
method RendererBarsLineH (line 1102) | RendererBarsLineH(const _Getter1& getter1, const _Getter2& getter2, Im...
method Init (line 1110) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1113) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererStairsPre (line 1142) | struct RendererStairsPre : RendererBase {
method RendererStairsPre (line 1143) | RendererStairsPre(const _Getter& getter, ImU32 col, float weight) :
method Init (line 1151) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1154) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererStairsPost (line 1173) | struct RendererStairsPost : RendererBase {
method RendererStairsPost (line 1174) | RendererStairsPost(const _Getter& getter, ImU32 col, float weight) :
method Init (line 1182) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1185) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererStairsPreShaded (line 1204) | struct RendererStairsPreShaded : RendererBase {
method RendererStairsPreShaded (line 1205) | RendererStairsPreShaded(const _Getter& getter, ImU32 col) :
method Init (line 1213) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1216) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererStairsPostShaded (line 1236) | struct RendererStairsPostShaded : RendererBase {
method RendererStairsPostShaded (line 1237) | RendererStairsPostShaded(const _Getter& getter, ImU32 col) :
method Init (line 1245) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1248) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererShaded (line 1270) | struct RendererShaded : RendererBase {
method RendererShaded (line 1271) | RendererShaded(const _Getter1& getter1, const _Getter2& getter2, ImU32...
method Init (line 1280) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1283) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RectC (line 1330) | struct RectC {
type RendererRectC (line 1337) | struct RendererRectC : RendererBase {
method RendererRectC (line 1338) | RendererRectC(const _Getter& getter) :
method Init (line 1342) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1345) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
function RenderPrimitivesEx (line 1364) | void RenderPrimitivesEx(const _Renderer& renderer, ImDrawList& draw_list...
function RenderPrimitives1 (line 1403) | void RenderPrimitives1(const _Getter& getter, Args... args) {
function RenderPrimitives2 (line 1410) | void RenderPrimitives2(const _Getter1& getter1, const _Getter2& getter2,...
type RendererMarkersFill (line 1421) | struct RendererMarkersFill : RendererBase {
method RendererMarkersFill (line 1422) | RendererMarkersFill(const _Getter& getter, const ImVec2* marker, int c...
method Init (line 1430) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1433) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
type RendererMarkersLine (line 1464) | struct RendererMarkersLine : RendererBase {
method RendererMarkersLine (line 1465) | RendererMarkersLine(const _Getter& getter, const ImVec2* marker, int c...
method Init (line 1474) | void Init(ImDrawList& draw_list) const {
method IMPLOT_INLINE (line 1477) | IMPLOT_INLINE bool Render(ImDrawList& draw_list, const ImRect& cull_re...
function RenderMarkers (line 1540) | void RenderMarkers(const _Getter& getter, ImPlotMarker marker, float siz...
function PlotLineEx (line 1573) | void PlotLineEx(const char* label_id, const _Getter& getter, ImPlotLineF...
function PlotLine (line 1620) | void PlotLine(const char* label_id, const T* values, int count, double x...
function PlotLine (line 1626) | void PlotLine(const char* label_id, const T* xs, const T* ys, int count,...
function PlotLineG (line 1638) | void PlotLineG(const char* label_id, ImPlotGetter getter_func, void* dat...
function PlotScatterEx (line 1648) | void PlotScatterEx(const char* label_id, const Getter& getter, ImPlotSca...
function PlotScatter (line 1670) | void PlotScatter(const char* label_id, const T* values, int count, doubl...
function PlotScatter (line 1676) | void PlotScatter(const char* label_id, const T* xs, const T* ys, int cou...
function PlotScatterG (line 1688) | void PlotScatterG(const char* label_id, ImPlotGetter getter_func, void* ...
function PlotStairsEx (line 1698) | void PlotStairsEx(const char* label_id, const Getter& getter, ImPlotStai...
function PlotStairs (line 1734) | void PlotStairs(const char* label_id, const T* values, int count, double...
function PlotStairs (line 1740) | void PlotStairs(const char* label_id, const T* xs, const T* ys, int coun...
function PlotStairsG (line 1752) | void PlotStairsG(const char* label_id, ImPlotGetter getter_func, void* d...
function PlotShadedEx (line 1762) | void PlotShadedEx(const char* label_id, const Getter1& getter1, const Ge...
function PlotShaded (line 1778) | void PlotShaded(const char* label_id, const T* values, int count, double...
function PlotShaded (line 1789) | void PlotShaded(const char* label_id, const T* xs, const T* ys, int coun...
function PlotShaded (line 1801) | void PlotShaded(const char* label_id, const T* xs, const T* ys1, const T...
function PlotShadedG (line 1815) | void PlotShadedG(const char* label_id, ImPlotGetter getter_func1, void* ...
function PlotBarsVEx (line 1826) | void PlotBarsVEx(const char* label_id, const Getter1& getter1, const Get...
function PlotBarsHEx (line 1850) | void PlotBarsHEx(const char* label_id, const Getter1& getter1, const Get...
function PlotBars (line 1874) | void PlotBars(const char* label_id, const T* values, int count, double b...
function PlotBars (line 1888) | void PlotBars(const char* label_id, const T* xs, const T* ys, int count,...
function PlotBarsG (line 1907) | void PlotBarsG(const char* label_id, ImPlotGetter getter_func, void* dat...
function PlotBarGroups (line 1925) | void PlotBarGroups(const char* const label_ids[], const T* values, int i...
function PlotErrorBarsVEx (line 2010) | void PlotErrorBarsVEx(const char* label_id, const _GetterPos& getter_pos...
function PlotErrorBarsHEx (line 2035) | void PlotErrorBarsHEx(const char* label_id, const _GetterPos& getter_pos...
function PlotErrorBars (line 2060) | void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const...
function PlotErrorBars (line 2065) | void PlotErrorBars(const char* label_id, const T* xs, const T* ys, const...
function PlotStemsEx (line 2098) | void PlotStemsEx(const char* label_id, const _GetterM& getter_mark, cons...
function PlotStems (line 2123) | void PlotStems(const char* label_id, const T* values, int count, double ...
function PlotStems (line 2137) | void PlotStems(const char* label_id, const T* xs, const T* ys, int count...
function PlotInfLines (line 2162) | void PlotInfLines(const char* label_id, const T* values, int count, ImPl...
function IMPLOT_INLINE (line 2203) | IMPLOT_INLINE void RenderPieSlice(ImDrawList& draw_list, const ImPlotPoi...
function PieChartSum (line 2255) | double PieChartSum(const T* values, int count, bool ignore_hidden) {
function PlotPieChartEx (line 2280) | void PlotPieChartEx(const char* const label_ids[], const T* values, int ...
function PieChartFormatter (line 2317) | int PieChartFormatter(double value, char* buff, int size, void* data) {
function PlotPieChart (line 2323) | void PlotPieChart(const char* const label_ids[], const T* values, int co...
function PlotPieChart (line 2331) | void PlotPieChart(const char* const label_ids[], const T* values, int co...
type GetterHeatmapRowMaj (line 2380) | struct GetterHeatmapRowMaj {
method GetterHeatmapRowMaj (line 2381) | GetterHeatmapRowMaj(const T* values, int rows, int cols, double scale_...
method IMPLOT_INLINE (line 2395) | IMPLOT
Condensed preview — 60 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,180K chars).
[
{
"path": ".gitignore",
"chars": 23,
"preview": "Binaries/\nIntermediate/"
},
{
"path": "ImGui.uplugin",
"chars": 339,
"preview": "{\n\t\"FileVersion\": 3,\n\t\"Version\": 3,\n\t\"VersionName\": \"1.3\",\n\t\"FriendlyName\": \"ImGui\",\n\t\"Description\": \"\",\n\t\"Category\": \""
},
{
"path": "LICENSE",
"chars": 1068,
"preview": "MIT License\n\nCopyright (c) 2023 Ves Georgiev\n\nPermission is hereby granted, free of charge, to any person obtaining a co"
},
{
"path": "README.md",
"chars": 3831,
"preview": "# ImGui for Unreal Engine\n\nSupercharge your Unreal Engine development with [Dear ImGui](https://github.com/ocornut/imgui"
},
{
"path": "Source/ImGui/ImGui.Build.cs",
"chars": 1275,
"preview": "using UnrealBuildTool;\n\npublic class ImGui : ModuleRules\n{\n\tprotected virtual bool WithImPlot => true;\n\tprotected virtu"
},
{
"path": "Source/ImGui/Private/ImGuiConfig.cpp",
"chars": 14836,
"preview": "#include \"ImGuiConfig.h\"\n\n#ifndef IMGUI_DISABLE\n\n#include <InputCoreTypes.h>\n#include <Framework/Commands/InputChord.h>\n"
},
{
"path": "Source/ImGui/Private/ImGuiContext.cpp",
"chars": 20804,
"preview": "#include \"ImGuiContext.h\"\n\n#ifndef IMGUI_DISABLE\n\n#include <Framework/Application/SlateApplication.h>\n#include <HAL/LowL"
},
{
"path": "Source/ImGui/Private/ImGuiModule.cpp",
"chars": 5206,
"preview": "#include \"ImGuiModule.h\"\n\n#ifndef IMGUI_DISABLE\n\n#include <Widgets/SWindow.h>\n\n#if WITH_ENGINE\n#include <Engine/Engine."
},
{
"path": "Source/ImGui/Private/SImGuiOverlay.cpp",
"chars": 12734,
"preview": "#include \"SImGuiOverlay.h\"\n\n#ifndef IMGUI_DISABLE\n\n#include <Framework/Application/SlateApplication.h>\n\n#include \"ImGui"
},
{
"path": "Source/ImGui/Private/SImGuiOverlay.h",
"chars": 1855,
"preview": "#pragma once\n\n#ifndef IMGUI_DISABLE\n\n#include <Framework/Application/IInputProcessor.h>\n#include <Widgets/SLeafWidget.h"
},
{
"path": "Source/ImGui/Private/SImGuiWindow.cpp",
"chars": 2318,
"preview": "#include \"SImGuiWindow.h\"\n\n#ifndef IMGUI_DISABLE\n\nTHIRD_PARTY_INCLUDES_START\n#include <imgui.h>\nTHIRD_PARTY_INCLUDES_END"
},
{
"path": "Source/ImGui/Private/SImGuiWindow.h",
"chars": 438,
"preview": "#pragma once\n\n#ifndef IMGUI_DISABLE\n\n#include <Widgets/SWindow.h>\n\nstruct ImGuiViewport;\n\nclass SImGuiWindow : public SW"
},
{
"path": "Source/ImGui/Public/ImGuiConfig.h",
"chars": 4415,
"preview": "#pragma once\n\n#ifndef IMGUI_DISABLE\n\n#include <Math/Color.h>\n#include <Math/IntPoint.h>\n#include <Math/IntVector.h>\n#in"
},
{
"path": "Source/ImGui/Public/ImGuiConfig.inl",
"chars": 507,
"preview": "#pragma once\n\n#ifndef IMGUI_DISABLE\n\nnamespace ImGui\n{\n\t/// Converts ImGui 32-bit color to UE color\n\tIMGUI_API FORCEINLI"
},
{
"path": "Source/ImGui/Public/ImGuiContext.h",
"chars": 2066,
"preview": "#pragma once\n\n#ifndef IMGUI_DISABLE\n\n#include <Templates/SharedPointer.h>\n\n#if WITH_ENGINE\n#include <Engine/Texture2D.h>"
},
{
"path": "Source/ImGui/Public/ImGuiModule.h",
"chars": 1410,
"preview": "#pragma once\n\n#ifndef IMGUI_DISABLE\n\n#include <Misc/EngineVersionComparison.h>\n#include <Modules/ModuleManager.h>\n\nclas"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/ImGuiLibrary.Build.cs",
"chars": 216,
"preview": "using UnrealBuildTool;\n\npublic class ImGuiLibrary : ModuleRules\n{\n\tpublic ImGuiLibrary(ReadOnlyTargetRules Target) : bas"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/LICENSE.txt",
"chars": 1083,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2014-2026 Omar Cornut\n\nPermission is hereby granted, free of charge, to any person "
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imconfig.h",
"chars": 12173,
"preview": "//-----------------------------------------------------------------------------\n// DEAR IMGUI COMPILE-TIME OPTIONS\n// Ru"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui.cpp",
"chars": 1265848,
"preview": "// dear imgui, v1.92.6\n// (main code and documentation)\n\n// Help:\n// - Call and read ImGui::ShowDemoWindow() in imgui_de"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui.h",
"chars": 453758,
"preview": "// dear imgui, v1.92.6\n// (headers)\n\n// Help:\n// - Call and read ImGui::ShowDemoWindow() in imgui_demo.cpp. All applicat"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui.natstepfilter",
"chars": 1419,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\n.natstepfilter file for Visual Studio debugger.\nPurpose: instruct debugger t"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui.natvis",
"chars": 2117,
"preview": "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<!--\n.natvis file for Visual Studio debugger.\nPurpose: provide nicer views on dat"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui_demo.cpp",
"chars": 594120,
"preview": "// dear imgui, v1.92.6\n// (demo code)\n\n// Help:\n// - Read FAQ at http://dearimgui.com/faq\n// - Call and read ImGui::Show"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui_draw.cpp",
"chars": 378375,
"preview": "// dear imgui, v1.92.6\n// (drawing and font code)\n\n/*\n\nIndex of this file:\n\n// [SECTION] STB libraries implementation\n//"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui_internal.h",
"chars": 327198,
"preview": "// dear imgui, v1.92.6\n// (internal structures/api)\n\n// You may use this file to debug, understand or extend Dear ImGui "
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui_tables.cpp",
"chars": 251334,
"preview": "// dear imgui, v1.92.6\n// (tables and columns code)\n\n/*\n\nIndex of this file:\n\n// [SECTION] Commentary\n// [SECTION] Heade"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imgui_widgets.cpp",
"chars": 546940,
"preview": "// dear imgui, v1.92.6\n// (widgets code)\n\n/*\n\nIndex of this file:\n\n// [SECTION] Forward Declarations\n// [SECTION] Widget"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imstb_rectpack.h",
"chars": 20344,
"preview": "// [DEAR IMGUI]\n// This is a slightly modified version of stb_rect_pack.h 1.01.\n// Grep for [DEAR IMGUI] to find the cha"
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imstb_textedit.h",
"chars": 60111,
"preview": "// [DEAR IMGUI]\n// This is a slightly modified version of stb_textedit.h 1.14.\n// Those changes would need to be pushed "
},
{
"path": "Source/ThirdParty/ImGuiLibrary/imstb_truetype.h",
"chars": 199503,
"preview": "// [DEAR IMGUI]\n// This is a slightly modified version of stb_truetype.h 1.26.\n// Mostly fixing for compiler and static "
},
{
"path": "Source/ThirdParty/ImPlotLibrary/ImPlotLibrary.Build.cs",
"chars": 218,
"preview": "using UnrealBuildTool;\n\npublic class ImPlotLibrary : ModuleRules\n{\n\tpublic ImPlotLibrary(ReadOnlyTargetRules Target) : b"
},
{
"path": "Source/ThirdParty/ImPlotLibrary/LICENSE",
"chars": 1068,
"preview": "MIT License\n\nCopyright (c) 2020 Evan Pezent\n\nPermission is hereby granted, free of charge, to any person obtaining a cop"
},
{
"path": "Source/ThirdParty/ImPlotLibrary/implot.cpp",
"chars": 274509,
"preview": "// MIT License\n\n// Copyright (c) 2023 Evan Pezent\n\n// Permission is hereby granted, free of charge, to any person obtain"
},
{
"path": "Source/ThirdParty/ImPlotLibrary/implot.h",
"chars": 80226,
"preview": "// MIT License\n\n// Copyright (c) 2023 Evan Pezent\n\n// Permission is hereby granted, free of charge, to any person obtain"
},
{
"path": "Source/ThirdParty/ImPlotLibrary/implot_demo.cpp",
"chars": 114731,
"preview": "// MIT License\n\n// Copyright (c) 2023 Evan Pezent\n\n// Permission is hereby granted, free of charge, to any person obtain"
},
{
"path": "Source/ThirdParty/ImPlotLibrary/implot_internal.h",
"chars": 68473,
"preview": "// MIT License\n\n// Copyright (c) 2023 Evan Pezent\n\n// Permission is hereby granted, free of charge, to any person obtain"
},
{
"path": "Source/ThirdParty/ImPlotLibrary/implot_items.cpp",
"chars": 124866,
"preview": "// MIT License\n\n// Copyright (c) 2023 Evan Pezent\n\n// Permission is hereby granted, free of charge, to any person obtain"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/LICENSE.txt",
"chars": 1092,
"preview": "MIT License\n\nCopyright (c) 2021 Sammy Fatnassi (Github: @Sammyfreg)\n\nPermission is hereby granted, free of charge, to an"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/NetImGuiLibrary.Build.cs",
"chars": 269,
"preview": "using UnrealBuildTool;\n\npublic class NetImGuiLibrary : ModuleRules\n{\n\tpublic NetImGuiLibrary(ReadOnlyTargetRules Target)"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/NetImgui_Api.h",
"chars": 17085,
"preview": "#pragma once\n\n//=================================================================================================\n//! @N"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/NetImgui_Config.h",
"chars": 2941,
"preview": "#pragma once\n\n//=================================================================================================\n// Ena"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_Api.cpp",
"chars": 34831,
"preview": "#include \"NetImgui_Shared.h\"\n#include \"NetImgui_WarningDisable.h\"\n\n#if NETIMGUI_ENABLED\n#include <algorithm>\n#include <t"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_Client.cpp",
"chars": 39288,
"preview": "#include \"NetImgui_Shared.h\"\n\n#if NETIMGUI_ENABLED\n#include \"NetImgui_WarningDisable.h\"\n#include \"NetImgui_Client.h\"\n#in"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_Client.h",
"chars": 10214,
"preview": "#pragma once\n\n#include \"NetImgui_Shared.h\"\n#include \"NetImgui_CmdPackets.h\"\n#include <mutex>\n\n//========================"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_Client.inl",
"chars": 546,
"preview": "\n#include \"NetImgui_Network.h\"\n\nnamespace NetImgui { namespace Internal { namespace Client {\n\nbool ClientInfo::IsConnect"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_CmdPackets.h",
"chars": 15341,
"preview": "#pragma once\n\n#include \"NetImgui_Shared.h\"\n#include \"NetImgui_CmdPackets_DrawFrame.h\"\n\nnamespace NetImgui { namespace In"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_CmdPackets.inl",
"chars": 2362,
"preview": "#include \"NetImgui_CmdPackets.h\"\n\nnamespace NetImgui { namespace Internal\n{\n\nvoid CmdDrawFrame::ToPointers()\n{\n\tif( !mpD"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_CmdPackets_DrawFrame.cpp",
"chars": 20708,
"preview": "#include \"NetImgui_Shared.h\"\n\n#if NETIMGUI_ENABLED\n#include \"NetImgui_WarningDisable.h\"\n#include \"NetImgui_CmdPackets.h\""
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_CmdPackets_DrawFrame.h",
"chars": 1969,
"preview": "#pragma once\n\n#include \"NetImgui_Shared.h\"\n\nnamespace NetImgui { namespace Internal\n{\n\nstruct ImguiVert\n{\n\t//Note: If up"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_Network.h",
"chars": 1075,
"preview": "#pragma once\n\nnamespace NetImgui { namespace Internal { struct PendingCom; }}\n\nnamespace NetImgui { namespace Internal {"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_NetworkPosix.cpp",
"chars": 14051,
"preview": "#include \"NetImgui_Shared.h\"\n\n#if defined(_MSC_VER) \n#pragma warning (disable: 4221)\t\t\n#endif\n\n#if NETIMGUI_ENABLED && N"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_NetworkUE4.cpp",
"chars": 8397,
"preview": "#include \"NetImgui_Shared.h\"\n\n// Tested with Unreal Engine 4.27, 5.3, 5.4, 5.5\n\n#if NETIMGUI_ENABLED && defined(__UNREAL"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_NetworkWin32.cpp",
"chars": 9035,
"preview": "#include \"NetImgui_Shared.h\"\n\n#if NETIMGUI_ENABLED && NETIMGUI_WINSOCKET_ENABLED\n#include \"NetImgui_WarningDisableStd.h\""
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_Shared.h",
"chars": 6665,
"preview": "#pragma once\n\n//=================================================================================================\n// Inc"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_Shared.inl",
"chars": 8700,
"preview": "#pragma once\n\n#include <assert.h>\n#include <string.h>\n\nnamespace NetImgui { namespace Internal\n{\n\ntemplate <typename TTy"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_WarningDisable.h",
"chars": 2322,
"preview": "#pragma once\n//\n// Deactivate a few warnings to allow internal netImgui code to compile \n// with 'Warning as error' and "
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_WarningDisableImgui.h",
"chars": 2003,
"preview": "#pragma once\n//\n// Deactivate a few warnings to allow Imgui header includes, \n// without generating warnings in '-Wall'"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_WarningDisableStd.h",
"chars": 1267,
"preview": "#pragma once\n//\n// Deactivate a few more warnings to allow standard header includes,\n// without generating warnings in '"
},
{
"path": "Source/ThirdParty/NetImGuiLibrary/Private/NetImgui_WarningReenable.h",
"chars": 561,
"preview": "\n#pragma once\n\n//=================================================================================================\n// Cl"
}
]
About this extraction
This page contains the full source code of the VesCodes/ImGui GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 60 files (4.8 MB), approximately 1.3M tokens, and a symbol index with 2240 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.