1606 lines
69 KiB
C++
1606 lines
69 KiB
C++
// WorldGraph Node Editor
|
||
// Standalone Dear ImGui + imnodes tool for editing WorldGraph node graphs.
|
||
// Each node displays a 64×64 preview image of its output, ShaderGraph-style.
|
||
// The permanent "World Output" node collects generation passes and renders
|
||
// the final generated chunk using GenerateChunk().
|
||
|
||
#include <GLFW/glfw3.h>
|
||
#include "imgui.h"
|
||
#include "imgui_internal.h"
|
||
#include "imgui_impl_glfw.h"
|
||
#include "imgui_impl_opengl3.h"
|
||
#include "imnodes.h"
|
||
#include "ImGuiFileDialog.h"
|
||
|
||
#include "WorldGraph/WorldGraph.h"
|
||
#include "WorldGraph/WorldGraphNode.h"
|
||
#include "WorldGraph/WorldGraphTypes.h"
|
||
#include "WorldGraph/WorldGraphSerializer.h"
|
||
#include "WorldGraph/WorldGraphChunk.h"
|
||
|
||
#include <nlohmann/json.hpp>
|
||
|
||
#include <algorithm>
|
||
#include <array>
|
||
#include <cmath>
|
||
#include <cstdint>
|
||
#include <cstdio>
|
||
#include <filesystem>
|
||
#include <fstream>
|
||
#include <memory>
|
||
#include <sstream>
|
||
#include <string>
|
||
#include <typeindex>
|
||
#include <unordered_map>
|
||
#include <vector>
|
||
|
||
using namespace WorldGraph;
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// Pin / link ID space
|
||
//
|
||
// Regular node output pin → nodeID * 10 + 9
|
||
// Regular node input slot S → nodeID * 10 + S (S = 0..8)
|
||
//
|
||
// World Output input pin N → WORLD_OUTPUT_PIN_BASE + N
|
||
// World Output static attr → WORLD_OUTPUT_PIN_BASE + 500
|
||
//
|
||
// Regular link IDs → 0 .. (num regular connections - 1)
|
||
// World Output link N → WORLD_OUTPUT_LINK_BASE + N
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
static constexpr int WORLD_OUTPUT_IMNODES_ID = 0;
|
||
static constexpr int WORLD_OUTPUT_PIN_BASE = 10000;
|
||
static constexpr int WORLD_OUTPUT_LINK_BASE = 20000;
|
||
|
||
static int OutputPin(Graph::NodeID n) { return static_cast<int>(n) * 10 + 9; }
|
||
static int InputPin (Graph::NodeID n, int slot) { return static_cast<int>(n) * 10 + slot; }
|
||
static Graph::NodeID PinToNode(int attr) { return static_cast<Graph::NodeID>(attr / 10); }
|
||
static int PinToSlot(int attr) { return attr % 10; } // 9 = output
|
||
|
||
static bool IsWorldOutputPin(int attr)
|
||
{
|
||
return attr >= WORLD_OUTPUT_PIN_BASE && attr < WORLD_OUTPUT_PIN_BASE + 500;
|
||
}
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// Tile registry – maps integer IDs to human-readable names
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
struct TileEntry {
|
||
int32_t id { 0 };
|
||
std::string name { "Tile" };
|
||
float color[3] { 1.0f, 1.0f, 1.0f }; // RGB in [0, 1]
|
||
};
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// Color helpers
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
static void HsvToRgb(float h, float s, float v, uint8_t& r, uint8_t& g, uint8_t& b)
|
||
{
|
||
float c = v * s;
|
||
float x = c * (1.0f - std::fabs(std::fmod(h * 6.0f, 2.0f) - 1.0f));
|
||
float m = v - c;
|
||
float r1, g1, b1;
|
||
int hi = static_cast<int>(h * 6.0f) % 6;
|
||
switch (hi) {
|
||
case 0: r1 = c; g1 = x; b1 = 0; break;
|
||
case 1: r1 = x; g1 = c; b1 = 0; break;
|
||
case 2: r1 = 0; g1 = c; b1 = x; break;
|
||
case 3: r1 = 0; g1 = x; b1 = c; break;
|
||
case 4: r1 = x; g1 = 0; b1 = c; break;
|
||
default:r1 = c; g1 = 0; b1 = x; break;
|
||
}
|
||
r = static_cast<uint8_t>((r1 + m) * 255.0f);
|
||
g = static_cast<uint8_t>((g1 + m) * 255.0f);
|
||
b = static_cast<uint8_t>((b1 + m) * 255.0f);
|
||
}
|
||
|
||
static void ValueToRGBA(const Value& v,
|
||
const std::vector<TileEntry>* registry,
|
||
uint8_t& r, uint8_t& g, uint8_t& b, uint8_t& a)
|
||
{
|
||
a = 255;
|
||
switch (v.type) {
|
||
case Type::Float: {
|
||
uint8_t grey = static_cast<uint8_t>(std::clamp(v.AsFloat(), 0.0f, 1.0f) * 255.0f);
|
||
r = g = b = grey;
|
||
return;
|
||
}
|
||
case Type::Bool: {
|
||
uint8_t c = v.AsBool() ? 255 : 0;
|
||
r = g = b = c;
|
||
return;
|
||
}
|
||
case Type::Int:
|
||
break;
|
||
}
|
||
|
||
// Int path — look up registry first, fall back to hash.
|
||
int32_t id = v.AsInt();
|
||
if (registry) {
|
||
for (const auto& t : *registry) {
|
||
if (t.id == id) {
|
||
r = static_cast<uint8_t>(t.color[0] * 255.0f);
|
||
g = static_cast<uint8_t>(t.color[1] * 255.0f);
|
||
b = static_cast<uint8_t>(t.color[2] * 255.0f);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
// Fallback: tile 0 (AIR) = near-black, others get a hashed hue.
|
||
if (id == 0) { r = g = b = 30; return; }
|
||
uint32_t h = static_cast<uint32_t>(id) * 2654435761u;
|
||
HsvToRgb((h & 0xFFu) / 255.0f, 0.7f, 0.85f, r, g, b);
|
||
}
|
||
|
||
// Pin colors by value type.
|
||
// Float → blue Int → orange Bool → green
|
||
static ImU32 PinColor(Type t)
|
||
{
|
||
switch (t) {
|
||
case Type::Float: return IM_COL32(100, 150, 220, 255);
|
||
case Type::Int: return IM_COL32(220, 160, 60, 255);
|
||
case Type::Bool: return IM_COL32( 80, 200, 100, 255);
|
||
}
|
||
return IM_COL32(200, 200, 200, 255);
|
||
}
|
||
static ImU32 PinColorHovered(Type t)
|
||
{
|
||
switch (t) {
|
||
case Type::Float: return IM_COL32(130, 180, 255, 255);
|
||
case Type::Int: return IM_COL32(255, 195, 90, 255);
|
||
case Type::Bool: return IM_COL32(110, 235, 130, 255);
|
||
}
|
||
return IM_COL32(230, 230, 230, 255);
|
||
}
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// VisualNode – wraps a graph node with its preview texture
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
static constexpr int PREVIEW_SIZE = 64;
|
||
static constexpr float PREVIEW_SCALE = 1.5f; // world units per pixel
|
||
static constexpr float FINAL_PREVIEW_SCALE = 4.0f; // for World Output node
|
||
|
||
static GLuint MakePreviewTexture()
|
||
{
|
||
GLuint tex = 0;
|
||
glGenTextures(1, &tex);
|
||
glBindTexture(GL_TEXTURE_2D, tex);
|
||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||
std::array<uint8_t, PREVIEW_SIZE * PREVIEW_SIZE * 4> buf;
|
||
buf.fill(40);
|
||
for (int i = 3; i < (int)buf.size(); i += 4) buf[i] = 255;
|
||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PREVIEW_SIZE, PREVIEW_SIZE,
|
||
0, GL_RGBA, GL_UNSIGNED_BYTE, buf.data());
|
||
return tex;
|
||
}
|
||
|
||
struct VisualNode {
|
||
Graph::NodeID id { Graph::INVALID_ID };
|
||
GLuint tex { 0 };
|
||
bool dirty { true };
|
||
|
||
void InitTex() { tex = MakePreviewTexture(); }
|
||
void FreeTex() { if (tex) { glDeleteTextures(1, &tex); tex = 0; } }
|
||
};
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// Node catalogue – all creatable node types
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
struct NodeMenuItem {
|
||
const char* label;
|
||
const char* category;
|
||
std::function<std::unique_ptr<Node>()> create;
|
||
};
|
||
|
||
static const std::vector<NodeMenuItem> NODE_MENU = {
|
||
// ── Source ──────────────────────────────────────────────────────────────
|
||
{ "Constant", "Source", [] { return std::make_unique<ConstantNode>(0.0f); } },
|
||
{ "TileID", "Source", [] { return std::make_unique<IDNode>(1); } },
|
||
{ "PositionX", "Source", [] { return std::make_unique<PositionXNode>(); } },
|
||
{ "PositionY", "Source", [] { return std::make_unique<PositionYNode>(); } },
|
||
{ "LayerStrength", "Source", [] { return std::make_unique<LayerStrengthNode>(); } },
|
||
// ── Math ────────────────────────────────────────────────────────────────
|
||
{ "Add", "Math", [] { return std::make_unique<AddNode>(); } },
|
||
{ "Subtract", "Math", [] { return std::make_unique<SubtractNode>(); } },
|
||
{ "Multiply", "Math", [] { return std::make_unique<MultiplyNode>(); } },
|
||
{ "Divide", "Math", [] { return std::make_unique<DivideNode>(); } },
|
||
{ "Modulo", "Math", [] { return std::make_unique<ModuloNode>(); } },
|
||
{ "Sin", "Math", [] { return std::make_unique<SinNode>(); } },
|
||
{ "Cos", "Math", [] { return std::make_unique<CosNode>(); } },
|
||
{ "Floor", "Math", [] { return std::make_unique<FloorNode>(); } },
|
||
{ "Ceil", "Math", [] { return std::make_unique<CeilNode>(); } },
|
||
{ "Sqrt", "Math", [] { return std::make_unique<SqrtNode>(); } },
|
||
{ "Pow", "Math", [] { return std::make_unique<PowNode>(); } },
|
||
{ "Square", "Math", [] { return std::make_unique<SquareNode>(); } },
|
||
{ "Abs", "Math", [] { return std::make_unique<AbsNode>(); } },
|
||
{ "Negate", "Math", [] { return std::make_unique<NegateNode>(); } },
|
||
{ "OneMinus", "Math", [] { return std::make_unique<OneMinusNode>(); } },
|
||
{ "Min", "Math", [] { return std::make_unique<MinNode>(); } },
|
||
{ "Max", "Math", [] { return std::make_unique<MaxNode>(); } },
|
||
{ "Clamp", "Math", [] { return std::make_unique<ClampNode>(); } },
|
||
{ "Map", "Math", [] { return std::make_unique<MapNode>(-1.0f, 1.0f, 0.0f, 1.0f); } },
|
||
// ── Compare ─────────────────────────────────────────────────────────────
|
||
{ "Less", "Compare", [] { return std::make_unique<LessNode>(); } },
|
||
{ "Greater", "Compare", [] { return std::make_unique<GreaterNode>(); } },
|
||
{ "LessEqual", "Compare", [] { return std::make_unique<LessEqualNode>(); } },
|
||
{ "GreaterEqual", "Compare", [] { return std::make_unique<GreaterEqualNode>(); } },
|
||
{ "Equal", "Compare", [] { return std::make_unique<EqualNode>(); } },
|
||
// ── Logic ───────────────────────────────────────────────────────────────
|
||
{ "And", "Logic", [] { return std::make_unique<AndNode>(); } },
|
||
{ "Or", "Logic", [] { return std::make_unique<OrNode>(); } },
|
||
{ "Not", "Logic", [] { return std::make_unique<NotNode>(); } },
|
||
{ "Xor", "Logic", [] { return std::make_unique<XorNode>(); } },
|
||
{ "Nand", "Logic", [] { return std::make_unique<NandNode>(); } },
|
||
{ "Nor", "Logic", [] { return std::make_unique<NorNode>(); } },
|
||
{ "Xnor", "Logic", [] { return std::make_unique<XnorNode>(); } },
|
||
// ── Control ─────────────────────────────────────────────────────────────
|
||
{ "Branch", "Control", [] { return std::make_unique<BranchNode>(); } },
|
||
{ "IntBranch", "Control", [] { return std::make_unique<IntBranchNode>(); } },
|
||
// ── Query ───────────────────────────────────────────────────────────────
|
||
{ "QueryTile", "Query", [] { return std::make_unique<QueryTileNode>(0, -1, 1); } },
|
||
{ "QueryRange", "Query", [] { return std::make_unique<QueryRangeNode>(-1, -1, 1, 1, 1); } },
|
||
{ "QueryDistance", "Query", [] { return std::make_unique<QueryDistanceNode>(1, 4); } },
|
||
{ "QueryLiquid", "Query", [] { return std::make_unique<LiquidNode>(8, 4); } },
|
||
// ── Noise ───────────────────────────────────────────────────────────────
|
||
{ "Random", "Noise", [] { return std::make_unique<RandomNode>(); } },
|
||
{ "PerlinNoise", "Noise", [] { return std::make_unique<PerlinNoiseNode>(0.01f); } },
|
||
{ "SimplexNoise", "Noise", [] { return std::make_unique<SimplexNoiseNode>(0.01f); } },
|
||
{ "CellularNoise", "Noise", [] { return std::make_unique<CellularNoiseNode>(0.01f); } },
|
||
{ "ValueNoise", "Noise", [] { return std::make_unique<ValueNoiseNode>(0.01f); } },
|
||
};
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// GraphTab – all state for one open graph (one browser-style tab)
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
struct GraphTab {
|
||
std::string currentFile;
|
||
|
||
Graph graph;
|
||
std::unordered_map<Graph::NodeID, VisualNode> visualNodes;
|
||
|
||
std::vector<Graph::NodeID> worldOutputPasses;
|
||
GLuint worldOutputTex { 0 };
|
||
bool worldOutputDirty { true };
|
||
bool pendingWorldOutputPos { true };
|
||
|
||
int previewOriginX { 0 };
|
||
int previewOriginY { 0 };
|
||
float previewScale { 1.0f };
|
||
uint64_t previewSeed { 0 };
|
||
|
||
ImNodesEditorContext* imnodesCtx { nullptr };
|
||
|
||
void Init()
|
||
{
|
||
worldOutputPasses = { Graph::INVALID_ID };
|
||
worldOutputTex = MakePreviewTexture();
|
||
imnodesCtx = ImNodes::EditorContextCreate();
|
||
}
|
||
|
||
void Free()
|
||
{
|
||
for (auto& [id, vn] : visualNodes) vn.FreeTex();
|
||
if (worldOutputTex) { glDeleteTextures(1, &worldOutputTex); worldOutputTex = 0; }
|
||
if (imnodesCtx) { ImNodes::EditorContextFree(imnodesCtx); imnodesCtx = nullptr; }
|
||
}
|
||
|
||
std::string Label() const
|
||
{
|
||
if (currentFile.empty()) return "Untitled";
|
||
return std::filesystem::path(currentFile).filename().string();
|
||
}
|
||
};
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// NodeEditorApp
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
class NodeEditorApp {
|
||
public:
|
||
NodeEditorApp()
|
||
{
|
||
NewTab();
|
||
}
|
||
|
||
~NodeEditorApp()
|
||
{
|
||
for (auto& tab : tabs) tab.Free();
|
||
}
|
||
|
||
// ── Public render entry point ─────────────────────────────────────────────
|
||
|
||
void Render()
|
||
{
|
||
// Restore last session written by the ini settings handler.
|
||
if (!pendingLoadRegistry.empty()) {
|
||
LoadSharedRegistry(pendingLoadRegistry);
|
||
pendingLoadRegistry.clear();
|
||
}
|
||
if (!pendingLoadFiles.empty()) {
|
||
for (const auto& f : pendingLoadFiles) {
|
||
auto& cur = Active();
|
||
if (cur.graph.NodeCount() == 0 && cur.currentFile.empty())
|
||
Load(f);
|
||
else { NewTab(); Load(f); }
|
||
}
|
||
pendingLoadFiles.clear();
|
||
if (pendingActiveTab >= 0 && pendingActiveTab < static_cast<int>(tabs.size()))
|
||
requestedTab = activeTab = pendingActiveTab;
|
||
pendingActiveTab = -1;
|
||
}
|
||
|
||
RenderDirtyPreviews();
|
||
|
||
DrawMenuBar();
|
||
|
||
constexpr float kMenuH = 18.0f;
|
||
constexpr float kTabBarH = 24.0f;
|
||
const float kContentY = kMenuH + kTabBarH;
|
||
const float dispW = ImGui::GetIO().DisplaySize.x;
|
||
const float dispH = ImGui::GetIO().DisplaySize.y;
|
||
|
||
// Tab bar strip
|
||
ImGui::SetNextWindowPos(ImVec2(0, kMenuH), ImGuiCond_Always);
|
||
ImGui::SetNextWindowSize(ImVec2(dispW, kTabBarH), ImGuiCond_Always);
|
||
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(4, 3));
|
||
ImGui::Begin("##tabbar", nullptr,
|
||
ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar |
|
||
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize |
|
||
ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoCollapse |
|
||
ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoNav);
|
||
DrawTabBar();
|
||
ImGui::End();
|
||
ImGui::PopStyleVar();
|
||
|
||
ImGui::SetNextWindowPos(ImVec2(0, kContentY), ImGuiCond_Always);
|
||
ImGui::SetNextWindowSize(ImVec2(200, dispH - kContentY), ImGuiCond_Always);
|
||
ImGui::Begin("Settings", nullptr,
|
||
ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
|
||
ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoBringToFrontOnFocus);
|
||
DrawSettingsPanel();
|
||
ImGui::End();
|
||
|
||
ImGui::SetNextWindowPos(ImVec2(200, kContentY), ImGuiCond_Always);
|
||
ImGui::SetNextWindowSize(
|
||
ImVec2(dispW - 200, dispH - kContentY),
|
||
ImGuiCond_Always);
|
||
ImGui::Begin("Node Canvas", nullptr,
|
||
ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove |
|
||
ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoBringToFrontOnFocus |
|
||
ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
|
||
DrawNodeCanvas();
|
||
ImGui::End();
|
||
}
|
||
|
||
private:
|
||
std::vector<GraphTab> tabs;
|
||
int activeTab { 0 };
|
||
int requestedTab { -1 }; // set to trigger programmatic tab switch (one frame)
|
||
|
||
// Shared tile registry — one across all tabs / graph files
|
||
std::vector<TileEntry> sharedRegistry {
|
||
TileEntry{0, "Empty", {30.0f/255.0f, 30.0f/255.0f, 30.0f/255.0f}}
|
||
};
|
||
std::string sharedRegistryPath;
|
||
|
||
// Pending data from ini settings handler
|
||
std::vector<std::string> pendingLoadFiles;
|
||
int pendingActiveTab { -1 };
|
||
std::string pendingLoadRegistry;
|
||
|
||
GraphTab& Active() { return tabs[activeTab]; }
|
||
|
||
// ── Tab management ────────────────────────────────────────────────────────
|
||
|
||
void NewTab()
|
||
{
|
||
tabs.emplace_back();
|
||
tabs.back().Init();
|
||
requestedTab = activeTab = static_cast<int>(tabs.size()) - 1;
|
||
}
|
||
|
||
void CloseTab(int idx)
|
||
{
|
||
tabs[idx].Free();
|
||
tabs.erase(tabs.begin() + idx);
|
||
if (tabs.empty()) { NewTab(); return; }
|
||
if (activeTab >= static_cast<int>(tabs.size()))
|
||
activeTab = static_cast<int>(tabs.size()) - 1;
|
||
requestedTab = activeTab;
|
||
}
|
||
|
||
void DrawTabBar()
|
||
{
|
||
ImGuiTabBarFlags flags = ImGuiTabBarFlags_Reorderable |
|
||
ImGuiTabBarFlags_AutoSelectNewTabs;
|
||
if (ImGui::BeginTabBar("##maintabs", flags)) {
|
||
for (int i = 0; i < static_cast<int>(tabs.size()); ++i) {
|
||
bool open = true;
|
||
std::string label = tabs[i].Label() + "##tab" + std::to_string(i);
|
||
ImGuiTabItemFlags itemFlags = (requestedTab == i)
|
||
? ImGuiTabItemFlags_SetSelected : ImGuiTabItemFlags_None;
|
||
if (ImGui::BeginTabItem(label.c_str(), &open, itemFlags)) {
|
||
activeTab = i;
|
||
ImGui::EndTabItem();
|
||
}
|
||
if (!open) {
|
||
CloseTab(i);
|
||
break; // vector modified — restart next frame
|
||
}
|
||
}
|
||
if (ImGui::TabItemButton("+",
|
||
ImGuiTabItemFlags_Trailing | ImGuiTabItemFlags_NoTooltip))
|
||
NewTab();
|
||
ImGui::EndTabBar();
|
||
}
|
||
requestedTab = -1;
|
||
}
|
||
|
||
// ── Preview rendering ─────────────────────────────────────────────────────
|
||
|
||
void RenderDirtyPreviews()
|
||
{
|
||
auto& tab = Active();
|
||
std::array<uint8_t, PREVIEW_SIZE * PREVIEW_SIZE * 4> pixels;
|
||
|
||
// Per-node previews (evaluate single node across a grid).
|
||
for (auto& [id, vn] : tab.visualNodes) {
|
||
if (!vn.dirty) continue;
|
||
vn.dirty = false;
|
||
|
||
Node* node = tab.graph.GetNode(id);
|
||
if (!node) continue;
|
||
|
||
for (int py = 0; py < PREVIEW_SIZE; ++py) {
|
||
for (int px = 0; px < PREVIEW_SIZE; ++px) {
|
||
EvalContext ctx;
|
||
ctx.worldX = tab.previewOriginX + static_cast<int>(px * tab.previewScale);
|
||
ctx.worldY = tab.previewOriginY + static_cast<int>((PREVIEW_SIZE - 1 - py) * tab.previewScale);
|
||
ctx.seed = tab.previewSeed;
|
||
|
||
Value v = tab.graph.Evaluate(id, ctx);
|
||
int base = (py * PREVIEW_SIZE + px) * 4;
|
||
ValueToRGBA(v, &sharedRegistry,
|
||
pixels[base], pixels[base+1], pixels[base+2], pixels[base+3]);
|
||
}
|
||
}
|
||
|
||
glBindTexture(GL_TEXTURE_2D, vn.tex);
|
||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PREVIEW_SIZE, PREVIEW_SIZE,
|
||
0, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
|
||
}
|
||
|
||
// World Output preview — runs GenerateChunk with all connected passes.
|
||
if (tab.worldOutputDirty) {
|
||
tab.worldOutputDirty = false;
|
||
|
||
std::vector<GenerationPass> passes;
|
||
for (auto nodeID : tab.worldOutputPasses) {
|
||
if (nodeID != Graph::INVALID_ID && tab.graph.GetNode(nodeID))
|
||
passes.push_back({ tab.graph, nodeID });
|
||
}
|
||
|
||
if (passes.empty()) {
|
||
pixels.fill(30);
|
||
for (int i = 3; i < (int)pixels.size(); i += 4) pixels[i] = 255;
|
||
} else {
|
||
TileGrid chunk = GenerateChunk(passes,
|
||
tab.previewOriginX, tab.previewOriginY,
|
||
PREVIEW_SIZE, PREVIEW_SIZE,
|
||
tab.previewSeed);
|
||
|
||
for (int py = 0; py < PREVIEW_SIZE; ++py) {
|
||
for (int px = 0; px < PREVIEW_SIZE; ++px) {
|
||
int32_t tileID = chunk.Get(tab.previewOriginX + px, tab.previewOriginY + (PREVIEW_SIZE - 1 - py));
|
||
int base = (py * PREVIEW_SIZE + px) * 4;
|
||
Value v = Value::MakeInt(tileID);
|
||
ValueToRGBA(v, &sharedRegistry,
|
||
pixels[base], pixels[base+1], pixels[base+2], pixels[base+3]);
|
||
}
|
||
}
|
||
}
|
||
|
||
glBindTexture(GL_TEXTURE_2D, tab.worldOutputTex);
|
||
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PREVIEW_SIZE, PREVIEW_SIZE,
|
||
0, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data());
|
||
}
|
||
}
|
||
|
||
void MarkAllDirty()
|
||
{
|
||
for (auto& [id, vn] : Active().visualNodes) vn.dirty = true;
|
||
Active().worldOutputDirty = true;
|
||
}
|
||
|
||
// ── UI drawing ────────────────────────────────────────────────────────────
|
||
|
||
void DrawMenuBar()
|
||
{
|
||
if (!ImGui::BeginMainMenuBar()) return;
|
||
if (ImGui::BeginMenu("File")) {
|
||
if (ImGui::MenuItem("New", "Ctrl+N")) { NewTab(); }
|
||
if (ImGui::MenuItem("Open...", "Ctrl+O")) { OpenFileDialog(); }
|
||
if (ImGui::MenuItem("Close Tab", "Ctrl+W")) { CloseTab(activeTab); }
|
||
if (ImGui::MenuItem("Save", "Ctrl+S")) { SaveCurrent(); }
|
||
if (ImGui::MenuItem("Save As...")) { SaveAsDialog(); }
|
||
ImGui::EndMenu();
|
||
}
|
||
if (!Active().currentFile.empty())
|
||
ImGui::TextDisabled(" %s", Active().currentFile.c_str());
|
||
ImGui::EndMainMenuBar();
|
||
}
|
||
|
||
void DrawSettingsPanel()
|
||
{
|
||
auto& tab = Active();
|
||
|
||
ImGui::SeparatorText("Preview");
|
||
|
||
bool changed = false;
|
||
changed |= ImGui::DragInt("Origin X", &tab.previewOriginX, 1.0f);
|
||
changed |= ImGui::DragInt("Origin Y", &tab.previewOriginY, 1.0f);
|
||
changed |= ImGui::DragFloat("Scale", &tab.previewScale, 0.1f, 0.1f, 64.0f, "%.2f wp/px");
|
||
|
||
int seed32 = static_cast<int>(tab.previewSeed & 0xFFFFFFFFu);
|
||
if (ImGui::DragInt("Seed", &seed32)) {
|
||
tab.previewSeed = static_cast<uint64_t>(static_cast<uint32_t>(seed32));
|
||
changed = true;
|
||
}
|
||
|
||
if (changed) MarkAllDirty();
|
||
|
||
ImGui::Spacing();
|
||
ImGui::SeparatorText("Tile IDs");
|
||
|
||
// Registry file path (read-only display)
|
||
{
|
||
const char* rpath = sharedRegistryPath.empty() ? "(unsaved)" : sharedRegistryPath.c_str();
|
||
ImGui::TextDisabled("%s", rpath);
|
||
}
|
||
if (ImGui::SmallButton("Open##reg")) OpenRegistryDialog();
|
||
ImGui::SameLine();
|
||
if (ImGui::SmallButton("Save##reg"))
|
||
{
|
||
if (sharedRegistryPath.empty()) SaveRegistryDialog();
|
||
else SaveSharedRegistry(sharedRegistryPath);
|
||
}
|
||
ImGui::SameLine();
|
||
if (ImGui::SmallButton("Save As##reg")) SaveRegistryDialog();
|
||
|
||
ImGui::Spacing();
|
||
|
||
int toRemove = -1;
|
||
for (int i = 0; i < static_cast<int>(sharedRegistry.size()); ++i) {
|
||
ImGui::PushID(i);
|
||
TileEntry& entry = sharedRegistry[i];
|
||
|
||
// Color button — opens a popup picker.
|
||
char cpopup[32];
|
||
snprintf(cpopup, sizeof(cpopup), "##cpick%d", i);
|
||
if (ImGui::ColorButton(cpopup,
|
||
ImVec4(entry.color[0], entry.color[1], entry.color[2], 1.0f),
|
||
ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_NoBorder,
|
||
ImVec2(18, 18))) {
|
||
ImGui::OpenPopup(cpopup);
|
||
}
|
||
if (ImGui::BeginPopup(cpopup)) {
|
||
if (ImGui::ColorPicker3("##cp", entry.color,
|
||
ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoSidePreview))
|
||
MarkAllDirty();
|
||
ImGui::EndPopup();
|
||
}
|
||
ImGui::SameLine(0, 3);
|
||
|
||
// ID field (narrow) — locked for the reserved Empty entry
|
||
ImGui::BeginDisabled(entry.id == 0);
|
||
ImGui::SetNextItemWidth(32);
|
||
ImGui::DragInt("##tid", &entry.id, 1, 0, 9999);
|
||
ImGui::EndDisabled();
|
||
ImGui::SameLine(0, 3);
|
||
|
||
// Name field (fills remaining width minus remove button)
|
||
ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x - 20);
|
||
char buf[64];
|
||
strncpy(buf, entry.name.c_str(), sizeof(buf) - 1);
|
||
buf[sizeof(buf) - 1] = '\0';
|
||
if (ImGui::InputText("##tname", buf, sizeof(buf)))
|
||
entry.name = buf;
|
||
ImGui::SameLine(0, 3);
|
||
|
||
// ID 0 "Empty" is permanent — show a disabled remove button
|
||
ImGui::BeginDisabled(entry.id == 0);
|
||
if (ImGui::SmallButton("x"))
|
||
toRemove = i;
|
||
ImGui::EndDisabled();
|
||
|
||
ImGui::PopID();
|
||
}
|
||
if (toRemove >= 0)
|
||
sharedRegistry.erase(sharedRegistry.begin() + toRemove);
|
||
|
||
if (ImGui::SmallButton("+ Add Tile")) {
|
||
int32_t nextId = sharedRegistry.empty() ? 1
|
||
: sharedRegistry.back().id + 1;
|
||
TileEntry entry;
|
||
entry.id = nextId;
|
||
entry.name = "Tile";
|
||
// Seed the default color from the hash so new tiles start distinct.
|
||
uint8_t hr, hg, hb;
|
||
uint32_t h = static_cast<uint32_t>(nextId) * 2654435761u;
|
||
HsvToRgb((h & 0xFFu) / 255.0f, 0.7f, 0.85f, hr, hg, hb);
|
||
entry.color[0] = hr / 255.0f;
|
||
entry.color[1] = hg / 255.0f;
|
||
entry.color[2] = hb / 255.0f;
|
||
sharedRegistry.push_back(entry);
|
||
}
|
||
|
||
ImGui::Spacing();
|
||
ImGui::SeparatorText("World Output");
|
||
|
||
int connected = 0;
|
||
for (auto id : tab.worldOutputPasses)
|
||
if (id != Graph::INVALID_ID) ++connected;
|
||
ImGui::Text("%d / %zu pass(es) connected", connected, tab.worldOutputPasses.size());
|
||
|
||
ImGui::Spacing();
|
||
ImGui::SeparatorText("Graph");
|
||
ImGui::Text("%zu nodes", tab.graph.NodeCount());
|
||
|
||
ImGui::Spacing();
|
||
ImGui::SeparatorText("Help");
|
||
ImGui::TextWrapped(
|
||
"Right-click canvas to add nodes.\n"
|
||
"Drag an output pin into a World Output pass slot to register a generation pass.\n"
|
||
"Delete key removes selected nodes.\n"
|
||
"Scale controls per-node previews only; World Output always shows 1 tile/pixel.\n"
|
||
"\nQuery nodes preview blank (no prev-pass data in per-node preview)."
|
||
);
|
||
}
|
||
|
||
void DrawNodeCanvas()
|
||
{
|
||
auto& tab = Active();
|
||
|
||
// Switch to this tab's imnodes context before any ImNodes:: calls.
|
||
ImNodes::EditorContextSet(tab.imnodesCtx);
|
||
|
||
// Position World Output node on first frame (or after load with no saved pos).
|
||
if (tab.pendingWorldOutputPos) {
|
||
tab.pendingWorldOutputPos = false;
|
||
ImNodes::SetNodeGridSpacePos(WORLD_OUTPUT_IMNODES_ID, ImVec2(400.0f, 0.0f));
|
||
}
|
||
|
||
// IsLinkHovered must be called outside BeginNodeEditor/EndNodeEditor.
|
||
// s_linkWasHovered carries the previous frame's result so the canvas
|
||
// right-click menu can be suppressed when the cursor is over a link.
|
||
static bool s_linkWasHovered = false;
|
||
|
||
ImNodes::BeginNodeEditor();
|
||
|
||
// Right-click blank canvas → add node menu
|
||
if (ImGui::IsWindowHovered(ImGuiFocusedFlags_RootAndChildWindows) &&
|
||
ImNodes::IsEditorHovered() &&
|
||
ImGui::IsMouseReleased(ImGuiMouseButton_Right) &&
|
||
!ImGui::IsAnyItemHovered() &&
|
||
!s_linkWasHovered)
|
||
{
|
||
ImGui::OpenPopup("##add_node_menu");
|
||
}
|
||
|
||
ImGui::SetNextWindowSize(ImVec2(220, 300), ImGuiCond_Always);
|
||
if (ImGui::BeginPopup("##add_node_menu")) {
|
||
ImVec2 spawnPos = ImGui::GetMousePosOnOpeningCurrentPopup();
|
||
|
||
static char filterBuf[128] = "";
|
||
if (ImGui::IsWindowAppearing()) {
|
||
ImGui::SetKeyboardFocusHere();
|
||
filterBuf[0] = '\0';
|
||
}
|
||
ImGui::SetNextItemWidth(-1);
|
||
ImGui::InputText("##filter", filterBuf, sizeof(filterBuf));
|
||
ImGui::Separator();
|
||
|
||
const bool filtering = filterBuf[0] != '\0';
|
||
|
||
auto spawnItem = [&](const NodeMenuItem& item) {
|
||
if (ImGui::MenuItem(item.label)) {
|
||
Graph::NodeID newId = AddNode(item.create());
|
||
ImNodes::SetNodeScreenSpacePos(static_cast<int>(newId), spawnPos);
|
||
ImGui::CloseCurrentPopup();
|
||
}
|
||
};
|
||
|
||
// Scrollable list region — fills the remaining space below the filter.
|
||
ImGui::BeginChild("##node_list", ImVec2(0, 0), false);
|
||
|
||
if (filtering) {
|
||
// Case-insensitive flat list — matches label or category name.
|
||
std::string needle = filterBuf;
|
||
for (char& c : needle) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
|
||
|
||
for (const auto& item : NODE_MENU) {
|
||
auto contains = [&](const char* s) {
|
||
std::string hay = s;
|
||
for (char& c : hay) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
|
||
return hay.find(needle) != std::string::npos;
|
||
};
|
||
if (contains(item.label) || contains(item.category))
|
||
spawnItem(item);
|
||
}
|
||
} else {
|
||
// Tree view grouped by category, all expanded by default.
|
||
const char* curCat = nullptr;
|
||
bool catOpen = false;
|
||
for (const auto& item : NODE_MENU) {
|
||
if (!curCat || strcmp(curCat, item.category) != 0) {
|
||
if (curCat && catOpen) ImGui::TreePop();
|
||
catOpen = ImGui::TreeNodeEx(item.category, ImGuiTreeNodeFlags_DefaultOpen);
|
||
curCat = item.category;
|
||
}
|
||
if (catOpen)
|
||
spawnItem(item);
|
||
}
|
||
if (curCat && catOpen) ImGui::TreePop();
|
||
}
|
||
|
||
ImGui::EndChild();
|
||
ImGui::EndPopup();
|
||
}
|
||
|
||
// Draw the permanent World Output node first (so it's rendered behind others).
|
||
DrawWorldOutputNode();
|
||
|
||
// Draw all regular nodes.
|
||
for (auto& [id, vn] : tab.visualNodes)
|
||
DrawNode(vn);
|
||
|
||
// Draw regular graph connections.
|
||
int linkId = 0;
|
||
for (auto& [id, vn] : tab.visualNodes) {
|
||
Node* node = tab.graph.GetNode(id);
|
||
if (!node) continue;
|
||
for (int slot = 0; slot < static_cast<int>(node->GetInputCount()); ++slot) {
|
||
auto src = tab.graph.GetInput(id, slot);
|
||
if (src.has_value())
|
||
ImNodes::Link(linkId++, OutputPin(*src), InputPin(id, slot));
|
||
}
|
||
}
|
||
|
||
// Draw World Output pass connections (fixed link IDs avoid re-enumeration issues).
|
||
for (int i = 0; i < static_cast<int>(tab.worldOutputPasses.size()); ++i) {
|
||
if (tab.worldOutputPasses[i] != Graph::INVALID_ID)
|
||
ImNodes::Link(WORLD_OUTPUT_LINK_BASE + i,
|
||
OutputPin(tab.worldOutputPasses[i]),
|
||
WORLD_OUTPUT_PIN_BASE + i);
|
||
}
|
||
|
||
ImNodes::EndNodeEditor();
|
||
|
||
// Query link hover state here — must be outside Begin/End editor.
|
||
int hoveredLink = -1;
|
||
bool linkIsHovered = ImNodes::IsLinkHovered(&hoveredLink);
|
||
s_linkWasHovered = linkIsHovered;
|
||
|
||
// ── Handle new connections ────────────────────────────────────────────
|
||
|
||
int fromAttr, toAttr;
|
||
if (ImNodes::IsLinkCreated(&fromAttr, &toAttr)) {
|
||
bool fromIsWO = IsWorldOutputPin(fromAttr);
|
||
bool toIsWO = IsWorldOutputPin(toAttr);
|
||
|
||
if (toIsWO || fromIsWO) {
|
||
// One end is a World Output pass slot; the other must be a regular output.
|
||
int woPin = toIsWO ? toAttr : fromAttr;
|
||
int regularPin = toIsWO ? fromAttr : toAttr;
|
||
|
||
if (PinToSlot(regularPin) == 9) { // must be an output pin
|
||
int passIdx = woPin - WORLD_OUTPUT_PIN_BASE;
|
||
if (passIdx >= 0 && passIdx < static_cast<int>(tab.worldOutputPasses.size())) {
|
||
// World Output only accepts Int (tile ID) outputs.
|
||
Node* srcNode = tab.graph.GetNode(PinToNode(regularPin));
|
||
if (srcNode && srcNode->GetOutputType() == Type::Int) {
|
||
tab.worldOutputPasses[passIdx] = PinToNode(regularPin);
|
||
tab.worldOutputDirty = true;
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
// Regular node-to-node connection.
|
||
Graph::NodeID fromNode, toNode;
|
||
int toSlot;
|
||
if (PinToSlot(fromAttr) == 9 && PinToSlot(toAttr) != 9) {
|
||
fromNode = PinToNode(fromAttr);
|
||
toNode = PinToNode(toAttr);
|
||
toSlot = PinToSlot(toAttr);
|
||
} else if (PinToSlot(toAttr) == 9 && PinToSlot(fromAttr) != 9) {
|
||
fromNode = PinToNode(toAttr);
|
||
toNode = PinToNode(fromAttr);
|
||
toSlot = PinToSlot(fromAttr);
|
||
} else {
|
||
goto done_link;
|
||
}
|
||
// Only connect when output type matches the destination input type.
|
||
Node* srcNode = tab.graph.GetNode(fromNode);
|
||
Node* dstNode = tab.graph.GetNode(toNode);
|
||
if (srcNode && dstNode) {
|
||
auto dstInputTypes = dstNode->GetInputTypes();
|
||
if (toSlot < static_cast<int>(dstInputTypes.size()) &&
|
||
srcNode->GetOutputType() == dstInputTypes[toSlot])
|
||
{
|
||
if (tab.graph.Connect(fromNode, toNode, toSlot))
|
||
MarkAllDirty();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
done_link:;
|
||
|
||
// ── Handle link deletion ──────────────────────────────────────────────
|
||
|
||
auto destroyLink = [&](int linkId) {
|
||
if (linkId >= WORLD_OUTPUT_LINK_BASE) {
|
||
int passIdx = linkId - WORLD_OUTPUT_LINK_BASE;
|
||
if (passIdx >= 0 && passIdx < static_cast<int>(tab.worldOutputPasses.size())) {
|
||
tab.worldOutputPasses[passIdx] = Graph::INVALID_ID;
|
||
tab.worldOutputDirty = true;
|
||
}
|
||
} else {
|
||
// Regular link — re-enumerate to find which one.
|
||
int idx = 0;
|
||
bool found = false;
|
||
for (auto& [id, vn] : tab.visualNodes) {
|
||
if (found) break;
|
||
Node* node = tab.graph.GetNode(id);
|
||
if (!node) continue;
|
||
for (int slot = 0; slot < static_cast<int>(node->GetInputCount()); ++slot) {
|
||
if (tab.graph.GetInput(id, slot).has_value()) {
|
||
if (idx == linkId) {
|
||
tab.graph.Disconnect(id, slot);
|
||
MarkAllDirty();
|
||
found = true;
|
||
break;
|
||
}
|
||
++idx;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
int destroyedLink;
|
||
if (ImNodes::IsLinkDestroyed(&destroyedLink))
|
||
destroyLink(destroyedLink);
|
||
|
||
// ── Right-click a link → disconnect popup ─────────────────────────────
|
||
|
||
static int s_rightClickedLink = -1;
|
||
if (linkIsHovered && ImGui::IsMouseReleased(ImGuiMouseButton_Right)) {
|
||
s_rightClickedLink = hoveredLink;
|
||
ImGui::OpenPopup("##link_ctx");
|
||
}
|
||
if (ImGui::BeginPopup("##link_ctx")) {
|
||
if (ImGui::MenuItem("Disconnect") && s_rightClickedLink >= 0) {
|
||
destroyLink(s_rightClickedLink);
|
||
s_rightClickedLink = -1;
|
||
}
|
||
ImGui::EndPopup();
|
||
}
|
||
|
||
// ── Delete selected nodes ─────────────────────────────────────────────
|
||
|
||
if (ImGui::IsKeyPressed(ImGuiKey_Delete)) {
|
||
int count = ImNodes::NumSelectedNodes();
|
||
if (count > 0) {
|
||
std::vector<int> selected(count);
|
||
ImNodes::GetSelectedNodes(selected.data());
|
||
for (int sid : selected) {
|
||
if (sid == WORLD_OUTPUT_IMNODES_ID) continue; // permanent node
|
||
|
||
Graph::NodeID gid = static_cast<Graph::NodeID>(sid);
|
||
|
||
// Clear any World Output pass that referenced this node.
|
||
for (auto& pass : tab.worldOutputPasses)
|
||
if (pass == gid) { pass = Graph::INVALID_ID; tab.worldOutputDirty = true; }
|
||
|
||
tab.graph.RemoveNode(gid);
|
||
auto it = tab.visualNodes.find(gid);
|
||
if (it != tab.visualNodes.end()) {
|
||
it->second.FreeTex();
|
||
tab.visualNodes.erase(it);
|
||
}
|
||
}
|
||
MarkAllDirty();
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── World Output node ─────────────────────────────────────────────────────
|
||
|
||
void DrawWorldOutputNode()
|
||
{
|
||
auto& tab = Active();
|
||
|
||
ImNodes::PushColorStyle(ImNodesCol_TitleBar, IM_COL32( 30, 80, 160, 255));
|
||
ImNodes::PushColorStyle(ImNodesCol_TitleBarHovered, IM_COL32( 45, 100, 190, 255));
|
||
ImNodes::PushColorStyle(ImNodesCol_TitleBarSelected, IM_COL32( 60, 120, 210, 255));
|
||
|
||
ImNodes::BeginNode(WORLD_OUTPUT_IMNODES_ID);
|
||
|
||
ImNodes::BeginNodeTitleBar();
|
||
ImGui::Text("World Output");
|
||
ImNodes::EndNodeTitleBar();
|
||
|
||
// One input pin per generation pass — Int only.
|
||
for (int i = 0; i < static_cast<int>(tab.worldOutputPasses.size()); ++i) {
|
||
ImNodes::PushColorStyle(ImNodesCol_Pin, PinColor(Type::Int));
|
||
ImNodes::PushColorStyle(ImNodesCol_PinHovered, PinColorHovered(Type::Int));
|
||
ImNodes::BeginInputAttribute(WORLD_OUTPUT_PIN_BASE + i);
|
||
Graph::NodeID connected = tab.worldOutputPasses[i];
|
||
if (connected != Graph::INVALID_ID) {
|
||
Node* n = tab.graph.GetNode(connected);
|
||
ImGui::Text("Pass %d (%s)", i, n ? n->GetName().c_str() : "?");
|
||
} else {
|
||
ImGui::TextDisabled("Pass %d (empty)", i);
|
||
}
|
||
ImNodes::EndInputAttribute();
|
||
ImNodes::PopColorStyle();
|
||
ImNodes::PopColorStyle();
|
||
}
|
||
|
||
// Add / remove pass buttons.
|
||
ImNodes::BeginStaticAttribute(WORLD_OUTPUT_PIN_BASE + 500);
|
||
if (ImGui::SmallButton("+ Pass")) {
|
||
tab.worldOutputPasses.push_back(Graph::INVALID_ID);
|
||
}
|
||
if (tab.worldOutputPasses.size() > 1) {
|
||
ImGui::SameLine();
|
||
if (ImGui::SmallButton("- Pass")) {
|
||
tab.worldOutputPasses.pop_back();
|
||
tab.worldOutputDirty = true;
|
||
}
|
||
}
|
||
ImNodes::EndStaticAttribute();
|
||
|
||
// Generated chunk preview — always 1 tile per pixel.
|
||
ImGui::Image(
|
||
static_cast<ImTextureID>(static_cast<uint64_t>(tab.worldOutputTex)),
|
||
ImVec2(PREVIEW_SIZE * FINAL_PREVIEW_SCALE, PREVIEW_SIZE * FINAL_PREVIEW_SCALE));
|
||
|
||
ImNodes::EndNode();
|
||
|
||
ImNodes::PopColorStyle();
|
||
ImNodes::PopColorStyle();
|
||
ImNodes::PopColorStyle();
|
||
}
|
||
|
||
// ── Regular node ─────────────────────────────────────────────────────────
|
||
|
||
void DrawNode(VisualNode& vn)
|
||
{
|
||
auto& tab = Active();
|
||
Node* node = tab.graph.GetNode(vn.id);
|
||
if (!node) return;
|
||
|
||
ImNodes::BeginNode(static_cast<int>(vn.id));
|
||
|
||
ImNodes::BeginNodeTitleBar();
|
||
ImGui::Text("%s", node->GetName().c_str());
|
||
ImNodes::EndNodeTitleBar();
|
||
|
||
// Output pin
|
||
ImNodes::PushColorStyle(ImNodesCol_Pin, PinColor(node->GetOutputType()));
|
||
ImNodes::PushColorStyle(ImNodesCol_PinHovered, PinColorHovered(node->GetOutputType()));
|
||
ImNodes::BeginOutputAttribute(OutputPin(vn.id));
|
||
const char* outType = node->GetOutputType() == Type::Float ? "Float"
|
||
: node->GetOutputType() == Type::Int ? "Int" : "Bool";
|
||
ImGui::Text("out (%s)", outType);
|
||
ImNodes::EndOutputAttribute();
|
||
ImNodes::PopColorStyle();
|
||
ImNodes::PopColorStyle();
|
||
|
||
// Input pins.
|
||
auto inputTypes = node->GetInputTypes();
|
||
for (int slot = 0; slot < static_cast<int>(inputTypes.size()); ++slot) {
|
||
ImNodes::PushColorStyle(ImNodesCol_Pin, PinColor(inputTypes[slot]));
|
||
ImNodes::PushColorStyle(ImNodesCol_PinHovered, PinColorHovered(inputTypes[slot]));
|
||
ImNodes::BeginInputAttribute(InputPin(vn.id, slot));
|
||
const char* t = inputTypes[slot] == Type::Float ? "f"
|
||
: inputTypes[slot] == Type::Int ? "i" : "b";
|
||
ImGui::TextDisabled("[%s] in%d", t, slot);
|
||
ImNodes::EndInputAttribute();
|
||
ImNodes::PopColorStyle();
|
||
ImNodes::PopColorStyle();
|
||
}
|
||
|
||
DrawNodeParams(vn.id, node);
|
||
|
||
ImGui::Image(
|
||
static_cast<ImTextureID>(static_cast<uint64_t>(vn.tex)),
|
||
ImVec2(PREVIEW_SIZE * PREVIEW_SCALE, PREVIEW_SIZE * PREVIEW_SCALE));
|
||
|
||
ImNodes::EndNode();
|
||
}
|
||
|
||
// ── Per-type param drawers ────────────────────────────────────────────────
|
||
// Each function receives the app (for instance state like tileRegistry) and
|
||
// the node, and returns true when any value changed.
|
||
// Static member functions can access private members through the app ref.
|
||
//
|
||
// To support a new node type:
|
||
// 1. Add a Draw*Params function here.
|
||
// 2. Register it in the kDrawers table in DrawNodeParams below.
|
||
|
||
static bool DrawConstantParams(NodeEditorApp& /*app*/, Node* node)
|
||
{
|
||
auto* n = static_cast<ConstantNode*>(node);
|
||
ImGui::SetNextItemWidth(80);
|
||
return ImGui::DragFloat("##val", &n->value, 0.01f);
|
||
}
|
||
|
||
static bool DrawIDDropdown(const char* label, NodeEditorApp& app, int& currentID)
|
||
{
|
||
auto& reg = app.sharedRegistry;
|
||
int selIdx = -1;
|
||
bool changed = false;
|
||
for (int i = 0; i < static_cast<int>(reg.size()); ++i)
|
||
if (reg[i].id == currentID) { selIdx = i; break; }
|
||
const char* preview = selIdx >= 0 ? reg[selIdx].name.c_str() : "???";
|
||
ImGui::SetNextItemWidth(80);
|
||
if (ImGui::BeginCombo(label, preview)) {
|
||
for (int i = 0; i < static_cast<int>(reg.size()); ++i) {
|
||
bool sel = (i == selIdx);
|
||
char label[80];
|
||
snprintf(label, sizeof(label), "%s (%d)",
|
||
reg[i].name.c_str(), reg[i].id);
|
||
if (ImGui::Selectable(label, sel)) {
|
||
currentID = reg[i].id;
|
||
changed = true;
|
||
}
|
||
if (sel) ImGui::SetItemDefaultFocus();
|
||
}
|
||
ImGui::EndCombo();
|
||
}
|
||
return changed;
|
||
}
|
||
|
||
static bool DrawIDParams(NodeEditorApp& app, Node* node)
|
||
{
|
||
auto* n = static_cast<IDNode*>(node);
|
||
auto& reg = app.sharedRegistry;
|
||
bool changed = false;
|
||
if (reg.empty()) {
|
||
changed = ImGui::DragInt("##id", &n->tileID, 1, 0, 9999);
|
||
} else {
|
||
changed |= DrawIDDropdown("##id", app, n->tileID);
|
||
}
|
||
return changed;
|
||
}
|
||
|
||
static bool DrawQueryTileParams(NodeEditorApp& app, Node* node)
|
||
{
|
||
auto* n = static_cast<QueryTileNode*>(node);
|
||
bool changed = false;
|
||
ImGui::Text("relative offset");
|
||
ImGui::PushItemWidth(70);
|
||
changed |= ImGui::DragInt("##ox", &n->offsetX, 1);
|
||
ImGui::SameLine();
|
||
changed |= ImGui::DragInt("##oy", &n->offsetY, 1);
|
||
// TODO: it would be best if this is a dropdown of tile ids that the user can choose from
|
||
ImGui::Text("Tile ID");
|
||
changed |= DrawIDDropdown("##eid", app, n->expectedID);
|
||
ImGui::PopItemWidth();
|
||
return changed;
|
||
}
|
||
|
||
static bool DrawQueryRangeParams(NodeEditorApp& app, Node* node)
|
||
{
|
||
auto* n = static_cast<QueryRangeNode*>(node);
|
||
bool changed = false;
|
||
ImGui::PushItemWidth(70);
|
||
ImGui::Text("min x -> max x");
|
||
changed |= ImGui::DragInt("##mnx", &n->minX, 1);
|
||
ImGui::SameLine();
|
||
changed |= ImGui::DragInt("##mxx", &n->maxX, 1);
|
||
ImGui::Text("min y -> max y");
|
||
changed |= ImGui::DragInt("##mny", &n->minY, 1);
|
||
ImGui::SameLine();
|
||
changed |= ImGui::DragInt("##mxy", &n->maxY, 1);
|
||
changed |= DrawIDDropdown("##rtid", app, n->tileID);
|
||
ImGui::PopItemWidth();
|
||
return changed;
|
||
}
|
||
|
||
static bool DrawQueryDistanceParams(NodeEditorApp& app, Node* node)
|
||
{
|
||
auto* n = static_cast<QueryDistanceNode*>(node);
|
||
bool changed = false;
|
||
ImGui::PushItemWidth(70);
|
||
changed |= DrawIDDropdown("##dtid", app, n->tileID);
|
||
changed |= ImGui::DragInt("##md", &n->maxDistance, 1, 1, 32);
|
||
ImGui::PopItemWidth();
|
||
return changed;
|
||
}
|
||
|
||
static bool DrawLiquidNodeParams(NodeEditorApp& /*app*/, Node* node)
|
||
{
|
||
auto* n = static_cast<LiquidNode*>(node);
|
||
bool changed = false;
|
||
ImGui::PushItemWidth(70);
|
||
ImGui::Text("max width");
|
||
changed |= ImGui::DragInt("##lw", &n->maxWidth, 1, 1, 64);
|
||
ImGui::Text("max depth");
|
||
changed |= ImGui::DragInt("##ld", &n->maxDepth, 1, 1, 64);
|
||
ImGui::PopItemWidth();
|
||
return changed;
|
||
}
|
||
|
||
static bool DrawMapParams(NodeEditorApp& /*app*/, Node* node)
|
||
{
|
||
auto* n = static_cast<MapNode*>(node);
|
||
bool changed = false;
|
||
ImGui::TextDisabled("in");
|
||
ImGui::SetNextItemWidth(70); changed |= ImGui::DragFloat("##mn0", &n->min0, 0.01f, 0.0f, 0.0f, "%.2f");
|
||
ImGui::SameLine(0, 3);
|
||
ImGui::SetNextItemWidth(70); changed |= ImGui::DragFloat("##mx0", &n->max0, 0.01f, 0.0f, 0.0f, "%.2f");
|
||
ImGui::TextDisabled("out");
|
||
ImGui::SetNextItemWidth(70); changed |= ImGui::DragFloat("##mn1", &n->min1, 0.01f, 0.0f, 0.0f, "%.2f");
|
||
ImGui::SameLine(0, 3);
|
||
ImGui::SetNextItemWidth(70); changed |= ImGui::DragFloat("##mx1", &n->max1, 0.01f, 0.0f, 0.0f, "%.2f");
|
||
return changed;
|
||
}
|
||
|
||
// All four noise nodes share the same single-field UI; a common helper
|
||
// avoids repeating the widget call four times.
|
||
static bool DrawFrequencyParam(float& freq)
|
||
{
|
||
ImGui::SetNextItemWidth(80);
|
||
return ImGui::DragFloat("##freq", &freq, 0.0001f, 0.0001f, 10.0f, "%.4f");
|
||
}
|
||
static bool DrawPerlinNoiseParams (NodeEditorApp&, Node* n) { return DrawFrequencyParam(static_cast<PerlinNoiseNode*> (n)->frequency); }
|
||
static bool DrawSimplexNoiseParams (NodeEditorApp&, Node* n) { return DrawFrequencyParam(static_cast<SimplexNoiseNode*> (n)->frequency); }
|
||
static bool DrawCellularNoiseParams(NodeEditorApp&, Node* n) { return DrawFrequencyParam(static_cast<CellularNoiseNode*>(n)->frequency); }
|
||
static bool DrawValueNoiseParams (NodeEditorApp&, Node* n) { return DrawFrequencyParam(static_cast<ValueNoiseNode*> (n)->frequency); }
|
||
|
||
// ── Param dispatcher ──────────────────────────────────────────────────────
|
||
|
||
void DrawNodeParams(Graph::NodeID /*id*/, Node* node)
|
||
{
|
||
using DrawFn = bool(*)(NodeEditorApp&, Node*);
|
||
static const std::unordered_map<std::type_index, DrawFn> kDrawers = {
|
||
{ typeid(ConstantNode), DrawConstantParams },
|
||
{ typeid(IDNode), DrawIDParams },
|
||
{ typeid(QueryTileNode), DrawQueryTileParams },
|
||
{ typeid(QueryRangeNode), DrawQueryRangeParams },
|
||
{ typeid(QueryDistanceNode), DrawQueryDistanceParams },
|
||
{ typeid(LiquidNode), DrawLiquidNodeParams },
|
||
{ typeid(MapNode), DrawMapParams },
|
||
{ typeid(PerlinNoiseNode), DrawPerlinNoiseParams },
|
||
{ typeid(SimplexNoiseNode), DrawSimplexNoiseParams },
|
||
{ typeid(CellularNoiseNode), DrawCellularNoiseParams },
|
||
{ typeid(ValueNoiseNode), DrawValueNoiseParams },
|
||
};
|
||
|
||
auto it = kDrawers.find(typeid(*node));
|
||
if (it != kDrawers.end() && it->second(*this, node))
|
||
MarkAllDirty();
|
||
}
|
||
|
||
// ── Graph management ──────────────────────────────────────────────────────
|
||
|
||
Graph::NodeID AddNode(std::unique_ptr<Node> node)
|
||
{
|
||
auto& tab = Active();
|
||
Graph::NodeID id = tab.graph.AddNode(std::move(node));
|
||
VisualNode vn;
|
||
vn.id = id;
|
||
vn.dirty = true;
|
||
vn.InitTex();
|
||
tab.visualNodes.emplace(id, std::move(vn));
|
||
return id;
|
||
}
|
||
|
||
// ── Serialization ─────────────────────────────────────────────────────────
|
||
|
||
// ── Shared tile registry I/O ──────────────────────────────────────────────
|
||
|
||
void SaveSharedRegistry(const std::string& path)
|
||
{
|
||
nlohmann::json j;
|
||
auto& tiles = j["tiles"] = nlohmann::json::array();
|
||
for (auto& t : sharedRegistry)
|
||
tiles.push_back({ {"id", t.id}, {"name", t.name},
|
||
{"color", { t.color[0], t.color[1], t.color[2] }} });
|
||
std::ofstream f(path);
|
||
if (f) { f << j.dump(2); sharedRegistryPath = path; }
|
||
else fprintf(stderr, "Failed to write registry %s\n", path.c_str());
|
||
}
|
||
|
||
void LoadSharedRegistry(const std::string& path)
|
||
{
|
||
std::ifstream f(path);
|
||
if (!f) { fprintf(stderr, "Cannot open registry %s\n", path.c_str()); return; }
|
||
nlohmann::json j;
|
||
try { j = nlohmann::json::parse(f); }
|
||
catch (...) { fprintf(stderr, "JSON parse error in registry %s\n", path.c_str()); return; }
|
||
|
||
if (!j.contains("tiles") || !j["tiles"].is_array()) return;
|
||
|
||
sharedRegistry.clear();
|
||
for (auto& t : j["tiles"]) {
|
||
TileEntry entry;
|
||
entry.id = t.value("id", 0);
|
||
entry.name = t.value("name", std::string("Tile"));
|
||
if (t.contains("color") && t["color"].size() == 3) {
|
||
entry.color[0] = t["color"][0].get<float>();
|
||
entry.color[1] = t["color"][1].get<float>();
|
||
entry.color[2] = t["color"][2].get<float>();
|
||
}
|
||
sharedRegistry.push_back(entry);
|
||
}
|
||
// Always ensure ID 0 sentinel is present.
|
||
bool hasEmpty = std::any_of(sharedRegistry.begin(), sharedRegistry.end(),
|
||
[](const TileEntry& e) { return e.id == 0; });
|
||
if (!hasEmpty)
|
||
sharedRegistry.insert(sharedRegistry.begin(),
|
||
TileEntry{0, "Empty", {30.0f/255.0f, 30.0f/255.0f, 30.0f/255.0f}});
|
||
|
||
sharedRegistryPath = path;
|
||
MarkAllDirty();
|
||
}
|
||
|
||
void OpenRegistryDialog()
|
||
{
|
||
IGFD::FileDialogConfig cfg;
|
||
cfg.path = sharedRegistryPath.empty() ? "."
|
||
: std::filesystem::path(sharedRegistryPath).parent_path().string();
|
||
ImGuiFileDialog::Instance()->OpenDialog("OpenRegistryDlg", "Open Tile Registry", ".json", cfg);
|
||
}
|
||
|
||
void SaveRegistryDialog()
|
||
{
|
||
IGFD::FileDialogConfig cfg;
|
||
if (!sharedRegistryPath.empty()) {
|
||
std::filesystem::path p(sharedRegistryPath);
|
||
cfg.path = p.parent_path().string();
|
||
cfg.fileName = p.filename().string();
|
||
} else {
|
||
cfg.path = ".";
|
||
cfg.fileName = "tiles.json";
|
||
}
|
||
ImGuiFileDialog::Instance()->OpenDialog("SaveRegistryDlg", "Save Tile Registry", ".json", cfg);
|
||
}
|
||
|
||
void Save(const std::string& path)
|
||
{
|
||
auto& tab = Active();
|
||
ImNodes::EditorContextSet(tab.imnodesCtx);
|
||
|
||
nlohmann::json root;
|
||
root["graph"] = GraphSerializer::ToJson(tab.graph);
|
||
|
||
// Node positions (including World Output).
|
||
nlohmann::json positions = nlohmann::json::object();
|
||
for (auto& [id, vn] : tab.visualNodes) {
|
||
ImVec2 pos = ImNodes::GetNodeGridSpacePos(static_cast<int>(id));
|
||
positions[std::to_string(id)] = { pos.x, pos.y };
|
||
}
|
||
{
|
||
ImVec2 pos = ImNodes::GetNodeGridSpacePos(WORLD_OUTPUT_IMNODES_ID);
|
||
positions["__worldOutput"] = { pos.x, pos.y };
|
||
}
|
||
|
||
root["editor"]["nodePositions"] = positions;
|
||
root["editor"]["seed"] = tab.previewSeed;
|
||
root["editor"]["previewOriginX"] = tab.previewOriginX;
|
||
root["editor"]["previewOriginY"] = tab.previewOriginY;
|
||
root["editor"]["previewScale"] = tab.previewScale;
|
||
|
||
nlohmann::json passes = nlohmann::json::array();
|
||
for (auto id : tab.worldOutputPasses)
|
||
passes.push_back(id);
|
||
root["editor"]["worldOutputPasses"] = passes;
|
||
|
||
std::ofstream f(path);
|
||
if (f) { f << root.dump(2); tab.currentFile = path; }
|
||
else fprintf(stderr, "Failed to write %s\n", path.c_str());
|
||
}
|
||
|
||
void Load(const std::string& path)
|
||
{
|
||
std::ifstream f(path);
|
||
if (!f) { fprintf(stderr, "Cannot open %s\n", path.c_str()); return; }
|
||
|
||
nlohmann::json root;
|
||
try { root = nlohmann::json::parse(f); }
|
||
catch (...) { fprintf(stderr, "JSON parse error in %s\n", path.c_str()); return; }
|
||
|
||
auto newGraph = GraphSerializer::FromJson(root.value("graph", nlohmann::json::object()));
|
||
if (!newGraph) { fprintf(stderr, "Invalid graph in %s\n", path.c_str()); return; }
|
||
|
||
// Reset this tab's graph state in-place.
|
||
auto& tab = Active();
|
||
for (auto& [id, vn] : tab.visualNodes) vn.FreeTex();
|
||
tab.visualNodes.clear();
|
||
tab.graph = Graph{};
|
||
tab.worldOutputPasses = { Graph::INVALID_ID };
|
||
tab.worldOutputDirty = true;
|
||
tab.pendingWorldOutputPos = true;
|
||
tab.currentFile = "";
|
||
|
||
tab.graph = std::move(*newGraph);
|
||
|
||
uint32_t maxId = root["graph"].value("nextId", 1u);
|
||
for (uint32_t id = 1; id < maxId; ++id) {
|
||
if (tab.graph.GetNode(id)) {
|
||
VisualNode vn;
|
||
vn.id = id;
|
||
vn.dirty = true;
|
||
vn.InitTex();
|
||
tab.visualNodes.emplace(id, std::move(vn));
|
||
}
|
||
}
|
||
|
||
if (root.contains("editor")) {
|
||
const auto& ed = root["editor"];
|
||
tab.previewSeed = ed.value("seed", uint64_t{0});
|
||
tab.previewOriginX = ed.value("previewOriginX", 0);
|
||
tab.previewOriginY = ed.value("previewOriginY", 0);
|
||
tab.previewScale = ed.value("previewScale", 1.0f);
|
||
|
||
// Note: "tileRegistry" embedded in old .wge files is intentionally
|
||
// ignored — use the shared tiles.json registry instead.
|
||
|
||
if (ed.contains("worldOutputPasses")) {
|
||
tab.worldOutputPasses.clear();
|
||
for (auto& v : ed["worldOutputPasses"])
|
||
tab.worldOutputPasses.push_back(v.get<Graph::NodeID>());
|
||
if (tab.worldOutputPasses.empty())
|
||
tab.worldOutputPasses.push_back(Graph::INVALID_ID);
|
||
}
|
||
|
||
ImNodes::EditorContextSet(tab.imnodesCtx);
|
||
if (ed.contains("nodePositions")) {
|
||
for (auto& [key, val] : ed["nodePositions"].items()) {
|
||
float x = val[0].get<float>();
|
||
float y = val[1].get<float>();
|
||
if (key == "__worldOutput") {
|
||
ImNodes::SetNodeGridSpacePos(WORLD_OUTPUT_IMNODES_ID, ImVec2(x, y));
|
||
tab.pendingWorldOutputPos = false;
|
||
} else {
|
||
ImNodes::SetNodeGridSpacePos(std::stoi(key), ImVec2(x, y));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
tab.currentFile = path;
|
||
}
|
||
|
||
// ── File dialogs ──────────────────────────────────────────────────────────
|
||
|
||
void OpenFileDialog()
|
||
{
|
||
IGFD::FileDialogConfig cfg;
|
||
const auto& cur = Active();
|
||
cfg.path = cur.currentFile.empty() ? "."
|
||
: std::filesystem::path(cur.currentFile).parent_path().string();
|
||
ImGuiFileDialog::Instance()->OpenDialog("OpenFileDlg", "Open Graph", ".json", cfg);
|
||
}
|
||
|
||
void SaveAsDialog()
|
||
{
|
||
IGFD::FileDialogConfig cfg;
|
||
const auto& cur = Active();
|
||
if (!cur.currentFile.empty()) {
|
||
std::filesystem::path p(cur.currentFile);
|
||
cfg.path = p.parent_path().string();
|
||
cfg.fileName = p.filename().string();
|
||
} else {
|
||
cfg.path = ".";
|
||
cfg.fileName = "graph.json";
|
||
}
|
||
ImGuiFileDialog::Instance()->OpenDialog("SaveFileDlg", "Save Graph", ".json", cfg);
|
||
}
|
||
|
||
void SaveCurrent() { if (Active().currentFile.empty()) SaveAsDialog(); else Save(Active().currentFile); }
|
||
|
||
public:
|
||
void RenderFileDialogs()
|
||
{
|
||
ImVec2 dlgSize(600, 400);
|
||
|
||
if (ImGuiFileDialog::Instance()->Display("OpenFileDlg",
|
||
ImGuiWindowFlags_NoCollapse, dlgSize)) {
|
||
if (ImGuiFileDialog::Instance()->IsOk()) {
|
||
std::string path = ImGuiFileDialog::Instance()->GetFilePathName();
|
||
// If file already open, switch to that tab.
|
||
bool found = false;
|
||
for (int i = 0; i < static_cast<int>(tabs.size()); ++i) {
|
||
if (tabs[i].currentFile == path) {
|
||
requestedTab = activeTab = i;
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!found) {
|
||
// Reuse current tab if it's blank, otherwise open a new tab.
|
||
auto& cur = Active();
|
||
if (cur.graph.NodeCount() > 0 || !cur.currentFile.empty())
|
||
NewTab();
|
||
Load(path);
|
||
}
|
||
}
|
||
ImGuiFileDialog::Instance()->Close();
|
||
}
|
||
|
||
if (ImGuiFileDialog::Instance()->Display("SaveFileDlg",
|
||
ImGuiWindowFlags_NoCollapse, dlgSize)) {
|
||
if (ImGuiFileDialog::Instance()->IsOk())
|
||
Save(ImGuiFileDialog::Instance()->GetFilePathName());
|
||
ImGuiFileDialog::Instance()->Close();
|
||
}
|
||
|
||
if (ImGuiFileDialog::Instance()->Display("OpenRegistryDlg",
|
||
ImGuiWindowFlags_NoCollapse, dlgSize)) {
|
||
if (ImGuiFileDialog::Instance()->IsOk())
|
||
LoadSharedRegistry(ImGuiFileDialog::Instance()->GetFilePathName());
|
||
ImGuiFileDialog::Instance()->Close();
|
||
}
|
||
|
||
if (ImGuiFileDialog::Instance()->Display("SaveRegistryDlg",
|
||
ImGuiWindowFlags_NoCollapse, dlgSize)) {
|
||
if (ImGuiFileDialog::Instance()->IsOk())
|
||
SaveSharedRegistry(ImGuiFileDialog::Instance()->GetFilePathName());
|
||
ImGuiFileDialog::Instance()->Close();
|
||
}
|
||
}
|
||
|
||
void HandleKeyboardShortcuts()
|
||
{
|
||
ImGuiIO& io = ImGui::GetIO();
|
||
if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_S)) SaveCurrent();
|
||
if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_O)) OpenFileDialog();
|
||
if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_N)) NewTab();
|
||
if (io.KeyCtrl && ImGui::IsKeyPressed(ImGuiKey_W)) CloseTab(activeTab);
|
||
}
|
||
|
||
// Registers a custom [NodeEditor][Session] block in imgui.ini that persists
|
||
// all open file paths and the active tab index across sessions.
|
||
// Must be called after ImGui::CreateContext() and before the first ImGui::NewFrame().
|
||
void RegisterSettingsHandler()
|
||
{
|
||
ImGuiSettingsHandler h;
|
||
h.TypeName = "NodeEditor";
|
||
h.TypeHash = ImHashStr("NodeEditor");
|
||
h.UserData = this;
|
||
|
||
// Called when the [NodeEditor][Session] header is found — return non-null
|
||
// to accept the entry and route its lines to ReadLineFn.
|
||
h.ReadOpenFn = [](ImGuiContext*, ImGuiSettingsHandler* handler, const char*) -> void* {
|
||
return handler->UserData;
|
||
};
|
||
|
||
// Called for each key=value line inside the entry.
|
||
h.ReadLineFn = [](ImGuiContext*, ImGuiSettingsHandler*, void* entry, const char* line) {
|
||
auto* app = static_cast<NodeEditorApp*>(entry);
|
||
if (strncmp(line, "LastFiles=", 10) == 0) {
|
||
std::istringstream ss(line + 10);
|
||
std::string file;
|
||
while (std::getline(ss, file, ';'))
|
||
if (!file.empty()) app->pendingLoadFiles.push_back(file);
|
||
}
|
||
if (strncmp(line, "ActiveTab=", 10) == 0)
|
||
app->pendingActiveTab = std::atoi(line + 10);
|
||
if (strncmp(line, "SharedRegistry=", 15) == 0)
|
||
app->pendingLoadRegistry = line + 15;
|
||
};
|
||
|
||
// Called when ImGui writes imgui.ini (periodically and on shutdown).
|
||
h.WriteAllFn = [](ImGuiContext*, ImGuiSettingsHandler* handler, ImGuiTextBuffer* out_buf) {
|
||
auto* app = static_cast<NodeEditorApp*>(handler->UserData);
|
||
std::string files;
|
||
for (auto& tab : app->tabs) {
|
||
if (!tab.currentFile.empty()) {
|
||
if (!files.empty()) files += ";";
|
||
files += tab.currentFile;
|
||
}
|
||
}
|
||
out_buf->appendf("[NodeEditor][Session]\n");
|
||
if (!files.empty()) {
|
||
out_buf->appendf("LastFiles=%s\n", files.c_str());
|
||
out_buf->appendf("ActiveTab=%d\n", app->activeTab);
|
||
}
|
||
if (!app->sharedRegistryPath.empty())
|
||
out_buf->appendf("SharedRegistry=%s\n", app->sharedRegistryPath.c_str());
|
||
out_buf->appendf("\n");
|
||
};
|
||
|
||
ImGui::AddSettingsHandler(&h);
|
||
}
|
||
};
|
||
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
// Main / render loop
|
||
// ─────────────────────────────────────────────────────────────────────────────
|
||
|
||
static void GlfwErrorCallback(int error, const char* desc)
|
||
{
|
||
fprintf(stderr, "GLFW error %d: %s\n", error, desc);
|
||
}
|
||
|
||
int main()
|
||
{
|
||
glfwSetErrorCallback(GlfwErrorCallback);
|
||
if (!glfwInit()) return 1;
|
||
|
||
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
||
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
|
||
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
||
#ifdef __APPLE__
|
||
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
|
||
#endif
|
||
|
||
GLFWwindow* window = glfwCreateWindow(1280, 720, "WorldGraph Node Editor", nullptr, nullptr);
|
||
if (!window) { glfwTerminate(); return 1; }
|
||
|
||
glfwMakeContextCurrent(window);
|
||
glfwSwapInterval(1);
|
||
|
||
IMGUI_CHECKVERSION();
|
||
ImGui::CreateContext();
|
||
ImNodes::CreateContext();
|
||
|
||
ImGuiIO& io = ImGui::GetIO();
|
||
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
|
||
|
||
ImGui::StyleColorsDark();
|
||
ImNodes::StyleColorsDark();
|
||
ImNodes::GetStyle().NodePadding = ImVec2(8, 8);
|
||
|
||
ImGui_ImplGlfw_InitForOpenGL(window, true);
|
||
ImGui_ImplOpenGL3_Init("#version 330");
|
||
|
||
NodeEditorApp app;
|
||
app.RegisterSettingsHandler();
|
||
|
||
while (!glfwWindowShouldClose(window)) {
|
||
glfwPollEvents();
|
||
|
||
ImGui_ImplOpenGL3_NewFrame();
|
||
ImGui_ImplGlfw_NewFrame();
|
||
ImGui::NewFrame();
|
||
|
||
app.HandleKeyboardShortcuts();
|
||
app.Render();
|
||
app.RenderFileDialogs();
|
||
|
||
ImGui::Render();
|
||
|
||
int dispW, dispH;
|
||
glfwGetFramebufferSize(window, &dispW, &dispH);
|
||
glViewport(0, 0, dispW, dispH);
|
||
glClearColor(0.15f, 0.15f, 0.15f, 1.0f);
|
||
glClear(GL_COLOR_BUFFER_BIT);
|
||
|
||
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
|
||
glfwSwapBuffers(window);
|
||
}
|
||
|
||
ImGui_ImplOpenGL3_Shutdown();
|
||
ImGui_ImplGlfw_Shutdown();
|
||
ImNodes::DestroyContext();
|
||
ImGui::DestroyContext();
|
||
glfwDestroyWindow(window);
|
||
glfwTerminate();
|
||
return 0;
|
||
}
|