2021-11-30 21:29:18 -06:00
|
|
|
#include "gameobject.h"
|
|
|
|
|
|
|
|
#include "2dphysics.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
#include <string.h>
|
2022-12-12 01:35:42 -06:00
|
|
|
#include "debugdraw.h"
|
2023-12-11 08:36:45 -06:00
|
|
|
#include "log.h"
|
2023-12-24 09:14:46 -06:00
|
|
|
#include "math.h"
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2022-08-26 09:19:17 -05:00
|
|
|
#include "stb_ds.h"
|
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
gameobject *body2go(cpBody *body) { return cpBodyGetUserData(body); }
|
2024-04-11 17:17:49 -05:00
|
|
|
gameobject *shape2go(cpShape *shape) {
|
|
|
|
struct phys2d_shape *pshape = cpShapeGetUserData(shape);
|
|
|
|
if (!pshape) return NULL;
|
|
|
|
return pshape->go;
|
|
|
|
}
|
2023-11-07 17:24:26 -06:00
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
HMM_Vec2 go_pos(gameobject *go)
|
2023-11-09 16:44:33 -06:00
|
|
|
{
|
|
|
|
cpVect p = cpBodyGetPosition(go->body);
|
|
|
|
return (HMM_Vec2){p.x, p.y};
|
|
|
|
}
|
2023-12-18 17:12:05 -06:00
|
|
|
float go_angle(gameobject *go) { return cpBodyGetAngle(go->body); }
|
2023-11-21 17:05:06 -06:00
|
|
|
|
|
|
|
transform3d go2t3(gameobject *go)
|
|
|
|
{
|
|
|
|
transform3d t;
|
2023-11-30 16:24:26 -06:00
|
|
|
HMM_Vec2 p = go_pos(go);
|
2023-11-30 10:47:59 -06:00
|
|
|
t.pos.X = p.X;
|
2023-11-21 17:05:06 -06:00
|
|
|
t.pos.Y = p.Y;
|
2023-11-30 10:47:59 -06:00
|
|
|
t.pos.Z = go->drawlayer;
|
2023-11-21 17:05:06 -06:00
|
|
|
t.scale = go->scale;
|
|
|
|
t.scale.Z = go->scale.X;
|
2023-11-30 16:24:26 -06:00
|
|
|
t.rotation = HMM_QFromAxisAngle_RH(vFWD, go_angle(go));
|
2023-11-22 03:51:43 -06:00
|
|
|
t.rotation = HMM_MulQ(HMM_QFromAxisAngle_RH(vRIGHT, -t.pos.Y/100), t.rotation);
|
|
|
|
t.rotation = HMM_MulQ(HMM_QFromAxisAngle_RH(vUP, t.pos.X/100), t.rotation);
|
2023-11-21 17:05:06 -06:00
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
HMM_Vec2 go2world(gameobject *go, HMM_Vec2 pos) { return mat_t_pos(t_go2world(go), pos); }
|
|
|
|
HMM_Vec2 world2go(gameobject *go, HMM_Vec2 pos) { return mat_t_pos(t_world2go(go), pos); }
|
|
|
|
HMM_Mat3 t_go2world(gameobject *go) { return transform2d2mat(go2t(go)); }
|
|
|
|
HMM_Mat3 t_world2go(gameobject *go) { return HMM_InvGeneralM3(t_go2world(go)); }
|
|
|
|
HMM_Mat4 t3d_go2world(gameobject *go) { return transform3d2mat(go2t3(go)); }
|
|
|
|
HMM_Mat4 t3d_world2go(gameobject *go) { return HMM_InvGeneralM4(t3d_go2world(go)); }
|
2023-11-15 16:42:39 -06:00
|
|
|
|
2023-11-09 16:44:33 -06:00
|
|
|
transform2d go2t(gameobject *go)
|
|
|
|
{
|
|
|
|
transform2d t;
|
2023-11-15 16:42:39 -06:00
|
|
|
t.pos.cp = cpBodyGetPosition(go->body);
|
2023-11-09 16:44:33 -06:00
|
|
|
t.angle = cpBodyGetAngle(go->body);
|
2023-11-11 20:01:42 -06:00
|
|
|
t.scale = go->scale.XY;
|
2023-12-27 07:04:18 -06:00
|
|
|
if (!isfinite(t.scale.X)) t.scale.X = 1;
|
|
|
|
if (!isfinite(t.scale.Y)) t.scale.Y = 1;
|
2023-11-09 16:44:33 -06:00
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2023-11-20 07:49:14 -06:00
|
|
|
unsigned int editor_cat = 1<<31;
|
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
void go_shape_apply(cpBody *body, cpShape *shape, gameobject *go) {
|
2024-03-20 16:07:23 -05:00
|
|
|
cpShapeSetFriction(shape, go->friction);
|
|
|
|
cpShapeSetElasticity(shape, go->elasticity);
|
2023-12-21 17:21:01 -06:00
|
|
|
cpShapeSetCollisionType(shape, (cpCollisionType)go);
|
2022-08-26 11:38:35 -05:00
|
|
|
|
2023-05-24 20:45:50 -05:00
|
|
|
cpShapeFilter filter;
|
2023-12-21 17:21:01 -06:00
|
|
|
filter.group = (cpCollisionType)go;
|
2023-11-20 07:49:14 -06:00
|
|
|
filter.categories = 1<<go->layer | editor_cat;
|
|
|
|
filter.mask = category_masks[go->layer] | editor_cat;
|
|
|
|
// filter.mask = CP_ALL_CATEGORIES;
|
2023-05-24 20:45:50 -05:00
|
|
|
cpShapeSetFilter(shape, filter);
|
2023-09-26 17:07:51 -05:00
|
|
|
|
|
|
|
struct phys2d_shape *ape = cpShapeGetUserData(shape);
|
2023-09-27 17:40:04 -05:00
|
|
|
if (ape && ape->apply)
|
2023-09-26 17:07:51 -05:00
|
|
|
ape->apply(ape->data);
|
2023-02-28 09:40:53 -06:00
|
|
|
}
|
2022-08-28 22:34:33 -05:00
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
void go_shape_moi(cpBody *body, cpShape *shape, gameobject *go) {
|
2023-12-28 17:38:17 -06:00
|
|
|
float moment = cpBodyGetMoment(body);
|
2023-05-12 13:22:05 -05:00
|
|
|
struct phys2d_shape *s = cpShapeGetUserData(shape);
|
|
|
|
if (!s) {
|
2023-12-28 17:38:17 -06:00
|
|
|
cpBodySetMoment(body, moment + 1);
|
2023-05-12 13:22:05 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-12-28 17:38:17 -06:00
|
|
|
moment += s->moi(s->data);
|
|
|
|
if (moment < 0) moment = 0;
|
|
|
|
cpBodySetMoment(body, moment);
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
void gameobject_apply(gameobject *go) {
|
2024-03-22 13:40:56 -05:00
|
|
|
YughSpam("Applying gameobject %p", go);
|
2024-03-20 09:04:28 -05:00
|
|
|
cpBodySetType(go->body, go->phys);
|
2023-05-12 13:22:05 -05:00
|
|
|
cpBodyEachShape(go->body, go_shape_apply, go);
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2024-03-20 09:04:28 -05:00
|
|
|
if (go->phys == CP_BODY_TYPE_DYNAMIC) {
|
2023-05-12 13:22:05 -05:00
|
|
|
cpBodySetMass(go->body, go->mass);
|
|
|
|
cpBodySetMoment(go->body, 0.f);
|
|
|
|
cpBodyEachShape(go->body, go_shape_moi, go);
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
if (cpBodyGetMoment(go->body) <= 0.f)
|
|
|
|
cpBodySetMoment(go->body, 1.f);
|
|
|
|
}
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
|
|
|
|
2023-11-06 07:05:27 -06:00
|
|
|
static void velocityFn(cpBody *body, cpVect gravity, cpFloat damping, cpFloat dt)
|
|
|
|
{
|
2023-12-11 08:36:45 -06:00
|
|
|
gameobject *go = body2go(body);
|
2024-01-04 08:14:37 -06:00
|
|
|
cpVect pos = cpBodyGetPosition(body);
|
2024-01-14 10:24:31 -06:00
|
|
|
HMM_Vec2 g = warp_force((HMM_Vec3){pos.x, pos.y, 0}, go->warp_filter).xy;
|
2023-11-20 07:49:14 -06:00
|
|
|
if (!go) {
|
2024-01-04 08:14:37 -06:00
|
|
|
cpBodyUpdateVelocity(body,g.cp,damping,dt);
|
2023-11-20 07:49:14 -06:00
|
|
|
return;
|
|
|
|
}
|
2023-11-06 07:05:27 -06:00
|
|
|
|
2024-03-13 16:30:55 -05:00
|
|
|
// cpFloat d = isfinite(go->damping) ? go->damping : damping;
|
|
|
|
cpFloat d = damping;
|
2023-11-20 07:49:14 -06:00
|
|
|
|
2024-01-04 08:14:37 -06:00
|
|
|
cpBodyUpdateVelocity(body,g.cp,d,dt*go->timescale);
|
2023-11-06 07:05:27 -06:00
|
|
|
|
2023-12-26 15:39:46 -06:00
|
|
|
if (isfinite(go->maxvelocity))
|
2023-11-06 07:05:27 -06:00
|
|
|
cpBodySetVelocity(body, cpvclamp(cpBodyGetVelocity(body), go->maxvelocity));
|
2023-11-20 07:49:14 -06:00
|
|
|
|
2023-12-26 15:39:46 -06:00
|
|
|
if (isfinite(go->maxangularvelocity)) {
|
2023-11-06 07:05:27 -06:00
|
|
|
float av = cpBodyGetAngularVelocity(body);
|
|
|
|
if (fabs(av) > go->maxangularvelocity)
|
|
|
|
cpBodySetAngularVelocity(body, copysignf(go->maxangularvelocity, av));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
gameobject *MakeGameobject() {
|
|
|
|
gameobject *ngo = malloc(sizeof(*ngo));
|
|
|
|
gameobject go = {
|
2023-11-11 20:01:42 -06:00
|
|
|
.scale = (HMM_Vec3){1.f,1.f,1.f},
|
2024-03-20 09:04:28 -05:00
|
|
|
.phys = CP_BODY_TYPE_STATIC,
|
2023-11-06 07:05:27 -06:00
|
|
|
.maxvelocity = INFINITY,
|
|
|
|
.maxangularvelocity = INFINITY,
|
2023-05-12 13:22:05 -05:00
|
|
|
.mass = 1.f,
|
|
|
|
.next = -1,
|
2023-11-21 01:07:50 -06:00
|
|
|
.drawlayer = 0,
|
2023-12-24 09:14:46 -06:00
|
|
|
.damping = INFINITY,
|
2023-11-20 07:49:14 -06:00
|
|
|
.timescale = 1.0,
|
2023-11-29 12:40:13 -06:00
|
|
|
.ref = JS_UNDEFINED,
|
2023-05-12 13:22:05 -05:00
|
|
|
};
|
2022-08-15 23:46:06 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
go.body = cpSpaceAddBody(space, cpBodyNew(go.mass, 1.f));
|
2023-11-06 07:05:27 -06:00
|
|
|
cpBodySetVelocityUpdateFunc(go.body, velocityFn);
|
2022-08-15 23:46:06 -05:00
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
*ngo = go;
|
|
|
|
cpBodySetUserData(go.body, ngo);
|
|
|
|
phys2d_setup_handlers(ngo);
|
|
|
|
return ngo;
|
2023-11-30 10:47:59 -06:00
|
|
|
}
|
2022-08-15 23:46:06 -05:00
|
|
|
|
2023-01-13 08:05:36 -06:00
|
|
|
void rm_body_shapes(cpBody *body, cpShape *shape, void *data) {
|
2023-05-12 13:22:05 -05:00
|
|
|
struct phys2d_shape *s = cpShapeGetUserData(shape);
|
2024-04-11 17:17:49 -05:00
|
|
|
|
2023-12-22 11:50:03 -06:00
|
|
|
if (s) {
|
2024-04-11 17:17:49 -05:00
|
|
|
JS_FreeValue(js, s->ref);
|
|
|
|
s->ref = JS_UNDEFINED;
|
2023-12-22 11:50:03 -06:00
|
|
|
if (s->free)
|
|
|
|
s->free(s->data);
|
|
|
|
else
|
|
|
|
free(s->data);
|
|
|
|
}
|
2024-04-11 17:17:49 -05:00
|
|
|
|
|
|
|
cpShapeSetFilter(shape, nofilter);
|
2023-12-22 11:50:03 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
cpSpaceRemoveShape(space, shape);
|
|
|
|
cpShapeFree(shape);
|
2023-01-13 08:05:36 -06:00
|
|
|
}
|
|
|
|
|
2024-01-03 08:38:17 -06:00
|
|
|
void rm_body_constraints(cpBody *body, cpConstraint *constraint, void *data)
|
|
|
|
{
|
2024-01-14 10:24:31 -06:00
|
|
|
constraint_break(cpConstraintGetUserData(constraint));
|
2024-01-03 08:38:17 -06:00
|
|
|
}
|
|
|
|
|
2024-01-03 17:19:13 -06:00
|
|
|
void gameobject_free(gameobject *go) {
|
|
|
|
go->ref = JS_UNDEFINED;
|
2023-05-12 13:22:05 -05:00
|
|
|
cpBodyEachShape(go->body, rm_body_shapes, NULL);
|
2024-01-03 08:38:17 -06:00
|
|
|
cpBodyEachConstraint(go->body, rm_body_constraints, NULL);
|
2023-05-12 13:22:05 -05:00
|
|
|
cpSpaceRemoveBody(space, go->body);
|
|
|
|
cpBodyFree(go->body);
|
2023-12-11 08:36:45 -06:00
|
|
|
free(go);
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
void gameobject_setangle(gameobject *go, float angle) {
|
2023-05-12 13:22:05 -05:00
|
|
|
cpBodySetAngle(go->body, angle);
|
|
|
|
phys2d_reindex_body(go->body);
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
2022-02-04 11:36:24 -06:00
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
void gameobject_setpos(gameobject *go, cpVect vec) {
|
2023-05-12 13:22:05 -05:00
|
|
|
if (!go || !go->body) return;
|
|
|
|
cpBodySetPosition(go->body, vec);
|
|
|
|
phys2d_reindex_body(go->body);
|
2022-02-06 10:14:57 -06:00
|
|
|
}
|
2022-08-12 14:03:56 -05:00
|
|
|
|
2023-01-13 08:05:36 -06:00
|
|
|
void body_draw_shapes_dbg(cpBody *body, cpShape *shape, void *data) {
|
2023-05-12 13:22:05 -05:00
|
|
|
struct phys2d_shape *s = cpShapeGetUserData(shape);
|
|
|
|
s->debugdraw(s->data);
|
2023-01-13 08:05:36 -06:00
|
|
|
}
|
2022-08-12 14:03:56 -05:00
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
void gameobject_draw_debug(gameobject *go) {
|
|
|
|
if (!go || !go->body) return;
|
2022-08-25 15:48:15 -05:00
|
|
|
|
2023-12-11 08:36:45 -06:00
|
|
|
cpBodyEachShape(go->body, body_draw_shapes_dbg, NULL);
|
2022-12-22 16:58:06 -06:00
|
|
|
}
|