110a9a77fb
Previously if you used movable or scalable groups you had to add the group border width to the panel to access the updated position or size. Nuklear now takes control of the process and the new position/size can be read after `nk_group_end` from `nk_panel` directly.
343 lines
14 KiB
C
343 lines
14 KiB
C
/* nuklear - v1.00 - public domain */
|
|
/* This is a simple node editor just to show a simple implementation and that
|
|
* it is possible to achieve it with this library. While all nodes inside this
|
|
* example use a simple color modifier as content you could change them
|
|
* to have your custom content depending on the node time.
|
|
* Biggest difference to most usual implementation is that this example does
|
|
* not have connectors on the right position of the property that it links.
|
|
* This is mainly done out of laziness and could be implemented as well but
|
|
* requires calculating the position of all rows and add connectors.
|
|
* In addition adding and removing nodes is quite limited at the
|
|
* moment since it is based on a simple fixed array. If this is to be converted
|
|
* into something more serious it is probably best to extend it.*/
|
|
struct node {
|
|
int ID;
|
|
char name[32];
|
|
struct nk_rect bounds;
|
|
float value;
|
|
struct nk_color color;
|
|
int input_count;
|
|
int output_count;
|
|
struct node *next;
|
|
struct node *prev;
|
|
};
|
|
|
|
struct node_link {
|
|
int input_id;
|
|
int input_slot;
|
|
int output_id;
|
|
int output_slot;
|
|
struct nk_vec2 in;
|
|
struct nk_vec2 out;
|
|
};
|
|
|
|
struct node_linking {
|
|
int active;
|
|
struct node *node;
|
|
int input_id;
|
|
int input_slot;
|
|
};
|
|
|
|
struct node_editor {
|
|
int initialized;
|
|
struct node node_buf[32];
|
|
struct node_link links[64];
|
|
struct node *begin;
|
|
struct node *end;
|
|
int node_count;
|
|
int link_count;
|
|
struct nk_rect bounds;
|
|
struct node *selected;
|
|
int show_grid;
|
|
struct nk_vec2 scrolling;
|
|
struct node_linking linking;
|
|
};
|
|
static struct node_editor nodeEditor;
|
|
|
|
static void
|
|
node_editor_push(struct node_editor *editor, struct node *node)
|
|
{
|
|
if (!editor->begin) {
|
|
node->next = NULL;
|
|
node->prev = NULL;
|
|
editor->begin = node;
|
|
editor->end = node;
|
|
} else {
|
|
node->prev = editor->end;
|
|
if (editor->end)
|
|
editor->end->next = node;
|
|
node->next = NULL;
|
|
editor->end = node;
|
|
}
|
|
}
|
|
|
|
static void
|
|
node_editor_pop(struct node_editor *editor, struct node *node)
|
|
{
|
|
if (node->next)
|
|
node->next->prev = node->prev;
|
|
if (node->prev)
|
|
node->prev->next = node->next;
|
|
if (editor->end == node)
|
|
editor->end = node->prev;
|
|
if (editor->begin == node)
|
|
editor->begin = node->next;
|
|
node->next = NULL;
|
|
node->prev = NULL;
|
|
}
|
|
|
|
static struct node*
|
|
node_editor_find(struct node_editor *editor, int ID)
|
|
{
|
|
struct node *iter = editor->begin;
|
|
while (iter) {
|
|
if (iter->ID == ID)
|
|
return iter;
|
|
iter = iter->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
node_editor_add(struct node_editor *editor, const char *name, struct nk_rect bounds,
|
|
struct nk_color col, int in_count, int out_count)
|
|
{
|
|
static int IDs = 0;
|
|
struct node *node;
|
|
assert((nk_size)editor->node_count < LEN(editor->node_buf));
|
|
node = &editor->node_buf[editor->node_count++];
|
|
node->ID = IDs++;
|
|
node->value = 0;
|
|
node->color = nk_rgb(255, 0, 0);
|
|
node->input_count = in_count;
|
|
node->output_count = out_count;
|
|
node->color = col;
|
|
node->bounds = bounds;
|
|
strcpy(node->name, name);
|
|
node_editor_push(editor, node);
|
|
}
|
|
|
|
static void
|
|
node_editor_link(struct node_editor *editor, int in_id, int in_slot,
|
|
int out_id, int out_slot)
|
|
{
|
|
struct node_link *link;
|
|
assert((nk_size)editor->link_count < LEN(editor->links));
|
|
link = &editor->links[editor->link_count++];
|
|
link->input_id = in_id;
|
|
link->input_slot = in_slot;
|
|
link->output_id = out_id;
|
|
link->output_slot = out_slot;
|
|
}
|
|
|
|
static void
|
|
node_editor_init(struct node_editor *editor)
|
|
{
|
|
memset(editor, 0, sizeof(*editor));
|
|
editor->begin = NULL;
|
|
editor->end = NULL;
|
|
node_editor_add(editor, "Source", nk_rect(40, 10, 180, 220), nk_rgb(255, 0, 0), 0, 1);
|
|
node_editor_add(editor, "Source", nk_rect(40, 260, 180, 220), nk_rgb(0, 255, 0), 0, 1);
|
|
node_editor_add(editor, "Combine", nk_rect(400, 100, 180, 220), nk_rgb(0,0,255), 2, 2);
|
|
node_editor_link(editor, 0, 0, 2, 0);
|
|
node_editor_link(editor, 1, 0, 2, 1);
|
|
editor->show_grid = nk_true;
|
|
}
|
|
|
|
static int
|
|
node_editor(struct nk_context *ctx)
|
|
{
|
|
int n = 0;
|
|
struct nk_rect total_space;
|
|
const struct nk_input *in = &ctx->input;
|
|
struct nk_command_buffer *canvas;
|
|
struct node *updated = 0;
|
|
struct nk_panel layout;
|
|
struct node_editor *nodedit = &nodeEditor;
|
|
|
|
if (!nodeEditor.initialized) {
|
|
node_editor_init(&nodeEditor);
|
|
nodeEditor.initialized = 1;
|
|
}
|
|
|
|
if (nk_begin(ctx, &layout, "NodeEdit", nk_rect(0, 0, 800, 600),
|
|
NK_WINDOW_BORDER|NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_MOVABLE|NK_WINDOW_CLOSABLE))
|
|
{
|
|
/* allocate complete window space */
|
|
canvas = nk_window_get_canvas(ctx);
|
|
total_space = nk_window_get_content_region(ctx);
|
|
nk_layout_space_begin(ctx, NK_STATIC, total_space.h, nodedit->node_count);
|
|
{
|
|
struct nk_panel node, menu;
|
|
struct node *it = nodedit->begin;
|
|
struct nk_rect size = nk_layout_space_bounds(ctx);
|
|
|
|
if (nodedit->show_grid) {
|
|
/* display grid */
|
|
float x, y;
|
|
const float grid_size = 32.0f;
|
|
const struct nk_color grid_color = nk_rgb(50, 50, 50);
|
|
for (x = (float)fmod(size.x - nodedit->scrolling.x, grid_size); x < size.w; x += grid_size)
|
|
nk_stroke_line(canvas, x+size.x, size.y, x+size.x, size.y+size.h, 1.0f, grid_color);
|
|
for (y = (float)fmod(size.y - nodedit->scrolling.y, grid_size); y < size.h; y += grid_size)
|
|
nk_stroke_line(canvas, size.x, y+size.y, size.x+size.w, y+size.y, 1.0f, grid_color);
|
|
}
|
|
|
|
/* execute each node as a movable group */
|
|
while (it) {
|
|
/* calculate scrolled node window position and size */
|
|
nk_layout_space_push(ctx, nk_rect(it->bounds.x - nodedit->scrolling.x,
|
|
it->bounds.y - nodedit->scrolling.y, it->bounds.w, it->bounds.h));
|
|
|
|
/* execute node window */
|
|
if (nk_group_begin(ctx, &node, it->name, NK_WINDOW_MOVABLE|NK_WINDOW_NO_SCROLLBAR|NK_WINDOW_BORDER|NK_WINDOW_TITLE))
|
|
{
|
|
/* always have last selected node on top */
|
|
if (nk_input_mouse_clicked(in, NK_BUTTON_LEFT, node.bounds) &&
|
|
(!(it->prev && nk_input_mouse_clicked(in, NK_BUTTON_LEFT,
|
|
nk_layout_space_rect_to_screen(ctx, node.bounds)))) &&
|
|
nodedit->end != it)
|
|
{
|
|
updated = it;
|
|
}
|
|
|
|
/* ================= NODE CONTENT =====================*/
|
|
nk_layout_row_dynamic(ctx, 25, 1);
|
|
nk_button_color(ctx, it->color, NK_BUTTON_DEFAULT);
|
|
it->color.r = (nk_byte)nk_propertyi(ctx, "#R:", 0, it->color.r, 255, 1,1);
|
|
it->color.g = (nk_byte)nk_propertyi(ctx, "#G:", 0, it->color.g, 255, 1,1);
|
|
it->color.b = (nk_byte)nk_propertyi(ctx, "#B:", 0, it->color.b, 255, 1,1);
|
|
it->color.a = (nk_byte)nk_propertyi(ctx, "#A:", 0, it->color.a, 255, 1,1);
|
|
/* ====================================================*/
|
|
nk_group_end(ctx);
|
|
}
|
|
{
|
|
/* node connector and linking */
|
|
float space;
|
|
struct nk_rect bounds;
|
|
bounds = nk_layout_space_rect_to_local(ctx, node.bounds);
|
|
bounds.x += nodedit->scrolling.x;
|
|
bounds.y += nodedit->scrolling.y;
|
|
it->bounds = bounds;
|
|
|
|
/* output connector */
|
|
space = node.bounds.h / (float)((it->output_count) + 1);
|
|
for (n = 0; n < it->output_count; ++n) {
|
|
struct nk_rect circle;
|
|
circle.x = node.bounds.x + node.bounds.w-4;
|
|
circle.y = node.bounds.y + space * (float)(n+1);
|
|
circle.w = 8; circle.h = 8;
|
|
nk_fill_circle(canvas, circle, nk_rgb(100, 100, 100));
|
|
|
|
/* start linking process */
|
|
if (nk_input_has_mouse_click_down_in_rect(in, NK_BUTTON_LEFT, circle, nk_true)) {
|
|
nodedit->linking.active = nk_true;
|
|
nodedit->linking.node = it;
|
|
nodedit->linking.input_id = it->ID;
|
|
nodedit->linking.input_slot = n;
|
|
}
|
|
|
|
/* draw curve from linked node slot to mouse position */
|
|
if (nodedit->linking.active && nodedit->linking.node == it &&
|
|
nodedit->linking.input_slot == n) {
|
|
struct nk_vec2 l0 = nk_vec2(circle.x + 3, circle.y + 3);
|
|
struct nk_vec2 l1 = in->mouse.pos;
|
|
nk_stroke_curve(canvas, l0.x, l0.y, l0.x + 50.0f, l0.y,
|
|
l1.x - 50.0f, l1.y, l1.x, l1.y, 1.0f, nk_rgb(100, 100, 100));
|
|
}
|
|
}
|
|
|
|
/* input connector */
|
|
space = node.bounds.h / (float)((it->input_count) + 1);
|
|
for (n = 0; n < it->input_count; ++n) {
|
|
struct nk_rect circle;
|
|
circle.x = node.bounds.x-4;
|
|
circle.y = node.bounds.y + space * (float)(n+1);
|
|
circle.w = 8; circle.h = 8;
|
|
nk_fill_circle(canvas, circle, nk_rgb(100, 100, 100));
|
|
if (nk_input_is_mouse_released(in, NK_BUTTON_LEFT) &&
|
|
nk_input_is_mouse_hovering_rect(in, circle) &&
|
|
nodedit->linking.active && nodedit->linking.node != it) {
|
|
nodedit->linking.active = nk_false;
|
|
node_editor_link(nodedit, nodedit->linking.input_id,
|
|
nodedit->linking.input_slot, it->ID, n);
|
|
}
|
|
}
|
|
}
|
|
it = it->next;
|
|
}
|
|
|
|
/* reset linking connection */
|
|
if (nodedit->linking.active && nk_input_is_mouse_released(in, NK_BUTTON_LEFT)) {
|
|
nodedit->linking.active = nk_false;
|
|
nodedit->linking.node = NULL;
|
|
fprintf(stdout, "linking failed\n");
|
|
}
|
|
|
|
/* draw each link */
|
|
for (n = 0; n < nodedit->link_count; ++n) {
|
|
struct node_link *link = &nodedit->links[n];
|
|
struct node *ni = node_editor_find(nodedit, link->input_id);
|
|
struct node *no = node_editor_find(nodedit, link->output_id);
|
|
float spacei = node.bounds.h / (float)((ni->output_count) + 1);
|
|
float spaceo = node.bounds.h / (float)((no->input_count) + 1);
|
|
struct nk_vec2 l0 = nk_layout_space_to_screen(ctx,
|
|
nk_vec2(ni->bounds.x + ni->bounds.w, 3.0f + ni->bounds.y + spacei * (float)(link->input_slot+1)));
|
|
struct nk_vec2 l1 = nk_layout_space_to_screen(ctx,
|
|
nk_vec2(no->bounds.x, 3.0f + no->bounds.y + spaceo * (float)(link->output_slot+1)));
|
|
|
|
l0.x -= nodedit->scrolling.x;
|
|
l0.y -= nodedit->scrolling.y;
|
|
l1.x -= nodedit->scrolling.x;
|
|
l1.y -= nodedit->scrolling.y;
|
|
nk_stroke_curve(canvas, l0.x, l0.y, l0.x + 50.0f, l0.y,
|
|
l1.x - 50.0f, l1.y, l1.x, l1.y, 1.0f, nk_rgb(100, 100, 100));
|
|
}
|
|
|
|
if (updated) {
|
|
/* reshuffle nodes to have least recently selected node on top */
|
|
node_editor_pop(nodedit, updated);
|
|
node_editor_push(nodedit, updated);
|
|
}
|
|
|
|
/* node selection */
|
|
if (nk_input_mouse_clicked(in, NK_BUTTON_LEFT, nk_layout_space_bounds(ctx))) {
|
|
it = nodedit->begin;
|
|
nodedit->selected = NULL;
|
|
nodedit->bounds = nk_rect(in->mouse.pos.x, in->mouse.pos.y, 100, 200);
|
|
while (it) {
|
|
struct nk_rect b = nk_layout_space_rect_to_screen(ctx, it->bounds);
|
|
b.x -= nodedit->scrolling.x;
|
|
b.y -= nodedit->scrolling.y;
|
|
if (nk_input_is_mouse_hovering_rect(in, b))
|
|
nodedit->selected = it;
|
|
it = it->next;
|
|
}
|
|
}
|
|
|
|
/* contextual menu */
|
|
if (nk_contextual_begin(ctx, &menu, 0, nk_vec2(100, 220), nk_window_get_bounds(ctx))) {
|
|
const char *grid_option[] = {"Show Grid", "Hide Grid"};
|
|
nk_layout_row_dynamic(ctx, 25, 1);
|
|
if (nk_contextual_item_label(ctx, "New", NK_TEXT_CENTERED))
|
|
node_editor_add(nodedit, "New", nk_rect(400, 260, 180, 220),
|
|
nk_rgb(255, 255, 255), 1, 2);
|
|
if (nk_contextual_item_label(ctx, grid_option[nodedit->show_grid],NK_TEXT_CENTERED))
|
|
nodedit->show_grid = !nodedit->show_grid;
|
|
nk_contextual_end(ctx);
|
|
}
|
|
}
|
|
nk_layout_space_end(ctx);
|
|
|
|
/* window content scrolling */
|
|
if (nk_input_is_mouse_hovering_rect(in, nk_window_get_bounds(ctx)) &&
|
|
nk_input_is_mouse_down(in, NK_BUTTON_MIDDLE)) {
|
|
nodedit->scrolling.x += in->mouse.delta.x;
|
|
nodedit->scrolling.y += in->mouse.delta.y;
|
|
}
|
|
}
|
|
nk_end(ctx);
|
|
return !nk_window_is_closed(ctx, "NodeEdit");
|
|
}
|
|
|