prosperon/source/engine/2dphysics.c

626 lines
17 KiB
C
Raw Normal View History

2021-11-30 21:29:18 -06:00
#include "2dphysics.h"
#include "gameobject.h"
2023-05-12 13:22:05 -05:00
#include <string.h>
2021-11-30 21:29:18 -06:00
2022-08-17 00:01:51 -05:00
#include "debugdraw.h"
2022-12-20 08:16:26 -06:00
#include "stb_ds.h"
2023-01-25 21:32:58 -06:00
#include <assert.h>
2023-05-12 13:22:05 -05:00
#include <chipmunk/chipmunk_unsafe.h>
#include <math.h>
2022-12-20 08:16:26 -06:00
2023-04-28 20:55:24 -05:00
#include "2dphysics.h"
2023-11-03 22:01:30 -05:00
#include "jsffi.h"
2023-05-12 13:22:05 -05:00
#include "script.h"
2022-12-26 20:57:45 -06:00
2022-12-20 08:16:26 -06:00
#include "log.h"
2022-08-17 00:01:51 -05:00
2021-11-30 21:29:18 -06:00
cpSpace *space = NULL;
2023-05-16 01:31:13 -05:00
struct rgba color_white = {255,255,255,255};
struct rgba color_black = {0,0,0,255};
struct rgba color_clear = {0,0,0,0};
2023-05-16 01:31:13 -05:00
2023-05-24 20:45:50 -05:00
struct rgba disabled_color = {148,148,148,255};
struct rgba sleep_color = {255,140,228,255};
struct rgba dynamic_color = {255,70,46,255};
struct rgba kinematic_color = {255, 194, 64, 255};
struct rgba static_color = {73,209,80,255};
static JSValue fns[100];
static JSValue hits[100];
static int cb_idx = 0;
2023-05-24 20:45:50 -05:00
static const unsigned char col_alpha = 40;
2023-05-25 21:55:55 -05:00
static const float sensor_seg = 10;
2023-03-10 13:13:48 -06:00
unsigned int category_masks[32];
2023-12-11 08:36:45 -06:00
void set_cat_mask(int cat, unsigned int mask) { category_masks[cat] = mask; }
2023-03-10 13:13:48 -06:00
2023-12-04 13:38:37 -06:00
cpTransform m3_to_cpt(HMM_Mat3 m)
{
cpTransform t;
t.a = m.Columns[0].x;
2023-12-19 15:34:36 -06:00
t.b = m.Columns[0].y;
t.tx = m.Columns[2].x;
t.c = m.Columns[1].x;
2023-12-04 13:38:37 -06:00
t.d = m.Columns[1].y;
2023-12-19 15:34:36 -06:00
t.ty = m.Columns[2].y;
2023-12-04 13:38:37 -06:00
return t;
}
2023-05-12 13:22:05 -05:00
cpShape *phys2d_query_pos(cpVect pos) {
2024-04-03 17:17:32 -05:00
return cpSpacePointQueryNearest(space, pos, 0.f, allfilter, NULL);
}
2024-01-02 07:55:22 -06:00
static int qhit;
void qpoint(cpShape *shape, cpFloat dist, cpVect point, int *data)
{
qhit++;
}
void bbhit(cpShape *shape, int *data)
{
qhit++;
}
2024-04-11 17:17:49 -05:00
cpShapeFilter nofilter = {
.group = CP_NO_GROUP,
.mask = ~CP_ALL_CATEGORIES,
.categories = ~CP_ALL_CATEGORIES
};
2024-03-26 18:31:20 -05:00
cpShapeFilter allfilter = {
2024-01-02 07:55:22 -06:00
.group = CP_NO_GROUP,
.mask = CP_ALL_CATEGORIES,
.categories = CP_ALL_CATEGORIES,
};
int query_point(HMM_Vec2 pos)
{
qhit = 0;
// cpSpacePointQuery(space, pos.cp, 0, filter, qpoint, &qhit);
2024-03-26 18:31:20 -05:00
cpSpaceBBQuery(space, cpBBNewForCircle(pos.cp, 2), allfilter, bbhit, &qhit);
2024-01-02 07:55:22 -06:00
return qhit;
}
2023-12-12 08:46:27 -06:00
int p_compare(void *a, void *b)
{
if (a > b) return 1;
if (a < b) return -1;
return 0;
2023-12-12 08:46:27 -06:00
}
2023-12-11 16:59:59 -06:00
gameobject **clean_ids(gameobject **ids)
2023-12-04 13:38:37 -06:00
{
2023-12-12 08:46:27 -06:00
qsort(ids, arrlen(ids), sizeof(*ids), p_compare);
2023-12-11 16:59:59 -06:00
gameobject *curid = NULL;
2023-12-04 13:38:37 -06:00
for (int i = arrlen(ids)-1; i >= 0; i--)
if (ids[i] == curid)
arrdelswap(ids, i);
else
curid = ids[i];
return ids;
2023-02-05 17:42:36 -06:00
}
2023-05-12 13:22:05 -05:00
int cpshape_enabled(cpShape *c) {
cpShapeFilter filter = cpShapeGetFilter(c);
if (filter.categories == ~CP_ALL_CATEGORIES && filter.mask == ~CP_ALL_CATEGORIES)
return 0;
2023-05-12 13:22:05 -05:00
return 1;
}
2023-05-24 20:45:50 -05:00
struct rgba shape_color(cpShape *shape) {
if (!cpshape_enabled(shape)) return disabled_color;
2023-05-12 13:22:05 -05:00
switch (cpBodyGetType(cpShapeGetBody(shape))) {
case CP_BODY_TYPE_DYNAMIC:
2023-05-24 20:45:50 -05:00
// cpBodySleep(cpShapeGetBody(shape));
if (cpBodyIsSleeping(cpShapeGetBody(shape)))
return sleep_color;
2023-05-12 13:22:05 -05:00
return dynamic_color;
2023-05-12 13:22:05 -05:00
case CP_BODY_TYPE_KINEMATIC:
return kinematic_color;
2023-05-12 13:22:05 -05:00
case CP_BODY_TYPE_STATIC:
return static_color;
2023-05-12 13:22:05 -05:00
}
return static_color;
}
2024-01-04 08:14:37 -06:00
static warp_gravity *space_gravity;
2023-05-24 20:45:50 -05:00
void phys2d_init()
{
2023-05-12 13:22:05 -05:00
space = cpSpaceNew();
2023-05-24 20:45:50 -05:00
cpSpaceSetSleepTimeThreshold(space, 1);
2023-05-29 10:47:30 -05:00
cpSpaceSetCollisionSlop(space, 0.01);
cpSpaceSetCollisionBias(space, cpfpow(1.0-0.5, 165.f));
2024-01-04 08:14:37 -06:00
space_gravity = warp_gravity_make();
2021-11-30 21:29:18 -06:00
}
2024-01-04 08:14:37 -06:00
void phys2d_set_gravity(HMM_Vec2 v)
{
float str = HMM_LenV2(v);
HMM_Vec2 dir = HMM_NormV2(v);
space_gravity->strength = str;
space_gravity->t.scale = (HMM_Vec3){v.x,v.y, 0};
space_gravity->planar_force = (HMM_Vec3){v.x,v.y,0};
}
2024-01-14 10:24:31 -06:00
constraint *constraint_make(cpConstraint *c)
{
constraint *cp = malloc(sizeof(*cp));
cp->c = c;
cp->break_cb = JS_UNDEFINED;
cp->remove_cb = JS_UNDEFINED;
cpSpaceAddConstraint(space,c);
cpConstraintSetUserData(c, cp);
return cp;
}
void constraint_break(constraint *constraint)
{
if (!constraint->c) return;
cpSpaceRemoveConstraint(space, constraint->c);
cpConstraintFree(constraint->c);
constraint->c = NULL;
script_call_sym(constraint->break_cb,0,NULL);
2024-01-14 10:24:31 -06:00
}
void constraint_free(constraint *constraint)
{
constraint_break(constraint);
free(constraint);
}
void constraint_test(cpConstraint *constraint, float *dt)
{
float max = cpConstraintGetMaxForce(constraint);
if (!isfinite(max)) return;
float force = cpConstraintGetImpulse(constraint)/ *dt;
if (force > max)
constraint_break(cpConstraintGetUserData(constraint));
}
void phys2d_update(float deltaT) {
cpSpaceStep(space, deltaT);
cpSpaceEachConstraint(space, constraint_test, &deltaT);
cb_idx = 0;
2024-01-14 10:24:31 -06:00
}
2021-11-30 21:29:18 -06:00
2023-12-11 08:36:45 -06:00
void init_phys2dshape(struct phys2d_shape *shape, gameobject *go, void *data) {
2023-05-12 13:22:05 -05:00
shape->go = go;
shape->data = data;
2023-12-19 15:34:36 -06:00
shape->t.scale = (HMM_Vec2){1.0,1.0};
2023-12-11 08:36:45 -06:00
go_shape_apply(go->body, shape->shape, go);
cpShapeSetCollisionType(shape->shape, (cpCollisionType)go);
2023-05-12 13:22:05 -05:00
cpShapeSetUserData(shape->shape, shape);
2021-11-30 21:29:18 -06:00
}
2023-05-12 13:22:05 -05:00
void phys2d_shape_del(struct phys2d_shape *shape) {
if (!shape->shape) return;
cpSpaceRemoveShape(space, shape->shape);
cpShapeFree(shape->shape);
2022-08-28 22:34:33 -05:00
}
2023-01-16 02:16:39 -06:00
/***************** CIRCLE2D *****************/
2023-12-11 08:36:45 -06:00
struct phys2d_circle *Make2DCircle(gameobject *go) {
2023-05-12 13:22:05 -05:00
struct phys2d_circle *new = malloc(sizeof(struct phys2d_circle));
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
new->radius = 10.f;
2023-11-11 20:01:42 -06:00
new->offset = v2zero;
2021-11-30 21:29:18 -06:00
2023-12-11 08:36:45 -06:00
new->shape.shape = cpSpaceAddShape(space, cpCircleShapeNew(go->body, new->radius, cpvzero));
2023-05-12 13:22:05 -05:00
new->shape.debugdraw = phys2d_dbgdrawcircle;
new->shape.moi = phys2d_circle_moi;
2023-09-26 17:07:51 -05:00
new->shape.apply = phys2d_applycircle;
new->shape.free = NULL;
2023-05-12 13:22:05 -05:00
init_phys2dshape(&new->shape, go, new);
2023-09-27 09:37:20 -05:00
phys2d_applycircle(new);
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
return new;
2021-11-30 21:29:18 -06:00
}
2023-12-28 17:38:17 -06:00
float phys2d_circle_moi(struct phys2d_circle *c) {
float m = c->shape.go->mass;
return cpMomentForCircle(m, 0, cpCircleShapeGetRadius(c->shape.shape), cpCircleShapeGetOffset(c->shape.shape));
}
2024-03-20 14:32:35 -05:00
void phys2d_circledel(struct phys2d_circle *c) { phys2d_shape_del(&c->shape); }
void circle2d_free(circle2d *c) { phys2d_circledel(c); }
2022-08-28 22:34:33 -05:00
void phys2d_dbgdrawcpcirc(cpShape *c) {
2023-11-30 10:47:59 -06:00
HMM_Vec2 pos = mat_t_pos(t_go2world(shape2go(c)), (HMM_Vec2)cpCircleShapeGetOffset(c));
2023-05-12 13:22:05 -05:00
float radius = cpCircleShapeGetRadius(c);
2023-05-24 20:45:50 -05:00
struct rgba color = shape_color(c);
float seglen = cpShapeGetSensor(c) ? 5 : -1;
2023-11-14 09:20:09 -06:00
draw_circle(pos, radius, 1, color, seglen);
2023-05-24 20:45:50 -05:00
color.a = col_alpha;
2023-11-14 09:20:09 -06:00
draw_circle(pos,radius,radius,color,-1);
2023-01-03 09:06:36 -06:00
}
2023-12-28 17:38:17 -06:00
void phys2d_shape_apply(struct phys2d_shape *s)
{
float moment = cpBodyGetMoment(s->go->body);
float moi = s->moi(s->data);
s->apply(s->data);
float newmoi = s->moi(s->data);
moment-=moi;
moment += newmoi;
if (moment < 0) moment = 0;
2023-12-28 17:38:17 -06:00
cpBodySetMoment(s->go->body, moment);
}
2023-05-12 13:22:05 -05:00
void phys2d_dbgdrawcircle(struct phys2d_circle *circle) {
phys2d_dbgdrawcpcirc(circle->shape.shape);
2022-08-17 00:01:51 -05:00
}
2023-05-12 13:22:05 -05:00
void phys2d_applycircle(struct phys2d_circle *circle) {
2023-12-11 08:36:45 -06:00
gameobject *go = circle->shape.go;
2023-11-14 09:20:09 -06:00
float radius = circle->radius * HMM_MAX(HMM_ABS(go->scale.X), HMM_ABS(go->scale.Y));
2023-05-12 13:22:05 -05:00
cpCircleShapeSetRadius(circle->shape.shape, radius);
2023-12-24 11:50:01 -06:00
cpCircleShapeSetOffset(circle->shape.shape, circle->offset.cp);
2022-08-12 14:03:56 -05:00
}
2023-01-12 17:41:54 -06:00
/************** POLYGON ************/
2022-08-12 14:03:56 -05:00
2023-12-11 08:36:45 -06:00
struct phys2d_poly *Make2DPoly(gameobject *go) {
2023-05-12 13:22:05 -05:00
struct phys2d_poly *new = malloc(sizeof(struct phys2d_poly));
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
new->points = NULL;
arrsetlen(new->points, 0);
new->radius = 0.f;
2021-11-30 21:29:18 -06:00
new->shape.shape = cpSpaceAddShape(space, cpPolyShapeNewRaw(go->body, 0, (cpVect*)new->points, new->radius));
2023-05-12 13:22:05 -05:00
new->shape.debugdraw = phys2d_dbgdrawpoly;
new->shape.moi = phys2d_poly_moi;
new->shape.free = phys2d_poly_free;
2023-09-27 12:36:32 -05:00
new->shape.apply = phys2d_applypoly;
2023-05-12 13:22:05 -05:00
init_phys2dshape(&new->shape, go, new);
return new;
2021-11-30 21:29:18 -06:00
}
void phys2d_poly_free(struct phys2d_poly *poly)
{
arrfree(poly->points);
free(poly);
}
2023-12-28 17:38:17 -06:00
float phys2d_poly_moi(struct phys2d_poly *poly) {
float m = poly->shape.go->mass;
int len = cpPolyShapeGetCount(poly->shape.shape);
if (!len) {
YughWarn("Cannot evaluate the MOI of a polygon of length %d.", len);
return 0;
}
2023-12-28 17:38:17 -06:00
cpVect points[len];
for (int i = 0; i < len; i++)
points[i] = cpPolyShapeGetVert(poly->shape.shape, i);
float moi = cpMomentForPoly(m, len, points, cpvzero, poly->radius);
if (!isfinite(moi))
2023-05-24 20:45:50 -05:00
return 0;
2023-05-12 13:22:05 -05:00
2023-02-27 08:50:36 -06:00
return moi;
}
2023-05-12 13:22:05 -05:00
void phys2d_polydel(struct phys2d_poly *poly) {
arrfree(poly->points);
phys2d_shape_del(&poly->shape);
2022-08-28 22:34:33 -05:00
}
2023-05-12 13:22:05 -05:00
void phys2d_polyaddvert(struct phys2d_poly *poly) {
2023-11-11 20:01:42 -06:00
arrput(poly->points, v2zero);
2021-11-30 21:29:18 -06:00
}
void phys2d_poly_setverts(struct phys2d_poly *poly, HMM_Vec2 *verts) {
2023-05-12 13:22:05 -05:00
if (!verts) return;
2023-10-05 17:30:17 -05:00
if (poly->points)
arrfree(poly->points);
2023-10-05 17:30:17 -05:00
arrsetlen(poly->points, arrlen(verts));
2023-12-19 15:34:36 -06:00
for (int i = 0; i < arrlen(verts); i++)
poly->points[i] = verts[i];
2023-12-28 17:38:17 -06:00
phys2d_shape_apply(&poly->shape);
2023-01-25 21:32:58 -06:00
}
2022-08-12 14:03:56 -05:00
2023-05-12 13:22:05 -05:00
void phys2d_applypoly(struct phys2d_poly *poly) {
if (arrlen(poly->points) <= 0) return;
2023-12-19 15:34:36 -06:00
assert(sizeof(poly->points[0]) == sizeof(cpVect));
2023-12-11 08:36:45 -06:00
struct gameobject *go = poly->shape.go;
2023-12-27 07:04:18 -06:00
transform2d t = go2t(shape2go(poly->shape.shape));
t.pos.cp = cpvzero;
t.angle = 0;
cpTransform T = m3_to_cpt(transform2d2mat(t));
2023-12-26 15:39:46 -06:00
cpPolyShapeSetVerts(poly->shape.shape, arrlen(poly->points), (cpVect*)poly->points, T);
2023-05-12 13:22:05 -05:00
cpPolyShapeSetRadius(poly->shape.shape, poly->radius);
cpSpaceReindexShapesForBody(space, cpShapeGetBody(poly->shape.shape));
}
2023-12-27 07:04:18 -06:00
2023-05-12 13:22:05 -05:00
void phys2d_dbgdrawpoly(struct phys2d_poly *poly) {
2023-05-16 01:31:13 -05:00
struct rgba color = shape_color(poly->shape.shape);
2023-05-24 20:45:50 -05:00
struct rgba line_color = color;
color.a = col_alpha;
2023-01-12 17:41:54 -06:00
2023-05-12 13:22:05 -05:00
if (arrlen(poly->points) >= 3) {
int n = cpPolyShapeGetCount(poly->shape.shape);
2023-12-19 17:28:45 -06:00
HMM_Vec2 points[n+1];
2023-12-27 07:04:18 -06:00
transform2d t = go2t(shape2go(poly->shape.shape));
t.scale = (HMM_Vec2){1,1};
HMM_Mat3 rt = transform2d2mat(t);
2023-05-12 13:22:05 -05:00
for (int i = 0; i < n; i++)
2023-12-27 07:04:18 -06:00
points[i] = mat_t_pos(rt, (HMM_Vec2)cpPolyShapeGetVert(poly->shape.shape, i));
2023-01-25 21:32:58 -06:00
2023-12-19 17:28:45 -06:00
points[n] = points[0];
2023-05-25 21:55:55 -05:00
draw_poly(points, n, color);
float seglen = cpShapeGetSensor(poly->shape.shape) ? sensor_seg : 0;
2023-12-19 17:28:45 -06:00
draw_line(points, n, line_color, seglen, 0);
2023-05-12 13:22:05 -05:00
}
2023-01-25 21:32:58 -06:00
}
2023-01-12 17:41:54 -06:00
/****************** EDGE 2D**************/
2023-12-11 08:36:45 -06:00
struct phys2d_edge *Make2DEdge(gameobject *go) {
2023-05-12 13:22:05 -05:00
struct phys2d_edge *new = malloc(sizeof(struct phys2d_edge));
new->points = NULL;
arrsetlen(new->points, 0);
new->thickness = 0.f;
new->shapes = NULL;
arrsetlen(new->shapes, 0);
new->shape.go = go;
new->shape.data = new;
new->shape.debugdraw = phys2d_dbgdrawedge;
2024-03-09 18:22:06 -06:00
new->shape.moi = phys2d_edge_moi;
2023-05-12 13:22:05 -05:00
new->shape.shape = NULL;
2024-03-09 18:22:06 -06:00
new->shape.apply = NULL;
new->shape.free = phys2d_edge_free;
2023-05-24 20:45:50 -05:00
new->draws = 0;
2023-05-12 13:22:05 -05:00
phys2d_applyedge(new);
return new;
}
void phys2d_edge_free(struct phys2d_edge *edge)
{
for (int i = 0; i < arrlen(edge->shapes); i++)
cpShapeSetUserData(edge->shapes[i], NULL);
arrfree(edge->points);
arrfree(edge->shapes);
free(edge);
}
2023-12-28 17:38:17 -06:00
float phys2d_edge_moi(struct phys2d_edge *edge) {
float m = edge->shape.go->mass;
2023-02-28 09:40:53 -06:00
float moi = 0;
2023-05-12 13:22:05 -05:00
for (int i = 0; i < arrlen(edge->points) - 1; i++)
2023-11-11 20:01:42 -06:00
moi += cpMomentForSegment(m, edge->points[i].cp, edge->points[i + 1].cp, edge->thickness);
2023-02-28 09:40:53 -06:00
return moi;
}
2023-12-19 15:34:36 -06:00
void phys2d_edgedel(struct phys2d_edge *edge) { phys2d_shape_del(&edge->shape); }
2022-08-28 22:34:33 -05:00
2023-12-12 19:35:34 -06:00
void phys2d_edgeaddvert(struct phys2d_edge *edge, HMM_Vec2 v) {
arrput(edge->points, v);
2023-05-12 13:22:05 -05:00
if (arrlen(edge->points) > 1)
2023-12-11 08:36:45 -06:00
arrput(edge->shapes, cpSpaceAddShape(space, cpSegmentShapeNew(edge->shape.go->body, cpvzero, cpvzero, edge->thickness)));
2022-08-12 14:03:56 -05:00
}
2023-05-12 13:22:05 -05:00
void phys2d_edge_rmvert(struct phys2d_edge *edge, int index) {
2023-12-12 19:35:34 -06:00
if (index>arrlen(edge->points) || index < 0) return;
2023-02-08 15:30:12 -06:00
2023-05-12 13:22:05 -05:00
arrdel(edge->points, index);
2023-02-08 15:30:12 -06:00
2023-05-12 13:22:05 -05:00
if (arrlen(edge->points) == 0) return;
2023-02-08 15:30:12 -06:00
2023-05-12 13:22:05 -05:00
if (index == 0) {
cpSpaceRemoveShape(space, edge->shapes[index]);
cpShapeFree(edge->shapes[index]);
arrdel(edge->shapes, index);
return;
}
2023-02-08 15:30:12 -06:00
2023-12-12 19:35:34 -06:00
if (index != arrlen(edge->points))
2023-11-11 20:01:42 -06:00
cpSegmentShapeSetEndpoints(edge->shapes[index - 1], edge->points[index - 1].cp, edge->points[index].cp);
2023-02-08 15:30:12 -06:00
2023-05-12 13:22:05 -05:00
cpSpaceRemoveShape(space, edge->shapes[index - 1]);
cpShapeFree(edge->shapes[index - 1]);
arrdel(edge->shapes, index - 1);
2021-11-30 21:29:18 -06:00
}
2023-05-12 13:22:05 -05:00
void phys2d_edge_setvert(struct phys2d_edge *edge, int index, cpVect val) {
assert(arrlen(edge->points) > index && index >= 0);
2023-11-11 20:01:42 -06:00
edge->points[index].cp = val;
2023-12-12 19:35:34 -06:00
}
void phys2d_edge_update_verts(struct phys2d_edge *edge, HMM_Vec2 *verts)
{
if (arrlen(edge->points) == arrlen(verts)) {
for (int i = 0; i < arrlen(verts); i++)
phys2d_edge_setvert(edge,i,verts[i].cp);
} else {
int vertchange = arrlen(verts)-arrlen(edge->points);
phys2d_edge_clearverts(edge);
phys2d_edge_addverts(edge,verts);
}
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
phys2d_applyedge(edge);
2021-11-30 21:29:18 -06:00
}
2023-05-12 13:22:05 -05:00
void phys2d_edge_clearverts(struct phys2d_edge *edge) {
2023-12-12 19:35:34 -06:00
for (int i = arrlen(edge->points) - 1; i >= 0; i--)
2023-02-08 15:30:12 -06:00
phys2d_edge_rmvert(edge, i);
}
2023-12-12 19:35:34 -06:00
void phys2d_edge_addverts(struct phys2d_edge *edge, HMM_Vec2 *verts) {
for (int i = 0; i < arrlen(verts); i++)
phys2d_edgeaddvert(edge, verts[i]);
2023-02-08 15:30:12 -06:00
}
2023-12-12 19:35:34 -06:00
/* Calculates all true positions of verts, links them up, and so on */
2023-05-12 13:22:05 -05:00
void phys2d_applyedge(struct phys2d_edge *edge) {
2023-12-11 08:36:45 -06:00
struct gameobject *go = edge->shape.go;
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
for (int i = 0; i < arrlen(edge->shapes); i++) {
2023-12-04 13:38:37 -06:00
/* Points must be scaled with gameobject, */
HMM_Vec2 a = HMM_MulV2(go->scale.xy, edge->points[i]);
HMM_Vec2 b = HMM_MulV2(go->scale.xy, edge->points[i+1]);
2023-11-11 20:01:42 -06:00
cpSegmentShapeSetEndpoints(edge->shapes[i], a.cp, b.cp);
2023-05-12 13:22:05 -05:00
cpSegmentShapeSetRadius(edge->shapes[i], edge->thickness);
if (i > 0 && i < arrlen(edge->shapes) - 1)
2023-12-04 13:38:37 -06:00
cpSegmentShapeSetNeighbors(edge->shapes[i], HMM_MulV2(go->scale.xy,edge->points[i-1]).cp, HMM_MulV2(go->scale.xy,edge->points[i+2]).cp);
2023-05-12 13:22:05 -05:00
go_shape_apply(NULL, edge->shapes[i], go);
cpShapeSetUserData(edge->shapes[i], &edge->shape);
}
2023-12-11 08:36:45 -06:00
cpSpaceReindexShapesForBody(space, edge->shape.go->body);
2021-11-30 21:29:18 -06:00
}
2023-05-12 13:22:05 -05:00
void phys2d_dbgdrawedge(struct phys2d_edge *edge) {
edge->draws++;
if (edge->draws > 1) {
if (edge->draws >= arrlen(edge->shapes))
edge->draws = 0;
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
return;
}
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
if (arrlen(edge->shapes) < 1) return;
2021-11-30 21:29:18 -06:00
2023-11-11 20:01:42 -06:00
HMM_Vec2 drawpoints[arrlen(edge->points)];
2023-12-11 08:36:45 -06:00
struct gameobject *go = edge->shape.go;
2021-11-30 21:29:18 -06:00
2023-11-15 16:42:39 -06:00
HMM_Mat3 g2w = t_go2world(go);
for (int i = 0; i < arrlen(edge->points); i++)
drawpoints[i] = mat_t_pos(g2w, edge->points[i]);
2021-11-30 21:29:18 -06:00
2023-05-25 21:55:55 -05:00
float seglen = cpShapeGetSensor(edge->shapes[0]) ? sensor_seg : 0;
2023-05-24 20:45:50 -05:00
struct rgba color = shape_color(edge->shapes[0]);
struct rgba line_color = color;
color.a = col_alpha;
2023-12-19 17:28:45 -06:00
draw_edge(drawpoints, arrlen(edge->points), color, edge->thickness * 2, 0, line_color, seglen);
2023-05-12 13:22:05 -05:00
draw_points(drawpoints, arrlen(edge->points), 2, kinematic_color);
2021-11-30 21:29:18 -06:00
}
2023-01-25 21:32:58 -06:00
/************ COLLIDER ****************/
2023-05-12 13:22:05 -05:00
void shape_enabled(struct phys2d_shape *shape, int enabled) {
2024-04-11 17:17:49 -05:00
cpShapeFilter set = enabled ? CP_SHAPE_FILTER_ALL : CP_SHAPE_FILTER_NONE;
if (!shape->shape) {
struct phys2d_edge *edge = shape->data;
for (int i = 0; i < arrlen(edge->shapes[i]); i++)
cpShapeSetFilter(edge->shapes[i], set);
} else
cpShapeSetFilter(shape->shape, set);
}
2023-05-12 13:22:05 -05:00
int shape_is_enabled(struct phys2d_shape *shape) {
if (cpshape_enabled(shape->shape))
return 1;
2023-05-12 13:22:05 -05:00
return 0;
}
2023-05-12 13:22:05 -05:00
void shape_set_sensor(struct phys2d_shape *shape, int sensor) {
if (!shape->shape) {
struct phys2d_edge *edge = shape->data;
for (int i = 0; i < arrlen(edge->shapes); i++)
cpShapeSetSensor(edge->shapes[i], sensor);
} else
cpShapeSetSensor(shape->shape, sensor);
2023-01-17 13:04:08 -06:00
}
2023-05-12 13:22:05 -05:00
int shape_get_sensor(struct phys2d_shape *shape) {
if (!shape->shape) {
2023-05-27 07:01:17 -05:00
struct phys2d_edge *edge = shape->data;
if (arrlen(edge->shapes) > 0) return cpShapeGetSensor(edge->shapes[0]);
return 0;
2023-05-12 13:22:05 -05:00
}
2023-05-27 07:01:17 -05:00
2023-05-12 13:22:05 -05:00
return cpShapeGetSensor(shape->shape);
}
2023-12-04 13:38:37 -06:00
void phys2d_reindex_body(cpBody *body) { cpSpaceReindexShapesForBody(space, body); }
2024-01-03 17:19:13 -06:00
JSValue arb2js(cpArbiter *arb)
{
cpBody *body1;
cpBody *body2;
cpArbiterGetBodies(arb, &body1, &body2);
2023-05-12 13:22:05 -05:00
cpShape *shape1;
cpShape *shape2;
cpArbiterGetShapes(arb, &shape1, &shape2);
struct phys2d_shape *pshape = cpShapeGetUserData(shape2);
gameobject *go2 = cpBodyGetUserData(body2);
2023-05-12 13:22:05 -05:00
JSValue obj = JS_NewObject(js);
JS_SetPropertyStr(js, obj, "normal", vec22js((HMM_Vec2)cpArbiterGetNormal(arb)));
2024-01-03 17:19:13 -06:00
JS_SetPropertyStr(js, obj, "obj", JS_DupValue(js,go2->ref));
JS_SetPropertyStr(js, obj, "shape", JS_DupValue(js, pshape->ref));
2024-04-09 16:48:15 -05:00
// JS_SetPropertyStr(js, obj, "point", vec22js((HMM_Vec2)cpArbiterGetPointA(arb, 0)));
2024-01-03 17:19:13 -06:00
2023-11-14 09:20:09 -06:00
HMM_Vec2 srfv;
srfv.cp = cpArbiterGetSurfaceVelocity(arb);
JS_SetPropertyStr(js, obj, "velocity", vec22js(srfv));
2023-05-27 10:13:20 -05:00
2024-01-03 17:19:13 -06:00
return obj;
2023-02-17 01:16:52 -06:00
}
2024-01-03 17:19:13 -06:00
void phys_run_post(cpSpace *space, JSValue *fn, JSValue *hit)
{
2024-04-03 00:44:08 -05:00
script_call_sym(*fn, 1, hit);
JS_FreeValue(js, *hit);
JS_FreeValue(js, *fn);
2024-01-03 17:19:13 -06:00
}
void register_hit(cpArbiter *arb, gameobject *go, const char *name)
2024-01-03 17:19:13 -06:00
{
2024-04-11 17:17:49 -05:00
if (JS_IsUndefined(go->ref)) return;
JSValue cb = JS_GetPropertyStr(js, go->ref, name);
if (!JS_IsUndefined(cb)) {
JSValue jarb = arb2js(arb);
fns[cb_idx] = JS_DupValue(js, cb);
hits[cb_idx] = jarb;
cpSpaceAddPostStepCallback(space, phys_run_post, &fns[cb_idx], &hits[cb_idx]);
cb_idx++;
2024-03-22 09:02:10 -05:00
}
2024-01-03 17:19:13 -06:00
cpShape *s1, *s2;
2024-04-11 17:17:49 -05:00
cpArbiterGetShapes(arb, &s1, &s2);
if (JS_IsUndefined(shape2go(s1)->ref)) return;
if (JS_IsUndefined(shape2go(s2)->ref)) return;
struct phys2d_shape *pshape1 = cpShapeGetUserData(s1);
2024-01-03 17:19:13 -06:00
if (JS_IsUndefined(pshape1->ref)) return;
cb = JS_GetPropertyStr(js, pshape1->ref, name);
if (!JS_IsUndefined(cb)) {
JSValue jarb = arb2js(arb);
fns[cb_idx] = JS_DupValue(js,cb);
hits[cb_idx] = jarb;
cpSpaceAddPostStepCallback(space, phys_run_post, &fns[cb_idx], &hits[cb_idx]);
cb_idx++;
2024-01-03 17:19:13 -06:00
}
}
void script_phys_cb_begin(cpArbiter *arb, cpSpace *space, gameobject *go) { register_hit(arb, go, "collide"); }
void script_phys_cb_separate(cpArbiter *arb, cpSpace *space, gameobject *go) { register_hit(arb, go, "separate"); }
2023-12-11 08:36:45 -06:00
void phys2d_setup_handlers(gameobject *go) {
cpCollisionHandler *handler = cpSpaceAddWildcardHandler(space, (cpCollisionType)go);
2023-12-11 08:36:45 -06:00
handler->userData = go;
2024-04-11 17:17:49 -05:00
handler->beginFunc = script_phys_cb_begin;
2023-03-17 10:25:35 -05:00
handler->separateFunc = script_phys_cb_separate;
2023-03-10 13:13:48 -06:00
}