prosperon/source/engine/debug/debugdraw.c

632 lines
16 KiB
C
Raw Normal View History

2021-11-30 21:29:18 -06:00
#include "debugdraw.h"
#include "openglrender.h"
2023-05-22 00:08:08 -05:00
#include "render.h"
2021-11-30 21:29:18 -06:00
2023-05-24 20:45:50 -05:00
#include "yugine.h"
2021-11-30 21:29:18 -06:00
#include "shader.h"
#include "log.h"
2023-01-25 21:32:58 -06:00
#include <assert.h>
#include "debug.h"
2023-02-13 08:30:35 -06:00
#include "window.h"
2023-03-03 13:07:59 -06:00
#include "2dphysics.h"
2023-01-25 21:32:58 -06:00
#include "stb_ds.h"
2023-05-04 17:07:00 -05:00
#include "sokol/sokol_gfx.h"
2021-11-30 21:29:18 -06:00
2023-05-12 22:21:11 -05:00
#define PAR_STREAMLINES_IMPLEMENTATION
#include "par/par_streamlines.h"
2023-05-12 13:22:05 -05:00
#include "font.h"
2021-11-30 21:29:18 -06:00
2023-05-24 20:45:50 -05:00
#define v_amt 1000
2023-05-16 01:31:13 -05:00
static sg_shader point_shader;
static sg_pipeline point_pipe;
static sg_bindings point_bind;
struct point_vertex {
cpVect pos;
struct rgba color;
float radius;
};
static int point_c = 0;
2023-05-24 20:45:50 -05:00
static struct point_vertex point_b[v_amt];
2023-05-16 01:31:13 -05:00
2023-05-16 13:31:19 -05:00
static sg_shader line_shader;
static sg_pipeline line_pipe;
static sg_bindings line_bind;
struct line_vert {
cpVect pos;
float dist;
struct rgba color;
float seg_len;
2023-05-25 21:55:55 -05:00
float seg_speed;
2023-05-16 13:31:19 -05:00
};
static int line_c = 0;
static int line_v = 0;
2023-05-24 20:45:50 -05:00
static struct line_vert line_b[v_amt];
static uint16_t line_bi[v_amt];
2023-05-16 13:31:19 -05:00
2023-05-12 13:22:05 -05:00
static sg_pipeline grid_pipe;
static sg_bindings grid_bind;
static sg_shader grid_shader;
static int grid_c = 0;
2021-11-30 21:29:18 -06:00
2023-05-13 22:01:53 -05:00
static sg_pipeline poly_pipe;
static sg_bindings poly_bind;
static sg_shader poly_shader;
static int poly_c = 0;
static int poly_v = 0;
2023-05-16 01:31:13 -05:00
struct poly_vertex {
2023-05-24 20:45:50 -05:00
cpVect pos;
2023-05-16 01:31:13 -05:00
float uv[2];
struct rgba color;
};
2023-05-24 20:45:50 -05:00
static struct poly_vertex poly_b[v_amt];
static uint32_t poly_bi[v_amt];
2023-05-13 22:01:53 -05:00
2023-05-12 13:22:05 -05:00
static sg_pipeline circle_pipe;
static sg_bindings circle_bind;
static sg_shader csg;
static int circle_count = 0;
2023-05-16 01:31:13 -05:00
struct circle_vertex {
2023-05-27 10:13:20 -05:00
cpVect pos;
2023-05-16 01:31:13 -05:00
float radius;
struct rgba color;
2023-05-24 20:45:50 -05:00
float segsize;
float fill;
2023-05-16 01:31:13 -05:00
};
2023-05-24 20:45:50 -05:00
static struct circle_vertex circle_b[v_amt];
2023-05-04 17:07:00 -05:00
2023-05-07 19:47:49 -05:00
void debug_flush()
{
2023-05-12 13:22:05 -05:00
2023-05-22 00:08:08 -05:00
if (poly_c != 0) {
2023-05-13 22:01:53 -05:00
sg_apply_pipeline(poly_pipe);
sg_apply_bindings(&poly_bind);
sg_apply_uniforms(SG_SHADERSTAGE_VS,0,SG_RANGE_REF(projection));
2023-05-22 00:08:08 -05:00
sg_update_buffer(poly_bind.vertex_buffers[0], &(sg_range){
.ptr = poly_b, .size = sizeof(struct poly_vertex)*poly_v});
sg_update_buffer(poly_bind.index_buffer, &(sg_range){
.ptr = poly_bi, .size = sizeof(uint32_t)*poly_c});
2023-05-13 22:01:53 -05:00
sg_draw(0,poly_c,1);
poly_c = 0;
poly_v = 0;
2023-05-22 00:08:08 -05:00
}
2023-05-16 01:31:13 -05:00
2023-05-22 00:08:08 -05:00
if (point_c != 0) {
2023-05-16 01:31:13 -05:00
sg_apply_pipeline(point_pipe);
sg_apply_bindings(&point_bind);
sg_apply_uniforms(SG_SHADERSTAGE_VS,0,SG_RANGE_REF(projection));
2023-05-22 00:08:08 -05:00
sg_update_buffer(point_bind.vertex_buffers[0], &(sg_range){
.ptr = point_b,
.size = sizeof(struct point_vertex)*point_c});
2023-05-16 01:31:13 -05:00
sg_draw(0,point_c,1);
point_c = 0;
2023-05-22 00:08:08 -05:00
}
2023-05-16 13:31:19 -05:00
2023-05-22 00:08:08 -05:00
if (line_c != 0) {
2023-05-16 13:31:19 -05:00
sg_apply_pipeline(line_pipe);
sg_apply_bindings(&line_bind);
sg_apply_uniforms(SG_SHADERSTAGE_VS,0,SG_RANGE_REF(projection));
2023-05-24 20:45:50 -05:00
float time = lastTick;
sg_range tr = {
.ptr = &time,
.size = sizeof(float)
};
sg_apply_uniforms(SG_SHADERSTAGE_FS,0,&tr);
2023-05-22 00:08:08 -05:00
sg_update_buffer(line_bind.vertex_buffers[0], &(sg_range){
.ptr = line_b, .size = sizeof(struct line_vert)*line_v});
sg_update_buffer(line_bind.index_buffer, &(sg_range){
.ptr = line_bi, .size = sizeof(uint16_t)*line_c});
2023-05-16 13:31:19 -05:00
sg_draw(0,line_c,1);
line_c = 0;
line_v = 0;
2023-05-22 00:08:08 -05:00
}
2023-05-27 07:01:17 -05:00
if (circle_count != 0) {
sg_apply_pipeline(circle_pipe);
sg_apply_bindings(&circle_bind);
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, SG_RANGE_REF(projection));
sg_update_buffer(circle_bind.vertex_buffers[0], &(sg_range){
.ptr = circle_b,
.size = sizeof(struct circle_vertex)*circle_count
});
sg_draw(0,4,circle_count);
circle_count = 0;
}
2023-05-07 19:47:49 -05:00
}
2023-05-12 13:22:05 -05:00
static sg_shader_uniform_block_desc projection_ubo = {
.size = sizeof(projection),
.uniforms = {
[0] = { .name = "proj", .type = SG_UNIFORMTYPE_MAT4 },
}
};
2023-05-24 20:45:50 -05:00
static sg_shader_uniform_block_desc time_ubo = {
.size = sizeof(float),
.uniforms = {
[0] = { .name = "time", .type = SG_UNIFORMTYPE_FLOAT },
}
};
2021-11-30 21:29:18 -06:00
void debugdraw_init()
{
2023-05-24 20:45:50 -05:00
point_shader = sg_compile_shader("shaders/point_v.glsl", "shaders/point_f.glsl", &(sg_shader_desc){
2023-05-16 01:31:13 -05:00
.vs.uniform_blocks[0] = projection_ubo
});
point_pipe = sg_make_pipeline(&(sg_pipeline_desc){
.shader = point_shader,
.layout = {
.attrs = {
[0].format = SG_VERTEXFORMAT_FLOAT2, /* pos */
[1].format = SG_VERTEXFORMAT_UBYTE4N, /* color */
[2].format = SG_VERTEXFORMAT_FLOAT /* radius */
}
},
.primitive_type = SG_PRIMITIVETYPE_POINTS,
.colors[0].blend = blend_trans
});
point_bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(struct point_vertex)*5000,
.usage = SG_USAGE_STREAM
});
2023-05-24 20:45:50 -05:00
line_shader = sg_compile_shader("shaders/linevert.glsl", "shaders/linefrag.glsl", &(sg_shader_desc){
.vs.uniform_blocks[0] = projection_ubo,
.fs.uniform_blocks[0] = time_ubo
2023-05-16 13:31:19 -05:00
});
line_pipe = sg_make_pipeline(&(sg_pipeline_desc){
.shader = line_shader,
.layout = {
.attrs = {
[0].format = SG_VERTEXFORMAT_FLOAT2, /* pos */
[1].format = SG_VERTEXFORMAT_FLOAT, /* dist */
[2].format = SG_VERTEXFORMAT_UBYTE4N, /* color */
2023-05-25 21:55:55 -05:00
[3].format = SG_VERTEXFORMAT_FLOAT, /* seg length */
[4].format = SG_VERTEXFORMAT_FLOAT /* dashed line speed */
2023-05-16 13:31:19 -05:00
}
},
.primitive_type = SG_PRIMITIVETYPE_LINES,
.index_type = SG_INDEXTYPE_UINT16,
.colors[0].blend = blend_trans
});
line_bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(struct line_vert)*5000,
.usage = SG_USAGE_STREAM
});
line_bind.index_buffer = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(uint16_t)*5000,
.usage = SG_USAGE_STREAM,
.type = SG_BUFFERTYPE_INDEXBUFFER
});
2023-05-24 20:45:50 -05:00
csg = sg_compile_shader("shaders/circlevert.glsl", "shaders/circlefrag.glsl", &(sg_shader_desc){
2023-05-12 13:22:05 -05:00
.vs.uniform_blocks[0] = projection_ubo,
2023-05-04 17:07:00 -05:00
});
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
circle_pipe = sg_make_pipeline(&(sg_pipeline_desc){
.shader = csg,
.layout = {
.attrs = {
[0].format = SG_VERTEXFORMAT_FLOAT2,
[0].buffer_index = 1,
2023-05-16 01:31:13 -05:00
[1].format = SG_VERTEXFORMAT_FLOAT2,
[2].format = SG_VERTEXFORMAT_FLOAT,
2023-05-24 20:45:50 -05:00
[3].format = SG_VERTEXFORMAT_UBYTE4N,
[4].format = SG_VERTEXFORMAT_FLOAT,
[5].format = SG_VERTEXFORMAT_FLOAT
2023-05-12 13:22:05 -05:00
},
.buffers[0].step_func = SG_VERTEXSTEP_PER_INSTANCE,
},
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
.cull_mode = SG_CULLMODE_BACK,
2023-05-16 01:31:13 -05:00
.colors[0].blend = blend_trans,
2023-05-12 13:22:05 -05:00
.label = "circle pipeline"
});
circle_bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
2023-05-24 20:45:50 -05:00
.size = sizeof(struct circle_vertex)*v_amt,
2023-05-12 13:22:05 -05:00
.usage = SG_USAGE_STREAM,
});
float circleverts[8] = {
-1,-1,
-1,1,
1,-1,
1,1
};
circle_bind.vertex_buffers[1] = sg_make_buffer(&(sg_buffer_desc){
.data = SG_RANGE(circleverts),
.usage = SG_USAGE_IMMUTABLE,
});
2023-05-16 01:31:13 -05:00
2023-05-24 20:45:50 -05:00
grid_shader = sg_compile_shader("shaders/gridvert.glsl", "shaders/gridfrag.glsl", &(sg_shader_desc){
2023-05-12 13:22:05 -05:00
.vs.uniform_blocks[0] = projection_ubo,
.vs.uniform_blocks[1] = {
.size = sizeof(float)*2,
.uniforms = { [0] = { .name = "offset", .type = SG_UNIFORMTYPE_FLOAT2 } } },
.fs.uniform_blocks[0] = {
2023-05-16 01:31:13 -05:00
.size = sizeof(float)*6,
2023-05-12 13:22:05 -05:00
.uniforms = {
[0] = { .name = "thickness", .type = SG_UNIFORMTYPE_FLOAT },
[1] = { .name = "span", .type = SG_UNIFORMTYPE_FLOAT },
2023-05-16 01:31:13 -05:00
[2] = { .name = "color", .type = SG_UNIFORMTYPE_FLOAT4 },
2023-05-12 13:22:05 -05:00
}
},
});
2023-05-16 01:31:13 -05:00
2023-05-12 13:22:05 -05:00
grid_pipe = sg_make_pipeline(&(sg_pipeline_desc){
.shader = grid_shader,
.layout = {
.attrs = {
2023-05-16 01:31:13 -05:00
[0].format = SG_VERTEXFORMAT_FLOAT2, /* pos */
2023-05-12 13:22:05 -05:00
}
},
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
2023-05-16 01:31:13 -05:00
// .cull_mode = sg_cullmode_back,
2023-05-12 13:22:05 -05:00
.label = "grid pipeline",
2023-05-16 01:31:13 -05:00
.colors[0].blend = blend_trans,
2023-05-12 13:22:05 -05:00
});
2023-05-16 01:31:13 -05:00
2023-05-12 13:22:05 -05:00
grid_bind.vertex_buffers[0] = circle_bind.vertex_buffers[1];
2023-05-13 22:01:53 -05:00
2023-05-24 20:45:50 -05:00
poly_shader = sg_compile_shader("shaders/poly_v.glsl", "shaders/poly_f.glsl", &(sg_shader_desc){
2023-05-16 01:31:13 -05:00
.vs.uniform_blocks[0] = projection_ubo
2023-05-13 22:01:53 -05:00
});
poly_pipe = sg_make_pipeline(&(sg_pipeline_desc){
.shader = poly_shader,
.layout = {
2023-05-16 01:31:13 -05:00
.attrs = { [0].format = SG_VERTEXFORMAT_FLOAT2, /* pos */
[1].format = SG_VERTEXFORMAT_FLOAT2, /* uv */
[2].format = SG_VERTEXFORMAT_UBYTE4N /* color rgba */
2023-05-13 22:01:53 -05:00
}
},
2023-05-16 01:31:13 -05:00
.index_type = SG_INDEXTYPE_UINT32,
.colors[0].blend = blend_trans,
2023-05-13 22:01:53 -05:00
});
poly_bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
2023-05-24 20:45:50 -05:00
.size = sizeof(struct poly_vertex)*v_amt,
2023-05-13 22:01:53 -05:00
.usage = SG_USAGE_STREAM,
.type = SG_BUFFERTYPE_VERTEXBUFFER,
});
poly_bind.index_buffer = sg_make_buffer(&(sg_buffer_desc){
2023-05-24 20:45:50 -05:00
.size = sizeof(uint32_t)*6*v_amt,
2023-05-13 22:01:53 -05:00
.usage = SG_USAGE_STREAM,
.type = SG_BUFFERTYPE_INDEXBUFFER
});
2021-11-30 21:29:18 -06:00
}
2023-05-25 21:55:55 -05:00
void draw_line(cpVect *a_points, int a_n, struct rgba color, float seg_len, int closed, float seg_speed)
2021-11-30 21:29:18 -06:00
{
2023-05-16 13:31:19 -05:00
if (a_n < 2) return;
2023-05-27 07:01:17 -05:00
seg_speed = 1;
2023-05-24 20:45:50 -05:00
int n = closed ? a_n+1 : a_n;
2023-05-16 13:31:19 -05:00
cpVect points[n];
2023-05-24 20:45:50 -05:00
memcpy(points, a_points, sizeof(cpVect)*n);
if (closed)
points[n-1] = a_points[0];
2023-05-16 13:31:19 -05:00
struct line_vert v[n];
float dist = 0;
for (int i = 0; i < n-1; i++) {
v[i].pos = points[i];
v[i].dist = dist;
v[i].color = color;
v[i].seg_len = seg_len;
2023-05-25 21:55:55 -05:00
v[i].seg_speed = seg_speed;
2023-05-16 13:31:19 -05:00
dist += cpvdist(points[i], points[i+1]);
}
v[n-1].pos = points[n-1];
v[n-1].dist = dist;
v[n-1].color = color;
v[n-1].seg_len = seg_len;
2023-05-25 21:55:55 -05:00
v[n-1].seg_speed = seg_speed;
2023-05-16 13:31:19 -05:00
int i_c = (n-1)*2;
uint16_t idxs[i_c];
for (int i = 0, d = 0; i < n-1; i++, d+=2) {
idxs[d] = i + line_v;
idxs[d+1] = i+1 + line_v;
}
sg_range vr = {
.ptr = v,
.size = sizeof(struct line_vert)*n
};
sg_range ir = {
.ptr = idxs,
.size = sizeof(uint16_t)*i_c
};
2023-05-22 00:08:08 -05:00
memcpy(line_b+line_v, v, sizeof(struct line_vert)*n);
memcpy(line_bi+line_c, idxs, sizeof(uint16_t)*i_c);
2023-05-16 13:31:19 -05:00
line_c += i_c;
line_v += n;
2021-11-30 21:29:18 -06:00
}
2023-02-15 17:54:05 -06:00
cpVect center_of_vects(cpVect *v, int n)
{
cpVect c;
for (int i = 0; i < n; i++) {
c.x += v[i].x;
c.y += v[i].y;
}
c.x /= n;
c.y /= n;
return c;
}
float vecs2m(cpVect a, cpVect b)
{
return (b.y-a.y)/(b.x-a.x);
}
2023-02-16 01:56:22 -06:00
cpVect inflatepoint(cpVect a, cpVect b, cpVect c, float d)
{
cpVect ba = cpvnormalize(cpvsub(a,b));
cpVect bc = cpvnormalize(cpvsub(c,b));
cpVect avg = cpvadd(ba, bc);
avg = cpvmult(avg, 0.5);
float dot = cpvdot(ba, bc);
dot /= cpvlength(ba);
dot /= cpvlength(bc);
float mid = acos(dot)/2;
avg = cpvnormalize(avg);
return cpvadd(b, cpvmult(avg, d/sin(mid)));
}
void inflatepoints(cpVect *r, cpVect *p, float d, int n)
2023-03-24 14:01:01 -05:00
{
if (d == 0) {
2023-02-16 01:56:22 -06:00
for (int i = 0; i < n; i++)
r[i] = p[i];
return;
}
2023-03-24 14:01:01 -05:00
2023-02-16 01:56:22 -06:00
if (cpveql(p[0], p[n-1])) {
r[0] = inflatepoint(p[n-2],p[0],p[1],d);
r[n-1] = r[0];
} else {
cpVect outdir = cpvmult(cpvnormalize(cpvsub(p[0],p[1])),fabs(d));
cpVect perp;
if (d > 0)
perp = cpvperp(outdir);
else
perp = cpvrperp(outdir);
r[0] = cpvadd(p[0],cpvadd(outdir,perp));
outdir = cpvmult(cpvnormalize(cpvsub(p[n-1],p[n-2])),fabs(d));
if (d > 0)
perp = cpvrperp(outdir);
else
perp = cpvperp(outdir);
r[n-1] = cpvadd(p[n-1],cpvadd(outdir,perp));
}
for (int i = 0; i < n-2; i++)
r[i+1] = inflatepoint(p[i],p[i+1],p[i+2], d);
}
2023-05-24 20:45:50 -05:00
void draw_edge(cpVect *points, int n, struct rgba color, int thickness, int closed, int flags, struct rgba line_color, float line_seg)
2021-11-30 21:29:18 -06:00
{
2023-05-16 01:31:13 -05:00
static_assert(sizeof(cpVect) == 2*sizeof(float));
2023-05-24 20:45:50 -05:00
if (thickness == 0) {
thickness = 1;
}
2023-05-16 01:31:13 -05:00
/* todo: should be dashed, and filled. use a texture. */
/* draw polygon outline */
2023-05-24 20:45:50 -05:00
if (cpveql(points[0], points[n-1])) {
closed = true;
n--;
}
2023-05-13 22:01:53 -05:00
parsl_position par_v[n];
for (int i = 0; i < n; i++) {
par_v[i].x = points[i].x;
par_v[i].y = points[i].y;
}
2023-02-16 01:56:22 -06:00
2023-05-13 22:01:53 -05:00
uint16_t spine_lens[] = {n};
parsl_context *par_ctx = parsl_create_context((parsl_config){
2023-05-24 20:45:50 -05:00
.thickness = thickness,
2023-05-16 13:31:19 -05:00
.flags = PARSL_FLAG_ANNOTATIONS,
.u_mode = PAR_U_MODE_DISTANCE,
2023-05-13 22:01:53 -05:00
});
parsl_mesh *mesh = parsl_mesh_from_lines(par_ctx, (parsl_spine_list){
.num_vertices = n,
.num_spines = 1,
2023-05-16 01:31:13 -05:00
.vertices = par_v,
2023-05-13 22:01:53 -05:00
.spine_lengths = spine_lens,
2023-05-16 01:31:13 -05:00
.closed = closed
2023-05-13 22:01:53 -05:00
});
for (int i = 0; i < mesh->num_triangles*3; i++)
mesh->triangle_indices[i] += poly_v;
2023-05-16 01:31:13 -05:00
struct poly_vertex vertices[mesh->num_vertices];
2023-05-13 22:01:53 -05:00
2023-05-16 01:31:13 -05:00
for (int i = 0; i < mesh->num_vertices; i++) {
2023-05-24 20:45:50 -05:00
vertices[i].pos = (cpVect){ .x = mesh->positions[i].x, .y = mesh->positions[i].y };
2023-05-16 01:31:13 -05:00
vertices[i].uv[0] = mesh->annotations[i].u_along_curve;
vertices[i].uv[1] = mesh->annotations[i].v_across_curve;
vertices[i].color = color;
}
2023-05-22 00:08:08 -05:00
memcpy(poly_b+poly_v, vertices, sizeof(struct poly_vertex)*mesh->num_vertices);
memcpy(poly_bi+poly_c, mesh->triangle_indices, sizeof(uint32_t)*mesh->num_triangles*3);
2023-05-13 22:01:53 -05:00
poly_c += mesh->num_triangles*3;
2023-05-16 01:31:13 -05:00
poly_v += mesh->num_vertices;
2023-05-13 22:01:53 -05:00
parsl_destroy_context(par_ctx);
2023-05-24 20:45:50 -05:00
/* Now drawing the line outlines */
if (thickness == 1) {
2023-05-25 21:55:55 -05:00
draw_line(points,n,line_color,line_seg, 0, 0);
2023-05-24 20:45:50 -05:00
} else {
/* Draw inside and outside lines */
cpVect in_p[n];
cpVect out_p[n];
for (int i = 0, v = 0; i < n*2+1; i+=2, v++)
in_p[v] = vertices[i].pos;
for (int i = 1, v = 0; i < n*2; i+=2,v++)
out_p[v] = vertices[i].pos;
2023-05-25 21:55:55 -05:00
draw_line(in_p,n,line_color,line_seg,1,0);
draw_line(out_p,n,line_color,line_seg,1,0);
2023-05-24 20:45:50 -05:00
}
2021-11-30 21:29:18 -06:00
}
2023-05-27 10:13:20 -05:00
void draw_circle(cpVect pos, float radius, float pixels, struct rgba color, float seg)
2021-11-30 21:29:18 -06:00
{
2023-05-16 01:31:13 -05:00
struct circle_vertex cv;
2023-05-27 10:13:20 -05:00
cv.pos = pos;
2023-05-16 01:31:13 -05:00
cv.radius = radius;
cv.color = color;
2023-05-25 21:55:55 -05:00
cv.segsize = seg/radius;
2023-05-24 20:45:50 -05:00
cv.fill = pixels/radius;
2023-05-22 00:08:08 -05:00
memcpy(circle_b+circle_count, &cv, sizeof(struct circle_vertex));
2023-05-12 13:22:05 -05:00
circle_count++;
2021-11-30 21:29:18 -06:00
}
2023-05-25 21:55:55 -05:00
void draw_box(struct cpVect c, struct cpVect wh, struct rgba color)
2021-11-30 21:29:18 -06:00
{
2023-05-25 21:55:55 -05:00
float hw = wh.x / 2.f;
float hh = wh.y / 2.f;
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
cpVect verts[4] = {
2023-05-25 21:55:55 -05:00
{ .x = c.x-hw, .y = c.y-hh },
{ .x = c.x+hw, .y = c.y-hh },
{ .x = c.x+hw, .y = c.y+hh },
{ .x = c.x-hw, .y = c.y+hh }
2021-11-30 21:29:18 -06:00
};
2023-05-12 13:22:05 -05:00
2023-05-25 21:55:55 -05:00
draw_poly(verts, 4, color);
2023-02-05 17:42:36 -06:00
}
2023-05-16 01:31:13 -05:00
void draw_arrow(struct cpVect start, struct cpVect end, struct rgba color, int capsize)
2023-05-16 13:31:19 -05:00
{
cpVect points[2] = {start, end};
2023-05-25 21:55:55 -05:00
draw_line(points, 2, color, 0, 0,0);
2023-03-17 10:25:35 -05:00
draw_cppoint(end, capsize, color);
2023-03-13 09:27:32 -05:00
}
2023-05-16 01:31:13 -05:00
void draw_grid(int width, int span, struct rgba color)
2021-11-30 21:29:18 -06:00
{
2023-02-13 08:30:35 -06:00
cpVect offset = cam_pos();
2023-05-12 13:22:05 -05:00
offset = cpvmult(offset, 1/cam_zoom());
2023-02-13 08:30:35 -06:00
offset.x -= mainwin->width/2;
offset.y -= mainwin->height/2;
2023-02-20 16:28:07 -06:00
2023-05-12 13:22:05 -05:00
sg_apply_pipeline(grid_pipe);
sg_apply_bindings(&grid_bind);
2023-05-16 01:31:13 -05:00
float col[4] = { color.r/255.0 ,color.g/255.0 ,color.b/255.0 ,color.a/255.0 };
float fubo[6];
fubo[0] = 1;
fubo[1] = span;
memcpy(&fubo[2], col, sizeof(float)*4);
2023-05-12 13:22:05 -05:00
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, SG_RANGE_REF(projection));
sg_apply_uniforms(SG_SHADERSTAGE_VS, 1, SG_RANGE_REF(offset));
sg_apply_uniforms(SG_SHADERSTAGE_FS, 0, SG_RANGE_REF(fubo));
sg_draw(0,4,1);
2021-11-30 21:29:18 -06:00
}
2023-05-16 13:31:19 -05:00
void draw_cppoint(struct cpVect point, float r, struct rgba color)
2021-11-30 21:29:18 -06:00
{
2023-05-16 13:31:19 -05:00
struct point_vertex p = {
.pos = point,
.color = color,
.radius = r
2023-05-16 01:31:13 -05:00
};
2023-05-22 00:08:08 -05:00
memcpy(point_b+point_c, &p, sizeof(struct point_vertex));
2023-05-16 01:31:13 -05:00
point_c++;
2021-11-30 21:29:18 -06:00
}
2023-05-16 01:31:13 -05:00
void draw_points(struct cpVect *points, int n, float size, struct rgba color)
2023-01-25 21:32:58 -06:00
{
for (int i = 0; i < n; i++)
2023-05-16 13:31:19 -05:00
draw_cppoint(points[i], size, color);
2023-01-25 21:32:58 -06:00
}
2023-05-25 21:55:55 -05:00
void draw_poly(cpVect *points, int n, struct rgba color)
2021-11-30 21:29:18 -06:00
{
2023-05-16 01:31:13 -05:00
/* Find polygon mesh */
int tric = n - 2;
2023-05-13 22:01:53 -05:00
2023-05-16 01:31:13 -05:00
if (n < 1) return;
uint32_t tridxs[tric*3];
2023-05-13 22:01:53 -05:00
2023-05-16 01:31:13 -05:00
for (int i = 2, ti = 0; i < n; i++, ti+=3) {
tridxs[ti] = 0;
tridxs[ti+1] = i-1;
tridxs[ti+2] = i;
}
for (int i = 0; i < tric*3; i++)
tridxs[i] += poly_v;
sg_range trip = {
.ptr = tridxs,
.size = sizeof(uint32_t)*3*tric
2023-05-13 22:01:53 -05:00
};
2023-05-16 01:31:13 -05:00
struct poly_vertex polyverts[n];
2023-05-13 22:01:53 -05:00
2023-05-16 01:31:13 -05:00
for (int i = 0; i < n; i++) {
2023-05-24 20:45:50 -05:00
polyverts[i].pos = points[i];
2023-05-16 01:31:13 -05:00
polyverts[i].uv[0] = 0.0;
polyverts[i].uv[1] = 0.0;
polyverts[i].color = color;
2023-05-13 22:01:53 -05:00
}
2023-05-16 01:31:13 -05:00
sg_range ppp = {
.ptr = polyverts,
.size = sizeof(struct poly_vertex)*n
2023-05-13 22:01:53 -05:00
};
2023-05-22 00:08:08 -05:00
memcpy(poly_b+poly_v, polyverts, sizeof(struct poly_vertex)*n);
memcpy(poly_bi+poly_c, tridxs, sizeof(uint32_t)*3*tric);
2023-05-13 22:01:53 -05:00
2023-05-16 01:31:13 -05:00
poly_c += tric*3;
poly_v += n;
2021-11-30 21:29:18 -06:00
}
void debugdraw_flush()
{
}