@Net-Ninja It already has it for quite a bit of time - (BeginDragDropSource, SetDragDropPayload, EndDragDropSource, BeginDragDropTarget, AcceptDragDropPayload and EndDragDropTarget - are the functions under ImGui namespace you want to look at). Previously I had to simulate those functions on my own. I'm using them to simulate drag & drop models into the scene, and also to drag & drop nodes within scenegraph.
@Repixel And editor UI with ImGui for a game engine can look F.e. like this:
Fig. 01 - Editor of my own game engine
Of course it does support majority of features lots of other engines do (in-editor play/pause/stop of the scene, load/save of the scene, undo/redo, various components (note that actual components can be added on-demand)).
The editor is just a project under the engine (although directly outputting executable file, it could technically be just a dll - as all of the projects do have same interface used for starting ... similar situation is for the components, while those I'm using are directly in engine core, you can add custom components as dlls as long as they follow the same interface), the runtime viewer is another project under the same engine (again outputting executable file directly).
The same engine (and editor!) was used to build scene for small competition game here on GameDev.net - GROOM (shameless self-promotion):
Fig. 02 - GROOM, a simple game built with this engine
The game actually uses completely different renderer (instead of Direct3D 12 based one, it uses a custom real time path tracer written in OpenCL), different windowing system (it uses SOIL instead of native windows like the Editor uses). The rest is technically the same - scene management, resource loaders, physics & collision system, etc. Actually I have used the editor to put together the scene and set up components for each of the objects you can see in GROOM.
EDIT: To demonstrate how actual engine, runtime or even GROOM looks like in terms of source (I tried to keep this short):
class Main : public Engine::System
// Attributes for the application
// Engine system constructor
Main(Engine::Log* log, Engine::Constants* options) : Engine::System("Main")
// Here we allocate everything we're going to need (resource managers, some subsystems like renderer, physics, etc.)
// Engine system destructor
// Here we deallocate everything we have allocated (destroy resource managers, de-init subsystems like renderer, physics, etc.)
// Scene, subsystems, etc. initialization
virtual bool Init()
// For case of GROOM - here we load resources into managers, set up scenes, etc.
// Scene, subsystems, etc. deinitialization
virtual void Shutdown()
// For case of GROOM - here goes resource deinitialization, etc.
// System update function
virtual void Update()
// For case of GROOM - here goes actual game loop for given scene (there are 2 scenes - one for main menu, one for actual game level)
// The actual loop here calls BVHs update and render, apart from actual game logic step
// System event handlers
void Handle(const Engine::Keyboard::KeyPressed& kp)
// Handle key pressed event
// Other event handlers here
Now the actual application running this can be for example this (the most simple):
Engine::Log* log = new Engine::Log();
log->AddOutput(new std::ofstream("Output.log"), Engine::Log::LOG_DEFAULT);
Engine::Constants* options = new Engine::Constants(log, "Config.conf");
Engine::Input* input = new Engine::Input();
Main* m = new Main(log, options);
// Add other subsystems
EDIT 2: Sorry for long post.