edgevoid/armorpaint
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
4c77755da0bde8c8405ad54b70469e79a2a311b1
armorpaint/base/sources/iron_ui_nodes.c
T
luboslenco 4c77755da0 base: merge gc remove
2026-08-21 22:35:30 +02:00

1793 lines
66 KiB
C
Raw Blame History

#include "iron_ui.h"
#include "iron_armpack.h"
#include "iron_array.h"
#include "iron_draw.h"
#include "iron_alloc.h"
#include "iron_gpu.h"
#include "iron_json.h"
#include "iron_string.h"
#include "iron_system.h"
#include <math.h>
#include <stdlib.h>
#include <string.h>
static ui_nodes_t *current_nodes = NULL;
static bool ui_nodes_elements_baked = false;
static gpu_texture_t ui_socket_image;
static bool ui_touch_drag = false;
static bool ui_box_select = false;
static int ui_box_select_x = 0;
static int ui_box_select_y = 0;
static const int ui_max_buttons = 9;
static int ui_node_id = -1;
static ui_node_t *node_resize = NULL;
char *ui_clipboard = "";
string_array_t *ui_nodes_exclude_remove = NULL; // No removal for listed node types
bool ui_nodes_socket_released = false;
string_array_t *(*ui_nodes_enum_texts)(char *) = NULL; // Retrieve combo items for buttons of type ENUM
any_array_t *(*ui_nodes_enum_textures)(char *) = NULL;
gpu_texture_t *(*ui_nodes_preview_texture)(ui_node_t *) = NULL; // Retrieve preview image
void (*ui_nodes_on_custom_button)(int, char *) = NULL; // Call external function
ui_canvas_control_t *(*ui_nodes_on_canvas_control)(void) = NULL;
void (*ui_nodes_on_canvas_released)(void) = NULL;
void (*ui_nodes_on_socket_released)(int) = NULL;
void (*ui_nodes_on_link_drag)(int, bool) = NULL;
void (*ui_nodes_on_node_remove)(ui_node_t *) = NULL;
void (*ui_nodes_on_node_changed)(ui_node_t *) = NULL;
bool ui_nodes_grid_snap = true;
int ui_nodes_grid_snap_w = 40;
int ui_popup_x = 0;
int ui_popup_y = 0;
int ui_popup_w = 0;
int ui_popup_h = 0;
void (*ui_popup_commands)(ui_t *, void *, void *) = NULL;
void *ui_popup_data;
void *ui_popup_data2;
int ui_popup_handle_node_id = -1;
int ui_popup_handle_node_socket_id = -1;
char *tr(char *id); // translator.c
char *ui_tr(char *id) {
return tr(id);
}
void ui_nodes_init(ui_nodes_t *nodes) {
if (current_nodes == NULL) {
current_nodes = nodes;
}
memset(nodes, 0, sizeof(ui_nodes_t));
nodes->zoom = 1.0;
nodes->scale_factor = 1.0;
nodes->ELEMENT_H = 25.0;
nodes->snap_from_id = -1;
nodes->snap_to_id = -1;
nodes->link_drag_id = -1;
nodes->nodes_selected_id = calloc(1, sizeof(i32_array_t));
nodes->handle = ui_handle_create();
}
float UI_NODES_SCALE() {
return current_nodes->scale_factor * current_nodes->zoom;
}
float UI_NODES_PAN_X() {
float zoom_pan = (1.0 - current_nodes->zoom) * current_nodes->uiw / 2.5;
return current_nodes->pan_x * UI_NODES_SCALE() + zoom_pan;
}
float UI_NODES_PAN_Y() {
float zoom_pan = (1.0 - current_nodes->zoom) * current_nodes->uih / 2.5;
return current_nodes->pan_y * UI_NODES_SCALE() + zoom_pan;
}
float UI_LINE_H() {
return current_nodes->ELEMENT_H * UI_NODES_SCALE();
}
float UI_BUTTONS_H(ui_node_t *node) {
if (node->flags & UI_NODE_FLAG_COLLAPSED)
return 0.0;
float h = 0.0;
for (int i = 0; i < node->buttons->length; ++i) {
ui_node_button_t *but = node->buttons->buffer[i];
if (strcmp(but->type, "RGBA") == 0) {
float ratio = node->width > 0 ? node->width / 140.0 : 1.0; // Node resized
h += 104.0 * ratio * UI_NODES_SCALE() + UI_LINE_H() * 5.0; // Color wheel + controls
}
else if (strcmp(but->type, "VECTOR") == 0) {
h += UI_LINE_H() * 4.0;
}
else if (strcmp(but->type, "CUSTOM") == 0) {
h += UI_LINE_H() * but->height;
}
else {
h += UI_LINE_H();
}
}
return h;
}
float UI_OUTPUTS_H(ui_node_t *node, int length) {
if (node->flags & UI_NODE_FLAG_COLLAPSED)
return 0.0;
float h = 0.0;
for (int i = 0; i < (length < 0 ? node->outputs->length : length); ++i) {
h += UI_LINE_H();
}
return h;
}
bool ui_input_linked(ui_node_canvas_t *canvas, int node_id, int i) {
for (int x = 0; x < canvas->links->length; ++x) {
ui_node_link_t *l = canvas->links->buffer[x];
if (l->to_id == node_id && l->to_socket == i) {
return true;
}
}
return false;
}
float UI_INPUTS_H(ui_node_canvas_t *canvas, ui_node_socket_t **sockets, int sockets_count, int length) {
float h = 0.0;
for (int i = 0; i < (length < 0 ? sockets_count : length); ++i) {
if (strcmp(sockets[i]->type, "VECTOR") == 0 && sockets[i]->display == 1 && !ui_input_linked(canvas, sockets[i]->node_id, i)) {
h += UI_LINE_H() * 4;
}
else {
h += UI_LINE_H();
}
}
return h;
}
float UI_NODE_H(ui_node_canvas_t *canvas, ui_node_t *node) {
if (node->flags & UI_NODE_FLAG_COLLAPSED)
return UI_LINE_H() * 1.2;
return UI_LINE_H() * 1.2 + UI_INPUTS_H(canvas, node->inputs->buffer, node->inputs->length, -1) + UI_OUTPUTS_H(node, -1) + UI_BUTTONS_H(node);
}
float UI_NODE_W(ui_node_t *node) {
return (node->width != 0 ? node->width : 140.0) * UI_NODES_SCALE();
}
float UI_NODE_X(ui_node_t *node) {
return node->x * UI_NODES_SCALE() + UI_NODES_PAN_X();
}
float UI_NODE_Y(ui_node_t *node) {
return node->y * UI_NODES_SCALE() + UI_NODES_PAN_Y();
}
float UI_INPUT_Y(ui_node_canvas_t *canvas, ui_node_t *node, int pos) {
if (node->flags & UI_NODE_FLAG_COLLAPSED)
return UI_LINE_H() * 0.5;
return UI_LINE_H() * 1.62 + UI_INPUTS_H(canvas, node->inputs->buffer, node->inputs->length, pos);
}
float UI_OUTPUT_Y(ui_node_t *node, int pos) {
if (node->flags & UI_NODE_FLAG_COLLAPSED)
return UI_LINE_H() * 0.5;
return UI_LINE_H() * 1.62 + UI_OUTPUTS_H(node, pos);
}
float ui_p(float f) {
return f * UI_NODES_SCALE();
}
ui_node_t *ui_get_node(ui_node_array_t *nodes, int id) {
for (int i = 0; i < nodes->length; ++i) {
if (nodes->buffer[i]->id == id) {
return nodes->buffer[i];
}
}
return NULL;
}
int ui_get_node_index(ui_node_t **nodes, int nodes_count, int id) {
for (int i = 0; i < nodes_count; ++i) {
if (nodes[i]->id == id) {
return i;
}
}
return -1;
}
int ui_next_node_id(ui_node_array_t *nodes) {
if (ui_node_id == -1) {
for (int i = 0; i < nodes->length; ++i) {
if (ui_node_id < nodes->buffer[i]->id) {
ui_node_id = nodes->buffer[i]->id;
}
}
}
return ++ui_node_id;
}
ui_node_link_t *ui_get_link(ui_node_link_array_t *links, int id) {
for (int i = 0; i < links->length; ++i) {
if (links->buffer[i]->id == id) {
return links->buffer[i];
}
}
return NULL;
}
int ui_get_link_index(ui_node_link_array_t *links, int id) {
for (int i = 0; i < links->length; ++i) {
if (links->buffer[i]->id == id) {
return i;
}
}
return -1;
}
int ui_next_link_id(ui_node_link_array_t *links) {
int id = 0;
for (int i = 0; i < links->length; ++i) {
if (links->buffer[i]->id >= id) {
id = links->buffer[i]->id + 1;
}
}
return id;
}
int ui_get_socket_id(ui_node_array_t *nodes) {
int id = 0;
for (int i = 0; i < nodes->length; ++i) {
ui_node_t *n = nodes->buffer[i];
for (int j = 0; j < n->inputs->length; ++j) {
if (n->inputs->buffer[j]->id >= id) {
id = n->inputs->buffer[j]->id + 1;
}
}
for (int j = 0; j < n->outputs->length; ++j) {
if (n->outputs->buffer[j]->id >= id) {
id = n->outputs->buffer[j]->id + 1;
}
}
}
return id;
}
void ui_nodes_bake_elements() {
if (ui_socket_image.width != 0) {
gpu_texture_destroy(&ui_socket_image);
}
gpu_render_target_init(&ui_socket_image, 24, 24, GPU_TEXTURE_FORMAT_RGBA32);
draw_begin(&ui_socket_image, true, 0x00000000);
draw_set_color(0xff111111);
draw_filled_circle(12, 12, 11, 0);
draw_set_color(0xffffffff);
draw_filled_circle(12, 12, 9, 0);
draw_end();
ui_nodes_elements_baked = true;
}
ui_canvas_control_t *ui_on_default_canvas_control() {
ui_t *current = ui_get_current();
static ui_canvas_control_t c;
c.pan_x = current->input_down_r ? current->input_dx : 0.0;
c.pan_y = current->input_down_r ? current->input_dy : 0.0;
c.zoom = -current->input_wheel_delta / 10.0;
return &c;
}
void ui_draw_link(float x1, float y1, float x2, float y2, bool highlight) {
ui_t *current = ui_get_current();
int c1 = current->ops->theme->LABEL_COL;
int c2 = current->ops->theme->HOVER_COL + 0X00222222;
int c = highlight ? c1 : c2;
draw_set_color(ui_color(ui_color_r(c), ui_color_g(c), ui_color_b(c), 210));
if (current->ops->theme->LINK_STYLE == UI_LINK_STYLE_LINE) {
draw_line_aa(x1, y1, x2, y2, 1.0);
}
else if (current->ops->theme->LINK_STYLE == UI_LINK_STYLE_CUBIC_BEZIER) {
f32_array_t xa;
f32_array_t ya;
float x[] = {x1, x1 + fabs(x1 - x2) / 2.0, x2 - fabs(x1 - x2) / 2.0, x2};
float y[] = {y1, y1, y2, y2};
xa.buffer = x;
ya.buffer = y;
draw_cubic_bezier(&xa, &ya, 30, highlight ? 2.0 : 1.0);
}
}
static void ui_remove_link_at(ui_node_canvas_t *canvas, int at) {
canvas->links->buffer[at] = NULL;
for (int i = at; i < canvas->links->length - 1; ++i) {
canvas->links->buffer[i] = canvas->links->buffer[i + 1];
}
canvas->links->length--;
}
static void ui_remove_node_at(ui_node_canvas_t *canvas, int at) {
canvas->nodes->buffer[at] = NULL;
for (int i = at; i < canvas->nodes->length - 1; ++i) {
canvas->nodes->buffer[i] = canvas->nodes->buffer[i + 1];
}
canvas->nodes->length--;
}
void ui_remove_node(ui_node_t *n, ui_node_canvas_t *canvas) {
if (n == NULL)
return;
int i = 0;
while (i < canvas->links->length) {
ui_node_link_t *l = canvas->links->buffer[i];
if (l->from_id == n->id || l->to_id == n->id) {
ui_remove_link_at(canvas, i);
if (ui_nodes_on_node_changed != NULL && l->from_id == n->id) {
ui_nodes_on_node_changed(ui_get_node(canvas->nodes, l->to_id));
}
}
else {
i++;
}
}
ui_remove_node_at(canvas, ui_get_node_index(canvas->nodes->buffer, canvas->nodes->length, n->id));
if (ui_nodes_on_node_remove != NULL) {
(*ui_nodes_on_node_remove)(n);
}
}
bool ui_is_selected(ui_node_t *node) {
for (int i = 0; i < current_nodes->nodes_selected_id->length; ++i) {
if (current_nodes->nodes_selected_id->buffer[i] == node->id) {
return true;
}
}
return false;
}
static void remove_from_selection(ui_node_t *node) {
i32_array_remove(current_nodes->nodes_selected_id, node->id);
}
static void add_to_selection(ui_node_t *node) {
i32_array_push(current_nodes->nodes_selected_id, node->id);
}
void ui_popup(int x, int y, int w, int h, void (*commands)(ui_t *, void *, void *), void *data, void *data2) {
ui_popup_x = x;
ui_popup_y = y;
ui_popup_w = w;
ui_popup_h = h;
ui_popup_commands = commands;
ui_popup_data = data;
ui_popup_data2 = data2;
}
static void color_picker_callback(uint32_t color) {
ui_t *current = ui_get_current();
float *val = (float *)current_nodes->color_picker_callback_data;
val[0] = ui_color_r(color) / 255.0f;
val[1] = ui_color_g(color) / 255.0f;
val[2] = ui_color_b(color) / 255.0f;
current->changed = true;
}
void ui_color_wheel_picker(void *data) {
current_nodes->color_picker_callback_data = data;
current_nodes->color_picker_callback = &color_picker_callback;
}
static void rgba_popup_commands(ui_t *ui, void *data, void *data2) {
ui_handle_t *nhandle = (ui_handle_t *)data;
float *val = (float *)data2;
nhandle->color = ui_color(val[0] * 255.0, val[1] * 255.0, val[2] * 255.0, 255.0);
ui_color_wheel(nhandle, false, -1, -1, true, &ui_color_wheel_picker, val);
val[0] = ui_color_r(nhandle->color) / 255.0f;
val[1] = ui_color_g(nhandle->color) / 255.0f;
val[2] = ui_color_b(nhandle->color) / 255.0f;
}
void ui_nodes_rgba_popup(ui_handle_t *nhandle, float *val, int x, int y) {
ui_t *current = ui_get_current();
ui_popup(x, y, 140.0 * current_nodes->scale_factor, current->ops->theme->ELEMENT_H * 10.0, &rgba_popup_commands, nhandle, val);
}
static float ui_nodes_snap(float f) {
float w = ui_nodes_grid_snap_w * UI_NODES_SCALE();
f = f * UI_NODES_SCALE();
return roundf(f / w) * w;
}
static string_array_t enum_ar;
static char enum_label[64];
static char enum_texts_data[256][64];
static char *enum_texts[256];
static string_array_t temp_ar; // Used by open combo
static char temp_label[64];
static char temp_texts_data[256][64];
static char *temp_texts[256];
void ui_node_draw_body(ui_node_t *node, ui_node_canvas_t *canvas, float nx, float ny) {
ui_t *current = ui_get_current();
float wx = current->_window_x;
float wy = current->_window_y;
float w = UI_NODE_W(node);
// float h = UI_NODE_H(canvas, node);
float lineh = UI_LINE_H();
// Outputs
for (int i = 0; i < node->outputs->length; ++i) {
ui_node_socket_t *out = node->outputs->buffer[i];
ny += lineh;
draw_set_color(out->color);
draw_scaled_image(&ui_socket_image, nx + w - ui_p(6), ny - ui_p(3), ui_p(12), ui_p(12));
}
ny -= lineh * node->outputs->length;
draw_set_color(current->ops->theme->LABEL_COL);
for (int i = 0; i < node->outputs->length; ++i) {
ui_node_socket_t *out = node->outputs->buffer[i];
ny += lineh;
float strw = draw_string_width(current->ops->font, current->font_size, ui_tr(out->name));
draw_string(ui_tr(out->name), nx + w - strw - ui_p(12), ny - ui_p(3));
if (ui_nodes_on_socket_released != NULL && current->input_enabled && (current->input_released || current->input_released_r)) {
if (current->input_x > wx + nx && current->input_x < wx + nx + w && current->input_y > wy + ny && current->input_y < wy + ny + lineh) {
ui_nodes_on_socket_released(out->id);
ui_nodes_socket_released = true;
}
}
}
// Buttons
ui_handle_t *nhandle = ui_nest(current_nodes->handle, node->id);
ny -= lineh / 3.0; // Fix align
for (int buti = 0; buti < node->buttons->length; ++buti) {
ui_node_button_t *but = node->buttons->buffer[buti];
float *val = but->output == -1 ? but->default_value->buffer : node->outputs->buffer[but->output]->default_value->buffer;
if (strcmp(but->type, "RGBA") == 0) {
ny += lineh; // 18 + 2 separator
current->_x = nx + 1; // Offset for node selection border
current->_y = ny;
current->_w = w;
nhandle->color = ui_color(val[0] * 255.0, val[1] * 255.0, val[2] * 255.0, 255.0);
ui_color_wheel(nhandle, false, -1, -1, true, &ui_color_wheel_picker, val);
val[0] = ui_color_r(nhandle->color) / 255.0f;
val[1] = ui_color_g(nhandle->color) / 255.0f;
val[2] = ui_color_b(nhandle->color) / 255.0f;
}
else if (strcmp(but->type, "VECTOR") == 0) {
ny += lineh;
current->_x = nx;
current->_y = ny;
current->_w = w;
float min = but->min;
float max = but->max;
float text_off = current->ops->theme->TEXT_OFFSET;
current->ops->theme->TEXT_OFFSET = 6;
ui_text(ui_tr(but->name), UI_ALIGN_LEFT, 0);
ui_handle_t *h = ui_nest(nhandle, buti);
ui_handle_t *h0 = ui_nest(h, 0);
if (h0->init) {
h0->f = val[0];
}
ui_handle_t *h1 = ui_nest(h, 1);
if (h1->init) {
h1->f = val[1];
}
ui_handle_t *h2 = ui_nest(h, 2);
if (h2->init) {
h2->f = val[2];
}
val[0] = ui_slider(h0, "X", min, max, true, but->precision, true, UI_ALIGN_LEFT, true);
val[1] = ui_slider(h1, "Y", min, max, true, but->precision, true, UI_ALIGN_LEFT, true);
val[2] = ui_slider(h2, "Z", min, max, true, but->precision, true, UI_ALIGN_LEFT, true);
current->ops->theme->TEXT_OFFSET = text_off;
ny += lineh * 3.0;
}
else if (strcmp(but->type, "VALUE") == 0) {
ny += lineh;
current->_x = nx;
current->_y = ny;
current->_w = w;
float min = but->min;
float max = but->max;
float prec = but->precision;
float text_off = current->ops->theme->TEXT_OFFSET;
current->ops->theme->TEXT_OFFSET = 6;
ui_handle_t *soc_handle = ui_nest(nhandle, buti);
if (soc_handle->init) {
soc_handle->f = val[0];
}
val[0] = ui_slider(soc_handle, ui_tr(but->name), min, max, true, prec, true, UI_ALIGN_LEFT, true);
current->ops->theme->TEXT_OFFSET = text_off;
}
else if (strcmp(but->type, "STRING") == 0) {
ny += lineh;
current->_x = nx;
current->_y = ny;
current->_w = w;
ui_handle_t *h = ui_nest(nhandle, buti);
h->text = val != NULL ? (char *)val : "";
but->default_value->buffer = ui_text_input(h, ui_tr(but->name), UI_ALIGN_LEFT, true, false);
but->default_value->length = strlen(but->default_value->buffer) + 1;
}
else if (strcmp(but->type, "ENUM") == 0) {
ny += lineh;
current->_x = nx;
current->_y = ny;
current->_w = w;
ui_handle_t *but_handle = ui_nest(nhandle, buti);
but_handle->i = ((float *)but->default_value->buffer)[0];
bool combo_select = current->combo_selected_handle == NULL && ui_get_released(UI_ELEMENT_H());
char *label = combo_select ? temp_label : enum_label;
char (*texts_data)[256] = combo_select ? temp_texts_data : enum_texts_data;
char **texts = combo_select ? temp_texts : enum_texts;
string_array_t *ar = combo_select ? &temp_ar : &enum_ar;
any_array_t *images = NULL;
int texts_count = 0;
bool has_but_data = but->data != NULL && but->data->length > 1;
if (has_but_data) {
int wi = 0;
for (int i = 0; i < but->data->length; ++i) {
if (texts_count == 255) {
break;
}
char c = ((char *)but->data->buffer)[i];
if (c == '\0') {
texts_data[texts_count][wi] = '\0';
texts_count++;
break;
}
if (c == '\n') {
texts_data[texts_count][wi] = '\0';
texts_count++;
wi = 0;
continue;
}
texts_data[texts_count][wi] = c;
wi++;
}
for (int i = 0; i < texts_count; ++i) {
strcpy(texts_data[i], ui_tr(texts_data[i]));
texts[i] = texts_data[i];
}
ar->buffer = texts;
ar->length = texts_count;
}
else {
ar = (*ui_nodes_enum_texts)(node->type);
}
strcpy(label, ui_tr(but->name));
((float *)but->default_value->buffer)[0] = ui_combo(but_handle, ar, label, false, UI_ALIGN_LEFT, true);
if (current->combo_selected_handle == but_handle && !has_but_data && ui_nodes_enum_textures != NULL) {
current->combo_selected_images = (*ui_nodes_enum_textures)(node->type);
}
}
else if (strcmp(but->type, "BOOL") == 0) {
ny += lineh;
current->_x = nx;
current->_y = ny;
current->_w = w;
ui_handle_t *h = ui_nest(nhandle, buti);
if (h->init) {
h->b = ((float *)but->default_value->buffer)[0];
}
((float *)but->default_value->buffer)[0] = ui_check(h, ui_tr(but->name), "");
}
else if (strcmp(but->type, "CUSTOM") == 0) { // Calls external function for custom button drawing
ny += lineh;
current->_x = nx;
current->_y = ny;
current->_w = w;
ui_nodes_on_custom_button(node->id, but->name);
ny += lineh * (but->height - 1); // but->height specifies vertical button size
}
}
ny += lineh / 3.0; // Fix align
// Inputs
for (int i = 0; i < node->inputs->length; ++i) {
ui_node_socket_t *inp = node->inputs->buffer[i];
ny += lineh;
draw_set_color(inp->color);
draw_scaled_image(&ui_socket_image, nx - ui_p(6), ny - ui_p(3), ui_p(12), ui_p(12));
bool is_linked = ui_input_linked(canvas, node->id, i);
if (!is_linked && strcmp(inp->type, "VALUE") == 0) {
current->_x = nx + ui_p(6);
current->_y = ny - ui_p(current_nodes->ELEMENT_H / 3.0);
current->_w = w - ui_p(6);
ui_node_socket_t *soc = inp;
float min = soc->min;
float max = soc->max;
float prec = soc->precision;
float text_off = current->ops->theme->TEXT_OFFSET;
current->ops->theme->TEXT_OFFSET = 6;
ui_handle_t *_handle = ui_nest(nhandle, ui_max_buttons);
ui_handle_t *soc_handle = ui_nest(_handle, i);
if (soc_handle->init) {
soc_handle->f = ((float *)soc->default_value->buffer)[0];
}
((float *)soc->default_value->buffer)[0] = ui_slider(soc_handle, ui_tr(inp->name), min, max, true, prec, true, UI_ALIGN_LEFT, true);
current->ops->theme->TEXT_OFFSET = text_off;
}
else if (!is_linked && strcmp(inp->type, "STRING") == 0) {
current->_x = nx + ui_p(6);
current->_y = ny - ui_p(9);
current->_w = w - ui_p(6);
ui_node_socket_t *soc = inp;
float text_off = current->ops->theme->TEXT_OFFSET;
current->ops->theme->TEXT_OFFSET = 6;
ui_handle_t *_handle = ui_nest(nhandle, ui_max_buttons);
ui_handle_t *h = ui_nest(_handle, i);
if (h->init) {
strcpy(h->text, soc->default_value->buffer);
}
soc->default_value->buffer = ui_text_input(h, ui_tr(inp->name), UI_ALIGN_LEFT, true, false);
current->ops->theme->TEXT_OFFSET = text_off;
}
else if (!is_linked && strcmp(inp->type, "RGBA") == 0) {
draw_set_color(current->ops->theme->LABEL_COL);
draw_string(ui_tr(inp->name), nx + ui_p(12), ny - ui_p(3));
ui_node_socket_t *soc = inp;
draw_set_color(0xff000000);
draw_filled_rect(nx + w - ui_p(38), ny - ui_p(6), ui_p(36), ui_p(18));
float *val = (float *)soc->default_value->buffer;
draw_set_color(ui_color(val[0] * 255, val[1] * 255, val[2] * 255, 255));
float rx = nx + w - ui_p(37);
float ry = ny - ui_p(5);
float rw = ui_p(34);
float rh = ui_p(16);
draw_filled_rect(rx, ry, rw, rh);
float ix = current->input_x - wx;
float iy = current->input_y - wy;
if (current->input_started && ix > rx && iy > ry && ix < rx + rw && iy < ry + rh) {
current_nodes->_input_started = current->input_started = false;
ui_nodes_rgba_popup(nhandle, soc->default_value->buffer, (int)(rx), (int)(ry + UI_ELEMENT_H()));
ui_popup_handle_node_id = node->id;
ui_popup_handle_node_socket_id = soc->id;
}
if (ui_popup_commands != NULL && ui_popup_handle_node_id == node->id && ui_popup_handle_node_socket_id == soc->id) {
// armpack data may have been moved in memory
ui_popup_data = nhandle;
ui_popup_data2 = soc->default_value->buffer;
}
}
else if (!is_linked && strcmp(inp->type, "VECTOR") == 0 && inp->display == 1) {
draw_set_color(current->ops->theme->LABEL_COL);
draw_string(ui_tr(inp->name), nx + ui_p(12), ny - ui_p(3));
ny += lineh / 2;
current->_x = nx;
current->_y = ny;
current->_w = w;
float min = inp->min;
float max = inp->max;
float text_off = current->ops->theme->TEXT_OFFSET;
current->ops->theme->TEXT_OFFSET = 6;
float *val = (float *)inp->default_value->buffer;
ui_handle_t *h = ui_nest(nhandle, ui_max_buttons);
ui_handle_t *hi = ui_nest(h, i);
ui_handle_t *h0 = ui_nest(hi, 0);
if (h0->init) {
h0->f = val[0];
}
ui_handle_t *h1 = ui_nest(hi, 1);
if (h1->init) {
h1->f = val[1];
}
ui_handle_t *h2 = ui_nest(hi, 2);
if (h2->init) {
h2->f = val[2];
}
val[0] = ui_slider(h0, "X", min, max, true, inp->precision, true, UI_ALIGN_LEFT, true);
val[1] = ui_slider(h1, "Y", min, max, true, inp->precision, true, UI_ALIGN_LEFT, true);
val[2] = ui_slider(h2, "Z", min, max, true, inp->precision, true, UI_ALIGN_LEFT, true);
current->ops->theme->TEXT_OFFSET = text_off;
ny += lineh * 2.5;
}
else {
draw_set_color(current->ops->theme->LABEL_COL);
draw_string(ui_tr(inp->name), nx + ui_p(12), ny - ui_p(3));
}
if (ui_nodes_on_socket_released != NULL && current->input_enabled && (current->input_released || current->input_released_r)) {
if (current->input_x > wx + nx && current->input_x < wx + nx + w && current->input_y > wy + ny && current->input_y < wy + ny + lineh) {
ui_nodes_on_socket_released(inp->id);
ui_nodes_socket_released = true;
}
}
}
}
void ui_node_draw(ui_node_t *node, ui_node_canvas_t *canvas) {
ui_t *current = ui_get_current();
float wx = current->_window_x;
float wy = current->_window_y;
float ui_x = current->_x;
float ui_y = current->_y;
float ui_w = current->_w;
float w = UI_NODE_W(node);
float h = UI_NODE_H(canvas, node);
float nx = UI_NODE_X(node);
float ny = UI_NODE_Y(node);
char *text = ui_tr(node->name);
float lineh = UI_LINE_H();
// Disallow input if node is overlapped by another node
current_nodes->_input_started = current->input_started;
if (current->input_started) {
for (int i = ui_get_node_index(canvas->nodes->buffer, canvas->nodes->length, node->id) + 1; i < canvas->nodes->length; ++i) {
ui_node_t *n = canvas->nodes->buffer[i];
if (UI_NODE_X(n) < current->input_x - current->_window_x && UI_NODE_X(n) + UI_NODE_W(n) > current->input_x - current->_window_x &&
UI_NODE_Y(n) < current->input_y - current->_window_y && UI_NODE_Y(n) + UI_NODE_H(canvas, n) > current->input_y - current->_window_y) {
current->input_started = false;
break;
}
}
}
// Grid snap preview
if (ui_nodes_grid_snap && ui_is_selected(node) && current_nodes->nodes_drag) {
draw_set_color(current->ops->theme->BUTTON_COL);
ui_draw_rect(false, true, ui_nodes_snap(node->x) + UI_NODES_PAN_X(), ui_nodes_snap(node->y) + UI_NODES_PAN_Y(), w + 2, h + 2);
// nx = ui_nodes_snap(node->x) + UI_NODES_PAN_X();
// ny = ui_nodes_snap(node->y) + UI_NODES_PAN_Y();
}
// Node preview
if ((node->flags & UI_NODE_FLAG_PREVIEW) && ui_nodes_preview_texture != NULL) {
// ui_draw_shadow(nx, ny - w, w * 0.98, w * 0.98);
gpu_texture_t *image = ui_nodes_preview_texture(node);
if (image != NULL) {
draw_set_color(0xffffffff);
float ph = w * (image->height / (float)image->width);
draw_scaled_image(image, nx, ny - ph, w, ph);
}
}
// Shadow
ui_draw_shadow(nx, ny, w, h);
// Outline
draw_set_color(ui_is_selected(node) ? current->ops->theme->HIGHLIGHT_COL : current->ops->theme->PRESSED_COL);
ui_draw_rect(true, true, nx - 1, ny - 1, w + 2, h + 2);
// Body
draw_set_color(current->ops->theme->WINDOW_BG_COL);
ui_draw_rect(true, true, nx, ny, w, h);
// Header line
draw_set_color(node->color);
draw_filled_rect(nx, ny + lineh - ui_p(3), w, ui_p(3));
// Collapse button
bool hover = current->input_x > wx + nx && current->input_x < wx + nx + ui_p(20) && current->input_y > wy + ny && current->input_y < wy + ny + ui_p(20);
if (hover && current->input_started) {
node->flags ^= UI_NODE_FLAG_COLLAPSED;
}
draw_set_color(hover ? current->ops->theme->LABEL_COL : current->ops->theme->HOVER_COL);
int bx = nx + ui_p(4);
int by = ny + ui_p(8);
draw_filled_triangle(bx, by, bx + UI_ARROW_SIZE() * 2, by, bx + UI_ARROW_SIZE(), by + UI_ARROW_SIZE());
// Eye button
hover = current->input_x > wx + nx + w - ui_p(20) && current->input_x < wx + nx + w && current->input_y > wy + ny && current->input_y < wy + ny + ui_p(20);
if (hover && current->input_started) {
node->flags ^= UI_NODE_FLAG_PREVIEW;
}
draw_set_color(hover ? current->ops->theme->LABEL_COL : current->ops->theme->HOVER_COL);
float ex = nx + w - ui_p(10);
float ey = ny + ui_p(10);
float hw = ui_p(6);
float hh = ui_p(3);
float x[4] = {ex - hw, ex - hw * 0.5, ex + hw * 0.5, ex + hw};
float y_upper[4] = {ey, ey - hh * 1.5, ey - hh * 1.5, ey};
f32_array_t xa;
f32_array_t ya;
xa.buffer = x;
ya.buffer = y_upper;
draw_cubic_bezier(&xa, &ya, 15, 1.0);
float y_lower[4] = {ey, ey + hh * 1.5, ey + hh * 1.5, ey};
ya.buffer = y_lower;
draw_cubic_bezier(&xa, &ya, 15, 1.0);
draw_filled_circle(ex, ey, ui_p(2), 0);
// Title
draw_set_color(current->ops->theme->TEXT_COL);
// float textw = draw_string_width(current->ops->font, current->font_size, text);
draw_string(text, nx + ui_p(20), ny + ui_p(6));
ny += lineh * 0.5;
if (!(node->flags & UI_NODE_FLAG_COLLAPSED)) {
bool _changed = current->changed;
current->changed = false;
ui_node_draw_body(node, canvas, nx, ny);
if (ui_nodes_on_node_changed != NULL && current->changed) {
ui_nodes_on_node_changed(node);
}
current->changed = _changed || current->changed;
}
current->_x = ui_x;
current->_y = ui_y;
current->_w = ui_w;
current->input_started = current_nodes->_input_started;
}
bool ui_is_node_type_excluded(char *type) {
for (int i = 0; i < ui_nodes_exclude_remove->length; ++i) {
if (strcmp(ui_nodes_exclude_remove->buffer[i], type) == 0) {
return true;
}
}
return false;
}
void ui_node_canvas(ui_nodes_t *nodes, ui_node_canvas_t *canvas) {
current_nodes = nodes;
ui_t *current = ui_get_current();
if (!ui_nodes_elements_baked) {
gpu_texture_t *current = _draw_current;
draw_end();
ui_nodes_bake_elements();
draw_begin(current, false, 0);
}
if (ui_nodes_exclude_remove == NULL) {
ui_nodes_exclude_remove = calloc(1, sizeof(string_array_t));
}
float wx = current->_window_x;
float wy = current->_window_y;
bool _input_enabled = current->input_enabled;
current->input_enabled = _input_enabled && ui_popup_commands == NULL;
ui_canvas_control_t *controls = ui_nodes_on_canvas_control != NULL ? ui_nodes_on_canvas_control() : ui_on_default_canvas_control();
ui_nodes_socket_released = false;
// Pan canvas
if (current->input_enabled && (controls->pan_x != 0.0 || controls->pan_y != 0.0)) {
current_nodes->pan_x += controls->pan_x / UI_NODES_SCALE();
current_nodes->pan_y += controls->pan_y / UI_NODES_SCALE();
}
// Zoom canvas
if (current->input_enabled && controls->zoom != 0.0) {
current_nodes->zoom += controls->zoom;
if (current_nodes->zoom < 0.1) {
current_nodes->zoom = 0.1;
}
else if (current_nodes->zoom > 1.0) {
current_nodes->zoom = 1.0;
}
current_nodes->zoom = round(current_nodes->zoom * 100.0) / 100.0;
current_nodes->uiw = current->_w;
current_nodes->uih = current->_h;
if (ui_touch_control) {
// Zoom to finger location
current_nodes->pan_x -= (current->input_x - current->_window_x - current->_window_w / 2.0) * controls->zoom * 5.0 * (1.0 - current_nodes->zoom);
current_nodes->pan_y -= (current->input_y - current->_window_y - current->_window_h / 2.0) * controls->zoom * 5.0 * (1.0 - current_nodes->zoom);
}
}
current_nodes->scale_factor = UI_SCALE();
current_nodes->ELEMENT_H = current->ops->theme->ELEMENT_H + 2;
ui_set_scale(UI_NODES_SCALE()); // Apply zoomed scale
current->elements_baked = true;
draw_set_font(current->ops->font, current->font_size);
for (int i = 0; i < canvas->links->length; ++i) {
ui_node_link_t *link = canvas->links->buffer[i];
ui_node_t *from = ui_get_node(canvas->nodes, link->from_id);
ui_node_t *to = ui_get_node(canvas->nodes, link->to_id);
float from_x = from == NULL ? current->input_x : wx + UI_NODE_X(from) + UI_NODE_W(from);
float from_y = from == NULL ? current->input_y : wy + UI_NODE_Y(from) + UI_OUTPUT_Y(from, link->from_socket);
float to_x = to == NULL ? current->input_x : wx + UI_NODE_X(to);
float to_y = to == NULL ? current->input_y : wy + UI_NODE_Y(to) + UI_INPUT_Y(canvas, to, link->to_socket) + UI_OUTPUTS_H(to, -1) + UI_BUTTONS_H(to);
// Cull
float left = to_x > from_x ? from_x : to_x;
float right = to_x > from_x ? to_x : from_x;
float top = to_y > from_y ? from_y : to_y;
float bottom = to_y > from_y ? to_y : from_y;
if (right < 0 || left > wx + current->_window_w || bottom < 0 || top > wy + current->_window_h) {
continue;
}
// Snap to nearest socket
if (current_nodes->link_drag_id == link->id) {
if (current_nodes->snap_from_id != -1) {
from_x = current_nodes->snap_x;
from_y = current_nodes->snap_y;
}
if (current_nodes->snap_to_id != -1) {
to_x = current_nodes->snap_x;
to_y = current_nodes->snap_y;
}
current_nodes->snap_from_id = current_nodes->snap_to_id = -1;
for (int j = 0; j < canvas->nodes->length; ++j) {
ui_node_t *node = canvas->nodes->buffer[j];
float node_h = UI_NODE_H(canvas, node);
float rx = wx + UI_NODE_X(node) - UI_LINE_H() / 2;
float ry = wy + UI_NODE_Y(node) - UI_LINE_H() / 2;
float rw = UI_NODE_W(node) + UI_LINE_H();
float rh = node_h + UI_LINE_H();
if (ui_input_in_rect(rx, ry, rw, rh)) {
if (from == NULL && node->id != to->id) { // Snap to output
for (int k = 0; k < node->outputs->length; ++k) {
float sx = wx + UI_NODE_X(node) + UI_NODE_W(node);
float sy = wy + UI_NODE_Y(node) + UI_OUTPUT_Y(node, k);
float rx = sx - UI_LINE_H() / 2;
float ry = sy - UI_LINE_H() / 2;
if (ui_input_in_rect(rx, ry, UI_LINE_H(), UI_LINE_H())) {
current_nodes->snap_x = sx;
current_nodes->snap_y = sy;
current_nodes->snap_from_id = node->id;
current_nodes->snap_socket = k;
break;
}
}
}
else if (to == NULL && node->id != from->id) { // Snap to input
for (int k = 0; k < node->inputs->length; ++k) {
float sx = wx + UI_NODE_X(node);
float sy = wy + UI_NODE_Y(node) + UI_INPUT_Y(canvas, node, k) + UI_OUTPUTS_H(node, -1) + UI_BUTTONS_H(node);
float rx = sx - UI_LINE_H() / 2.0;
float ry = sy - UI_LINE_H() / 2.0;
if (ui_input_in_rect(rx, ry, UI_LINE_H(), UI_LINE_H())) {
current_nodes->snap_x = sx;
current_nodes->snap_y = sy;
current_nodes->snap_to_id = node->id;
current_nodes->snap_socket = k;
break;
}
}
}
}
}
}
bool selected = false;
for (int j = 0; j < current_nodes->nodes_selected_id->length; ++j) {
int n_id = current_nodes->nodes_selected_id->buffer[j];
if (link->from_id == n_id || link->to_id == n_id) {
selected = true;
break;
}
}
ui_draw_link(from_x - wx, from_y - wy, to_x - wx, to_y - wy, selected);
}
for (int i = 0; i < canvas->nodes->length; ++i) {
ui_node_t *node = canvas->nodes->buffer[i];
// Cull
float preview_h = (node->flags & UI_NODE_FLAG_PREVIEW) ? UI_NODE_W(node) : 0.0;
if (UI_NODE_X(node) > current->_window_w || UI_NODE_X(node) + UI_NODE_W(node) < 0 || UI_NODE_Y(node) - preview_h > current->_window_h ||
UI_NODE_Y(node) + UI_NODE_H(canvas, node) < 0) {
if (!ui_is_selected(node)) {
continue;
}
}
// Resize node
float node_h = UI_NODE_H(canvas, node);
float top_h = UI_LINE_H() + UI_OUTPUTS_H(node, -1) + ui_p(5);
if (current->input_enabled && (ui_input_in_rect(wx + UI_NODE_X(node) + UI_NODE_W(node), wy + UI_NODE_Y(node), 5, UI_LINE_H()) ||
ui_input_in_rect(wx + UI_NODE_X(node) + UI_NODE_W(node), wy + UI_NODE_Y(node) + top_h, 5, node_h - top_h))) {
iron_mouse_set_cursor(IRON_CURSOR_SIZEWE);
if (current->input_started) {
node_resize = node;
}
}
// Drag node
if (current->input_enabled && node_resize == NULL &&
ui_input_in_rect(wx + UI_NODE_X(node) - UI_LINE_H() / 2.0, wy + UI_NODE_Y(node), UI_NODE_W(node) + UI_LINE_H(), UI_LINE_H())) {
if (current->input_started) {
if (current->is_shift_down || current->is_ctrl_down) {
// Add to selection or deselect
if (ui_is_selected(node)) {
remove_from_selection(node);
}
else {
add_to_selection(node);
}
}
else if (current_nodes->nodes_selected_id->length <= 1) {
// Selecting single node, otherwise wait for input release
current_nodes->nodes_selected_id->length = 0;
i32_array_push(current_nodes->nodes_selected_id, node->id);
}
current_nodes->move_on_top = node; // Place selected node on top
current_nodes->nodes_drag = true;
current_nodes->dragged = false;
}
else if (current->input_released && !current->is_shift_down && !current->is_ctrl_down && !current_nodes->dragged) {
// No drag performed, select single node
current_nodes->nodes_selected_id->length = 0;
i32_array_push(current_nodes->nodes_selected_id, node->id);
}
}
if (current->input_started && !(node->flags & UI_NODE_FLAG_COLLAPSED) &&
ui_input_in_rect(wx + UI_NODE_X(node) - UI_LINE_H() / 2, wy + UI_NODE_Y(node) - UI_LINE_H() / 2, UI_NODE_W(node) + UI_LINE_H(),
node_h + UI_LINE_H())) {
// Check sockets
if (current_nodes->link_drag_id == -1) {
for (int j = 0; j < node->outputs->length; ++j) {
float sx = wx + UI_NODE_X(node) + UI_NODE_W(node);
float sy = wy + UI_NODE_Y(node) + UI_OUTPUT_Y(node, j);
if (ui_input_in_rect(sx - UI_LINE_H() / 2.0, sy - UI_LINE_H() / 2.0, UI_LINE_H(), UI_LINE_H())) {
// New link from output
ui_node_link_t *l = (ui_node_link_t *)malloc(sizeof(ui_node_link_t)); // TODO: store at canvas->links without malloc
l->id = ui_next_link_id(canvas->links);
l->from_id = node->id;
l->from_socket = j;
l->to_id = -1;
l->to_socket = -1;
any_array_push(canvas->links, l);
current_nodes->link_drag_id = l->id;
current_nodes->is_new_link = true;
break;
}
}
}
if (current_nodes->link_drag_id == -1) {
for (int j = 0; j < node->inputs->length; ++j) {
float sx = wx + UI_NODE_X(node);
float sy = wy + UI_NODE_Y(node) + UI_INPUT_Y(canvas, node, j) + UI_OUTPUTS_H(node, -1) + UI_BUTTONS_H(node);
if (ui_input_in_rect(sx - UI_LINE_H() / 2.0, sy - UI_LINE_H() / 2.0, UI_LINE_H(), UI_LINE_H())) {
// Already has a link - disconnect
for (int k = 0; k < canvas->links->length; ++k) {
ui_node_link_t *l = canvas->links->buffer[k];
if (l->to_id == node->id && l->to_socket == j) {
l->to_id = l->to_socket = -1;
current_nodes->link_drag_id = l->id;
current_nodes->is_new_link = false;
if (ui_nodes_on_node_changed != NULL) {
ui_nodes_on_node_changed(node);
}
break;
}
}
if (current_nodes->link_drag_id != -1) {
break;
}
// New link from input
ui_node_link_t *l = (ui_node_link_t *)malloc(sizeof(ui_node_link_t));
l->id = ui_next_link_id(canvas->links);
l->from_id = -1;
l->from_socket = -1;
l->to_id = node->id;
l->to_socket = j;
any_array_push(canvas->links, l);
current_nodes->link_drag_id = l->id;
current_nodes->is_new_link = true;
break;
}
}
}
}
else if (current->input_released) {
if (current_nodes->snap_to_id != -1) { // Connect to input
// Force single link per input
for (int j = 0; j < canvas->links->length; ++j) {
ui_node_link_t *l = canvas->links->buffer[j];
if (l->to_id == current_nodes->snap_to_id && l->to_socket == current_nodes->snap_socket) {
ui_remove_link_at(canvas, ui_get_link_index(canvas->links, l->id));
break;
}
}
ui_node_link_t *link_drag = ui_get_link(canvas->links, current_nodes->link_drag_id);
link_drag->to_id = current_nodes->snap_to_id;
link_drag->to_socket = current_nodes->snap_socket;
current->changed = true;
if (ui_nodes_on_node_changed != NULL) {
ui_nodes_on_node_changed(ui_get_node(canvas->nodes, link_drag->to_id));
}
}
else if (current_nodes->snap_from_id != -1) { // Connect to output
ui_node_link_t *link_drag = ui_get_link(canvas->links, current_nodes->link_drag_id);
link_drag->from_id = current_nodes->snap_from_id;
link_drag->from_socket = current_nodes->snap_socket;
current->changed = true;
if (ui_nodes_on_node_changed != NULL) {
ui_nodes_on_node_changed(ui_get_node(canvas->nodes, link_drag->to_id));
}
}
else if (current_nodes->link_drag_id != -1) { // Remove dragged link
current->changed = true;
if (ui_nodes_on_link_drag != NULL) {
ui_nodes_on_link_drag(current_nodes->link_drag_id, current_nodes->is_new_link);
}
ui_remove_link_at(canvas, ui_get_link_index(canvas->links, current_nodes->link_drag_id));
}
current_nodes->snap_to_id = current_nodes->snap_from_id = -1;
current_nodes->link_drag_id = -1;
current_nodes->nodes_drag = false;
}
if (current_nodes->nodes_drag && ui_is_selected(node) && !current->input_down_r) {
if (current->input_dx != 0 || current->input_dy != 0) {
current_nodes->dragged = true;
node->x += current->input_dx / UI_NODES_SCALE();
node->y += current->input_dy / UI_NODES_SCALE();
// Absolute
// node->x = (current->input_x - current->_window_x - UI_NODES_PAN_X()) / UI_NODES_SCALE();
// node->y = (current->input_y - current->_window_y - UI_NODES_PAN_Y()) / UI_NODES_SCALE();
}
}
if (ui_nodes_grid_snap && current->input_released && ui_is_selected(node)) {
node->x = ui_nodes_snap(node->x) / UI_NODES_SCALE();
node->y = ui_nodes_snap(node->y) / UI_NODES_SCALE();
}
ui_node_draw(node, canvas);
}
if (ui_nodes_on_canvas_released != NULL && current->input_enabled && (current->input_released || current->input_released_r) && !ui_nodes_socket_released) {
ui_nodes_on_canvas_released();
}
if (node_resize != NULL) {
iron_mouse_set_cursor(IRON_CURSOR_SIZEWE);
node_resize->width += current->input_dx / UI_NODES_SCALE();
if (node_resize->width < 140) {
node_resize->width = 140;
}
if (current->input_released) {
node_resize = NULL;
}
}
else {
if (ui_box_select) {
draw_set_color(0x223333dd);
draw_filled_rect(ui_box_select_x, ui_box_select_y, current->input_x - ui_box_select_x - current->_window_x,
current->input_y - ui_box_select_y - current->_window_y);
draw_set_color(0x773333dd);
draw_rect(ui_box_select_x, ui_box_select_y, current->input_x - ui_box_select_x - current->_window_x,
current->input_y - ui_box_select_y - current->_window_y, 1);
draw_set_color(0xffffffff);
}
if (current->input_enabled && current->input_started && !current->is_alt_down && current_nodes->link_drag_id == -1 && !current_nodes->nodes_drag &&
!current->changed && ui_input_in_rect(current->_window_x, current->_window_y, current->_window_w, current->_window_h)) {
if (ui_touch_control) {
ui_touch_drag = true;
}
else {
ui_box_select = true;
ui_box_select_x = current->input_x - current->_window_x;
ui_box_select_y = current->input_y - current->_window_y;
}
}
if (ui_touch_drag) {
if (!current->input_down) {
ui_touch_drag = false;
}
current_nodes->pan_x += current->input_dx / UI_NODES_SCALE();
current_nodes->pan_y += current->input_dy / UI_NODES_SCALE();
}
if (ui_box_select && !current->input_down) {
ui_box_select = false;
int left = ui_box_select_x;
int top = ui_box_select_y;
int right = current->input_x - current->_window_x;
int bottom = current->input_y - current->_window_y;
if (left > right) {
int t = left;
left = right;
right = t;
}
if (top > bottom) {
int t = top;
top = bottom;
bottom = t;
}
ui_node_t *nodes[32];
int nodes_count = 0;
for (int j = 0; j < canvas->nodes->length; ++j) {
ui_node_t *n = canvas->nodes->buffer[j];
if (UI_NODE_X(n) + UI_NODE_W(n) > left && UI_NODE_X(n) < right && UI_NODE_Y(n) + UI_NODE_H(canvas, n) > top && UI_NODE_Y(n) < bottom) {
nodes[nodes_count] = n;
nodes_count++;
}
}
if (current->is_shift_down || current->is_ctrl_down) {
for (int j = 0; j < nodes_count; ++j) {
add_to_selection(nodes[j]);
}
}
else {
current_nodes->nodes_selected_id->length = 0;
for (int j = 0; j < nodes_count; ++j) {
add_to_selection(nodes[j]);
}
}
}
}
// Place selected node on top
if (current_nodes->move_on_top != NULL) {
int index = ui_get_node_index(canvas->nodes->buffer, canvas->nodes->length, current_nodes->move_on_top->id);
ui_remove_node_at(canvas, index);
any_array_push(canvas->nodes, current_nodes->move_on_top);
current_nodes->move_on_top = NULL;
}
// Node copy & paste
bool cut_selected = false;
if (ui_is_copy && !current->is_typing) {
ui_node_t *copy_nodes[32];
int copy_nodes_count = 0;
for (int i = 0; i < current_nodes->nodes_selected_id->length; ++i) {
int id = current_nodes->nodes_selected_id->buffer[i];
ui_node_t *n = ui_get_node(canvas->nodes, id);
if (ui_is_node_type_excluded(n->type)) {
continue;
}
copy_nodes[copy_nodes_count] = n;
copy_nodes_count++;
}
ui_node_link_t *copy_links[64];
int copy_links_count = 0;
for (int i = 0; i < canvas->links->length; ++i) {
ui_node_link_t *l = canvas->links->buffer[i];
ui_node_t *from = NULL;
for (int j = 0; j < current_nodes->nodes_selected_id->length; ++j) {
if (current_nodes->nodes_selected_id->buffer[j] == l->from_id) {
from = ui_get_node(canvas->nodes, l->from_id);
break;
}
}
ui_node_t *to = NULL;
for (int j = 0; j < current_nodes->nodes_selected_id->length; ++j) {
if (current_nodes->nodes_selected_id->buffer[j] == l->to_id) {
to = ui_get_node(canvas->nodes, l->to_id);
break;
}
}
if (from != NULL && !ui_is_node_type_excluded(from->type) && to != NULL && !ui_is_node_type_excluded(to->type)) {
copy_links[copy_links_count] = l;
copy_links_count++;
}
}
if (copy_nodes_count > 0) {
ui_node_canvas_t copy_canvas = {0};
copy_canvas.name = canvas->name;
ui_node_array_t nodes = {.buffer = copy_nodes, .length = copy_nodes_count};
ui_node_link_array_t links = {.buffer = copy_links, .length = copy_links_count};
copy_canvas.nodes = &nodes;
copy_canvas.links = &links;
ui_clipboard = ui_node_canvas_to_json(&copy_canvas);
iron_copy_to_clipboard(ui_clipboard);
}
cut_selected = ui_is_cut;
ui_is_copy = false;
ui_is_cut = false;
}
if (ui_is_paste && !current->is_typing) {
ui_is_paste = false;
bool is_json = ui_clipboard[0] == '{';
if (is_json) {
ui_node_canvas_t *paste_canvas = json_parse(ui_clipboard);
// Convert button data from string to u8 array
for (int i = 0; i < paste_canvas->nodes->length; ++i) {
for (int j = 0; j < paste_canvas->nodes->buffer[i]->buttons->length; ++j) {
ui_node_button_t *but = paste_canvas->nodes->buffer[i]->buttons->buffer[j];
if (but->data != NULL) {
char *s = string_replace_all(but->data, "\\n", "\n");
but->data = u8_array_create_from_raw((uint8_t *)s, strlen(s) + 1);
}
}
}
for (int i = 0; i < paste_canvas->links->length; ++i) {
ui_node_link_t *l = paste_canvas->links->buffer[i];
// Assign unique link id
l->id = ui_next_link_id(canvas->links);
any_array_push(canvas->links, l);
}
int offset_x = (int)(((int)(current->input_x / UI_SCALE()) * UI_NODES_SCALE() - wx - UI_NODES_PAN_X()) / UI_NODES_SCALE()) -
paste_canvas->nodes->buffer[paste_canvas->nodes->length - 1]->x;
int offset_y = (int)(((int)(current->input_y / UI_SCALE()) * UI_NODES_SCALE() - wy - UI_NODES_PAN_Y()) / UI_NODES_SCALE()) -
paste_canvas->nodes->buffer[paste_canvas->nodes->length - 1]->y;
for (int i = 0; i < paste_canvas->nodes->length; ++i) {
ui_node_t *n = paste_canvas->nodes->buffer[i];
// Assign unique node id
int old_id = n->id;
n->id = ui_next_node_id(canvas->nodes);
for (int j = 0; j < n->inputs->length; ++j) {
ui_node_socket_t *soc = n->inputs->buffer[j];
soc->id = ui_get_socket_id(canvas->nodes);
soc->node_id = n->id;
}
for (int j = 0; j < n->outputs->length; ++j) {
ui_node_socket_t *soc = n->outputs->buffer[j];
soc->id = ui_get_socket_id(canvas->nodes);
soc->node_id = n->id;
}
for (int j = 0; j < paste_canvas->links->length; ++j) {
ui_node_link_t *l = paste_canvas->links->buffer[j];
if (l->from_id == old_id)
l->from_id = n->id;
else if (l->to_id == old_id)
l->to_id = n->id;
}
n->x += offset_x;
n->y += offset_y;
any_array_push(canvas->nodes, n);
}
current_nodes->nodes_drag = true;
current_nodes->nodes_selected_id->length = 0;
for (int i = 0; i < paste_canvas->nodes->length; ++i) {
i32_array_push(current_nodes->nodes_selected_id, paste_canvas->nodes->buffer[i]->id);
}
current->changed = true;
}
}
// Select all nodes
if (current->is_ctrl_down && current->key_code == KEY_CODE_A && !current->is_typing) {
current_nodes->nodes_selected_id->length = 0;
for (int i = 0; i < canvas->nodes->length; ++i) {
add_to_selection(canvas->nodes->buffer[i]);
}
}
// Node removal
bool node_removal = current->input_enabled && (current->is_backspace_down || current->is_delete_down) && !current->is_typing;
if (node_removal || cut_selected) {
int i = current_nodes->nodes_selected_id->length - 1;
while (i >= 0) {
int nid = current_nodes->nodes_selected_id->buffer[i--];
ui_node_t *n = ui_get_node(canvas->nodes, nid);
if (ui_is_node_type_excluded(n->type)) {
n->flags ^= UI_NODE_FLAG_COLLAPSED;
continue;
}
ui_remove_node(n, canvas);
current->changed = true;
}
current_nodes->nodes_selected_id->length = 0;
}
// Node duplicate
bool node_duplicate = current->input_enabled && current->is_ctrl_down && current->is_key_pressed && current->key_code == KEY_CODE_D && !current->is_typing;
if (current_nodes->nodes_selected_id->length > 0 && node_duplicate) {
ui_is_copy = true;
ui_is_paste = true;
}
ui_set_scale(current_nodes->scale_factor); // Restore non-zoomed scale
current->elements_baked = true;
current->input_enabled = _input_enabled;
if (ui_popup_commands != NULL) {
current->_x = ui_popup_x;
current->_y = ui_popup_y;
current->_w = ui_popup_w;
ui_draw_shadow(current->_x - 5, current->_y - 5, current->_w + 10, ui_popup_h * UI_SCALE() + 10);
draw_set_color(current->ops->theme->SEPARATOR_COL);
ui_draw_rect(true, true, current->_x - 5, current->_y - 5, current->_w + 10, ui_popup_h * UI_SCALE() + 10);
(*ui_popup_commands)(current, ui_popup_data, ui_popup_data2);
bool hide = (current->input_started || current->input_started_r) &&
(current->input_x - wx < ui_popup_x - 6 || current->input_x - wx > ui_popup_x + ui_popup_w + 6 || current->input_y - wy < ui_popup_y - 6 ||
current->input_y - wy > ui_popup_y + ui_popup_h * UI_SCALE() + 6);
if (hide || current->is_escape_down) {
ui_popup_commands = NULL;
ui_nodes_on_node_changed(ui_get_node(canvas->nodes, ui_popup_handle_node_id));
current->changed = false;
}
}
}
void ui_node_canvas_encode(ui_node_canvas_t *canvas) {
// armpack_encode_start(encoded);
armpack_encode_map(3);
armpack_encode_string("name");
armpack_encode_string(canvas->name);
armpack_encode_string("nodes");
armpack_encode_array(canvas->nodes->length);
for (int i = 0; i < canvas->nodes->length; ++i) {
armpack_encode_map(11);
armpack_encode_string("id");
armpack_encode_i32(canvas->nodes->buffer[i]->id);
armpack_encode_string("name");
armpack_encode_string(canvas->nodes->buffer[i]->name);
armpack_encode_string("type");
armpack_encode_string(canvas->nodes->buffer[i]->type);
armpack_encode_string("x");
armpack_encode_f32(canvas->nodes->buffer[i]->x);
armpack_encode_string("y");
armpack_encode_f32(canvas->nodes->buffer[i]->y);
armpack_encode_string("color");
armpack_encode_i32(canvas->nodes->buffer[i]->color);
armpack_encode_string("inputs");
armpack_encode_array(canvas->nodes->buffer[i]->inputs->length);
for (int j = 0; j < canvas->nodes->buffer[i]->inputs->length; ++j) {
armpack_encode_map(10);
armpack_encode_string("id");
armpack_encode_i32(canvas->nodes->buffer[i]->inputs->buffer[j]->id);
armpack_encode_string("node_id");
armpack_encode_i32(canvas->nodes->buffer[i]->inputs->buffer[j]->node_id);
armpack_encode_string("name");
armpack_encode_string(canvas->nodes->buffer[i]->inputs->buffer[j]->name);
armpack_encode_string("type");
armpack_encode_string(canvas->nodes->buffer[i]->inputs->buffer[j]->type);
armpack_encode_string("color");
armpack_encode_i32(canvas->nodes->buffer[i]->inputs->buffer[j]->color);
armpack_encode_string("default_value");
armpack_encode_array_f32(canvas->nodes->buffer[i]->inputs->buffer[j]->default_value);
armpack_encode_string("min");
armpack_encode_f32(canvas->nodes->buffer[i]->inputs->buffer[j]->min);
armpack_encode_string("max");
armpack_encode_f32(canvas->nodes->buffer[i]->inputs->buffer[j]->max);
armpack_encode_string("precision");
armpack_encode_f32(canvas->nodes->buffer[i]->inputs->buffer[j]->precision);
armpack_encode_string("display");
armpack_encode_i32(canvas->nodes->buffer[i]->inputs->buffer[j]->display);
}
armpack_encode_string("outputs");
armpack_encode_array(canvas->nodes->buffer[i]->outputs->length);
for (int j = 0; j < canvas->nodes->buffer[i]->outputs->length; ++j) {
armpack_encode_map(10);
armpack_encode_string("id");
armpack_encode_i32(canvas->nodes->buffer[i]->outputs->buffer[j]->id);
armpack_encode_string("node_id");
armpack_encode_i32(canvas->nodes->buffer[i]->outputs->buffer[j]->node_id);
armpack_encode_string("name");
armpack_encode_string(canvas->nodes->buffer[i]->outputs->buffer[j]->name);
armpack_encode_string("type");
armpack_encode_string(canvas->nodes->buffer[i]->outputs->buffer[j]->type);
armpack_encode_string("color");
armpack_encode_i32(canvas->nodes->buffer[i]->outputs->buffer[j]->color);
armpack_encode_string("default_value");
armpack_encode_array_f32(canvas->nodes->buffer[i]->outputs->buffer[j]->default_value);
armpack_encode_string("min");
armpack_encode_f32(canvas->nodes->buffer[i]->outputs->buffer[j]->min);
armpack_encode_string("max");
armpack_encode_f32(canvas->nodes->buffer[i]->outputs->buffer[j]->max);
armpack_encode_string("precision");
armpack_encode_f32(canvas->nodes->buffer[i]->outputs->buffer[j]->precision);
armpack_encode_string("display");
armpack_encode_i32(canvas->nodes->buffer[i]->outputs->buffer[j]->display);
}
armpack_encode_string("buttons");
armpack_encode_array(canvas->nodes->buffer[i]->buttons->length);
for (int j = 0; j < canvas->nodes->buffer[i]->buttons->length; ++j) {
armpack_encode_map(9);
armpack_encode_string("name");
armpack_encode_string(canvas->nodes->buffer[i]->buttons->buffer[j]->name);
armpack_encode_string("type");
armpack_encode_string(canvas->nodes->buffer[i]->buttons->buffer[j]->type);
armpack_encode_string("output");
armpack_encode_i32(canvas->nodes->buffer[i]->buttons->buffer[j]->output);
armpack_encode_string("default_value");
armpack_encode_array_f32(canvas->nodes->buffer[i]->buttons->buffer[j]->default_value);
armpack_encode_string("data");
u8_array_t *u8 = canvas->nodes->buffer[i]->buttons->buffer[j]->data;
armpack_encode_array_u8(u8);
armpack_encode_string("min");
armpack_encode_f32(canvas->nodes->buffer[i]->buttons->buffer[j]->min);
armpack_encode_string("max");
armpack_encode_f32(canvas->nodes->buffer[i]->buttons->buffer[j]->max);
armpack_encode_string("precision");
armpack_encode_f32(canvas->nodes->buffer[i]->buttons->buffer[j]->precision);
armpack_encode_string("height");
armpack_encode_f32(canvas->nodes->buffer[i]->buttons->buffer[j]->height);
}
armpack_encode_string("width");
armpack_encode_f32(canvas->nodes->buffer[i]->width);
armpack_encode_string("flags");
armpack_encode_i32(canvas->nodes->buffer[i]->flags);
}
armpack_encode_string("links");
armpack_encode_array(canvas->links->length);
for (int i = 0; i < canvas->links->length; ++i) {
armpack_encode_map(5);
armpack_encode_string("id");
armpack_encode_i32(canvas->links->buffer[i]->id);
armpack_encode_string("from_id");
armpack_encode_i32(canvas->links->buffer[i]->from_id);
armpack_encode_string("from_socket");
armpack_encode_i32(canvas->links->buffer[i]->from_socket);
armpack_encode_string("to_id");
armpack_encode_i32(canvas->links->buffer[i]->to_id);
armpack_encode_string("to_socket");
armpack_encode_i32(canvas->links->buffer[i]->to_socket);
}
}
uint32_t ui_node_canvas_encoded_size(ui_node_canvas_t *canvas) {
uint32_t size = 0;
size += armpack_size_map();
size += armpack_size_string("name");
size += armpack_size_string(canvas->name);
size += armpack_size_string("nodes");
size += armpack_size_array();
for (int i = 0; i < canvas->nodes->length; ++i) {
size += armpack_size_map();
size += armpack_size_string("id");
size += armpack_size_i32();
size += armpack_size_string("name");
size += armpack_size_string(canvas->nodes->buffer[i]->name);
size += armpack_size_string("type");
size += armpack_size_string(canvas->nodes->buffer[i]->type);
size += armpack_size_string("x");
size += armpack_size_f32();
size += armpack_size_string("y");
size += armpack_size_f32();
size += armpack_size_string("color");
size += armpack_size_i32();
size += armpack_size_string("inputs");
size += armpack_size_array();
for (int j = 0; j < canvas->nodes->buffer[i]->inputs->length; ++j) {
size += armpack_size_map();
size += armpack_size_string("id");
size += armpack_size_i32();
size += armpack_size_string("node_id");
size += armpack_size_i32();
size += armpack_size_string("name");
size += armpack_size_string(canvas->nodes->buffer[i]->inputs->buffer[j]->name);
size += armpack_size_string("type");
size += armpack_size_string(canvas->nodes->buffer[i]->inputs->buffer[j]->type);
size += armpack_size_string("color");
size += armpack_size_i32();
size += armpack_size_string("default_value");
size += armpack_size_array_f32(canvas->nodes->buffer[i]->inputs->buffer[j]->default_value);
size += armpack_size_string("min");
size += armpack_size_f32();
size += armpack_size_string("max");
size += armpack_size_f32();
size += armpack_size_string("precision");
size += armpack_size_f32();
size += armpack_size_string("display");
size += armpack_size_i32();
}
size += armpack_size_string("outputs");
size += armpack_size_array();
for (int j = 0; j < canvas->nodes->buffer[i]->outputs->length; ++j) {
size += armpack_size_map();
size += armpack_size_string("id");
size += armpack_size_i32();
size += armpack_size_string("node_id");
size += armpack_size_i32();
size += armpack_size_string("name");
size += armpack_size_string(canvas->nodes->buffer[i]->outputs->buffer[j]->name);
size += armpack_size_string("type");
size += armpack_size_string(canvas->nodes->buffer[i]->outputs->buffer[j]->type);
size += armpack_size_string("color");
size += armpack_size_i32();
size += armpack_size_string("default_value");
size += armpack_size_array_f32(canvas->nodes->buffer[i]->outputs->buffer[j]->default_value);
size += armpack_size_string("min");
size += armpack_size_f32();
size += armpack_size_string("max");
size += armpack_size_f32();
size += armpack_size_string("precision");
size += armpack_size_f32();
size += armpack_size_string("display");
size += armpack_size_i32();
}
size += armpack_size_string("buttons");
size += armpack_size_array();
for (int j = 0; j < canvas->nodes->buffer[i]->buttons->length; ++j) {
size += armpack_size_map();
size += armpack_size_string("name");
size += armpack_size_string(canvas->nodes->buffer[i]->buttons->buffer[j]->name);
size += armpack_size_string("type");
size += armpack_size_string(canvas->nodes->buffer[i]->buttons->buffer[j]->type);
size += armpack_size_string("output");
size += armpack_size_i32();
size += armpack_size_string("default_value");
size += armpack_size_array_f32(canvas->nodes->buffer[i]->buttons->buffer[j]->default_value);
size += armpack_size_string("data");
u8_array_t *u8 = canvas->nodes->buffer[i]->buttons->buffer[j]->data;
size += armpack_size_array_u8(u8);
size += armpack_size_string("min");
size += armpack_size_f32();
size += armpack_size_string("max");
size += armpack_size_f32();
size += armpack_size_string("precision");
size += armpack_size_f32();
size += armpack_size_string("height");
size += armpack_size_f32();
}
size += armpack_size_string("width");
size += armpack_size_f32();
size += armpack_size_string("flags");
size += armpack_size_i32();
}
size += armpack_size_string("links");
size += armpack_size_array();
for (int i = 0; i < canvas->links->length; ++i) {
size += armpack_size_map();
size += armpack_size_string("id");
size += armpack_size_i32();
size += armpack_size_string("from_id");
size += armpack_size_i32();
size += armpack_size_string("from_socket");
size += armpack_size_i32();
size += armpack_size_string("to_id");
size += armpack_size_i32();
size += armpack_size_string("to_socket");
size += armpack_size_i32();
}
return size;
}
char *ui_node_canvas_to_json(ui_node_canvas_t *canvas) {
json_encode_begin();
json_encode_string("name", canvas->name);
json_encode_begin_array("nodes");
for (int i = 0; i < canvas->nodes->length; ++i) {
json_encode_begin_object();
json_encode_i32("id", canvas->nodes->buffer[i]->id);
json_encode_string("name", canvas->nodes->buffer[i]->name);
json_encode_string("type", canvas->nodes->buffer[i]->type);
json_encode_f32("x", canvas->nodes->buffer[i]->x);
json_encode_f32("y", canvas->nodes->buffer[i]->y);
json_encode_i32("color", canvas->nodes->buffer[i]->color);
json_encode_begin_array("inputs");
for (int j = 0; j < canvas->nodes->buffer[i]->inputs->length; ++j) {
json_encode_begin_object();
json_encode_i32("id", canvas->nodes->buffer[i]->inputs->buffer[j]->id);
json_encode_i32("node_id", canvas->nodes->buffer[i]->inputs->buffer[j]->node_id);
json_encode_string("name", canvas->nodes->buffer[i]->inputs->buffer[j]->name);
json_encode_string("type", canvas->nodes->buffer[i]->inputs->buffer[j]->type);
json_encode_i32("color", canvas->nodes->buffer[i]->inputs->buffer[j]->color);
json_encode_f32_array("default_value", canvas->nodes->buffer[i]->inputs->buffer[j]->default_value);
json_encode_f32("min", canvas->nodes->buffer[i]->inputs->buffer[j]->min);
json_encode_f32("max", canvas->nodes->buffer[i]->inputs->buffer[j]->max);
json_encode_f32("precision", canvas->nodes->buffer[i]->inputs->buffer[j]->precision);
json_encode_i32("display", canvas->nodes->buffer[i]->inputs->buffer[j]->display);
json_encode_end_object();
}
json_encode_end_array();
json_encode_begin_array("outputs");
for (int j = 0; j < canvas->nodes->buffer[i]->outputs->length; ++j) {
json_encode_begin_object();
json_encode_i32("id", canvas->nodes->buffer[i]->outputs->buffer[j]->id);
json_encode_i32("node_id", canvas->nodes->buffer[i]->outputs->buffer[j]->node_id);
json_encode_string("name", canvas->nodes->buffer[i]->outputs->buffer[j]->name);
json_encode_string("type", canvas->nodes->buffer[i]->outputs->buffer[j]->type);
json_encode_i32("color", canvas->nodes->buffer[i]->outputs->buffer[j]->color);
json_encode_f32_array("default_value", canvas->nodes->buffer[i]->outputs->buffer[j]->default_value);
json_encode_f32("min", canvas->nodes->buffer[i]->outputs->buffer[j]->min);
json_encode_f32("max", canvas->nodes->buffer[i]->outputs->buffer[j]->max);
json_encode_f32("precision", canvas->nodes->buffer[i]->outputs->buffer[j]->precision);
json_encode_i32("display", canvas->nodes->buffer[i]->outputs->buffer[j]->display);
json_encode_end_object();
}
json_encode_end_array();
json_encode_begin_array("buttons");
for (int j = 0; j < canvas->nodes->buffer[i]->buttons->length; ++j) {
json_encode_begin_object();
json_encode_string("name", canvas->nodes->buffer[i]->buttons->buffer[j]->name);
json_encode_string("type", canvas->nodes->buffer[i]->buttons->buffer[j]->type);
json_encode_i32("output", canvas->nodes->buffer[i]->buttons->buffer[j]->output);
json_encode_f32_array("default_value", canvas->nodes->buffer[i]->buttons->buffer[j]->default_value);
u8_array_t *data = canvas->nodes->buffer[i]->buttons->buffer[j]->data;
if (data != NULL) {
char *s = string_replace_all((char *)data->buffer, "\n", "\\n");
json_encode_string("data", s);
}
else {
json_encode_null("data");
}
json_encode_f32("min", canvas->nodes->buffer[i]->buttons->buffer[j]->min);
json_encode_f32("max", canvas->nodes->buffer[i]->buttons->buffer[j]->max);
json_encode_f32("precision", canvas->nodes->buffer[i]->buttons->buffer[j]->precision);
json_encode_f32("height", canvas->nodes->buffer[i]->buttons->buffer[j]->height);
json_encode_end_object();
}
json_encode_end_array();
json_encode_f32("width", canvas->nodes->buffer[i]->width);
json_encode_i32("flags", canvas->nodes->buffer[i]->flags);
json_encode_end_object();
}
json_encode_end_array();
json_encode_begin_array("links");
for (int i = 0; i < canvas->links->length; ++i) {
json_encode_begin_object();
json_encode_i32("id", canvas->links->buffer[i]->id);
json_encode_i32("from_id", canvas->links->buffer[i]->from_id);
json_encode_i32("from_socket", canvas->links->buffer[i]->from_socket);
json_encode_i32("to_id", canvas->links->buffer[i]->to_id);
json_encode_i32("to_socket", canvas->links->buffer[i]->to_socket);
json_encode_end_object();
}
json_encode_end_array();
return json_encode_end();
}
////
f32 ui_nodes_INPUT_Y(ui_node_canvas_t *canvas, ui_node_t *node, i32 pos) {
return UI_INPUT_Y(canvas, node, pos);
}
extern any_map_t *ui_nodes_custom_buttons;
void nodes_on_custom_button(i32 node_id, char *button_name) {
void (*f)(i32) = any_map_get(ui_nodes_custom_buttons, button_name);
f(node_id);
}
ui_nodes_t *ui_nodes_create() {
ui_nodes_t *raw = ALLOC_INIT(ui_nodes_t, {0});
ui_nodes_init(raw);
ui_nodes_exclude_remove = any_array_create_from_raw(
(void *[]){
"OUTPUT_MATERIAL_PBR",
"GROUP_OUTPUT",
"GROUP_INPUT",
"brush_output_node",
},
4);
ui_nodes_on_custom_button = nodes_on_custom_button;
return raw;
}
typedef struct ui_node_t_array {
ui_node_t **buffer;
int length;
int capacity;
} ui_node_t_array_t;
ui_node_socket_t *ui_get_socket(ui_node_t_array_t *nodes, i32 id) {
for (i32 i = 0; i < nodes->length; ++i) {
ui_node_t *n = nodes->buffer[i];
for (i32 j = 0; j < n->inputs->length; ++j) {
ui_node_socket_t *s = n->inputs->buffer[j];
if (s->id == id) {
return s;
}
}
for (i32 j = 0; j < n->outputs->length; ++j) {
ui_node_socket_t *s = n->outputs->buffer[j];
if (s->id == id) {
return s;
}
}
}
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink