I have returned!

data/actors.lua

@@ -1,26 +1,23 @@
 return {
     hero = {                            -- actor id 
         name = "Hero",                  -- default name of the actor
-        player_controlled = true,       -- wether it is controlled by the player
         health = "6",                   -- starting & max health
         strength = "2",                 -- strength
         glyph_id = '@',                 -- sprite id for the glyph, chars gets converted to ints
-        glyph_color = {.1, .4, .9, 1},  -- color tint for the glyph
+        glyph_color = {0.1, 0.4, 0.9, 1.0},  -- color tint for the glyph
     },
     goblin = {
         name = "Goblin",
-        player_controlled = false,
         health = "4",
         strength = "1",
         glyph_id = 'g',
-        glyph_color = {.1, .7, .2, 1},
+        glyph_color = {0.1, 0.7, 0.2, 1.0},
     },
     shaman = {
         name = "Shaman",
-        player_controlled = false,
         health = "2",
         strength = "1",
         glyph_id = 'g',
-        glyph_color = {.1, .7, .5, 1},
+        glyph_color = {0.1, 0.7, 0.5, 1.0},
     },
 }

data/init.lua

@@ -0,0 +1,4 @@
+util = require("data.util")
+
+dungeon.add_actors(require("data.actors"))
+dungeon.add_tiles(require("data.tiles"))

data/tiles.lua

@@ -1,18 +1,28 @@
 local tiles = {
     dungeon_wall = {
         glyph = '#', -- texture id for the tile, usually ascii
-        fg = {.1,.1,.3,1}, -- what color to tint the tile with, {R,G,B,A}
+        fg = {0.1,0.1,0.3,1.0}, -- what color to tint the tile with, {R,G,B,A}
-        bg = {.6,.6,.9,1}, -- what color to paint the rect behind the tile
+        bg = {0.6,0.6,0.9,1.0}, -- what color to paint the rect behind the tile
         passable = false, -- wether entities can pass through the tile
         opaque = true, -- wether actors can see through the tile
         wall = true, -- wether we should render the tile as a wall (only used in generation yet)
         description = "A stone wall", -- description for the tile
-        tags = { "dungeon", "stone", "wall" } -- tags that help generators find the tile
+        tags = { "dungeon", "stone", "wall" } -- tags that help map generators find the tile
+    },
+    dungeon_wall_alt = {
+        glyph = '#',
+        fg = {0.01,0.01,0.1,1.0},
+        bg = {0.4,0.4,0.8,1.0},
+        passable = false, 
+        opaque = true, 
+        wall = true, 
+        description = "A stone wall", 
+        tags = { "dungeon", "stone", "wall" } 
     },
     dungeon_door = {
         glyph = '+',
-        fg = {.1,.05,.05,1},
+        fg = {0.1,0.05,0.05,1.0},
-        bg = {.4,.2,.1,1},
+        bg = {0.4,0.2,0.1,1.0},
         passable = true,
         opaque = true,
         wall = true,
@@ -21,8 +31,18 @@ local tiles = {
     },
     dungeon_floor = {
         glyph = '.',
-        fg = {.8,.8,1,1},
+        fg = {0.8,0.8,1.0,1.0},
-        bg = {.1,.1,.2,1},
+        bg = {0.1,0.1,0.2,1.0},
+        passable = true,
+        opaque = false,
+        wall = false,
+        description = "A stone floor",
+        tags = { "dungeon", "stone", "floor" }
+    },
+    dungeon_floor_alt = {
+        glyph = '.',
+        fg = {0.6,0.6,0.9,1.0},
+        bg = {0.1,0.1,0.2,1.0},
         passable = true,
         opaque = false,
         wall = false,
@@ -31,8 +51,8 @@ local tiles = {
     },
     dungeon_entrance = {
         glyph = '>',
-        fg = {.8,.8,1,1},
+        fg = {0.8,0.8,1.0,1.0},
-        bg = {.1,.1,.2,1},
+        bg = {0.1,0.1,0.2,1.0},
         passable = true,
         opaque = false,
         wall = false,
@@ -41,8 +61,8 @@ local tiles = {
     },
     dungeon_exit = {
         glyph = '<',
-        fg = {.8,.8,1,1},
+        fg = {0.8,0.8,1.0,1.0},
-        bg = {.1,.1,.2,1},
+        bg = {0.1,0.1,0.2,1.0},
         passable = true,
         opaque = false,
         wall = false,
@@ -56,8 +76,8 @@ local dijkstra_debug_amount = 100
 for i=1,dijkstra_debug_amount do
     local debugtile = {
         glyph = tostring(math.floor(i/10)),
-        bg = {0,0,0,1},
+        bg = {0.0,0.0,0.0,1.0},
-        fg = {i/dijkstra_debug_amount,1-i/dijkstra_debug_amount,0,1},
+        fg = {i/dijkstra_debug_amount,1-i/dijkstra_debug_amount,0.0,1.0},
         passable = true,
         opaque = false,
         wall = false,

data/util.lua

@@ -0,0 +1,50 @@
+local util = {}
+
+function util.deepcopy(orig)
+    local orig_type = type(orig)
+    local copy
+    if orig_type == 'table' then
+        copy = {}
+        for orig_key, orig_value in next, orig, nil do
+            copy[deepcopy(orig_key)] = deepcopy(orig_value)
+        end
+        setmetatable(copy, deepcopy(getmetatable(orig)))
+    else -- number, string, boolean, etc
+        copy = orig
+    end
+    return copy
+end
+
+function util.merge(bot, top)
+    local p_type = type(parent)
+    local c_type = type(child)
+    assert(p_type == 'table', 'expected table, found '..p_type..' instead.')
+    assert(c_type == 'table', 'expected table, found '..c_type..' instead.')
+
+    for k,v in pairs(top) do
+        if type(k) == 'number' and type(bot[1]) ~= nil and type(top[1]) ~= nil then
+            table.insert(bot, v)
+        elseif type(v) == 'table' then 
+            if type(bot[k]) == 'table' then
+                merge(bot[k], v)
+            else
+                bot[k] = v
+            end
+        else
+            bot[k] = v
+        end
+    end
+end
+
+function util.inherit(parent, child)
+    local p_type = type(parent)
+    local c_type = type(child)
+    assert(p_type == 'table', 'expected table, found '..p_type..' instead.')
+    assert(c_type == 'table', 'expected table, found '..c_type..' instead.')
+
+    local result = util.deepcopy(parent)
+
+    merge(result, child)
+
+    return result
+end

dungeon.vcxproj

@@ -116,6 +116,7 @@
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="src\LuaHandler.cpp" />
     <ClCompile Include="src\Shader.cpp" />
     <ClCompile Include="src\Actor.cpp" />
     <ClCompile Include="src\App.cpp" />
@@ -160,6 +161,8 @@
     <ClCompile Include="src\TileSet.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="src\Item.h" />
+    <ClInclude Include="src\LuaHandler.h" />
     <ClInclude Include="src\Shader.h" />
     <ClInclude Include="src\Actor.h" />
     <ClInclude Include="src\App.h" />

dungeon.vcxproj.filters

@@ -141,6 +141,9 @@
     <ClCompile Include="src\TileSet.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\LuaHandler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\Actor.h">
@@ -293,5 +296,11 @@
     <ClInclude Include="src\TileSet.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\Item.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="src\LuaHandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

src/Actor.cpp

@@ -35,6 +35,7 @@ void Actor::update(Tilemap* map) {
 
 void Actor::damage(int str) {
   health -= str;
+  healcounter = 4;
   if (health <= 0) {
     kill();
   }
@@ -65,6 +66,7 @@ void Actor::attack(vec2i dpos, Tilemap* map) {
 
 void Actor::heal(int amount) {
   health += amount;
+  healcounter = 4;
   if (health > health_max) {
     health = health_max;
   }

src/App.cpp

@@ -13,13 +13,14 @@
 #include "Input.h"
 #include "Gamestate.h"
 #include "PlayState.h"
+#include "LuaHandler.h"
 
 Uint64 perfFreq;
 double currTime() {
   return SDL_GetPerformanceCounter() / (double)perfFreq;
 }
 
-struct {
+struct Config {
   struct {
     bool fullscreen = false;
     int width = 792;

src/Input.h

@@ -17,6 +17,8 @@ enum InputAction {
   ACTION_MOVE_SOUTH,
   ACTION_MOVE_SOUTHWEST,
   ACTION_MOVE_SOUTHEAST,
+  ACTION_MOVE_DOWN,
+  ACTION_MOVE_UP,
   ACTION_WAIT,
   INPUTACTION_END // Used to get the length of the enum. Must be the final entry.
 };

src/Item.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Actor.h"
+
+class Item : Entity {
+  Item() {};
+public:
+  virtual bool consume(Actor& consumer) = 0;
+  virtual bool equip(Actor& equipper) = 0;
+  virtual bool unequip(Actor& equipper) = 0;
+  virtual bool can_consume(Actor& consumer) = 0;
+  virtual bool can_equip(Actor& equipper) = 0;
+  virtual ~Item() {};
+};
+

src/LuaHandler.cpp

@@ -0,0 +1,74 @@
+#include "LuaHandler.h"
+
+const char* DUNGEON_LUA_NAMESPACE = "dungeon";
+
+LuaHandler::LuaHandler() {}
+
+LuaHandler::~LuaHandler() {
+  
+}
+
+void LuaHandler::add_tile(TileSet* tileset, std::string name, kaguya::LuaTable act) {
+  Tile t;
+  if (act["glyph"].type() == LUA_TSTRING) {
+    std::string s = act["glyph"];
+    t.glyph = s.at(0);
+  }
+  if (act["fg"].type() == LUA_TTABLE) {
+    auto fg = act["fg"];
+    t.fg.r = fg[1];
+    t.fg.g = fg[2];
+    t.fg.b = fg[3];
+    t.fg.a = fg[4];
+  }
+  if (act["bg"].type() == LUA_TTABLE) {
+    auto bg = act["bg"];
+    t.bg.r = bg[1];
+    t.bg.g = bg[2];
+    t.bg.b = bg[3];
+    t.bg.a = bg[4];
+  }
+  if (act["passable"].type() == LUA_TBOOLEAN) {
+    t.passable = act["passable"];
+  }
+  if (act["opaque"].type() == LUA_TBOOLEAN) {
+    t.opaque = act["opaque"];
+  }
+  if (act["wall"].type() == LUA_TBOOLEAN) {
+    t.wall = act["wall"];
+  }
+  if (act["tags"].type() == LUA_TTABLE) {
+    for (std::string tag : act["tags"].values()) {
+      t.tags.emplace_back(tag);
+    }
+  }
+  tileset->add_tile(name, t);
+}
+
+void LuaHandler::load_module(std::string name, TileSet* tileset) {
+  lua[DUNGEON_LUA_NAMESPACE] = kaguya::NewTable();
+  
+
+
+  lua[DUNGEON_LUA_NAMESPACE]["add_actor"] = kaguya::function([](std::string name, kaguya::LuaTable act) {
+
+  });
+
+  lua[DUNGEON_LUA_NAMESPACE]["add_actors"] = kaguya::function([](kaguya::LuaTable actors) {
+    for (auto pair : actors.map()) {
+      
+    }
+  });
+
+  lua[DUNGEON_LUA_NAMESPACE]["add_tile"] = kaguya::function([tileset](std::string name, kaguya::LuaTable tile) {
+    add_tile(tileset, name, tile);
+  });
+
+  lua[DUNGEON_LUA_NAMESPACE]["add_tiles"] = kaguya::function([tileset](kaguya::LuaTable tiles) {
+    for (auto pair : tiles.map()) {
+      add_tile(tileset, pair.first, pair.second);
+    }
+  });
+
+  lua.dofile(name + "/init.lua");
+}

src/LuaHandler.h

@@ -0,0 +1,14 @@
+#pragma once
+#include <string>
+#include <kaguya/kaguya.hpp>
+#include "TileSet.h"
+
+class LuaHandler {
+public:
+  LuaHandler();
+  ~LuaHandler();
+  void load_module(std::string name, TileSet* tileset);
+  static void LuaHandler::add_tile(TileSet* tileset, std::string name, kaguya::LuaTable act);
+private:
+  kaguya::State lua;
+};

src/Mapgen.cpp

@@ -64,14 +64,18 @@ void maze_fill(Tilemap& map, int x, int y, std::string wall, std::string floor,
 
 }
 
-Tilemap generate_dungeon(int width, int height, TileSet tileset) {
+Tilemap generate_dungeon(int width, int height, TileSet& tileset) {
   return generate_dungeon(Rng::get_random_seed(), width, height, tileset);
 }
 
-Tilemap generate_dungeon(unsigned int seed, int width, int height, TileSet tileset) {
+Tilemap generate_dungeon(unsigned int seed, int width, int height, TileSet& tileset) {
   Rng rng = Rng(seed);
 
-  Tilemap map = Tilemap(tileset, width, height);
+  Tilemap map = Tilemap(tileset, width, height);
+
+#ifdef _DEBUG
+  assert(tileset.count() > 0);
+#endif
 
   std::vector<std::string> wall_tiles = tileset.find_tiles(false, true, true, { "dungeon", "wall" }, {});
   std::vector<std::string> floor_tiles = tileset.find_tiles(true, false, false, { "dungeon", "floor" }, {});

src/Mapgen.h

@@ -1,5 +1,5 @@
 #pragma once
 #include "Tilemap.h"
 
-Tilemap generate_dungeon(int width, int height, TileSet tileset);
+Tilemap generate_dungeon(int width, int height, TileSet& tileset);
-Tilemap generate_dungeon(unsigned int seed, int width, int height, TileSet tileset);
+Tilemap generate_dungeon(unsigned int seed, int width, int height, TileSet& tileset);

src/PlayState.cpp

@@ -16,25 +16,21 @@
 #include "Shaman.h"
 #include "Rng.h"
 #include "TileSet.h"
+#include "LuaHandler.h"
 #include <kaguya\kaguya.hpp>
 
 InputAction player_action;
 TileSet tileset;
+LuaHandler handler;
 
 void PlayState::load() {
   SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Creating ascii tileset...\n");
   ascii = new SpriteAtlas(app->renderer, "./assets/12x12.bmp", 192, 192, 12, 12);
   SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Created ascii tileset.\n");
 
-  app->input->bind_key(SDLK_ESCAPE, ACTION_ESCAPE_MENU);
+  handler.load_module("data", &tileset);
 
-  kaguya::State lua;
+  app->input->bind_key(SDLK_ESCAPE, ACTION_ESCAPE_MENU);
-  lua["tiles"] = kaguya::NewTable();
-  lua(R"LUA(
-actors = dofile('data/actors.lua')
-tiles = dofile('data/tiles.lua')
-)LUA");
-  tileset.load_from_table(lua.globalTable().getField("tiles"));
 
   // Movement: keypad
   app->input->bind_key(SDLK_KP_8, ACTION_MOVE_NORTH);
@@ -65,6 +61,7 @@ tiles = dofile('data/tiles.lua')
 
   // General
   app->input->bind_key(SDLK_PERIOD, ACTION_WAIT);
+  app->input->bind_key(SDLK_LESS, ACTION_MOVE_DOWN);
 
   // debug
   app->input->bind_key(SDLK_F1, ACTION_TOGGLE_DEBUG);
@@ -77,27 +74,29 @@ tiles = dofile('data/tiles.lua')
 void PlayState::new_game() {
   player_action = ACTION_NONE;
 
-  tilemap.delete_actors();
+  tilemap = nullptr;
   player_actor = nullptr;
 
   SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Creating tilemap...\n");
 
   Rng rng;
-  tilemap = generate_dungeon(48, 48, tileset);
+  world = World(rng.get_random_seed());
+  current_level = 0;
+  tilemap = &world.GetMap(current_level, tileset);
   vec2i heropos;
   Tile t;
   do {
-    heropos.x = rng.get_int(1, tilemap.get_width() - 1);
+    heropos.x = rng.get_int(1, tilemap->get_width() - 1);
-    heropos.y = rng.get_int(1, tilemap.get_width() - 1);
+    heropos.y = rng.get_int(1, tilemap->get_width() - 1);
-    t = tilemap.get_tile(heropos.x, heropos.y);
+    t = tilemap->get_tile(heropos.x, heropos.y);
   } while (!t.passable);
   SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Done.\n");
   SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Calculating initial FOV...\n");
-  fov = FieldOfView(&tilemap);
+  fov = FieldOfView(tilemap);
   SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Done.\n");
 
   current_entity_index = 0;
-  Actor* actor = tilemap.get_actor_list()->at(current_entity_index);
+  Actor* actor = tilemap->get_actor_list()->at(current_entity_index);
   is_player_turn = actor->player_controlled;
   if (is_player_turn) { 
     camera_pos = actor->get_position();
@@ -107,7 +106,7 @@ void PlayState::new_game() {
 
 Gamestate *PlayState::update(double delta) {
   while (!is_player_turn || player_action != ACTION_NONE) {
-    std::vector<Actor*>* actors = tilemap.get_actor_list();
+    std::vector<Actor*>* actors = tilemap->get_actor_list();
     Actor* actor = actors->at(current_entity_index);
 
     if (is_player_turn && actor->is_alive()) {
@@ -122,27 +121,46 @@ Gamestate *PlayState::update(double delta) {
         case ACTION_MOVE_SOUTHWEST: dir = {-1, 1}; break;
         case ACTION_MOVE_SOUTHEAST: dir = {1, 1}; break;
         case ACTION_WAIT: dir = {0, 0}; break;
+        case ACTION_MOVE_DOWN:
+        {
+          vec2i pos = actor->get_position();
+          
+          if (tilemap->get_tile(pos.x, pos.y).has_tag("exit")) {
+            current_level++;
+            tilemap = &world.GetMap(current_level, tileset);
+            return nullptr;
+          }
+          else {
+            return nullptr;
+          }
+          break;
+        }
         default: player_action = ACTION_NONE; SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Turn aborted: no player action.\n"); return nullptr; // abort turn
       }
       if (dir != vec2i(0,0)) {
-        if (!actor->move(dir.x, dir.y, &tilemap)) {
+        if (!actor->move(dir.x, dir.y, tilemap)) {
           vec2i heropos = actor->get_position();
-          Actor* act = tilemap.get_actor(heropos.x + dir.x, heropos.y + dir.y);
+          std::vector<Actor*> actors = tilemap->get_actors(heropos.x + dir.x, heropos.y + dir.y, 0);
-          if(act == nullptr) {
+          bool attacked = false;
+          for (Actor* act : actors) {
+            if (act->is_alive() && act->get_actor_faction() != actor->get_actor_faction()) {
+              actor->attack(act);
+              attacked = true;
+              break;
+            }
+          }
+          if(!attacked) {
             SDL_LogVerbose(SDL_LOG_CATEGORY_SYSTEM, "Turn aborted: invalid player action.\n");
             player_action = ACTION_NONE;
             return nullptr; // unable to move and nothing to attack == abort turn
           }
-          if (act->is_alive() && act->get_actor_faction() != actor->get_actor_faction()) {
-            actor->attack(act);
-          }
         }
       }
       vec2i pos = actor->get_position();
       fov.calc(pos, 6);
       camera_pos = pos;
     }
-    actor->update(&tilemap);
+    actor->update(tilemap);
 
     player_action = ACTION_NONE;
 
@@ -188,7 +206,7 @@ void PlayState::draw(double delta) {
     if (debug_actors) {
       ImGui::Begin("Actors", &debug_actors);
 
-      auto actors = tilemap.get_actor_list();
+      auto actors = tilemap->get_actor_list();
       const char* headers[] {
           "id", "name", "health", "strength"
       };
@@ -225,9 +243,9 @@ void PlayState::draw(double delta) {
       (tilesize.x/2-camera_pos.x),
       (tilesize.y/2- camera_pos.y),
   };
-  tilemap.draw(app->renderer, ascii, margin.x, margin.y, -offset.x, -offset.y, tilesize.x, tilesize.y, debug_disable_fov ? nullptr : &fov);
+  tilemap->draw(app->renderer, ascii, margin.x, margin.y, -offset.x, -offset.y, tilesize.x, tilesize.y, debug_disable_fov ? nullptr : &fov);
 
-  auto entities = tilemap.get_actor_list();
+  auto entities = tilemap->get_actor_list();
 
   const Color black = Color(0, 0, 0, 1);
 
@@ -253,7 +271,7 @@ void PlayState::draw(double delta) {
     
       int sprite = var->get_sprite_id();
       Color fg = var->get_sprite_color();
-      Color bg = tilemap.get_tile(pos.x, pos.y).bg;
+      Color bg = tilemap->get_tile(pos.x, pos.y).bg;
       app->renderer->draw_sprite(ascii->get_sprite(sprite), fg, bg, margin.x + (offset.x + pos.x) * asciisize.x, margin.y + (offset.y + pos.y) * asciisize.y);
     }
   }

src/PlayState.h

@@ -3,17 +3,20 @@
 #include "Gamestate.h"
 #include "Tilemap.h"
 #include "FieldOfView.h"
+#include "World.h"
 
 class SpriteAtlas;
 class Actor;
 
 class PlayState : public Gamestate {
   SpriteAtlas* ascii;
-  Tilemap tilemap;
+  World world;
+  Tilemap* tilemap;
   Actor * player_actor;
   FieldOfView fov;
   unsigned int current_entity_index;
   bool is_player_turn;
+  unsigned int current_level;
 
   vec2i camera_pos;
 

src/Renderer.cpp

@@ -86,7 +86,6 @@ Renderer::Renderer() {
   window = nullptr;
 }
 
-
 Renderer::~Renderer() {
   ImGui_ImplSdlGL3_Shutdown();
 
@@ -119,7 +118,7 @@ bool Renderer::Init(std::string title, int width, int height) {
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
 
-  window = SDL_CreateWindow(title.data(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL /* | SDL_WINDOW_RESIZABLE */);
+  window = SDL_CreateWindow(title.data(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
   if (window == NULL) {
     SDL_LogCritical(SDL_LOG_CATEGORY_RENDER,"Failed to create a window!\n");
     return false;
@@ -185,6 +184,18 @@ void Renderer::set_title(const char *title) {
 
 void Renderer::set_window_size(int width, int height) {
   SDL_SetWindowSize(window, width, height);
+  // temp fix for sprites looking ugly af with an odd window resolution
+  // but we're doing it after setting the actual window size, 
+  // to prevent the game from locking if it was just maximized
+  // TODO: Figure this out.
+  if (width % 2 == 1) {
+    width++;
+  }
+  if (height % 2 == 1) {
+    height++;
+  }
+
+  glViewport(0, 0, width, height);
 
   windowwidth = width;
   windowheight = height;
@@ -234,9 +245,11 @@ int Renderer::get_renderer_height() {
 bool Renderer::ImguiProcessEvents(SDL_Event *e) {
   return ImGui_ImplSdlGL3_ProcessEvent(e);
 }
+
 void Renderer::ImguiNewFrame() {
   ImGui_ImplSdlGL3_NewFrame(window);
 }
+
 Texture * Renderer::LoadTexture(std::string path) {
   auto it = textures.find(path);
   if (it == textures.end()) {
@@ -288,7 +301,6 @@ Texture * Renderer::LoadTexture(std::string path) {
   }
 }
 
-
 Sprite Renderer::CreateSprite(std::string path, int x, int y, int w, int h) {
   Sprite sprite;
   sprite.region.x = x;
@@ -314,7 +326,6 @@ Sprite Renderer::CreateSprite(std::string path, int x, int y, int w, int h) {
   return sprite;
 }
 
-
 void Renderer::draw_sprite(Sprite *sprite, Color fg, Color bg, int x, int y, float sx, float sy) {
 
   glm::mat4 model = glm::translate(glm::vec3(x, y, 0)) * glm::scale(glm::vec3(sprite->region.w * sx, sprite->region.h * sy, 1)) * glm::mat4(1);

src/TileSet.cpp

@@ -9,69 +9,8 @@ TileSet::TileSet() {}
 
 TileSet::~TileSet() {}
 
-void TileSet::load_from_table(kaguya::LuaStackRef table) {
+int TileSet::count() const {
-  for (std::string key : table.keys()) {
+  return tiles.size();
-    auto val = table[key];
-    Tile t;
-    if (val["glyph"].type() == LUA_TSTRING) {
-      std::string s = val["glyph"];
-      t.glyph = s.at(0);
-    }
-    else {
-      SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Missing value glyph for tile: %s", key.c_str());
-    }
-    if (val["fg"].type() == LUA_TTABLE) {
-      auto fg = val["fg"];
-      t.fg.r = fg[1];
-      t.fg.g = fg[2];
-      t.fg.b = fg[3];
-      t.fg.a = fg[4];
-    }
-    else {
-      SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Missing value fg for tile: %s", key.c_str());
-    }
-    if (val["bg"].type() == LUA_TTABLE) {
-      auto bg = val["bg"];
-      t.bg.r = bg[1];
-      t.bg.g = bg[2];
-      t.bg.b = bg[3];
-      t.bg.a = bg[4];
-    }
-    else {
-      SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Missing value bg for tile: %s", key.c_str());
-    }
-    if (val["passable"].type() == LUA_TBOOLEAN) {
-      t.passable = val["passable"];
-    }
-    else {
-      SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Missing value passable for tile: %s", key.c_str());
-    }
-    if (val["opaque"].type() == LUA_TBOOLEAN) {
-      t.opaque = val["opaque"];
-    }
-    else {
-      SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Missing value opaque for tile: %s", key.c_str());
-    }
-    if (val["wall"].type() == LUA_TBOOLEAN) {
-      t.wall = val["wall"];
-    }
-    else {
-      SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Missing value wall for tile: %s", key.c_str());
-    }
-    if (val["tags"].type() == LUA_TTABLE) {
-      for (std::string tag : val["tags"].values()) {
-        t.tags.emplace_back(tag);
-      }
-    }
-    else {
-      SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Missing value wall for tile: %s", key.c_str());
-    }
-    SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Added tile: %s", key.c_str());
-    tiles.insert_or_assign(key, t);
-    if (tiles.count(key) == 0) {
-      SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "Tileset: Could not find the tile we just added?!: %s", key.c_str());
-    }
-  }
 }
 
 void TileSet::add_tile(std::string name, Tile tile) {

src/TileSet.h

@@ -13,7 +13,7 @@ struct Tile {
   bool passable = false;
   bool opaque = false;
   bool wall = true;
-  std::string desc = "";
+  std::string desc = "?";
   std::vector<std::string> tags;
 
   bool has_tag(std::string tag) const {
@@ -31,7 +31,7 @@ class TileSet {
 public:
   TileSet();
   ~TileSet();
-  void load_from_table(kaguya::LuaStackRef table);
+  int count() const;
   void add_tile(std::string name, Tile tile);
   Tile const& get_tile(std::string name);
   std::vector<std::string> find_tiles(bool passable, bool opaque, bool wall, std::vector<std::string> include_tags = {}, std::vector<std::string> exclude_tags = {});

src/Tilemap.cpp

@@ -108,9 +108,10 @@ Actor * Tilemap::get_actor(int x, int y) {
   return nullptr;
 }
 
-std::vector<Actor*> Tilemap::get_actors(int x, int y, int range) {
+std::vector<Actor*> Tilemap::get_actors(int x, int y, int range = 0) {
   std::vector<Actor*> found;
   std::vector<vec2i> neigh = get_neighbours(x, y, range);
+  neigh.emplace_back(vec2i(x, y));
   for (Actor* ent : actors) {
     for (vec2i pos : neigh) {
       vec2i apos = ent->get_position();

src/World.cpp

@@ -1,48 +1,27 @@
 #include "World.h"
 #include <time.h>
 #include <cstdlib>
-
+#include "Mapgen.h"
-World::World() {
+#include "TileSet.h"
-  World(0);
-}
 
 World::World(unsigned int seed) {
   worldseed = seed;
-}
-
-void World::Init() {
-  if (seeds.size() != 0) {
-    return;
-  }
   srand(worldseed);
   rand(); rand(); rand();
   for (int i = 0; i < 10; i++) {
     seeds.push_back(rand());
-    maps.push_back(nullptr);
+    maps.push_back(Tilemap());
   }
 }
 
-Tilemap* World::GetMap(unsigned int level) {
+Tilemap& World::GetMap(unsigned int level, TileSet& tileset) {
-  if (level < seeds.size()) {
+  if (maps[level].get_height() > 1) {
-    if (maps[level] != nullptr) {
+    return maps[level];
-      return maps[level];
+  }
-    }
+  else {
-    else {
+    maps[level] = generate_dungeon(seeds[level], 64, 64, tileset);
-      Tilemap* map = new Tilemap(TileSet(),64, 64);
+    return maps[level];
-      // TODO: generate map
-      maps[level] = map;
-      return map;
-    }
   }
-  return nullptr;
 }
 
-World::~World() {
+World::~World() {}
-  seeds.clear();
-  for (Tilemap* map : maps) {
-    if (map != nullptr) {
-      delete map;
-    }
-  }
-  maps.clear();
-}

src/World.h

@@ -4,14 +4,12 @@
 
 class World {
 public:
-  World();
+  World(unsigned int seed = 0);
-  World(unsigned int seed);
+  Tilemap& GetMap(unsigned int level, TileSet& tileset);
-  void Init();
-  Tilemap* GetMap(unsigned int level); // returns null if invalid level or if not initialized
   ~World();
   
 private:
   int worldseed;
   std::vector<unsigned int> seeds;
-  std::vector<Tilemap*> maps;
+  std::vector<Tilemap> maps;
 };

src/imconfig.h

@@ -13,23 +13,27 @@
 //#define IMGUI_API __declspec( dllexport )
 //#define IMGUI_API __declspec( dllimport )
 
+//---- Don't define obsolete functions names. Consider enabling from time to time or when updating to reduce like hood of using already obsolete function/names
+//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+
 //---- Include imgui_user.h at the end of imgui.h
-#define IMGUI_INCLUDE_IMGUI_USER_H
+//#define IMGUI_INCLUDE_IMGUI_USER_H
 
 //---- Don't implement default handlers for Windows (so as not to link with OpenClipboard() and others Win32 functions)
-//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCS
+//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS
-//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCS
+//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS
 
-//---- Don't implement help and test window functionality (ShowUserGuide()/ShowStyleEditor()/ShowTestWindow() methods will be empty)
+//---- Don't implement demo windows functionality (ShowDemoWindow()/ShowStyleEditor()/ShowUserGuide() methods will be empty)
-//#define IMGUI_DISABLE_TEST_WINDOWS
+//---- It is very strongly recommended to NOT disable the demo windows. Please read the comment at the top of imgui_demo.cpp to learn why.
+//#define IMGUI_DISABLE_DEMO_WINDOWS
 
-//---- Don't define obsolete functions names
+//---- Don't implement ImFormatString(), ImFormatStringV() so you can reimplement them yourself.
-#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
+//#define IMGUI_DISABLE_FORMAT_STRING_FUNCTIONS
 
 //---- Pack colors to BGRA instead of RGBA (remove need to post process vertex buffer in back ends)
 //#define IMGUI_USE_BGRA_PACKED_COLOR
 
-//---- Implement STB libraries in a namespace to avoid conflicts
+//---- Implement STB libraries in a namespace to avoid linkage conflicts
 //#define IMGUI_STB_NAMESPACE     ImGuiStb
 
 //---- Define constructor and implicit cast operators to convert back<>forth from your math types and ImVec2/ImVec4.

src/imgui_internal.h

@@ -1,9 +1,10 @@
-// dear imgui, v1.50
+// dear imgui, v1.53
 // (internals)
 
 // You may use this file to debug, understand or extend ImGui features but we don't provide any guarantee of forward compatibility!
-// Implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
+// Set:
 //   #define IMGUI_DEFINE_MATH_OPERATORS
+// To implement maths operators for ImVec2 (disabled by default to not collide with using IM_VEC2_CLASS_EXTRA along with your own math types+operators)
 
 #pragma once
 
@@ -37,15 +38,16 @@ struct ImGuiGroupData;
 struct ImGuiSimpleColumns;
 struct ImGuiDrawContext;
 struct ImGuiTextEditState;
-struct ImGuiIniData;
 struct ImGuiMouseCursorData;
 struct ImGuiPopupRef;
 struct ImGuiWindow;
+struct ImGuiWindowSettings;
 
-typedef int ImGuiLayoutType;      // enum ImGuiLayoutType_
+typedef int ImGuiLayoutType;        // enum: horizontal or vertical             // enum ImGuiLayoutType_
-typedef int ImGuiButtonFlags;     // enum ImGuiButtonFlags_
+typedef int ImGuiButtonFlags;       // flags: for ButtonEx(), ButtonBehavior()  // enum ImGuiButtonFlags_
-typedef int ImGuiTreeNodeFlags;   // enum ImGuiTreeNodeFlags_
+typedef int ImGuiItemFlags;         // flags: for PushItemFlag()                // enum ImGuiItemFlags_
-typedef int ImGuiSliderFlags;     // enum ImGuiSliderFlags_
+typedef int ImGuiSeparatorFlags;    // flags: for Separator() - internal        // enum ImGuiSeparatorFlags_
+typedef int ImGuiSliderFlags;       // flags: for SliderBehavior()              // enum ImGuiSliderFlags_
 
 //-------------------------------------------------------------------------
 // STB libraries
@@ -75,9 +77,8 @@ extern IMGUI_API ImGuiContext* GImGui;  // Current implicit ImGui context pointe
 // Helpers
 //-----------------------------------------------------------------------------
 
-#define IM_ARRAYSIZE(_ARR)      ((int)(sizeof(_ARR)/sizeof(*_ARR)))
+#define IM_PI                       3.14159265358979323846f
-#define IM_PI                   3.14159265358979323846f
+#define IM_OFFSETOF(_TYPE,_ELM)     ((size_t)&(((_TYPE*)0)->_ELM))
-#define IM_OFFSETOF(_TYPE,_ELM) ((size_t)&(((_TYPE*)0)->_ELM))
 
 // Helpers: UTF-8 <> wchar
 IMGUI_API int           ImTextStrToUtf8(char* buf, int buf_size, const ImWchar* in_text, const ImWchar* in_text_end);      // return output UTF-8 bytes count
@@ -89,20 +90,28 @@ IMGUI_API int           ImTextCountUtf8BytesFromStr(const ImWchar* in_text, cons
 // Helpers: Misc
 IMGUI_API ImU32         ImHash(const void* data, int data_size, ImU32 seed = 0);    // Pass data_size==0 for zero-terminated strings
 IMGUI_API void*         ImFileLoadToMemory(const char* filename, const char* file_open_mode, int* out_file_size = NULL, int padding_bytes = 0);
-IMGUI_API FILE*         ImFileOpen(const char* filename, const char* file_open_mode);         
+IMGUI_API FILE*         ImFileOpen(const char* filename, const char* file_open_mode);
-IMGUI_API bool          ImIsPointInTriangle(const ImVec2& p, const ImVec2& a, const ImVec2& b, const ImVec2& c);
 static inline bool      ImCharIsSpace(int c)            { return c == ' ' || c == '\t' || c == 0x3000; }
+static inline bool      ImIsPowerOfTwo(int v)           { return v != 0 && (v & (v - 1)) == 0; }
 static inline int       ImUpperPowerOfTwo(int v)        { v--; v |= v >> 1; v |= v >> 2; v |= v >> 4; v |= v >> 8; v |= v >> 16; v++; return v; }
 
+// Helpers: Geometry
+IMGUI_API ImVec2        ImLineClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& p);
+IMGUI_API bool          ImTriangleContainsPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
+IMGUI_API ImVec2        ImTriangleClosestPoint(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p);
+IMGUI_API void          ImTriangleBarycentricCoords(const ImVec2& a, const ImVec2& b, const ImVec2& c, const ImVec2& p, float& out_u, float& out_v, float& out_w);
+
 // Helpers: String
 IMGUI_API int           ImStricmp(const char* str1, const char* str2);
-IMGUI_API int           ImStrnicmp(const char* str1, const char* str2, int count);
+IMGUI_API int           ImStrnicmp(const char* str1, const char* str2, size_t count);
+IMGUI_API void          ImStrncpy(char* dst, const char* src, size_t count);
 IMGUI_API char*         ImStrdup(const char* str);
+IMGUI_API char*         ImStrchrRange(const char* str_begin, const char* str_end, char c);
 IMGUI_API int           ImStrlenW(const ImWchar* str);
 IMGUI_API const ImWchar*ImStrbolW(const ImWchar* buf_mid_line, const ImWchar* buf_begin); // Find beginning-of-line
 IMGUI_API const char*   ImStristr(const char* haystack, const char* haystack_end, const char* needle, const char* needle_end);
-IMGUI_API int           ImFormatString(char* buf, int buf_size, const char* fmt, ...) IM_PRINTFARGS(3);
+IMGUI_API int           ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
-IMGUI_API int           ImFormatStringV(char* buf, int buf_size, const char* fmt, va_list args);
+IMGUI_API int           ImFormatStringV(char* buf, size_t buf_size, const char* fmt, va_list args) IM_FMTLIST(3);
 
 // Helpers: Math
 // We are keeping those not leaking to the user by default, in the case the user has implicit cast operators between ImVec2 and its own types (when IM_VEC2_CLASS_EXTRA is defined)
@@ -117,7 +126,9 @@ static inline ImVec2& operator+=(ImVec2& lhs, const ImVec2& rhs)
 static inline ImVec2& operator-=(ImVec2& lhs, const ImVec2& rhs)                { lhs.x -= rhs.x; lhs.y -= rhs.y; return lhs; }
 static inline ImVec2& operator*=(ImVec2& lhs, const float rhs)                  { lhs.x *= rhs; lhs.y *= rhs; return lhs; }
 static inline ImVec2& operator/=(ImVec2& lhs, const float rhs)                  { lhs.x /= rhs; lhs.y /= rhs; return lhs; }
+static inline ImVec4 operator+(const ImVec4& lhs, const ImVec4& rhs)            { return ImVec4(lhs.x+rhs.x, lhs.y+rhs.y, lhs.z+rhs.z, lhs.w+rhs.w); }
 static inline ImVec4 operator-(const ImVec4& lhs, const ImVec4& rhs)            { return ImVec4(lhs.x-rhs.x, lhs.y-rhs.y, lhs.z-rhs.z, lhs.w-rhs.w); }
+static inline ImVec4 operator*(const ImVec4& lhs, const ImVec4& rhs)            { return ImVec4(lhs.x*rhs.x, lhs.y*rhs.y, lhs.z*rhs.z, lhs.w*rhs.w); }
 #endif
 
 static inline int    ImMin(int lhs, int rhs)                                    { return lhs < rhs ? lhs : rhs; }
@@ -130,40 +141,54 @@ static inline int    ImClamp(int v, int mn, int mx)
 static inline float  ImClamp(float v, float mn, float mx)                       { return (v < mn) ? mn : (v > mx) ? mx : v; }
 static inline ImVec2 ImClamp(const ImVec2& f, const ImVec2& mn, ImVec2 mx)      { return ImVec2(ImClamp(f.x,mn.x,mx.x), ImClamp(f.y,mn.y,mx.y)); }
 static inline float  ImSaturate(float f)                                        { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
+static inline void   ImSwap(int& a, int& b)                                     { int tmp = a; a = b; b = tmp; }
+static inline void   ImSwap(float& a, float& b)                                 { float tmp = a; a = b; b = tmp; }
+static inline int    ImLerp(int a, int b, float t)                              { return (int)(a + (b - a) * t); }
 static inline float  ImLerp(float a, float b, float t)                          { return a + (b - a) * t; }
+static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, float t)          { return ImVec2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t); }
 static inline ImVec2 ImLerp(const ImVec2& a, const ImVec2& b, const ImVec2& t)  { return ImVec2(a.x + (b.x - a.x) * t.x, a.y + (b.y - a.y) * t.y); }
+static inline ImVec4 ImLerp(const ImVec4& a, const ImVec4& b, float t)          { return ImVec4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t); }
 static inline float  ImLengthSqr(const ImVec2& lhs)                             { return lhs.x*lhs.x + lhs.y*lhs.y; }
 static inline float  ImLengthSqr(const ImVec4& lhs)                             { return lhs.x*lhs.x + lhs.y*lhs.y + lhs.z*lhs.z + lhs.w*lhs.w; }
 static inline float  ImInvLength(const ImVec2& lhs, float fail_value)           { float d = lhs.x*lhs.x + lhs.y*lhs.y; if (d > 0.0f) return 1.0f / sqrtf(d); return fail_value; }
 static inline float  ImFloor(float f)                                           { return (float)(int)f; }
-static inline ImVec2 ImFloor(ImVec2 v)                                          { return ImVec2((float)(int)v.x, (float)(int)v.y); }
+static inline ImVec2 ImFloor(const ImVec2& v)                                   { return ImVec2((float)(int)v.x, (float)(int)v.y); }
+static inline float  ImDot(const ImVec2& a, const ImVec2& b)                    { return a.x * b.x + a.y * b.y; }
+static inline ImVec2 ImRotate(const ImVec2& v, float cos_a, float sin_a)        { return ImVec2(v.x * cos_a - v.y * sin_a, v.x * sin_a + v.y * cos_a); }
+static inline float  ImLinearSweep(float current, float target, float speed)    { if (current < target) return ImMin(current + speed, target); if (current > target) return ImMax(current - speed, target); return current; }
+static inline ImVec2 ImMul(const ImVec2& lhs, const ImVec2& rhs)                { return ImVec2(lhs.x * rhs.x, lhs.y * rhs.y); }
 
 // We call C++ constructor on own allocated memory via the placement "new(ptr) Type()" syntax.
 // Defining a custom placement new() with a dummy parameter allows us to bypass including <new> which on some platforms complains when user has disabled exceptions.
-#ifdef IMGUI_DEFINE_PLACEMENT_NEW
+struct ImNewPlacementDummy {};
-struct ImPlacementNewDummy {};
+inline void* operator   new(size_t, ImNewPlacementDummy, void* ptr) { return ptr; }
-inline void* operator new(size_t, ImPlacementNewDummy, void* ptr) { return ptr; }
+inline void  operator   delete(void*, ImNewPlacementDummy, void*)   {} // This is only required so we can use the symetrical new()
-inline void operator delete(void*, ImPlacementNewDummy, void*) {}
+#define IM_PLACEMENT_NEW(_PTR)              new(ImNewPlacementDummy(), _PTR)
-#define IM_PLACEMENT_NEW(_PTR)  new(ImPlacementNewDummy(), _PTR)
+#define IM_NEW(_TYPE)                       new(ImNewPlacementDummy(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE
-#endif
+template <typename T> void IM_DELETE(T*& p) { if (p) { p->~T(); ImGui::MemFree(p); p = NULL; } }
 
 //-----------------------------------------------------------------------------
 // Types
 //-----------------------------------------------------------------------------
 
+// Internal Drag and Drop payload types. String starting with '_' are reserved for Dear ImGui.
+#define IMGUI_PAYLOAD_TYPE_DOCKABLE         "_IMDOCK"   // ImGuiWindow* // [Internal] Docking/tabs
+
 enum ImGuiButtonFlags_
 {
     ImGuiButtonFlags_Repeat                 = 1 << 0,   // hold to repeat
-    ImGuiButtonFlags_PressedOnClickRelease  = 1 << 1,   // (default) return pressed on click+release on same item (default if no PressedOn** flag is set)
+    ImGuiButtonFlags_PressedOnClickRelease  = 1 << 1,   // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
-    ImGuiButtonFlags_PressedOnClick         = 1 << 2,   // return pressed on click (default requires click+release)
+    ImGuiButtonFlags_PressedOnClick         = 1 << 2,   // return true on click (default requires click+release)
-    ImGuiButtonFlags_PressedOnRelease       = 1 << 3,   // return pressed on release (default requires click+release)
+    ImGuiButtonFlags_PressedOnRelease       = 1 << 3,   // return true on release (default requires click+release)
-    ImGuiButtonFlags_PressedOnDoubleClick   = 1 << 4,   // return pressed on double-click (default requires click+release)
+    ImGuiButtonFlags_PressedOnDoubleClick   = 1 << 4,   // return true on double-click (default requires click+release)
-    ImGuiButtonFlags_FlattenChilds          = 1 << 5,   // allow interaction even if a child window is overlapping
+    ImGuiButtonFlags_FlattenChildren        = 1 << 5,   // allow interactions even if a child window is overlapping
-    ImGuiButtonFlags_DontClosePopups        = 1 << 6,   // disable automatically closing parent popup on press
+    ImGuiButtonFlags_AllowItemOverlap       = 1 << 6,   // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
-    ImGuiButtonFlags_Disabled               = 1 << 7,   // disable interaction
+    ImGuiButtonFlags_DontClosePopups        = 1 << 7,   // disable automatically closing parent popup on press // [UNUSED]
-    ImGuiButtonFlags_AlignTextBaseLine      = 1 << 8,   // vertically align button to match text baseline - ButtonEx() only
+    ImGuiButtonFlags_Disabled               = 1 << 8,   // disable interactions
-    ImGuiButtonFlags_NoKeyModifiers         = 1 << 9,   // disable interaction if a key modifier is held
+    ImGuiButtonFlags_AlignTextBaseLine      = 1 << 9,   // vertically align button to match text baseline - ButtonEx() only // FIXME: Should be removed and handled by SmallButton(), not possible currently because of DC.CursorPosPrevLine
-    ImGuiButtonFlags_AllowOverlapMode       = 1 << 10   // require previous frame HoveredId to either match id or be null before being usable
+    ImGuiButtonFlags_NoKeyModifiers         = 1 << 10,  // disable interaction if a key modifier is held
+    ImGuiButtonFlags_NoHoldingActiveID      = 1 << 11,  // don't set ActiveId while holding the mouse (ImGuiButtonFlags_PressedOnClick only)
+    ImGuiButtonFlags_PressedOnDragDropHold  = 1 << 12   // press when held into while we are drag and dropping another item (used by e.g. tree nodes, collapsing headers)
 };
 
 enum ImGuiSliderFlags_
@@ -171,15 +196,31 @@ enum ImGuiSliderFlags_
     ImGuiSliderFlags_Vertical               = 1 << 0
 };
 
+enum ImGuiColumnsFlags_
+{
+    // Default: 0
+    ImGuiColumnsFlags_NoBorder              = 1 << 0,   // Disable column dividers
+    ImGuiColumnsFlags_NoResize              = 1 << 1,   // Disable resizing columns when clicking on the dividers
+    ImGuiColumnsFlags_NoPreserveWidths      = 1 << 2,   // Disable column width preservation when adjusting columns
+    ImGuiColumnsFlags_NoForceWithinWindow   = 1 << 3,   // Disable forcing columns to fit within window
+    ImGuiColumnsFlags_GrowParentContentsSize= 1 << 4    // (WIP) Restore pre-1.51 behavior of extending the parent window contents size but _without affecting the columns width at all_. Will eventually remove.
+};
+
 enum ImGuiSelectableFlagsPrivate_
 {
     // NB: need to be in sync with last value of ImGuiSelectableFlags_
-    ImGuiSelectableFlags_Menu               = 1 << 3,
+    ImGuiSelectableFlags_Menu               = 1 << 3,   // -> PressedOnClick
-    ImGuiSelectableFlags_MenuItem           = 1 << 4,
+    ImGuiSelectableFlags_MenuItem           = 1 << 4,   // -> PressedOnRelease
     ImGuiSelectableFlags_Disabled           = 1 << 5,
     ImGuiSelectableFlags_DrawFillAvailWidth = 1 << 6
 };
 
+enum ImGuiSeparatorFlags_
+{
+    ImGuiSeparatorFlags_Horizontal          = 1 << 0,   // Axis default to current layout type, so generally Horizontal unless e.g. in a menu bar
+    ImGuiSeparatorFlags_Vertical            = 1 << 1
+};
+
 // FIXME: this is in development, not exposed/functional as a generic feature yet.
 enum ImGuiLayoutType_
 {
@@ -187,6 +228,13 @@ enum ImGuiLayoutType_
     ImGuiLayoutType_Horizontal
 };
 
+enum ImGuiAxis
+{
+    ImGuiAxis_None = -1,
+    ImGuiAxis_X = 0,
+    ImGuiAxis_Y = 1
+};
+
 enum ImGuiPlotType
 {
     ImGuiPlotType_Lines,
@@ -197,16 +245,17 @@ enum ImGuiDataType
 {
     ImGuiDataType_Int,
     ImGuiDataType_Float,
-    ImGuiDataType_Float2,
+    ImGuiDataType_Float2
 };
 
-enum ImGuiCorner
+enum ImGuiDir
 {
-    ImGuiCorner_TopLeft     = 1 << 0, // 1
+    ImGuiDir_None    = -1,
-    ImGuiCorner_TopRight    = 1 << 1, // 2
+    ImGuiDir_Left    = 0,
-    ImGuiCorner_BottomRight = 1 << 2, // 4
+    ImGuiDir_Right   = 1,
-    ImGuiCorner_BottomLeft  = 1 << 3, // 8
+    ImGuiDir_Up      = 2,
-    ImGuiCorner_All         = 0x0F
+    ImGuiDir_Down    = 3,
+    ImGuiDir_Count_
 };
 
 // 2D axis aligned bounding-box
@@ -236,9 +285,11 @@ struct IMGUI_API ImRect
     void        Add(const ImRect& rhs)          { if (Min.x > rhs.Min.x) Min.x = rhs.Min.x; if (Min.y > rhs.Min.y) Min.y = rhs.Min.y; if (Max.x < rhs.Max.x) Max.x = rhs.Max.x; if (Max.y < rhs.Max.y) Max.y = rhs.Max.y; }
     void        Expand(const float amount)      { Min.x -= amount;   Min.y -= amount;   Max.x += amount;   Max.y += amount; }
     void        Expand(const ImVec2& amount)    { Min.x -= amount.x; Min.y -= amount.y; Max.x += amount.x; Max.y += amount.y; }
-    void        Reduce(const ImVec2& amount)    { Min.x += amount.x; Min.y += amount.y; Max.x -= amount.x; Max.y -= amount.y; }
+    void        Translate(const ImVec2& v)      { Min.x += v.x; Min.y += v.y; Max.x += v.x; Max.y += v.y; }
-    void        Clip(const ImRect& clip)        { if (Min.x < clip.Min.x) Min.x = clip.Min.x; if (Min.y < clip.Min.y) Min.y = clip.Min.y; if (Max.x > clip.Max.x) Max.x = clip.Max.x; if (Max.y > clip.Max.y) Max.y = clip.Max.y; }
+    void        ClipWith(const ImRect& clip)    { if (Min.x < clip.Min.x) Min.x = clip.Min.x; if (Min.y < clip.Min.y) Min.y = clip.Min.y; if (Max.x > clip.Max.x) Max.x = clip.Max.x; if (Max.y > clip.Max.y) Max.y = clip.Max.y; }
     void        Floor()                         { Min.x = (float)(int)Min.x; Min.y = (float)(int)Min.y; Max.x = (float)(int)Max.x; Max.y = (float)(int)Max.y; }
+    void        FixInverted()                   { if (Min.x > Max.x) ImSwap(Min.x, Max.x); if (Min.y > Max.y) ImSwap(Min.y, Max.y); }
+    bool        IsFinite() const                { return Min.x != FLT_MAX; }
     ImVec2      GetClosestPoint(ImVec2 p, bool on_edge) const
     {
         if (!on_edge && Contains(p))
@@ -282,13 +333,6 @@ struct ImGuiGroupData
     bool        AdvanceCursor;
 };
 
-// Per column data for Columns()
-struct ImGuiColumnData
-{
-    float       OffsetNorm;     // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
-    //float     IndentX;
-};
-
 // Simple column measurement currently used for MenuItem() only. This is very short-sighted/throw-away code and NOT a generic helper.
 struct IMGUI_API ImGuiSimpleColumns
 {
@@ -328,13 +372,24 @@ struct IMGUI_API ImGuiTextEditState
 };
 
 // Data saved in imgui.ini file
-struct ImGuiIniData
+struct ImGuiWindowSettings
 {
     char*       Name;
     ImGuiID     Id;
     ImVec2      Pos;
     ImVec2      Size;
     bool        Collapsed;
+
+    ImGuiWindowSettings() { Name = NULL; Id = 0; Pos = Size = ImVec2(0,0); Collapsed = false; }
+};
+
+struct ImGuiSettingsHandler
+{
+    const char* TypeName;   // Short description stored in .ini file. Disallowed characters: '[' ']'  
+    ImGuiID     TypeHash;   // == ImHash(TypeName, 0, 0)
+    void*       (*ReadOpenFn)(ImGuiContext& ctx, const char* name);
+    void        (*ReadLineFn)(ImGuiContext& ctx, void* entry, const char* line);
+    void        (*WriteAllFn)(ImGuiContext& ctx, ImGuiTextBuffer* out_buf);
 };
 
 // Mouse cursor data (used when io.MouseDrawCursor is set)
@@ -350,15 +405,71 @@ struct ImGuiMouseCursorData
 // Storage for current popup stack
 struct ImGuiPopupRef
 {
-    ImGuiID         PopupId;        // Set on OpenPopup()
+    ImGuiID             PopupId;        // Set on OpenPopup()
-    ImGuiWindow*    Window;         // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
+    ImGuiWindow*        Window;         // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
-    ImGuiWindow*    ParentWindow;   // Set on OpenPopup()
+    ImGuiWindow*        ParentWindow;   // Set on OpenPopup()
-    ImGuiID         ParentMenuSet;  // Set on OpenPopup()
+    ImGuiID             ParentMenuSet;  // Set on OpenPopup()
-    ImVec2          MousePosOnOpen; // Copy of mouse position at the time of opening popup
+    ImVec2              MousePosOnOpen; // Copy of mouse position at the time of opening popup
 
     ImGuiPopupRef(ImGuiID id, ImGuiWindow* parent_window, ImGuiID parent_menu_set, const ImVec2& mouse_pos) { PopupId = id; Window = NULL; ParentWindow = parent_window; ParentMenuSet = parent_menu_set; MousePosOnOpen = mouse_pos; }
 };
 
+struct ImGuiColumnData
+{
+    float               OffsetNorm;         // Column start offset, normalized 0.0 (far left) -> 1.0 (far right)
+    float               OffsetNormBeforeResize;
+    ImGuiColumnsFlags   Flags;              // Not exposed
+    ImRect              ClipRect;
+
+    ImGuiColumnData()   { OffsetNorm = OffsetNormBeforeResize = 0.0f; Flags = 0; }
+};
+
+struct ImGuiColumnsSet
+{
+    ImGuiID             ID;
+    ImGuiColumnsFlags   Flags;
+    bool                IsFirstFrame;
+    bool                IsBeingResized;
+    int                 Current;
+    int                 Count;
+    float               MinX, MaxX;
+    float               StartPosY;
+    float               StartMaxPosX;       // Backup of CursorMaxPos
+    float               CellMinY, CellMaxY;
+    ImVector<ImGuiColumnData> Columns;
+
+    ImGuiColumnsSet()   { Clear(); }
+    void Clear()
+    {
+        ID = 0;
+        Flags = 0;
+        IsFirstFrame = false;
+        IsBeingResized = false;
+        Current = 0;
+        Count = 1;
+        MinX = MaxX = 0.0f;
+        StartPosY = 0.0f;
+        StartMaxPosX = 0.0f;
+        CellMinY = CellMaxY = 0.0f;
+        Columns.clear();
+    }
+};
+
+struct ImDrawListSharedData
+{
+    ImVec2          TexUvWhitePixel;            // UV of white pixel in the atlas
+    ImFont*         Font;                       // Current/default font (optional, for simplified AddText overload)
+    float           FontSize;                   // Current/default font size (optional, for simplified AddText overload)
+    float           CurveTessellationTol;
+    ImVec4          ClipRectFullscreen;         // Value for PushClipRectFullscreen()
+
+    // Const data
+    // FIXME: Bake rounded corners fill/borders in atlas
+    ImVec2          CircleVtx12[12];
+
+    ImDrawListSharedData();
+};
+
 // Main state for ImGui
 struct ImGuiContext
 {
@@ -366,9 +477,9 @@ struct ImGuiContext
     ImGuiIO                 IO;
     ImGuiStyle              Style;
     ImFont*                 Font;                               // (Shortcut) == FontStack.empty() ? IO.Font : FontStack.back()
-    float                   FontSize;                           // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize()
+    float                   FontSize;                           // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
-    float                   FontBaseSize;                       // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Size of characters.
+    float                   FontBaseSize;                       // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
-    ImVec2                  FontTexUvWhitePixel;                // (Shortcut) == Font->TexUvWhitePixel
+    ImDrawListSharedData    DrawListSharedData;
 
     float                   Time;
     int                     FrameCount;
@@ -376,25 +487,27 @@ struct ImGuiContext
     int                     FrameCountRendered;
     ImVector<ImGuiWindow*>  Windows;
     ImVector<ImGuiWindow*>  WindowsSortBuffer;
-    ImGuiWindow*            CurrentWindow;                      // Being drawn into
     ImVector<ImGuiWindow*>  CurrentWindowStack;
-    ImGuiWindow*            FocusedWindow;                      // Will catch keyboard inputs
+    ImGuiStorage            WindowsById;
+    int                     WindowsActiveCount;
+    ImGuiWindow*            CurrentWindow;                      // Being drawn into
+    ImGuiWindow*            NavWindow;                          // Nav/focused window for navigation
     ImGuiWindow*            HoveredWindow;                      // Will catch mouse inputs
     ImGuiWindow*            HoveredRootWindow;                  // Will catch mouse inputs (for focus/move only)
     ImGuiID                 HoveredId;                          // Hovered widget
     bool                    HoveredIdAllowOverlap;
     ImGuiID                 HoveredIdPreviousFrame;
+    float                   HoveredIdTimer;
     ImGuiID                 ActiveId;                           // Active widget
     ImGuiID                 ActiveIdPreviousFrame;
-    bool                    ActiveIdIsAlive;
+    float                   ActiveIdTimer;
+    bool                    ActiveIdIsAlive;                    // Active widget has been seen this frame
     bool                    ActiveIdIsJustActivated;            // Set at the time of activation for one frame
-    bool                    ActiveIdAllowOverlap;               // Set only by active widget
+    bool                    ActiveIdAllowOverlap;               // Active widget allows another widget to steal active id (generally for overlapping widgets, but not always)
     ImVec2                  ActiveIdClickOffset;                // Clicked offset from upper-left corner, if applicable (currently only set by ButtonBehavior)
     ImGuiWindow*            ActiveIdWindow;
-    ImGuiWindow*            MovedWindow;                        // Track the child window we clicked on to move a window.
+    ImGuiWindow*            MovingWindow;                       // Track the child window we clicked on to move a window.
-    ImGuiID                 MovedWindowMoveId;                  // == MovedWindow->RootWindow->MoveId
+    ImGuiID                 MovingWindowMoveId;                 // == MovingWindow->MoveId
-    ImVector<ImGuiIniData>  Settings;                           // .ini Settings
-    float                   SettingsDirtyTimer;                 // Save .ini Settings on disk when time reaches zero
     ImVector<ImGuiColMod>   ColorModifiers;                     // Stack for PushStyleColor()/PopStyleColor()
     ImVector<ImGuiStyleMod> StyleModifiers;                     // Stack for PushStyleVar()/PopStyleVar()
     ImVector<ImFont*>       FontStack;                          // Stack for PushFont()/PopFont()
@@ -403,20 +516,21 @@ struct ImGuiContext
 
     // Storage for SetNexWindow** and SetNextTreeNode*** functions
     ImVec2                  SetNextWindowPosVal;
+    ImVec2                  SetNextWindowPosPivot;
     ImVec2                  SetNextWindowSizeVal;
     ImVec2                  SetNextWindowContentSizeVal;
     bool                    SetNextWindowCollapsedVal;
-    ImGuiSetCond            SetNextWindowPosCond;
+    ImGuiCond               SetNextWindowPosCond;
-    ImGuiSetCond            SetNextWindowSizeCond;
+    ImGuiCond               SetNextWindowSizeCond;
-    ImGuiSetCond            SetNextWindowContentSizeCond;
+    ImGuiCond               SetNextWindowContentSizeCond;
-    ImGuiSetCond            SetNextWindowCollapsedCond;
+    ImGuiCond               SetNextWindowCollapsedCond;
     ImRect                  SetNextWindowSizeConstraintRect;           // Valid if 'SetNextWindowSizeConstraint' is true
     ImGuiSizeConstraintCallback SetNextWindowSizeConstraintCallback;
-    void*                       SetNextWindowSizeConstraintCallbackUserData;
+    void*                   SetNextWindowSizeConstraintCallbackUserData;
     bool                    SetNextWindowSizeConstraint;
     bool                    SetNextWindowFocus;
     bool                    SetNextTreeNodeOpenVal;
-    ImGuiSetCond            SetNextTreeNodeOpenCond;
+    ImGuiCond               SetNextTreeNodeOpenCond;
 
     // Render
     ImDrawData              RenderDrawData;                     // Main ImDrawData instance to pass render information to the user
@@ -426,21 +540,41 @@ struct ImGuiContext
     ImGuiMouseCursor        MouseCursor;
     ImGuiMouseCursorData    MouseCursorData[ImGuiMouseCursor_Count_];
 
+    // Drag and Drop
+    bool                    DragDropActive;
+    ImGuiDragDropFlags      DragDropSourceFlags;
+    int                     DragDropMouseButton;
+    ImGuiPayload            DragDropPayload;
+    ImRect                  DragDropTargetRect;
+    ImGuiID                 DragDropTargetId;
+    float                   DragDropAcceptIdCurrRectSurface;
+    ImGuiID                 DragDropAcceptIdCurr;               // Target item id (set at the time of accepting the payload)
+    ImGuiID                 DragDropAcceptIdPrev;               // Target item id from previous frame (we need to store this to allow for overlapping drag and drop targets)
+    int                     DragDropAcceptFrameCount;           // Last time a target expressed a desire to accept the source
+    ImVector<unsigned char> DragDropPayloadBufHeap;             // We don't expose the ImVector<> directly
+    unsigned char           DragDropPayloadBufLocal[8];
+
     // Widget state
     ImGuiTextEditState      InputTextState;
     ImFont                  InputTextPasswordFont;
     ImGuiID                 ScalarAsInputTextId;                // Temporary text input when CTRL+clicking on a slider, etc.
-    ImGuiStorage            ColorEditModeStorage;               // Store user selection of color edit mode
+    ImGuiColorEditFlags     ColorEditOptions;                   // Store user options for color edit widgets
+    ImVec4                  ColorPickerRef;
     float                   DragCurrentValue;                   // Currently dragged value, always float, not rounded by end-user precision settings
     ImVec2                  DragLastMouseDelta;
     float                   DragSpeedDefaultRatio;              // If speed == 0.0f, uses (max-min) * DragSpeedDefaultRatio
     float                   DragSpeedScaleSlow;
     float                   DragSpeedScaleFast;
     ImVec2                  ScrollbarClickDeltaToGrabCenter;    // Distance between mouse and center of grab box, normalized in parent space. Use storage?
-    char                    Tooltip[1024];
+    int                     TooltipOverrideCount;
-    char*                   PrivateClipboard;                   // If no custom clipboard handler is defined
+    ImVector<char>          PrivateClipboard;                   // If no custom clipboard handler is defined
     ImVec2                  OsImePosRequest, OsImePosSet;       // Cursor position request & last passed to the OS Input Method Editor
 
+    // Settings
+    float                          SettingsDirtyTimer;          // Save .ini Settings on disk when time reaches zero
+    ImVector<ImGuiWindowSettings>  SettingsWindows;             // .ini settings for ImGuiWindow
+    ImVector<ImGuiSettingsHandler> SettingsHandlers;            // List of .ini settings handlers
+
     // Logging
     bool                    LogEnabled;
     FILE*                   LogFile;                            // If != NULL log to stdout/ file
@@ -452,37 +586,39 @@ struct ImGuiContext
     float                   FramerateSecPerFrame[120];          // calculate estimate of framerate for user
     int                     FramerateSecPerFrameIdx;
     float                   FramerateSecPerFrameAccum;
-    int                     CaptureMouseNextFrame;              // explicit capture via CaptureInputs() sets those flags
+    int                     WantCaptureMouseNextFrame;          // explicit capture via CaptureInputs() sets those flags
-    int                     CaptureKeyboardNextFrame;
+    int                     WantCaptureKeyboardNextFrame;
+    int                     WantTextInputNextFrame;
     char                    TempBuffer[1024*3+1];               // temporary text buffer
 
-    ImGuiContext()
+    ImGuiContext() : OverlayDrawList(NULL)
     {
         Initialized = false;
         Font = NULL;
         FontSize = FontBaseSize = 0.0f;
-        FontTexUvWhitePixel = ImVec2(0.0f, 0.0f);
 
         Time = 0.0f;
         FrameCount = 0;
         FrameCountEnded = FrameCountRendered = -1;
+        WindowsActiveCount = 0;
         CurrentWindow = NULL;
-        FocusedWindow = NULL;
+        NavWindow = NULL;
         HoveredWindow = NULL;
         HoveredRootWindow = NULL;
         HoveredId = 0;
         HoveredIdAllowOverlap = false;
         HoveredIdPreviousFrame = 0;
+        HoveredIdTimer = 0.0f;
         ActiveId = 0;
         ActiveIdPreviousFrame = 0;
+        ActiveIdTimer = 0.0f;
         ActiveIdIsAlive = false;
         ActiveIdIsJustActivated = false;
         ActiveIdAllowOverlap = false;
         ActiveIdClickOffset = ImVec2(-1,-1);
         ActiveIdWindow = NULL;
-        MovedWindow = NULL;
+        MovingWindow = NULL;
-        MovedWindowMoveId = 0;
+        MovingWindowMoveId = 0;
-        SettingsDirtyTimer = 0.0f;
 
         SetNextWindowPosVal = ImVec2(0.0f, 0.0f);
         SetNextWindowSizeVal = ImVec2(0.0f, 0.0f);
@@ -499,22 +635,33 @@ struct ImGuiContext
         SetNextTreeNodeOpenVal = false;
         SetNextTreeNodeOpenCond = 0;
 
+        DragDropActive = false;
+        DragDropSourceFlags = 0;
+        DragDropMouseButton = -1;
+        DragDropTargetId = 0;
+        DragDropAcceptIdPrev = DragDropAcceptIdCurr = 0;
+        DragDropAcceptFrameCount = -1;
+        memset(DragDropPayloadBufLocal, 0, sizeof(DragDropPayloadBufLocal));
+
         ScalarAsInputTextId = 0;
+        ColorEditOptions = ImGuiColorEditFlags__OptionsDefault;
         DragCurrentValue = 0.0f;
         DragLastMouseDelta = ImVec2(0.0f, 0.0f);
         DragSpeedDefaultRatio = 1.0f / 100.0f;
-        DragSpeedScaleSlow = 0.01f;
+        DragSpeedScaleSlow = 1.0f / 100.0f;
         DragSpeedScaleFast = 10.0f;
         ScrollbarClickDeltaToGrabCenter = ImVec2(0.0f, 0.0f);
-        memset(Tooltip, 0, sizeof(Tooltip));
+        TooltipOverrideCount = 0;
-        PrivateClipboard = NULL;
         OsImePosRequest = OsImePosSet = ImVec2(-1.0f, -1.0f);
 
         ModalWindowDarkeningRatio = 0.0f;
+        OverlayDrawList._Data = &DrawListSharedData;
         OverlayDrawList._OwnerName = "##Overlay"; // Give it a name for debugging
         MouseCursor = ImGuiMouseCursor_Arrow;
         memset(MouseCursorData, 0, sizeof(MouseCursorData));
 
+        SettingsDirtyTimer = 0.0f;
+
         LogEnabled = false;
         LogFile = NULL;
         LogClipboard = NULL;
@@ -524,11 +671,23 @@ struct ImGuiContext
         memset(FramerateSecPerFrame, 0, sizeof(FramerateSecPerFrame));
         FramerateSecPerFrameIdx = 0;
         FramerateSecPerFrameAccum = 0.0f;
-        CaptureMouseNextFrame = CaptureKeyboardNextFrame = -1;
+        WantCaptureMouseNextFrame = WantCaptureKeyboardNextFrame = WantTextInputNextFrame = -1;
         memset(TempBuffer, 0, sizeof(TempBuffer));
     }
 };
 
+// Transient per-window flags, reset at the beginning of the frame. For child window, inherited from parent on first Begin().
+enum ImGuiItemFlags_
+{
+    ImGuiItemFlags_AllowKeyboardFocus           = 1 << 0,  // true
+    ImGuiItemFlags_ButtonRepeat                 = 1 << 1,  // false    // Button() will return true multiple times based on io.KeyRepeatDelay and io.KeyRepeatRate settings.
+    ImGuiItemFlags_Disabled                     = 1 << 2,  // false    // FIXME-WIP: Disable interactions but doesn't affect visuals. Should be: grey out and disable interactions with widgets that affect data + view widgets (WIP) 
+    //ImGuiItemFlags_NoNav                      = 1 << 3,  // false
+    //ImGuiItemFlags_NoNavDefaultFocus          = 1 << 4,  // false
+    ImGuiItemFlags_SelectableDontClosePopup     = 1 << 5,  // false    // MenuItem/Selectable() automatically closes current Popup window
+    ImGuiItemFlags_Default_                     = ImGuiItemFlags_AllowKeyboardFocus
+};
+
 // Transient per-window data, reset at the beginning of the frame
 // FIXME: That's theory, in practice the delimitation between ImGuiWindow and ImGuiDrawContext is quite tenuous and could be reconsidered.
 struct IMGUI_API ImGuiDrawContext
@@ -536,7 +695,7 @@ struct IMGUI_API ImGuiDrawContext
     ImVec2                  CursorPos;
     ImVec2                  CursorPosPrevLine;
     ImVec2                  CursorStartPos;
-    ImVec2                  CursorMaxPos;           // Implicitly calculate the size of our contents, always extending. Saved into window->SizeContents at the end of the frame
+    ImVec2                  CursorMaxPos;           // Used to implicitly calculate the size of our contents, always growing during the frame. Turned into window->SizeContents at the beginning of next frame
     float                   CurrentLineHeight;
     float                   CurrentLineTextBaseOffset;
     float                   PrevLineHeight;
@@ -545,8 +704,7 @@ struct IMGUI_API ImGuiDrawContext
     int                     TreeDepth;
     ImGuiID                 LastItemId;
     ImRect                  LastItemRect;
-    bool                    LastItemHoveredAndUsable;  // Item rectangle is hovered, and its window is currently interactable with (not blocked by a popup preventing access to the window)
+    bool                    LastItemRectHoveredRect;
-    bool                    LastItemHoveredRect;       // Item rectangle is hovered, but its window may or not be currently interactable with (might be blocked by a popup preventing access to the window)
     bool                    MenuBarAppending;
     float                   MenuBarOffsetX;
     ImVector<ImGuiWindow*>  ChildWindows;
@@ -554,31 +712,19 @@ struct IMGUI_API ImGuiDrawContext
     ImGuiLayoutType         LayoutType;
 
     // We store the current settings outside of the vectors to increase memory locality (reduce cache misses). The vectors are rarely modified. Also it allows us to not heap allocate for short-lived windows which are not using those settings.
+    ImGuiItemFlags          ItemFlags;              // == ItemFlagsStack.back() [empty == ImGuiItemFlags_Default]
     float                   ItemWidth;              // == ItemWidthStack.back(). 0.0: default, >0.0: width in pixels, <0.0: align xx pixels to the right of window
     float                   TextWrapPos;            // == TextWrapPosStack.back() [empty == -1.0f]
-    bool                    AllowKeyboardFocus;     // == AllowKeyboardFocusStack.back() [empty == true]
+    ImVector<ImGuiItemFlags>ItemFlagsStack;
-    bool                    ButtonRepeat;           // == ButtonRepeatStack.back() [empty == false]
     ImVector<float>         ItemWidthStack;
     ImVector<float>         TextWrapPosStack;
-    ImVector<bool>          AllowKeyboardFocusStack;
-    ImVector<bool>          ButtonRepeatStack;
     ImVector<ImGuiGroupData>GroupStack;
-    ImGuiColorEditMode      ColorEditMode;
     int                     StackSizesBackup[6];    // Store size of various stacks for asserting
 
     float                   IndentX;                // Indentation / start position from left of window (increased by TreePush/TreePop, etc.)
     float                   GroupOffsetX;
     float                   ColumnsOffsetX;         // Offset to the current column (if ColumnsCurrent > 0). FIXME: This and the above should be a stack to allow use cases like Tree->Column->Tree. Need revamp columns API.
-    int                     ColumnsCurrent;
+    ImGuiColumnsSet*        ColumnsSet;             // Current columns set
-    int                     ColumnsCount;
-    float                   ColumnsMinX;
-    float                   ColumnsMaxX;
-    float                   ColumnsStartPosY;
-    float                   ColumnsCellMinY;
-    float                   ColumnsCellMaxY;
-    bool                    ColumnsShowBorders;
-    ImGuiID                 ColumnsSetId;
-    ImVector<ImGuiColumnData> ColumnsData;
 
     ImGuiDrawContext()
     {
@@ -588,29 +734,21 @@ struct IMGUI_API ImGuiDrawContext
         LogLinePosY = -1.0f;
         TreeDepth = 0;
         LastItemId = 0;
-        LastItemRect = ImRect(0.0f,0.0f,0.0f,0.0f);
+        LastItemRect = ImRect();
-        LastItemHoveredAndUsable = LastItemHoveredRect = false;
+        LastItemRectHoveredRect = false;
         MenuBarAppending = false;
         MenuBarOffsetX = 0.0f;
         StateStorage = NULL;
         LayoutType = ImGuiLayoutType_Vertical;
         ItemWidth = 0.0f;
-        ButtonRepeat = false;
+        ItemFlags = ImGuiItemFlags_Default_;
-        AllowKeyboardFocus = true;
         TextWrapPos = -1.0f;
-        ColorEditMode = ImGuiColorEditMode_RGB;
         memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
 
         IndentX = 0.0f;
         GroupOffsetX = 0.0f;
         ColumnsOffsetX = 0.0f;
-        ColumnsCurrent = 0;
+        ColumnsSet = NULL;
-        ColumnsCount = 1;
-        ColumnsMinX = ColumnsMaxX = 0.0f;
-        ColumnsStartPosY = 0.0f;
-        ColumnsCellMinY = ColumnsCellMaxY = 0.0f;
-        ColumnsShowBorders = true;
-        ColumnsSetId = 0;
     }
 };
 
@@ -620,51 +758,60 @@ struct IMGUI_API ImGuiWindow
     char*                   Name;
     ImGuiID                 ID;                                 // == ImHash(Name)
     ImGuiWindowFlags        Flags;                              // See enum ImGuiWindowFlags_
-    int                     IndexWithinParent;                  // Order within immediate parent window, if we are a child window. Otherwise 0.
     ImVec2                  PosFloat;
     ImVec2                  Pos;                                // Position rounded-up to nearest pixel
     ImVec2                  Size;                               // Current size (==SizeFull or collapsed title bar size)
     ImVec2                  SizeFull;                           // Size when non collapsed
-    ImVec2                  SizeContents;                       // Size of contents (== extents reach of the drawing cursor) from previous frame
+    ImVec2                  SizeFullAtLastBegin;                // Copy of SizeFull at the end of Begin. This is the reference value we'll use on the next frame to decide if we need scrollbars.
+    ImVec2                  SizeContents;                       // Size of contents (== extents reach of the drawing cursor) from previous frame. Include decoration, window title, border, menu, etc.
     ImVec2                  SizeContentsExplicit;               // Size of contents explicitly set by the user via SetNextWindowContentSize()
     ImRect                  ContentsRegionRect;                 // Maximum visible content position in window coordinates. ~~ (SizeContentsExplicit ? SizeContentsExplicit : Size - ScrollbarSizes) - CursorStartPos, per axis
-    ImVec2                  WindowPadding;                      // Window padding at the time of begin. We need to lock it, in particular manipulation of the ShowBorder would have an effect
+    ImVec2                  WindowPadding;                      // Window padding at the time of begin.
+    float                   WindowRounding;                     // Window rounding at the time of begin.
+    float                   WindowBorderSize;                   // Window border size at the time of begin.
     ImGuiID                 MoveId;                             // == window->GetID("#MOVE")
     ImVec2                  Scroll;
     ImVec2                  ScrollTarget;                       // target scroll position. stored as cursor position with scrolling canceled out, so the highest point is always 0.0f. (FLT_MAX for no change)
     ImVec2                  ScrollTargetCenterRatio;            // 0.0f = scroll so that target position is at top, 0.5f = scroll so that target position is centered
     bool                    ScrollbarX, ScrollbarY;
     ImVec2                  ScrollbarSizes;
-    float                   BorderSize;
     bool                    Active;                             // Set to true on Begin()
     bool                    WasActive;
-    bool                    Accessed;                           // Set to true when any widget access the current window
+    bool                    WriteAccessed;                      // Set to true when any widget access the current window
     bool                    Collapsed;                          // Set when collapsing window to become only title-bar
-    bool                    SkipItems;                          // == Visible && !Collapsed
+    bool                    SkipItems;                          // Set when items can safely be all clipped (e.g. window not visible or collapsed)
+    bool                    Appearing;                          // Set during the frame where the window is appearing (or re-appearing)
+    bool                    CloseButton;                        // Set when the window has a close button (p_open != NULL)
+    int                     BeginOrderWithinParent;             // Order within immediate parent window, if we are a child window. Otherwise 0.
+    int                     BeginOrderWithinContext;            // Order within entire imgui context. This is mostly used for debugging submission order related issues.
     int                     BeginCount;                         // Number of Begin() during the current frame (generally 0 or 1, 1+ if appending via multiple Begin/End pairs)
     ImGuiID                 PopupId;                            // ID in the popup stack when this window is used as a popup/menu (because we use generic Name/ID for recycling)
     int                     AutoFitFramesX, AutoFitFramesY;
     bool                    AutoFitOnlyGrows;
-    int                     AutoPosLastDirection;
+    int                     AutoFitChildAxises;
+    ImGuiDir                AutoPosLastDirection;
     int                     HiddenFrames;
-    int                     SetWindowPosAllowFlags;             // bit ImGuiSetCond_*** specify if SetWindowPos() call will succeed with this particular flag.
+    ImGuiCond               SetWindowPosAllowFlags;             // store condition flags for next SetWindowPos() call.
-    int                     SetWindowSizeAllowFlags;            // bit ImGuiSetCond_*** specify if SetWindowSize() call will succeed with this particular flag.
+    ImGuiCond               SetWindowSizeAllowFlags;            // store condition flags for next SetWindowSize() call.
-    int                     SetWindowCollapsedAllowFlags;       // bit ImGuiSetCond_*** specify if SetWindowCollapsed() call will succeed with this particular flag.
+    ImGuiCond               SetWindowCollapsedAllowFlags;       // store condition flags for next SetWindowCollapsed() call.
-    bool                    SetWindowPosCenterWanted;
+    ImVec2                  SetWindowPosVal;                    // store window position when using a non-zero Pivot (position set needs to be processed when we know the window size)
+    ImVec2                  SetWindowPosPivot;                  // store window pivot for positioning. ImVec2(0,0) when positioning from top-left corner; ImVec2(0.5f,0.5f) for centering; ImVec2(1,1) for bottom right.
 
     ImGuiDrawContext        DC;                                 // Temporary per-window data, reset at the beginning of the frame
     ImVector<ImGuiID>       IDStack;                            // ID stack. ID are hashes seeded with the value at the top of the stack
     ImRect                  ClipRect;                           // = DrawList->clip_rect_stack.back(). Scissoring / clipping rectangle. x1, y1, x2, y2.
     ImRect                  WindowRectClipped;                  // = WindowRect just after setup in Begin(). == window->Rect() for root window.
+    ImRect                  InnerRect;
     int                     LastFrameActive;
     float                   ItemWidthDefault;
     ImGuiSimpleColumns      MenuColumns;                        // Simplified columns storage for menu items
     ImGuiStorage            StateStorage;
+    ImVector<ImGuiColumnsSet> ColumnsStorage;
     float                   FontWindowScale;                    // Scale multiplier per-window
     ImDrawList*             DrawList;
-    ImGuiWindow*            RootWindow;                         // If we are a child window, this is pointing to the first non-child parent window. Else point to ourself.
+    ImGuiWindow*            ParentWindow;                       // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
-    ImGuiWindow*            RootNonPopupWindow;                 // If we are a child window, this is pointing to the first non-child non-popup parent window. Else point to ourself.
+    ImGuiWindow*            RootWindow;                         // Generally point to ourself. If we are a child window, this is pointing to the first non-child parent window.
-    ImGuiWindow*            ParentWindow;                       // If we are a child window, this is pointing to our parent window. Else point to NULL.
+    ImGuiWindow*            RootNonPopupWindow;                 // Generally point to ourself. Used to display TitleBgActive color and for selecting which window to use for NavWindowing
 
     // Navigation / Focus
     int                     FocusIdxAllCounter;                 // Start at -1 and increase as assigned via FocusItemRegister()
@@ -675,13 +822,15 @@ struct IMGUI_API ImGuiWindow
     int                     FocusIdxTabRequestNext;             // "
 
 public:
-    ImGuiWindow(const char* name);
+    ImGuiWindow(ImGuiContext* context, const char* name);
     ~ImGuiWindow();
 
     ImGuiID     GetID(const char* str, const char* str_end = NULL);
     ImGuiID     GetID(const void* ptr);
     ImGuiID     GetIDNoKeepAlive(const char* str, const char* str_end = NULL);
+    ImGuiID     GetIDFromRectangle(const ImRect& r_abs);
 
+    // We don't use g.FontSize because the window may be != g.CurrentWidow.
     ImRect      Rect() const                            { return ImRect(Pos.x, Pos.y, Pos.x+Size.x, Pos.y+Size.y); }
     float       CalcFontSize() const                    { return GImGui->FontBaseSize * FontWindowScale; }
     float       TitleBarHeight() const                  { return (Flags & ImGuiWindowFlags_NoTitleBar) ? 0.0f : CalcFontSize() + GImGui->Style.FramePadding.y * 2.0f; }
@@ -690,6 +839,18 @@ public:
     ImRect      MenuBarRect() const                     { float y1 = Pos.y + TitleBarHeight(); return ImRect(Pos.x, y1, Pos.x + SizeFull.x, y1 + MenuBarHeight()); }
 };
 
+// Backup and restore just enough data to be able to use IsItemHovered() on item A after another B in the same window has overwritten the data.  
+struct ImGuiItemHoveredDataBackup
+{
+    ImGuiID     LastItemId;
+    ImRect      LastItemRect;
+    bool        LastItemRectHoveredRect;
+
+    ImGuiItemHoveredDataBackup() { Backup(); }
+    void Backup()        { ImGuiWindow* window = GImGui->CurrentWindow; LastItemId = window->DC.LastItemId; LastItemRect = window->DC.LastItemRect; LastItemRectHoveredRect = window->DC.LastItemRectHoveredRect; }
+    void Restore() const { ImGuiWindow* window = GImGui->CurrentWindow; window->DC.LastItemId = LastItemId; window->DC.LastItemRect = LastItemRect; window->DC.LastItemRectHoveredRect = LastItemRectHoveredRect; }
+};
+
 //-----------------------------------------------------------------------------
 // Internal API
 // No guarantee of forward compatibility here.
@@ -702,45 +863,76 @@ namespace ImGui
     // - ImGui::NewFrame() has never been called, which is illegal.
     // - You are calling ImGui functions after ImGui::Render() and before the next ImGui::NewFrame(), which is also illegal.
     inline    ImGuiWindow*  GetCurrentWindowRead()      { ImGuiContext& g = *GImGui; return g.CurrentWindow; }
-    inline    ImGuiWindow*  GetCurrentWindow()          { ImGuiContext& g = *GImGui; g.CurrentWindow->Accessed = true; return g.CurrentWindow; }
+    inline    ImGuiWindow*  GetCurrentWindow()          { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }
-    IMGUI_API ImGuiWindow*  GetParentWindow();
     IMGUI_API ImGuiWindow*  FindWindowByName(const char* name);
     IMGUI_API void          FocusWindow(ImGuiWindow* window);
+    IMGUI_API void          BringWindowToFront(ImGuiWindow* window);
+    IMGUI_API void          BringWindowToBack(ImGuiWindow* window);
+    IMGUI_API bool          IsWindowChildOf(ImGuiWindow* window, ImGuiWindow* potential_parent);
 
-    IMGUI_API void          EndFrame();                 // Ends the ImGui frame. Automatically called by Render()! you most likely don't need to ever call that yourself directly. If you don't need to render you can call EndFrame() but you'll have wasted CPU already. If you don't need to render, don't create any windows instead!
+    IMGUI_API void          Initialize();
+
+    IMGUI_API void                  MarkIniSettingsDirty();
+    IMGUI_API ImGuiSettingsHandler* FindSettingsHandler(ImGuiID type_id);
+    IMGUI_API ImGuiWindowSettings*  FindWindowSettings(ImGuiID id);
 
     IMGUI_API void          SetActiveID(ImGuiID id, ImGuiWindow* window);
-	IMGUI_API void          ClearActiveID();
+    IMGUI_API void          ClearActiveID();
     IMGUI_API void          SetHoveredID(ImGuiID id);
     IMGUI_API void          KeepAliveID(ImGuiID id);
 
     IMGUI_API void          ItemSize(const ImVec2& size, float text_offset_y = 0.0f);
     IMGUI_API void          ItemSize(const ImRect& bb, float text_offset_y = 0.0f);
-    IMGUI_API bool          ItemAdd(const ImRect& bb, const ImGuiID* id);
+    IMGUI_API bool          ItemAdd(const ImRect& bb, ImGuiID id);
-    IMGUI_API bool          IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged);
+    IMGUI_API bool          ItemHoverable(const ImRect& bb, ImGuiID id);
-    IMGUI_API bool          IsHovered(const ImRect& bb, ImGuiID id, bool flatten_childs = false);
+    IMGUI_API bool          IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged);
-    IMGUI_API bool          FocusableItemRegister(ImGuiWindow* window, bool is_active, bool tab_stop = true);      // Return true if focus is requested
+    IMGUI_API bool          FocusableItemRegister(ImGuiWindow* window, ImGuiID id, bool tab_stop = true);      // Return true if focus is requested
     IMGUI_API void          FocusableItemUnregister(ImGuiWindow* window);
     IMGUI_API ImVec2        CalcItemSize(ImVec2 size, float default_x, float default_y);
     IMGUI_API float         CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x);
+    IMGUI_API void          PushMultiItemsWidths(int components, float width_full = 0.0f);
+    IMGUI_API void          PushItemFlag(ImGuiItemFlags option, bool enabled);
+    IMGUI_API void          PopItemFlag();
 
-    IMGUI_API void          OpenPopupEx(const char* str_id, bool reopen_existing);
+    IMGUI_API void          OpenPopupEx(ImGuiID id, bool reopen_existing);
+    IMGUI_API void          ClosePopup(ImGuiID id);
+    IMGUI_API bool          IsPopupOpen(ImGuiID id);
+    IMGUI_API bool          BeginPopupEx(ImGuiID id, ImGuiWindowFlags extra_flags);
+    IMGUI_API void          BeginTooltipEx(ImGuiWindowFlags extra_flags, bool override_previous_tooltip = true);
 
-    // NB: All position are in absolute pixels coordinates (not window coordinates)
+    IMGUI_API int           CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate);
-    // FIXME: All those functions are a mess and needs to be refactored into something decent. AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION.
+
-    // We need: a sort of symbol library, preferably baked into font atlas when possible + decent text rendering helpers.
+    IMGUI_API void          Scrollbar(ImGuiLayoutType direction);
+    IMGUI_API void          VerticalSeparator();        // Vertical separator, for menu bars (use current line height). not exposed because it is misleading what it doesn't have an effect on regular layout.
+    IMGUI_API bool          SplitterBehavior(ImGuiID id, const ImRect& bb, ImGuiAxis axis, float* size1, float* size2, float min_size1, float min_size2, float hover_extend = 0.0f);
+
+    IMGUI_API bool          BeginDragDropTargetCustom(const ImRect& bb, ImGuiID id);
+    IMGUI_API void          ClearDragDrop();
+    IMGUI_API bool          IsDragDropPayloadBeingAccepted();
+
+    // FIXME-WIP: New Columns API
+    IMGUI_API void          BeginColumns(const char* str_id, int count, ImGuiColumnsFlags flags = 0); // setup number of columns. use an identifier to distinguish multiple column sets. close with EndColumns().
+    IMGUI_API void          EndColumns();                                                             // close columns
+    IMGUI_API void          PushColumnClipRect(int column_index = -1);
+
+    // NB: All position are in absolute pixels coordinates (never using window coordinates internally)
+    // AVOID USING OUTSIDE OF IMGUI.CPP! NOT FOR PUBLIC CONSUMPTION. THOSE FUNCTIONS ARE A MESS. THEIR SIGNATURE AND BEHAVIOR WILL CHANGE, THEY NEED TO BE REFACTORED INTO SOMETHING DECENT.
     IMGUI_API void          RenderText(ImVec2 pos, const char* text, const char* text_end = NULL, bool hide_text_after_hash = true);
     IMGUI_API void          RenderTextWrapped(ImVec2 pos, const char* text, const char* text_end, float wrap_width);
     IMGUI_API void          RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align = ImVec2(0,0), const ImRect* clip_rect = NULL);
     IMGUI_API void          RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border = true, float rounding = 0.0f);
-    IMGUI_API void          RenderCollapseTriangle(ImVec2 pos, bool is_open, float scale = 1.0f);
+    IMGUI_API void          RenderFrameBorder(ImVec2 p_min, ImVec2 p_max, float rounding = 0.0f);
+    IMGUI_API void          RenderColorRectWithAlphaCheckerboard(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, float grid_step, ImVec2 grid_off, float rounding = 0.0f, int rounding_corners_flags = ~0);
+    IMGUI_API void          RenderTriangle(ImVec2 pos, ImGuiDir dir, float scale = 1.0f);
     IMGUI_API void          RenderBullet(ImVec2 pos);
-    IMGUI_API void          RenderCheckMark(ImVec2 pos, ImU32 col);
+    IMGUI_API void          RenderCheckMark(ImVec2 pos, ImU32 col, float sz);
+    IMGUI_API void          RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding);
     IMGUI_API const char*   FindRenderedTextEnd(const char* text, const char* text_end = NULL); // Find the optional ## from which we stop displaying text.
 
     IMGUI_API bool          ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags = 0);
     IMGUI_API bool          ButtonEx(const char* label, const ImVec2& size_arg = ImVec2(0,0), ImGuiButtonFlags flags = 0);
     IMGUI_API bool          CloseButton(ImGuiID id, const ImVec2& pos, float radius);
+    IMGUI_API bool          ArrowButton(ImGuiID id, ImGuiDir dir, ImVec2 padding, ImGuiButtonFlags flags = 0);
 
     IMGUI_API bool          SliderBehavior(const ImRect& frame_bb, ImGuiID id, float* v, float v_min, float v_max, float power, int decimal_precision, ImGuiSliderFlags flags = 0);
     IMGUI_API bool          SliderFloatN(const char* label, float* v, int components, float v_min, float v_max, const char* display_format, float power);
@@ -756,6 +948,9 @@ namespace ImGui
     IMGUI_API bool          InputScalarEx(const char* label, ImGuiDataType data_type, void* data_ptr, void* step_ptr, void* step_fast_ptr, const char* scalar_format, ImGuiInputTextFlags extra_flags);
     IMGUI_API bool          InputScalarAsWidgetReplacement(const ImRect& aabb, const char* label, ImGuiDataType data_type, void* data_ptr, ImGuiID id, int decimal_precision);
 
+    IMGUI_API void          ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags);
+    IMGUI_API void          ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags);
+
     IMGUI_API bool          TreeNodeBehavior(ImGuiID id, ImGuiTreeNodeFlags flags, const char* label, const char* label_end = NULL);
     IMGUI_API bool          TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags = 0);                     // Consume previous SetNextTreeNodeOpened() data, if any. May return true when logging
     IMGUI_API void          TreePushRawID(ImGuiID id);
@@ -765,8 +960,22 @@ namespace ImGui
     IMGUI_API int           ParseFormatPrecision(const char* fmt, int default_value);
     IMGUI_API float         RoundScalar(float value, int decimal_precision);
 
+    // Shade functions
+    IMGUI_API void          ShadeVertsLinearColorGradientKeepAlpha(ImDrawVert* vert_start, ImDrawVert* vert_end, ImVec2 gradient_p0, ImVec2 gradient_p1, ImU32 col0, ImU32 col1);
+    IMGUI_API void          ShadeVertsLinearAlphaGradientForLeftToRightText(ImDrawVert* vert_start, ImDrawVert* vert_end, float gradient_p0_x, float gradient_p1_x);
+    IMGUI_API void          ShadeVertsLinearUV(ImDrawVert* vert_start, ImDrawVert* vert_end, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp);
+
 } // namespace ImGui
 
+// ImFontAtlas internals
+IMGUI_API bool              ImFontAtlasBuildWithStbTruetype(ImFontAtlas* atlas);
+IMGUI_API void              ImFontAtlasBuildRegisterDefaultCustomRects(ImFontAtlas* atlas);
+IMGUI_API void              ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent); 
+IMGUI_API void              ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* spc);
+IMGUI_API void              ImFontAtlasBuildFinish(ImFontAtlas* atlas);
+IMGUI_API void              ImFontAtlasBuildMultiplyCalcLookupTable(unsigned char out_table[256], float in_multiply_factor);
+IMGUI_API void              ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride);
+
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif