tyromaniac/pleascach
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revived the project, it seems to be mostly functional right now in terms of load/unloading files of scenes. Not yet tested on linux.

Browse Source
This commit is contained in:
connellpaxton 2025-03-30 23:40:19 -04:00
parent a3efba825f
commit f3fa22c3c5
31 changed files with 4526 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -38,12 +38,13 @@ foreach(SHADER_SOURCE ${SHADER_SOURCE_FILES})
set(SPIRV "${CMAKE_SOURCE_DIR}/assets/shaders/${FILE_NAME}.spv")
add_custom_command(
OUTPUT ${SPIRV}
COMMAND ${Vulkan_GLSLC_EXECUTABLE} -o ${SPIRV} ${SHADER_SOURCE}
COMMAND glslc -o ${SPIRV} ${SHADER_SOURCE}
DEPENDS ${SHADER_SOURCE}
)
list(APPEND SPIRV_BIN_FILES ${SPIRV})
endforeach(SHADER_SOURCE)
add_custom_target (
shaders
DEPENDS ${SPIRV_BIN_FILES}

11
Input/Input.cpp
View File

@ -74,7 +74,7 @@ void Input::setCursor(bool enabled) {
}
void Input::handleMovementKeys(Renderer& ren) {
if (ImGui::GetIO().WantCaptureKeyboard)
if (ImGui::GetIO().WantCaptureKeyboard && ren.in_menu)
return;
auto dir = ren.cam.dir();
@ -139,16 +139,17 @@ void Input::handleCursorMovement(Renderer& ren, double x, double y) {
int rel_mouse_y = static_cast<int>(y) - last_mouse.y;
auto& io = ImGui::GetIO();
if (io.WantCaptureMouse)
if (io.WantCaptureMouse && ren.in_menu)
return;
if (!ren.capture_mouse) {
if (ren.in_menu) {
io.AddMousePosEvent(x, y);
return;
}
ren.cam.phi += rel_mouse_x / 100.0;
ren.cam.theta += rel_mouse_y / 100.0;
// scaling factor
ren.cam.phi += rel_mouse_x / 200.0;
ren.cam.theta += rel_mouse_y / 200.0;
last_mouse = glm::vec2(x,y);

59
Renderer/Renderer.cpp
View File

@ -15,6 +15,8 @@
#include <Renderer/UniformBuffer.hpp>
#include <Renderer/VertexBuffer.hpp>
#include <Scene/March.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <UI/UI.hpp>
@ -192,10 +194,42 @@ Renderer::Renderer(Window& win) : win(win) {
uniform_buffer = std::make_unique<UniformBuffer>(phys_dev, dev);
/* load map */
bsp = std::make_unique<Q3BSP::BSP>("assets/maps/git.bsp");
objects.reserve(2);
uint id = 0;
objects.push_back(Object{
.center = glm::vec4(0.0),
.dimensions = glm::vec4(1.0),
.id = id,
.shape = Shape::eSPHERE,
});
objects.push_back(Object{
.center = glm::vec4(1.0),
.dimensions = glm::vec4(0.5),
.id = id,
.shape = Shape::eBOX,
});
#if 0
for (const auto& plane : bsp->planes) {
/* for planes, center.xyz holds normal, dimensions.x holds distance */
objects.push_back(Object{
.center = glm::vec4(plane.norm, 0.0),
.dimensions = glm::vec4(plane.dist, 0.0, 0.0, 0.0),
.id = id,
.shape = Shape::ePLANE,
});
id++;
}
#endif
shader_buffer = std::make_unique<ShaderBuffer>(phys_dev, dev, MAX_OBJECTS);
shader_buffer->upload(objects);
shader_buffer = std::make_unique<ShaderBuffer>(phys_dev, dev, bsp->planes.size());
textures = createResources({
"assets/textures/oil.jpg",
@ -224,21 +258,6 @@ Renderer::Renderer(Window& win) : win(win) {
{ { -1.0,-1.0 } },
});
objects.reserve(bsp->planes.size());
uint id = 0;
for (const auto& plane : bsp->planes) {
/* for planes, center.xyz holds normal, dimensions.x holds distance */
objects.push_back(Object{
.center = glm::vec4(plane.norm, 0.0),
.dimensions = glm::vec4(plane.dist, 0.0, 0.0, 0.0),
.id = id,
.shape = Shape::ePLANE,
});
id++;
}
shader_buffer->upload(objects);
pipeline = std::make_unique<GraphicsPipeline>(dev, shaders, swapchain->extent, *render_pass, bindings, *vertex_buffer);
pipeline->update(0, *uniform_buffer);
@ -349,7 +368,7 @@ void Renderer::draw() {
.time = time,
.viewport = glm::vec4(viewport.width, viewport.y, 0.0, 0.0),
.cam_dir = cam.dir(),
.n_objects = 2,
.n_objects = static_cast<unsigned int>(objects.size()),
.rad = rad,
});
@ -406,7 +425,9 @@ void Renderer::present() {
default:
Log::error("Failed to present surface.\n");
break;
}
time += frametime / 1000.0 * speed * static_cast<float>(!paused);
frame++;
}

17
Renderer/Renderer.hpp
View File

@ -10,7 +10,7 @@
#include <Renderer/ShaderBuffer.hpp>
#include <Renderer/Swapchain.hpp>
#include <Scene/BSP.hpp>
#include <map>
#include <Scene/Camera.hpp>
#include <UI/UI.hpp>
@ -20,6 +20,8 @@ struct UniformBuffer;
struct VertexBuffer;
struct Texture;
#define MAX_OBJECTS 256
/* Contains all of the Vulkan objects involved in rendering the scene */
struct Renderer {
Renderer(Window& win);
@ -55,8 +57,6 @@ struct Renderer {
std::vector<Texture> textures;
std::unique_ptr<Q3BSP::BSP> bsp;
uint32_t current_image_idx;
uint64_t frame = 0;
@ -70,7 +70,18 @@ struct Renderer {
bool flycam = false;
/* time speed */
float time = 0.0;
float frametime = 0.0;
float fps = 0.0;
float max_fps = 60.0;
float speed = 1.0;
float rad = 1.0;
bool in_menu = false;
bool should_close = false;
bool paused = false;
bool running = true;
std::map<std::string, int> scene_map;
std::string scene_file = "scene.txt";
};

62
Scene/BSP.cpp
View File

@ -1,62 +0,0 @@
#include <Scene/BSP.hpp>
#include <util/file.hpp>
#include <util/log.hpp>
#include <cstring>
using namespace Q3BSP;
static inline void copy_data(void* file_data, std::string& dst, Lump& lump) {
dst.resize(lump.len);
std::memcpy(dst.data(), (u8*)file_data + (size_t)lump.offset, lump.len);
}
template<typename T>
static inline void copy_data(void* file_data, std::vector<T>& dst, Lump& lump) {
Log::debug("Size: %zu (%zu)\n", lump.len/sizeof(T), lump.len);
dst.resize(lump.len / sizeof(T));
puts("ALLOC'D");
//Log::debug("%p %p\n", dst.data(), (u8*)file_data + lump.offset);
std::memcpy(dst.data(), ((u8*)file_data) + lump.offset, lump.len);
}
BSP::BSP(const std::string& fname) : filename(fname) {
file_data = file::slurpb(fname);
Log::debug("File size: %zu\n", file_data.size());
header = reinterpret_cast<Header*>(file_data.data());
Log::info("Loading BSP: %s\n", fname.c_str());
if(header->magic != BSP_MAGIC) {
Log::error("BSP file missing magic!\n");
}
for (size_t i = 0; i < std::size(header->lumps); i++) {
Log::debug("%i: Offset: %u | Length: %u\n", i, header->lumps[i].offset, header->lumps[i].len);
Log::debug("\tPointer: 0x%p\n", (u8*)file_data.data() + (size_t)header->lumps[i].offset);
}
copy_data(file_data.data(), entities, header->entities);
copy_data(file_data.data(), textures, header->textures);
copy_data(file_data.data(), planes, header->planes);
copy_data(file_data.data(), nodes, header->nodes);
copy_data(file_data.data(), leafs, header->leafs);
copy_data(file_data.data(), leaf_faces, header->leaf_faces);
copy_data(file_data.data(), leaf_brushes, header->leaf_brushes);
copy_data(file_data.data(), models, header->models);
copy_data(file_data.data(), brushes, header->brushes);
copy_data(file_data.data(), brush_sides, header->brush_sides);
copy_data(file_data.data(), vertices, header->vertices);
copy_data(file_data.data(), mesh_vertices, header->mesh_vertices);
copy_data(file_data.data(), effects, header->effects);
copy_data(file_data.data(), faces, header->faces);
copy_data(file_data.data(), lightmaps, header->lightmaps);
copy_data(file_data.data(), lightvols, header->lightvols);
vis_info.sz_vectors = reinterpret_cast<u32*>(file_data.data() + header->vis_info.offset)[1];
auto sz = header->vis_info.len;
Log::debug("Size: %u\n", sz);
vis_info.vectors.resize(sz);
std::memcpy(vis_info.vectors.data(), file_data.data() + header->vis_info.offset + 2*sizeof(u32), sz);
}

194
Scene/BSP.hpp
View File

@ -1,194 +0,0 @@
#pragma once
#include <util/int.hpp>
#include <glm/glm.hpp>
#include <vector>
#include <string>
/* contains loading functions for Quake III-style BSPs */
namespace Q3BSP {
struct Lump {
u32 offset;
u32 len;
};
using rgb = glm::u8vec3;
using rgba = glm::u8vec4;
/* "IBSP" */
const uint32_t BSP_MAGIC = 0x50534249U;
struct Header {
u32 magic;
u32 version;
union {
Lump lumps[17];
struct {
Lump entities,
textures,
planes,
nodes,
leafs,
leaf_faces,
leaf_brushes,
models,
brushes,
brush_sides,
vertices,
mesh_vertices,
effects,
faces,
lightmaps,
lightvols,
vis_info;
};
};
};
struct Texture {
char name[64];
/* values of unknown meaning - TODO: check darkplaces or some other 3rd party loader */
i32 flags;
i32 contents;
};
struct Plane {
glm::vec3 norm;
float dist;
};
struct Node {
u32 plane;
/* negative numbers are leaf indices */
i32 children[2];
/* bounding box coords (integer) */
glm::ivec3 bb_mins;
glm::ivec3 bb_maxes;
};
struct Leaf {
i32 cluster_idx;
u32 area;
glm::ivec3 bb_mins;
glm::ivec3 bb_maxes;
i32 first_leaf_face_idx;
u32 n_leaf_faces;
i32 first_leaf_brush_idx;
u32 n_leaf_brushes;
};
struct LeafFaces {
/* list of face indices (one list per leaf) */
i32 face_idx;
};
struct LeafBrush {
/* list of brush indices (one list leaf) */
i32 brush_idx;
};
struct Model {
glm::vec3 bb_mins;
glm::vec3 bb_maxes;
i32 first_face_idx;
u32 n_faces;
i32 first_brush_idx;
u32 n_brushes;
};
struct Brush {
i32 first_brushside_idx;
u32 n_brushsides;
i32 texture_idx;
};
struct BrushSide {
i32 plane_idx;
i32 texture_idx;
};
struct Vertex {
glm::vec3 position;
glm::vec2 tex_coords;
glm::vec2 lightmap_coords;
glm::vec3 normal;
glm::u8vec4 color;
};
struct MeshVertex {
i32 idx;
};
struct Effect {
char name[64];
i32 brush_idx;
/* almost always 5 for some reason */
i32 unknown;
};
struct Face {
i32 texture_idx;
/* -1 if no effect */
i32 effect_idx;
enum FaceType {
ePOLYGON = 1,
ePATCH = 2,
eMESH = 3,
eBILLBOARD = 4,
} type;
i32 first_vertex_idx;
u32 n_vertices;
i32 first_mesh_vertex_idx;
u32 n_mesh_vertices;
i32 lightmap_idx;
glm::vec2 lightmap_start;
glm::vec2 lightmap_end;
glm::vec3 lightmap_origin;
glm::vec3 lightmap_unit_vectors[2];
glm::vec3 norm;
glm::ivec2 patch_dimensions;
};
struct Lightmap {
u8 map[128][128][3];
};
struct Lightvol {
rgb ambient;
rgb directional;
/* spherical coordinates */
glm::u8vec2 direction;
};
struct VisibilityInfo {
u32 sz_vectors;
std::vector<u8> vectors;
};
struct BSP {
Header* header;
BSP(const std::string& fname);
std::string filename;
std::vector<u8> file_data;
std::string entities;
std::vector<Texture> textures;
std::vector<Plane> planes;
std::vector<Node> nodes;
std::vector<Leaf> leafs;
std::vector<LeafBrush> leaf_brushes;
std::vector<LeafFaces> leaf_faces;
std::vector<Model> models;
std::vector<Brush> brushes;
std::vector<BrushSide> brush_sides;
std::vector<Vertex> vertices;
std::vector<MeshVertex> mesh_vertices;
std::vector<Effect> effects;
std::vector<Face> faces;
std::vector<Lightmap> lightmaps;
std::vector<Lightvol> lightvols;
VisibilityInfo vis_info;
};
}

168
Scene/March.hpp Normal file
View File

@ -0,0 +1,168 @@
#pragma once
/* file format for storing raymarched scene for dynamic SDF */
#include <Scene/Object.hpp>
#include <util/log.hpp>
#include <fstream>
#include <map>
namespace March {
static std::vector<Object> readFile(const std::string& fname, std::map<std::string, int>& name_map) {
/* this should be rewritten once we are loading more than 250 objects */
std::ifstream in(fname);
std::vector<Object> ret;
Object tmp;
std::string name;
std::string type;
int id = 0;
while(in >> type) {
Log::info("Object Type: %s\n", type.c_str());
char dummy;
in >> dummy;
if (dummy != '(') {
Log::error("Expected '(', found %c\n", dummy);
}
in >> tmp.center.x;
in >> tmp.center.y;
in >> tmp.center.z;
in >> dummy;
if (dummy != ')') {
Log::error("Expected ')', found %c\n", dummy);
}
if (type == "SPHERE") {
tmp.shape = Shape::eSPHERE;
char dummy;
in >> dummy;
if (dummy != '(') {
Log::error("Expected '(', found %c\n", dummy);
}
in >> tmp.dimensions.x;
in >> dummy;
if (dummy != ')') {
Log::error("Expected ')', found %c\n", dummy);
}
} else if (type == "BOX") {
tmp.shape = Shape::eBOX;
char dummy;
in >> dummy;
if (dummy != '(') {
Log::error("Expected '(', found %c\n", dummy);
}
in >> tmp.dimensions.x;
in >> tmp.dimensions.y;
in >> tmp.dimensions.z;
in >> dummy;
if (dummy != ')') {
Log::error("Expected ')', found %c\n", dummy);
}
} else {
Log::error("Expected type name, but not recognized %s!\n", type.c_str());
}
in >> name;
if (name_map.find(name) == name_map.end())
name_map[name] = id++;
tmp.id = name_map[name];
ret.push_back(tmp);
}
return ret;
}
static std::string find_name(const std::map<std::string, int>& map, const int id, bool& found) {
found = false;
std::string name = "##";
for (const auto& p : map) {
if (p.second == id) {
found = true;
name = p.first;
break;
}
}
return name;
}
static void add_sphere(const std::string& name, glm::vec3 center, float rad, Renderer* ren) {
unsigned int id = 0xDEADBEEF;
if (ren->scene_map.find(name) == ren->scene_map.end()) {
/* start iterating from the number of total objects, which will break immediately if stuff is deleted and new things added before saving, so please change this */
id = ren->scene_map.size();
ren->scene_map[name] = id;
} else {
id = ren->scene_map[name];
}
ren->objects.push_back(Object{
.center = glm::vec4(center.x, center.y, center.z, 0.0),
.dimensions = glm::vec4(rad),
.id = id,
.shape = eSPHERE,
});
}
static void add_box(const std::string& name, glm::vec3 center, glm::vec3 dim, Renderer* ren) {
unsigned int id = 0xDEADBEEF;
if (ren->scene_map.find(name) == ren->scene_map.end()) {
/* start iterating from the number of total objects, which will break immediately if stuff is deleted and new things added before saving, so please change this */
id = ren->scene_map.size();
ren->scene_map[name] = id;
} else {
id = ren->scene_map[name];
}
ren->objects.push_back(Object{
.center = glm::vec4(center.x, center.y, center.z, 0.0),
.dimensions = glm::vec4(dim.x, dim.y, dim.z, 0.0),
.id = id,
.shape = eBOX,
});
}
static void writeFile(const std::string& fname, const std::vector<Object>& objs, const std::map<std::string, int>& map) {
std::ofstream out(fname);
const char* shape_names[] = {
"SPHERE",
"BOX",
"PLANE",
};
int anon = 0;
for (const auto& obj : objs) {
out << shape_names[obj.shape] << " ( " << obj.center.x << " " << obj.center.y << " " << obj.center.z << " ) ( ";
switch (obj.shape) {
case eSPHERE:
out << obj.dimensions.x << " ";
break;
case eBOX:
out << obj.dimensions.x << " "
<< obj.dimensions.y << " "
<< obj.dimensions.z << " ";
break;
case ePLANE:
out << obj.dimensions.x << " "
<< obj.dimensions.y << " "
<< obj.dimensions.z << " ";
break;
}
bool found = false;
auto name = find_name(map, obj.id, found);
if (!found || name[0] == '#') {
name = std::string("#") + std::to_string(anon++);
}
out << ") " << name << std::endl;
}
out.close();
}
};

129
UI/UI.cpp
View File

@ -2,6 +2,7 @@
#include <imgui/imgui_impl_glfw.h>
#include <imgui/imgui_impl_vulkan.h>
#include <imgui/imgui_console.h>
#include <Window/Window.hpp>
@ -10,8 +11,36 @@
#include <Renderer/Renderer.hpp>
#include <Scene/Camera.hpp>
#include <Scene/March.hpp>
UI::UI(Renderer* ren) : info { .flycam = ren->flycam, .time = ren->time, .rad = ren->rad, .cam = ren->cam, .objects = ren->objects}, dev(ren->dev) {
/* this pains me to do, but its the only way :( */
Renderer* __ren;
static csys::ItemLog& operator<<(csys::ItemLog& log, ImVector<float>& vec) {
if (!vec.size())
return log << "vector<f32> {}";
log << "vector<f32> { ";
for (int i = 0; i < vec.size() - 1; i++)
log << vec[i] << ", ";
return log << vec[vec.size() - 1] << " }";
}
static void scene_load(csys::String fname) {
__ren->objects = March::readFile(fname.m_String, __ren->scene_map);
__ren->shader_buffer->upload(__ren->objects);
}
static void scene_write(csys::String fname) {
March::writeFile(fname.m_String, __ren->objects, __ren->scene_map);
}
static void add_sphere() {
}
UI::UI(Renderer* ren) : ren(ren) {
__ren = ren;
IMGUI_CHECKVERSION();
ImGui::CreateContext();
@ -79,6 +108,66 @@ UI::UI(Renderer* ren) : info { .flycam = ren->flycam, .time = ren->time, .rad =
ImGui_ImplVulkan_DestroyFontUploadObjects();
ImGui::StyleColorsDark();
/* set up input so we can use the keyboard */
auto& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
console = std::make_unique<ImGuiConsole>("developer console");
console->System().RegisterCommand("pause", "Pauses or unpauses the engine", [this]() {
this->ren->paused = !this->ren->paused;
console->System().Log(csys::ItemType::eINFO) << "Paused: " << (this->ren->paused ? "True" : "False") << csys::endl;
});
console->System().RegisterCommand("quit", "Quits the engine", [this]() {
this->ren->should_close = true;
console->System().Log(csys::ItemType::eINFO) << "Quitting..." << csys::endl;
});
console->System().RegisterCommand("read_scene", "Adds elements from a scene file", [this](csys::String fname) {
console->System().Log(csys::ItemType::eINFO) << "Loading file: " << fname.m_String << csys::endl;
scene_load(fname);
}, csys::Arg<csys::String>("file-name"));
console->System().RegisterCommand("write_scene", "Writes elements to a scene file (destroys underlying data if present)", [this](csys::String fname) {
Log::info("Writing to " + fname.m_String + "\n");
console->System().Log(csys::ItemType::eINFO) << "Writing to file: " << fname.m_String << "\n";
scene_write(fname);
}, csys::Arg<csys::String>("file-name"));
console->System().RegisterCommand("add_sphere", "Adds sphere to the scene.", [this](csys::String name, float cx, float cy, float cz, float rad) {
March::add_sphere(name.m_String, glm::vec3(cx, cy, cz), rad, __ren);
}, csys::Arg<csys::String>("Name"), csys::Arg<float>("center.x"), csys::Arg<float>("center.y"), csys::Arg<float>("center.z"), csys::Arg<float>("radius"));
console->System().RegisterCommand("add_box", "Adds box to the scene.", [this](csys::String name, float cx, float cy, float cz, float dx, float dy, float dz) {
March::add_box(name.m_String, glm::vec3(cx, cy, cz), glm::vec3(dx, dy, dz), __ren);
}, csys::Arg<csys::String>("Name"),
csys::Arg<float>("center.x"), csys::Arg<float>("center.y"), csys::Arg<float>("center.z"),
csys::Arg<float>("dim.x"), csys::Arg<float>("dim.y"), csys::Arg<float>("dim.z"));
console->System().RegisterCommand("list-vars", "List variables accessible from developer console", [this]() {
const std::vector<std::string> names = {
// "show_bboxes",
// "visibility_testing",
"flycam",
"speed",
"max_fps",
// "wireframe",
// "backface_culling",
};
for (const auto& name : names)
console->System().Log(csys::ItemType::eINFO) << name << csys::endl;
});
// console->System().RegisterVariable("show_bboxes", ren->show_bboxes, csys::Arg<bool>("value"));
// console->System().RegisterVariable("visibility_testing", ren->visibility_testing, csys::Arg<bool>("value"));
console->System().RegisterVariable("flycam", ren->flycam, csys::Arg<bool>("value"));
console->System().RegisterVariable("speed", ren->speed, csys::Arg<float>("value"));
console->System().RegisterVariable("max_fps", ren->max_fps, csys::Arg<float>("value"));
// console->System().RegisterVariable("wireframe", ren->wireframe_mode, pipeline_setter);
// console->System().RegisterVariable("backface_culling", ren->backface_culling, pipeline_setter);
console->System().Log(csys::ItemType::eINFO) << "Welcome to Pleascach!" << csys::endl;
}
void UI::newFrame() {
@ -86,25 +175,40 @@ void UI::newFrame() {
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
ImGui::SetNextWindowBgAlpha(0.5f);
ImGui::Begin("Rendering Info", nullptr);
ImGui::Text("FPS: %f", info.fps);
ImGui::Text("Time: %f", info.time);
ImGui::SliderFloat("Rad", &info.rad, 0.0, 3.0);
ImGui::SliderFloat("Theta", &info.cam.theta, 0.0, glm::pi<float>());
ImGui::SliderFloat("Phi", &info.cam.phi, 0.0, glm::two_pi<float>());
ImGui::Text("FPS: %f", ren->fps);
ImGui::Text("Time: %f", ren->time);
ImGui::SliderFloat("Rad", &ren->rad, 0.0, 3.0);
ImGui::SliderFloat("Theta", &ren->cam.theta, 0.0, glm::pi<float>());
ImGui::SliderFloat("Phi", &ren->cam.phi, 0.0, glm::two_pi<float>());
ImGui::SliderFloat("X", &info.cam.pos.x, -1000.0, 1000.0);
ImGui::SliderFloat("Y", &info.cam.pos.y, -1000.0, 1000.0);
ImGui::SliderFloat("Z", &info.cam.pos.z, -1000.0, 1000.0);
ImGui::SliderFloat("X", &ren->cam.pos.x, -1000.0, 1000.0);
ImGui::SliderFloat("Y", &ren->cam.pos.y, -1000.0, 1000.0);
ImGui::SliderFloat("Z", &ren->cam.pos.z, -1000.0, 1000.0);
if(ImGui::CollapsingHeader("Objects")) {
for(const auto& obj : info.objects) {
ImGui::Text("(%f %f %f) + %f", obj.center.x, obj.center.y, obj.center.z, obj.dimensions.x);
int anon = 0;
for (const auto& obj : ren->objects) {
bool found = false;
auto name = March::find_name(ren->scene_map, obj.id, found);
if (!found || name[0] == '#') {
name = std::string("#") + std::to_string(anon++);
}
ImGui::Text("(%f %f %f %f) (%f %f %f %f) \"%s\"",
obj.center.x, obj.center.y, obj.center.z, obj.center.w,
obj.dimensions.x, obj.dimensions.y, obj.dimensions.z, obj.dimensions.w,
name.c_str());
}
}
if (ren->in_menu)
console->Draw();
ImGui::End();
}
@ -115,7 +219,8 @@ void UI::render(vk::CommandBuffer cmd) {
}
UI::~UI() {
dev.destroyDescriptorPool(desc_pool);
console.reset();
// dev.destroyDescriptorPool(desc_pool);
ImGui_ImplVulkan_Shutdown();
ImGui_ImplGlfw_Shutdown();

17
UI/UI.hpp
View File

@ -3,8 +3,11 @@
#define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
#include <vulkan/vulkan.hpp>
#include <Renderer/CommandBuffer.hpp>
#include <imgui/imgui_console.h>
#include <vector>
struct Object;
@ -12,22 +15,14 @@ struct Renderer;
struct Camera;
struct UI {
struct UI_Info {
float fps = 0.0;
bool& flycam;
float& time;
/* for cantor */
float& rad;
/* camera stuff */
Camera& cam;
const std::vector<Object>& objects;
} info;
Renderer* ren;
vk::Device dev;
vk::DescriptorPool desc_pool;
UI(Renderer* ren);
std::unique_ptr<ImGuiConsole> console;
void newFrame();
void render(vk::CommandBuffer cmd);

9
assets/shaders/ray.frag
View File

@ -93,7 +93,8 @@ float terrain(vec3 p) {
vec2 sdf(vec3 pos) {
vec2 d = vec2(100000000.0, -1.0);
for(uint i = 0; i < n_objects; i++) {
d = op_union(d, obj_to_sdf(pos, i), objects[n_objects].id);
d = op_union(d, obj_to_sdf(pos, i), 1.0);
// d = op_union(d, sphere(pos, objects[i].center.xyz, objects[i].dimensions.x), 1.0);
}
@ -114,8 +115,8 @@ vec2 raycast(vec3 dir) {
if(dt.y == -1.0)
return dt;
if(dt.x < 0.0001*t)
return vec2(t, dt.y);
// return float(i)/MAX_STEPS;
// return vec2(t, dt.y);
return vec2(t, float(i)/MAX_STEPS);
else if(dt.x > 2000.0)
return vec2(dt.x, -1.0);
t += dt.x;
@ -150,7 +151,7 @@ void main() {
vec3 p = d.x*dir + cam_pos;
if(d.y != -1.0)
fragColor = vec4(d.y/n_objects);
fragColor = vec4(d.y);
else
fragColor = vec4(0.0);
}

BIN
assets/shaders/ray.frag.spv
View File

Binary file not shown.

69
include/csys/api.h Normal file
View File

@ -0,0 +1,69 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_API_H
#define CSYS_API_H
#ifdef CSYS_COMPILED_LIB
# undef CSYS_HEADER_ONLY
# define CSYS_INLINE
# ifdef CSYS_SHARED_LIB
// Windows Shared Library.
# if defined(_WIN32)
# ifdef csys_EXPORTS
# define CSYS_API __declspec(dllexport)
# else
# define CSYS_API __declspec(dllimport)
# endif
// Linux shared library.
# else
# ifdef csys_EXPORTS
# define CSYS_API __attribute__((visibility("default")))
# else
# define CSYS_API __attribute__((visibility("default")))
# endif
# endif
# else
# define CSYS_API
# endif
// No export.
# ifndef CSYS_NO_EXPORT
# if defined(_WIN32)
# define CSYS_NO_EXPORT
# else
# define CSYS_NO_EXPORT __attribute__((visibility("hidden")))
# endif
# endif
#else
# define CSYS_API
# define CSYS_NO_EXPORT
# define CSYS_HEADER_ONLY
# define CSYS_INLINE inline
#endif
#if defined(__GNUC__) || defined(__clang__)
#define CSYS_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define CSYS_DEPRECATED __declspec(deprecated)
#else
#define CSYS_DEPRECATED
#endif
#ifndef CSYS_DEPRECATED_EXPORT
# define CSYS_DEPRECATED_EXPORT CSYS_API CSYS_DEPRECATED
#endif
#ifndef CSYS_DEPRECATED_NO_EXPORT
# define CSYS_DEPRECATED_NO_EXPORT CSYS_NO_EXPORT CSYS_DEPRECATED
#endif
#if 0 /* DEFINE_NO_DEPRECATED */
# ifndef CSYS_NO_DEPRECATED
# define CSYS_NO_DEPRECATED
# endif
#endif
#endif /* CSYS_API_H */

516
include/csys/argument_parser.h Normal file
View File

@ -0,0 +1,516 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_ARGUMENT_PARSER_H
#define CSYS_ARGUMENT_PARSER_H
#pragma once
#include "csys/api.h"
#include "csys/string.h"
#include "csys/exceptions.h"
#include <vector>
#include <stdexcept>
#include <string_view>
namespace csys
{
namespace
{
inline const std::string_view s_Reserved("\\[]\""); //!< All the reserved chars
inline constexpr char s_ErrMsgReserved[] = "Reserved chars '\\, [, ], \"' must be escaped with \\"; //!< Error message for reserved chars
}
/*!
* \brief
* Helper class to check for parsing arguments that involve checking for reserved chars
*/
struct CSYS_API Reserved
{
/*!
* \brief
* Checks if the current char 'c' is the escaping char
* \param c
* Char to compare against with the escaping char
* \return
* Returns true if the char 'c' is the escaping char
*/
static inline bool IsEscapeChar(char c)
{ return c == '\\'; }
/*!
* \brief
* Checks if the current char is reserved
* \param c
* Char to check
* \return
* Returns true if the current char 'c' is reserved
*/
static inline bool IsReservedChar(char c)
{
for (auto rc : s_Reserved) if (c == rc) return true;
return false;
}
/*!
* \brief
* Checks if a char is escaping another
* \param input
* Chars to check for it escaping
* \param pos
* Char that is escaping
* \return
* Returns true if the current char is the escaping char and is escaping
*/
static inline bool IsEscaping(std::string &input, size_t pos)
{
return pos < input.size() - 1 && IsEscapeChar(input[pos]) && IsReservedChar(input[pos + 1]);
}
/*!
* \brief
* Checks if a certain char is being escaped
* \param input
* Chars to check
* \param pos
* The current char to check if its being escaped
* \return
* Returns true if the current char at 'pos' is being escaped
*/
static inline bool IsEscaped(std::string &input, size_t pos)
{
bool result = false;
// Go through checking if the prev char is getting escaped and toggle between true and false
// Edge case is escaping the escaping char before another
for (size_t i = pos; i > 0; --i)
if (IsReservedChar(input[i]) && IsEscapeChar(input[i - 1]))
result = !result;
else
break;
return result;
}
// Delete unwanted operations
Reserved() = delete;
~Reserved() = delete;
Reserved(Reserved&&) = delete;
Reserved(const Reserved&) = delete;
Reserved& operator=(Reserved&&) = delete;
Reserved& operator=(const Reserved&) = delete;
};
/*!
* \brief
* Used for parsing arguments of different types
* \tparam T
* Argument type
*/
template<typename T>
struct CSYS_API ArgumentParser
{
/*!
* \brief
* Constructor that parses the argument and sets value T
* \param input
* Command line set of arguments to be parsed
* \param start
* Start in 'input' to where this argument should be parsed from
*/
inline ArgumentParser(String &input, size_t &start);
T m_Value; //!< Value of parsed argument
};
/*!
* \brief
* Macro for template specialization, used for cleaner code reuse
*/
#define ARG_PARSE_BASE_SPEC(TYPE) \
template<> \
struct CSYS_API ArgumentParser<TYPE> \
{ \
inline ArgumentParser(String &input, size_t &start); \
TYPE m_Value = 0; \
}; \
inline ArgumentParser<TYPE>::ArgumentParser(String &input, size_t &start)
/*!
* \brief
* Macro for getting the sub-string within a range, used for readability
*/
#define ARG_PARSE_SUBSTR(range) input.m_String.substr(range.first, range.second - range.first)
/*!
* \brief
* Macro for build-int types that already have functions in the stl for parsing them from a string
*/
#define ARG_PARSE_GENERAL_SPEC(TYPE, TYPE_NAME, FUNCTION) \
ARG_PARSE_BASE_SPEC(TYPE) \
{ \
auto range = input.NextPoi(start); \
try \
{ \
m_Value = (TYPE)FUNCTION(ARG_PARSE_SUBSTR(range), &range.first); \
} \
catch (const std::out_of_range&) \
{ \
throw Exception(std::string("Argument too large for ") + TYPE_NAME, \
input.m_String.substr(range.first, range.second)); \
} \
catch (const std::invalid_argument&) \
{ \
throw Exception(std::string("Missing or invalid ") + TYPE_NAME + " argument", \
input.m_String.substr(range.first, range.second)); } \
}
/*!
* \brief
* Template specialization for string argument parsing
*/
ARG_PARSE_BASE_SPEC(csys::String)
{
m_Value.m_String.clear(); // Empty string before using
// Lambda for getting a word from the string and checking for reserved chars
static auto GetWord = [](std::string &str, size_t start, size_t end)
{
// For issues with reserved chars
static std::string invalid_chars;
invalid_chars.clear();
std::string result;
// Go through the str from start to end
for (size_t i = start; i < end; ++i)
// general case, not reserved char
if (!Reserved::IsReservedChar(str[i]))
result.push_back(str[i]);
// is a reserved char
else
{
// check for \ char and if its escaping
if (Reserved::IsEscapeChar(str[i]) && Reserved::IsEscaping(str, i))
result.push_back(str[++i]);
// reserved char but not being escaped
else
throw Exception(s_ErrMsgReserved, str.substr(start, end - start));
}
return result;
};
// Go to the start of the string argument
auto range = input.NextPoi(start);
// If its a single string
if (input.m_String[range.first] != '"')
m_Value = GetWord(input.m_String, range.first, range.second);
// Multi word string
else
{
++range.first; // move past the first "
while (true)
{
// Get the next non-escaped "
range.second = input.m_String.find('"', range.first);
while (range.second != std::string::npos && Reserved::IsEscaped(input.m_String, range.second))
range.second = input.m_String.find('"', range.second + 1);
// Check for closing "
if (range.second == std::string::npos)
{
range.second = input.m_String.size();
throw Exception("Could not find closing '\"'", ARG_PARSE_SUBSTR(range));
}
// Add word to already existing string
m_Value.m_String += GetWord(input.m_String, range.first, range.second);
// Go to next word
range.first = range.second + 1;
// End of string check
if (range.first < input.m_String.size() && !std::isspace(input.m_String[range.first]))
{
// joining two strings together
if (input.m_String[range.first] == '"')
++range.first;
}
else
// End of input
break;
}
}
// Finished parsing
start = range.second + 1;
}
/*!
* \brief
* Template specialization for boolean argument parsing
*/
ARG_PARSE_BASE_SPEC(bool)
{
// Error messages
static const char *s_err_msg = "Missing or invalid boolean argument";
static const char *s_false = "false";
static const char *s_true = "true";
// Get argument
auto range = input.NextPoi(start);
// check if the length is between the len of "true" and "false"
input.m_String[range.first] = char(std::tolower(input.m_String[range.first]));
// true branch
if (range.second - range.first == 4 && input.m_String[range.first] == 't')
{
// Go through comparing grabbed arg to "true" char by char, bail if not the same
for (size_t i = range.first + 1; i < range.second; ++i)
if ((input.m_String[i] = char(std::tolower(input.m_String[i]))) != s_true[i - range.first])
throw Exception(s_err_msg + std::string(", expected true"), ARG_PARSE_SUBSTR(range));
m_Value = true;
}
// false branch
else if (range.second - range.first == 5 && input.m_String[range.first] == 'f')
{
// Go through comparing grabbed arg to "false" char by char, bail if not the same
for (size_t i = range.first + 1; i < range.second; ++i)
if ((input.m_String[i] = char(std::tolower(input.m_String[i]))) != s_false[i - range.first])
throw Exception(s_err_msg + std::string(", expected false"), ARG_PARSE_SUBSTR(range));
m_Value = false;
}
// anything else, not true or false
else
throw Exception(s_err_msg, ARG_PARSE_SUBSTR(range));
}
/*!
* \brief
* Template specialization for char argument parsing
*/
ARG_PARSE_BASE_SPEC(char)
{
// Grab the argument
auto range = input.NextPoi(start);
size_t len = range.second - range.first;
// Check if its 3 or more letters
if (len > 2 || len <= 0)
throw Exception("Too many or no chars were given", ARG_PARSE_SUBSTR(range));
// potential reserved char
else if (len == 2)
{
// Check if the first char is \ and the second is a reserved char
if (!Reserved::IsEscaping(input.m_String, range.first))
throw Exception("Too many chars were given", ARG_PARSE_SUBSTR(range));
// is correct
m_Value = input.m_String[range.first + 1];
}
// if its one char and reserved
else if (Reserved::IsReservedChar(input.m_String[range.first]))
throw Exception(s_ErrMsgReserved, ARG_PARSE_SUBSTR(range));
// one char, not reserved
else
m_Value = input.m_String[range.first];
}
/*!
* \brief
* Template specialization for unsigned char argument parsing
*/
ARG_PARSE_BASE_SPEC(unsigned char)
{
// Grab the argument
auto range = input.NextPoi(start);
size_t len = range.second - range.first;
// Check if its 3 or more letters
if (len > 2 || len <= 0)
throw Exception("Too many or no chars were given", ARG_PARSE_SUBSTR(range));
// potential reserved char
else if (len == 2)
{
// Check if the first char is \ and the second is a reserved char
if (!Reserved::IsEscaping(input.m_String, range.first))
throw Exception("Too many chars were given", ARG_PARSE_SUBSTR(range));
// is correct
m_Value = static_cast<unsigned char>(input.m_String[range.first + 1]);
}
// if its one char and reserved
else if (Reserved::IsReservedChar(input.m_String[range.first]))
throw Exception(s_ErrMsgReserved, ARG_PARSE_SUBSTR(range));
// one char, not reserved
else
m_Value = static_cast<unsigned char>(input.m_String[range.first]);
}
/*!
* \brief
* Template specialization for short argument parsing
*/
ARG_PARSE_GENERAL_SPEC(short, "signed short", std::stoi)
/*!
* \brief
* Template specialization for unsigned short argument parsing
*/
ARG_PARSE_GENERAL_SPEC(unsigned short, "unsigned short", std::stoul)
/*!
* \brief
* Template specialization for int argument parsing
*/
ARG_PARSE_GENERAL_SPEC(int, "signed int", std::stoi)
/*!
* \brief
* Template specialization for unsigned int argument parsing
*/
ARG_PARSE_GENERAL_SPEC(unsigned int, "unsigned int", std::stoul)
/*!
* \brief
* Template specialization for long argument parsing
*/
ARG_PARSE_GENERAL_SPEC(long, "long", std::stol)
/*!
* \brief
* Template specialization for unsigned long argument parsing
*/
ARG_PARSE_GENERAL_SPEC(unsigned long, "unsigned long", std::stoul)
/*!
* \brief
* Template specialization for long long argument parsing
*/
ARG_PARSE_GENERAL_SPEC(long long, "long long", std::stoll)
/*!
* \brief
* Template specialization for unsigned long long argument parsing
*/
ARG_PARSE_GENERAL_SPEC(unsigned long long, "unsigned long long", std::stoull)
/*!
* \brief
* Template specialization for float argument parsing
*/
ARG_PARSE_GENERAL_SPEC(float, "float", std::stof)
/*!
* \brief
* Template specialization for double argument parsing
*/
ARG_PARSE_GENERAL_SPEC(double, "double", std::stod)
/*!
* \brief
* Template specialization for long double argument parsing
*/
ARG_PARSE_GENERAL_SPEC(long double, "long double", std::stold)
/*!
* \brief
* Template specialization for vector argument parsing
* \tparam T
* Type that the vector holds
*
*/
template<typename T>
struct CSYS_API ArgumentParser<std::vector<T>>
{
/*!
* \brief
* Grabs a vector argument of type T from 'input' starting from 'start'
* \param input
* Input to the command for this class to parse its argument
* \param start
* Start of this argument
*/
ArgumentParser(String &input, size_t &start);
std::vector<T> m_Value; //!< Vector of data parsed
};
/*!
* \brief
* Grabs a vector argument of type T from 'input' starting from 'start'
* \tparam T
* Type of vector
* \param input
* Input to the command for this class to parse its argument
* \param start
* Start of this argument
*/
template<typename T>
ArgumentParser<std::vector<T>>::ArgumentParser(String &input, size_t &start)
{
// Clean out vector before use
m_Value.clear();
// Grab the start of the vector argument
auto range = input.NextPoi(start);
// Empty
if (range.first == input.End()) return;
// Not starting with [
if (input.m_String[range.first] != '[')
throw Exception("Invalid vector argument missing opening [", ARG_PARSE_SUBSTR(range));
// Erase [
input.m_String[range.first] = ' ';
while (true)
{
// Get next argument in vector
range = input.NextPoi(range.first);
// No more, empty vector
if (range.first == input.End()) return;
// Is a nested vector, go deeper
else if (input.m_String[range.first] == '[')
m_Value.push_back(ArgumentParser<T>(input, range.first).m_Value);
else
{
// Find first non-escaped ]
range.second = input.m_String.find(']', range.first);
while (range.second != std::string::npos && Reserved::IsEscaped(input.m_String, range.second))
range.second = input.m_String.find(']', range.second + 1);
// Check for closing ]
if (range.second == std::string::npos)
{
range.second = input.m_String.size();
throw Exception("Invalid vector argument missing closing ]", ARG_PARSE_SUBSTR(range));
}
// Erase ]
input.m_String[range.second] = ' ';
start = range.first;
// Parse all arguments contained within the vector
while (true)
{
// If end of parsing, get out
if ((range.first = input.NextPoi(range.first).first) >= range.second)
{
start = range.first;
return;
}
// Parse argument and go to next
m_Value.push_back(ArgumentParser<T>(input, start).m_Value);
range.first = start;
}
}
}
}
}
#endif //CSYS_ARGUMENT_PARSER_H

208
include/csys/arguments.h Normal file
View File

@ -0,0 +1,208 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_ARGUMENTS_H
#define CSYS_ARGUMENTS_H
#pragma once
#include "csys/api.h"
#include "csys/string.h"
#include "csys/exceptions.h"
#include "csys/argument_parser.h"
#include <vector>
namespace csys
{
/*!
* \brief
* Macro for supporting trivial types
*/
#define SUPPORT_TYPE(TYPE, TYPE_NAME)\
template<> struct is_supported_type<TYPE> { static constexpr bool value = true; }; \
template<> \
struct CSYS_API ArgData<TYPE> \
{ \
explicit ArgData(String name) : m_Name(std::move(name)), m_Value() {} \
const String m_Name; \
String m_TypeName = TYPE_NAME; \
TYPE m_Value; \
};
using NULL_ARGUMENT = void (*)(); //!< Null argument typedef
/*!
* \brief
* Base case struct where a type is not supported
*/
template<typename> struct is_supported_type { static constexpr bool value = false; };
/*!
* \brief
* Wrapper around a given data type to name it
* \tparam T
* Type of data that must have a default constructor
*/
template<typename T>
struct CSYS_API ArgData
{
/*!
* \brief
* Non-default constructor
* \param name
* Name of the argument
*/
explicit ArgData(String name) : m_Name(std::move(name)), m_Value()
{ }
const String m_Name = ""; //!< Name of argument
String m_TypeName = "Unsupported Type"; //!< Name of type
T m_Value; //!< Actual value
};
//! Supported types
SUPPORT_TYPE(String, "String")
SUPPORT_TYPE(bool, "Boolean")
SUPPORT_TYPE(char, "Char")
SUPPORT_TYPE(unsigned char, "Unsigned_Char")
SUPPORT_TYPE(short, "Signed_Short")
SUPPORT_TYPE(unsigned short, "Unsigned_Short")
SUPPORT_TYPE(int, "Signed_Int")
SUPPORT_TYPE(unsigned int, "Unsigned_Int")
SUPPORT_TYPE(long, "Signed_Long")
SUPPORT_TYPE(unsigned long, "Unsigned_Long")
SUPPORT_TYPE(long long, "Signed_Long_Long")
SUPPORT_TYPE(unsigned long long, "Unsigned_Long_Long")
SUPPORT_TYPE(float, "Float")
SUPPORT_TYPE(double, "Double")
SUPPORT_TYPE(long double, "Long_Double")
//! Supported containers
template<typename U> struct is_supported_type<std::vector<U>> { static constexpr bool value = is_supported_type<U>::value; };
template<typename T>
struct CSYS_API ArgData<std::vector<T>>
{
/*!
* \brief
* Constructor for a vector argument
* \param name
* Name for argument
*/
explicit ArgData(String name) : m_Name(std::move(name))
{}
const String m_Name; //!< Name of argument
String m_TypeName = std::string("Vector_Of_") + ArgData<T>("").m_TypeName.m_String; //!< Type name
std::vector<T> m_Value; //!< Vector of data
};
/*!
* \brief
* Wrapper around an argument for use of parsing a command line
* \tparam T
* Data type
*/
template<typename T>
struct CSYS_API Arg
{
/*!
* \brief
* Is true if type of U is a supported type
* \tparam U
* Type to check if it is supported
*/
template<typename U>
static constexpr bool is_supported_type_v = is_supported_type<U>::value;
public:
using ValueType = std::remove_cv_t<std::remove_reference_t<T>>; //!< Type of this argument
/*!
* \brief
* Constructor for an argument for naming
* \param name
* Name of the argument
*/
explicit Arg(const String &name) : m_Arg(name)
{
static_assert(is_supported_type_v<ValueType>,
"ValueType 'T' is not supported, see 'Supported types' for more help");
}
/*!
* \brief
* Grabs its own argument from the command line and sets its value
* \param input
* Command line argument list
* \param start
* Start of its argument
* \return
* Returns this
*/
Arg<T> &Parse(String &input, size_t &start)
{
size_t index = start;
// Check if there are more arguments to be read in
if (input.NextPoi(index).first == input.End())
throw Exception("Not enough arguments were given", input.m_String);
// Set value grabbed from input aka command line argument
m_Arg.m_Value = ArgumentParser<ValueType>(input, start).m_Value;
return *this;
}
/*!
* \brief
* Gets the info of the argument in the form of [name:type]
* \return
* Returns a string containing the arugment's info
*/
std::string Info()
{
return std::string(" [") + m_Arg.m_Name.m_String + ":" + m_Arg.m_TypeName.m_String + "]";
}
ArgData<ValueType> m_Arg; //!< Data relating to this argument
};
/*!
* \brief
* Template specialization for a null argument that gets appended to a command's argument list to check if more
* than the required number of arguments
*/
template<>
struct CSYS_API Arg<NULL_ARGUMENT>
{
/*!
* \brief
* Checks if the input starting from param 'start' is all whitespace or not
* \param input
* Command line argument list
* \param start
* Start of its argument
* \return
* Returns this
*/
Arg<NULL_ARGUMENT> &Parse(String &input, size_t &start)
{
if (input.NextPoi(start).first != input.End())
throw Exception("Too many arguments were given", input.m_String);
return *this;
}
};
}
#endif //CSYS_ARGUMENTS_H

386
include/csys/autocomplete.h Normal file
View File

@ -0,0 +1,386 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_AUTOCOMPLETE_H
#define CSYS_AUTOCOMPLETE_H
#pragma once
#include "csys/api.h"
#include <vector>
#include <string>
#include <memory>
namespace csys
{
// TODO: Check how to add support for UTF Encoding.
// TODO: Todo add max word suggestion depth.
// TODO: Only use "const char *" or "std::string" in csys. (On stl containers use iterators - SLOW). (Need to add std::string version)
//!< Auto complete ternary search tree.
class CSYS_API AutoComplete
{
public:
// Type definitions.
using r_sVector = std::vector<std::string> &;
using sVector = std::vector<std::string>;
//!< Autocomplete node.
struct ACNode
{
explicit ACNode(const char data, bool isWord = false) : m_Data(data), m_IsWord(isWord), m_Less(nullptr), m_Equal(nullptr), m_Greater(nullptr)
{};
explicit ACNode(const char &&data, bool isWord = false) : m_Data(data), m_IsWord(isWord), m_Less(nullptr), m_Equal(nullptr), m_Greater(nullptr)
{};
~ACNode()
{
delete m_Less;
delete m_Equal;
delete m_Greater;
};
char m_Data; //!< Node data.
bool m_IsWord; //!< Flag to determine if node is the end of a word.
ACNode *m_Less; //!< Left pointer.
ACNode *m_Equal; //!< Middle pointer.
ACNode *m_Greater; //!< Right pointer.
};
/*!
* \brief Default Constructor
*/
AutoComplete() = default;
/*!
* \brief
* Copy constructor
* \param tree
* Tree to be copied
*/
AutoComplete(const AutoComplete &tree);
/*!
* \brief
* Move constructor
* \param rhs
* Tree to be copied
*/
AutoComplete(AutoComplete &&rhs) = default;
/*!
* \brief
* Assignment operator
* \param rhs
* Source tree
* \return
* Self
*/
AutoComplete &operator=(const AutoComplete &rhs);
/*!
* \brief
* Move assignment operator
* \param rhs
* Source tree
* \return
* Self
*/
AutoComplete& operator=(AutoComplete&& rhs) = default;
/*!
*
* \tparam inputType
* String input type
* \param[in] il
* List of string from which TST will be constructed
*/
template<typename inputType>
AutoComplete(std::initializer_list<inputType> il)
{
for (const auto &item : il)
{
Insert(item);
}
}
/*!
*
* \tparam T
* Container type
* \param[in] items
* Arbitrary container of strings
*/
template<typename T>
explicit AutoComplete(const T &items)
{
for (const auto &item : items)
{
Insert(item);
}
}
/*!
* /brief
* Destructor
*/
~AutoComplete();
/*!
* \brief
* Get tree node count
* \return
* Tree node count
*/
[[nodiscard]] size_t Size() const;
/*!
* \brief
* Get tree word count
* \return
* Word count
*/
[[nodiscard]] size_t Count() const;
/*!
* \brief
* Search if the given word is in the tree
* \param[in] word
* Word to search
* \return
* Found word
*/
bool Search(const char *word);
/*!
* \brief
* Insert word into tree
* \param[in] word
* Word to be inserted
*/
void Insert(const char *word);
/*!
* \brief
* Insert word into tree
* \param[in] word
* Word to be inserted
*/
void Insert(const std::string &word);
/*!
* \brief
* Insert word into tree
* \tparam strType
* String type to be inserted
* \param[in] word
* Word to be inserted
*/
template<typename strType>
void Insert(const strType &word)
{
ACNode **ptr = &m_Root;
++m_Count;
while (*word != '\0')
{
// Insert char into tree.
if (*ptr == nullptr)
{
*ptr = new ACNode(*word);
++m_Size;
}
// Traverse tree.
if (*word < (*ptr)->m_Data)
{
ptr = &(*ptr)->m_Less;
}
else if (*word == (*ptr)->m_Data)
{
// String is already in tree, therefore only mark as word.
if (*(word + 1) == '\0')
{
if ((*ptr)->m_IsWord)
--m_Count;
(*ptr)->m_IsWord = true;
}
// Advance.
ptr = &(*ptr)->m_Equal;
++word;
}
else
{
ptr = &(*ptr)->m_Greater;
}
}
}
/*!
* \brief
* Removes a word from the tree if found
* \param[in] word
* String to be removed
*/
void Remove(const std::string &word);
/*!
* \brief
* Retrieve suggestions that match the given prefix
* \tparam strType
* Prefix string type
* \param[in] prefix
* Prefix to use for suggestion lookup
* \param[out] ac_options
* Vector of found suggestions
*/
template<typename strType>
void Suggestions(const strType &prefix, r_sVector ac_options)
{
ACNode *ptr = m_Root;
auto temp = prefix;
// Traverse tree and check if prefix exists.
while (ptr)
{
if (*prefix < ptr->m_Data)
{
ptr = ptr->m_Less;
}
else if (*prefix == ptr->m_Data)
{
// Prefix exists in tree.
if (*(prefix + 1) == '\0')
break;
ptr = ptr->m_Equal;
++prefix;
}
else
{
ptr = ptr->m_Greater;
}
}
// Already a word. (No need to auto complete).
if (ptr && ptr->m_IsWord) return;
// Prefix is not in tree.
if (!ptr) return;
// Retrieve auto complete options.
SuggestionsAux(ptr->m_Equal, ac_options, temp);
}
/*!
* \brief
* Retrieve suggestions that match the given prefix
* \param[in] prefix
* Prefix to use for suggestion lookup
* \param[out] ac_options
* Vector of found suggestions
*/
void Suggestions(const char *prefix, r_sVector ac_options);
/*!
* \brief
* Store suggestions that match prefix in ac_options and return partially completed prefix if possible.
* \param[in] prefix
* Prefix to use for suggestion lookup
* \param[out] ac_options
* Vector of found suggestions
* \return
* Partially completed prefix
*/
std::string Suggestions(const std::string &prefix, r_sVector ac_options);
/*!
* \brief
* Retrieve suggestions that match the given prefix
* \param[in/out] prefix
* Prefix to use for suggestion lookup, will be partially completed if flag partial_complete is on
* \param[out] ac_options
* Vector of found suggestions
* \param[in] partial_complete
* Flag to determine if prefix string will be partially completed
*/
void Suggestions(std::string &prefix, r_sVector ac_options, bool partial_complete);
/*!
* \brief
* Retrieve suggestions that match the given prefix
* \tparam strType
* Prefix string type
* \param[in] prefix
* Prefix to use for suggestion lookup
* \return
* Vector of found suggestions
*/
template<typename strType>
std::unique_ptr<sVector> Suggestions(const strType &prefix)
{
auto temp = std::make_unique<sVector>();
Suggestions(prefix, *temp);
return temp;
}
/*!
* \brief
* Retrieve suggestions that match the given prefix
* \param[in] prefix
* Prefix to use for suggestion lookup
* \return
* Vector of found suggestions
*/
std::unique_ptr<sVector> Suggestions(const char *prefix);
protected:
/*!
* \param[in] root
* Permutation root
* \param[out] ac_options
* Vector of found suggestions
* \param[in] buffer
* Prefix buffer
*/
void SuggestionsAux(ACNode *root, r_sVector ac_options, std::string buffer);
/*!
* \brief
* Remove word auxiliary function
* \param[in] root
* Current node to process
* \param[in] word
* String to look for and remove
* \return
* If node is word
*/
bool RemoveAux(ACNode *root, const char *word);
/*!
* \brief
* Clone acNode and all its children
* \param src
* Node to copy from
* \param dest
* Where new node will be stored
*/
void DeepClone(ACNode *src, ACNode *&dest);
ACNode *m_Root = nullptr; //!< Ternary Search Tree Root node
size_t m_Size = 0; //!< Node count
size_t m_Count = 0; //!< Word count
};
}
#ifdef CSYS_HEADER_ONLY
#include "csys/autocomplete.inl"
#endif
#endif //CSYS_AUTOCOMPLETE_H

318
include/csys/autocomplete.inl Normal file
View File

@ -0,0 +1,318 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef CSYS_HEADER_ONLY
#include "csys/autocomplete.h"
#endif
namespace csys
{
///////////////////////////////////////////////////////////////////////////
// Constructor/Destructors ////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
CSYS_INLINE AutoComplete::~AutoComplete()
{
delete m_Root;
}
CSYS_INLINE AutoComplete::AutoComplete(const AutoComplete &tree) : m_Size(tree.m_Size), m_Count(tree.m_Count)
{
DeepClone(tree.m_Root, m_Root);
}
CSYS_INLINE AutoComplete &AutoComplete::operator=(const AutoComplete &rhs)
{
// Prevent self assignment.
if (&rhs == this) return *this;
// Clean.
delete m_Root;
// Copy from source tree.
DeepClone(rhs.m_Root, m_Root);
m_Size = rhs.m_Size;
m_Count = rhs.m_Count;
return *this;
}
///////////////////////////////////////////////////////////////////////////
// Public methods /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
CSYS_INLINE size_t AutoComplete::Size() const
{
return m_Size;
}
CSYS_INLINE size_t AutoComplete::Count() const
{
return m_Count;
}
CSYS_INLINE bool AutoComplete::Search(const char *word)
{
ACNode *ptr = m_Root;
// Traverse tree in look for the given string.
while (ptr)
{
if (*word < ptr->m_Data)
{
ptr = ptr->m_Less;
} else if (*word == ptr->m_Data)
{
// Word was found.
if (*(word + 1) == '\0' && ptr->m_IsWord)
return true;
ptr = ptr->m_Equal;
++word;
} else
{
ptr = ptr->m_Greater;
}
}
return false;
}
CSYS_INLINE void AutoComplete::Insert(const char *word)
{
ACNode **ptr = &m_Root;
++m_Count;
while (*word != '\0')
{
// Insert char into tree.
if (*ptr == nullptr)
{
*ptr = new ACNode(*word);
++m_Size;
}
// Traverse tree.
if (*word < (*ptr)->m_Data)
{
ptr = &(*ptr)->m_Less;
} else if (*word == (*ptr)->m_Data)
{
// String is already in tree, therefore only mark as word.
if (*(word + 1) == '\0')
{
if ((*ptr)->m_IsWord)
--m_Count;
(*ptr)->m_IsWord = true;
}
// Advance.
ptr = &(*ptr)->m_Equal;
++word;
} else
{
ptr = &(*ptr)->m_Greater;
}
}
}
CSYS_INLINE void AutoComplete::Insert(const std::string &word)
{
Insert(word.c_str());
}
CSYS_INLINE void AutoComplete::Remove(const std::string &word)
{
RemoveAux(m_Root, word.c_str());
}
CSYS_INLINE void AutoComplete::Suggestions(const char *prefix, std::vector<std::string> &ac_options)
{
ACNode *ptr = m_Root;
auto temp = prefix;
// Traverse tree and check if prefix exists.
while (ptr)
{
if (*prefix < ptr->m_Data)
{
ptr = ptr->m_Less;
} else if (*prefix == ptr->m_Data)
{
// Prefix exists in tree.
if (*(prefix + 1) == '\0')
break;
ptr = ptr->m_Equal;
++prefix;
} else
{
ptr = ptr->m_Greater;
}
}
// Already a word. (No need to auto complete).
if (ptr && ptr->m_IsWord) return;
// Prefix is not in tree.
if (!ptr) return;
// Retrieve auto complete options.
SuggestionsAux(ptr->m_Equal, ac_options, temp);
}
CSYS_INLINE std::string AutoComplete::Suggestions(const std::string &prefix, r_sVector &ac_options)
{
std::string temp = prefix;
Suggestions(temp, ac_options, true);
return temp;
}
CSYS_INLINE void AutoComplete::Suggestions(std::string &prefix, r_sVector ac_options, bool partial_complete)
{
ACNode *ptr = m_Root;
const char *temp = prefix.data();
size_t prefix_end = prefix.size();
// Traverse tree and check if prefix exists.
while (ptr)
{
if (*temp < ptr->m_Data)
{
ptr = ptr->m_Less;
} else if (*temp == ptr->m_Data)
{
// Prefix exists in tree.
if (*(temp + 1) == '\0')
{
if (partial_complete)
{
ACNode *pc_ptr = ptr->m_Equal;
// Get partially completed string.
while (pc_ptr)
{
if (pc_ptr->m_Equal && !pc_ptr->m_Less && !pc_ptr->m_Greater)
prefix.push_back(pc_ptr->m_Data);
else
break;
pc_ptr = pc_ptr->m_Equal;
}
}
break;
}
ptr = ptr->m_Equal;
++temp;
} else
{
ptr = ptr->m_Greater;
}
}
// Already a word. (No need to auto complete).
if (ptr && ptr->m_IsWord) return;
// Prefix is not in tree.
if (!ptr) return;
// Retrieve auto complete options.
SuggestionsAux(ptr->m_Equal, ac_options, prefix.substr(0, prefix_end));
}
CSYS_INLINE std::unique_ptr<AutoComplete::sVector> AutoComplete::Suggestions(const char *prefix)
{
auto temp = std::make_unique<sVector>();
Suggestions(prefix, *temp);
return temp;
}
///////////////////////////////////////////////////////////////////////////
// Private methods ////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
CSYS_INLINE void AutoComplete::SuggestionsAux(AutoComplete::ACNode *root, r_sVector ac_options, std::string buffer)
{
if (!root) return;
// Continue looking in left branch.
if (root->m_Less) SuggestionsAux(root->m_Less, ac_options, buffer);
// Word was found, push into autocomplete options.
if (root->m_IsWord)
{
ac_options.push_back(buffer.append(1, root->m_Data));
buffer.pop_back();
}
// Continue in middle branch, and push character.
if (root->m_Equal)
{
SuggestionsAux(root->m_Equal, ac_options, buffer.append(1, root->m_Data));
buffer.pop_back();
}
// Continue looking in right branch.
if (root->m_Greater)
{
SuggestionsAux(root->m_Greater, ac_options, buffer);
}
}
CSYS_INLINE bool AutoComplete::RemoveAux(AutoComplete::ACNode *root, const char *word)
{
if (!root) return false;
// String is in TST.
if (*(word + 1) == '\0' && root->m_Data == *word)
{
// Un-mark word node.
if (root->m_IsWord)
{
root->m_IsWord = false;
return (!root->m_Equal && !root->m_Less && !root->m_Greater);
}
// String is a prefix.
else
return false;
} else
{
// String is a prefix.
if (*word < root->m_Data)
RemoveAux(root->m_Less, word);
else if (*word > root->m_Data)
RemoveAux(root->m_Greater, word);
// String is in TST.
else if (*word == root->m_Data)
{
// Char is unique.
if (RemoveAux(root->m_Equal, word + 1))
{
delete root->m_Equal;
root->m_Equal = nullptr;
return !root->m_IsWord && (!root->m_Equal && !root->m_Less && !root->m_Greater);
}
}
}
return false;
}
CSYS_INLINE void AutoComplete::DeepClone(AutoComplete::ACNode *src, AutoComplete::ACNode *&dest)
{
if (!src) return;
dest = new ACNode(*src);
DeepClone(src->m_Less, dest->m_Less);
DeepClone(src->m_Equal, dest->m_Equal);
DeepClone(src->m_Greater, dest->m_Greater);
}
}

292
include/csys/command.h Normal file
View File

@ -0,0 +1,292 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_COMMAND_H
#define CSYS_COMMAND_H
#pragma once
#include <functional>
#include <type_traits>
#include <utility>
#include "csys/arguments.h"
#include "csys/exceptions.h"
#include "csys/item.h"
namespace csys
{
/*!
* \brief
* Non-templated class that allows for the storage of commands as well as accessing certain functionality of
* said commands.
*/
struct CommandBase
{
/*!
* \brief
* Default virtual destructor
*/
virtual ~CommandBase() = default;
/*!
* \brief
* Parses and runs the function held within the child class
* \param input
* String of arguments for the command to parse and pass to the function
* \return
* Returns item error if the parsing in someway was messed up, and none if there was no issue
*/
virtual Item operator()(String &input) = 0;
/*!
* \brief
* Gets info about the command and usage
* \return
* String containing info about the command
*/
[[nodiscard]] virtual std::string Help() = 0;
/*!
* \brief
* Getter for the number of arguments the command takes
* \return
* Returns the number of arguments taken by the command
*/
[[nodiscard]] virtual size_t ArgumentCount() const = 0;
/*!
* \brief
* Deep copies a command
* \return
* Pointer to newly copied command
*/
[[nodiscard]] virtual CommandBase* Clone() const = 0;
};
/*!
* \brief
* Base template for a command that takes N amount of arguments
* \tparam Fn
* Decltype of function to be called when command is parsed and ran
* \tparam Args
* Argument type list that is proportional to the argument list of the function Fn
*/
template<typename Fn, typename ...Args>
class CSYS_API Command : public CommandBase
{
public:
/*!
* \brief
* Constructor that sets the name, description, function and arguments as well as add a null argument
* for parsing
* \param name
* Name of the command to call by
* \param description
* Info about the command
* \param function
* Function to run when command is called
* \param args
* Arguments to be used for parsing and passing into the function. Must be of type "Arg<T>"
*/
Command(String name, String description, Fn function, Args... args) : m_Name(std::move(name)),
m_Description(std::move(description)),
m_Function(function),
m_Arguments(args..., Arg<NULL_ARGUMENT>())
{}
/*!
* \brief
* Parses and runs the function m_Function
* \param input
* String of arguments for the command to parse and pass to the function
* \return
* Returns item error if the parsing in someway was messed up, and none if there was no issue
*/
Item operator()(String &input) final
{
try
{
// Try to parse and call the function
constexpr int argumentSize = sizeof... (Args);
Call(input, std::make_index_sequence<argumentSize + 1>{}, std::make_index_sequence<argumentSize>{});
}
catch (Exception &ae)
{
// Error happened with parsing
return Item(eERROR) << (m_Name.m_String + ": " + ae.what());
}
return Item(eNONE);
}
/*!
* \brief
* Gets info about the command and usage
* \return
* String containing info about the command
*/
[[nodiscard]] std::string Help() final
{
return m_Name.m_String + DisplayArguments(std::make_index_sequence<sizeof ...(Args)>{}) + "\n\t\t- " +
m_Description.m_String + "\n\n";
}
/*!
* \brief
* Getter for the number of arguments the command takes
* \return
* Returns the number of arguments taken by the command
*/
[[nodiscard]] size_t ArgumentCount() const final
{
return sizeof... (Args);
}
/*!
* \brief
* Deep copies a command
* \return
* Pointer to newly copied command
*/
[[nodiscard]] CommandBase* Clone() const final
{
return new Command<Fn, Args...>(*this);
}
private:
/*!
* \brief
* Parses arguments and passes them into the command to be ran
* \tparam Is_p
* Index sequence from 0 to Argument Count + 1, used for parsing
* \tparam Is_c
* Index sequence from 0 to Argument Count, used for passing into the function
* \param input
* String of arguments to be parsed
*/
template<size_t... Is_p, size_t... Is_c>
void Call(String &input, const std::index_sequence<Is_p...> &, const std::index_sequence<Is_c...> &)
{
size_t start = 0;
// Parse arguments
int _[]{0, (void(std::get<Is_p>(m_Arguments).Parse(input, start)), 0)...};
(void) (_);
// Call function with unpacked tuple
m_Function((std::get<Is_c>(m_Arguments).m_Arg.m_Value)...);
}
/*!
* \brief
* Displays the usage for running the command successfully
* \tparam Is
* Index sequence from 0 to Argument CountH
* \return
* Returns a string containing the usage of the command
*/
template<size_t ...Is>
std::string DisplayArguments(const std::index_sequence<Is...> &)
{
return (std::get<Is>(m_Arguments).Info() + ...);
}
const String m_Name; //!< Name of command
const String m_Description; //!< Description of the command
std::function<void(typename Args::ValueType...)> m_Function; //!< Function to be invoked as command
std::tuple<Args..., Arg<NULL_ARGUMENT>> m_Arguments; //!< Arguments to be passed into m_Function
};
/*!
* \brief
* Template specialization for a command that doesn't take any arguments
* \tparam Fn
* Decltype of function to be called when the command is invoked
*/
template<typename Fn>
class CSYS_API Command<Fn> : public CommandBase
{
public:
/*!
* \brief
* Constructor that sets the name, description and function. A null argument will be added to the arguments
* for parsing
* \param name
* Name of the command to call by
* \param description
* Info about the command
* \param function
* Function to run when command is called
*/
Command(String name, String description, Fn function) : m_Name(std::move(name)),
m_Description(std::move(description)),
m_Function(function), m_Arguments(Arg<NULL_ARGUMENT>())
{}
/*!
* \brief
* Parses and runs the function m_Function
* \param input
* String of arguments for the command to parse and pass to the function. This should be empty
* \return
* Returns item error if the parsing in someway was messed up, and none if there was no issue
*/
Item operator()(String &input) final
{
// call the function
size_t start = 0;
try
{
// Check to see if input is all whitespace
std::get<0>(m_Arguments).Parse(input, start);
}
catch (Exception &ae)
{
// Command had something passed into it
return Item(eERROR) << (m_Name.m_String + ": " + ae.what());
}
// Call function
m_Function();
return Item(eNONE);
}
/*!
* \brief
* Gets info about the command and usage
* \return
* String containing info about the command
*/
[[nodiscard]] std::string Help() final
{
return m_Name.m_String + "\n\t\t- " + m_Description.m_String + "\n\n";
}
/*!
* \brief
* Getter for the number of arguments the command takes
* \return
* 0
*/
[[nodiscard]] size_t ArgumentCount() const final
{
return 0;
}
/*!
* \brief
* Deep copies a command
* \return
* Pointer to newly copied command
*/
[[nodiscard]] CommandBase* Clone() const final
{
return new Command<Fn>(*this);
}
private:
const String m_Name; //!< Name of command
const String m_Description; //!< Description of the command
std::function<void(void)> m_Function; //!< Function to be invoked as command
std::tuple<Arg<NULL_ARGUMENT>> m_Arguments; //!< Arguments to be passed into m_Function
};
}
#endif //CSYS_COMMAND_H

11
include/csys/csys.h Normal file
View File

@ -0,0 +1,11 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_H
#define CSYS_H
#pragma once
#include "csys/system.h"
#endif

64
include/csys/exceptions.h Normal file
View File

@ -0,0 +1,64 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_EXCEPTIONS_H
#define CSYS_EXCEPTIONS_H
#pragma once
#include <string>
#include <exception>
#include <utility>
#include "csys/api.h"
namespace csys
{
/*!
* \brief
* Csys exception extended from the stl for any issues
*/
class CSYS_API Exception : public std::exception
{
public:
/*!
* \brief
* Basic constructor that makes a message with an arg
* \param message
* Message describing what went wrong
* \param arg
* What went wrong (will get put between ' ')
*/
explicit Exception(const std::string &message, const std::string &arg) : m_Msg(message + ": '" + arg + "'")
{}
/*!
* \brief
* Constructor for one string
* \param message
* Message describing what went wrong
*/
explicit Exception(std::string message) : m_Msg(std::move(message))
{}
/*!
* \brief
* Default destructor
*/
~Exception() override = default;
/*!
* \brief
* Gets what happened
* \return
* Returns a c-style string of what happened
*/
[[nodiscard]] const char *what() const noexcept override
{
return m_Msg.c_str();
}
protected:
std::string m_Msg; //!< Message of what happened
};
}
#endif //CSYS_CSYS_EXCEPTIONS_H

152
include/csys/history.h Normal file
View File

@ -0,0 +1,152 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_HISTORY_H
#define CSYS_HISTORY_H
#pragma once
#include <string>
#include <vector>
#include "csys/api.h"
namespace csys
{
class CSYS_API CommandHistory
{
public:
/*!
* \brief
* Command history constructor.
* \param maxRecord
* Maximum amount of command strings to keep track at once.
*/
explicit CommandHistory(unsigned int maxRecord = 100);
/*!
* \brief
* Move constructor
* \param rhs
* History to be copied.
*/
CommandHistory(CommandHistory &&rhs) = default;
/*!
* \brief
* Copy constructor
* \param rhs
* History to be copied.
*/
CommandHistory(const CommandHistory &rhs) = default;
/*!
* \brief
* Move assignment operator
* \param rhs
* History to be copied.
*/
CommandHistory &operator=(CommandHistory &&rhs) = default;
/*!
* \brief
* Copy assigment operator.
* \param rhs
* History to be copied.
*/
CommandHistory &operator=(const CommandHistory &rhs) = default;
/*!
* \brief
* Record command string. (Start at the beginning once end is reached).
* \param line
* Command string to be recorded.
*/
void PushBack(const std::string &line);
/*!
* \brief
* Get newest register command entry index
* \return
* Newest command entry index
*/
[[nodiscard]] unsigned int GetNewIndex() const;
/*!
* \brief
* Get newest register command entry
* \return
* Newest command entry
*/
const std::string &GetNew();
/*!
* \brief
* Get oldest register command entry index
* \return
* Oldest command entry index
*/
[[nodiscard]] unsigned int GetOldIndex() const;
/*!
* \brief
* Get oldest register command entry
* \return
* Oldest command entry string
*/
const std::string &GetOld();
/*!
* \brief Clear command history
*/
void Clear();
/*!
* \brief
* Retrieve command history at given index
* \param index
* Position to lookup in command history vector
* \return
* Command at given index
*
* \note
* No bound checking is performed when accessing with these index operator.
* Use the *index()* method for safe history vector indexing.
*/
const std::string &operator[](size_t index);
/*!
* \brief
* Output available command history.
* \param os
* Output stream
* \param history
* Reference to history to be printed
* \return
* Reference to history to be printed
*/
friend std::ostream &operator<<(std::ostream &os, const CommandHistory &history);
/*!
* \return
* Number of registered commands.
*/
size_t Size();
/*!
* \return
* Maximum commands that are able to be recorded
*/
size_t Capacity();
protected:
unsigned int m_Record; //!< Amount of commands recorded
unsigned int m_MaxRecord; //!< Maximum command record to keep track of
std::vector<std::string> m_History; //!< Console command history
};
}
#ifdef CSYS_HEADER_ONLY
#include "csys/history.inl"
#endif
#endif //CSYS_HISTORY_H

83
include/csys/history.inl Normal file
View File

@ -0,0 +1,83 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef CSYS_HEADER_ONLY
#include "csys/history.h"
#endif
#include <algorithm>
#include <iostream>
namespace csys
{
///////////////////////////////////////////////////////////////////////////
// Public methods /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
CSYS_INLINE CommandHistory::CommandHistory(unsigned int maxRecord) : m_Record(0), m_MaxRecord(maxRecord), m_History(maxRecord)
{
}
CSYS_INLINE void CommandHistory::PushBack(const std::string &line)
{
m_History[m_Record++ % m_MaxRecord] = line;
}
CSYS_INLINE unsigned int CommandHistory::GetNewIndex() const
{
return (m_Record - 1) % m_MaxRecord;
}
CSYS_INLINE const std::string &CommandHistory::GetNew()
{
return m_History[(m_Record - 1) % m_MaxRecord];
}
CSYS_INLINE unsigned int CommandHistory::GetOldIndex() const
{
if (m_Record <= m_MaxRecord)
return 0;
else
return m_Record % m_MaxRecord;
}
CSYS_INLINE const std::string &CommandHistory::GetOld()
{
if (m_Record <= m_MaxRecord)
return m_History.front();
else
return m_History[m_Record % m_MaxRecord];
}
CSYS_INLINE void CommandHistory::Clear()
{
m_Record = 0;
}
CSYS_INLINE const std::string &CommandHistory::operator[](size_t index)
{
return m_History[index];
}
CSYS_INLINE std::ostream &operator<<(std::ostream &os, const CommandHistory &history)
{
os << "History: " << '\n';
for (unsigned int i = 0; i < history.m_Record && history.m_Record <= history.m_MaxRecord; ++i)
std::cout << history.m_History[i] << '\n';
return os;
}
CSYS_INLINE size_t CommandHistory::Size()
{
return m_Record < m_MaxRecord ? m_Record : m_MaxRecord;
}
CSYS_INLINE size_t CommandHistory::Capacity()
{
return m_History.capacity();
}
}

197
include/csys/item.h Normal file
View File

@ -0,0 +1,197 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_ITEM_H
#define CSYS_ITEM_H
#pragma once
#include <vector>
#include <string>
#include "csys/api.h"
namespace csys
{
static const char endl = '\n';
/*!
* \brief
* Console item type:
* - Command: Only used for commands.
* - Log: Used to log information inside a command.
* - Warning: Warn client through console.
* - Error: Display error to client through console.
* - Info: Any information wished to display through console.
* - None: Empty console item.
*/
enum ItemType
{
eCOMMAND = 0,
eLOG,
eWARNING,
eERROR,
eINFO,
eNONE
};
struct CSYS_API Item
{
/*!
* \brief
* Create console item type
* \param type
* Item type to be stored
*/
explicit Item(ItemType type = ItemType::eLOG);
/*!
* \brief
* Move constructor
* \param rhs
* Item to be copied.
*/
Item(Item &&rhs) = default;
/*!
* \brief
* Copy constructor
* \param rhs
* Item to be copied.
*/
Item(const Item &rhs) = default;
/*!
* \brief
* Move assignment operator
* \param rhs
* Item to be copied.
*/
Item &operator=(Item &&rhs) = default;
/*!
* \brief
* Copy assigment operator.
* \param rhs
* Item to be copied.
*/
Item &operator=(const Item &rhs) = default;
/*!
* \brief
* Log data to console item
* \param str
* Append string to item data
* \return
* Self (To allow for fluent logging)
*/
Item &operator<<(std::string_view str);
/*!
* \brief
* Get final/styled string of the item
* \return
* Stylized item string
*/
[[nodiscard]] std::string Get() const;
ItemType m_Type; //!< Console item type
std::string m_Data; //!< Item string data
unsigned int m_TimeStamp; //!< Record timestamp
};
#define LOG_BASIC_TYPE_DECL(type) ItemLog& operator<<(type data)
class CSYS_API ItemLog
{
public:
/*!
* \brief
* Log console item
* \param type
* Type of item to log
* \return
* Self (To allow for fluent logging)
*/
ItemLog &log(ItemType type);
ItemLog() = default;
/*!
* \brief
* Move constructor
* \param rhs
* ItemLog to be copied.
*/
ItemLog(ItemLog &&rhs) = default;
/*!
* \brief
* Copy constructor
* \param rhs
* ItemLog to be copied.
*/
ItemLog(const ItemLog &rhs) = default;
/*!
* \brief
* Move assignment operator
* \param rhs
* ItemLog to be copied.
*/
ItemLog &operator=(ItemLog &&rhs) = default;
/*!
* \brief
* Copy assigment operator.
* \param rhs
* ItemLog to be copied.
*/
ItemLog &operator=(const ItemLog &rhs) = default;
/*!
* \brief
* Get logged console items
* \return
* Console log
*/
std::vector<Item> &Items();
/*!
* \brief Delete console item log history
*/
void Clear();
LOG_BASIC_TYPE_DECL(int);
LOG_BASIC_TYPE_DECL(long);
LOG_BASIC_TYPE_DECL(float);
LOG_BASIC_TYPE_DECL(double);
LOG_BASIC_TYPE_DECL(long long);
LOG_BASIC_TYPE_DECL(long double);
LOG_BASIC_TYPE_DECL(unsigned int);
LOG_BASIC_TYPE_DECL(unsigned long);
LOG_BASIC_TYPE_DECL(unsigned long long);
LOG_BASIC_TYPE_DECL(std::string_view);
LOG_BASIC_TYPE_DECL(char);
protected:
std::vector<Item> m_Items;
};
}
#ifdef CSYS_HEADER_ONLY
#include "csys/item.inl"
#endif
#endif

116
include/csys/item.inl Normal file
View File

@ -0,0 +1,116 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef CSYS_HEADER_ONLY
#include "csys/item.h"
#endif
#include <chrono>
namespace csys
{
///////////////////////////////////////////////////////////////////////////
// Console Item ///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
CSYS_INLINE static const std::string_view s_Command = "> ";
CSYS_INLINE static const std::string_view s_Warning = "\t[WARNING]: ";
CSYS_INLINE static const std::string_view s_Error = "[ERROR]: ";
CSYS_INLINE static const auto s_TimeBegin = std::chrono::steady_clock::now();
CSYS_INLINE Item::Item(ItemType type) : m_Type(type)
{
auto timeNow = std::chrono::steady_clock::now();
m_TimeStamp = static_cast<unsigned int>(std::chrono::duration_cast<std::chrono::milliseconds>(timeNow - s_TimeBegin).count());
}
CSYS_INLINE Item &Item::operator<<(const std::string_view str)
{
m_Data.append(str);
return *this;
}
CSYS_INLINE std::string Item::Get() const
{
switch (m_Type)
{
case eCOMMAND:
return s_Command.data() + m_Data;
case eLOG:
return '\t' + m_Data;
case eWARNING:
return s_Warning.data() + m_Data;
case eERROR:
return s_Error.data() + m_Data;
case eINFO:
return m_Data;
case eNONE:
default:
return "";
}
}
///////////////////////////////////////////////////////////////////////////
// Console Item Log ///////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
#define LOG_BASIC_TYPE_DEF(type)\
CSYS_INLINE ItemLog& ItemLog::operator<<(type data)\
{\
m_Items.back() << std::to_string(data);\
return *this;\
}
CSYS_INLINE ItemLog &ItemLog::log(ItemType type)
{
// New item.
m_Items.emplace_back(type);
return *this;
}
CSYS_INLINE std::vector<Item> &ItemLog::Items()
{
return m_Items;
}
CSYS_INLINE void ItemLog::Clear()
{
m_Items.clear();
}
CSYS_INLINE ItemLog &ItemLog::operator<<(const std::string_view data)
{
m_Items.back() << data;
return *this;
}
CSYS_INLINE ItemLog &ItemLog::operator<<(const char data)
{
m_Items.back().m_Data.append(1, data);
return *this;
}
// Basic type operator definitions.
LOG_BASIC_TYPE_DEF(int)
LOG_BASIC_TYPE_DEF(long)
LOG_BASIC_TYPE_DEF(float)
LOG_BASIC_TYPE_DEF(double)
LOG_BASIC_TYPE_DEF(long long)
LOG_BASIC_TYPE_DEF(long double)
LOG_BASIC_TYPE_DEF(unsigned int)
LOG_BASIC_TYPE_DEF(unsigned long)
LOG_BASIC_TYPE_DEF(unsigned long long)
}

120
include/csys/script.h Normal file
View File

@ -0,0 +1,120 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_SCRIPT_H
#define CSYS_SCRIPT_H
#pragma once
#include <string>
#include <vector>
#include "csys/api.h"
namespace csys
{
class CSYS_API Script
{
public:
/*!
* \brief
* Create script object from file
* \param path
* Path of script file
* \param load_on_init
* Load script when object is created
*/
explicit Script(std::string path, bool load_on_init = true);
/*!
* \brief
* Create script object from file
* \param path
* Path of script file
* \param load_on_init
* Load script when object is created
*/
explicit Script(const char *path, bool load_on_init = true);
/*!
* \brief
* Create script object from file already in memory
* \param data
* Script file memory
*/
explicit Script(std::vector<std::string> data);
/*!
* \brief
* Move constructor
* \param rhs
* Script to be copied.
*/
Script(Script &&rhs) = default;
/*!
* \brief
* Copy constructor
* \param rhs
* Script to be copied.
*/
Script(const Script &rhs) = default;
/*!
* \brief
* Move assignment operator
* \param rhs
* Script to be copied.
*/
Script &operator=(Script &&rhs) = default;
/*!
* \brief
* Copy assigment operator.
* \param rhs
* Script to be copied.
*/
Script &operator=(const Script &rhs) = default;
/*!
* \brief Load script file
*/
void Load();
/*!
* \brief Reload script file (Unload & Load)
*/
void Reload();
/*!
* /brief Clear script data
*/
void Unload();
/*!
* \brief
* Set script file path (Will be used when laoding)
* \param path
* Script file path
*/
void SetPath(std::string path);
/*!
* \brief
* Retrieve script data (Commands)
* \return
* List of commands in script
*/
const std::vector<std::string> &Data();
protected:
std::vector<std::string> m_Data; //!< Commands in script
std::string m_Path; //!< Path of script file
bool m_FromMemory; //!< Flag to specify if script was loaded from file or memory
};
}
#ifdef CSYS_HEADER_ONLY
#include "csys/script.inl"
#endif
#endif

83
include/csys/script.inl Normal file
View File

@ -0,0 +1,83 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef CSYS_HEADER_ONLY
#include "csys/script.h"
#endif
#include <fstream>
#include <utility>
#include "csys/exceptions.h"
namespace csys
{
CSYS_INLINE Script::Script(std::string path, bool load_on_init) : m_Path(std::move(path)), m_FromMemory(false)
{
// Load file.
if (load_on_init)
Load();
}
CSYS_INLINE Script::Script(const char *path, bool load_on_init) : m_Path(path), m_FromMemory(false)
{
// Load file.
if (load_on_init)
Load();
}
CSYS_INLINE Script::Script(std::vector<std::string> data) : m_Data(std::move(data)), m_FromMemory(true)
{}
CSYS_INLINE void Script::Load()
{
std::ifstream script_fstream(m_Path);
// Error check.
if (!script_fstream.good())
throw csys::Exception("Failed to load script", m_Path);
// Check and open file.
if (script_fstream.good() && script_fstream.is_open())
{
// Line buffer.
std::string line_buf;
// Read commands.
while (std::getline(script_fstream, line_buf))
{
m_Data.emplace_back(line_buf);
}
// Close file.
script_fstream.close();
}
}
CSYS_INLINE void Script::Reload()
{
if (m_FromMemory) return;
Unload();
Load();
}
CSYS_INLINE void Script::Unload()
{
m_Data.clear();
}
CSYS_INLINE void Script::SetPath(std::string path)
{
m_Path = std::move(path);
}
CSYS_INLINE const std::vector<std::string> &Script::Data()
{
return m_Data;
}
}

110
include/csys/string.h Normal file
View File

@ -0,0 +1,110 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_STRING_H
#define CSYS_STRING_H
#pragma once
#include <string>
#include <cctype>
#include "csys/api.h"
namespace csys
{
/*!
* \brief
* Wrapper around std::string to be used with parsing a string argument
*/
struct CSYS_API String
{
/*!
* \brief
* Default constructor
*/
String() = default;
/*!
* \brief
* Conversion constructor from c-style string. A deep copy is made
* \param str
* String to be converted
*/
String(const char *str [[maybe_unused]]) : m_String(str ? str : "")
{}
/*!
* \brief
* Conversion constructor from an std::string to csys::String. A deep copy is made
* \param str
* String to be converted
*/
String(std::string str) : m_String(std::move(str))
{}
/*!
* \brief
* Conversion constructor from csys::String to a c-style string
* \return
* Returns a pointer to the string contained within this string
*/
operator const char *()
{ return m_String.c_str(); }
/*!
* \brief
* Conversion constructor from csys::String to an std::string
* \return
* Returns a copy of this string
*/
operator std::string()
{ return m_String; }
/*!
* \brief
* Moves until first non-whitespace char, and continues until the end of the string or a whitespace has is
* found
* \param start
* Where to start scanning from. Will be set to pair.second
* \return
* Returns the first element and one passed the end of non-whitespace. In other words [first, second)
*/
std::pair<size_t, size_t> NextPoi(size_t &start) const
{
size_t end = m_String.size();
std::pair<size_t, size_t> range(end + 1, end);
size_t pos = start;
// Go to the first non-whitespace char
for (; pos < end; ++pos)
if (!std::isspace(m_String[pos]))
{
range.first = pos;
break;
}
// Go to the first whitespace char
for (; pos < end; ++pos)
if (std::isspace(m_String[pos]))
{
range.second = pos;
break;
}
start = range.second;
return range;
}
/*!
* \brief
* Returns a value to be compared with the .first of the pair returned from NextPoi
* \return
* Returns size of string + 1
*/
[[nodiscard]] size_t End() const
{ return m_String.size() + 1; }
std::string m_String; //!< String data member
};
}
#endif //CSYS_CSYS_STRING_H

356
include/csys/system.h Normal file
View File

@ -0,0 +1,356 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef CSYS_SYSTEM_H
#define CSYS_SYSTEM_H
#pragma once
#include "csys/command.h"
#include "csys/autocomplete.h"
#include "csys/history.h"
#include "csys/item.h"
#include "csys/script.h"
#include <memory>
#include <unordered_map>
#include <string>
namespace csys
{
class CSYS_API System
{
public:
/*!
* \brief Initialize system object
*/
System();
/*!
* \brief
* Move constructor
* \param rhs
* System to be copied.
*/
System(System &&rhs) = default;
/*!
* \brief
* Copy constructor
* \param rhs
* System to be copied.
*/
System(const System &rhs);
/*!
* \brief
* Move assignment operator
* \param rhs
* System to be copied.
*/
System &operator=(System &&rhs) = default;
/*!
* \brief
* Copy assigment operator.
* \param rhs
* System to be copied.
*/
System &operator=(const System &rhs);
/*!
* \brief
* Parse given command line input and run it
* \param line
* Command line string
*/
void RunCommand(const std::string &line);
/*!
* \brief
* Get console registered command autocomplete tree
* \return
* Autocomplete Ternary Search Tree
*/
AutoComplete &CmdAutocomplete();
/*!
* \brief
* Get console registered variables autocomplete tree
* \return
* Autocomplete Ternary Search Tree
*/
AutoComplete &VarAutocomplete();
/*!
* \brief
* Get command history container
* \return
* Command history vector
*/
CommandHistory &History();
/*!
* \brief
* Get console items
* \return
* Console items container
*/
std::vector<Item> &Items();
/*!
* \brief
* Creates a new item entry to log information
* \param type
* Log type (COMMAND, LOG, WARNING, ERROR)
* \return
* Reference to console items obj
*/
ItemLog &Log(ItemType type = ItemType::eLOG);
/*!
* \brief
* Run the given script
* \param script_name
* Script to be executed
*
* \note
* If script exists but its not loaded, this methods will load the script and proceed to run it.
*/
void RunScript(const std::string &script_name);
/*!
* \brief
* Get registered command container
* \return
* Commands container
*/
std::unordered_map<std::string, std::unique_ptr<CommandBase>> &Commands();
/*!
* \brief
* Get registered scripts container
* \return
* Scripts container
*/
std::unordered_map<std::string, std::unique_ptr<Script>> &Scripts();
/*!
* \brief
* Registers a command within the system to be invokable
* \tparam Fn
* Decltype of the function to invoke when command is ran
* \tparam Args
* List of arguments that match that of the argument list within the function Fn of type csys::Arg<T>
* \param name
* Non-whitespace separating name of the command. Whitespace will be dropped
* \param description
* Description describing what the command does
* \param function
* A non-member function to run when command is called
* \param args
* List of csys::Arg<T>s that matches that of the argument list of 'function'
*/
template<typename Fn, typename ...Args>
void RegisterCommand(const String &name, const String &description, Fn function, Args... args)
{
// Check if function can be called with the given arguments and is not part of a class
static_assert(std::is_invocable_v<Fn, typename Args::ValueType...>, "Arguments specified do not match that of the function");
static_assert(!std::is_member_function_pointer_v<Fn>, "Non-static member functions are not allowed");
// Move to command
size_t name_index = 0;
auto range = name.NextPoi(name_index);
// Command already registered
if (m_Commands.find(name.m_String) != m_Commands.end())
throw csys::Exception("ERROR: Command already exists");
// Check if command has a name
else if (range.first == name.End())
{
Log(eERROR) << "Empty command name given" << csys::endl;
return;
}
// Get command name
std::string command_name = name.m_String.substr(range.first, range.second - range.first);
// Command contains more than one word
if (name.NextPoi(name_index).first != name.End())
throw csys::Exception("ERROR: Whitespace separated command names are forbidden");
// Register for autocomplete.
if (m_RegisterCommandSuggestion)
{
m_CommandSuggestionTree.Insert(command_name);
m_VariableSuggestionTree.Insert(command_name);
}
// Add commands to system
m_Commands[name.m_String] = std::make_unique<Command<Fn, Args...>>(name, description, function, args...);
// Make help command for command just added
auto help = [this, command_name]() {
Log(eLOG) << m_Commands[command_name]->Help() << csys::endl;
};
m_Commands["help " + command_name] = std::make_unique<Command<decltype(help)>>("help " + command_name,
"Displays help info about command " +
command_name, help);
}
/*!
* \brief
* Register's a variable within the system
* \tparam T
* Type of the variable
* \tparam Types
* Type of arguments that type T can be constructed with
* \param name
* Name of the variable
* \param var
* The variable to register
* \param args
* List of csys::Arg to be used for the construction of type T
* \note
* Type T requires an assignment operator, and constructor that takes type 'Types...'
* Param 'var' is assumed to have a valid life-time up until it is unregistered or the program ends
*/
template<typename T, typename ...Types>
void RegisterVariable(const String &name, T &var, Arg<Types>... args)
{
static_assert(std::is_constructible_v<T, Types...>, "Type of var 'T' can not be constructed with types of 'Types'");
static_assert(sizeof... (Types) != 0, "Empty variadic list");
// Register get command
auto var_name = RegisterVariableAux(name, var);
// Register set command
auto setter = [&var](Types... params){ var = T(params...); };
m_Commands["set " + var_name] = std::make_unique<Command<decltype(setter), Arg<Types>...>>("set " + var_name,
"Sets the variable " + var_name,
setter, args...);
}
/*!
* \brief
* Register's a variable within the system
* \tparam T
* Type of the variable
* \tparam Types
* Type of arguments that type T can be constructed with
* \param name
* Name of the variable
* \param var
* The variable to register
* \param setter
* Custom setter that runs when command set 'name' is invoked
* \note
* The setter must have dceltype of void(decltype(var)&, Types...)
* Param 'var' is assumed to have a valid life-time up until it is unregistered or the program ends
*/
template<typename T, typename ...Types>
void RegisterVariable(const String &name, T &var, void(*setter)(T&, Types...))
{
// Register get command
auto var_name = RegisterVariableAux(name, var);
// Register set command
auto setter_l = [&var, setter](Types... args){ setter(var, args...); };
m_Commands["set " + var_name] = std::make_unique<Command<decltype(setter_l), Arg<Types>...>>("set " + var_name,
"Sets the variable " + var_name,
setter_l, Arg<Types>("")...);
}
/*!
* \brief
* Register script into console system
* \param name
* Script name
* \param path
* Scrip path
*/
void RegisterScript(const std::string &name, const std::string &path);
/*!
* \brief
* Unregister command from console system
* \param cmd_name
* Command to unregister
*/
void UnregisterCommand(const std::string &cmd_name);
/*!
* \brief
* Unregister variable from console system
* \param var_name
* Variable to unregister
*/
void UnregisterVariable(const std::string &var_name);
/*!
* \brief
* Unregister script from console system
* \param script_name
* Script to unregister
*/
void UnregisterScript(const std::string &script_name);
protected:
template<typename T>
std::string RegisterVariableAux(const String &name, T &var)
{
// Disable.
m_RegisterCommandSuggestion = false;
// Make sure only one word was passed in
size_t name_index = 0;
auto range = name.NextPoi(name_index);
if (name.NextPoi(name_index).first != name.End())
throw csys::Exception("ERROR: Whitespace separated variable names are forbidden");
// Get variable name
std::string var_name = name.m_String.substr(range.first, range.second - range.first);
// Get Command
const auto GetFunction = [this, &var]() {
m_ItemLog.log(eLOG) << var << endl;
};
// Register get command
m_Commands["get " + var_name] = std::make_unique<Command<decltype(GetFunction)>>("get " + var_name,
"Gets the variable " +
var_name, GetFunction);
// Enable again.
m_RegisterCommandSuggestion = true;
// Register variable
m_VariableSuggestionTree.Insert(var_name);
return var_name;
}
void ParseCommandLine(const String &line); //!< Parse command line and execute command
std::unordered_map<std::string, std::unique_ptr<CommandBase>> m_Commands; //!< Registered command container
AutoComplete m_CommandSuggestionTree; //!< Autocomplete Ternary Search Tree for commands
AutoComplete m_VariableSuggestionTree; //!< Autocomplete Ternary Search Tree for registered variables
CommandHistory m_CommandHistory; //!< History of executed commands
ItemLog m_ItemLog; //!< Console Items (Logging)
std::unordered_map<std::string, std::unique_ptr<Script>> m_Scripts; //!< Scripts
bool m_RegisterCommandSuggestion = true; //!< Flag that determines if commands will be registered for autocomplete.
};
}
#ifdef CSYS_HEADER_ONLY
#include "csys/system.inl"
#endif
#endif
// void (T&, int, float...);
// registaerVariable("name", var, Arg<int>...); //c
// registaerVariable("name", var, setter); //d

300
include/csys/system.inl Normal file
View File

@ -0,0 +1,300 @@
// Copyright (c) 2020-present, Roland Munguia & Tristan Florian Bouchard.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#pragma once
#ifndef CSYS_HEADER_ONLY
#include "csys/system.h"
#endif
namespace csys
{
///////////////////////////////////////////////////////////////////////////
// Public methods /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Commands-Error-Warning strings.
static const std::string_view s_Set = "set";
static const std::string_view s_Get = "get";
static const std::string_view s_Help = "help";
static const std::string_view s_ErrorNoVar = "No variable provided";
static const std::string_view s_ErrorSetGetNotFound = "Command doesn't exist and/or variable is not registered";
CSYS_INLINE System::System()
{
// Register help command.
RegisterCommand(s_Help.data(), "Display commands information", [this]()
{
// Custom command information display
Log() << "help [command_name:String] (Optional)\n\t\t- Display command(s) information\n" << csys::endl;
Log() << "set [variable_name:String] [data]\n\t\t- Assign data to given variable\n" << csys::endl;
Log() << "get [variable_name:String]\n\t\t- Display data of given variable\n" << csys::endl;
for (const auto &tuple : Commands())
{
// Filter set and get.
if (tuple.first.size() >= 5 && (tuple.first[3] == ' ' || tuple.first[4] == ' '))
continue;
// Skip help command.
if (tuple.first.size() == 4 && (tuple.first == "help"))
continue;
// Print the rest of commands
Log() << tuple.second->Help();
}
});
// Register pre-defined commands.
m_CommandSuggestionTree.Insert(s_Set.data());
m_CommandSuggestionTree.Insert(s_Get.data());
}
CSYS_INLINE System::System(const System &rhs) : m_CommandSuggestionTree(rhs.m_CommandSuggestionTree),
m_VariableSuggestionTree(rhs.m_VariableSuggestionTree),
m_CommandHistory(rhs.m_CommandHistory),
m_ItemLog(rhs.m_ItemLog),
m_RegisterCommandSuggestion(rhs.m_RegisterCommandSuggestion)
{
// Copy commands.
for (const auto &pair : rhs.m_Commands)
{
m_Commands[pair.first] = std::unique_ptr<CommandBase>(pair.second->Clone());
}
// Copy scripts.
for (const auto &pair: rhs.m_Scripts)
{
m_Scripts[pair.first] = std::make_unique<Script>(*pair.second);
}
}
CSYS_INLINE System &System::operator=(const System &rhs)
{
if (this == &rhs)
return *this;
// Copy commands.
for (const auto &pair : rhs.m_Commands)
{
m_Commands[pair.first] = std::unique_ptr<CommandBase>(pair.second->Clone());
}
// Other data.
m_CommandSuggestionTree = rhs.m_CommandSuggestionTree;
m_VariableSuggestionTree = rhs.m_VariableSuggestionTree;
m_CommandHistory = rhs.m_CommandHistory;
m_ItemLog = rhs.m_ItemLog;
// Copy scripts.
for (const auto &pair: rhs.m_Scripts)
{
m_Scripts[pair.first] = std::make_unique<Script>(*pair.second);
}
// Rest of data.
m_RegisterCommandSuggestion = rhs.m_RegisterCommandSuggestion;
return *this;
}
CSYS_INLINE void System::RunCommand(const std::string &line)
{
// Error checking.
if (line.empty())
return;
// Log command.
Log(csys::ItemType::eCOMMAND) << line << csys::endl;
// Parse command line.
ParseCommandLine(line);
}
CSYS_INLINE void System::RunScript(const std::string &script_name)
{
// Attempt to find script.
auto script_pair = m_Scripts.find(script_name);
// Exit if not found.
if (script_pair == m_Scripts.end())
{
m_ItemLog.log(eERROR) << "Script \"" << script_name << "\" not found" << csys::endl;
return;
}
// About to run script.
m_ItemLog.log(eINFO) << "Running \"" << script_name << "\"" << csys::endl;
// Load if script is empty.
if (script_pair->second->Data().empty())
{
try
{
script_pair->second->Load();
}
catch (csys::Exception &e)
{
Log(eERROR) << e.what() << csys::endl;
}
}
// Run script.
for (const auto &cmd : script_pair->second->Data())
{
// Parse command.
RunCommand(cmd);
}
}
CSYS_INLINE void System::RegisterScript(const std::string &name, const std::string &path)
{
// Attempt to find scripts.
auto script = m_Scripts.find(name);
// Don't register if script already exists.
if (script == m_Scripts.end())
{
m_Scripts[name] = std::make_unique<Script>(path, true);
m_VariableSuggestionTree.Insert(name);
} else
throw csys::Exception("ERROR: Script \'" + name + "\' already registered");
}
CSYS_INLINE void System::UnregisterCommand(const std::string &cmd_name)
{
// Exit if non existent.
if (cmd_name.empty()) return;
// Get command.
auto command_it = m_Commands.find(cmd_name);
auto help_command_it = m_Commands.find("help " + cmd_name);
// Erase if found.
if (command_it != m_Commands.end() && help_command_it != m_Commands.end())
{
m_CommandSuggestionTree.Remove(cmd_name);
m_VariableSuggestionTree.Remove(cmd_name);
m_Commands.erase(command_it);
m_Commands.erase(help_command_it);
}
}
CSYS_INLINE void System::UnregisterVariable(const std::string &var_name)
{
// Exit if non existent.
if (var_name.empty()) return;
// Get command.
auto s_it = m_Commands.find("set " + var_name);
auto g_it = m_Commands.find("get " + var_name);
// Erase if found.
if (s_it != m_Commands.end() && g_it != m_Commands.end())
{
m_VariableSuggestionTree.Remove(var_name);
m_Commands.erase(s_it);
m_Commands.erase(g_it);
}
}
CSYS_INLINE void System::UnregisterScript(const std::string &script_name)
{
// Exit if non existent.
if (script_name.empty()) return;
// Get command.
auto it = m_Scripts.find(script_name);
// Erase if found.
if (it != m_Scripts.end())
{
m_VariableSuggestionTree.Remove(script_name);
m_Scripts.erase(it);
}
}
// Getters ////////////////////////////////////////////////////////////////
CSYS_INLINE AutoComplete &System::CmdAutocomplete() { return m_CommandSuggestionTree; }
CSYS_INLINE AutoComplete &System::VarAutocomplete() { return m_VariableSuggestionTree; }
CSYS_INLINE CommandHistory &System::History() { return m_CommandHistory; }
CSYS_INLINE std::vector<Item> &System::Items() { return m_ItemLog.Items(); }
CSYS_INLINE ItemLog &System::Log(ItemType type) { return m_ItemLog.log(type); }
CSYS_INLINE std::unordered_map<std::string, std::unique_ptr<CommandBase>> &System::Commands() { return m_Commands; }
CSYS_INLINE std::unordered_map<std::string, std::unique_ptr<Script>> &System::Scripts() { return m_Scripts; }
///////////////////////////////////////////////////////////////////////////
// Private methods ////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
CSYS_INLINE void System::ParseCommandLine(const String &line)
{
// Get first non-whitespace char.
size_t line_index = 0;
std::pair<size_t, size_t> range = line.NextPoi(line_index);
// Just whitespace was passed in. Don't log as command.
if (range.first == line.End())
return;
// Push to history.
m_CommandHistory.PushBack(line.m_String);
// Get name of command.
std::string command_name = line.m_String.substr(range.first, range.second - range.first);
// Set or get
bool is_cmd_set = command_name == s_Set;
bool is_cmd_get = command_name == s_Get;
bool is_cmd_help = !(is_cmd_set || is_cmd_get) ? command_name == s_Help : false;
// Edge case for if user is just runs "help" command
if (is_cmd_help)
{
range = line.NextPoi(line_index);
if (range.first != line.End())
command_name += " " + line.m_String.substr(range.first, range.second - range.first);
}
// Its a set or get command
else if (is_cmd_set || is_cmd_get)
{
// Try to get variable name
if ((range = line.NextPoi(line_index)).first == line.End())
{
Log(eERROR) << s_ErrorNoVar << endl;
return;
} else
// Append variable name.
command_name += " " + line.m_String.substr(range.first, range.second - range.first);
}
// Get runnable command
auto command = m_Commands.find(command_name);
if (command == m_Commands.end())
Log(eERROR) << s_ErrorSetGetNotFound << endl;
// Run the command
else
{
// Get the arguments.
String arguments = line.m_String.substr(range.second, line.m_String.size() - range.first);
// Execute command.
auto cmd_out = (*command->second)(arguments);
// Log output.
if (cmd_out.m_Type != eNONE)
m_ItemLog.Items().emplace_back(cmd_out);
}
}
}

656
include/imgui/imgui_console.cpp Normal file
View File

@ -0,0 +1,656 @@
// Copyright (c) 2020 - present, Roland Munguia
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//#pragma once
#include <string>
#include "imgui_console.h"
#include "imgui_internal.h"
#include <cstring>
// The following three functions (InputTextCallback_UserData, InputTextCallback, InputText) are obtained from misc/cpp/imgui_stdlib.h
// Which are licensed under MIT License (https://github.com/ocornut/imgui/blob/master/LICENSE.txt)
namespace ImGui {
struct InputTextCallback_UserData
{
std::string* Str;
ImGuiInputTextCallback ChainCallback;
void* ChainCallbackUserData;
};
static int InputTextCallback(ImGuiInputTextCallbackData* data)
{
auto* user_data = (InputTextCallback_UserData*)data->UserData;
if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
{
// Resize string callback
// If for some reason we refuse the new length (BufTextLen) and/or capacity (BufSize) we need to set them back to what we want.
std::string* str = user_data->Str;
IM_ASSERT(data->Buf == str->c_str());
str->resize(data->BufTextLen);
data->Buf = (char*)str->c_str();
} else if (user_data->ChainCallback)
{
// Forward to user callback, if any
data->UserData = user_data->ChainCallbackUserData;
return user_data->ChainCallback(data);
}
return 0;
}
bool InputText(const char* label, std::string* str, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
{
IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
flags |= ImGuiInputTextFlags_CallbackResize;
InputTextCallback_UserData cb_user_data;
cb_user_data.Str = str;
cb_user_data.ChainCallback = callback;
cb_user_data.ChainCallbackUserData = user_data;
return InputText(label, (char*)str->c_str(), str->capacity() + 1, flags, InputTextCallback, &cb_user_data);
}
}
ImGuiConsole::ImGuiConsole(std::string c_name, size_t inputBufferSize) : m_ConsoleName(std::move(c_name))
{
// Set input buffer size.
m_Buffer.resize(inputBufferSize);
m_HistoryIndex = std::numeric_limits<size_t>::min();
// Specify custom data to be store/loaded from imgui.ini
InitIniSettings();
// Set Console ImGui default settings
if (!m_LoadedFromIni)
{
DefaultSettings();
}
// Custom functions.
RegisterConsoleCommands();
}
void ImGuiConsole::Draw()
{
///////////////////////////////////////////////////////////////////////////
// Window and Settings ////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// Begin Console Window.
ImGui::PushStyleVar(ImGuiStyleVar_Alpha, m_WindowAlpha);
if (!ImGui::Begin(m_ConsoleName.data(), nullptr, ImGuiWindowFlags_MenuBar))
{
ImGui::PopStyleVar();
ImGui::End();
return;
}
ImGui::PopStyleVar();
///////////////
// Menu bar //
///////////////
MenuBar();
////////////////
// Filter bar //
////////////////
if (m_FilterBar)
{
FilterBar();
}
//////////////////
// Console Logs //
//////////////////
LogWindow();
// Section off.
ImGui::Separator();
///////////////////////////////////////////////////////////////////////////
// Command-line ///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
InputBar();
ImGui::End();
}
csys::System& ImGuiConsole::System()
{
return m_ConsoleSystem;
}
void ImGuiConsole::InitIniSettings()
{
ImGuiContext& g = *ImGui::GetCurrentContext();
// Load from .ini
if (g.Initialized && !g.SettingsLoaded && !m_LoadedFromIni)
{
ImGuiSettingsHandler console_ini_handler;
console_ini_handler.TypeName = "imgui-console";
console_ini_handler.TypeHash = ImHashStr("imgui-console");
console_ini_handler.ClearAllFn = SettingsHandler_ClearALl;
console_ini_handler.ApplyAllFn = SettingsHandler_ApplyAll;
console_ini_handler.ReadInitFn = SettingsHandler_ReadInit;
console_ini_handler.ReadOpenFn = SettingsHandler_ReadOpen;
console_ini_handler.ReadLineFn = SettingsHandler_ReadLine;
console_ini_handler.WriteAllFn = SettingsHandler_WriteAll;
console_ini_handler.UserData = this;
g.SettingsHandlers.push_back(console_ini_handler);
}
// else Ini settings already loaded!
}
void ImGuiConsole::DefaultSettings()
{
// Settings
m_AutoScroll = true;
m_ScrollToBottom = false;
m_ColoredOutput = true;
m_FilterBar = true;
m_TimeStamps = true;
// Style
m_WindowAlpha = 1;
m_ColorPalette[COL_COMMAND] = ImVec4(1.f, 1.f, 1.f, 1.f);
m_ColorPalette[COL_LOG] = ImVec4(1.f, 1.f, 1.f, 0.5f);
m_ColorPalette[COL_WARNING] = ImVec4(1.0f, 0.87f, 0.37f, 1.f);
m_ColorPalette[COL_ERROR] = ImVec4(1.f, 0.365f, 0.365f, 1.f);
m_ColorPalette[COL_INFO] = ImVec4(0.46f, 0.96f, 0.46f, 1.f);
m_ColorPalette[COL_TIMESTAMP] = ImVec4(1.f, 1.f, 1.f, 0.5f);
}
void ImGuiConsole::RegisterConsoleCommands()
{
m_ConsoleSystem.RegisterCommand("clear", "Clear console log", [this]()
{
m_ConsoleSystem.Items().clear();
});
m_ConsoleSystem.RegisterCommand("filter", "Set screen filter", [this](const csys::String& filter)
{
// Reset filter buffer.
std::memset(m_TextFilter.InputBuf, '\0', 256);
// Copy filter input buffer from client.
std::copy(filter.m_String.c_str(), filter.m_String.c_str() + std::min(static_cast<int>(filter.m_String.length()), 255), m_TextFilter.InputBuf);
// Build text filter.
m_TextFilter.Build();
}, csys::Arg<csys::String>("filter_str"));
m_ConsoleSystem.RegisterCommand("run", "Run given script", [this](const csys::String& filter)
{
// Logs command.
m_ConsoleSystem.RunScript(filter.m_String);
}, csys::Arg<csys::String>("script_name"));
}
void ImGuiConsole::FilterBar()
{
m_TextFilter.Draw("Filter", ImGui::GetWindowWidth() * 0.25f);
ImGui::Separator();
}
void ImGuiConsole::LogWindow()
{
const float footerHeightToReserve = ImGui::GetStyle().ItemSpacing.y + ImGui::GetFrameHeightWithSpacing();
if (ImGui::BeginChild("ScrollRegion##", ImVec2(0, -footerHeightToReserve), false, 0))
{
// Display colored command output.
static const float timestamp_width = ImGui::CalcTextSize("00:00:00:0000").x; // Timestamp.
int count = 0; // Item count.
// Wrap items.
ImGui::PushTextWrapPos();
// Display items.
for (const auto& item : m_ConsoleSystem.Items())
{
// Exit if word is filtered.
if (!m_TextFilter.PassFilter(item.Get().c_str()))
continue;
// Spacing between commands.
if (item.m_Type == csys::eCOMMAND)
{
if (m_TimeStamps) ImGui::PushTextWrapPos(ImGui::GetColumnWidth() - timestamp_width); // Wrap before timestamps start.
if (count++ != 0) ImGui::Dummy(ImVec2(-1, ImGui::GetFontSize())); // No space for the first command.
}
// Items.
if (m_ColoredOutput)
{
ImGui::PushStyleColor(ImGuiCol_Text, m_ColorPalette[item.m_Type]);
ImGui::TextUnformatted(item.Get().data());
ImGui::PopStyleColor();
} else
{
ImGui::TextUnformatted(item.Get().data());
}
// Time stamp.
if (item.m_Type == csys::eCOMMAND && m_TimeStamps)
{
// No wrap for timestamps
ImGui::PopTextWrapPos();
// Right align.
ImGui::SameLine(ImGui::GetColumnWidth(-1) - timestamp_width);
// Draw time stamp.
ImGui::PushStyleColor(ImGuiCol_Text, m_ColorPalette[COL_TIMESTAMP]);
ImGui::Text("%02d:%02d:%02d:%04d", ((item.m_TimeStamp / 1000 / 3600) % 24), ((item.m_TimeStamp / 1000 / 60) % 60),
((item.m_TimeStamp / 1000) % 60), item.m_TimeStamp % 1000);
ImGui::PopStyleColor();
}
}
// Stop wrapping since we are done displaying console items.
ImGui::PopTextWrapPos();
// Auto-scroll logs.
if ((m_ScrollToBottom && (ImGui::GetScrollY() >= ImGui::GetScrollMaxY() || m_AutoScroll)))
ImGui::SetScrollHereY(1.0f);
m_ScrollToBottom = false;
// Loop through command string vector.
ImGui::EndChild();
}
}
void ImGuiConsole::InputBar()
{
// Variables.
ImGuiInputTextFlags inputTextFlags =
ImGuiInputTextFlags_CallbackHistory | ImGuiInputTextFlags_CallbackCharFilter | ImGuiInputTextFlags_CallbackCompletion |
ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackAlways;
// Only reclaim after enter key is pressed!
bool reclaimFocus = false;
// Input widget. (Width an always fixed width)
ImGui::PushItemWidth(-ImGui::GetStyle().ItemSpacing.x * 7);
if (ImGui::InputText("Input", &m_Buffer, inputTextFlags, InputCallback, this))
{
// Validate.
if (!m_Buffer.empty())
{
// Run command line input.
m_ConsoleSystem.RunCommand(m_Buffer);
// Scroll to bottom after its ran.
m_ScrollToBottom = true;
}
// Keep focus.
reclaimFocus = true;
// Clear command line.
m_Buffer.clear();
}
ImGui::PopItemWidth();
// Reset suggestions when client provides char input.
if (ImGui::IsItemEdited() && !m_WasPrevFrameTabCompletion)
{
m_CmdSuggestions.clear();
}
m_WasPrevFrameTabCompletion = false;
// Auto-focus on window apparition
ImGui::SetItemDefaultFocus();
if (reclaimFocus)
ImGui::SetKeyboardFocusHere(-1); // Focus on command line after clearing.
}
void ImGuiConsole::MenuBar()
{
if (ImGui::BeginMenuBar())
{
// Settings menu.
if (ImGui::BeginMenu("Settings"))
{
// Colored output
ImGui::Checkbox("Colored Output", &m_ColoredOutput);
ImGui::SameLine();
HelpMaker("Enable colored command output");
// Auto Scroll
ImGui::Checkbox("Auto Scroll", &m_AutoScroll);
ImGui::SameLine();
HelpMaker("Automatically scroll to bottom of console log");
// Filter bar
ImGui::Checkbox("Filter Bar", &m_FilterBar);
ImGui::SameLine();
HelpMaker("Enable console filter bar");
// Time stamp
ImGui::Checkbox("Time Stamps", &m_TimeStamps);
ImGui::SameLine();
HelpMaker("Display command execution timestamps");
// Reset to default settings
if (ImGui::Button("Reset settings", ImVec2(ImGui::GetColumnWidth(), 0)))
ImGui::OpenPopup("Reset Settings?");
// Confirmation
if (ImGui::BeginPopupModal("Reset Settings?", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
{
ImGui::Text("All settings will be reset to default.\nThis operation cannot be undone!\n\n");
ImGui::Separator();
if (ImGui::Button("Reset", ImVec2(120, 0)))
{
DefaultSettings();
ImGui::CloseCurrentPopup();
}
ImGui::SetItemDefaultFocus();
ImGui::SameLine();
if (ImGui::Button("Cancel", ImVec2(120, 0)))
{
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
ImGui::EndMenu();
}
// View settings.
if (ImGui::BeginMenu("Appearance"))
{
// Logging Colors
ImGuiColorEditFlags flags =
ImGuiColorEditFlags_Float | ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_AlphaBar;
ImGui::TextUnformatted("Color Palette");
ImGui::Indent();
ImGui::ColorEdit4("Command##", (float*)&m_ColorPalette[COL_COMMAND], flags);
ImGui::ColorEdit4("Log##", (float*)&m_ColorPalette[COL_LOG], flags);
ImGui::ColorEdit4("Warning##", (float*)&m_ColorPalette[COL_WARNING], flags);
ImGui::ColorEdit4("Error##", (float*)&m_ColorPalette[COL_ERROR], flags);
ImGui::ColorEdit4("Info##", (float*)&m_ColorPalette[COL_INFO], flags);
ImGui::ColorEdit4("Time Stamp##", (float*)&m_ColorPalette[COL_TIMESTAMP], flags);
ImGui::Unindent();
ImGui::Separator();
// Window transparency.
ImGui::TextUnformatted("Background");
ImGui::SliderFloat("Transparency##", &m_WindowAlpha, 0.1f, 1.f);
ImGui::EndMenu();
}
// All scripts.
if (ImGui::BeginMenu("Scripts"))
{
// Show registered scripts.
for (const auto& scr_pair : m_ConsoleSystem.Scripts())
{
if (ImGui::MenuItem(scr_pair.first.c_str()))
{
m_ConsoleSystem.RunScript(scr_pair.first);
m_ScrollToBottom = true;
}
}
// Reload scripts.
ImGui::Separator();
if (ImGui::Button("Reload Scripts", ImVec2(ImGui::GetColumnWidth(), 0)))
{
for (const auto& scr_pair : m_ConsoleSystem.Scripts())
{
scr_pair.second->Reload();
}
}
ImGui::EndMenu();
}
ImGui::EndMenuBar();
}
}
// From imgui_demo.cpp
void ImGuiConsole::HelpMaker(const char* desc)
{
ImGui::TextDisabled("(?)");
if (ImGui::IsItemHovered())
{
ImGui::BeginTooltip();
ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
ImGui::TextUnformatted(desc);
ImGui::PopTextWrapPos();
ImGui::EndTooltip();
}
}
int ImGuiConsole::InputCallback(ImGuiInputTextCallbackData* data)
{
// Exit if no buffer.
if (data->BufTextLen == 0 && (data->EventFlag != ImGuiInputTextFlags_CallbackHistory))
return 0;
// Get input string and console.
std::string input_str = data->Buf;
std::string trim_str;
auto console = static_cast<ImGuiConsole*>(data->UserData);
// Optimize by only using positions.
// Trim start and end spaces.
size_t startPos = console->m_Buffer.find_first_not_of(' ');
size_t endPos = console->m_Buffer.find_last_not_of(' ');
// Get trimmed string.
if (startPos != std::string::npos && endPos != std::string::npos)
trim_str = console->m_Buffer.substr(startPos, endPos + 1);
else
trim_str = console->m_Buffer;
switch (data->EventFlag)
{
case ImGuiInputTextFlags_CallbackCompletion:
{
// Find last word.
size_t startSubtrPos = trim_str.find_last_of(' ');
csys::AutoComplete* console_autocomplete;
// Command line is an entire word/string (No whitespace)
// Determine which autocomplete tree to use.
if (startSubtrPos == std::string::npos)
{
startSubtrPos = 0;
console_autocomplete = &console->m_ConsoleSystem.CmdAutocomplete();
} else
{
startSubtrPos += 1;
console_autocomplete = &console->m_ConsoleSystem.VarAutocomplete();
}
// Validate str
if (!trim_str.empty())
{
// Display suggestions on console.
if (!console->m_CmdSuggestions.empty())
{
console->m_ConsoleSystem.Log(csys::eCOMMAND) << "Suggestions: " << csys::endl;
for (const auto& suggestion : console->m_CmdSuggestions)
console->m_ConsoleSystem.Log(csys::eLOG) << suggestion << csys::endl;
console->m_CmdSuggestions.clear();
}
// Get partial completion and suggestions.
std::string partial = console_autocomplete->Suggestions(trim_str.substr(startSubtrPos, endPos + 1), console->m_CmdSuggestions);
// Autocomplete only when one work is available.
if (!console->m_CmdSuggestions.empty() && console->m_CmdSuggestions.size() == 1)
{
data->DeleteChars(static_cast<int>(startSubtrPos), static_cast<int>(data->BufTextLen - startSubtrPos));
data->InsertChars(static_cast<int>(startSubtrPos), console->m_CmdSuggestions[0].data());
console->m_CmdSuggestions.clear();
} else
{
// Partially complete word.
if (!partial.empty())
{
data->DeleteChars(static_cast<int>(startSubtrPos), static_cast<int>(data->BufTextLen - startSubtrPos));
data->InsertChars(static_cast<int>(startSubtrPos), partial.data());
}
}
}
// We have performed the completion event.
console->m_WasPrevFrameTabCompletion = true;
}
break;
case ImGuiInputTextFlags_CallbackHistory:
{
// Clear buffer.
data->DeleteChars(0, data->BufTextLen);
// Init history index
if (console->m_HistoryIndex == std::numeric_limits<size_t>::min())
console->m_HistoryIndex = console->m_ConsoleSystem.History().GetNewIndex();
// Traverse history.
if (data->EventKey == ImGuiKey_UpArrow)
{
if (console->m_HistoryIndex) --(console->m_HistoryIndex);
} else
{
if (console->m_HistoryIndex < console->m_ConsoleSystem.History().Size()) ++(console->m_HistoryIndex);
}
// Get history.
std::string prevCommand = console->m_ConsoleSystem.History()[console->m_HistoryIndex];
// Insert commands.
data->InsertChars(data->CursorPos, prevCommand.data());
}
break;
case ImGuiInputTextFlags_CallbackCharFilter:
case ImGuiInputTextFlags_CallbackAlways:
default:
break;
}
return 0;
}
void ImGuiConsole::SettingsHandler_ClearALl(ImGuiContext* ctx, ImGuiSettingsHandler* handler)
{
}
void ImGuiConsole::SettingsHandler_ReadInit(ImGuiContext* ctx, ImGuiSettingsHandler* handler)
{
}
void* ImGuiConsole::SettingsHandler_ReadOpen(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name)
{
if (!handler->UserData)
return nullptr;
auto console = static_cast<ImGuiConsole*>(handler->UserData);
if (strcmp(name, console->m_ConsoleName.c_str()) != 0)
return nullptr;
return (void*)1;
}
void ImGuiConsole::SettingsHandler_ReadLine(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line)
{
if (!handler->UserData)
return;
// Get console.
auto console = static_cast<ImGuiConsole*>(handler->UserData);
// Ensure console doesn't reset variables.
console->m_LoadedFromIni = true;
// Disable warning regarding sscanf when using MVSC
#pragma warning( push )
#pragma warning( disable:4996 )
#define INI_CONSOLE_LOAD_COLOR(type) (std::sscanf(line, #type"=%i,%i,%i,%i", &r, &g, &b, &a) == 4) { console->m_ColorPalette[type] = ImColor(r, g, b, a); }
#define INI_CONSOLE_LOAD_FLOAT(var) (std::sscanf(line, #var"=%f", &f) == 1) { console->var = f; }
#define INI_CONSOLE_LOAD_BOOL(var) (std::sscanf(line, #var"=%i", &b) == 1) {console->var = b == 1;}
float f;
int r, g, b, a;
// Window style/visuals
if INI_CONSOLE_LOAD_COLOR(COL_COMMAND)
else if INI_CONSOLE_LOAD_COLOR(COL_LOG)
else if INI_CONSOLE_LOAD_COLOR(COL_WARNING)
else if INI_CONSOLE_LOAD_COLOR(COL_ERROR)
else if INI_CONSOLE_LOAD_COLOR(COL_INFO)
else if INI_CONSOLE_LOAD_COLOR(COL_TIMESTAMP)
else if INI_CONSOLE_LOAD_FLOAT(m_WindowAlpha)
// Window settings
else if INI_CONSOLE_LOAD_BOOL(m_AutoScroll)
else if INI_CONSOLE_LOAD_BOOL(m_ScrollToBottom)
else if INI_CONSOLE_LOAD_BOOL(m_ColoredOutput)
else if INI_CONSOLE_LOAD_BOOL(m_FilterBar)
else if INI_CONSOLE_LOAD_BOOL(m_TimeStamps)
#pragma warning( pop )
}
void ImGuiConsole::SettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler)
{
if (!handler->UserData)
return;
}
void ImGuiConsole::SettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf)
{
if (!handler->UserData)
return;
// Get console.
auto console = static_cast<ImGuiConsole*>(handler->UserData);
#define INI_CONSOLE_SAVE_COLOR(type) buf->appendf(#type"=%i,%i,%i,%i\n", (int)(console->m_ColorPalette[type].x * 255),\
(int)(console->m_ColorPalette[type].y * 255),\
(int)(console->m_ColorPalette[type].z * 255),\
(int)(console->m_ColorPalette[type].w * 255))
#define INI_CONSOLE_SAVE_FLOAT(var) buf->appendf(#var"=%.3f\n", console->var)
#define INI_CONSOLE_SAVE_BOOL(var) buf->appendf(#var"=%i\n", console->var)
// Set header for CONSOLE Console
buf->appendf("[%s][%s]\n", handler->TypeName, console->m_ConsoleName.data());
// Window settings.
INI_CONSOLE_SAVE_BOOL(m_AutoScroll);
INI_CONSOLE_SAVE_BOOL(m_ScrollToBottom);
INI_CONSOLE_SAVE_BOOL(m_ColoredOutput);
INI_CONSOLE_SAVE_BOOL(m_FilterBar);
INI_CONSOLE_SAVE_BOOL(m_TimeStamps);
// Window style/visuals
INI_CONSOLE_SAVE_FLOAT(m_WindowAlpha);
INI_CONSOLE_SAVE_COLOR(COL_COMMAND);
INI_CONSOLE_SAVE_COLOR(COL_LOG);
INI_CONSOLE_SAVE_COLOR(COL_WARNING);
INI_CONSOLE_SAVE_COLOR(COL_ERROR);
INI_CONSOLE_SAVE_COLOR(COL_INFO);
INI_CONSOLE_SAVE_COLOR(COL_TIMESTAMP);
// End saving.
buf->append("\n");
}

112
include/imgui/imgui_console.h Normal file
View File

@ -0,0 +1,112 @@
// Copyright (c) 2020 - present, Roland Munguia
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
#ifndef IMGUI_CONSOLE_H
#define IMGUI_CONSOLE_H
#pragma once
#include "csys/system.h"
#include "imgui.h"
#include <array>
struct ImGuiSettingsHandler;
class ImGuiConsole
{
public:
/*!
* \brief Construct an imgui console
* \param c_name Name of the console
* \param inputBufferSize Maximum input buffer size
*/
explicit ImGuiConsole(std::string c_name = "imgui-console", size_t inputBufferSize = 256);
/*!
* \brief Render the Dear ImGui Console
*/
void Draw();
/*!
* \brief Console system which handles the console functionality (Logging, Commands, History, Scripts, etc).
* \return System Obj
*/
csys::System& System();
protected:
// Console ////////////////////////////////////////////////////////////////
csys::System m_ConsoleSystem; //!< Main console system.
size_t m_HistoryIndex; //!< Command history index.
// Dear ImGui ////////////////////////////////////////////////////////////
// Main
std::string m_Buffer; //!< Input buffer.
std::string m_ConsoleName; //!< Console name string buffer.
ImGuiTextFilter m_TextFilter; //!< Logging filer.
bool m_AutoScroll; //!< Auto scroll flag.
bool m_ColoredOutput; //!< Colored output flag.
bool m_ScrollToBottom; //!< Scroll to bottom after is command is ran
bool m_FilterBar; //!< Filter bar flag.
bool m_TimeStamps; //!< Display time stamps flag
void InitIniSettings(); //!< Initialize Ini Settings handler
void DefaultSettings(); //!< Restore console default settings
void RegisterConsoleCommands(); //!< Register built-in console commands
void MenuBar(); //!< Console menu bar
void FilterBar(); //!< Console filter bar
void InputBar(); //!< Console input bar
void LogWindow(); //!< Console log
static void HelpMaker(const char* desc);
// Window appearance.
float m_WindowAlpha; //!< Window transparency
enum COLOR_PALETTE
{
// This four have to match the csys item type enum.
COL_COMMAND = 0, //!< Color for command logs
COL_LOG, //!< Color for in-command logs
COL_WARNING, //!< Color for warnings logs
COL_ERROR, //!< Color for error logs
COL_INFO, //!< Color for info logs
COL_TIMESTAMP, //!< Color for timestamps
COL_COUNT //!< For bookkeeping purposes
};
std::array<ImVec4, COL_COUNT> m_ColorPalette; //!< Container for all available colors
// ImGui Console Window.
static int InputCallback(ImGuiInputTextCallbackData* data); //!< Console input callback
bool m_WasPrevFrameTabCompletion = false; //!< Flag to determine if previous input was a tab completion
std::vector<std::string> m_CmdSuggestions; //!< Holds command suggestions from partial completion
// Save data inside .ini
bool m_LoadedFromIni = false;
static void SettingsHandler_ClearALl(ImGuiContext* ctx, ImGuiSettingsHandler* handler);
static void SettingsHandler_ReadInit(ImGuiContext* ctx, ImGuiSettingsHandler* handler);
static void* SettingsHandler_ReadOpen(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name);
static void SettingsHandler_ReadLine(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line);
static void SettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler);
static void SettingsHandler_WriteAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* buf);
///////////////////////////////////////////////////////////////////////////
};
#endif //IMGUI_CONSOLE_H

31
pléascach.cpp
View File

@ -21,7 +21,7 @@ int main(int argc, char* argv[]) {
auto in = win.getInput();
Renderer ren(win);
while (!in->shouldClose()) {
while (!in->shouldClose() && !ren.should_close) {
Timer frame_timer;
in->poll();
in->handleMovementKeys(ren);
@ -56,11 +56,14 @@ int main(int argc, char* argv[]) {
case InputEvent::Tag::eBUTTON:
break;
case InputEvent::Tag::eKEY:
if (event.key.key == GLFW_KEY_Q) {
return 0;
} else if (event.key.key == GLFW_KEY_ESCAPE && event.key.state == GLFW_PRESS) {
ren.capture_mouse = !ren.capture_mouse;
in->setCursor(!ren.capture_mouse);
if (event.key.key == GLFW_KEY_ESCAPE && event.key.state == GLFW_PRESS) {
ren.in_menu = !ren.in_menu;
in->setCursor(ren.in_menu);
} else if (event.key.key == GLFW_KEY_Q && event.key.state == GLFW_PRESS) {
if (!ren.in_menu) {
ren.should_close = true;
goto quit;
}
} else if (event.key.key == GLFW_KEY_R && event.key.state == GLFW_PRESS) {
ren.time = 0;
} else if (event.key.key == GLFW_KEY_C && event.key.state == GLFW_PRESS) {
@ -78,15 +81,19 @@ int main(int argc, char* argv[]) {
ren.draw();
ren.present();
const auto t = frame_timer.read();
ren.ui->info.fps = 1000.0f / t;
ren.time += t / 1000.0 * ren.speed * static_cast<float>(ren.running);
ren.frametime = frame_timer.read();
ren.fps = 1000.0f / ren.frametime;
/*while (frame_timer.read() < 16.60)
;*/
while (frame_timer.read() < 1000.0 / ren.max_fps)
;
ren.frametime = frame_timer.read();
}
} catch (const std::string& e) {
std::cerr << "Exception: " << e << std::endl;
}
}
quit:
Log::info("Quitting\n");
}