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

asdfafs

Browse source
This commit is contained in:
lachrymaLF 2024-05-23 03:18:24 -04:00
parent f0db892b6a
commit 2de32140be
14 changed files with 497 additions and 168 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Keishiki/CMakeLists.txt
View file

@ -10,7 +10,7 @@ add_executable (Keishiki
"ext/imgui/imgui_demo.cpp" "ext/imgui/imgui_draw.cpp" "ext/imgui/imgui_tables.cpp" "ext/imgui/imgui_widgets.cpp" "ext/imgui/imgui_demo.cpp" "ext/imgui/imgui_draw.cpp" "ext/imgui/imgui_tables.cpp" "ext/imgui/imgui_widgets.cpp"
"ext/imgui/misc/cpp/imgui_stdlib.cpp" "ext/imgui/misc/cpp/imgui_stdlib.cpp"
"Keishiki.cpp" "Graphics.cpp" "UI.cpp" "ShaderGraph.cpp" "include/ShaderGraph.h" "include/ShaderNodes.h") "Keishiki.cpp" "Graphics.cpp" "UI.cpp" "ShaderGraph.cpp")
if (CMAKE_VERSION VERSION_GREATER 3.12) if (CMAKE_VERSION VERSION_GREATER 3.12)
set_property(TARGET Keishiki PROPERTY CXX_STANDARD 20) set_property(TARGET Keishiki PROPERTY CXX_STANDARD 20)

63
Keishiki/Graphics.cpp
View file

@ -20,7 +20,6 @@ namespace {
switch (bgfx::getRendererType()) { switch (bgfx::getRendererType()) {
case bgfx::RendererType::Noop: case bgfx::RendererType::Noop:
// case bgfx::RendererType::Direct3D9: shaderPath = "shaders/dx9/"; break;
case bgfx::RendererType::Direct3D11: case bgfx::RendererType::Direct3D11:
case bgfx::RendererType::Direct3D12: shaderPath = "shaders/dx11/"; break; case bgfx::RendererType::Direct3D12: shaderPath = "shaders/dx11/"; break;
case bgfx::RendererType::Gnm: shaderPath = "shaders/pssl/"; break; case bgfx::RendererType::Gnm: shaderPath = "shaders/pssl/"; break;
@ -55,7 +54,7 @@ namespace {
f32 v; f32 v;
}; };
static PosUVVertex quad_vert[] = PosUVVertex quad_vert[] =
{ {
{ 0.f, 0.f, 0.0f, 0.0f, 0.0f }, { 0.f, 0.f, 0.0f, 0.0f, 0.0f },
{ 0.f, 1.f, 0.0f, 0.0f, 1.0f }, { 0.f, 1.f, 0.0f, 0.0f, 1.0f },
@ -63,7 +62,7 @@ namespace {
{ 1.f, 1.f, 0.0f, 1.0f, 1.0f } { 1.f, 1.f, 0.0f, 1.0f, 1.0f }
}; };
static const u16 quad_indices[] = const u16 quad_indices[] =
{ {
0, 2, 1, 0, 2, 1,
1, 2, 3 1, 2, 3
@ -182,7 +181,8 @@ namespace {
} }
Font regular, bold; Font regular, bold;
bgfx::ProgramHandle a_program, imga_program; bgfx::ProgramHandle imga_program;
bgfx::ProgramHandle a_program;
bgfx::UniformHandle s_texColor; bgfx::UniformHandle s_texColor;
bgfx::UniformHandle imga_opacity; bgfx::UniformHandle imga_opacity;
@ -192,6 +192,10 @@ namespace {
bgfx::VertexLayout pcvDecl; bgfx::VertexLayout pcvDecl;
Dict<String, ImageTexture> imgs; Dict<String, ImageTexture> imgs;
f32 composite_view[16];
bgfx::UniformHandle composite_A, composite_B, composite_mode;
bgfx::ProgramHandle composite_pg;
} }
namespace K::Graphics { namespace K::Graphics {
@ -225,6 +229,11 @@ namespace K::Graphics {
s_texColor = bgfx::createUniform("s_texColor", bgfx::UniformType::Sampler); s_texColor = bgfx::createUniform("s_texColor", bgfx::UniformType::Sampler);
mmaker = Graphics::GetImageTextureFromFile("mmaker.png"); mmaker = Graphics::GetImageTextureFromFile("mmaker.png");
bx::mtxTranslate(composite_view, 0.f, 0.f, 1.0f);
composite_A = bgfx::createUniform("v_A", bgfx::UniformType::Sampler);
composite_B = bgfx::createUniform("v_B", bgfx::UniformType::Sampler);
composite_pg = load_shader_program("BinaryComposite");
composite_mode = bgfx::createUniform("f_mode", bgfx::UniformType::Vec4);
return true; return true;
} }
@ -246,16 +255,16 @@ namespace K::Graphics {
bgfx::destroy(s_texColor); bgfx::destroy(s_texColor);
bgfx::destroy(imga_opacity); bgfx::destroy(imga_opacity);
bgfx::destroy(composite_A);
bgfx::destroy(composite_B);
bgfx::destroy(composite_pg);
bgfx::destroy(composite_mode);
} }
// Draws quad with texture on Z = 0 // Draws quad with texture on Z = 0
void DrawTexture(u32 view_id, const bgfx::TextureHandle& tex, i32 pos_x, i32 pos_y, u32 w, u32 h, u64 state, const bgfx::ProgramHandle& pg) { void DrawTextureWithTransform(u32 view_id, const bgfx::TextureHandle& tex, f32 mtx[16], u64 state, const bgfx::ProgramHandle& pg) {
f32 mtx1[16], mtx2[16], mtx3[16]; bgfx::setTransform(mtx);
bx::mtxTranslate(mtx1, pos_x, pos_y, 0.0f);
bx::mtxScale(mtx2, w, h, 1.0f);
bx::mtxMul(mtx3, mtx2, mtx1);
bgfx::setTransform(mtx3);
bgfx::setVertexBuffer(0, vbh); bgfx::setVertexBuffer(0, vbh);
bgfx::setIndexBuffer(ibh); bgfx::setIndexBuffer(ibh);
@ -266,8 +275,17 @@ namespace K::Graphics {
bgfx::submit(view_id, pg); bgfx::submit(view_id, pg);
} }
void DrawTexture(u32 view_id, const bgfx::TextureHandle& tex, i32 pos_x, i32 pos_y, u32 w, u32 h, u64 state, const bgfx::ProgramHandle& pg) {
static f32 mtx1[16], mtx2[16], mtx3[16];
bx::mtxTranslate(mtx1, pos_x, pos_y, 0.0f);
bx::mtxScale(mtx2, w, h, 1.0f);
bx::mtxMul(mtx3, mtx2, mtx1);
DrawTextureWithTransform(view_id, tex, mtx3, state, pg);
}
void DrawTextureImageAlpha(u32 view_id, const ImageTexture& img, i32 pos_x, i32 pos_y, f32 alpha) { void DrawTextureImageAlpha(u32 view_id, const ImageTexture& img, i32 pos_x, i32 pos_y, f32 alpha) {
f32 pack[4]{}; static f32 pack[4]{};
pack[0] = alpha; pack[0] = alpha;
bgfx::setUniform(imga_opacity, pack); bgfx::setUniform(imga_opacity, pack);
DrawTexture(view_id, img.tx, pos_x, pos_y, img.w, img.h, (BGFX_STATE_DEFAULT | BGFX_STATE_BLEND_ALPHA) & ~(BGFX_STATE_WRITE_Z | BGFX_STATE_DEPTH_TEST_LESS), imga_program); DrawTexture(view_id, img.tx, pos_x, pos_y, img.w, img.h, (BGFX_STATE_DEFAULT | BGFX_STATE_BLEND_ALPHA) & ~(BGFX_STATE_WRITE_Z | BGFX_STATE_DEPTH_TEST_LESS), imga_program);
@ -413,4 +431,25 @@ namespace K::Graphics {
} }
return pos_x; return pos_x;
} }
void Composite(bgfx::FrameBufferHandle fb, bgfx::TextureHandle composite, bgfx::TextureHandle from, Blending mode, u16 w, u16 h, f32 proj[16], f32 transform[16]) {
static f32 pack[4]{};
pack[0] = static_cast<f32>(mode);
bgfx::touch(K::Graphics::K_VIEW_DRAW);
bgfx::setViewMode(K::Graphics::K_VIEW_DRAW, bgfx::ViewMode::Sequential);
bgfx::setViewClear(K::Graphics::K_VIEW_DRAW, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x00000000, 1.0f, 0);
bgfx::setViewFrameBuffer(K::Graphics::K_VIEW_COMP_COMPOSITE, fb);
bgfx::setViewTransform(K::Graphics::K_VIEW_COMP_COMPOSITE, composite_view, proj);
bgfx::setViewRect(K::Graphics::K_VIEW_COMP_COMPOSITE, 0, 0, w, h);
bgfx::setTransform(transform);
bgfx::setVertexBuffer(0, vbh);
bgfx::setIndexBuffer(ibh);
bgfx::setTexture(0, composite_A, composite);
bgfx::setTexture(0, composite_B, from);
bgfx::setUniform(composite_mode, pack);
bgfx::setState((BGFX_STATE_DEFAULT | BGFX_STATE_BLEND_ALPHA) & ~(BGFX_STATE_WRITE_Z | BGFX_STATE_DEPTH_TEST_LESS));
bgfx::submit(K::Graphics::K_VIEW_COMP_COMPOSITE, composite_pg);
}
} }

45
Keishiki/Keishiki.cpp
View file

@ -9,9 +9,8 @@
#include <bgfx/bgfx.h> #include <bgfx/bgfx.h>
#include <bgfx/platform.h> #include <bgfx/platform.h>
#include <imgui.h>
#include "backends/imgui_impl_sdl2.h" #include "backends/imgui_impl_sdl2.h"
#include "imgui_impl_bgfx.h" #include <imgui.h>
namespace { namespace {
SDL_Window* window; SDL_Window* window;
@ -22,13 +21,9 @@ namespace {
bool running = false; bool running = false;
K::CompState state; K::CompState state;
bgfx::FrameBufferHandle fb = BGFX_INVALID_HANDLE;
K::Graphics::ImageTexture* mm;
} }
namespace K { namespace K {
const char* BlendingToString[] = { "Normal", "Additive", "Invalid Blending" };
bool Init() { bool Init() {
if (SDL_Init(SDL_INIT_VIDEO)) { if (SDL_Init(SDL_INIT_VIDEO)) {
LogError(SDL_GetError()); LogError(SDL_GetError());
@ -75,25 +70,14 @@ namespace K {
if (!bgfx::init(bgfxInit)) { if (!bgfx::init(bgfxInit)) {
LogError("bgfx initialization failed"); LogError("bgfx initialization failed");
return false; return false;
}; }
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
// io.Fonts->AddFontFromFileTTF("SourceHanSans-Regular.ttc", 17);
ImGui_Implbgfx_Init(K::Graphics::K_VIEW_TOP);
bgfx::setDebug(BGFX_DEBUG_TEXT); bgfx::setDebug(BGFX_DEBUG_TEXT);
bgfx::setViewClear(K::Graphics::K_VIEW_TOP, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x000000ff, 1.0f, 0); bgfx::setViewClear(K::Graphics::K_VIEW_TOP, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x000000ff, 1.0f, 0);
bgfx::setViewRect(K::Graphics::K_VIEW_TOP, 0, 0, window_width, window_height); bgfx::setViewRect(K::Graphics::K_VIEW_TOP, 0, 0, window_width, window_height);
#if BX_PLATFORM_WINDOWS K::UI::Init(window);
ImGui_ImplSDL2_InitForD3D(window);
#elif BX_PLATFORM_OSX
ImGui_ImplSDL2_InitForMetal(window);
#elif BX_PLATFORM_LINUX || BX_PLATFORM_EMSCRIPTEN
ImGui_ImplSDL2_InitForOpenGL(window, nullptr);
#endif
if (!K::Graphics::Init(window_width, window_height)) { if (!K::Graphics::Init(window_width, window_height)) {
LogError("Graphics init failed"); LogError("Graphics init failed");
@ -102,23 +86,13 @@ namespace K {
state.width = 800; state.width = 800;
state.height = 600; state.height = 600;
fb = bgfx::createFrameBuffer(state.width, state.height, bgfx::TextureFormat::RGBA8); K::UI::SetupViewport(state);
state.layers.push_back(Layer{
VisualTrack{},
"garfield",
true,
false,
K_V_Normal
});
return true; return true;
} }
void Render() { void Render() {
// ImGui::ShowDemoWindow(); UI::Draw(state);
UI::Draw(state, mm, fb);
ImGui::Render();
ImGui_Implbgfx_RenderDrawLists(ImGui::GetDrawData());
const bgfx::Stats* stat = bgfx::getStats(); const bgfx::Stats* stat = bgfx::getStats();
bgfx::dbgTextClear(); bgfx::dbgTextClear();
@ -137,10 +111,6 @@ namespace K {
current_time = SDL_GetTicks64(); current_time = SDL_GetTicks64();
delta_t = current_time - last_time; delta_t = current_time - last_time;
ImGui_ImplSDL2_NewFrame();
ImGui_Implbgfx_NewFrame();
ImGui::NewFrame();
for (SDL_Event current_event; SDL_PollEvent(&current_event) != 0;) { for (SDL_Event current_event; SDL_PollEvent(&current_event) != 0;) {
ImGui_ImplSDL2_ProcessEvent(&current_event); ImGui_ImplSDL2_ProcessEvent(&current_event);
if (current_event.type == SDL_QUIT) { if (current_event.type == SDL_QUIT) {
@ -156,11 +126,8 @@ namespace K {
} }
void Shutdown() { void Shutdown() {
bgfx::destroy(fb);
K::Graphics::Shutdown(); K::Graphics::Shutdown();
ImGui_Implbgfx_Shutdown(); K::UI::Shutdown(state);
ImGui_ImplSDL2_Shutdown();
ImGui::DestroyContext();
bgfx::shutdown(); bgfx::shutdown();
SDL_DestroyWindow(window); SDL_DestroyWindow(window);
SDL_Quit(); SDL_Quit();

194
Keishiki/UI.cpp
View file

@ -5,18 +5,23 @@
#include <imgui.h> #include <imgui.h>
#include <imgui_internal.h> #include <imgui_internal.h>
#include <misc/cpp/imgui_stdlib.h> #include <misc/cpp/imgui_stdlib.h>
#include <fstream>
namespace { namespace {
bool draw_viewport = true; bool draw_viewport = true;
bool draw_sequencer = true; bool draw_sequencer = true;
bool draw_nodes = true; bool draw_nodes = true;
// Viewport
bgfx::FrameBufferHandle composite_fb = BGFX_INVALID_HANDLE, render_fb = BGFX_INVALID_HANDLE;
K::VisualTrack bg{};
f32 proj[16], transform[16];
} }
namespace ImGui { namespace ImGui {
inline ImTextureID toId(bgfx::TextureHandle _handle, uint8_t _flags, uint8_t _mip) inline ImTextureID toId(bgfx::TextureHandle _handle, uint8_t _flags, uint8_t _mip)
{ {
union { struct { bgfx::TextureHandle handle; uint8_t flags; uint8_t mip; } s; ImTextureID id; } tex; union { struct { bgfx::TextureHandle handle; uint8_t flags; uint8_t mip; } s; ImTextureID id; } tex{};
tex.s.handle = _handle; tex.s.handle = _handle;
tex.s.flags = _flags; tex.s.flags = _flags;
tex.s.mip = _mip; tex.s.mip = _mip;
@ -46,24 +51,74 @@ namespace K::UI {
} }
ImGui::EndMainMenuBar(); ImGui::EndMainMenuBar();
} }
void Viewport(CompState& s, Graphics::ImageTexture* mm, bgfx::FrameBufferHandle fb) {
void SetupViewport(CompState& s) {
composite_fb = bgfx::createFrameBuffer(s.width, s.height, bgfx::TextureFormat::RGBA8);
render_fb = bgfx::createFrameBuffer(s.width, s.height, bgfx::TextureFormat::RGBA8);
bg.pg = K::Graphics::load_shader_program("Checkerboard");
bg.add_uniform("f_hw", ShaderGraph::Type::T_XYZ);
bx::mtxOrtho(proj, 0.0f, static_cast<f32>(s.width), 0.0f, static_cast<f32>(s.height),
0.1f, 100.0f, 0.f, bgfx::getCaps()->homogeneousDepth);
f32 mtx1[16], mtx2[16];
bx::mtxTranslate(mtx1, 0, 0, 0.0f);
bx::mtxScale(mtx2, s.width, s.height, 1.0f);
bx::mtxMul(transform, mtx2, mtx1);
}
void DestroyViewport(CompState& s) {
bgfx::destroy(composite_fb);
bgfx::destroy(render_fb);
bgfx::destroy(bg.pg);
bgfx::destroy(bg.uniforms.begin()->second.first);
bg.uniforms.erase(bg.uniforms.begin());
for (auto& layer : s.layers) {
if (bgfx::isValid(layer.track.pg))
bgfx::destroy(layer.track.pg);
for (auto& uniform : layer.track.uniforms) {
bgfx::destroy(uniform.second.first);
}
}
}
void Viewport(CompState& s) {
if (ImGui::Begin("Viewport", &draw_viewport)) { if (ImGui::Begin("Viewport", &draw_viewport)) {
ImTextureID idx = nullptr; ImTextureID idx = nullptr;
// If we need new frame
bgfx::TextureHandle composite = bg.get_frame(composite_fb, s.width, s.height);
for (auto& layer : s.layers) { for (auto& layer : s.layers) {
if (!layer.enabled) continue; if (!layer.enabled) continue;
bgfx::TextureHandle tx = layer.track.get_frame(0, mm, fb, s.width, s.height); Graphics::Composite(composite_fb, composite, layer.track.get_frame(render_fb, s.width, s.height),
idx = ImGui::toId(tx, 0, 0); &layer == &s.layers.front() ? Graphics::K_V_AlphaOver : layer.mode, s.width, s.height, proj, transform);
} }
idx = ImGui::toId(composite, 0, 0);
if (idx != nullptr) if (idx != nullptr)
ImGui::Image(idx, ImVec2{ 800, 600 }); ImGui::Image(idx, ImVec2{ static_cast<f32>(s.width), static_cast<f32>(s.height) });
ImGui::Text("Comp Size: %ux%u", s.width, s.height); ImGui::Text("Comp Size: %ux%u", s.width, s.height);
} }
ImGui::End(); ImGui::End();
} }
void Sequencer(CompState& s){ void Sequencer(CompState& s){
if (ImGui::Begin("Sequencer", &draw_sequencer)) { if (ImGui::Begin("Sequencer", &draw_sequencer)) {
static String name{};
if (ImGui::Button("Add Layer") && !name.empty()) {
s.layers.push_back(Layer{
VisualTrack{},
name,
true,
false,
Graphics::K_V_AlphaOver
});
}
ImGui::SameLine();
ImGui::InputText("##UniformName", &name);
if (ImGui::BeginTable("Layers", 5, ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) { if (ImGui::BeginTable("Layers", 5, ImGuiTableFlags_Borders | ImGuiTableFlags_SizingFixedFit)) {
ImGui::TableSetupColumn("#", ImGuiTableColumnFlags_NoSort); ImGui::TableSetupColumn("#", ImGuiTableColumnFlags_NoSort);
ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoSort); ImGui::TableSetupColumn("Name", ImGuiTableColumnFlags_NoSort);
@ -76,18 +131,19 @@ namespace K::UI {
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::Text("%u", i); ImGui::Text("%u", i);
ImGui::TableNextColumn(); ImGui::TableNextColumn();
if (ImGui::Selectable(s.layers[i].name.c_str(), &s.layers[i].selected)) { if (ImGui::Selectable((s.layers[i].name + "##" + std::to_string(i)).c_str(), &s.layers[i].selected)) {
s.active = s.layers[i].selected ? &s.layers[i] : nullptr; s.active = s.layers[i].selected ? i : -1;
// if (s.active != nullptr && ImGui::GetIO().KeyCtrl) // Clear selection when CTRL is not held if (!ImGui::GetIO().KeyCtrl) // Clear selection when CTRL is not held
// layers[i].selected = !layers[i].selected; for (u32 j = 0; j < s.layers.size(); j++)
s.layers[j].selected = j == i && s.layers[j].selected;
} }
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::SetNextItemWidth(100.0f); ImGui::SetNextItemWidth(100.0f);
if (ImGui::BeginCombo(("##Blending" + std::to_string(i)).c_str(), BlendingToString[s.layers[i].mode])) { if (ImGui::BeginCombo(("##Blending" + std::to_string(i)).c_str(), Graphics::BlendingToString[s.layers[i].mode])) {
for (i32 b = K_V_Normal; b != K_V_Count; b++) { for (i32 b = Graphics::K_V_AlphaOver; b != Graphics::K_V_Count; b++) {
const bool is_selected = ((Blending)b == s.layers[i].mode); const bool is_selected = (static_cast<Graphics::Blending>(b) == s.layers[i].mode);
if (ImGui::Selectable(BlendingToString[b], is_selected)) if (ImGui::Selectable(Graphics::BlendingToString[b], is_selected))
s.layers[i].mode = (Blending)b; s.layers[i].mode = static_cast<Graphics::Blending>(b);
if (is_selected) if (is_selected)
ImGui::SetItemDefaultFocus(); ImGui::SetItemDefaultFocus();
} }
@ -101,6 +157,7 @@ namespace K::UI {
} }
ImGui::End(); ImGui::End();
} }
/*void Nodegraph(CompState& s) { /*void Nodegraph(CompState& s) {
Layer* active = nullptr; Layer* active = nullptr;
u32 active_index = 0; u32 active_index = 0;
@ -246,18 +303,19 @@ namespace K::UI {
} }
ImGui::End(); ImGui::End();
}*/ }*/
void Shader(CompState& s) { void Shader(CompState& s) {
if (ImGui::Begin("Shader", &draw_nodes)) { if (ImGui::Begin("Shader", &draw_nodes)) {
if (s.active == nullptr) if (s.active == -1)
ImGui::Text("No active layer."); ImGui::Text("No active layer.");
else { else {
static int type_current = 0; static int type_current = 0;
static char text[8] = ""; static String name{};
if (ImGui::Button("Add Uniform") && text[0] != '\0') { // todo LEAK!! if (ImGui::Button("Add Uniform") && !name.empty()) {
s.active->track.add_uniform(text, ShaderGraph::expand_type(static_cast<ShaderGraph::Type>(type_current))); s.layers[s.active].track.add_uniform(name, ShaderGraph::expand_type(static_cast<ShaderGraph::Type>(type_current)));
} }
ImGui::SameLine(); ImGui::SameLine();
ImGui::InputText("##UniformName", text, IM_ARRAYSIZE(text)); ImGui::InputText("##UniformName", &name);
ImGui::SameLine(); ImGui::SameLine();
ImGui::Combo("Type", &type_current, ShaderGraph::Type_To_Str, ShaderGraph::T_Count); ImGui::Combo("Type", &type_current, ShaderGraph::Type_To_Str, ShaderGraph::T_Count);
@ -268,7 +326,7 @@ namespace K::UI {
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_NoSort); ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_NoSort);
ImGui::TableSetupColumn("##del", ImGuiTableColumnFlags_NoSort); ImGui::TableSetupColumn("##del", ImGuiTableColumnFlags_NoSort);
ImGui::TableHeadersRow(); ImGui::TableHeadersRow();
for (auto it = s.active->track.uniforms.begin(); it != s.active->track.uniforms.end();) { for (auto it = s.layers[s.active].track.uniforms.begin(); it != s.layers[s.active].track.uniforms.end();) {
ImGui::TableNextRow(); ImGui::TableNextRow();
ImGui::TableNextColumn(); ImGui::TableNextColumn();
ImGui::Text("%s", it->first.c_str()); ImGui::Text("%s", it->first.c_str());
@ -286,71 +344,65 @@ namespace K::UI {
else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_RGBA>::type>) else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_RGBA>::type>)
ImGui::InputFloat4(("##" + it->first).c_str(), &arg.r); ImGui::InputFloat4(("##" + it->first).c_str(), &arg.r);
else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_XYZ>::type>) else if constexpr (std::is_same_v<T, ShaderGraph::T_Map<ShaderGraph::T_XYZ>::type>)
ImGui::InputFloat3(("##" + it->first).c_str(), &arg.x);; ImGui::InputFloat3(("##" + it->first).c_str(), &arg.x);
}, it->second.second); }, it->second.second);
ImGui::TableNextColumn(); ImGui::TableNextColumn();
if (ImGui::Button("Delete Uniform")) { if (ImGui::Button("Delete Uniform")) {
bgfx::destroy(it->second.first); bgfx::destroy(it->second.first);
it = s.active->track.uniforms.erase(it); it = s.layers[s.active].track.uniforms.erase(it);
} }
else it++; else it++;
} }
ImGui::EndTable(); ImGui::EndTable();
} }
ImGui::Text("Editing Layer %u: %s", 0, s.active->name.c_str()); ImGui::Text("Editing Layer %u: %s", s.active, s.layers[s.active].name.c_str());
ImGuiIO& io = ImGui::GetIO(); ImGui::InputTextMultiline("##source", &s.layers[s.active].track.shader, ImVec2(-FLT_MIN, ImGui::GetTextLineHeight() * 40), ImGuiInputTextFlags_AllowTabInput);
ImGui::InputTextMultiline("##source", &s.active->track.shader, ImVec2(-FLT_MIN, ImGui::GetTextLineHeight() * 24), ImGuiInputTextFlags_AllowTabInput); if (ImGui::Button("Submit Shader"))
if (ImGui::Button("Submit Shader")) { s.layers[s.active].track.compile();
// Compile shader and assign
std::ofstream f("temp.frag");
f << s.active->track.shader;
f.close();
if (std::system(
#if BX_PLATFORM_WINDOWS
"./ext/bgfx/cmake/bgfx/shaderc "
"-f temp.frag "
"--type fragment "
"--platform windows "
"--profile " "ps_5_0" " "
"--varyingdef temp.varying.def.sc "
"-i ./ "
"-o shaders/" "dx11" "/temp.frag.bin"
#elif BX_PLATFORM_LINUX
"./ext/bgfx/cmake/bgfx/shaderc "
"-f temp.frag "
"--type fragment "
"--platform windows "
"--profile " "spirv" " "
"--varyingdef temp.varying.def.sc "
"-i ./ "
"-o shaders/" "spirv" "/temp.frag.bin"
#elif BX_PLATFORM_OSX
"./ext/bgfx/cmake/bgfx/shaderc "
"-f temp.frag "
"--type fragment "
"--platform osx "
"--profile " "metal" " "
"--varyingdef temp.varying.def.sc "
"-i ./ "
"-o shaders/" "metal" "/temp.frag.bin"
#endif
) == 0) {
if (isValid( s.layers[0].track.pg)) bgfx::destroy(s.layers[0].track.pg);
s.layers[0].track.pg = Graphics::load_shader_program("temp"); // todo LEAK!!!
}
else
Log("User shader compilation failed");
}
} }
} }
ImGui::End(); ImGui::End();
} }
void Draw(CompState& s, Graphics::ImageTexture* mm, bgfx::FrameBufferHandle fb) {
void Draw(CompState& s) {
ImGui_ImplSDL2_NewFrame();
ImGui_Implbgfx_NewFrame();
ImGui::NewFrame();
// ImGui::ShowDemoWindow();
static ImGuiStyle& style = ImGui::GetStyle(); static ImGuiStyle& style = ImGui::GetStyle();
style.GrabRounding = style.FrameRounding = 15.0f; style.GrabRounding = style.FrameRounding = 5.0f;
MainMenuBar(s); MainMenuBar(s);
if (draw_viewport) Viewport(s, mm, fb); if (draw_viewport) Viewport(s);
if (draw_nodes) Shader(s); if (draw_nodes) Shader(s);
if (draw_sequencer) Sequencer(s); if (draw_sequencer) Sequencer(s);
ImGui::Render();
ImGui_Implbgfx_RenderDrawLists(ImGui::GetDrawData());
}
void Init(SDL_Window* window) {
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO();
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
// io.Fonts->AddFontFromFileTTF("SourceHanSans-Regular.ttc", 17);
ImGui_Implbgfx_Init(K::Graphics::K_VIEW_TOP);
#if BX_PLATFORM_WINDOWS
ImGui_ImplSDL2_InitForD3D(window);
#elif BX_PLATFORM_OSX
ImGui_ImplSDL2_InitForMetal(window);
#elif BX_PLATFORM_LINUX || BX_PLATFORM_EMSCRIPTEN
ImGui_ImplSDL2_InitForVulkan(window);
#endif
}
void Shutdown(CompState& s) {
DestroyViewport(s);
ImGui_Implbgfx_Shutdown();
ImGui_ImplSDL2_Shutdown();
ImGui::DestroyContext();
} }
} }

85
Keishiki/include/Graphics.h
View file

@ -8,7 +8,8 @@
namespace K::Graphics { namespace K::Graphics {
enum VIEW_ID { enum VIEW_ID {
K_VIEW_TOP = 0, K_VIEW_TOP = 0,
K_VIEW_DRAW = 5 K_VIEW_COMP_COMPOSITE,
K_VIEW_DRAW
}; };
bool Init(u16 width, u16 height); bool Init(u16 width, u16 height);
@ -23,6 +24,7 @@ namespace K::Graphics {
}; };
ImageTexture* GetImageTextureFromFile(const std::string& file); ImageTexture* GetImageTextureFromFile(const std::string& file);
void DrawTextureWithTransform(u32 view_id, const bgfx::TextureHandle& tex, f32 mtx[16], u64 state, const bgfx::ProgramHandle& pg);
void DrawTexture(u32 view_id, const bgfx::TextureHandle& tex, i32 pos_x, i32 pos_y, u32 w, u32 h, u64 state, const bgfx::ProgramHandle& pg); void DrawTexture(u32 view_id, const bgfx::TextureHandle& tex, i32 pos_x, i32 pos_y, u32 w, u32 h, u64 state, const bgfx::ProgramHandle& pg);
void DrawTextureImageAlpha(u32 view_id, const ImageTexture& img, i32 pos_x, i32 pos_y, f32 alpha); void DrawTextureImageAlpha(u32 view_id, const ImageTexture& img, i32 pos_x, i32 pos_y, f32 alpha);
void DrawTextureStencilAlpha(u32 view_id, const bgfx::TextureHandle& tex, i32 pos_x, i32 pos_y, u32 w, u32 h); void DrawTextureStencilAlpha(u32 view_id, const bgfx::TextureHandle& tex, i32 pos_x, i32 pos_y, u32 w, u32 h);
@ -39,5 +41,86 @@ namespace K::Graphics {
i32 RenderSubstringBox(u32 view_id, const String& s, i32& pos_x, i32& pos_y, i32 reset_x, u32 w, u32 col, size_t s_end = String::npos); i32 RenderSubstringBox(u32 view_id, const String& s, i32& pos_x, i32& pos_y, i32 reset_x, u32 w, u32 col, size_t s_end = String::npos);
enum Blending {
K_V_AlphaOver = 0,
K_V_Dissolve,
K_V_Add,
K_V_Subtract,
K_V_Difference,
K_V_Exclusion,
K_V_Multiply,
K_V_Divide,
K_V_Lighten,
K_V_Darken,
K_V_LighterColour,
K_V_DarkerColour,
K_V_Screen,
K_V_Overlay,
K_V_HardLight,
K_V_SoftLight,
K_V_VividLight,
K_V_LinearLight,
K_V_ColourBurn,
K_V_LinearBurn,
K_V_ColourDodge,
K_V_LinearDodge,
K_V_Hue,
K_V_Saturation,
K_V_Color,
K_V_Luminosity,
K_V_Count
};
static const char* BlendingToString[] = {
"Alpha Over",
"Dissolve",
"Add",
"Subtract",
"Difference",
"Exclusion",
"Multiply",
"Divide",
"Lighten",
"Darken",
"Lighter Colour",
"Darker Colour",
"Screen",
"Overlay",
"Hard Light",
"Soft Light",
"Vivid Light",
"Linear Light",
"Pin Light",
"Colour Burn",
"Linear Burn",
"Colour Dodge",
"Linear Dodge",
"Hue",
"Saturation",
"Color",
"Luminosity",
"Invalid"
};
void Composite(bgfx::FrameBufferHandle fb, bgfx::TextureHandle composite, bgfx::TextureHandle from, Blending mode, u16 w, u16 h, f32 proj[16], f32 transform[16]);
extern Graphics::ImageTexture* mmaker; extern Graphics::ImageTexture* mmaker;
} }

12
Keishiki/include/Keishiki.h
View file

@ -9,19 +9,11 @@ namespace K {
void Render(); void Render();
extern const char* BlendingToString[];
enum Blending {
K_V_Normal = 0,
K_V_Additive,
K_V_Count
};
struct Layer { struct Layer {
VisualTrack track; VisualTrack track;
String name; String name;
bool enabled, selected; bool enabled, selected;
Blending mode; Graphics::Blending mode;
}; };
struct CompState { struct CompState {
@ -30,6 +22,6 @@ namespace K {
u32 fps; u32 fps;
u32 width, height; u32 width, height;
Vector<Layer> layers; Vector<Layer> layers;
Layer* active = nullptr; i32 active = -1;
}; };
} }

6
Keishiki/include/UI.h
View file

@ -8,6 +8,8 @@
#include "imgui_impl_bgfx.h" #include "imgui_impl_bgfx.h"
namespace K::UI { namespace K::UI {
void Draw(CompState& s, Graphics::ImageTexture* mm, bgfx::FrameBufferHandle fb); void Init(SDL_Window* window);
void Draw(CompState& s);
void Shutdown(CompState& s);
void SetupViewport(CompState& s);
} }

44
Keishiki/include/VisualTrack.h
View file

@ -4,6 +4,7 @@
#include "ShaderGraph.h" #include "ShaderGraph.h"
#include <functional> #include <functional>
#include <bx/math.h> #include <bx/math.h>
#include <fstream>
namespace K { namespace K {
template <typename T> template <typename T>
@ -21,7 +22,8 @@ namespace K {
bgfx::ProgramHandle pg = BGFX_INVALID_HANDLE; bgfx::ProgramHandle pg = BGFX_INVALID_HANDLE;
String shader{}; String shader{};
Dict<String, std::pair<bgfx::UniformHandle, ShaderGraph::T_Map<ShaderGraph::T_Count>::type>> uniforms; Dict<String, std::pair<bgfx::UniformHandle, ShaderGraph::T_Map<ShaderGraph::T_Count>::type>> uniforms;
bgfx::TextureHandle get_frame(u64 time, Graphics::ImageTexture* mm, bgfx::FrameBufferHandle fb, u32 w, u32 h) const { // Vector<String> samplers;
bgfx::TextureHandle get_frame(bgfx::FrameBufferHandle fb, u32 w, u32 h) const {
bgfx::touch(K::Graphics::K_VIEW_DRAW); bgfx::touch(K::Graphics::K_VIEW_DRAW);
bgfx::setViewMode(K::Graphics::K_VIEW_DRAW, bgfx::ViewMode::Sequential); bgfx::setViewMode(K::Graphics::K_VIEW_DRAW, bgfx::ViewMode::Sequential);
bgfx::setViewClear(K::Graphics::K_VIEW_DRAW, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x00000000, 1.0f, 0); bgfx::setViewClear(K::Graphics::K_VIEW_DRAW, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x00000000, 1.0f, 0);
@ -66,6 +68,46 @@ namespace K {
if (!uniforms.contains(s)) if (!uniforms.contains(s))
uniforms.emplace(s, std::make_pair(bgfx::createUniform(s.c_str(), bgfx::UniformType::Vec4), std::move(val))); uniforms.emplace(s, std::make_pair(bgfx::createUniform(s.c_str(), bgfx::UniformType::Vec4), std::move(val)));
} }
void compile() {
std::ofstream f("temp.frag");
f << shader;
f.close();
if (std::system(
#if BX_PLATFORM_WINDOWS
"./ext/bgfx/cmake/bgfx/shaderc "
"-f temp.frag "
"--type fragment "
"--platform windows "
"--profile " "ps_5_0" " "
"--varyingdef temp.varying.def.sc "
"-i ./ "
"-o shaders/" "dx11" "/temp.frag.bin"
#elif BX_PLATFORM_LINUX
"./ext/bgfx/cmake/bgfx/shaderc "
"-f temp.frag "
"--type fragment "
"--platform windows "
"--profile " "spirv" " "
"--varyingdef temp.varying.def.sc "
"-i ./ "
"-o shaders/" "spirv" "/temp.frag.bin"
#elif BX_PLATFORM_OSX
"./ext/bgfx/cmake/bgfx/shaderc "
"-f temp.frag "
"--type fragment "
"--platform osx "
"--profile " "metal" " "
"--varyingdef temp.varying.def.sc "
"-i ./ "
"-o shaders/" "metal" "/temp.frag.bin"
#endif
) == 0) {
if (isValid(pg)) bgfx::destroy(pg);
pg = Graphics::load_shader_program("temp");
}
else
Log("User shader compilation failed");
}
}; };
void Composite(); void Composite();

23
Keishiki/shader.py
View file

@ -1,16 +1,19 @@
import subprocess, os import subprocess, os
#SHADERC = "..\\out\\install\\x64-Debug\\bin\\shaderc" #SHADERC = "..\\out\\install\\x64-Debug\\bin\\shaderc"
SHADERC = "/Users/lachrymal/Projects/NouVeL/build/ADVect/ext/bgfx/Debug/shaderc" # SHADERC = "/Users/lachrymal/Projects/NouVeL/build/ADVect/ext/bgfx/Debug/shaderc"
SHADERC = "/home/lach/Projects/Keishiki/cmake-build-debug/Keishiki/ext/bgfx/cmake/bgfx/shaderc"
#OUT = "..\\out\\build\\x64-Debug\\ADVect\\shaders\\" #OUT = "..\\out\\build\\x64-Debug\\ADVect\\shaders\\"
# OUT = "..\\build\\ADVect\\shaders\\" # OUT = "..\\build\\ADVect\\shaders\\"
OUT = "/Users/lachrymal/Projects/NouVeL/ADVect/runtime/shaders/" # OUT = "/Users/lachrymal/Projects/NouVeL/ADVect/runtime/shaders/"
OUT = "/home/lach/Projects/Keishiki/cmake-build-debug/Keishiki/shaders/"
I = "/home/lach/Projects/Keishiki/cmake-build-debug/Keishiki/"
P = lambda location, platform, frag, vert: { 'location': location, 'platform': platform, 'frag': frag, 'vert': vert } P = lambda location, platform, frag, vert: { 'location': location, 'platform': platform, 'frag': frag, 'vert': vert }
plats = [ plats = [
# P('glsl', 'windows', '140', '140'), P('glsl', 'windows', '140', '140'),
# P('dx11', 'windows', 'ps_5_0', 'vs_5_0'), # P('dx11', 'windows', 's_5_0', 's_5_0'),
# P('spirv', 'windows', 'spirv', 'spirv'), P('spirv', 'windows', 'spirv', 'spirv'),
P('metal', 'osx', 'metal', 'metal') P('metal', 'osx', 'metal', 'metal')
] ]
@ -22,15 +25,13 @@ for root, dirs, _ in os.walk('shaders'):
"--platform", config['platform'], "--platform", config['platform'],
"--profile", config['frag'], "--profile", config['frag'],
"--varyingdef", os.path.join(root, name, "varying.def.sc"), "--varyingdef", os.path.join(root, name, "varying.def.sc"),
"-i", "/Users/lachrymal/Projects/NouVeL/ADVect/ext/bgfx/bgfx/examples/common", "-i", I,
"-i", "/Users/lachrymal/Projects/NouVeL/ADVect/ext/bgfx/bgfx/src", "-o", OUT + config['location'] + "/" + name + ".frag.bin"])
"-o", OUT + config['location'] + "\\" + name + ".frag.bin"])
subprocess.run([SHADERC, "-f", os.path.join(root, name, name + '.vert'), subprocess.run([SHADERC, "-f", os.path.join(root, name, name + '.vert'),
"--type", "vertex", "--type", "vertex",
"--platform", config['platform'], "--platform", config['platform'],
"--profile", config['vert'], "--profile", config['vert'],
"--varyingdef", os.path.join(root, name, "varying.def.sc"), "--varyingdef", os.path.join(root, name, "varying.def.sc"),
"-i", "/Users/lachrymal/Projects/NouVeL/ADVect/ext/bgfx/bgfx/examples/common", "-i", I,
"-i", "/Users/lachrymal/Projects/NouVeL/ADVect/ext/bgfx/bgfx/src", "-o", OUT + config['location'] + "/" + name + ".vert.bin"])
"-o", OUT + config['location'] + "\\" + name + ".vert.bin"])

144
Keishiki/shaders/BinaryComposite/BinaryComposite.frag
View file

@ -3,11 +3,149 @@ $input v_texcoord0
#include <bgfx_shader.sh> #include <bgfx_shader.sh>
#include <shaderlib.sh> #include <shaderlib.sh>
SAMPLER2D(A, 0); uniform vec4 f_mode;
SAMPLER2D(B, 0); SAMPLER2D(v_A, 0);
SAMPLER2D(v_B, 0);
void main() void main()
{ {
vec2 uv = vec2(v_texcoord0.x, 1.0f - v_texcoord0.y); vec2 uv = vec2(v_texcoord0.x, 1.0f - v_texcoord0.y);
gl_FragColor = texture2D(A, uv) + texture2D(B, uv).a; vec4 _A = texture2D(v_A, uv);
vec4 _B = texture2D(v_B, uv);
if (f_mode.x == 0.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 1.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 2.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 3.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 4.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 5.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 6.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 7.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 8.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 9.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 10.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 11.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 12.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 13.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 14.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 15.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 16.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 17.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 18.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 19.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 20.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 21.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 22.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 23.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 24.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 25.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
else if (f_mode.x == 26.0f) {
float alpha_b = _A.a * (1.0f - _B.a);
float alpha = _A.a + alpha_b;
gl_FragColor = vec4((_A.rgb * _A.a + _B.rgb * alpha_b)/alpha, alpha);
}
} }

11
Keishiki/shaders/BinaryComposite/BinaryComposite.vert
View file

@ -0,0 +1,11 @@
$input a_position, a_texcoord0
$output v_texcoord0
#include <bgfx_shader.sh>
#include <shaderlib.sh>
void main()
{
gl_Position = mul(u_modelViewProj, vec4(a_position, 1.0));
v_texcoord0 = a_texcoord0;
}

8
Keishiki/shaders/Checkerboard/Checkerboard.frag
View file

@ -3,8 +3,12 @@ $input v_texcoord0
#include <bgfx_shader.sh> #include <bgfx_shader.sh>
#include <shaderlib.sh> #include <shaderlib.sh>
uniform vec4 f_hw;
void main() void main()
{ {
vec2 uv = vec2(v_texcoord0.x, 1.0f - v_texcoord0.y) * 100.0f; vec2 uv = vec2(v_texcoord0.x, 1.0f - v_texcoord0.y) * 20.0f;
gl_FragColor = ceil((uv - floor(uv)) - 0.5f); vec2 uvv = ceil(uv- floor(uv) - 0.5f);
float b = 0.8f - mod((uvv.x + uvv.y), 2.0f) * 0.2;
gl_FragColor = vec4(b, b, b, 1.0f);
} }

2
README.md
View file

@ -1,6 +1,6 @@
<img src="Keishiki.webp" alt="Logo" width="300"/> <img src="Keishiki.webp" alt="Logo" width="300"/>
# Keishiki Compositor-Sequencer # Keishiki: GPU Compositor-Sequencer
## Libraries ## Libraries
- [SDL2](https://www.libsdl.org/) - [SDL2](https://www.libsdl.org/)

4
TODO.md
View file

@ -1,12 +1,10 @@
## Compositor ## Compositor
- BinaryComposite
- Manage Samplers - Manage Samplers
- Data model for comps - Data model for comps
- Dump state, non-POD needs serialization!!! - Dump and read back state, (de)serialization!!!
## UI ## UI
- Sequencer timeline init - Sequencer timeline init
- Node editor
- Viewport Gizmos (https://github.com/CedricGuillemet/ImGuizmo) - Viewport Gizmos (https://github.com/CedricGuillemet/ImGuizmo)
- Shader nodes (https://github.com/CedricGuillemet/ImGuizmo) - Shader nodes (https://github.com/CedricGuillemet/ImGuizmo)