I have returned!
This commit is contained in:
parent
007fbd6587
commit
8ffe61ba5f
|
|
@ -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},
|
||||
},
|
||||
}
|
||||
4
data/init.lua
Normal file
4
data/init.lua
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
util = require("data.util")
|
||||
|
||||
dungeon.add_actors(require("data.actors"))
|
||||
dungeon.add_tiles(require("data.tiles"))
|
||||
|
|
@ -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}
|
||||
bg = {.6,.6,.9,1}, -- what color to paint the rect behind the tile
|
||||
fg = {0.1,0.1,0.3,1.0}, -- what color to tint the tile with, {R,G,B,A}
|
||||
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},
|
||||
bg = {.4,.2,.1,1},
|
||||
fg = {0.1,0.05,0.05,1.0},
|
||||
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},
|
||||
bg = {.1,.1,.2,1},
|
||||
fg = {0.8,0.8,1.0,1.0},
|
||||
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},
|
||||
bg = {.1,.1,.2,1},
|
||||
fg = {0.8,0.8,1.0,1.0},
|
||||
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},
|
||||
bg = {.1,.1,.2,1},
|
||||
fg = {0.8,0.8,1.0,1.0},
|
||||
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},
|
||||
fg = {i/dijkstra_debug_amount,1-i/dijkstra_debug_amount,0,1},
|
||||
bg = {0.0,0.0,0.0,1.0},
|
||||
fg = {i/dijkstra_debug_amount,1-i/dijkstra_debug_amount,0.0,1.0},
|
||||
passable = true,
|
||||
opaque = false,
|
||||
wall = false,
|
||||
|
|
|
|||
50
data/util.lua
Normal file
50
data/util.lua
Normal file
|
|
@ -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
|
||||
|
|
@ -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" />
|
||||
|
|
|
|||
|
|
@ -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>
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
};
|
||||
|
|
|
|||
15
src/Item.h
Normal file
15
src/Item.h
Normal file
|
|
@ -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() {};
|
||||
};
|
||||
|
||||
74
src/LuaHandler.cpp
Normal file
74
src/LuaHandler.cpp
Normal file
|
|
@ -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");
|
||||
}
|
||||
14
src/LuaHandler.h
Normal file
14
src/LuaHandler.h
Normal file
|
|
@ -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;
|
||||
};
|
||||
|
|
@ -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" }, {});
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#pragma once
|
||||
#include "Tilemap.h"
|
||||
|
||||
Tilemap generate_dungeon(int width, int height, TileSet tileset);
|
||||
Tilemap generate_dungeon(unsigned int seed, 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);
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
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"));
|
||||
app->input->bind_key(SDLK_ESCAPE, ACTION_ESCAPE_MENU);
|
||||
|
||||
// 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.y = rng.get_int(1, tilemap.get_width() - 1);
|
||||
t = tilemap.get_tile(heropos.x, heropos.y);
|
||||
heropos.x = 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);
|
||||
} 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);
|
||||
if(act == nullptr) {
|
||||
std::vector<Actor*> actors = tilemap->get_actors(heropos.x + dir.x, heropos.y + dir.y, 0);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -9,69 +9,8 @@ TileSet::TileSet() {}
|
|||
|
||||
TileSet::~TileSet() {}
|
||||
|
||||
void TileSet::load_from_table(kaguya::LuaStackRef table) {
|
||||
for (std::string key : table.keys()) {
|
||||
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());
|
||||
}
|
||||
}
|
||||
int TileSet::count() const {
|
||||
return tiles.size();
|
||||
}
|
||||
|
||||
void TileSet::add_tile(std::string name, Tile tile) {
|
||||
|
|
|
|||
|
|
@ -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 = {});
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -1,48 +1,27 @@
|
|||
#include "World.h"
|
||||
#include <time.h>
|
||||
#include <cstdlib>
|
||||
|
||||
World::World() {
|
||||
World(0);
|
||||
}
|
||||
#include "Mapgen.h"
|
||||
#include "TileSet.h"
|
||||
|
||||
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) {
|
||||
if (level < seeds.size()) {
|
||||
if (maps[level] != nullptr) {
|
||||
return maps[level];
|
||||
}
|
||||
else {
|
||||
Tilemap* map = new Tilemap(TileSet(),64, 64);
|
||||
// TODO: generate map
|
||||
maps[level] = map;
|
||||
return map;
|
||||
}
|
||||
Tilemap& World::GetMap(unsigned int level, TileSet& tileset) {
|
||||
if (maps[level].get_height() > 1) {
|
||||
return maps[level];
|
||||
}
|
||||
else {
|
||||
maps[level] = generate_dungeon(seeds[level], 64, 64, tileset);
|
||||
return maps[level];
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
World::~World() {
|
||||
seeds.clear();
|
||||
for (Tilemap* map : maps) {
|
||||
if (map != nullptr) {
|
||||
delete map;
|
||||
}
|
||||
}
|
||||
maps.clear();
|
||||
}
|
||||
World::~World() {}
|
||||
|
|
|
|||
|
|
@ -4,14 +4,12 @@
|
|||
|
||||
class World {
|
||||
public:
|
||||
World();
|
||||
World(unsigned int seed);
|
||||
void Init();
|
||||
Tilemap* GetMap(unsigned int level); // returns null if invalid level or if not initialized
|
||||
World(unsigned int seed = 0);
|
||||
Tilemap& GetMap(unsigned int level, TileSet& tileset);
|
||||
~World();
|
||||
|
||||
private:
|
||||
int worldseed;
|
||||
std::vector<unsigned int> seeds;
|
||||
std::vector<Tilemap*> maps;
|
||||
std::vector<Tilemap> maps;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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_IME_FUNCS
|
||||
//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS
|
||||
//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS
|
||||
|
||||
//---- Don't implement help and test window functionality (ShowUserGuide()/ShowStyleEditor()/ShowTestWindow() methods will be empty)
|
||||
//#define IMGUI_DISABLE_TEST_WINDOWS
|
||||
//---- Don't implement demo windows functionality (ShowDemoWindow()/ShowStyleEditor()/ShowUserGuide() methods will be empty)
|
||||
//---- 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
|
||||
#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
|
||||
//---- Don't implement ImFormatString(), ImFormatStringV() so you can reimplement them yourself.
|
||||
//#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.
|
||||
|
|
|
|||
5868
src/imgui.cpp
5868
src/imgui.cpp
File diff suppressed because it is too large
Load diff
890
src/imgui.h
890
src/imgui.h
File diff suppressed because it is too large
Load diff
1544
src/imgui_demo.cpp
1544
src/imgui_demo.cpp
File diff suppressed because it is too large
Load diff
1140
src/imgui_draw.cpp
1140
src/imgui_draw.cpp
File diff suppressed because it is too large
Load diff
|
|
@ -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 ImGuiButtonFlags; // enum ImGuiButtonFlags_
|
||||
typedef int ImGuiTreeNodeFlags; // enum ImGuiTreeNodeFlags_
|
||||
typedef int ImGuiSliderFlags; // enum ImGuiSliderFlags_
|
||||
typedef int ImGuiLayoutType; // enum: horizontal or vertical // enum ImGuiLayoutType_
|
||||
typedef int ImGuiButtonFlags; // flags: for ButtonEx(), ButtonBehavior() // enum ImGuiButtonFlags_
|
||||
typedef int ImGuiItemFlags; // flags: for PushItemFlag() // enum ImGuiItemFlags_
|
||||
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_OFFSETOF(_TYPE,_ELM) ((size_t)&(((_TYPE*)0)->_ELM))
|
||||
#define IM_PI 3.14159265358979323846f
|
||||
#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 bool ImIsPointInTriangle(const ImVec2& p, const ImVec2& a, const ImVec2& b, const ImVec2& c);
|
||||
IMGUI_API FILE* ImFileOpen(const char* filename, const char* file_open_mode);
|
||||
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 ImFormatStringV(char* buf, int buf_size, const char* fmt, va_list args);
|
||||
IMGUI_API int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...) IM_FMTARGS(3);
|
||||
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 ImPlacementNewDummy {};
|
||||
inline void* operator new(size_t, ImPlacementNewDummy, void* ptr) { return ptr; }
|
||||
inline void operator delete(void*, ImPlacementNewDummy, void*) {}
|
||||
#define IM_PLACEMENT_NEW(_PTR) new(ImPlacementNewDummy(), _PTR)
|
||||
#endif
|
||||
struct ImNewPlacementDummy {};
|
||||
inline void* operator new(size_t, ImNewPlacementDummy, void* ptr) { return ptr; }
|
||||
inline void operator delete(void*, ImNewPlacementDummy, void*) {} // This is only required so we can use the symetrical new()
|
||||
#define IM_PLACEMENT_NEW(_PTR) new(ImNewPlacementDummy(), _PTR)
|
||||
#define IM_NEW(_TYPE) new(ImNewPlacementDummy(), ImGui::MemAlloc(sizeof(_TYPE))) _TYPE
|
||||
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_PressedOnClick = 1 << 2, // return pressed on click (default requires click+release)
|
||||
ImGuiButtonFlags_PressedOnRelease = 1 << 3, // return pressed on release (default requires click+release)
|
||||
ImGuiButtonFlags_PressedOnDoubleClick = 1 << 4, // return pressed on double-click (default requires click+release)
|
||||
ImGuiButtonFlags_FlattenChilds = 1 << 5, // allow interaction even if a child window is overlapping
|
||||
ImGuiButtonFlags_DontClosePopups = 1 << 6, // disable automatically closing parent popup on press
|
||||
ImGuiButtonFlags_Disabled = 1 << 7, // disable interaction
|
||||
ImGuiButtonFlags_AlignTextBaseLine = 1 << 8, // vertically align button to match text baseline - ButtonEx() only
|
||||
ImGuiButtonFlags_NoKeyModifiers = 1 << 9, // disable interaction if a key modifier is held
|
||||
ImGuiButtonFlags_AllowOverlapMode = 1 << 10 // require previous frame HoveredId to either match id or be null before being usable
|
||||
ImGuiButtonFlags_PressedOnClickRelease = 1 << 1, // return true on click + release on same item [DEFAULT if no PressedOn* flag is set]
|
||||
ImGuiButtonFlags_PressedOnClick = 1 << 2, // return true on click (default requires click+release)
|
||||
ImGuiButtonFlags_PressedOnRelease = 1 << 3, // return true on release (default requires click+release)
|
||||
ImGuiButtonFlags_PressedOnDoubleClick = 1 << 4, // return true on double-click (default requires click+release)
|
||||
ImGuiButtonFlags_FlattenChildren = 1 << 5, // allow interactions even if a child window is overlapping
|
||||
ImGuiButtonFlags_AllowItemOverlap = 1 << 6, // require previous frame HoveredId to either match id or be null before being usable, use along with SetItemAllowOverlap()
|
||||
ImGuiButtonFlags_DontClosePopups = 1 << 7, // disable automatically closing parent popup on press // [UNUSED]
|
||||
ImGuiButtonFlags_Disabled = 1 << 8, // disable interactions
|
||||
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_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_MenuItem = 1 << 4,
|
||||
ImGuiSelectableFlags_Menu = 1 << 3, // -> PressedOnClick
|
||||
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
|
||||
ImGuiCorner_TopRight = 1 << 1, // 2
|
||||
ImGuiCorner_BottomRight = 1 << 2, // 4
|
||||
ImGuiCorner_BottomLeft = 1 << 3, // 8
|
||||
ImGuiCorner_All = 0x0F
|
||||
ImGuiDir_None = -1,
|
||||
ImGuiDir_Left = 0,
|
||||
ImGuiDir_Right = 1,
|
||||
ImGuiDir_Up = 2,
|
||||
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 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 Translate(const ImVec2& v) { Min.x += v.x; Min.y += v.y; Max.x += v.x; Max.y += v.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()
|
||||
ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
|
||||
ImGuiWindow* ParentWindow; // Set on OpenPopup()
|
||||
ImGuiID ParentMenuSet; // Set on OpenPopup()
|
||||
ImVec2 MousePosOnOpen; // Copy of mouse position at the time of opening popup
|
||||
ImGuiID PopupId; // Set on OpenPopup()
|
||||
ImGuiWindow* Window; // Resolved on BeginPopup() - may stay unresolved if user never calls OpenPopup()
|
||||
ImGuiWindow* ParentWindow; // Set on OpenPopup()
|
||||
ImGuiID ParentMenuSet; // Set on OpenPopup()
|
||||
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 FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Size of characters.
|
||||
ImVec2 FontTexUvWhitePixel; // (Shortcut) == Font->TexUvWhitePixel
|
||||
float FontSize; // (Shortcut) == FontBaseSize * g.CurrentWindow->FontWindowScale == window->FontSize(). Text height for current window.
|
||||
float FontBaseSize; // (Shortcut) == IO.FontGlobalScale * Font->Scale * Font->FontSize. Base text height.
|
||||
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.
|
||||
ImGuiID MovedWindowMoveId; // == MovedWindow->RootWindow->MoveId
|
||||
ImVector<ImGuiIniData> Settings; // .ini Settings
|
||||
float SettingsDirtyTimer; // Save .ini Settings on disk when time reaches zero
|
||||
ImGuiWindow* MovingWindow; // Track the child window we clicked on to move a window.
|
||||
ImGuiID MovingWindowMoveId; // == MovingWindow->MoveId
|
||||
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;
|
||||
ImGuiSetCond SetNextWindowSizeCond;
|
||||
ImGuiSetCond SetNextWindowContentSizeCond;
|
||||
ImGuiSetCond SetNextWindowCollapsedCond;
|
||||
ImGuiCond SetNextWindowPosCond;
|
||||
ImGuiCond SetNextWindowSizeCond;
|
||||
ImGuiCond SetNextWindowContentSizeCond;
|
||||
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];
|
||||
char* PrivateClipboard; // If no custom clipboard handler is defined
|
||||
int TooltipOverrideCount;
|
||||
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 CaptureKeyboardNextFrame;
|
||||
int WantCaptureMouseNextFrame; // explicit capture via CaptureInputs() sets those flags
|
||||
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;
|
||||
MovedWindowMoveId = 0;
|
||||
SettingsDirtyTimer = 0.0f;
|
||||
MovingWindow = NULL;
|
||||
MovingWindowMoveId = 0;
|
||||
|
||||
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));
|
||||
PrivateClipboard = NULL;
|
||||
TooltipOverrideCount = 0;
|
||||
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 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 LastItemRectHoveredRect;
|
||||
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]
|
||||
bool ButtonRepeat; // == ButtonRepeatStack.back() [empty == false]
|
||||
ImVector<ImGuiItemFlags>ItemFlagsStack;
|
||||
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;
|
||||
int ColumnsCount;
|
||||
float ColumnsMinX;
|
||||
float ColumnsMaxX;
|
||||
float ColumnsStartPosY;
|
||||
float ColumnsCellMinY;
|
||||
float ColumnsCellMaxY;
|
||||
bool ColumnsShowBorders;
|
||||
ImGuiID ColumnsSetId;
|
||||
ImVector<ImGuiColumnData> ColumnsData;
|
||||
ImGuiColumnsSet* ColumnsSet; // Current columns set
|
||||
|
||||
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);
|
||||
LastItemHoveredAndUsable = LastItemHoveredRect = false;
|
||||
LastItemRect = ImRect();
|
||||
LastItemRectHoveredRect = false;
|
||||
MenuBarAppending = false;
|
||||
MenuBarOffsetX = 0.0f;
|
||||
StateStorage = NULL;
|
||||
LayoutType = ImGuiLayoutType_Vertical;
|
||||
ItemWidth = 0.0f;
|
||||
ButtonRepeat = false;
|
||||
AllowKeyboardFocus = true;
|
||||
ItemFlags = ImGuiItemFlags_Default_;
|
||||
TextWrapPos = -1.0f;
|
||||
ColorEditMode = ImGuiColorEditMode_RGB;
|
||||
memset(StackSizesBackup, 0, sizeof(StackSizesBackup));
|
||||
|
||||
IndentX = 0.0f;
|
||||
GroupOffsetX = 0.0f;
|
||||
ColumnsOffsetX = 0.0f;
|
||||
ColumnsCurrent = 0;
|
||||
ColumnsCount = 1;
|
||||
ColumnsMinX = ColumnsMaxX = 0.0f;
|
||||
ColumnsStartPosY = 0.0f;
|
||||
ColumnsCellMinY = ColumnsCellMaxY = 0.0f;
|
||||
ColumnsShowBorders = true;
|
||||
ColumnsSetId = 0;
|
||||
ColumnsSet = NULL;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -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.
|
||||
int SetWindowSizeAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowSize() call will succeed with this particular flag.
|
||||
int SetWindowCollapsedAllowFlags; // bit ImGuiSetCond_*** specify if SetWindowCollapsed() call will succeed with this particular flag.
|
||||
bool SetWindowPosCenterWanted;
|
||||
ImGuiCond SetWindowPosAllowFlags; // store condition flags for next SetWindowPos() call.
|
||||
ImGuiCond SetWindowSizeAllowFlags; // store condition flags for next SetWindowSize() call.
|
||||
ImGuiCond SetWindowCollapsedAllowFlags; // store condition flags for next SetWindowCollapsed() call.
|
||||
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* RootNonPopupWindow; // If we are a child window, this is pointing to the first non-child non-popup parent window. Else point to ourself.
|
||||
ImGuiWindow* ParentWindow; // If we are a child window, this is pointing to our parent window. Else point to NULL.
|
||||
ImGuiWindow* ParentWindow; // If we are a child _or_ popup window, this is pointing to our parent. Otherwise NULL.
|
||||
ImGuiWindow* RootWindow; // Generally point to ourself. If we are a child window, this is pointing to the first non-child parent window.
|
||||
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; }
|
||||
IMGUI_API ImGuiWindow* GetParentWindow();
|
||||
inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; }
|
||||
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 IsClippedEx(const ImRect& bb, const ImGuiID* id, bool clip_even_when_logged);
|
||||
IMGUI_API bool IsHovered(const ImRect& bb, ImGuiID id, bool flatten_childs = false);
|
||||
IMGUI_API bool FocusableItemRegister(ImGuiWindow* window, bool is_active, bool tab_stop = true); // Return true if focus is requested
|
||||
IMGUI_API bool ItemAdd(const ImRect& bb, ImGuiID id);
|
||||
IMGUI_API bool ItemHoverable(const ImRect& bb, ImGuiID id);
|
||||
IMGUI_API bool IsClippedEx(const ImRect& bb, ImGuiID id, bool clip_even_when_logged);
|
||||
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)
|
||||
// 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 int CalcTypematicPressedRepeatAmount(float t, float t_prev, float repeat_delay, float repeat_rate);
|
||||
|
||||
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
|
||||
|
|
|
|||
Loading…
Reference in a new issue