Peaceultime/flecs_tests
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
c4d657043c8b429a85dd4e08b336f1fec68bb21f
flecs_tests/diff_output.patch

1832 lines
74 KiB
Diff
Raw Blame History

diff --git a/src/api.h b/src/api.h
index dd80adf..a4707c7 100644
--- a/src/api.h
+++ b/src/api.h
@@ -27,6 +27,21 @@
#include "generated/sprite.h"
#include "generated/shape.h"
+#include "generated/overlay.h"
+
+// Log-to-panel infrastructure
+static void (*g_panel_log_fn)(void*, int, const char*) = NULL;
+static void *g_panel_log_ud = NULL;
+
+static void panel_log(int level, const char *fmt, ...) {
+ if (!g_panel_log_fn) return;
+ char buf[256];
+ va_list ap;
+ va_start(ap, fmt);
+ vsnprintf(buf, sizeof(buf), fmt, ap);
+ va_end(ap);
+ g_panel_log_fn(g_panel_log_ud, level, buf);
+}
#include "util.h"
#include "shape.h"
diff --git a/src/draw.h b/src/draw.h
index 17ad292..e22234b 100644
--- a/src/draw.h
+++ b/src/draw.h
@@ -9,20 +9,109 @@ static void draw_shapes(userdata_t *ud)
if (g_shape_pool_dirty)
shape_pool_rebuild(&ud->shapes);
- if (ud->shapes.count == 0) return;
+ int n = ud->shapes.count;
+ if (n == 0) return;
+
+ if (g_shape_data_dirty) {
+ shape_upload_data(&ud->shapes);
+ g_shape_data_dirty = false;
+ }
+ panel_log(3, "[shapes] draw_shapes: n=%d pipeline=%d", n, shape_pipeline.id);
+
+ static uint32_t *imap = NULL;
+ static int imap_cap = 0;
+ static uint32_t *ne_counts = NULL;
+ static uint32_t *ne_starts = NULL;
+ static int ne_cap = 0;
+
+ if (n > imap_cap) {
+ if (imap) FREE(imap);
+ imap = (uint32_t*) ALLOC((size_t)n * sizeof(uint32_t));
+ imap_cap = n;
+ }
+
+ // Group shapes by num_elements using counting sort
+ uint32_t max_ne = 0;
+ for (int i = 0; i < n; i++) {
+ uint32_t ne = ((shape_t*) vec_get(&ud->shapes, i))->num_elements;
+ if (ne > max_ne) max_ne = ne;
+ }
+
+ int ne_size = (int)(max_ne + 1);
+ if (ne_size > ne_cap) {
+ if (ne_counts) FREE(ne_counts);
+ if (ne_starts) FREE(ne_starts);
+ ne_counts = (uint32_t*) ALLOC((size_t)ne_size * sizeof(uint32_t));
+ ne_starts = (uint32_t*) ALLOC((size_t)ne_size * sizeof(uint32_t));
+ ne_cap = ne_size;
+ }
+ memset(ne_counts, 0, (size_t)ne_size * sizeof(uint32_t));
+
+ for (int i = 0; i < n; i++) {
+ uint32_t ne = ((shape_t*) vec_get(&ud->shapes, i))->num_elements;
+ ne_counts[ne]++;
+ }
+
+ uint32_t pos = 0;
+ for (uint32_t ne = 0; ne <= max_ne; ne++) {
+ ne_starts[ne] = pos;
+ pos += ne_counts[ne];
+ ne_counts[ne] = 0;
+ }
+
+ for (int i = 0; i < n; i++) {
+ uint32_t ne = ((shape_t*) vec_get(&ud->shapes, i))->num_elements;
+ imap[ne_starts[ne] + ne_counts[ne]++] = (uint32_t)i;
+ }
+
+ shape_upload_instance_map(imap, n);
sg_apply_pipeline(shape_pipeline);
- sg_apply_bindings(&(sg_bindings){
- .vertex_buffers[0] = g_shape_vbuf,
- .index_buffer = g_shape_ibuf,
- });
- for (int i = 0; i < ud->shapes.count; i++) {
- shape_draw((shape_t*) vec_get(&ud->shapes, i), &ud->renderer.uniform.mvp);
+
+ int base = 0;
+ while (base < n) {
+ shape_t *s = (shape_t*) vec_get(&ud->shapes, imap[base]);
+ uint32_t ne = s->num_elements;
+ int count = 1;
+ while (base + count < n &&
+ ((shape_t*) vec_get(&ud->shapes, imap[base + count]))->num_elements == ne)
+ count++;
+
+ // Find the vertex buffer for this num_elements
+ sg_buffer group_vbuf = {0};
+ for (int gi = 0; gi < g_shape_group_count; gi++) {
+ if (g_shape_groups[gi].num_elements == ne) {
+ group_vbuf = g_shape_groups[gi].vbuf;
+ break;
+ }
+ }
+
+ struct { mat4 mvp; uint32_t base; uint8_t _pad[12]; } vs_u;
+ memcpy(vs_u.mvp, ud->renderer.uniform.mvp, sizeof(mat4));
+ vs_u.base = (uint32_t)base;
+ memset(vs_u._pad, 0, 12);
+ sg_apply_uniforms(0, &SG_RANGE(vs_u));
+
+ sg_apply_bindings(&(sg_bindings){
+ .vertex_buffers[0] = group_vbuf,
+ .views[0] = g_shape_data_view,
+ .views[1] = g_instance_map_view,
+ });
+ panel_log(3, "[shapes] draw group: ne=%u count=%d base=%d vbuf=%d data_view=%d imap_view=%d",
+ ne, count, base, group_vbuf.id, g_shape_data_view.id, g_instance_map_view.id);
+ sg_draw(0, (int)ne, count);
+
+ base += count;
}
+
}
static void draw_overlay_and_handles(userdata_t *ud, bool has_overlay, bool show_handle)
{
+ sg_apply_pipeline(overlay_pipeline);
+ panel_log(3, "[shapes] draw_overlay: pipeline=%d has_ov=%d show_h=%d",
+ overlay_pipeline.id, has_overlay, show_handle);
+
if (has_overlay) {
shape_uniform_t u;
glm_mat4_identity(u.transform);
diff --git a/src/generated/shape.h b/src/generated/shape.h
index c5e95d0..a35c0b1 100644
--- a/src/generated/shape.h
+++ b/src/generated/shape.h
@@ -2,90 +2,109 @@ unsigned char src_shaders_shape_wgsl[] = {
0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x56, 0x73, 0x55, 0x6e, 0x69,
0x66, 0x6f, 0x72, 0x6d, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6d,
0x76, 0x70, 0x3a, 0x20, 0x6d, 0x61, 0x74, 0x34, 0x78, 0x34, 0x66, 0x2c,
+ 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63,
+ 0x65, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x3a, 0x20, 0x75, 0x33, 0x32, 0x2c,
0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20,
- 0x53, 0x68, 0x61, 0x70, 0x65, 0x55, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d,
- 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73,
- 0x66, 0x6f, 0x72, 0x6d, 0x3a, 0x20, 0x6d, 0x61, 0x74, 0x34, 0x78, 0x34,
- 0x66, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65,
- 0x3a, 0x20, 0x75, 0x33, 0x32, 0x2c, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73,
- 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x56, 0x73, 0x49, 0x6e, 0x20, 0x7b,
- 0x0a, 0x20, 0x20, 0x20, 0x20, 0x40, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69,
- 0x6f, 0x6e, 0x28, 0x30, 0x29, 0x20, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69,
- 0x6f, 0x6e, 0x3a, 0x20, 0x76, 0x65, 0x63, 0x32, 0x66, 0x2c, 0x0a, 0x7d,
+ 0x53, 0x68, 0x61, 0x70, 0x65, 0x44, 0x61, 0x74, 0x61, 0x20, 0x7b, 0x0a,
+ 0x20, 0x20, 0x20, 0x20, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72,
+ 0x6d, 0x3a, 0x20, 0x6d, 0x61, 0x74, 0x34, 0x78, 0x34, 0x66, 0x2c, 0x0a,
+ 0x20, 0x20, 0x20, 0x20, 0x73, 0x74, 0x61, 0x74, 0x65, 0x3a, 0x20, 0x75,
+ 0x33, 0x32, 0x2c, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x40, 0x62, 0x69, 0x6e,
+ 0x64, 0x69, 0x6e, 0x67, 0x28, 0x30, 0x29, 0x20, 0x40, 0x67, 0x72, 0x6f,
+ 0x75, 0x70, 0x28, 0x30, 0x29, 0x20, 0x76, 0x61, 0x72, 0x3c, 0x75, 0x6e,
+ 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x3e, 0x20, 0x76, 0x73, 0x5f, 0x75, 0x6e,
+ 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x3a, 0x20, 0x56, 0x73, 0x55, 0x6e,
+ 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x3b, 0x0a, 0x0a, 0x40, 0x62, 0x69, 0x6e,
+ 0x64, 0x69, 0x6e, 0x67, 0x28, 0x30, 0x29, 0x20, 0x40, 0x67, 0x72, 0x6f,
+ 0x75, 0x70, 0x28, 0x31, 0x29, 0x20, 0x76, 0x61, 0x72, 0x3c, 0x73, 0x74,
+ 0x6f, 0x72, 0x61, 0x67, 0x65, 0x3e, 0x20, 0x73, 0x68, 0x61, 0x70, 0x65,
+ 0x5f, 0x64, 0x61, 0x74, 0x61, 0x3a, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79,
+ 0x3c, 0x53, 0x68, 0x61, 0x70, 0x65, 0x44, 0x61, 0x74, 0x61, 0x3e, 0x3b,
+ 0x0a, 0x40, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x28, 0x31, 0x29,
+ 0x20, 0x40, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x28, 0x31, 0x29, 0x20, 0x76,
+ 0x61, 0x72, 0x3c, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x3e, 0x20,
+ 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6d, 0x61, 0x70,
+ 0x3a, 0x20, 0x61, 0x72, 0x72, 0x61, 0x79, 0x3c, 0x75, 0x33, 0x32, 0x3e,
0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x56, 0x73,
- 0x32, 0x46, 0x73, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x40, 0x62,
- 0x75, 0x69, 0x6c, 0x74, 0x69, 0x6e, 0x28, 0x70, 0x6f, 0x73, 0x69, 0x74,
- 0x69, 0x6f, 0x6e, 0x29, 0x20, 0x70, 0x6f, 0x73, 0x3a, 0x20, 0x76, 0x65,
- 0x63, 0x34, 0x66, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x40, 0x6c, 0x6f,
- 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x30, 0x29, 0x20, 0x40, 0x69,
- 0x6e, 0x74, 0x65, 0x72, 0x70, 0x6f, 0x6c, 0x61, 0x74, 0x65, 0x28, 0x6c,
- 0x69, 0x6e, 0x65, 0x61, 0x72, 0x29, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
- 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x2c, 0x0a, 0x7d, 0x3b, 0x0a,
- 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20, 0x46, 0x73, 0x4f, 0x75,
- 0x74, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x40, 0x6c, 0x6f, 0x63,
- 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x30, 0x29, 0x20, 0x63, 0x6f, 0x6c,
- 0x6f, 0x72, 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x2c, 0x0a, 0x7d,
- 0x3b, 0x0a, 0x0a, 0x40, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x28,
- 0x30, 0x29, 0x20, 0x40, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x28, 0x30, 0x29,
- 0x20, 0x76, 0x61, 0x72, 0x3c, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d,
- 0x3e, 0x20, 0x76, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d,
- 0x73, 0x3a, 0x20, 0x56, 0x73, 0x55, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d,
- 0x3b, 0x0a, 0x40, 0x62, 0x69, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x28, 0x31,
- 0x29, 0x20, 0x40, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x28, 0x30, 0x29, 0x20,
- 0x76, 0x61, 0x72, 0x3c, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x3e,
- 0x20, 0x73, 0x68, 0x61, 0x70, 0x65, 0x5f, 0x75, 0x6e, 0x69, 0x66, 0x6f,
- 0x72, 0x6d, 0x3a, 0x20, 0x53, 0x68, 0x61, 0x70, 0x65, 0x55, 0x6e, 0x69,
- 0x66, 0x6f, 0x72, 0x6d, 0x3b, 0x0a, 0x0a, 0x40, 0x76, 0x65, 0x72, 0x74,
+ 0x49, 0x6e, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x40, 0x62, 0x75,
+ 0x69, 0x6c, 0x74, 0x69, 0x6e, 0x28, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e,
+ 0x63, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x29, 0x20, 0x69, 0x6e,
+ 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x78, 0x3a, 0x20,
+ 0x75, 0x33, 0x32, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x40, 0x6c, 0x6f,
+ 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x30, 0x29, 0x20, 0x70, 0x6f,
+ 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x3a, 0x20, 0x76, 0x65, 0x63, 0x32,
+ 0x66, 0x2c, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63,
+ 0x74, 0x20, 0x56, 0x73, 0x32, 0x46, 0x73, 0x20, 0x7b, 0x0a, 0x20, 0x20,
+ 0x20, 0x20, 0x40, 0x62, 0x75, 0x69, 0x6c, 0x74, 0x69, 0x6e, 0x28, 0x70,
+ 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x29, 0x20, 0x70, 0x6f, 0x73,
+ 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x2c, 0x0a, 0x20, 0x20, 0x20,
+ 0x20, 0x40, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x30,
+ 0x29, 0x20, 0x40, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x6f, 0x6c, 0x61,
+ 0x74, 0x65, 0x28, 0x6c, 0x69, 0x6e, 0x65, 0x61, 0x72, 0x29, 0x20, 0x63,
+ 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x2c,
+ 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x20,
+ 0x46, 0x73, 0x4f, 0x75, 0x74, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20,
+ 0x40, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x30, 0x29,
+ 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x76, 0x65, 0x63, 0x34,
+ 0x66, 0x2c, 0x0a, 0x7d, 0x3b, 0x0a, 0x0a, 0x40, 0x76, 0x65, 0x72, 0x74,
0x65, 0x78, 0x20, 0x66, 0x6e, 0x20, 0x76, 0x73, 0x5f, 0x6d, 0x61, 0x69,
0x6e, 0x28, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x3a, 0x20, 0x56, 0x73, 0x49,
0x6e, 0x29, 0x20, 0x2d, 0x3e, 0x20, 0x56, 0x73, 0x32, 0x46, 0x73, 0x20,
0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x75,
0x74, 0x70, 0x75, 0x74, 0x3a, 0x20, 0x56, 0x73, 0x32, 0x46, 0x73, 0x3b,
- 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x65, 0x74, 0x20, 0x77, 0x6f, 0x72,
- 0x6c, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x68, 0x61,
- 0x70, 0x65, 0x5f, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x74,
- 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x2a, 0x20, 0x76,
- 0x65, 0x63, 0x34, 0x66, 0x28, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2e, 0x70,
- 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x78, 0x2c, 0x20, 0x69,
- 0x6e, 0x70, 0x75, 0x74, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f,
- 0x6e, 0x2e, 0x79, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20, 0x31, 0x2e,
- 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x70,
- 0x75, 0x74, 0x2e, 0x70, 0x6f, 0x73, 0x20, 0x3d, 0x20, 0x76, 0x73, 0x5f,
- 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x2e, 0x6d, 0x76, 0x70,
- 0x20, 0x2a, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x5f, 0x70, 0x6f, 0x73,
- 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x28, 0x73, 0x68,
- 0x61, 0x70, 0x65, 0x5f, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x2e,
- 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x32, 0x75, 0x29,
+ 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x65, 0x74, 0x20, 0x73, 0x68, 0x61,
+ 0x70, 0x65, 0x5f, 0x69, 0x64, 0x78, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73,
+ 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x6d, 0x61, 0x70, 0x5b, 0x76, 0x73,
+ 0x5f, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x73, 0x2e, 0x69, 0x6e,
+ 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x62, 0x61, 0x73, 0x65, 0x20,
+ 0x2b, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2e, 0x69, 0x6e, 0x73, 0x74,
+ 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x69, 0x64, 0x78, 0x5d, 0x3b, 0x0a, 0x20,
+ 0x20, 0x20, 0x20, 0x6c, 0x65, 0x74, 0x20, 0x73, 0x68, 0x61, 0x70, 0x65,
+ 0x20, 0x3d, 0x20, 0x73, 0x68, 0x61, 0x70, 0x65, 0x5f, 0x64, 0x61, 0x74,
+ 0x61, 0x5b, 0x73, 0x68, 0x61, 0x70, 0x65, 0x5f, 0x69, 0x64, 0x78, 0x5d,
+ 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x65, 0x74, 0x20, 0x77, 0x6f,
+ 0x72, 0x6c, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x20, 0x3d, 0x20, 0x73, 0x68,
+ 0x61, 0x70, 0x65, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x6f, 0x72,
+ 0x6d, 0x20, 0x2a, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x28, 0x69, 0x6e,
+ 0x70, 0x75, 0x74, 0x2e, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e,
+ 0x2e, 0x78, 0x2c, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2e, 0x70, 0x6f,
+ 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x79, 0x2c, 0x20, 0x30, 0x2e,
+ 0x30, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20,
+ 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x70, 0x6f, 0x73, 0x20,
+ 0x3d, 0x20, 0x76, 0x73, 0x5f, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d,
+ 0x73, 0x2e, 0x6d, 0x76, 0x70, 0x20, 0x2a, 0x20, 0x77, 0x6f, 0x72, 0x6c,
+ 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69,
+ 0x66, 0x20, 0x28, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2e, 0x73, 0x74, 0x61,
+ 0x74, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x32, 0x75, 0x29, 0x20, 0x7b, 0x0a,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75, 0x74, 0x70,
+ 0x75, 0x74, 0x2e, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x76,
+ 0x65, 0x63, 0x34, 0x66, 0x28, 0x31, 0x2e, 0x30, 0x2c, 0x20, 0x30, 0x2e,
+ 0x38, 0x34, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20, 0x31, 0x2e, 0x30,
+ 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c, 0x73,
+ 0x65, 0x20, 0x69, 0x66, 0x20, 0x28, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2e,
+ 0x73, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x75, 0x29,
0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6f,
0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20,
- 0x3d, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x28, 0x31, 0x2e, 0x30, 0x2c,
- 0x20, 0x30, 0x2e, 0x38, 0x34, 0x2c, 0x20, 0x30, 0x2e, 0x30, 0x2c, 0x20,
- 0x31, 0x2e, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20,
- 0x65, 0x6c, 0x73, 0x65, 0x20, 0x69, 0x66, 0x20, 0x28, 0x73, 0x68, 0x61,
- 0x70, 0x65, 0x5f, 0x75, 0x6e, 0x69, 0x66, 0x6f, 0x72, 0x6d, 0x2e, 0x73,
- 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x75, 0x29, 0x20,
- 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x75,
- 0x74, 0x70, 0x75, 0x74, 0x2e, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d,
- 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x28, 0x30, 0x2e, 0x35, 0x2c, 0x20,
- 0x30, 0x2e, 0x36, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x2c, 0x20, 0x31, 0x2e,
- 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65, 0x6c,
- 0x73, 0x65, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x3d, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x28, 0x30, 0x2e, 0x35, 0x2c,
+ 0x20, 0x30, 0x2e, 0x36, 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x2c, 0x20, 0x31,
+ 0x2e, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d, 0x20, 0x65,
+ 0x6c, 0x73, 0x65, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x63, 0x6f, 0x6c,
+ 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x28, 0x30,
+ 0x2e, 0x38, 0x2c, 0x20, 0x30, 0x2e, 0x38, 0x2c, 0x20, 0x30, 0x2e, 0x38,
+ 0x2c, 0x20, 0x31, 0x2e, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
+ 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
+ 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x3b, 0x0a, 0x7d, 0x0a, 0x0a,
+ 0x40, 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x6e,
+ 0x20, 0x66, 0x73, 0x5f, 0x6d, 0x61, 0x69, 0x6e, 0x28, 0x69, 0x6e, 0x70,
+ 0x75, 0x74, 0x3a, 0x20, 0x56, 0x73, 0x32, 0x46, 0x73, 0x29, 0x20, 0x2d,
+ 0x3e, 0x20, 0x46, 0x73, 0x4f, 0x75, 0x74, 0x20, 0x7b, 0x0a, 0x20, 0x20,
+ 0x20, 0x20, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74,
+ 0x3a, 0x20, 0x46, 0x73, 0x4f, 0x75, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x20,
0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x63, 0x6f, 0x6c, 0x6f,
- 0x72, 0x20, 0x3d, 0x20, 0x76, 0x65, 0x63, 0x34, 0x66, 0x28, 0x30, 0x2e,
- 0x38, 0x2c, 0x20, 0x30, 0x2e, 0x38, 0x2c, 0x20, 0x30, 0x2e, 0x38, 0x2c,
- 0x20, 0x31, 0x2e, 0x30, 0x29, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x7d,
- 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
- 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x3b, 0x0a, 0x7d, 0x0a, 0x0a, 0x40,
- 0x66, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x66, 0x6e, 0x20,
- 0x66, 0x73, 0x5f, 0x6d, 0x61, 0x69, 0x6e, 0x28, 0x69, 0x6e, 0x70, 0x75,
- 0x74, 0x3a, 0x20, 0x56, 0x73, 0x32, 0x46, 0x73, 0x29, 0x20, 0x2d, 0x3e,
- 0x20, 0x46, 0x73, 0x4f, 0x75, 0x74, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20,
- 0x20, 0x76, 0x61, 0x72, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x3a,
- 0x20, 0x46, 0x73, 0x4f, 0x75, 0x74, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20,
- 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x2e, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
- 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2e, 0x63, 0x6f, 0x6c,
- 0x6f, 0x72, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
- 0x72, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x3b, 0x0a, 0x7d,
- 0x0a
+ 0x72, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x2e, 0x63, 0x6f,
+ 0x6c, 0x6f, 0x72, 0x3b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
+ 0x75, 0x72, 0x6e, 0x20, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x3b, 0x0a,
+ 0x7d, 0x0a
};
-unsigned int src_shaders_shape_wgsl_len = 1045;
+unsigned int src_shaders_shape_wgsl_len = 1274;
diff --git a/src/history.h b/src/history.h
index cfcf0aa..75471d2 100644
--- a/src/history.h
+++ b/src/history.h
@@ -3,6 +3,8 @@
#include "api.h"
+#define HISTORY_MAX_DEPTH 256
+
typedef enum {
HIST_POSITION,
HIST_SCALE,
@@ -103,6 +105,17 @@ static void history_push_entry(history_t *h, hist_entry_t entry) {
*((hist_entry_t*) vec_push(&h->entries)) = entry;
h->current = h->entries.count - 1;
+
+ while (h->entries.count > HISTORY_MAX_DEPTH) {
+ hist_entry_t *e = (hist_entry_t*) vec_get(&h->entries, 0);
+ if (e->changes) {
+ for (int j = 0; j < e->count; j++)
+ hist_free_change(&e->changes[j]);
+ FREE(e->changes);
+ }
+ vec_remove_ordered(&h->entries, 0);
+ h->current--;
+ }
}
static void history_begin_edit(history_t *h, vector_t *shapes,
@@ -180,14 +193,9 @@ static void history_batch_add(hist_batch_t *batch, int shape_index, hist_prop_t
// Used for HIST_CREATE and HIST_DELETE entries.
// old_val = { kind, cx, cy, num_verts }
// new_val = { sx, sy, rotation, group_id }
+// For procedural shapes (CIRCLE, STAR, RECTANGLE), vertices are reconstructed
+// from parameters instead of deep-copied. For STAR, new_val[1] stores inner_r.
static void hist_snapshot_shape_verts(hist_change_t *c, shape_t *s) {
- int n = (int)s->num_elements;
- c->vertex_count = n;
- c->index_count = n;
- c->vertex_data = (shape_vertex_t*) ALLOC((size_t)n * sizeof(shape_vertex_t));
- c->index_data = (uint16_t*) ALLOC((size_t)n * sizeof(uint16_t));
- memcpy(c->vertex_data, s->verts, (size_t)n * sizeof(shape_vertex_t));
- memcpy(c->index_data, s->indices, (size_t)n * sizeof(uint16_t));
c->old_val[0] = (float)s->kind;
c->old_val[1] = s->cx;
c->old_val[2] = s->cy;
@@ -196,6 +204,28 @@ static void hist_snapshot_shape_verts(hist_change_t *c, shape_t *s) {
c->new_val[1] = s->sy;
c->new_val[2] = s->rotation;
c->new_val[3] = (float)s->group_id;
+
+ if (s->kind == SHAPE_GENERIC) {
+ int n = (int)s->num_elements;
+ c->vertex_count = n;
+ c->index_count = n;
+ c->vertex_data = (shape_vertex_t*) ALLOC((size_t)n * sizeof(shape_vertex_t));
+ c->index_data = (uint16_t*) ALLOC((size_t)n * sizeof(uint16_t));
+ memcpy(c->vertex_data, s->verts, (size_t)n * sizeof(shape_vertex_t));
+ memcpy(c->index_data, s->indices, (size_t)n * sizeof(uint16_t));
+ } else if (s->kind == SHAPE_STAR) {
+ float inner_ratio = sqrtf(s->verts[1].x * s->verts[1].x + s->verts[1].y * s->verts[1].y);
+ c->new_val[1] = inner_ratio * s->sx;
+ c->vertex_count = 0;
+ c->index_count = 0;
+ c->vertex_data = NULL;
+ c->index_data = NULL;
+ } else {
+ c->vertex_count = 0;
+ c->index_count = 0;
+ c->vertex_data = NULL;
+ c->index_data = NULL;
+ }
}
// Append a CREATE or DELETE entry to a batch, snapshotting the shape's vertex data.
@@ -214,27 +244,46 @@ static void history_batch_commit(hist_batch_t *batch, history_t *h) {
// Reconstruct a shape_t from a HIST_CREATE / HIST_DELETE change snapshot.
static shape_t hist_rebuild_shape_from_snapshot(const hist_change_t *c) {
+ float cx = c->old_val[1], cy = c->old_val[2];
+ float sx = c->new_val[0], rot = c->new_val[2];
+ int gid = (int)c->new_val[3];
shape_t s;
- memset(&s, 0, sizeof(s));
- s.kind = (int)c->old_val[0];
- s.cx = c->old_val[1];
- s.cy = c->old_val[2];
- s.num_verts = (uint32_t)c->old_val[3];
- s.num_elements = (uint32_t)c->vertex_count;
- s.sx = c->new_val[0];
- s.sy = c->new_val[1];
- s.rotation = c->new_val[2];
- s.group_id = (int)c->new_val[3];
-
- int n = c->vertex_count;
- s.verts = (shape_vertex_t*) ALLOC((size_t)n * sizeof(shape_vertex_t));
- s.indices = (uint16_t*) ALLOC((size_t)n * sizeof(uint16_t));
- memcpy(s.verts, c->vertex_data, (size_t)n * sizeof(shape_vertex_t));
- memcpy(s.indices, c->index_data, (size_t)n * sizeof(uint16_t));
-
- shape_init_common(&s);
+
+ switch ((int)c->old_val[0]) {
+ case SHAPE_CIRCLE:
+ s = shape_circle(cx, cy, sx);
+ break;
+ case SHAPE_RECTANGLE:
+ s = shape_rectangle(cx, cy, sx * 2.0f, c->new_val[1] * 2.0f);
+ break;
+ case SHAPE_STAR: {
+ int points = (int)c->old_val[3] / 2;
+ s = shape_star(cx, cy, sx, c->new_val[1], points);
+ break;
+ }
+ default: {
+ memset(&s, 0, sizeof(s));
+ s.kind = (int)c->old_val[0];
+ s.cx = cx;
+ s.cy = cy;
+ s.num_verts = (uint32_t)c->old_val[3];
+ s.num_elements = (uint32_t)c->vertex_count;
+ s.sx = sx;
+ s.sy = c->new_val[1];
+ int n = c->vertex_count;
+ s.verts = (shape_vertex_t*) ALLOC((size_t)n * sizeof(shape_vertex_t));
+ s.indices = (uint16_t*) ALLOC((size_t)n * sizeof(uint16_t));
+ memcpy(s.verts, c->vertex_data, (size_t)n * sizeof(shape_vertex_t));
+ memcpy(s.indices, c->index_data, (size_t)n * sizeof(uint16_t));
+ shape_init_common(&s);
+ shape_build_transform(&s);
+ shape_make_buffers(&s);
+ return s;
+ }
+ }
+ s.rotation = rot;
+ s.group_id = gid;
shape_build_transform(&s);
- shape_make_buffers(&s);
return s;
}
diff --git a/src/input.h b/src/input.h
index ef7c48b..47714bc 100644
--- a/src/input.h
+++ b/src/input.h
@@ -55,7 +55,7 @@ static void handle_left_down_resize_begin(userdata_t *ud, float wx, float wy, in
int sel_n = 0;
for (int i = 0; i < ud->shapes.count; i++) {
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
- if (s->selected) { sum_sin += sinf(s->rotation); sum_cos += cosf(s->rotation); sel_n++; }
+ if (s->selected) { sum_sin += s->sin_r; sum_cos += s->cos_r; sel_n++; }
}
ud->interact.resize.angle = atan2f(sum_sin, sum_cos);
@@ -65,7 +65,7 @@ static void handle_left_down_resize_begin(userdata_t *ud, float wx, float wy, in
for (int i = 0; i < ud->shapes.count; i++) {
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
if (s->selected) {
- float sc = cosf(s->rotation), ss = sinf(s->rotation);
+ float sc = s->cos_r, ss = s->sin_r;
float hlx = (ud->interact.resize.start_wx - s->cx) * sc + (ud->interact.resize.start_wy - s->cy) * ss;
float hly = -(ud->interact.resize.start_wx - s->cx) * ss + (ud->interact.resize.start_wy - s->cy) * sc;
float plx = (ud->interact.resize.pivot_x - s->cx) * sc + (ud->interact.resize.pivot_y - s->cy) * ss;
@@ -92,6 +92,12 @@ static void handle_left_down_rotate_begin(userdata_t *ud, float wx, float wy)
wy - ud->interact.rotate.center_y,
wx - ud->interact.rotate.center_x);
ud->interact.rotate.total_delta = 0.0f;
+
+ ud->interact.drag_indices.count = 0;
+ for (int i = 0; i < ud->shapes.count; i++) {
+ if (((shape_t*) vec_get(&ud->shapes, i))->selected)
+ *(int*) vec_push(&ud->interact.drag_indices) = i;
+ }
}
static void handle_left_down_move_begin(userdata_t *ud, float wx, float wy)
@@ -101,6 +107,12 @@ static void handle_left_down_move_begin(userdata_t *ud, float wx, float wy)
ud->interact.move.start_wy = wy;
ud->interact.move.total_dx = 0;
ud->interact.move.total_dy = 0;
+
+ ud->interact.drag_indices.count = 0;
+ for (int i = 0; i < ud->shapes.count; i++) {
+ if (((shape_t*) vec_get(&ud->shapes, i))->selected)
+ *(int*) vec_push(&ud->interact.drag_indices) = i;
+ }
}
static void handle_left_down_select_or_marquee(userdata_t *ud, const sapp_event *event, float wx, float wy, float tol)
@@ -170,41 +182,37 @@ static void handle_resize_end(userdata_t *ud)
static void handle_rotate_end(userdata_t *ud)
{
- if (ud->interact.rotate.total_delta != 0.0f) {
- int sel_count = 0;
- for (int i = 0; i < ud->shapes.count; i++) {
- if (((shape_t*) vec_get(&ud->shapes, i))->selected) sel_count++;
- }
-
+ int n = ud->interact.drag_indices.count;
+ if (n > 0 && ud->interact.rotate.total_delta != 0.0f) {
float cos_b = cosf(-ud->interact.rotate.total_delta);
float sin_b = sinf(-ud->interact.rotate.total_delta);
float cx = ud->interact.rotate.center_x;
float cy = ud->interact.rotate.center_y;
hist_batch_t batch;
- history_batch_init(&batch, sel_count * 2);
+ history_batch_init(&batch, n * 2);
- for (int i = 0; i < ud->shapes.count; i++) {
+ for (int j = 0; j < n; j++) {
+ int i = *(int*) vec_get(&ud->interact.drag_indices, j);
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
- if (s->selected) {
- float dx = s->cx - cx;
- float dy = s->cy - cy;
- float old_cx = cx + dx * cos_b - dy * sin_b;
- float old_cy = cy + dx * sin_b + dy * cos_b;
-
- history_batch_add(&batch, i, HIST_POSITION,
- (float[4]){ old_cx, old_cy },
- (float[4]){ s->cx, s->cy });
- history_batch_add(&batch, i, HIST_ROTATION,
- (float[4]){ s->rotation - ud->interact.rotate.total_delta },
- (float[4]){ s->rotation });
- }
+ float dx = s->cx - cx;
+ float dy = s->cy - cy;
+ float old_cx = cx + dx * cos_b - dy * sin_b;
+ float old_cy = cy + dx * sin_b + dy * cos_b;
+
+ history_batch_add(&batch, i, HIST_POSITION,
+ (float[4]){ old_cx, old_cy },
+ (float[4]){ s->cx, s->cy });
+ history_batch_add(&batch, i, HIST_ROTATION,
+ (float[4]){ s->rotation - ud->interact.rotate.total_delta },
+ (float[4]){ s->rotation });
}
history_batch_commit(&batch, &ud->history);
}
ud->interact.rotate.dragging = false;
+ ud->interact.drag_indices.count = 0;
update_shape_states(ud);
spatial_mark_dirty(&ud->spatial_grid);
ud->interact.aabb_cached = false;
@@ -213,28 +221,24 @@ static void handle_rotate_end(userdata_t *ud)
static void handle_move_end(userdata_t *ud)
{
- if (ud->interact.move.total_dx != 0.0f || ud->interact.move.total_dy != 0.0f) {
- int sel_count = 0;
- for (int i = 0; i < ud->shapes.count; i++) {
- if (((shape_t*) vec_get(&ud->shapes, i))->selected) sel_count++;
- }
-
+ int n = ud->interact.drag_indices.count;
+ if (n > 0 && (ud->interact.move.total_dx != 0.0f || ud->interact.move.total_dy != 0.0f)) {
hist_batch_t batch;
- history_batch_init(&batch, sel_count);
+ history_batch_init(&batch, n);
- for (int i = 0; i < ud->shapes.count; i++) {
+ for (int j = 0; j < n; j++) {
+ int i = *(int*) vec_get(&ud->interact.drag_indices, j);
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
- if (s->selected) {
- history_batch_add(&batch, i, HIST_POSITION,
- (float[4]){ s->cx - ud->interact.move.total_dx, s->cy - ud->interact.move.total_dy },
- (float[4]){ s->cx, s->cy });
- }
+ history_batch_add(&batch, i, HIST_POSITION,
+ (float[4]){ s->cx - ud->interact.move.total_dx, s->cy - ud->interact.move.total_dy },
+ (float[4]){ s->cx, s->cy });
}
history_batch_commit(&batch, &ud->history);
}
ud->interact.move.dragging = false;
+ ud->interact.drag_indices.count = 0;
update_shape_states(ud);
spatial_mark_dirty(&ud->spatial_grid);
ud->interact.aabb_cached = false;
@@ -306,7 +310,7 @@ static void handle_resize_drag(userdata_t *ud, const sapp_event *event)
resize_init_t *ini = &ud->interact.resize.init[j];
shape_t *s = (shape_t*) vec_get(&ud->shapes, ini->idx);
- float sc = cosf(s->rotation), ss = sinf(s->rotation);
+ float sc = s->cos_r, ss = s->sin_r;
float mlx = (wx - ini->init_cx) * sc + (wy - ini->init_cy) * ss;
float mly = -(wx - ini->init_cx) * ss + (wy - ini->init_cy) * sc;
@@ -351,17 +355,16 @@ static void handle_rotate_drag(userdata_t *ud, const sapp_event *event)
float cx = ud->interact.rotate.center_x;
float cy = ud->interact.rotate.center_y;
- for (int i = 0; i < ud->shapes.count; i++) {
+ for (int j = 0; j < ud->interact.drag_indices.count; j++) {
+ int i = *(int*) vec_get(&ud->interact.drag_indices, j);
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
- if (s->selected) {
- float dx = s->cx - cx;
- float dy = s->cy - cy;
- s->cx = cx + dx * cos_a - dy * sin_a;
- s->cy = cy + dx * sin_a + dy * cos_a;
- s->rotation += inc;
- shape_build_transform(s);
- shape_set_state(s, false, true);
- }
+ float dx = s->cx - cx;
+ float dy = s->cy - cy;
+ s->cx = cx + dx * cos_a - dy * sin_a;
+ s->cy = cy + dx * sin_a + dy * cos_a;
+ s->rotation += inc;
+ shape_build_transform(s);
+ shape_set_state(s, false, true);
}
ud->interact.rotate.total_delta = delta;
@@ -376,14 +379,13 @@ static void handle_move_drag(userdata_t *ud, const sapp_event *event)
float delta_x = dx - ud->interact.move.total_dx;
float delta_y = dy - ud->interact.move.total_dy;
- for (int i = 0; i < ud->shapes.count; i++) {
+ for (int j = 0; j < ud->interact.drag_indices.count; j++) {
+ int i = *(int*) vec_get(&ud->interact.drag_indices, j);
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
- if (s->selected) {
- s->cx += delta_x;
- s->cy += delta_y;
- shape_build_transform(s);
- shape_set_state(s, false, true);
- }
+ s->cx += delta_x;
+ s->cy += delta_y;
+ shape_retranslate(s);
+ shape_set_state(s, false, true);
}
ud->interact.move.total_dx = dx;
@@ -411,6 +413,35 @@ static void handle_marquee_drag(userdata_t *ud, const sapp_event *event)
&ud->spatial_grid, &ud->shapes,
min_x, min_y, max_x, max_y);
+ if (ud->interact.focused_group_id == 0) {
+ int cap = ud->shapes.count;
+ int *gids = (int*) ALLOC((size_t)cap * sizeof(int));
+ int n_gids = 0;
+ for (int i = 0; i < ud->shapes.count; i++) {
+ shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
+ if (!s->selected || s->group_id == 0) continue;
+ int topmost = get_topmost_group(&ud->groups, s->group_id);
+ bool found = false;
+ for (int j = 0; j < n_gids; j++) {
+ if (gids[j] == topmost) { found = true; break; }
+ }
+ if (!found) gids[n_gids++] = topmost;
+ }
+ for (int j = 0; j < n_gids; j++) {
+ for (int i = 0; i < ud->shapes.count; i++) {
+ shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
+ if (is_shape_in_group_hierarchy(s->group_id, gids[j], &ud->groups))
+ s->selected = true;
+ }
+ }
+ FREE(gids);
+ ud->interact.selected_count = 0;
+ for (int i = 0; i < ud->shapes.count; i++) {
+ if (((shape_t*) vec_get(&ud->shapes, i))->selected)
+ ud->interact.selected_count++;
+ }
+ }
+
for (int i = 0; i < ud->shapes.count; i++) {
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
shape_set_state(s, false, s->selected);
@@ -435,16 +466,179 @@ static void handle_hover(userdata_t *ud, const sapp_event *event)
if (hovered >= 0) {
shape_t *hs = (shape_t*) vec_get(&ud->shapes, hovered);
hovered_gid = hs->group_id;
+ if (hovered_gid != 0 && ud->interact.focused_group_id == 0)
+ hovered_gid = get_topmost_group(&ud->groups, hovered_gid);
}
for (int i = 0; i < ud->shapes.count; i++) {
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
bool in_group = (ud->interact.focused_group_id == 0 &&
- hovered_gid != 0 && s->group_id == hovered_gid);
+ hovered_gid != 0 &&
+ is_shape_in_group_hierarchy(s->group_id, hovered_gid, &ud->groups));
shape_set_state(s, (i == hovered || in_group), s->selected);
}
}
+// -- clipboard --
+
+static shape_t clipboard_deep_copy_shape(const shape_t *src)
+{
+ shape_t dst = *src;
+ dst.verts = (shape_vertex_t*) ALLOC((size_t)src->num_elements * sizeof(shape_vertex_t));
+ dst.indices = (uint16_t*) ALLOC((size_t)src->num_elements * sizeof(uint16_t));
+ memcpy(dst.verts, src->verts, (size_t)src->num_elements * sizeof(shape_vertex_t));
+ memcpy(dst.indices, src->indices, (size_t)src->num_elements * sizeof(uint16_t));
+ return dst;
+}
+
+static void clipboard_clear(clipboard_t *cb)
+{
+ for (int i = 0; i < cb->shape_count; i++) {
+ FREE(cb->shapes[i].verts);
+ FREE(cb->shapes[i].indices);
+ }
+ FREE(cb->shapes);
+ FREE(cb->groups);
+ memset(cb, 0, sizeof(*cb));
+}
+
+static int clipboard_lookup_gid(int old_id, const int *map, int map_count)
+{
+ for (int j = 0; j < map_count; j++) {
+ if (map[j * 2] == old_id) return map[j * 2 + 1];
+ }
+ return 0;
+}
+
+static void handle_copy(userdata_t *ud)
+{
+ if (ud->interact.selected_count == 0) return;
+
+ clipboard_clear(&ud->clipboard);
+
+ int n = ud->shapes.count;
+ int sel = 0;
+ for (int i = 0; i < n; i++) {
+ if (((shape_t*) vec_get(&ud->shapes, i))->selected) sel++;
+ }
+
+ ud->clipboard.shapes = (shape_t*) ALLOC((size_t)sel * sizeof(shape_t));
+ ud->clipboard.shape_count = 0;
+
+ int *gids = (int*) ALLOC((size_t)n * sizeof(int));
+ int n_gids = 0;
+
+ for (int i = 0; i < n; i++) {
+ shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
+ if (!s->selected) continue;
+
+ ud->clipboard.shapes[ud->clipboard.shape_count++] = clipboard_deep_copy_shape(s);
+
+ int gid = s->group_id;
+ while (gid != 0) {
+ bool found = false;
+ for (int j = 0; j < n_gids; j++) {
+ if (gids[j] == gid) { found = true; break; }
+ }
+ if (!found) gids[n_gids++] = gid;
+ group_t *g = find_group(&ud->groups, gid);
+ gid = g ? g->parent_id : 0;
+ }
+ }
+
+ ud->clipboard.groups = (group_t*) ALLOC((size_t)n_gids * sizeof(group_t));
+ ud->clipboard.group_count = n_gids;
+ for (int j = 0; j < n_gids; j++) {
+ group_t *src = find_group(&ud->groups, gids[j]);
+ ud->clipboard.groups[j] = *src;
+ }
+
+ FREE(gids);
+}
+
+static void handle_paste(userdata_t *ud)
+{
+ clipboard_t *cb = &ud->clipboard;
+ if (cb->shape_count == 0) return;
+
+ int gc = cb->group_count;
+ int *gid_map = NULL;
+ if (gc > 0) {
+ gid_map = (int*) ALLOC((size_t)gc * 2 * sizeof(int));
+ for (int j = 0; j < gc; j++) {
+ gid_map[j * 2] = cb->groups[j].id;
+ gid_map[j * 2 + 1] = ud->next_group_id++;
+ }
+ for (int j = 0; j < gc; j++) {
+ group_t g = cb->groups[j];
+ g.id = clipboard_lookup_gid(g.id, gid_map, gc);
+ g.parent_id = clipboard_lookup_gid(g.parent_id, gid_map, gc);
+ *((group_t*) vec_push(&ud->groups)) = g;
+ }
+ group_index_rebuild(&ud->groups);
+ }
+
+ for (int i = 0; i < ud->shapes.count; i++)
+ ((shape_t*) vec_get(&ud->shapes, i))->selected = false;
+ ud->interact.selected_count = 0;
+
+ float cx, cy;
+ screen_to_world(&ud->camera, ud->mouse_x, ud->mouse_y, &cx, &cy);
+
+ float cb_min_x = 0, cb_min_y = 0, cb_max_x = 0, cb_max_y = 0;
+ for (int i = 0; i < cb->shape_count; i++) {
+ shape_t *s = &cb->shapes[i];
+ float sc = s->cos_r, ss = s->sin_r;
+ for (uint32_t v = 0; v < s->num_verts; v++) {
+ float lx = s->verts[v].x * s->sx;
+ float ly = s->verts[v].y * s->sy;
+ float wx = s->cx + lx * sc - ly * ss;
+ float wy = s->cy + lx * ss + ly * sc;
+ if (i == 0 && v == 0) {
+ cb_min_x = cb_max_x = wx;
+ cb_min_y = cb_max_y = wy;
+ } else {
+ if (wx < cb_min_x) cb_min_x = wx;
+ if (wx > cb_max_x) cb_max_x = wx;
+ if (wy < cb_min_y) cb_min_y = wy;
+ if (wy > cb_max_y) cb_max_y = wy;
+ }
+ }
+ }
+ float cb_cx = (cb_min_x + cb_max_x) * 0.5f;
+ float cb_cy = (cb_min_y + cb_max_y) * 0.5f;
+
+ int sc = cb->shape_count;
+ hist_batch_t batch;
+ history_batch_init(&batch, sc);
+
+ for (int i = 0; i < sc; i++) {
+ shape_t s = clipboard_deep_copy_shape(&cb->shapes[i]);
+ s.cx += cx - cb_cx;
+ s.cy += cy - cb_cy;
+ if (gc > 0)
+ s.group_id = clipboard_lookup_gid(s.group_id, gid_map, gc);
+ else
+ s.group_id = 0;
+ s.selected = true;
+ ud->interact.selected_count++;
+
+ *((shape_t*) vec_push(&ud->shapes)) = s;
+ g_shape_pool_dirty = true;
+ history_batch_add_shape(&batch, ud->shapes.count - 1, HIST_CREATE,
+ (shape_t*) vec_get(&ud->shapes, ud->shapes.count - 1));
+ }
+
+ history_batch_commit(&batch, &ud->history);
+ FREE(gid_map);
+
+ spatial_mark_dirty(&ud->spatial_grid);
+ ud->interact.aabb_cached = false;
+ ud->interact.focused_group_id = 0;
+ ud->overlay_upload_needed = true;
+ update_shape_states(ud);
+}
+
// -- public event handlers --
static bool handle_key_down(userdata_t *ud, const sapp_event *event)
@@ -454,6 +648,7 @@ static bool handle_key_down(userdata_t *ud, const sapp_event *event)
if (history_undo(&ud->history, &ud->shapes)) {
rebuild_groups_from_shapes(&ud->groups, &ud->shapes);
ud->interact.hovered_shape = -1;
+ g_shape_pool_dirty = true;
spatial_mark_dirty(&ud->spatial_grid);
ud->interact.aabb_cached = false;
ud->overlay_upload_needed = true;
@@ -464,12 +659,21 @@ static bool handle_key_down(userdata_t *ud, const sapp_event *event)
if (history_redo(&ud->history, &ud->shapes)) {
rebuild_groups_from_shapes(&ud->groups, &ud->shapes);
ud->interact.hovered_shape = -1;
+ g_shape_pool_dirty = true;
spatial_mark_dirty(&ud->spatial_grid);
ud->interact.aabb_cached = false;
ud->overlay_upload_needed = true;
}
return true;
}
+ if (event->key_code == SAPP_KEYCODE_C) {
+ handle_copy(ud);
+ return true;
+ }
+ if (event->key_code == SAPP_KEYCODE_V) {
+ handle_paste(ud);
+ return true;
+ }
if (event->key_code == SAPP_KEYCODE_G) {
if (event->modifiers & SAPP_MODIFIER_SHIFT) {
// Ungroup: collect unique group IDs of selected shapes
@@ -549,6 +753,8 @@ static bool handle_key_down(userdata_t *ud, const sapp_event *event)
}
}
+ group_index_rebuild(&ud->groups);
+
FREE(parents);
FREE(gids);
ud->ui.list_last_shape = -1;
@@ -624,6 +830,7 @@ static bool handle_key_down(userdata_t *ud, const sapp_event *event)
group_t new_grp = { .id = gid, .parent_id = 0 };
*((group_t*) vec_push(&ud->groups)) = new_grp;
+ group_index_rebuild(&ud->groups);
for (int j = 0; j < n_full; j++) {
for (int g = 0; g < ud->groups.count; g++) {
@@ -683,6 +890,7 @@ static bool handle_key_down(userdata_t *ud, const sapp_event *event)
shape_shutdown(s);
vec_remove_ordered(&ud->shapes, indices[j]);
}
+ g_shape_pool_dirty = true;
FREE(indices);
@@ -853,6 +1061,9 @@ static void handle_mouse_up(userdata_t *ud, const sapp_event *event)
static void handle_mouse_move(userdata_t *ud, const sapp_event *event)
{
+ ud->mouse_x = event->mouse_x;
+ ud->mouse_y = event->mouse_y;
+
if (ud->camera.pan_state.dragging) {
handle_pan_drag(ud, event);
} else if (ud->interact.resize.dragging) {
diff --git a/src/interact.h b/src/interact.h
index b1c97a7..0360207 100644
--- a/src/interact.h
+++ b/src/interact.h
@@ -11,7 +11,7 @@ static void selected_aabb(userdata_t *ud, float *min_x, float *min_y,
for (int i = 0; i < ud->shapes.count; i++) {
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
if (!s->selected) continue;
- float sc = cosf(s->rotation), ss = sinf(s->rotation);
+ float sc = s->cos_r, ss = s->sin_r;
for (uint32_t v = 0; v < s->num_verts; v++) {
float lx = s->verts[v].x * s->sx;
float ly = s->verts[v].y * s->sy;
@@ -117,6 +117,7 @@ static void rebuild_groups_from_shapes(vector_t *groups, vector_t *shapes)
}
if (saved) FREE(saved);
+ group_index_rebuild(groups);
}
static int hit_test_resize_handles(userdata_t *ud, float wx, float wy, float tol)
diff --git a/src/main.c b/src/main.c
index db1bf3c..33aa624 100644
--- a/src/main.c
+++ b/src/main.c
@@ -34,6 +34,16 @@ static void log_capture(const char* tag, uint32_t log_level, uint32_t log_item,
if (log_level <= 1) ud->ui.log_show = true;
}
+static void panel_log_impl(void *ud_v, int level, const char *msg) {
+ userdata_t *ud = (userdata_t*)ud_v;
+ int idx = ud->ui.log_head;
+ strncpy(ud->ui.log_ring[idx].text, msg, 255);
+ ud->ui.log_ring[idx].text[255] = 0;
+ ud->ui.log_ring[idx].level = (uint32_t)level;
+ ud->ui.log_head = (idx + 1) % LOG_RING_SIZE;
+ if (ud->ui.log_count < LOG_RING_SIZE) ud->ui.log_count++;
+}
+
static void meter_fps(userdata_t *ud)
{
float dt = (float)sapp_frame_duration();
@@ -102,10 +112,14 @@ static void init(void* _userdata)
userdata_t* ud = (userdata_t*) _userdata;
+ g_panel_log_fn = panel_log_impl;
+ g_panel_log_ud = ud;
+
sg_desc sgdesc = {
.environment = sglue_environment(),
.logger.func = log_capture,
.logger.user_data = ud,
+ .uniform_buffer_size = 16 * 1024 * 1024,
};
sg_setup(&sgdesc);
if (!sg_isvalid()) {
@@ -216,6 +230,7 @@ static void init(void* _userdata)
vec_init(&ud->shapes, sizeof(shape_t));
vec_init(&ud->groups, sizeof(group_t));
+ vec_init(&ud->interact.drag_indices, sizeof(int));
spatial_init(&ud->spatial_grid);
ud->interact.selected_count = 0;
ud->interact.hovered_shape = -1;
@@ -296,7 +311,7 @@ static void init(void* _userdata)
EM_ASM({
window.addEventListener('keydown', function(e) {
if (e.ctrlKey && !e.altKey && !e.metaKey) {
- if (e.key === 'z' || e.key === 'y') {
+ if (e.key === 'z' || e.key === 'y' || e.key === 'c' || e.key === 'v') {
e.preventDefault();
}
}
@@ -316,6 +331,8 @@ static void cleanup(void* _userdata)
spatial_destroy(&ud->spatial_grid);
vec_free(&ud->shapes);
vec_free(&ud->groups);
+ vec_free(&ud->interact.drag_indices);
+ group_index_shutdown();
history_destroy(&ud->history);
if (ud->interact.resize.init) FREE(ud->interact.resize.init);
sg_destroy_buffer(ud->rect_vbuf);
@@ -329,6 +346,13 @@ static void cleanup(void* _userdata)
shape_pool_shutdown();
shape_shutdown_pipeline();
+ for (int i = 0; i < ud->clipboard.shape_count; i++) {
+ FREE(ud->clipboard.shapes[i].verts);
+ FREE(ud->clipboard.shapes[i].indices);
+ }
+ FREE(ud->clipboard.shapes);
+ FREE(ud->clipboard.groups);
+
FREE(ud);
simgui_shutdown();
diff --git a/src/overlay.h b/src/overlay.h
index e20795b..c22a676 100644
--- a/src/overlay.h
+++ b/src/overlay.h
@@ -27,7 +27,26 @@ static void compute_overlay_geometry(userdata_t *ud,
overlay_verts[4] = (shape_vertex_t){x1, y1};
*has_overlay = true;
} else if (ud->interact.selected_count >= 1) {
- if (ud->interact.selected_count == 1) {
+ if (ud->interact.move.dragging && ud->interact.aabb_cached) {
+ float dx = ud->interact.move.total_dx;
+ float dy = ud->interact.move.total_dy;
+ float omin_x = ud->interact.cached_aabb[0] + dx;
+ float omin_y = ud->interact.cached_aabb[1] + dy;
+ float omax_x = ud->interact.cached_aabb[2] + dx;
+ float omax_y = ud->interact.cached_aabb[3] + dy;
+ float pad = 8.0f / ud->camera.zoom;
+ overlay_verts[0] = (shape_vertex_t){omin_x - pad, omin_y - pad};
+ overlay_verts[1] = (shape_vertex_t){omax_x + pad, omin_y - pad};
+ overlay_verts[2] = (shape_vertex_t){omax_x + pad, omax_y + pad};
+ overlay_verts[3] = (shape_vertex_t){omin_x - pad, omax_y + pad};
+ overlay_verts[4] = overlay_verts[0];
+ *sel_cx = (omin_x + omax_x) * 0.5f;
+ *sel_cy = (omin_y + omax_y) * 0.5f;
+ *sel_hw = (omax_x - omin_x) * 0.5f + pad;
+ *sel_hh = (omax_y - omin_y) * 0.5f + pad;
+ *sel_angle = 0;
+ *has_overlay = true;
+ } else if (ud->interact.selected_count == 1) {
for (int i = 0; i < ud->shapes.count; i++) {
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
if (!s->selected) continue;
@@ -52,8 +71,8 @@ static void compute_overlay_geometry(userdata_t *ud,
for (int i = 0; i < ud->shapes.count; i++) {
shape_t *s = (shape_t*) vec_get(&ud->shapes, i);
if (!s->selected) continue;
- sum_sin += sinf(s->rotation);
- sum_cos += cosf(s->rotation);
+ sum_sin += s->sin_r;
+ sum_cos += s->cos_r;
}
selected_aabb(ud, &omin[0], &omin[1], &omax[0], &omax[1]);
ud->interact.cached_aabb[0] = omin[0]; ud->interact.cached_aabb[1] = omin[1];
@@ -102,10 +121,19 @@ static void upload_overlay_buffers(userdata_t *ud,
ud->interact.rotate.handle_radius = radius;
const int n = HANDLE_CIRCLE_SEGMENTS + 1;
+ static shape_vertex_t unit_circle[HANDLE_CIRCLE_SEGMENTS + 1];
+ static bool unit_circle_ready = false;
+ if (!unit_circle_ready) {
+ for (int i = 0; i < n; i++) {
+ float a = (float)i / (float)HANDLE_CIRCLE_SEGMENTS * 2.0f * GLM_PIf;
+ unit_circle[i] = (shape_vertex_t){cosf(a), sinf(a)};
+ }
+ unit_circle_ready = true;
+ }
shape_vertex_t hv[HANDLE_CIRCLE_SEGMENTS + 1];
for (int i = 0; i < n; i++) {
- float a = (float)i / (float)HANDLE_CIRCLE_SEGMENTS * 2.0f * GLM_PIf;
- hv[i] = (shape_vertex_t){sel_cx + cosf(a) * radius, sel_cy + sinf(a) * radius};
+ hv[i] = (shape_vertex_t){sel_cx + unit_circle[i].x * radius,
+ sel_cy + unit_circle[i].y * radius};
}
if (need_upload)
sg_update_buffer(ud->handle_vbuf, &(sg_range){hv, sizeof(hv)});
diff --git a/src/render.h b/src/render.h
index 7f881b5..b0a4ae0 100644
--- a/src/render.h
+++ b/src/render.h
@@ -5,6 +5,8 @@
static sg_pipeline shape_pipeline;
static sg_shader shape_shader;
+static sg_pipeline overlay_pipeline;
+static sg_shader overlay_shader;
static int g_shape_frame_id;
static void shape_begin_frame(void)
@@ -14,13 +16,14 @@ static void shape_begin_frame(void)
static void shape_init_pipeline(void)
{
- shape_shader = sg_make_shader(&(sg_shader_desc) {
+ // Overlay shader/pipeline (simple, no storage buffers)
+ overlay_shader = sg_make_shader(&(sg_shader_desc) {
.vertex_func = {
- .source = (const char*) src_shaders_shape_wgsl,
+ .source = (const char*) src_shaders_overlay_wgsl,
.entry = "vs_main",
},
.fragment_func = {
- .source = (const char*) src_shaders_shape_wgsl,
+ .source = (const char*) src_shaders_overlay_wgsl,
.entry = "fs_main",
},
.uniform_blocks = {
@@ -38,31 +41,79 @@ static void shape_init_pipeline(void)
.attrs = {
[0] = { .base_type = SG_SHADERATTRBASETYPE_FLOAT },
},
+ .label = "Overlay shader",
+ });
+ panel_log(3, "[shapes] overlay shader id=%d valid=%d", overlay_shader.id, sg_isvalid());
+
+ overlay_pipeline = sg_make_pipeline(&(sg_pipeline_desc) {
+ .shader = overlay_shader,
+ .index_type = SG_INDEXTYPE_UINT16,
+ .primitive_type = SG_PRIMITIVETYPE_LINE_STRIP,
+ .layout.attrs = {
+ [0].format = SG_VERTEXFORMAT_FLOAT2,
+ },
+ .label = "Overlay pipeline",
+ });
+ panel_log(3, "[shapes] overlay pipeline id=%d valid=%d", overlay_pipeline.id, sg_isvalid());
+
+ // Shape shader/pipeline (storage buffers, instanced)
+ shape_shader = sg_make_shader(&(sg_shader_desc) {
+ .vertex_func = {
+ .source = (const char*) src_shaders_shape_wgsl,
+ .entry = "vs_main",
+ },
+ .fragment_func = {
+ .source = (const char*) src_shaders_shape_wgsl,
+ .entry = "fs_main",
+ },
+ .uniform_blocks = {
+ [0] = {
+ .size = 80,
+ .stage = SG_SHADERSTAGE_VERTEX,
+ .wgsl_group0_binding_n = 0,
+ },
+ },
+ .views = {
+ [0] = {
+ .storage_buffer = {
+ .stage = SG_SHADERSTAGE_VERTEX,
+ .readonly = true,
+ .wgsl_group1_binding_n = 0,
+ },
+ },
+ [1] = {
+ .storage_buffer = {
+ .stage = SG_SHADERSTAGE_VERTEX,
+ .readonly = true,
+ .wgsl_group1_binding_n = 1,
+ },
+ },
+ },
+ .attrs = {
+ [0] = { .base_type = SG_SHADERATTRBASETYPE_FLOAT },
+ },
.label = "Shape shader",
});
+ panel_log(3, "[shapes] shader id=%d valid=%d", shape_shader.id, sg_isvalid());
shape_pipeline = sg_make_pipeline(&(sg_pipeline_desc) {
.shader = shape_shader,
- .index_type = SG_INDEXTYPE_UINT16,
+ .index_type = SG_INDEXTYPE_NONE,
.primitive_type = SG_PRIMITIVETYPE_LINE_STRIP,
.layout.attrs = {
[0].format = SG_VERTEXFORMAT_FLOAT2,
},
.label = "Shape pipeline",
});
+ panel_log(3, "[shapes] pipeline id=%d valid=%d", shape_pipeline.id, sg_isvalid());
}
static void shape_shutdown_pipeline(void)
{
sg_destroy_pipeline(shape_pipeline);
sg_destroy_shader(shape_shader);
-}
-
-static void shape_draw(shape_t *s, const mat4 *mvp)
-{
- sg_apply_uniforms(0, &SG_RANGE(*mvp));
- sg_apply_uniforms(1, &SG_RANGE(s->uniform));
- sg_draw((int)s->index_base, (int)s->num_elements, 1);
+ sg_destroy_pipeline(overlay_pipeline);
+ sg_destroy_shader(overlay_shader);
}
#endif
diff --git a/src/shaders/shape.wgsl b/src/shaders/shape.wgsl
index e76259a..4d4a3d0 100644
--- a/src/shaders/shape.wgsl
+++ b/src/shaders/shape.wgsl
@@ -1,13 +1,20 @@
struct VsUniform {
mvp: mat4x4f,
+ instance_base: u32,
};
-struct ShapeUniform {
+struct ShapeData {
transform: mat4x4f,
state: u32,
};
+@binding(0) @group(0) var<uniform> vs_uniforms: VsUniform;
+
+@binding(0) @group(1) var<storage> shape_data: array<ShapeData>;
+@binding(1) @group(1) var<storage> instance_map: array<u32>;
+
struct VsIn {
+ @builtin(instance_index) instance_idx: u32,
@location(0) position: vec2f,
};
@@ -20,16 +27,15 @@ struct FsOut {
@location(0) color: vec4f,
};
-@binding(0) @group(0) var<uniform> vs_uniforms: VsUniform;
-@binding(1) @group(0) var<uniform> shape_uniform: ShapeUniform;
-
@vertex fn vs_main(input: VsIn) -> Vs2Fs {
var output: Vs2Fs;
- let world_pos = shape_uniform.transform * vec4f(input.position.x, input.position.y, 0.0, 1.0);
+ let shape_idx = instance_map[vs_uniforms.instance_base + input.instance_idx];
+ let shape = shape_data[shape_idx];
+ let world_pos = shape.transform * vec4f(input.position.x, input.position.y, 0.0, 1.0);
output.pos = vs_uniforms.mvp * world_pos;
- if (shape_uniform.state == 2u) {
+ if (shape.state == 2u) {
output.color = vec4f(1.0, 0.84, 0.0, 1.0);
- } else if (shape_uniform.state == 1u) {
+ } else if (shape.state == 1u) {
output.color = vec4f(0.5, 0.6, 1.0, 1.0);
} else {
output.color = vec4f(0.8, 0.8, 0.8, 1.0);
diff --git a/src/shape.h b/src/shape.h
index c1b65f3..fa59d5b 100644
--- a/src/shape.h
+++ b/src/shape.h
@@ -20,6 +20,12 @@ typedef struct shape_uniform_t {
uint8_t _pad[12];
} shape_uniform_t;
+typedef struct {
+ mat4 transform;
+ uint32_t state;
+ uint8_t _pad[12];
+} shape_gpu_data_t;
+
typedef struct shape_t {
shape_vertex_t *verts;
uint16_t *indices;
@@ -32,11 +38,9 @@ typedef struct shape_t {
float cx, cy;
float sx, sy;
float rotation;
+ float cos_r, sin_r;
int kind;
- uint32_t vertex_base;
- uint32_t index_base;
-
int group_id;
} shape_t;
@@ -47,15 +51,55 @@ typedef struct {
int parent_id; // 0 = top-level group
} group_t;
-static group_t* find_group(vector_t *groups, int id) {
+static group_t **g_group_by_id = NULL;
+static int g_group_by_id_cap = 0;
+
+static void group_index_rebuild(vector_t *groups)
+{
+ int max_id = 0;
+ for (int i = 0; i < groups->count; i++) {
+ int gid = ((group_t*) vec_get(groups, i))->id;
+ if (gid > max_id) max_id = gid;
+ }
+ if (max_id >= g_group_by_id_cap) {
+ if (g_group_by_id) FREE(g_group_by_id);
+ int new_cap = max_id + 64;
+ g_group_by_id = (group_t**) ALLOC((size_t)new_cap * sizeof(group_t*));
+ memset(g_group_by_id, 0, (size_t)new_cap * sizeof(group_t*));
+ g_group_by_id_cap = new_cap;
+ } else {
+ for (int i = 0; i <= max_id; i++) g_group_by_id[i] = NULL;
+ }
for (int i = 0; i < groups->count; i++) {
group_t *g = (group_t*) vec_get(groups, i);
- if (g->id == id) return g;
+ g_group_by_id[g->id] = g;
+ }
+}
+
+static void group_index_ensure_cap(int max_id)
+{
+ if (max_id >= g_group_by_id_cap) {
+ int new_cap = max_id + 64;
+ group_t **old = g_group_by_id;
+ g_group_by_id = (group_t**) ALLOC((size_t)new_cap * sizeof(group_t*));
+ if (old) {
+ memcpy(g_group_by_id, old, (size_t)g_group_by_id_cap * sizeof(group_t*));
+ FREE(old);
+ }
+ memset(g_group_by_id + g_group_by_id_cap, 0,
+ (size_t)(new_cap - g_group_by_id_cap) * sizeof(group_t*));
+ g_group_by_id_cap = new_cap;
}
- return NULL;
+}
+
+static group_t* find_group(vector_t *groups, int id) {
+ (void)groups;
+ if (id <= 0 || id >= g_group_by_id_cap) return NULL;
+ return g_group_by_id[id];
}
static int get_topmost_group(vector_t *groups, int gid) {
+ (void)groups;
while (gid != 0) {
group_t *g = find_group(groups, gid);
if (!g || g->parent_id == 0) return gid;
@@ -65,6 +109,7 @@ static int get_topmost_group(vector_t *groups, int gid) {
}
static bool is_shape_in_group_hierarchy(int shape_gid, int target_gid, vector_t *groups) {
+ (void)groups;
int cur = shape_gid;
while (cur != 0) {
if (cur == target_gid) return true;
@@ -75,74 +120,189 @@ static bool is_shape_in_group_hierarchy(int shape_gid, int target_gid, vector_t
return false;
}
+static void group_index_shutdown(void)
+{
+ if (g_group_by_id) FREE(g_group_by_id);
+ g_group_by_id = NULL;
+ g_group_by_id_cap = 0;
+}
+
// -- shared geometry buffers (one vbuf + one ibuf for all shapes) --
-static sg_buffer g_shape_vbuf = {0};
-static sg_buffer g_shape_ibuf = {0};
+static sg_buffer g_shape_data_sbuf = {0};
+static sg_buffer g_instance_map_sbuf = {0};
+static sg_view g_shape_data_view = {0};
+static sg_view g_instance_map_view = {0};
+
+// Per-group vertex buffers: one per unique num_elements
+typedef struct {
+ uint32_t num_elements;
+ sg_buffer vbuf;
+} shape_group_buf_t;
+static shape_group_buf_t *g_shape_groups = NULL;
+static int g_shape_group_count = 0;
+
static bool g_shape_pool_dirty;
-static uint32_t g_shape_vert_count;
-static uint32_t g_shape_idx_count;
+static bool g_shape_data_dirty;
+static size_t g_shape_data_buf_size = 0;
+static int g_instance_map_capacity = 0;
-static void shape_pool_rebuild(vector_t *shapes)
+static void shape_make_view_for_buffer(sg_view *view, sg_buffer buf)
+{
+ if (view->id) sg_destroy_view(*view);
+ *view = sg_make_view(&(sg_view_desc){
+ .storage_buffer = { .buffer = buf },
+ });
+}
+
+static shape_gpu_data_t *g_upload_buf = NULL;
+static int g_upload_buf_cap = 0;
+
+static void shape_upload_data(vector_t *shapes)
{
- // count total vertices / indices (line strips: num_elements == num_verts + 1)
- uint32_t total_verts = 0, total_indices = 0;
- for (int i = 0; i < shapes->count; i++) {
+ int n = shapes->count;
+ if (n == 0 || !g_shape_data_sbuf.id) return;
+
+ size_t need = (size_t)n * sizeof(shape_gpu_data_t);
+ if (need > g_shape_data_buf_size) {
+ panel_log(2, "[shapes] upload_data: buffer too small (%zu < %zu), forcing rebuild",
+ g_shape_data_buf_size, need);
+ g_shape_pool_dirty = true;
+ return;
+ }
+
+ if (n > g_upload_buf_cap) {
+ if (g_upload_buf) FREE(g_upload_buf);
+ g_upload_buf = (shape_gpu_data_t*) ALLOC(need);
+ g_upload_buf_cap = n;
+ }
+
+ for (int i = 0; i < n; i++) {
shape_t *s = (shape_t*) vec_get(shapes, i);
- total_verts += s->num_elements;
- total_indices += s->num_elements;
+ memcpy(g_upload_buf[i].transform, s->uniform.transform, sizeof(mat4));
+ g_upload_buf[i].state = s->uniform.state;
+ memset(g_upload_buf[i]._pad, 0, sizeof(g_upload_buf[i]._pad));
+ }
+ sg_update_buffer(g_shape_data_sbuf, &(sg_range){g_upload_buf, need});
+}
+
+static void shape_upload_instance_map(const uint32_t *map, int count)
+{
+ if (count > g_instance_map_capacity) {
+ if (g_instance_map_sbuf.id) sg_destroy_buffer(g_instance_map_sbuf);
+ g_instance_map_sbuf = sg_make_buffer(&(sg_buffer_desc){
+ .size = (size_t)count * sizeof(uint32_t),
+ .usage = { .storage_buffer = true, .stream_update = true },
+ .label = "Instance map",
+ });
+ g_instance_map_capacity = count;
+ shape_make_view_for_buffer(&g_instance_map_view, g_instance_map_sbuf);
+ }
+ sg_update_buffer(g_instance_map_sbuf, &(sg_range){map, (size_t)count * sizeof(uint32_t)});
+ panel_log(3, "[shapes] upload_instance_map: count=%d buf=%d view=%d",
+ count, g_instance_map_sbuf.id, g_instance_map_view.id);
+}
+
+static void shape_pool_rebuild(vector_t *shapes)
+{
+ int n = shapes->count;
+
+ // Destroy old groups
+ for (int i = 0; i < g_shape_group_count; i++) {
+ if (g_shape_groups[i].vbuf.id) sg_destroy_buffer(g_shape_groups[i].vbuf);
}
+ FREE(g_shape_groups);
+ g_shape_groups = NULL;
+ g_shape_group_count = 0;
- if (g_shape_vbuf.id) { sg_destroy_buffer(g_shape_vbuf); g_shape_vbuf.id = 0; }
- if (g_shape_ibuf.id) { sg_destroy_buffer(g_shape_ibuf); g_shape_ibuf.id = 0; }
- g_shape_vert_count = 0;
- g_shape_idx_count = 0;
+ if (g_shape_data_sbuf.id) { sg_destroy_buffer(g_shape_data_sbuf); g_shape_data_sbuf.id = 0; }
+ if (g_shape_data_view.id) { sg_destroy_view(g_shape_data_view); g_shape_data_view.id = 0; }
- if (total_verts == 0) {
+ if (n == 0) {
g_shape_pool_dirty = false;
return;
}
- shape_vertex_t *all_v = (shape_vertex_t*) ALLOC((size_t)total_verts * sizeof(shape_vertex_t));
- uint16_t *all_i = (uint16_t*) ALLOC((size_t)total_indices * sizeof(uint16_t));
-
- uint32_t voff = 0, ioff = 0;
- for (int i = 0; i < shapes->count; i++) {
- shape_t *s = (shape_t*) vec_get(shapes, i);
- uint32_t n = s->num_elements;
- memcpy(&all_v[voff], s->verts, (size_t)n * sizeof(shape_vertex_t));
- for (uint32_t j = 0; j < n; j++)
- all_i[ioff + j] = (uint16_t)(voff + s->indices[j]);
- s->vertex_base = voff;
- s->index_base = ioff;
- voff += n;
- ioff += n;
+ g_shape_data_buf_size = (size_t)n * sizeof(shape_gpu_data_t);
+ g_shape_data_sbuf = sg_make_buffer(&(sg_buffer_desc){
+ .size = g_shape_data_buf_size,
+ .usage = { .storage_buffer = true, .stream_update = true },
+ .label = "Shape data",
+ });
+ shape_make_view_for_buffer(&g_shape_data_view, g_shape_data_sbuf);
+ // Data filled by shape_upload_data() in draw_shapes
+
+ // Count unique num_elements
+ uint32_t max_ne = 0;
+ for (int i = 0; i < n; i++) {
+ uint32_t ne = ((shape_t*) vec_get(shapes, i))->num_elements;
+ if (ne > max_ne) max_ne = ne;
}
- g_shape_vbuf = sg_make_buffer(&(sg_buffer_desc){
- .data = { all_v, (size_t)total_verts * sizeof(shape_vertex_t) },
- .label = "Shape verts (shared)",
- });
- g_shape_ibuf = sg_make_buffer(&(sg_buffer_desc){
- .data = { all_i, (size_t)total_indices * sizeof(uint16_t) },
- .usage = { .index_buffer = true },
- .label = "Shape indices (shared)",
- });
+ int *ne_seen = (int*) ALLOC((size_t)(max_ne + 1) * sizeof(int));
+ memset(ne_seen, 0, (size_t)(max_ne + 1) * sizeof(int));
+ for (int i = 0; i < n; i++) {
+ uint32_t ne = ((shape_t*) vec_get(shapes, i))->num_elements;
+ ne_seen[ne] = 1;
+ }
+ int group_count = 0;
+ for (uint32_t ne = 0; ne <= max_ne; ne++)
+ if (ne_seen[ne]) group_count++;
+
+ // Create per-group vertex buffers (one copy of vertex data per unique num_elements)
+ g_shape_groups = (shape_group_buf_t*) ALLOC((size_t)group_count * sizeof(shape_group_buf_t));
+ memset(g_shape_groups, 0, (size_t)group_count * sizeof(shape_group_buf_t));
+
+ int gi = 0;
+ for (uint32_t ne = 0; ne <= max_ne; ne++) {
+ if (!ne_seen[ne]) continue;
+
+ // Find first shape with this num_elements to use as vertex template
+ shape_t *ref = NULL;
+ for (int i = 0; i < n; i++) {
+ if (((shape_t*) vec_get(shapes, i))->num_elements == ne) {
+ ref = (shape_t*) vec_get(shapes, i);
+ break;
+ }
+ }
+
+ g_shape_groups[gi].num_elements = ne;
+ g_shape_groups[gi].vbuf = sg_make_buffer(&(sg_buffer_desc){
+ .data = { ref->verts, (size_t)ne * sizeof(shape_vertex_t) },
+ .label = "Shape group verts",
+ });
+ gi++;
+ }
+ g_shape_group_count = group_count;
- FREE(all_v);
- FREE(all_i);
+ FREE(ne_seen);
+
+ panel_log(3, "[shapes] pool_rebuild: %d shapes, %d groups, data_buf=%d data_view=%d",
+ n, group_count, g_shape_data_sbuf.id, g_shape_data_view.id);
+ for (int gi = 0; gi < group_count; gi++) {
+ panel_log(3, "[shapes] group[%d]: ne=%u vbuf=%d",
+ gi, g_shape_groups[gi].num_elements, g_shape_groups[gi].vbuf.id);
+ }
- g_shape_vert_count = total_verts;
- g_shape_idx_count = total_indices;
g_shape_pool_dirty = false;
}
static void shape_pool_shutdown(void)
{
- if (g_shape_vbuf.id) { sg_destroy_buffer(g_shape_vbuf); g_shape_vbuf.id = 0; }
- if (g_shape_ibuf.id) { sg_destroy_buffer(g_shape_ibuf); g_shape_ibuf.id = 0; }
- g_shape_vert_count = 0;
- g_shape_idx_count = 0;
+ for (int i = 0; i < g_shape_group_count; i++) {
+ if (g_shape_groups[i].vbuf.id) sg_destroy_buffer(g_shape_groups[i].vbuf);
+ }
+ FREE(g_shape_groups);
+ g_shape_groups = NULL;
+ g_shape_group_count = 0;
+
+ if (g_shape_data_view.id) { sg_destroy_view(g_shape_data_view); g_shape_data_view.id = 0; }
+ if (g_instance_map_view.id) { sg_destroy_view(g_instance_map_view); g_instance_map_view.id = 0; }
+ if (g_shape_data_sbuf.id) { sg_destroy_buffer(g_shape_data_sbuf); g_shape_data_sbuf.id = 0; }
+ if (g_instance_map_sbuf.id) { sg_destroy_buffer(g_instance_map_sbuf); g_instance_map_sbuf.id = 0; }
+ g_instance_map_capacity = 0;
+ if (g_upload_buf) { FREE(g_upload_buf); g_upload_buf = NULL; }
+ g_upload_buf_cap = 0;
}
#define SHAPE_HOVER_PX 6.0f
@@ -172,11 +332,23 @@ static void shape_build_transform(shape_t *s)
glm_scale_make(S, (vec3){s->sx, s->sy, 1.0f});
glm_mat4_mul(R, S, RS);
glm_mat4_mul(T, RS, s->uniform.transform);
+ s->cos_r = R[0][0];
+ s->sin_r = R[0][1];
+ g_shape_data_dirty = true;
+}
+
+static void shape_retranslate(shape_t *s)
+{
+ s->uniform.transform[3][0] = s->cx;
+ s->uniform.transform[3][1] = s->cy;
+ g_shape_data_dirty = true;
}
static void shape_make_buffers(shape_t *s)
{
- (void)s;
+ for (int i = 0; i < g_shape_group_count; i++) {
+ if (g_shape_groups[i].num_elements == s->num_elements) return;
+ }
g_shape_pool_dirty = true;
}
@@ -194,9 +366,11 @@ static void shape_regenerate(shape_t *s)
static void shape_set_state(shape_t *s, bool hovered, bool selected)
{
+ uint32_t new_state = selected ? 2u : (hovered ? 1u : 0u);
+ if (s->uniform.state != new_state) g_shape_data_dirty = true;
s->hovered = hovered;
s->selected = selected;
- s->uniform.state = selected ? 2u : (hovered ? 1u : 0u);
+ s->uniform.state = new_state;
}
static bool point_in_polygon(float px, float py, shape_vertex_t *verts, uint32_t n)
@@ -213,7 +387,7 @@ static bool point_in_polygon(float px, float py, shape_vertex_t *verts, uint32_t
static bool shape_hit_test(shape_t *s, float wx, float wy, float world_tol)
{
- float sc = cosf(s->rotation), ss = sinf(s->rotation);
+ float sc = s->cos_r, ss = s->sin_r;
float dx = wx - s->cx, dy = wy - s->cy;
float lx = (dx * sc + dy * ss) / s->sx;
float ly = (-dx * ss + dy * sc) / s->sy;
diff --git a/src/spatial.h b/src/spatial.h
index d3dd24a..51bc4e9 100644
--- a/src/spatial.h
+++ b/src/spatial.h
@@ -35,8 +35,8 @@ static int spatial_hash(int cx, int cy)
static void spatial_compute_aabb(shape_t *s, float *min_x, float *min_y,
float *max_x, float *max_y)
{
- float cos_r = cosf(s->rotation);
- float sin_r = sinf(s->rotation);
+ float cos_r = s->cos_r;
+ float sin_r = s->sin_r;
float hx = fabsf(cos_r) * s->sx + fabsf(sin_r) * s->sy;
float hy = fabsf(sin_r) * s->sx + fabsf(cos_r) * s->sy;
*min_x = s->cx - hx;
@@ -184,52 +184,34 @@ static int spatial_query_rect_select(spatial_grid_t *grid, vector_t *shapes,
}
int selected_count = 0;
- int min_cx = (int) floorf(min_x / SPATIAL_CELL_SIZE);
- int min_cy = (int) floorf(min_y / SPATIAL_CELL_SIZE);
- int max_cx = (int) floorf(max_x / SPATIAL_CELL_SIZE);
- int max_cy = (int) floorf(max_y / SPATIAL_CELL_SIZE);
-
- for (int cell_x = min_cx; cell_x <= max_cx; cell_x++) {
- for (int cell_y = min_cy; cell_y <= max_cy; cell_y++) {
- int idx = spatial_hash(cell_x, cell_y) & (SPATIAL_HASH_SIZE - 1);
- int probe_start = idx;
-
- do {
- if (!grid->slots[idx].occupied) break;
-
- if (grid->slots[idx].cx == cell_x && grid->slots[idx].cy == cell_y) {
- for (int e = 0; e < grid->slots[idx].count; e++) {
- spatial_entry_t *entry = &grid->slots[idx].entries[e];
-
- if (entry->max_x < min_x || entry->min_x > max_x ||
- entry->max_y < min_y || entry->min_y > max_y)
- continue;
-
- shape_t *s = (shape_t*) vec_get(shapes, entry->shape_idx);
- if (s->selected) continue;
-
- bool hit = (s->cx >= min_x && s->cx <= max_x &&
- s->cy >= min_y && s->cy <= max_y);
- float sc = cosf(s->rotation), ss = sinf(s->rotation);
- for (uint32_t v = 0; !hit && v < s->num_verts; v++) {
- float lx = s->verts[v].x * s->sx;
- float ly = s->verts[v].y * s->sy;
- float wx = s->cx + lx * sc - ly * ss;
- float wy = s->cy + lx * ss + ly * sc;
- if (wx >= min_x && wx <= max_x &&
- wy >= min_y && wy <= max_y)
- hit = true;
- }
- if (hit) {
- s->selected = true;
- selected_count++;
- }
- }
- break;
- }
-
- idx = (idx + 1) & (SPATIAL_HASH_SIZE - 1);
- } while (idx != probe_start);
+ for (int s = 0; s < SPATIAL_HASH_SIZE; s++) {
+ if (!grid->slots[s].occupied) continue;
+ for (int e = 0; e < grid->slots[s].count; e++) {
+ spatial_entry_t *entry = &grid->slots[s].entries[e];
+
+ if (entry->max_x < min_x || entry->min_x > max_x ||
+ entry->max_y < min_y || entry->min_y > max_y)
+ continue;
+
+ shape_t *shape = (shape_t*) vec_get(shapes, entry->shape_idx);
+ if (shape->selected) continue;
+
+ bool hit = (shape->cx >= min_x && shape->cx <= max_x &&
+ shape->cy >= min_y && shape->cy <= max_y);
+ float sc = shape->cos_r, ss = shape->sin_r;
+ for (uint32_t v = 0; !hit && v < shape->num_verts; v++) {
+ float lx = shape->verts[v].x * shape->sx;
+ float ly = shape->verts[v].y * shape->sy;
+ float wx = shape->cx + lx * sc - ly * ss;
+ float wy = shape->cy + lx * ss + ly * sc;
+ if (wx >= min_x && wx <= max_x &&
+ wy >= min_y && wy <= max_y)
+ hit = true;
+ }
+ if (hit) {
+ shape->selected = true;
+ selected_count++;
+ }
}
}
return selected_count;
diff --git a/src/types.h b/src/types.h
index 8a9272f..98fcef8 100644
--- a/src/types.h
+++ b/src/types.h
@@ -89,6 +89,8 @@ typedef struct {
int focused_group_id;
double last_click_time;
int last_click_shape_idx;
+
+ vector_t drag_indices;
} interact_state_t;
typedef struct {
@@ -112,6 +114,13 @@ typedef struct {
int list_prev_count;
} ui_state_t;
+typedef struct {
+ shape_t *shapes;
+ int shape_count;
+ group_t *groups;
+ int group_count;
+} clipboard_t;
+
typedef struct userdata_t {
camera_t camera;
renderer_t renderer;
@@ -127,6 +136,8 @@ typedef struct userdata_t {
sg_buffer corner_vbuf, corner_ibuf;
int next_group_id;
vector_t groups;
+ clipboard_t clipboard;
+ float mouse_x, mouse_y;
double time;
} userdata_t;
diff --git a/src/ui_panels.h b/src/ui_panels.h
index 6d7a243..7ba4920 100644
--- a/src/ui_panels.h
+++ b/src/ui_panels.h
@@ -352,8 +352,8 @@ static void draw_properties_panel(userdata_t *ud)
(*m)[2][0], (*m)[2][1], (*m)[2][2], (*m)[2][3],
(*m)[3][0], (*m)[3][1], (*m)[3][2], (*m)[3][3],
s->verts[0].x, s->verts[0].y,
- s->cx + s->verts[0].x * s->sx * cosf(s->rotation) - s->verts[0].y * s->sy * sinf(s->rotation),
- s->cy + s->verts[0].x * s->sx * sinf(s->rotation) + s->verts[0].y * s->sy * cosf(s->rotation),
+ s->cx + s->verts[0].x * s->sx * s->cos_r - s->verts[0].y * s->sy * s->sin_r,
+ s->cy + s->verts[0].x * s->sx * s->sin_r + s->verts[0].y * s->sy * s->cos_r,
s->cx, s->cy, s->sx, s->sy, s->rotation);
if (igButton("Copy Debug", (ImVec2){0, 0}))
sapp_set_clipboard_string(dbg);
@@ -389,7 +389,9 @@ static void draw_log_panel(userdata_t *ud)
int idx = (start + i) % LOG_RING_SIZE;
off += snprintf(buf + off, (size_t)(cap - off), "%s\n", ud->ui.log_ring[idx].text);
}
- igSetClipboardText(buf);
+ EM_ASM({
+ navigator.clipboard.writeText(UTF8ToString($0));
+ }, buf);
FREE(buf);
}
igSameLine(0.0f, 10.0f);
Reference in New Issue View Git Blame Copy Permalink