fn-registry agent
444 lines
19 KiB
C++
444 lines
19 KiB
C++
#include "demos.h"
|
|
#include "demo.h"
|
|
|
|
#include "viz/graph_types.h"
|
|
#include "viz/graph_viewport.h"
|
|
#include "viz/graph_force_layout.h"
|
|
#include "viz/graph_force_layout_gpu.h"
|
|
#include "viz/graph_layouts.h"
|
|
#include "viz/graph_labels.h"
|
|
#include "core/button.h"
|
|
#include "core/tokens.h"
|
|
|
|
#include <imgui.h>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <vector>
|
|
|
|
namespace gallery {
|
|
|
|
// Paleta del demo: 8 colores tipo Mantine. v2.0 los usamos a traves de la
|
|
// tabla EntityType en lugar de escribirlos por nodo. Asi el modelo nuevo
|
|
// queda demostrado tal cual lo van a usar las apps reales (osint_graph,
|
|
// fn_explorer): tabla pequena de tipos + nodos que solo guardan type_id.
|
|
static const uint32_t k_demo_palette[] = {
|
|
0xFFEF8D5Bu, 0xFF8CCA58u, 0xFF3E97F5u, 0xFF5051D9u,
|
|
0xFFE07FB8u, 0xFFCCCD5Fu, 0xFF52CDF2u, 0xFF61D199u,
|
|
};
|
|
static constexpr int k_demo_palette_n =
|
|
sizeof(k_demo_palette) / sizeof(k_demo_palette[0]);
|
|
|
|
// Tabla compartida entre regeneraciones — las apariencias no cambian aunque
|
|
// el usuario regenere el grafo, asi que vive como `static`.
|
|
static EntityType s_demo_entity_types[k_demo_palette_n];
|
|
static RelationType s_demo_relation_types[1];
|
|
static bool s_demo_types_initialized = false;
|
|
|
|
static void init_demo_types() {
|
|
if (s_demo_types_initialized) return;
|
|
for (int k = 0; k < k_demo_palette_n; ++k) {
|
|
s_demo_entity_types[k] = entity_type(k_demo_palette[k],
|
|
SHAPE_CIRCLE, 4.0f, "cluster");
|
|
}
|
|
s_demo_relation_types[0] = relation_type(0xFF888888u, EDGE_SOLID, 1.0f, "default");
|
|
s_demo_types_initialized = true;
|
|
}
|
|
|
|
// Genera un grafo sintetico con N nodos en K clusters. Cada nodo tiene
|
|
// `edges_per_node` aristas intra-cluster + un pct% global inter-cluster.
|
|
// Cluster radio escala con sqrt(N) para que la "nube" no sea siempre el
|
|
// mismo cuadrado de 200 px — a 1M nodos crece a ~6 km de radio en graph
|
|
// space y los nodos pueden esparcirse libremente sin caja artificial.
|
|
static void generate_synthetic_graph(int N, int K,
|
|
int edges_per_node, int inter_pct,
|
|
std::vector<GraphNode>& nodes_out,
|
|
std::vector<GraphEdge>& edges_out) {
|
|
nodes_out.clear();
|
|
edges_out.clear();
|
|
nodes_out.reserve(N);
|
|
edges_out.reserve((size_t)N * (size_t)edges_per_node + (size_t)N * (size_t)inter_pct / 100u);
|
|
|
|
unsigned seed = 0x1234abcd;
|
|
auto rnd = [&]() {
|
|
seed = seed * 1664525u + 1013904223u;
|
|
return static_cast<float>((seed >> 8) & 0xffffff) / 16777216.0f;
|
|
};
|
|
|
|
// Cluster radius y scatter escalan con sqrt(N) para que los nodos no
|
|
// queden empaquetados al subir el slider. A 1M nodes el espacio inicial
|
|
// es ~12k px de lado en lugar de los 280 px hardcoded de antes.
|
|
const float scale = std::sqrt(static_cast<float>(std::max(N, 1)));
|
|
const float cluster_r = 12.0f * scale;
|
|
const float scatter = 4.0f * scale;
|
|
|
|
std::vector<float> cluster_cx(K), cluster_cy(K);
|
|
for (int k = 0; k < K; k++) {
|
|
float angle = 2.0f * 3.14159f * k / K;
|
|
cluster_cx[k] = std::cos(angle) * cluster_r;
|
|
cluster_cy[k] = std::sin(angle) * cluster_r;
|
|
}
|
|
|
|
for (int i = 0; i < N; i++) {
|
|
int k = i % K;
|
|
// type_id mapea al EntityType (k % k_demo_palette_n) que define
|
|
// color y shape. size_override = 3..5 px para conservar la
|
|
// variacion sutil del demo v1 — apariencia visual identica.
|
|
uint16_t tid = static_cast<uint16_t>(k % k_demo_palette_n);
|
|
GraphNode n = graph_node(
|
|
cluster_cx[k] + (rnd() - 0.5f) * scatter,
|
|
cluster_cy[k] + (rnd() - 0.5f) * scatter,
|
|
tid);
|
|
n.size_override = 3.0f + rnd() * 2.0f;
|
|
n.user_data = static_cast<uint64_t>(i);
|
|
nodes_out.push_back(n);
|
|
}
|
|
|
|
auto add_edge = [&](uint32_t a, uint32_t b, float w) {
|
|
if (a == b) return;
|
|
edges_out.push_back(graph_edge(a, b, w));
|
|
};
|
|
int per_cluster = N / K;
|
|
for (int k = 0; k < K; k++) {
|
|
int base = k * per_cluster;
|
|
int end = (k == K - 1) ? N : (base + per_cluster);
|
|
int size = end - base;
|
|
if (size < 2) continue;
|
|
for (int i = base; i < end; i++) {
|
|
for (int e = 0; e < edges_per_node; e++) {
|
|
int j = base + static_cast<int>(rnd() * size);
|
|
add_edge(static_cast<uint32_t>(i),
|
|
static_cast<uint32_t>(j), 1.0f);
|
|
}
|
|
}
|
|
}
|
|
// Inter-cluster: pct% del total de nodos
|
|
long long inter = (long long)N * (long long)inter_pct / 100LL;
|
|
for (long long e = 0; e < inter; e++) {
|
|
uint32_t a = static_cast<uint32_t>(rnd() * N);
|
|
uint32_t b = static_cast<uint32_t>(rnd() * N);
|
|
add_edge(a, b, 0.3f);
|
|
}
|
|
}
|
|
|
|
void demo_graph() {
|
|
demo_header("graph_viewport", "v1.0.0",
|
|
"Pipeline completo de visualizacion de grafos: graph_renderer (instanced GPU) "
|
|
"+ graph_force_layout (Barnes-Hut) + graph_spatial_hash (hit-testing). "
|
|
"Render a FBO mostrado via ImGui::Image — escala a decenas de miles de nodos.");
|
|
|
|
static int s_n_nodes = 1000;
|
|
static int s_n_clusters = 6;
|
|
static int s_edges_per_n = 3; // aristas intra-cluster por nodo
|
|
static int s_inter_pct = 5; // % de nodos para edges inter-cluster
|
|
static float s_repulsion = 3500.0f; // fuerza de dispersion entre nodos
|
|
static float s_attraction = 0.02f; // muelle entre nodos conectados
|
|
static float s_gravity = 0.001f; // tiron hacia el centro
|
|
static std::vector<GraphNode> s_nodes;
|
|
static std::vector<GraphEdge> s_edges;
|
|
static GraphData s_graph{};
|
|
static GraphViewportState s_state;
|
|
static bool s_initialized = false;
|
|
static bool s_needs_regen = true;
|
|
|
|
// GPU layout (issue 0049h): toggle CPU/GPU. ctx se crea perezosamente al
|
|
// primer frame en GPU mode; max_nodes/max_edges se dimensionan al maximo
|
|
// que ofrece el slider (1M nodos x 10 edges/nodo = 10M edges) — los SSBOs
|
|
// ocupan ~80 MB en ese tope, suficientemente barato para no
|
|
// recrear el ctx cada Regenerate. Si compute no esta disponible, el
|
|
// toggle queda deshabilitado.
|
|
static bool s_use_gpu = false;
|
|
static ForceLayoutGPU* s_gpu_ctx = nullptr;
|
|
static bool s_gpu_dirty = true; // re-upload tras regen / cambio
|
|
|
|
// Layout estatico activo (issue 0049i). 0=force (iterativo), 1=grid,
|
|
// 2=circular, 3=radial, 4=hierarchical, 5=fixed.
|
|
static int s_layout_mode = 0;
|
|
const char* k_layout_names[] = {
|
|
"force", "grid", "circular", "radial", "hierarchical", "fixed"
|
|
};
|
|
static int s_apply_layout = 0; // se incrementa cuando hay que reaplicar
|
|
|
|
// Labels (issue 0049j). LabelPolicy controlable desde la UI.
|
|
static graph::LabelPolicy s_label_policy;
|
|
static bool s_labels_enabled = true;
|
|
|
|
if (s_needs_regen) {
|
|
init_demo_types();
|
|
generate_synthetic_graph(s_n_nodes, s_n_clusters,
|
|
s_edges_per_n, s_inter_pct,
|
|
s_nodes, s_edges);
|
|
s_graph.nodes = s_nodes.data();
|
|
s_graph.node_count = static_cast<int>(s_nodes.size());
|
|
s_graph.node_capacity = static_cast<int>(s_nodes.capacity());
|
|
s_graph.edges = s_edges.data();
|
|
s_graph.edge_count = static_cast<int>(s_edges.size());
|
|
s_graph.edge_capacity = static_cast<int>(s_edges.capacity());
|
|
s_graph.types = s_demo_entity_types;
|
|
s_graph.type_count = k_demo_palette_n;
|
|
s_graph.rel_types = s_demo_relation_types;
|
|
s_graph.rel_type_count = 1;
|
|
s_graph.update_bounds();
|
|
s_state.layout_running = true;
|
|
s_state.layout_energy = 0.0f;
|
|
s_needs_regen = false;
|
|
s_initialized = true;
|
|
s_gpu_dirty = true;
|
|
}
|
|
|
|
section("Controls");
|
|
{
|
|
using namespace fn_ui;
|
|
ImGui::PushItemWidth(180);
|
|
// Slider Nodes con escala logaritmica para que sea util tanto a 100
|
|
// como a 1M sin tener que arrastrar 10000px.
|
|
ImGui::SliderInt("Nodes", &s_n_nodes, 100, 1000000, "%d",
|
|
ImGuiSliderFlags_Logarithmic);
|
|
ImGui::SameLine();
|
|
ImGui::SliderInt("Clusters", &s_n_clusters, 2, 16);
|
|
ImGui::SliderInt("Edges/node", &s_edges_per_n, 1, 10);
|
|
ImGui::SameLine();
|
|
ImGui::SliderInt("Inter %", &s_inter_pct, 0, 30, "%d%%");
|
|
ImGui::SliderFloat("Repulsion", &s_repulsion, 100.0f, 20000.0f, "%.0f");
|
|
ImGui::SameLine();
|
|
ImGui::SliderFloat("Attraction", &s_attraction, 0.001f, 0.5f, "%.3f");
|
|
ImGui::SameLine();
|
|
ImGui::SliderFloat("Gravity", &s_gravity, 0.0f, 0.05f, "%.4f");
|
|
ImGui::PopItemWidth();
|
|
|
|
if (button("Regenerate", ButtonVariant::Primary)) s_needs_regen = true;
|
|
ImGui::SameLine();
|
|
if (button(s_state.layout_running ? "Pause layout" : "Resume layout",
|
|
ButtonVariant::Secondary)) {
|
|
s_state.layout_running = !s_state.layout_running;
|
|
}
|
|
ImGui::SameLine();
|
|
if (button("Fit view", ButtonVariant::Subtle)) {
|
|
graph_viewport_fit(s_graph, s_state);
|
|
}
|
|
ImGui::SameLine();
|
|
// Toggle GPU layout. Si compute no esta disponible (Mesa software o
|
|
// driver < 4.3), deshabilitamos visualmente el checkbox.
|
|
bool prev_gpu = s_use_gpu;
|
|
if (s_gpu_ctx == nullptr && s_use_gpu == false) {
|
|
// primera oportunidad: intentar crear el ctx para detectar soporte.
|
|
// Lazy init solo si el usuario lo activa.
|
|
}
|
|
ImGui::Checkbox("GPU layout", &s_use_gpu);
|
|
if (s_use_gpu != prev_gpu) {
|
|
s_gpu_dirty = true; // re-upload al cambiar de modo
|
|
}
|
|
|
|
// Selector de layout (issue 0049i).
|
|
ImGui::PushItemWidth(140);
|
|
int prev_mode = s_layout_mode;
|
|
if (ImGui::Combo("Layout", &s_layout_mode,
|
|
k_layout_names, IM_ARRAYSIZE(k_layout_names))) {
|
|
// Cambio de modo: reaplicar instantaneamente
|
|
s_apply_layout++;
|
|
}
|
|
if (prev_mode != s_layout_mode) {
|
|
// En "force" volvemos a animar; en cualquier estatico paramos.
|
|
s_state.layout_running = (s_layout_mode == 0);
|
|
}
|
|
ImGui::PopItemWidth();
|
|
ImGui::SameLine();
|
|
if (button("Apply layout", ButtonVariant::Subtle)) s_apply_layout++;
|
|
|
|
// --- Labels (issue 0049j) ---------------------------------------
|
|
ImGui::Checkbox("Labels", &s_labels_enabled);
|
|
ImGui::SameLine();
|
|
ImGui::PushItemWidth(140);
|
|
ImGui::SliderInt("Max visible", &s_label_policy.max_visible, 0, 1000);
|
|
ImGui::SameLine();
|
|
ImGui::SliderFloat("Font", &s_label_policy.font_size,
|
|
8.0f, 24.0f, "%.0f");
|
|
ImGui::SameLine();
|
|
ImGui::SliderFloat("Min px", &s_label_policy.min_node_pixel_size,
|
|
0.0f, 40.0f, "%.0f");
|
|
ImGui::PopItemWidth();
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Selected", &s_label_policy.always_for_selected);
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Hovered", &s_label_policy.always_for_hovered);
|
|
ImGui::SameLine();
|
|
ImGui::Checkbox("Pinned", &s_label_policy.always_for_pinned);
|
|
}
|
|
|
|
section("Stats");
|
|
{
|
|
// Una sola linea fija — sin secciones condicionales que cambien la
|
|
// altura del panel (eso provocaba que el viewport saltara al hacer
|
|
// hover/select).
|
|
char hover_buf[32];
|
|
char sel_buf[32];
|
|
if (s_state.hovered_node >= 0) {
|
|
std::snprintf(hover_buf, sizeof(hover_buf), "#%d t%u",
|
|
s_state.hovered_node,
|
|
(unsigned)s_nodes[s_state.hovered_node].type_id);
|
|
} else {
|
|
std::snprintf(hover_buf, sizeof(hover_buf), "-");
|
|
}
|
|
if (s_state.selected_node >= 0) {
|
|
std::snprintf(sel_buf, sizeof(sel_buf), "#%d", s_state.selected_node);
|
|
} else {
|
|
std::snprintf(sel_buf, sizeof(sel_buf), "-");
|
|
}
|
|
ImGui::PushStyleColor(ImGuiCol_Text, fn_tokens::colors::text_muted);
|
|
ImGui::Text("nodes=%d edges=%d energy=%.2f fps=%.0f | hover=%s sel=%s",
|
|
s_graph.node_count, s_graph.edge_count,
|
|
s_state.layout_energy, ImGui::GetIO().Framerate,
|
|
hover_buf, sel_buf);
|
|
ImGui::PopStyleColor();
|
|
}
|
|
|
|
// Aplicar layout estatico cuando se solicita (cambio de modo / boton).
|
|
static int s_last_apply = -1;
|
|
if (s_apply_layout != s_last_apply) {
|
|
s_last_apply = s_apply_layout;
|
|
switch (s_layout_mode) {
|
|
case 1: graph::layout_grid (s_graph, 25.0f); break;
|
|
case 2: graph::layout_circular (s_graph, 200.0f); break;
|
|
case 3: graph::layout_radial (s_graph, 0, 80.0f); break;
|
|
case 4: graph::layout_hierarchical(s_graph, 0, 120.0f, 50.0f); break;
|
|
case 5: graph::layout_fixed (s_graph); break;
|
|
case 0: default:
|
|
// force: dejar las posiciones actuales; el bucle lo refinara
|
|
break;
|
|
}
|
|
s_gpu_dirty = true;
|
|
if (s_layout_mode != 0) graph_viewport_fit(s_graph, s_state);
|
|
}
|
|
|
|
section("Viewport (drag=pan, wheel=zoom, click=select, shift+drag=lasso, ctrl+click=toggle)");
|
|
if (s_initialized) {
|
|
// Avanzamos 1 paso de force layout cada frame mientras layout_running.
|
|
// Auto-pause: si la energia por nodo cae bajo el umbral durante N
|
|
// frames consecutivos, paramos la simulacion automaticamente — el
|
|
// grafo ya esta estable. El usuario lo retoma con "Resume layout"
|
|
// o "Regenerate".
|
|
static int s_low_energy_frames = 0;
|
|
const int k_pause_after_frames = 30;
|
|
const float k_pause_per_node = 0.001f; // umbral de energia/nodo
|
|
if (s_state.layout_running && s_layout_mode == 0) {
|
|
ForceLayoutConfig cfg;
|
|
cfg.repulsion = s_repulsion;
|
|
cfg.attraction = s_attraction;
|
|
cfg.gravity = s_gravity;
|
|
cfg.iterations = 1;
|
|
if (s_use_gpu) {
|
|
if (!s_gpu_ctx) {
|
|
s_gpu_ctx = graph_force_layout_gpu_create(s_graph.node_count + 1024,
|
|
s_graph.edge_count + 1024);
|
|
s_gpu_dirty = true;
|
|
}
|
|
if (s_gpu_ctx) {
|
|
if (s_gpu_dirty) {
|
|
graph_force_layout_gpu_upload(s_gpu_ctx, s_graph);
|
|
s_gpu_dirty = false;
|
|
}
|
|
s_state.layout_energy = graph_force_layout_gpu_step(s_gpu_ctx, cfg);
|
|
graph_force_layout_gpu_readback(s_gpu_ctx, s_graph, /*include_velocities=*/true);
|
|
} else {
|
|
// GPU no disponible: caer a CPU silenciosamente.
|
|
s_use_gpu = false;
|
|
s_state.layout_energy = graph_force_layout_step(s_graph, cfg);
|
|
}
|
|
} else {
|
|
s_state.layout_energy = graph_force_layout_step(s_graph, cfg);
|
|
}
|
|
|
|
const float per_node = s_graph.node_count > 0
|
|
? s_state.layout_energy / (float)s_graph.node_count
|
|
: 0.0f;
|
|
if (per_node < k_pause_per_node) ++s_low_energy_frames;
|
|
else s_low_energy_frames = 0;
|
|
|
|
if (graph_force_layout_should_pause(s_low_energy_frames,
|
|
k_pause_after_frames)) {
|
|
s_state.layout_running = false;
|
|
s_low_energy_frames = 0;
|
|
}
|
|
} else {
|
|
s_low_energy_frames = 0;
|
|
}
|
|
// Callbacks (issue 0049i): right-click abre popup contextual,
|
|
// double-click loguea el indice. Los callbacks corren dentro del
|
|
// frame ImGui — el caller puede usar OpenPopup directamente.
|
|
static int s_ctx_node = -1;
|
|
static bool s_ctx_open = false;
|
|
struct Cb {
|
|
static void on_ctx(int idx, ImVec2 /*pos*/, void* user) {
|
|
int* slot = (int*)user;
|
|
*slot = idx;
|
|
ImGui::OpenPopup("##graph_node_ctx");
|
|
}
|
|
static void on_dbl(int idx, void* /*user*/) {
|
|
std::printf("[graph] dbl-click on node %d\n", idx);
|
|
}
|
|
};
|
|
GraphViewportCallbacks cb;
|
|
cb.on_context_menu = &Cb::on_ctx;
|
|
cb.on_double_click = &Cb::on_dbl;
|
|
cb.user = &s_ctx_node;
|
|
|
|
graph_viewport("##graph_demo", s_graph, s_state, ImVec2(0, 460), cb);
|
|
|
|
// Labels overlay (issue 0049j). El callback formatea "#<idx>" en un
|
|
// buffer estatico por demo — apps reales (osint_graph) usaran un
|
|
// string pool de la BD origen.
|
|
if (s_labels_enabled) {
|
|
struct LblCtx { char buf[32]; };
|
|
static LblCtx s_lbl_ctx;
|
|
auto get_label = [](int idx, void* user) -> const char* {
|
|
auto* ctx = static_cast<LblCtx*>(user);
|
|
std::snprintf(ctx->buf, sizeof(ctx->buf), "#%d", idx);
|
|
return ctx->buf;
|
|
};
|
|
graph::graph_labels_draw(s_graph, s_state, s_label_policy,
|
|
get_label, &s_lbl_ctx);
|
|
}
|
|
|
|
if (ImGui::BeginPopup("##graph_node_ctx")) {
|
|
ImGui::Text("Node #%d", s_ctx_node);
|
|
ImGui::Separator();
|
|
if (ImGui::MenuItem("Pin")) {
|
|
if (s_ctx_node >= 0 && s_ctx_node < s_graph.node_count)
|
|
s_graph.nodes[s_ctx_node].flags |= NF_PINNED;
|
|
}
|
|
if (ImGui::MenuItem("Unpin")) {
|
|
if (s_ctx_node >= 0 && s_ctx_node < s_graph.node_count)
|
|
s_graph.nodes[s_ctx_node].flags &= ~NF_PINNED;
|
|
}
|
|
if (ImGui::MenuItem("Add to selection")) {
|
|
graph_viewport_add_to_selection(s_graph, s_state, s_ctx_node);
|
|
}
|
|
ImGui::EndPopup();
|
|
}
|
|
|
|
// Overlay con count seleccionados (lasso/multi-select feedback).
|
|
if (!s_state.selection.empty()) {
|
|
ImGui::SameLine();
|
|
ImGui::PushStyleColor(ImGuiCol_Text, fn_tokens::colors::text);
|
|
ImGui::Text("[%zu selected]", s_state.selection.size());
|
|
ImGui::PopStyleColor();
|
|
}
|
|
}
|
|
|
|
code_block(
|
|
"static GraphData graph;\n"
|
|
"static GraphViewportState state;\n"
|
|
"// ... rellenar graph.nodes / graph.edges ...\n"
|
|
"graph.update_bounds();\n"
|
|
"\n"
|
|
"// Por frame:\n"
|
|
"if (state.layout_running) {\n"
|
|
" ForceLayoutConfig cfg;\n"
|
|
" cfg.repulsion = 3500; cfg.gravity = 0.001f;\n"
|
|
" graph_force_layout_step(graph, cfg);\n"
|
|
"}\n"
|
|
"graph_viewport(\"##g\", graph, state, ImVec2(0, 460));"
|
|
);
|
|
}
|
|
|
|
} // namespace gallery
|