lachrymal/Keishiki
2
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

success!!

Browse source
This commit is contained in:
lachrymaLF 2024-05-29 12:32:37 -04:00
parent 98411895d3
commit 8232b4d3f3
7 changed files with 331 additions and 195 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
Keishiki/Keishiki.cpp
View file

@ -99,24 +99,21 @@ namespace K {
state.plugboard.comp_in = PlugboardGraph::Node{ state.plugboard.comp_in = PlugboardGraph::Node{
"Composition In", "Composition In",
{}, {},
{}, {{"Frame", PlugboardGraph::T_Int}, {"Time (s)", PlugboardGraph::T_Float}, {"App Ticks", PlugboardGraph::T_Float}},
{"Frame", "App Ticks"},
{PlugboardGraph::T_Int, PlugboardGraph::T_Float},
{ {
[](const CompState& s, const Vector<PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>& v) { return PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type{static_cast<i32>(s.current_frame)}; }, [](const CompState& s, const Vector<PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>& v) { return PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type{static_cast<i32>(s.current_frame)}; },
[](const CompState& s, const Vector<PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>& v) { return PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type{static_cast<f32>(s.current_frame) / s.fps}; },
[](const CompState& s, const Vector<PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>& v) { return PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type{ static_cast<f32>(SDL_GetTicks()) / 18.0f }; } // kill me [](const CompState& s, const Vector<PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>& v) { return PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type{ static_cast<f32>(SDL_GetTicks()) / 18.0f }; } // kill me
} }
}; };
state.plugboard.comp_out = { state.plugboard.comp_out = PlugboardGraph::Node{
"Composition Out", "Composition Out",
{}, {},
{}, {},
{},
{},
{} {}
}; };
state.plugboard.in_instance = PlugboardGraph::MakeInstance(state.plugboard.comp_in); state.plugboard.in_instance = PlugboardGraph::MakeInstance(state.plugboard.comp_in);
state.plugboard.out_instance = PlugboardGraph::MakeInstance(state.plugboard.comp_out); state.plugboard.out_instance = PlugboardGraph::MakeInstance(state.plugboard.comp_in);
K::UI::SetupViewport(state); K::UI::SetupViewport(state);
return true; return true;
@ -130,13 +127,13 @@ namespace K {
const bgfx::Stats *stat = bgfx::getStats(); const bgfx::Stats *stat = bgfx::getStats();
const bgfx::Caps *caps = bgfx::getCaps(); const bgfx::Caps *caps = bgfx::getCaps();
bgfx::dbgTextClear(); bgfx::dbgTextClear();
bgfx::dbgTextPrintf(0, window_height/16 - 2, 0xf8, bgfx::dbgTextPrintf(0, window_height/16 - 4, 0xf8,
" lachrymal.net :: %s Renderer :: Max Views %u :: Max FBs %u :: Max Texture Samplers %u :: Blitting %s :: %u FPS", " lachrymal.net :: %s Renderer :: Max Views %u :: Max FBs %u :: Max Texture Samplers %u :: Blitting %s :: %u FPS",
caps->supported & BGFX_CAPS_RENDERER_MULTITHREADED ? "Multithreaded" : "Singlethreaded", caps->supported & BGFX_CAPS_RENDERER_MULTITHREADED ? "Multithreaded" : "Singlethreaded",
caps->limits.maxViews, caps->limits.maxFrameBuffers, caps->limits.maxViews, caps->limits.maxFrameBuffers,
caps->limits.maxTextureSamplers, caps->supported & BGFX_CAPS_TEXTURE_BLIT ? "OK" : "NO", caps->limits.maxTextureSamplers, caps->supported & BGFX_CAPS_TEXTURE_BLIT ? "OK" : "NO",
stat->cpuTimerFreq / stat->cpuTimeFrame); stat->cpuTimerFreq / stat->cpuTimeFrame);
bgfx::dbgTextPrintf(0, window_height/16 - 1, 0xf8, bgfx::dbgTextPrintf(0, window_height/16 - 3, 0xf8,
" Project Keishiki :: %s :: Build %s %s :: SDL %i.%i.%i :: bgfx 1.%i :: Dear ImGui %s :: %s", " Project Keishiki :: %s :: Build %s %s :: SDL %i.%i.%i :: bgfx 1.%i :: Dear ImGui %s :: %s",
BX_COMPILER_NAME, __DATE__, __TIME__, SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL, BX_COMPILER_NAME, __DATE__, __TIME__, SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL,
BGFX_API_VERSION, ImGui::GetVersion(), bgfx::getRendererName(bgfx::getRendererType())); BGFX_API_VERSION, ImGui::GetVersion(), bgfx::getRendererName(bgfx::getRendererType()));

390
Keishiki/UI.cpp
View file

@ -19,7 +19,9 @@ namespace {
draw_shader = true, draw_shader = true,
draw_comp = true, draw_comp = true,
draw_interpolation = true, draw_interpolation = true,
draw_properties = true; draw_properties = true,
draw_assets = true,
draw_color = true;
const f32 row_height = 20.0f; const f32 row_height = 20.0f;
@ -117,18 +119,18 @@ namespace K::UI {
} }
void PlugboardNodeDrawSockets(PlugboardGraph::NodeInstance& n, ImGuiStyle& style, void PlugboardNodeDrawSockets(PlugboardGraph::NodeInstance& n, ImGuiStyle& style,
bool& dragging_on_socket, ImVec2& source, std::unordered_map<PlugboardGraph::ConnectInfo, PlugboardGraph::LinksFromSource, PlugboardGraph::_ConnectInfoHasher>& link_pos, bool& dragging_on_socket, ImVec2& source, std::unordered_map<PlugboardGraph::ConnectInfo, PlugboardGraph::LinksFromSource, PlugboardGraph::ConnectInfoHasher>& link_pos,
bool dummy = true) { bool dummy = true) {
i32 row = 1; i32 row = 1;
for (u32 out = 0; out < n.node->out_names.size(); out++, row++) { for (u32 out = 0; out < n.node->out.size(); out++, row++) {
ImGui::PushID(row); ImGui::PushID(row);
ImGui::TableNextRow(ImGuiTableRowFlags_None, row_height); ImGui::TableNextRow(ImGuiTableRowFlags_None, row_height);
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::TableNextColumn(); ImGui::TableNextColumn();
if (dummy) if (dummy)
ImGui::Dummy({100.0f - ImGui::CalcTextSize(n.node->out_names[out].c_str()).x - style.ItemSpacing.x, 0.0f}); ImGui::Dummy({100.0f - ImGui::CalcTextSize(n.node->out[out].name.c_str()).x - style.ItemSpacing.x, 0.0f});
ImGui::SameLine(); ImGui::SameLine();
ImGui::Text("%s", n.node->out_names[out].c_str()); ImGui::TextUnformatted(n.node->out[out].name.c_str());
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::RadioButton("##Out", false); ImGui::RadioButton("##Out", false);
if (ImGui::IsItemActive()) { if (ImGui::IsItemActive()) {
@ -192,7 +194,7 @@ namespace K::UI {
}, n.inputs_fed[in]); }, n.inputs_fed[in]);
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::Text("%s", n.node->in_names[in].c_str()); ImGui::TextUnformatted(n.node->in[in].name.c_str());
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::PopID(); ImGui::PopID();
@ -200,7 +202,7 @@ namespace K::UI {
} }
void PlugboardDrawNode(PlugboardGraph::NodeInstance& n, ImVec2& view_pos, i32 id, ImGuiIO& io, ImGuiStyle& style, void PlugboardDrawNode(PlugboardGraph::NodeInstance& n, ImVec2& view_pos, i32 id, ImGuiIO& io, ImGuiStyle& style,
bool& dragging_on_socket, ImVec2& source, std::unordered_map<PlugboardGraph::ConnectInfo, PlugboardGraph::LinksFromSource, PlugboardGraph::_ConnectInfoHasher>& link_pos) { bool& dragging_on_socket, ImVec2& source, std::unordered_map<PlugboardGraph::ConnectInfo, PlugboardGraph::LinksFromSource, PlugboardGraph::ConnectInfoHasher>& link_pos) {
ImGui::SetCursorPos(view_pos + n.pos); ImGui::SetCursorPos(view_pos + n.pos);
ImGui::PushID(id); ImGui::PushID(id);
ImGui::PushStyleColor(ImGuiCol_ChildBg, 0xAA080813); ImGui::PushStyleColor(ImGuiCol_ChildBg, 0xAA080813);
@ -267,7 +269,7 @@ namespace K::UI {
inline f32 TimelineFrameToScreenView(f32 view_left, f32 view_amt, f32 view_width, u64 frame, u64 frame_max) { inline f32 TimelineFrameToScreenView(f32 view_left, f32 view_amt, f32 view_width, u64 frame, u64 frame_max) {
return (static_cast<f32>(frame) / static_cast<f32>(frame_max + 1) - view_left) / view_amt * view_width; return (static_cast<f32>(frame) / static_cast<f32>(frame_max + 1) - view_left) / view_amt * view_width;
}; }
inline u64 TimelineScreenViewToFrame(f32 view_left, f32 view_amt, f32 view_width, f32 view, u64 frame_max) { inline u64 TimelineScreenViewToFrame(f32 view_left, f32 view_amt, f32 view_width, f32 view, u64 frame_max) {
return std::clamp(static_cast<u64>(std::round((view / view_width * view_amt + view_left) * static_cast<f32>(frame_max + 1))), 0UL, frame_max); return std::clamp(static_cast<u64>(std::round((view / view_width * view_amt + view_left) * static_cast<f32>(frame_max + 1))), 0UL, frame_max);
@ -283,7 +285,7 @@ namespace K::UI {
s.plugboard.nodes.push_back(PlugboardGraph::MakeInstance(PlugboardNodes::Sine)); s.plugboard.nodes.push_back(PlugboardGraph::MakeInstance(PlugboardNodes::Sine));
ImGui::SameLine(); ImGui::SameLine();
ImGui::Text("%u / %u Frames", s.current_frame, s.frame_max); ImGui::Text("%lu / %lu Frames", s.current_frame, s.frame_max);
ImGui::SameLine(); ImGui::SameLine();
const bool no_selection = s.selected.empty(); const bool no_selection = s.selected.empty();
@ -325,6 +327,11 @@ namespace K::UI {
"\tgl_FragColor = vec4(tx.rgb, tx.a * opacity);\n" "\tgl_FragColor = vec4(tx.rgb, tx.a * opacity);\n"
"}\n"; "}\n";
l.track.compile(); l.track.compile();
l.track.expose_uniform(s, "aspect_ratio");
l.track.expose_uniform(s, "opacity");
l.track.expose_uniform(s, "rot");
l.track.expose_uniform(s, "scale");
l.track.expose_uniform(s, "translate");
s.layers.push_back(std::move(l)); s.layers.push_back(std::move(l));
} }
ImGui::SameLine(); ImGui::SameLine();
@ -361,17 +368,18 @@ namespace K::UI {
ImVec2 avail = ImGui::GetContentRegionAvail(); ImVec2 avail = ImGui::GetContentRegionAvail();
static f32 view_scale = 1.0f; static f32 view_scale = 1.0f;
static ImVec2 view_pos{}, old_view_pos{}; static ImVec2 view_pos{}, old_view_pos{}, nodes_begin{};
bool dragging_on_socket{}; bool dragging_on_socket{};
static ImVec2 drag_source{}; ImVec2 drag_source{};
ImGui::PushStyleColor(ImGuiCol_ChildBg, 0xFF100500); ImGui::PushStyleColor(ImGuiCol_ChildBg, 0xFF100500);
if (ImGui::BeginChild("Nodes", {avail.x * .4f, avail.y}, 0, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar)) { if (ImGui::BeginChild("Nodes", {avail.x * .4f, avail.y}, ImGuiChildFlags_ResizeX, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoScrollbar)) {
ImGui::PopStyleColor(); ImGui::PopStyleColor();
ImGuiWindow *window = ImGui::GetCurrentWindow(); ImGuiWindow *window = ImGui::GetCurrentWindow();
ImVec2 window_pos = ImGui::GetWindowPos(); ImVec2 window_pos = ImGui::GetWindowPos();
nodes_begin = window_pos;
if (ImGui::BeginDragDropTargetCustom(window->ContentRegionRect, window->ID)) { if (ImGui::BeginDragDropTargetCustom(window->ContentRegionRect, window->ID)) {
if (const ImGuiPayload *payload = ImGui::AcceptDragDropPayload("K_PLUG_IN_TO_OUT")) { if (const ImGuiPayload *payload = ImGui::AcceptDragDropPayload("K_PLUG_IN_TO_OUT")) {
@ -400,7 +408,7 @@ namespace K::UI {
u32 i = 0; u32 i = 0;
for (auto it = s.plugboard.nodes.begin(); it != s.plugboard.nodes.end(); it++, i++) for (auto it = s.plugboard.nodes.begin(); it != s.plugboard.nodes.end(); it++, i++)
PlugboardDrawNode(*it, view_pos, i, io, style, dragging_on_socket, drag_source, s.plugboard.links_pos); PlugboardDrawNode(*it, view_pos, static_cast<i32>(i), io, style, dragging_on_socket, drag_source, s.plugboard.links_pos);
ImGui::SetCursorPos({}); ImGui::SetCursorPos({});
ImGui::PushStyleColor(ImGuiCol_ChildBg, 0x33FFFFFF); ImGui::PushStyleColor(ImGuiCol_ChildBg, 0x33FFFFFF);
@ -415,48 +423,38 @@ namespace K::UI {
} }
ImGui::EndChild(); ImGui::EndChild();
static f32 right_offset = 0.0f; // check after drawing this frame, so next frame will be correct
ImGui::SetCursorPos({ImGui::GetContentRegionAvail().x - right_offset, 0.0f});
ImGui::PushStyleColor(ImGuiCol_ChildBg, 0x33FFFFFF);
ImGui::BeginChild(s.plugboard.comp_out.name.c_str(), {},
ImGuiChildFlags_AlwaysAutoResize | ImGuiChildFlags_AutoResizeX |
ImGuiChildFlags_AutoResizeY);
ImGui::PopStyleColor();
if (ImGui::BeginTable(s.plugboard.comp_out.name.c_str(), 3)) {
PlugboardNodeDrawSockets(s.plugboard.out_instance, style, dragging_on_socket, drag_source,
s.plugboard.links_pos, false);
ImGui::EndTable();
} }
ImGui::EndChild(); ImGui::EndChild();
right_offset += ImGui::GetItemRectMax().x - ImGui::GetWindowWidth(); ImGui::SameLine(0.0f, 0.5f);
for (auto &[_, link]: s.plugboard.links_pos) f32 table_left = ImGui::GetCursorScreenPos().x;
for (auto &sink: link.sinks) ImVec2 tl_init_pos, tl_end_begin;
window->DrawList->AddBezierCubic(link.source, {link.source.x + 60.0f, link.source.y}, f32 view_width,
{sink.x - 60.0f, sink.y}, sink, 0xFFFFFFFF, 2.0f); tl_width,
view_height,
if (dragging_on_socket) control_left,
window->DrawList->AddLine(ImGui::GetMousePos(), drag_source, 0xFFFFFFFF, 2.0f); control_right;
} static f32 view_left = 0.0f,
ImGui::EndChild(); view_left_old = view_left,
view_right = 1.0f,
ImGui::SameLine(0.0f, 0.0f); view_right_old = view_right;
f32 view_amt;
if (ImGui::BeginTable("Layers", 5, ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) { if (ImGui::BeginTable("Layers", 5, ImGuiTableFlags_BordersInner | ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
ImGui::TableSetupColumn("#", ImGuiTableColumnFlags_NoSort); ImGui::TableSetupColumn("#", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_IndentDisable);
ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoSort); ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoSort);
ImGui::TableSetupColumn("Blending", ImGuiTableColumnFlags_NoSort, 100.0f); ImGui::TableSetupColumn("Blending", ImGuiTableColumnFlags_NoSort, 100.0f);
ImGui::TableSetupColumn("##Enable", ImGuiTableColumnFlags_NoSort); ImGui::TableSetupColumn("##Enable", ImGuiTableColumnFlags_NoSort);
ImGui::TableSetupColumn("##Timeline", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthStretch); ImGui::TableSetupColumn("##Timeline",
ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthStretch);
ImGui::TableNextRow(ImGuiTableRowFlags_Headers, ImGui::TableGetHeaderRowHeight()); ImGui::TableNextRow(ImGuiTableRowFlags_Headers, row_height);
for (int column = 0; column < 4; column++) { for (int column = 0; column < 4; column++) {
ImGui::TableSetColumnIndex(column); ImGui::TableSetColumnIndex(column);
ImGui::TableHeader(ImGui::TableGetColumnName(column)); ImGui::TableHeader(ImGui::TableGetColumnName(column));
} }
// Timeline controls // Timeline controls
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0)); ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{}); ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{});
@ -464,26 +462,21 @@ namespace K::UI {
ImGui::TableSetColumnIndex(4); ImGui::TableSetColumnIndex(4);
const auto& io = ImGui::GetIO();
const auto& style = ImGui::GetStyle();
auto *window = ImGui::GetCurrentWindow(); auto *window = ImGui::GetCurrentWindow();
const f32 knob_width = 8.0f; const f32 knob_width = 8.0f;
ImVec2 tl_init_pos = ImGui::GetCursorScreenPos(); tl_init_pos = ImGui::GetCursorScreenPos();
f32 view_width = ImGui::GetColumnWidth(), view_width = ImGui::GetColumnWidth(),
tl_width = view_width - knob_width, tl_width = view_width - knob_width,
view_height = ImGui::TableGetHeaderRowHeight(), view_height = ImGui::TableGetHeaderRowHeight(),
control_left = tl_init_pos.x, control_left = tl_init_pos.x,
control_right = tl_init_pos.x + view_width; control_right = tl_init_pos.x + view_width;
static f32 view_left = 0.0f, view_amt = view_right - view_left;
view_left_old = view_left,
view_right = 1.0f,
view_right_old = view_right;
f32 view_amt = view_right - view_left;
f32 delta_x = (std::clamp(io.MousePos.x, control_left, control_right) - io.MouseClickedPos[0].x) / view_width; f32 delta_x =
(std::clamp(io.MousePos.x, control_left, control_right) - io.MouseClickedPos[0].x) / view_width;
ImGui::SetCursorScreenPos({tl_init_pos.x - knob_width / 2.0f + view_width * view_left, tl_init_pos.y}); ImGui::SetCursorScreenPos({tl_init_pos.x - knob_width / 2.0f + view_width * view_left, tl_init_pos.y});
ImGui::InvisibleButton("##TL_L", ImVec2{ knob_width, view_height }); ImGui::InvisibleButton("##TL_L", ImVec2{knob_width, view_height});
if (ImGui::IsItemHovered()) { if (ImGui::IsItemHovered()) {
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
} }
@ -495,7 +488,7 @@ namespace K::UI {
} }
ImGui::SameLine(); ImGui::SameLine();
ImGui::InvisibleButton("##TL_INTERVAL", ImVec2{ std::max(2.0f, tl_width * view_amt), view_height }); ImGui::InvisibleButton("##TL_INTERVAL", ImVec2{std::max(2.0f, tl_width * view_amt), view_height});
if (ImGui::IsItemHovered()) { if (ImGui::IsItemHovered()) {
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
} }
@ -508,7 +501,7 @@ namespace K::UI {
view_right = view_left + view_amt; view_right = view_left + view_amt;
} }
ImGui::SameLine(); ImGui::SameLine();
ImGui::InvisibleButton("##TL_R", ImVec2{ knob_width, view_height }); ImGui::InvisibleButton("##TL_R", ImVec2{knob_width, view_height});
if (ImGui::IsItemHovered()) { if (ImGui::IsItemHovered()) {
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW); ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeEW);
} }
@ -519,54 +512,58 @@ namespace K::UI {
view_right = std::clamp(view_right_old + delta_x, view_left, 1.0f); view_right = std::clamp(view_right_old + delta_x, view_left, 1.0f);
} }
window->DrawList->AddLine({tl_init_pos.x, tl_init_pos.y }, {tl_init_pos.x, tl_init_pos.y + view_height }, 0x22FFFFFF, 2.0f); window->DrawList->AddLine({tl_init_pos.x, tl_init_pos.y}, {tl_init_pos.x, tl_init_pos.y + view_height},
window->DrawList->AddLine({tl_init_pos.x + view_width, tl_init_pos.y }, {tl_init_pos.x + view_width, tl_init_pos.y + view_height }, 0x22FFFFFF, 2.0f); 0x22FFFFFF, 2.0f);
window->DrawList->AddLine({tl_init_pos.x + view_width * view_left, tl_init_pos.y }, {tl_init_pos.x + view_width * view_left, tl_init_pos.y + view_height }, 0xAAFFFFFF, 2.0f); window->DrawList->AddLine({tl_init_pos.x + view_width, tl_init_pos.y},
window->DrawList->AddLine({tl_init_pos.x + view_width * view_right, tl_init_pos.y }, {tl_init_pos.x + view_width * view_right, tl_init_pos.y + view_height }, 0xAAFFFFFF, 2.0f); {tl_init_pos.x + view_width, tl_init_pos.y + view_height}, 0x22FFFFFF, 2.0f);
window->DrawList->AddRectFilled({tl_init_pos.x + view_width * view_left, tl_init_pos.y + view_height * .2f }, {tl_init_pos.x + view_width * view_right, tl_init_pos.y + view_height * .8f }, 0x33FFFFFF, 2.0f); window->DrawList->AddLine({tl_init_pos.x + view_width * view_left, tl_init_pos.y},
{tl_init_pos.x + view_width * view_left, tl_init_pos.y + view_height},
0xAAFFFFFF, 2.0f);
window->DrawList->AddLine({tl_init_pos.x + view_width * view_right, tl_init_pos.y},
{tl_init_pos.x + view_width * view_right, tl_init_pos.y + view_height},
0xAAFFFFFF, 2.0f);
window->DrawList->AddRectFilled(
{tl_init_pos.x + view_width * view_left, tl_init_pos.y + view_height * .2f},
{tl_init_pos.x + view_width * view_right, tl_init_pos.y + view_height * .8f}, 0x33FFFFFF, 2.0f);
// Playhead // Playhead
window->DrawList->AddLine({tl_init_pos.x + view_width * static_cast<f32>(s.current_frame) / static_cast<f32>(s.frame_max + 1), tl_init_pos.y }, {tl_init_pos.x + view_width * static_cast<f32>(s.current_frame) / static_cast<f32>(s.frame_max + 1), tl_init_pos.y + view_height }, 0xFF3333FF, 2.0f); window->DrawList->AddLine({tl_init_pos.x + view_width * static_cast<f32>(s.current_frame) /
static_cast<f32>(s.frame_max + 1), tl_init_pos.y},
{tl_init_pos.x + view_width * static_cast<f32>(s.current_frame) /
static_cast<f32>(s.frame_max + 1),
tl_init_pos.y + view_height}, 0xFF3333FF, 2.0f);
// Block out selectable row -- jank
ImGui::SetCursorScreenPos(tl_init_pos - style.CellPadding); ImGui::SetCursorScreenPos(tl_init_pos - style.CellPadding);
ImGui::InvisibleButton("##TL_BG", ImVec2{ view_width + style.CellPadding.x * 2, view_height + style.CellPadding.y * 2}); ImGui::InvisibleButton("##TL_BG", ImVec2{ view_width + style.CellPadding.x * 2, row_height + style.CellPadding.y});
// Frame Grid // Frame Grid
static f32 frame_grid_min_width = 20.0f; static f32 frame_grid_min_width = 20.0f;
f32 fr_step = 1.0f / static_cast<f32>(s.frame_max + 1) * view_width / view_amt; f32 fr_step = 1.0f / static_cast<f32>(s.frame_max + 1) * view_width / view_amt;
fr_step = fr_step >= frame_grid_min_width ? fr_step : std::ceil(frame_grid_min_width / fr_step) * fr_step; fr_step =
for (f32 fr = TimelineFrameToScreenView(view_left, view_amt, view_width, std::ceil(view_left * static_cast<f32>(s.frame_max + 1)), s.frame_max) + tl_init_pos.x; fr_step >= frame_grid_min_width ? fr_step : std::ceil(frame_grid_min_width / fr_step) * fr_step;
for (f32 fr = TimelineFrameToScreenView(view_left, view_amt, view_width,
std::ceil(view_left * static_cast<f32>(s.frame_max + 1)),
s.frame_max) + tl_init_pos.x;
fr < tl_init_pos.x + view_width; fr += fr_step) fr < tl_init_pos.x + view_width; fr += fr_step)
window->DrawList->AddLine({ fr, tl_init_pos.y + row_height }, { fr, ImGui::GetContentRegionAvail().y + tl_init_pos.y }, 0x11FFFFFF, 1.0f); window->DrawList->AddLine({fr, tl_init_pos.y + row_height},
{fr, ImGui::GetWindowSize().y + tl_init_pos.y}, 0x11FFFFFF, 1.0f);
if (TimelineFrameInView(view_left, view_right, s.current_frame, s.frame_max)) { if (TimelineFrameInView(view_left, view_right, s.current_frame, s.frame_max)) {
f32 fr = TimelineFrameToScreenView(view_left, view_amt, view_width, s.current_frame, s.frame_max) + tl_init_pos.x; f32 fr = TimelineFrameToScreenView(view_left, view_amt, view_width, s.current_frame, s.frame_max) +
tl_init_pos.x;
window->DrawList->AddLine( window->DrawList->AddLine(
{fr, tl_init_pos.y + row_height}, {fr, tl_init_pos.y + row_height},
{fr, ImGui::GetContentRegionAvail().y + tl_init_pos.y}, 0x773333FF, 1.0f); {fr, ImGui::GetWindowSize().y + tl_init_pos.y}, 0x773333FF, 1.0f);
} }
ImGui::PopStyleVar(3); ImGui::PopStyleVar(3);
ImGui::SameLine(); ImGui::SameLine();
ImGui::TableHeader(""); ImGui::TableHeader("");
// f32 pos_view = static_cast<f32>(pos) / static_cast<f32>(s.frame_max + 1); // Main rows
// if (pos_view >= view_left && pos_view < view_right) { // ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, {0.0f, 0.0f});
// ImGui::Dummy({(pos_view - view_left) / view_amt * view_width, 0.0f}); i32 move_from = -1, move_to = -1;
// ImGui::SameLine(); bool after{};
// ImGui::Button("kf");
// if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) {
// pos_old = pos;
// }
// if (ImGui::IsItemActive()) {
// pos = std::clamp(i64(pos_old) +
// i64(std::round(delta_x * (view_amt * static_cast<f32>(s.frame_max + 1)))), 0L, i64(s.frame_max)
// );
// }
// }
i32 move_from = -1, move_to = -1; bool after{};
for (u32 i = 0; i < s.layers.size(); i++) { for (u32 i = 0; i < s.layers.size(); i++) {
const bool selected = s.selected.contains(i), disabled = s.disabled.contains(i); const bool selected = s.selected.contains(i), disabled = s.disabled.contains(i);
ImGui::PushID(static_cast<i32>(i)); ImGui::PushID(static_cast<i32>(i));
@ -576,19 +573,24 @@ namespace K::UI {
ImGui::Text("%u", i); ImGui::Text("%u", i);
ImGui::TableSetColumnIndex(1); ImGui::TableSetColumnIndex(1);
if (ImGui::Selectable(s.layers[i].name.c_str(), selected, static auto base_flags = ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_OpenOnArrow |
ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_AllowOverlap, ImGuiTreeNodeFlags_AllowOverlap | ImGuiTreeNodeFlags_FramePadding;
ImVec2(0, row_height))) { auto flags = base_flags;
if (s.selected.contains(i))
flags |= ImGuiTreeNodeFlags_Selected;
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding,
{0.0f, (row_height - ImGui::GetTextLineHeight()) / 2.0f});
bool layer_open = ImGui::TreeNodeEx(s.layers[i].name.c_str(), flags);
ImGui::PopStyleVar();
if (ImGui::IsItemClicked() && !ImGui::IsItemToggledOpen()) {
if (io.KeyCtrl) { if (io.KeyCtrl) {
if (selected) if (selected)
s.selected.erase(i); s.selected.erase(i);
else else
s.selected.insert(i); s.selected.insert(i);
} } else if (io.KeyShift) {
else if (io.KeyShift) {
// TODO // TODO
} } else {
else {
s.selected.clear(); s.selected.clear();
if (!selected) if (!selected)
s.selected.insert(i); s.selected.insert(i);
@ -596,7 +598,8 @@ namespace K::UI {
s.active = selected ? -1 : static_cast<i32>(i); s.active = selected ? -1 : static_cast<i32>(i);
} }
auto source_flags = ImGuiDragDropFlags_SourceNoDisableHover | ImGuiDragDropFlags_SourceNoHoldToOpenOthers; auto source_flags =
ImGuiDragDropFlags_SourceNoDisableHover | ImGuiDragDropFlags_SourceNoHoldToOpenOthers;
if (!no_selection) source_flags |= ImGuiDragDropFlags_SourceNoPreviewTooltip; if (!no_selection) source_flags |= ImGuiDragDropFlags_SourceNoPreviewTooltip;
if ((no_selection || s.selected.contains(i)) && ImGui::BeginDragDropSource(source_flags)) { if ((no_selection || s.selected.contains(i)) && ImGui::BeginDragDropSource(source_flags)) {
if (s.selected.empty()) ImGui::Text("Swap with #%u %s", i, s.layers[i].name.c_str()); if (s.selected.empty()) ImGui::Text("Swap with #%u %s", i, s.layers[i].name.c_str());
@ -605,7 +608,8 @@ namespace K::UI {
} }
if ((no_selection || !s.selected.contains(i)) && ImGui::BeginDragDropTarget()) { if ((no_selection || !s.selected.contains(i)) && ImGui::BeginDragDropTarget()) {
if (!no_selection) { if (!no_selection) {
after = ImGui::GetMousePos().y - ImGui::GetWindowPos().y > ImGui::GetCursorPosY() - row_height / 2.0f; after = ImGui::GetMousePos().y - ImGui::GetWindowPos().y >
ImGui::GetCursorPosY() - row_height / 2.0f;
if (after) if (after)
ImGui::SetTooltip("After #%u %s", i, s.layers[i].name.c_str()); ImGui::SetTooltip("After #%u %s", i, s.layers[i].name.c_str());
else else
@ -613,8 +617,8 @@ namespace K::UI {
} }
if (const ImGuiPayload *payload = ImGui::AcceptDragDropPayload("K_COMP_REORDER")) { if (const ImGuiPayload *payload = ImGui::AcceptDragDropPayload("K_COMP_REORDER")) {
move_from = *(const int*)payload->Data; move_from = *(const int *) payload->Data;
move_to = i; move_to = static_cast<i32>(i);
} }
ImGui::EndDragDropTarget(); ImGui::EndDragDropTarget();
} }
@ -641,10 +645,13 @@ namespace K::UI {
s.disabled.insert(i); s.disabled.insert(i);
} }
// Timeline
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0)); ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(0, 0));
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{}); ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{});
ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, ImVec2{}); ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, ImVec2{});
ImGui::TableSetColumnIndex(4);
ImGui::TableNextColumn();
f32 init_y = ImGui::GetCursorScreenPos().y; f32 init_y = ImGui::GetCursorScreenPos().y;
// do stuff here // do stuff here
@ -654,7 +661,7 @@ namespace K::UI {
if (pos_view >= view_left && pos_view < view_right) { if (pos_view >= view_left && pos_view < view_right) {
ImGui::Dummy({(pos_view - view_left) / view_amt * view_width - 5.0f, 0.0f}); ImGui::Dummy({(pos_view - view_left) / view_amt * view_width - 5.0f, 0.0f});
ImGui::SameLine(); ImGui::SameLine();
ImGui::Button("kf"); ImGui::Button("kf", {0.0f, row_height * .8f});
if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) { if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) {
pos_old = pos; pos_old = pos;
} }
@ -673,8 +680,92 @@ namespace K::UI {
ImGui::PopStyleVar(3); ImGui::PopStyleVar(3);
if (layer_open) {
i32 j = 0;
for (auto &u: s.layers[i].track.uniforms) {
ImGui::PushID(j);
ImGui::TableNextRow(ImGuiTableRowFlags_None, row_height);
ImGui::TableSetColumnIndex(0);
ImGui::RadioButton("##Socket", false);
if (ImGui::BeginDragDropSource(ImGuiDragDropFlags_None)) {
ImGui::SetDragDropPayload("K_PLUG_IN_TO_OUT", &u.second.connection,
sizeof(u.second.connection));
ImGui::EndDragDropSource();
}
if (ImGui::BeginDragDropTarget()) {
if (const ImGuiPayload *payload = ImGui::AcceptDragDropPayload("K_PLUG_OUT_TO_IN")) {
PlugboardGraph::ConnectInfo out = *(const PlugboardGraph::ConnectInfo *) payload->Data;
u.second.connection.p->connect(u.second.connection.index, out.p, out.index);
}
ImGui::EndDragDropTarget();
}
std::visit([&dragging_on_socket, &drag_source, &s, &style](auto &&arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, PlugboardGraph::ConnectInfo>) {
if (ImGui::IsItemActive())
s.plugboard.links_pos[arg].sinks.push_back(ImGui::GetMousePos());
else
s.plugboard.links_pos[arg].sinks.push_back(ImGui::GetCursorScreenPos() +
ImVec2{ImGui::GetFrameHeight() / 2,
-ImGui::GetFrameHeight() / 2 -
style.ItemInnerSpacing.y});
} else if (ImGui::IsItemActive()) {
dragging_on_socket = true;
drag_source = ImGui::GetCursorScreenPos() + ImVec2{ImGui::GetFrameHeight() / 2,
-ImGui::GetFrameHeight() / 2 -
style.ItemInnerSpacing.y};
}
}, u.second.connection.p->inputs_fed[u.second.connection.index]);
ImGui::TableSetColumnIndex(1);
ImGui::TreeNodeEx(u.first.c_str(),
ImGuiTreeNodeFlags_SpanFullWidth | ImGuiTreeNodeFlags_Leaf |
ImGuiTreeNodeFlags_NoTreePushOnOpen);
ImGui::TableSetColumnIndex(2);
ImGui::SetNextItemWidth(-FLT_MIN);
bool plugged = u.second.connection.p->inputs_fed[u.second.connection.index].index() == 1;
if (!plugged)
std::visit([](auto &&arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_Float>::type>)
ImGui::DragFloat("##", &arg, 0.005f);
else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_Int>::type>)
ImGui::DragInt("##", &arg, 0.005f);
else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_RGBA>::type>)
ImGui::DragFloat4("##", &arg.r, 0.005f);
else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_XY>::type>)
ImGui::DragFloat2("##", &arg.x, 0.005f);
else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_XYZ>::type>)
ImGui::DragFloat3("##", &arg.x, 0.005f);
}, std::get<0>(u.second.connection.p->inputs_fed[u.second.connection.index]));
ImGui::TableSetColumnIndex(3);
ImGui::TableSetColumnIndex(4);
ImGui::InvisibleButton("##TL_BG", ImVec2{ view_width + style.CellPadding.x * 2, row_height + style.CellPadding.y});
if (ImGui::IsItemActive()) {
s.current_frame = TimelineScreenViewToFrame(view_left, view_amt, view_width, std::clamp(ImGui::GetMousePos().x - tl_init_pos.x, 0.0f, view_width), s.frame_max);
}
ImGui::PopID();
j++;
}
ImGui::TreePop();
} else
for (auto &u: s.layers[i].track.uniforms)
std::visit([table_left, &s](auto &&arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, PlugboardGraph::ConnectInfo>)
s.plugboard.links_pos[arg].sinks.push_back(
{table_left, ImGui::GetCursorScreenPos().y - row_height / 2.0f});
}, u.second.connection.p->inputs_fed[u.second.connection.index]);
ImGui::PopID(); ImGui::PopID();
} }
// ImGui::PopStyleVar();
if (move_from != -1 && move_to != -1) { if (move_from != -1 && move_to != -1) {
if (no_selection) if (no_selection)
@ -686,7 +777,8 @@ namespace K::UI {
u32 target = move_to + after, popped_before_target = 0; u32 target = move_to + after, popped_before_target = 0;
for (auto it = s.selected.rbegin(); it != s.selected.rend(); it++, inserted++) { for (auto it = s.selected.rbegin(); it != s.selected.rend(); it++, inserted++) {
u32 sel = *it; u32 sel = *it;
if (sel > target) sel += inserted; // note that we iterate backwards, so cur index is always right if < target if (sel > target)
sel += inserted; // note that we iterate backwards, so cur index is always right if < target
Layer l = s.layers[sel]; Layer l = s.layers[sel];
s.layers.erase(s.layers.begin() + sel); s.layers.erase(s.layers.begin() + sel);
if (sel < move_to) popped_before_target++; if (sel < move_to) popped_before_target++;
@ -699,8 +791,36 @@ namespace K::UI {
} }
} }
tl_end_begin = ImGui::GetCursorScreenPos();
ImGui::EndTable(); ImGui::EndTable();
} }
ImGui::SetCursorScreenPos(nodes_begin);
if (ImGui::BeginChild("Overlay", {}, false, ImGuiWindowFlags_NoInputs)) {
for (auto &[_, link]: s.plugboard.links_pos)
for (auto &sink: link.sinks)
ImGui::GetCurrentWindow()->DrawList->AddBezierCubic(link.source,
{link.source.x + 60.0f, link.source.y},
{sink.x - 60.0f, sink.y}, sink, 0xFFFFFFFF,
2.0f);
if (dragging_on_socket)
ImGui::GetCurrentWindow()->DrawList->AddLine(ImGui::GetMousePos(), drag_source, 0xFFFFFFFF, 2.0f);
}
ImGui::EndChild();
ImGui::SetCursorScreenPos(tl_end_begin);
if (ImGui::BeginChild("TL Overlay")) {
ImGui::InvisibleButton("##TL_BG", ImGui::GetContentRegionAvail());
if (ImGui::IsItemActive()) {
s.current_frame = TimelineScreenViewToFrame(view_left, view_amt, view_width,
std::clamp(ImGui::GetMousePos().x - tl_init_pos.x, 0.0f,
view_width), s.frame_max);
}
}
ImGui::EndChild();
ImGui::End(); ImGui::End();
} }
@ -729,63 +849,39 @@ namespace K::UI {
ImGui::SetNextItemWidth(-FLT_MIN); ImGui::SetNextItemWidth(-FLT_MIN);
ImGui::Combo("##Type", &type_current, ShaderGraph::Type_To_Str, ShaderGraph::T_Count); ImGui::Combo("##Type", &type_current, ShaderGraph::Type_To_Str, ShaderGraph::T_Count);
if (ImGui::BeginTable("Uniforms", 5, ImGuiTableFlags_Borders)) { if (ImGui::BeginTable("Uniforms", 4, ImGuiTableFlags_Borders)) {
ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthFixed); ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthFixed);
ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthFixed); ImGui::TableSetupColumn("Type", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthFixed);
ImGui::TableSetupColumn("Expose", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthFixed);
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthStretch); ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthStretch);
ImGui::TableSetupColumn("##del", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthFixed); ImGui::TableSetupColumn("##del", ImGuiTableColumnFlags_NoSort | ImGuiTableColumnFlags_WidthFixed);
ImGui::TableHeadersRow(); ImGui::TableHeadersRow();
i32 i = 0; i32 i = 0;
for (auto it = s.layers[s.active].track.uniforms.begin(); it != s.layers[s.active].track.uniforms.end();) { for (auto it = s.layers[s.active].track.uniforms.begin(); it != s.layers[s.active].track.uniforms.end();) {
if (it->second.connection.p == nullptr)
continue;
ImGui::TableNextRow(); ImGui::TableNextRow();
ImGui::PushID(i++); ImGui::PushID(i++);
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::Text("%s", it->first.c_str()); ImGui::TextUnformatted(it->first.c_str());
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::Text("%s", ShaderGraph::Type_To_Str[it->second.val.index()]); ImGui::TextUnformatted(ShaderGraph::Type_To_Str[it->second.val.index()]);
ImGui::TableNextColumn();
bool d = it->second.exposure.p != nullptr, cp = d;
ImGui::Checkbox("##Expose", &d);
if (d != cp) {
if (d) {
String id = s.layers[s.active].name + "." + it->first;
it->second.exposure = {&s.plugboard.out_instance, static_cast<u32>(s.plugboard.out_instance.node->in_names.size())};
s.plugboard.out_instance.node->in_names.push_back(id);
s.plugboard.out_instance.node->in_types.push_back(PlugboardGraph::Type(it->second.val.index())); // this is shaky and bug prone -- relies on the shader types being in line with plugboard types
s.plugboard.out_instance.inputs_fed.emplace_back(ShaderValToPlugboard(it->second.val));
}
else {
it->second.exposure.p->disconnect(it->second.exposure.index);
for (auto& l : s.layers)
for (auto& u : l.track.uniforms)
if (u.second.exposure.index > it->second.exposure.index)
u.second.exposure.index--;
s.plugboard.comp_out.in_names.erase(s.plugboard.out_instance.node->in_names.begin() + it->second.exposure.index);
s.plugboard.comp_out.in_types.erase(s.plugboard.out_instance.node->in_types.begin() + it->second.exposure.index);
s.plugboard.out_instance.inputs_fed.erase(s.plugboard.out_instance.inputs_fed.begin() + it->second.exposure.index);
it->second.exposure = {nullptr, 0};
}
}
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::SetNextItemWidth(-FLT_MIN); ImGui::SetNextItemWidth(-FLT_MIN);
ImGui::BeginDisabled(it->second.exposure.p != nullptr); if (it->second.connection.p->inputs_fed[it->second.connection.index].index() == 0)
std::visit([](auto&& arg) { std::visit([](auto&& arg) {
using T = std::decay_t<decltype(arg)>; using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_Float>::type>) if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_Float>::type>)
ImGui::DragFloat("##", &arg, 0.005f); ImGui::DragFloat("##", &arg, 0.005f);
else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_Int>::type>) else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_Int>::type>)
ImGui::DragInt("##", &arg, 0.005f); ImGui::DragInt("##", &arg, 0.005f);
else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_RGBA>::type>) else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_RGBA>::type>)
ImGui::DragFloat4("##", &arg.r, 0.005f); ImGui::DragFloat4("##", &arg.r, 0.005f);
else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_XY>::type>) else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_XY>::type>)
ImGui::DragFloat2("##", &arg.x, 0.005f); ImGui::DragFloat2("##", &arg.x, 0.005f);
else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_XYZ>::type>) else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_XYZ>::type>)
ImGui::DragFloat3("##", &arg.x, 0.005f); ImGui::DragFloat3("##", &arg.x, 0.005f);
}, it->second.val); }, std::get<0>(it->second.connection.p->inputs_fed[it->second.connection.index]));
ImGui::EndDisabled();
ImGui::TableNextColumn(); ImGui::TableNextColumn();
if (ImGui::Button("X")) { if (ImGui::Button("X")) {
bgfx::destroy(it->second.handle); bgfx::destroy(it->second.handle);
@ -819,6 +915,20 @@ namespace K::UI {
ImGui::End(); ImGui::End();
} }
void Assets(CompState& s) {
if (ImGui::Begin("Assets", &draw_assets)) {
}
ImGui::End();
}
void Color(CompState& s) {
if (ImGui::Begin("Color", &draw_color)) {
}
ImGui::End();
}
void Draw(u32 frame, CompState& s) { void Draw(u32 frame, CompState& s) {
ImGui_ImplSDL2_NewFrame(); ImGui_ImplSDL2_NewFrame();
ImGui_Implbgfx_NewFrame(); ImGui_Implbgfx_NewFrame();
@ -826,18 +936,20 @@ namespace K::UI {
ImGui::DockSpaceOverViewport(ImGui::GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode); ImGui::DockSpaceOverViewport(ImGui::GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode);
// ImGui::ShowDemoWindow(); ImGui::ShowDemoWindow();
static ImGuiStyle& style = ImGui::GetStyle(); // static ImGuiStyle& style = ImGui::GetStyle();
style.GrabRounding = style.FrameRounding = 5.0f; // style.GrabRounding = style.FrameRounding = 5.0f;
MainMenuBar(s); MainMenuBar(s);
if (draw_viewport) Viewport(s); if (draw_viewport) Viewport(s);
if (draw_shader) Shader(s); if (draw_shader) Shader(s);
if (draw_comp) Composition(s); if (draw_comp) Composition(s);
if (draw_interpolation) Interpolation(s); if (draw_interpolation) Interpolation(s);
if (draw_properties) Properties(s); if (draw_properties) Properties(s);
if (draw_assets) Assets(s);
if (draw_color) Color(s);
if (save_called && ready_frame == frame) { if (save_called && ready_frame == frame) {
stbi_write_png("frame.png", s.width, s.height, 4, save_buffer, s.width * 4); stbi_write_png("frame.png", static_cast<i32>(s.width), static_cast<i32>(s.height), 4, save_buffer, static_cast<i32>(s.width) * 4);
save_called = false; save_called = false;
} }

35
Keishiki/VisualTrack.cpp
View file

@ -1,4 +1,5 @@
#include "VisualTrack.h" #include "VisualTrack.h"
#include "Keishiki.h"
namespace K { namespace K {
PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type ShaderValToPlugboard(const ShaderGraph::T_Map<ShaderGraph::T_Count>::type& val) { PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type ShaderValToPlugboard(const ShaderGraph::T_Map<ShaderGraph::T_Count>::type& val) {
@ -48,16 +49,20 @@ namespace K {
for (auto& [_name, u] : uniforms) { for (auto& [_name, u] : uniforms) {
f32 pack[4]{}; f32 pack[4]{};
ShaderGraph::T_Map<ShaderGraph::T_Count>::type val_target; ShaderGraph::T_Map<ShaderGraph::T_Count>::type val_target;
if (u.exposure.p == nullptr) if (u.connection.p == nullptr)
val_target = u.val; val_target = u.val;
else { else {
std::visit([&s, &val_target](auto&& arg) { std::visit([&u, &s, &val_target](auto&& arg) {
using T = std::decay_t<decltype(arg)>; using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, PlugboardGraph::ConnectInfo>) if constexpr (std::is_same_v<T, PlugboardGraph::ConnectInfo>) {
val_target = PlugboardValToShader(PlugboardGraph::Eval(s, arg)); bool good;
val_target = PlugboardValToShader(PlugboardGraph::ConvertValue(PlugboardGraph::Eval(s, arg),
static_cast<PlugboardGraph::Type>(u.val.index()), // todo DANGEROUS !!
good));
}
else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>) else if constexpr (std::is_same_v<T, PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>)
val_target = PlugboardValToShader(arg); val_target = PlugboardValToShader(arg);
}, u.exposure.p->inputs_fed[u.exposure.index]); }, u.connection.p->inputs_fed[u.connection.index]);
} }
std::visit([&pack](auto&& arg) { std::visit([&pack](auto&& arg) {
using T = std::decay_t<decltype(arg)>; using T = std::decay_t<decltype(arg)>;
@ -170,6 +175,26 @@ namespace K {
uniforms.clear(); uniforms.clear();
} }
void VisualTrack::expose_uniform(CompState& s, const String& u) {
auto& uu = uniforms[u];
uu.connection = {&s.plugboard.out_instance, static_cast<u32>(s.plugboard.out_instance.node->in.size())};
s.plugboard.out_instance.node->in.push_back({ u, PlugboardGraph::Type(uu.val.index())}); // this is shaky and bug prone -- relies on the shader types being in line with plugboard types
s.plugboard.out_instance.inputs_fed.emplace_back(ShaderValToPlugboard(uu.val));
}
void VisualTrack::hide_uniform(CompState& s, const String& u) {
auto& uu = uniforms[u];
uu.connection.p->disconnect(uu.connection.index);
for (auto& l : s.layers)
for (auto& u_other : l.track.uniforms)
if (u_other.second.connection.index > uu.connection.index)
u_other.second.connection.index--;
s.plugboard.comp_out.in.erase(s.plugboard.out_instance.node->in.begin() + uu.connection.index);
s.plugboard.out_instance.inputs_fed.erase(s.plugboard.out_instance.inputs_fed.begin() + uu.connection.index);
uu.connection = {nullptr, 0};
}
void VisualTrack::add_uniform(const String& s, ShaderGraph::T_Map<ShaderGraph::T_Count>::type&& val) { void VisualTrack::add_uniform(const String& s, ShaderGraph::T_Map<ShaderGraph::T_Count>::type&& val) {
if (!uniforms.contains(s)) if (!uniforms.contains(s))
uniforms.emplace(s, Uniform{bgfx::createUniform(("__" + s).c_str(), bgfx::UniformType::Vec4), val, {nullptr, 0}}); uniforms.emplace(s, Uniform{bgfx::createUniform(("__" + s).c_str(), bgfx::UniformType::Vec4), val, {nullptr, 0}});

1
Keishiki/include/Keishiki.h
View file

@ -31,7 +31,6 @@ namespace K {
std::set<u32> selected; // indices for layers std::set<u32> selected; // indices for layers
std::unordered_set<u32> disabled; // indices for layers std::unordered_set<u32> disabled; // indices for layers
PlugboardGraph::PlugboardGraph plugboard; PlugboardGraph::PlugboardGraph plugboard;
}; };
} }

32
Keishiki/include/PlugboardGraph.h
View file

@ -55,16 +55,19 @@ namespace K::PlugboardGraph {
T_Map<T_Count>::type expand_type(Type i); T_Map<T_Count>::type expand_type(Type i);
struct Socket {
String name;
Type type;
};
struct Node { struct Node {
String name; // will likely get SSO for most stuff String name; // will likely get SSO for most stuff
Vector<String> in_names; Vector<Socket> in;
Vector<Type> in_types; Vector<Socket> out;
Vector<String> out_names;
Vector<Type> out_types;
Vector<std::function<T_Map<T_Count>::type(const CompState&, const Vector<T_Map<T_Count>::type>&)>> fetch; // maybe change to a function pointer later Vector<std::function<T_Map<T_Count>::type(const CompState&, const Vector<T_Map<T_Count>::type>&)>> fetch; // maybe change to a function pointer later
// todo investigate how you might wanna jit this instead of evaluating a tree for each output at runtime // todo investigate how you might wanna jit this instead of evaluating a tree for each output at runtime esp. when a project is set for rendering
}; };
struct NodeInstance; struct NodeInstance;
@ -72,11 +75,10 @@ namespace K::PlugboardGraph {
struct ConnectInfo { struct ConnectInfo {
NodeInstance *p; // NOTE: so NodeInstances must be stored in a list, otherwise vector realloc leads to UAF NodeInstance *p; // NOTE: so NodeInstances must be stored in a list, otherwise vector realloc leads to UAF
u32 index; u32 index;
auto operator<=>(const ConnectInfo&) const = default; auto operator<=>(const ConnectInfo&) const = default; // too-modern c++ black magic ?
}; };
struct _ConnectInfoHasher struct ConnectInfoHasher {
{
std::size_t operator()(const ConnectInfo& k) const std::size_t operator()(const ConnectInfo& k) const
{ {
return std::hash<NodeInstance *>()(k.p); return std::hash<NodeInstance *>()(k.p);
@ -111,7 +113,7 @@ namespace K::PlugboardGraph {
else if constexpr (std::is_same_v<T, T_Map<Type::T_Count>::type>) else if constexpr (std::is_same_v<T, T_Map<Type::T_Count>::type>)
; ;
}, inputs_fed[input_index]); }, inputs_fed[input_index]);
inputs_fed[input_index] = expand_type(node->in_types[input_index]); inputs_fed[input_index] = expand_type(node->in[input_index].type);
} }
}; };
@ -119,10 +121,10 @@ namespace K::PlugboardGraph {
inline NodeInstance MakeInstance(Node& n) { inline NodeInstance MakeInstance(Node& n) {
Vector<std::variant<T_Map<Type::T_Count>::type, ConnectInfo>> inp; Vector<std::variant<T_Map<Type::T_Count>::type, ConnectInfo>> inp;
Vector<Vector<ConnectInfo>> out; Vector<Vector<ConnectInfo>> out;
for (auto t : n.in_types) for (const auto& t : n.in)
inp.emplace_back(expand_type(t)); inp.emplace_back(expand_type(t.type));
for (auto t : n.out_types) for (auto t : n.out)
out.push_back({}); out.emplace_back();
return { return {
.node = &n, .node = &n,
.inputs_fed = std::move(inp), .inputs_fed = std::move(inp),
@ -229,7 +231,7 @@ namespace K::PlugboardGraph {
return Eval(s,arg); return Eval(s,arg);
else if constexpr (std::is_same_v<T, T_Map<Type::T_Count>::type>) else if constexpr (std::is_same_v<T, T_Map<Type::T_Count>::type>)
return arg; return arg;
}, info.p->inputs_fed[i]), info.p->node->in_types[i], good); }, info.p->inputs_fed[i]), info.p->node->in[i].type, good);
if (good) { if (good) {
pack.push_back(val); pack.push_back(val);
} }
@ -245,7 +247,7 @@ namespace K::PlugboardGraph {
struct PlugboardGraph { struct PlugboardGraph {
std::list<NodeInstance> nodes; // OK complexity wise since we would usually traverse the entire thing anyway, locality will likely be bad std::list<NodeInstance> nodes; // OK complexity wise since we would usually traverse the entire thing anyway, locality will likely be bad
std::unordered_map<ConnectInfo, LinksFromSource, _ConnectInfoHasher> links_pos; // this is hilariously bad std::unordered_map<ConnectInfo, LinksFromSource, ConnectInfoHasher> links_pos; // this is hilariously bad
Node comp_in, comp_out; Node comp_in, comp_out;
NodeInstance in_instance, out_instance; NodeInstance in_instance, out_instance;
}; };

6
Keishiki/include/PlugboardNodes.h
View file

@ -5,11 +5,9 @@
namespace K::PlugboardNodes { namespace K::PlugboardNodes {
PlugboardGraph::Node Sine = { PlugboardGraph::Node Sine = {
.name = "Sine", .name = "Sine",
.in_names = { "In" }, .in = { {"In", PlugboardGraph::T_Float } },
.in_types = { PlugboardGraph::T_Float },
.out_names = { "Out" }, .out = { { "Out", PlugboardGraph::T_Float } },
.out_types = { PlugboardGraph::T_Float },
.fetch = {[](const CompState&, const Vector<PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>& arg) { .fetch = {[](const CompState&, const Vector<PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type>& arg) {
return std::sin(std::get<PlugboardGraph::T_Float>(arg[0])); return std::sin(std::get<PlugboardGraph::T_Float>(arg[0]));
}} }}

5
Keishiki/include/VisualTrack.h
View file

@ -24,7 +24,7 @@ namespace K {
struct Uniform { struct Uniform {
bgfx::UniformHandle handle; bgfx::UniformHandle handle;
ShaderGraph::T_Map<ShaderGraph::T_Count>::type val; ShaderGraph::T_Map<ShaderGraph::T_Count>::type val;
PlugboardGraph::ConnectInfo exposure; PlugboardGraph::ConnectInfo connection;
}; };
ShaderGraph::T_Map<ShaderGraph::T_Count>::type PlugboardValToShader(const PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type& val); ShaderGraph::T_Map<ShaderGraph::T_Count>::type PlugboardValToShader(const PlugboardGraph::T_Map<PlugboardGraph::T_Count>::type& val);
@ -38,6 +38,9 @@ namespace K {
Dict<String, Uniform> uniforms; Dict<String, Uniform> uniforms;
// Vector<String> samplers; // Vector<String> samplers;
bgfx::TextureHandle get_frame(const CompState& s, bgfx::FrameBufferHandle fb, u32 w, u32 h, f32 proj[16], f32 view[16], f32 transform[16]) const; bgfx::TextureHandle get_frame(const CompState& s, bgfx::FrameBufferHandle fb, u32 w, u32 h, f32 proj[16], f32 view[16], f32 transform[16]) const;
void expose_uniform(CompState& s, const String& u);
void hide_uniform(CompState& s, const String& u);
void add_uniform(const String& s, ShaderGraph::T_Map<ShaderGraph::T_Count>::type&& val); void add_uniform(const String& s, ShaderGraph::T_Map<ShaderGraph::T_Count>::type&& val);
void compile(); void compile();