1425 lines
52 KiB
C
1425 lines
52 KiB
C
#include "sim.h"
|
|
#include "sim_ent.h"
|
|
#include "sim_client.h"
|
|
#include "sim_msg.h"
|
|
#include "sys.h"
|
|
#include "util.h"
|
|
#include "world.h"
|
|
#include "sprite.h"
|
|
#include "math.h"
|
|
#include "scratch.h"
|
|
#include "atomic.h"
|
|
#include "app.h"
|
|
#include "log.h"
|
|
#include "phys.h"
|
|
#include "collider.h"
|
|
#include "rng.h"
|
|
#include "space.h"
|
|
#include "byteio.h"
|
|
#include "host.h"
|
|
|
|
struct sim_ctx {
|
|
struct arena arena;
|
|
struct atomic_i32 sim_thread_shutdown;
|
|
struct sys_thread sim_thread;
|
|
|
|
u64 last_phys_iteration;
|
|
|
|
struct sprite_scope *sprite_frame_scope;
|
|
|
|
struct host *host;
|
|
|
|
/* TODO: Remove this (testing) */
|
|
b32 extra_spawn;
|
|
b32 should_reset_level;
|
|
|
|
struct sim_ent *root;
|
|
|
|
/* Bookkeeping structures */
|
|
struct sim_ent_lookup contact_lookup;
|
|
#if COLLIDER_DEBUG
|
|
struct sim_ent_lookup collision_debug_lookup;
|
|
#endif
|
|
struct space *space;
|
|
|
|
/* Tick */
|
|
struct world tick;
|
|
};
|
|
|
|
/* ========================== *
|
|
* Ctx
|
|
* ========================== */
|
|
|
|
INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sim_thread_entry_point, arg);
|
|
INTERNAL void test_sim_world_alloc(struct sim_ctx *ctx);
|
|
INTERNAL void test_sim_world_release(struct sim_ctx *ctx);
|
|
|
|
struct sim_ctx *sim_ctx_alloc(struct sprite_startup_receipt *sprite_sr,
|
|
struct phys_startup_receipt *phys_sr,
|
|
struct host_startup_receipt *host_sr,
|
|
u16 host_port)
|
|
{
|
|
struct arena arena = arena_alloc(GIGABYTE(64));
|
|
struct sim_ctx *ctx = arena_push_zero(&arena, struct sim_ctx);
|
|
ctx->arena = arena;
|
|
|
|
(UNUSED)sprite_sr;
|
|
(UNUSED)phys_sr;
|
|
(UNUSED)host_sr;
|
|
|
|
/* Intialize host */
|
|
ctx->host = host_alloc(host_port);
|
|
|
|
/* Initialize empty world */
|
|
test_sim_world_alloc(ctx);
|
|
|
|
ctx->sim_thread = sys_thread_alloc(&sim_thread_entry_point, ctx, LIT("[P2] Sim thread"));
|
|
|
|
return ctx;
|
|
}
|
|
|
|
void sim_ctx_release(struct sim_ctx *ctx)
|
|
{
|
|
__prof;
|
|
atomic_i32_eval_exchange(&ctx->sim_thread_shutdown, true);
|
|
sys_thread_wait_release(&ctx->sim_thread);
|
|
|
|
test_sim_world_release(ctx);
|
|
host_release(ctx->host);
|
|
arena_release(&ctx->arena);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Reset
|
|
* ========================== */
|
|
|
|
/* TODO: Remove this */
|
|
|
|
INTERNAL void test_sim_world_alloc(struct sim_ctx *ctx)
|
|
{
|
|
/* Create bookkeeping */
|
|
ctx->contact_lookup = sim_ent_lookup_alloc(4096);
|
|
#if COLLIDER_DEBUG
|
|
ctx->collision_debug_lookup = sim_ent_lookup_alloc(4096);
|
|
#endif
|
|
ctx->space = space_alloc(SPACE_CELL_SIZE, SPACE_CELL_BUCKETS_SQRT);
|
|
|
|
/* Re-create world */
|
|
world_alloc(&ctx->tick);
|
|
ctx->tick.timescale = SIM_TIMESCALE;
|
|
}
|
|
|
|
INTERNAL void test_sim_world_release(struct sim_ctx *ctx)
|
|
{
|
|
/* Release world */
|
|
world_release(&ctx->tick);
|
|
/* Release bookkeeping */
|
|
space_release(ctx->space);
|
|
#if COLLIDER_DEBUG
|
|
sim_ent_lookup_release(&ctx->collision_debug_lookup);
|
|
#endif
|
|
sim_ent_lookup_release(&ctx->contact_lookup);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Test
|
|
* ========================== */
|
|
|
|
/* TODO: Remove this */
|
|
|
|
INTERNAL void spawn_test_entities(struct sim_ctx *ctx)
|
|
{
|
|
struct sim_ent *root = sim_ent_from_handle(ctx->tick.ent_store, ctx->tick.ent_store->root);
|
|
root->mass_unscaled = F32_INFINITY;
|
|
root->inertia_unscaled = F32_INFINITY;
|
|
|
|
/* Enemy */
|
|
{
|
|
struct sim_ent *e = sim_ent_alloc(root);
|
|
|
|
struct v2 pos = V2(1, -2);
|
|
f32 r = 0;
|
|
struct v2 size = V2(1, 1);
|
|
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
|
|
sim_ent_set_xform(e, xf);
|
|
|
|
e->sprite = sprite_tag_from_path(LIT("res/graphics/tim.ase"));
|
|
e->sprite_collider_slice = LIT("shape");
|
|
e->layer = SIM_LAYER_SHOULDERS;
|
|
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_PHYSICAL_DYNAMIC);
|
|
e->mass_unscaled = 10;
|
|
e->inertia_unscaled = 10;
|
|
e->linear_ground_friction = 250;
|
|
e->angular_ground_friction = 200;
|
|
}
|
|
|
|
|
|
/* Big box */
|
|
#if 0
|
|
{
|
|
struct sim_ent *e = sim_ent_alloc(root);
|
|
|
|
struct v2 pos = V2(1, -0.5);
|
|
f32 r = 0;
|
|
struct v2 size = V2(0.5, 0.25);
|
|
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
|
|
sim_ent_set_xform(e, xf);
|
|
|
|
e->sprite = sprite_tag_from_path(LIT("res/graphics/box.ase"));
|
|
e->sprite_collider_slice = LIT("shape");
|
|
e->layer = SIM_LAYER_SHOULDERS;
|
|
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_PHYSICAL_DYNAMIC);
|
|
e->mass_unscaled = 100;
|
|
e->inertia_unscaled = 10;
|
|
e->linear_ground_friction = 100;
|
|
e->angular_ground_friction = 5;
|
|
}
|
|
#endif
|
|
|
|
/* Tiny box */
|
|
#if 0
|
|
{
|
|
struct sim_ent *e = sim_ent_alloc(root);
|
|
|
|
struct v2 pos = V2(1, -0.5);
|
|
f32 r = PI / 4;
|
|
struct v2 size = V2(0.5, 0.25);
|
|
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
|
|
sim_ent_set_xform(e, xf);
|
|
|
|
e->sprite = sprite_tag_from_path(LIT("res/graphics/bullet.ase"));
|
|
e->sprite_collider_slice = LIT("shape");
|
|
e->layer = SIM_LAYER_SHOULDERS;
|
|
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_PHYSICAL_DYNAMIC);
|
|
e->mass_unscaled = 0.5;
|
|
e->inertia_unscaled = 1000;
|
|
e->linear_ground_friction = 0.001;
|
|
}
|
|
#endif
|
|
|
|
ctx->extra_spawn = true;
|
|
}
|
|
|
|
INTERNAL struct sim_ent *spawn_test_player(struct sim_ctx *ctx)
|
|
{
|
|
struct sim_ent_store *store = ctx->tick.ent_store;
|
|
struct sim_ent *root = sim_ent_from_handle(store, store->root);
|
|
|
|
/* Player */
|
|
struct sim_ent *player_ent = sim_ent_nil();
|
|
//if (!ctx->extra_spawn) {
|
|
{
|
|
|
|
struct sim_ent *e = sim_ent_alloc(root);
|
|
|
|
struct v2 pos = V2(1, -1);
|
|
|
|
//struct v2 size = V2(0.5, 0.5);
|
|
//struct v2 size = V2(0.5, 0.25);
|
|
struct v2 size = V2(1.0, 1.0);
|
|
|
|
//f32 r = PI / 4;
|
|
f32 r = 0;
|
|
|
|
if (!ctx->extra_spawn) {
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_TEST);
|
|
e->sprite = sprite_tag_from_path(LIT("res/graphics/tim.ase"));
|
|
e->mass_unscaled = 10;
|
|
e->inertia_unscaled = 5;
|
|
} else {
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_TEST);
|
|
e->sprite = sprite_tag_from_path(LIT("res/graphics/tim.ase"));
|
|
e->mass_unscaled = 10;
|
|
e->inertia_unscaled = 5;
|
|
#if 0
|
|
e->sprite = sprite_tag_from_path(LIT("res/graphics/box.ase"));
|
|
e->mass_unscaled = 100;
|
|
e->inertia_unscaled = 100;
|
|
#endif
|
|
}
|
|
|
|
e->local_collider.points[0] = v2_with_len(V2(0.08f, 0.17f), 0.15f);
|
|
e->local_collider.points[1] = v2_with_len(V2(-0.07f, -0.2f), 0.15f);
|
|
e->local_collider.count = 2;
|
|
e->local_collider.radius = 0.075f;
|
|
|
|
//e->sprite = sprite_tag_from_path(LIT("res/graphics/box_rounded.ase"));
|
|
//e->sprite_span_name = LIT("idle.unarmed");
|
|
//e->sprite_span_name = LIT("idle.one_handed");
|
|
e->sprite_span_name = LIT("idle.two_handed");
|
|
e->layer = SIM_LAYER_SHOULDERS;
|
|
|
|
struct xform xf = XFORM_TRS(.t = pos, .r = r, .s = size);
|
|
//xf.bx.y = -1.f;
|
|
|
|
sim_ent_set_xform(e, xf);
|
|
|
|
e->linear_ground_friction = 250;
|
|
e->angular_ground_friction = 200;
|
|
|
|
//e->control_force = 500;
|
|
e->control_force = 500;
|
|
//e->control_force_max_speed = 4;
|
|
e->control_torque = 5000;
|
|
e->control_force_max_speed = 4;
|
|
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_PHYSICAL_DYNAMIC);
|
|
|
|
player_ent = e;
|
|
}
|
|
|
|
/* Player weapon */
|
|
if (player_ent->valid) {
|
|
struct sim_ent *e = sim_ent_alloc(player_ent);
|
|
e->sprite = sprite_tag_from_path(LIT("res/graphics/gun.ase"));
|
|
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_ATTACHED);
|
|
e->attach_slice = LIT("attach.wep");
|
|
e->layer = SIM_LAYER_RELATIVE_WEAPON;
|
|
|
|
sim_ent_enable_prop(e, SIM_ENT_PROP_WEAPON);
|
|
//e->trigger_delay = 1.0f / 10.0f;
|
|
e->trigger_delay = 1.0f / 100.0f;
|
|
|
|
player_ent->equipped = e->handle;
|
|
}
|
|
|
|
return player_ent;
|
|
}
|
|
|
|
INTERNAL struct sim_ent *spawn_test_player_camera(struct sim_ctx *ctx, struct sim_ent *player_ent)
|
|
{
|
|
struct sim_ent_store *store = ctx->tick.ent_store;
|
|
struct sim_ent *root = sim_ent_from_handle(store, store->root);
|
|
|
|
struct sim_ent *camera_ent = sim_ent_nil();
|
|
if (player_ent->valid) {
|
|
camera_ent = sim_ent_alloc(root);
|
|
sim_ent_set_xform(camera_ent, XFORM_IDENT);
|
|
|
|
sim_ent_enable_prop(camera_ent, SIM_ENT_PROP_CAMERA);
|
|
sim_ent_enable_prop(camera_ent, SIM_ENT_PROP_CAMERA_ACTIVE);
|
|
camera_ent->camera_follow = player_ent->handle;
|
|
|
|
f32 width = (f32)DEFAULT_CAMERA_WIDTH;
|
|
f32 height = (f32)DEFAULT_CAMERA_HEIGHT;
|
|
camera_ent->camera_quad_xform = XFORM_TRS(.s = V2(width, height));
|
|
}
|
|
|
|
return camera_ent;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Release entities
|
|
* ========================== */
|
|
|
|
INTERNAL void release_entities_with_prop(struct sim_ctx *ctx, enum sim_ent_prop prop)
|
|
{
|
|
struct temp_arena scratch = scratch_begin_no_conflict();
|
|
struct sim_ent_store *store = ctx->tick.ent_store;
|
|
struct space *space = ctx->space;
|
|
|
|
struct sim_ent **ents_to_release = arena_dry_push(scratch.arena, struct sim_ent *);
|
|
u64 ents_to_release_count = 0;
|
|
for (u64 ent_index = 0; ent_index < store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &store->entities[ent_index];
|
|
if (!ent->valid) continue;
|
|
|
|
if (sim_ent_has_prop(ent, prop)) {
|
|
*arena_push(scratch.arena, struct sim_ent *) = ent;
|
|
++ents_to_release_count;
|
|
}
|
|
}
|
|
|
|
/* Release references */
|
|
for (u64 i = 0; i < ents_to_release_count; ++i) {
|
|
struct sim_ent *ent = ents_to_release[i];
|
|
/* Release space entry */
|
|
{
|
|
struct space_entry *space_entry = space_entry_from_handle(space, ent->space_handle);
|
|
if (space_entry->valid) {
|
|
space_entry_release(space_entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Release from store */
|
|
/* TODO: Breadth first iteration to only release parent entities (since
|
|
* child entities will be released along with parent anyway) */
|
|
for (u64 i = 0; i < ents_to_release_count; ++i) {
|
|
struct sim_ent *ent = ents_to_release[i];
|
|
if (ent->valid) {
|
|
sim_ent_release(store, ent);
|
|
}
|
|
}
|
|
|
|
scratch_end(scratch);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Respond to physics collisions
|
|
* ========================== */
|
|
|
|
INTERNAL PHYS_COLLISION_CALLBACK_FUNC_DEF(on_collision, collision_data_array, udata)
|
|
{
|
|
struct sim_ctx *ctx = (struct sim_ctx *)udata;
|
|
struct sim_ent_store *store = ctx->tick.ent_store;
|
|
struct sim_ent *root = sim_ent_from_handle(store, store->root);
|
|
|
|
for (u64 i = 0; i < collision_data_array.count; ++i) {
|
|
struct phys_collision_data *data = &collision_data_array.a[i];
|
|
|
|
struct phys_contact_constraint *constraint = data->constraint;
|
|
struct sim_ent *e0 = sim_ent_from_handle(store, data->e0);
|
|
struct sim_ent *e1 = sim_ent_from_handle(store, data->e1);
|
|
|
|
if (sim_ent_is_valid_and_active(e0) && sim_ent_is_valid_and_active(e1)) {
|
|
/* Bullet hit entity */
|
|
if (sim_ent_has_prop(e0, SIM_ENT_PROP_BULLET) || sim_ent_has_prop(e1, SIM_ENT_PROP_BULLET)) {
|
|
struct v2 normal = data->normal; /* Impact normal */
|
|
struct v2 vrel = v2_neg(data->vrel); /* Impact velocity */
|
|
|
|
struct sim_ent *target = e0;
|
|
struct sim_ent *bullet = e1;
|
|
if (sim_ent_has_prop(e0, SIM_ENT_PROP_BULLET)) {
|
|
target = e1;
|
|
bullet = e0;
|
|
normal = v2_neg(normal);
|
|
vrel = v2_neg(vrel);
|
|
}
|
|
struct sim_ent *src = sim_ent_from_handle(store, bullet->bullet_src);
|
|
|
|
if (bullet->bullet_has_hit || sim_ent_handle_eq(src->top, target->top)) {
|
|
/* Ignore collision if bullet already spent or if weapon and
|
|
* target share same top level parent */
|
|
/* NOTE: Since bullet is most likely just a sensor skip_solve is probably already true */
|
|
constraint->skip_solve = true;
|
|
} else {
|
|
struct v2 point = data->point;
|
|
|
|
/* Update bullet */
|
|
bullet->bullet_has_hit = true;
|
|
sim_ent_enable_prop(bullet, SIM_ENT_PROP_RELEASE_THIS_TICK);
|
|
|
|
/* Update tracer */
|
|
struct sim_ent *tracer = sim_ent_from_handle(store, bullet->bullet_tracer);
|
|
if (sim_ent_is_valid_and_active(tracer)) {
|
|
struct xform xf = sim_ent_get_xform(tracer);
|
|
xf.og = point;
|
|
sim_ent_set_xform(tracer, xf);
|
|
sim_ent_set_linear_velocity(tracer, V2(0, 0));
|
|
}
|
|
|
|
/* Update target */
|
|
struct v2 knockback = v2_mul(v2_norm(vrel), bullet->bullet_knockback);
|
|
sim_ent_apply_linear_impulse(target, knockback, point);
|
|
|
|
/* Create test blood */
|
|
/* TODO: Remove this */
|
|
{
|
|
struct xform xf = XFORM_TRS(.t = point, .r = rng_rand_f32(0, TAU));
|
|
struct sim_ent *decal = sim_ent_alloc(root);
|
|
decal->sprite = sprite_tag_from_path(LIT("res/graphics/blood.ase"));
|
|
decal->sprite_tint = RGBA_32_F(1, 1, 1, 0.25f);
|
|
decal->layer = SIM_LAYER_FLOOR_DECALS;
|
|
sim_ent_set_xform(decal, xf);
|
|
|
|
f32 perp_range = 0.5;
|
|
struct v2 linear_velocity = v2_mul(normal, 0.5);
|
|
linear_velocity = v2_add(linear_velocity, v2_mul(v2_perp(normal), rng_rand_f32(-perp_range, perp_range)));
|
|
|
|
f32 angular_velocity_range = 5;
|
|
f32 angular_velocity = rng_rand_f32(-angular_velocity_range, angular_velocity_range);
|
|
|
|
sim_ent_enable_prop(decal, SIM_ENT_PROP_PHYSICAL_KINEMATIC);
|
|
sim_ent_set_linear_velocity(decal, linear_velocity);
|
|
sim_ent_set_angular_velocity(decal, angular_velocity);
|
|
|
|
decal->linear_damping = 5.0f;
|
|
decal->angular_damping = 5.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Update
|
|
* ========================== */
|
|
|
|
INTERNAL void sim_update(struct sim_ctx *ctx, f64 dt)
|
|
{
|
|
__prof;
|
|
|
|
struct temp_arena scratch = scratch_begin_no_conflict();
|
|
|
|
/* ========================== *
|
|
* Reset level if necessary
|
|
* ========================== */
|
|
|
|
if (ctx->should_reset_level) {
|
|
logf_info("Clearing level");
|
|
ctx->should_reset_level = false;
|
|
ctx->extra_spawn = false;
|
|
test_sim_world_release(ctx);
|
|
test_sim_world_alloc(ctx);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Begin frame
|
|
* ========================== */
|
|
|
|
++ctx->tick.tick_id;
|
|
|
|
ctx->tick.dt_ns = NS_FROM_SECONDS(max_f64(0.0, dt * ctx->tick.timescale));
|
|
ctx->tick.time_ns += ctx->tick.dt_ns;
|
|
|
|
f64 time = SECONDS_FROM_NS(ctx->tick.time_ns);
|
|
ctx->sprite_frame_scope = sprite_scope_begin();
|
|
ctx->root = sim_ent_from_handle(ctx->tick.ent_store, ctx->tick.ent_store->root);
|
|
|
|
struct sim_ent *root = ctx->root;
|
|
struct sim_ent_store *ent_store = ctx->tick.ent_store;
|
|
struct space *space = ctx->space;
|
|
struct sprite_scope *sprite_frame_scope = ctx->sprite_frame_scope;
|
|
|
|
(UNUSED)dt;
|
|
(UNUSED)time;
|
|
|
|
/* ========================== *
|
|
* Spawn test entities
|
|
* ========================== */
|
|
|
|
/* TODO: remove this (testing) */
|
|
/* Initialize entities */
|
|
{
|
|
static b32 run = 0;
|
|
if (!run) {
|
|
run = 1;
|
|
spawn_test_entities(ctx);
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Release entities
|
|
* ========================== */
|
|
|
|
release_entities_with_prop(ctx, SIM_ENT_PROP_RELEASE_NEXT_TICK);
|
|
|
|
/* ========================== *
|
|
* Activate entities
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!ent->valid) continue;
|
|
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_ACTIVE)) {
|
|
u64 atick = ent->activation_tick;
|
|
if (atick != 0 || ctx->tick.tick_id >= atick) {
|
|
sim_ent_activate(ent, ctx->tick.tick_id);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Reset triggered entities
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_TRIGGER_NEXT_TICK)) {
|
|
sim_ent_disable_prop(ent, SIM_ENT_PROP_TRIGGER_NEXT_TICK);
|
|
sim_ent_enable_prop(ent, SIM_ENT_PROP_TRIGGERED_THIS_TICK);
|
|
} else if (sim_ent_has_prop(ent, SIM_ENT_PROP_TRIGGERED_THIS_TICK)) {
|
|
sim_ent_disable_prop(ent, SIM_ENT_PROP_TRIGGERED_THIS_TICK);
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Process host events into sim cmds
|
|
* ========================== */
|
|
|
|
|
|
struct sim_cmd_list sim_cmds = ZI;
|
|
{
|
|
struct host_event_array host_events = host_pop_events(scratch.arena, ctx->host);
|
|
sim_cmds_from_host_events(scratch.arena, host_events, &sim_cmds);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Process sim cmds
|
|
* ========================== */
|
|
|
|
for (struct sim_cmd *cmd = sim_cmds.first; cmd; cmd = cmd->next) {
|
|
enum sim_cmd_kind kind = cmd->kind;
|
|
struct host_channel_id channel_id = cmd->channel_id;
|
|
|
|
struct sim_client *client = sim_client_from_channel_id(ctx->tick.client_store, channel_id);
|
|
if (client->valid) {
|
|
struct sim_ent *player_ent = sim_ent_from_handle(ctx->tick.ent_store, client->control_ent);
|
|
b32 start = cmd->state == SIM_CMD_STATE_START;
|
|
b32 stop = cmd->state == SIM_CMD_STATE_STOP;
|
|
switch (kind) {
|
|
/* TODO: Combine movement from multiple inputs? E.ctx-> a sudden
|
|
* start and immediate stop cmd should still move the player a
|
|
* tad. */
|
|
case SIM_CMD_KIND_PLAYER_MOVE:
|
|
{
|
|
if (player_ent->valid) {
|
|
struct v2 move = cmd->move_dir;
|
|
struct v2 focus = cmd->aim_dir;
|
|
if (v2_len_sq(move) > 1) {
|
|
/* Cap movement vector magnitude at 1 */
|
|
move = v2_norm(move);
|
|
}
|
|
player_ent->control.move = move;
|
|
player_ent->control.focus = focus;
|
|
}
|
|
} break;
|
|
|
|
case SIM_CMD_KIND_PLAYER_FIRE:
|
|
{
|
|
if (player_ent->valid) {
|
|
b32 firing = sim_ent_has_prop(player_ent, SIM_ENT_PROP_TRIGGERING_EQUIPPED);
|
|
if (start) {
|
|
firing = true;
|
|
} else if (stop) {
|
|
firing = false;
|
|
}
|
|
if (firing) {
|
|
sim_ent_enable_prop(player_ent, SIM_ENT_PROP_TRIGGERING_EQUIPPED);
|
|
} else {
|
|
sim_ent_disable_prop(player_ent, SIM_ENT_PROP_TRIGGERING_EQUIPPED);
|
|
}
|
|
}
|
|
} break;
|
|
|
|
/* Cursor */
|
|
case SIM_CMD_KIND_CURSOR_MOVE:
|
|
{
|
|
client->cursor_pos = cmd->cursor_pos;
|
|
} break;
|
|
|
|
/* Clear level */
|
|
case SIM_CMD_KIND_CLEAR_ALL:
|
|
{
|
|
ctx->should_reset_level = true;
|
|
} break;
|
|
|
|
/* Spawn test */
|
|
case SIM_CMD_KIND_SPAWN_TEST:
|
|
{
|
|
logf_info("Spawning (test)");
|
|
spawn_test_entities(ctx);
|
|
} break;
|
|
|
|
/* Disconnect client */
|
|
case SIM_CMD_KIND_SIM_CLIENT_DISCONNECT:
|
|
{
|
|
if (player_ent->valid) {
|
|
sim_ent_enable_prop(player_ent, SIM_ENT_PROP_RELEASE_NEXT_TICK);
|
|
host_queue_disconnect(ctx->host, channel_id);
|
|
}
|
|
sim_client_release(client);
|
|
} break;
|
|
|
|
default: break;
|
|
};
|
|
} else if (kind == SIM_CMD_KIND_SIM_CLIENT_CONNECT && !host_channel_id_is_nil(channel_id) && !client->valid) {
|
|
/* Connect client */
|
|
client = sim_client_alloc(ctx->tick.client_store, channel_id);
|
|
struct sim_ent *player_ent = spawn_test_player(ctx);
|
|
sim_ent_enable_prop(player_ent, SIM_ENT_PROP_CONTROLLED);
|
|
struct sim_ent *camera_ent = spawn_test_player_camera(ctx, player_ent);
|
|
client->control_ent = player_ent->handle;
|
|
client->camera_ent = camera_ent->handle;;
|
|
player_ent->controlling_client = client->handle;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
/* ========================== *
|
|
* Update entity movement from control
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_CONTROLLED)) {
|
|
/* Process cmds */
|
|
struct v2 move = ent->control.move;
|
|
struct v2 focus = ent->control.focus;
|
|
b32 firing = sim_ent_has_prop(ent, SIM_ENT_PROP_TRIGGERING_EQUIPPED);
|
|
|
|
for (struct sim_cmd *cmd = sim_cmds.first; cmd; cmd = cmd->next) {
|
|
/* TODO: Combine movement from multiple inputs? E.ctx-> a sudden
|
|
* start and immediate stop cmd should still move the player a
|
|
* tad. */
|
|
switch (cmd->kind) {
|
|
case SIM_CMD_KIND_PLAYER_MOVE:
|
|
{
|
|
move = cmd->move_dir;
|
|
focus = cmd->aim_dir;
|
|
} break;
|
|
|
|
case SIM_CMD_KIND_PLAYER_FIRE:
|
|
{
|
|
if (start) {
|
|
firing = true;
|
|
} else if (stop) {
|
|
firing = false;
|
|
}
|
|
} break;
|
|
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
/* Movement */
|
|
if (v2_len_sq(move) > 1) {
|
|
/* Cap movement vector magnitude at 1 */
|
|
move = v2_norm(move);
|
|
}
|
|
ent->control.move = move;
|
|
ent->control.focus = focus;
|
|
|
|
/* Firing */
|
|
if (firing) {
|
|
sim_ent_enable_prop(ent, SIM_ENT_PROP_TRIGGERING_EQUIPPED);
|
|
} else {
|
|
sim_ent_disable_prop(ent, SIM_ENT_PROP_TRIGGERING_EQUIPPED);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Update entities from sprite
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (sprite_tag_is_nil(ent->sprite)) continue;
|
|
|
|
/* Update animation */
|
|
|
|
struct sprite_sheet *sheet = sprite_sheet_from_tag_await(sprite_frame_scope, ent->sprite);
|
|
{
|
|
struct sprite_sheet_span span = sprite_sheet_get_span(sheet, ent->sprite_span_name);
|
|
|
|
f64 time_in_frame = ent->animation_time_in_frame + dt;
|
|
u64 frame_index = ent->animation_frame;
|
|
if (frame_index < span.start || frame_index > span.end) {
|
|
frame_index = span.start;
|
|
}
|
|
|
|
struct sprite_sheet_frame frame = sprite_sheet_get_frame(sheet, frame_index);
|
|
while (time_in_frame > frame.duration) {
|
|
time_in_frame -= frame.duration;
|
|
++frame_index;
|
|
if (frame_index > span.end) {
|
|
/* Loop animation */
|
|
frame_index = span.start;
|
|
}
|
|
frame = sprite_sheet_get_frame(sheet, frame_index);
|
|
}
|
|
|
|
ent->animation_time_in_frame = time_in_frame;
|
|
ent->animation_frame = frame_index;
|
|
}
|
|
|
|
/* Update sprite local xform */
|
|
{
|
|
struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, LIT("pivot"), ent->animation_frame);
|
|
struct v2 sprite_size = v2_div(sheet->frame_size, (f32)IMAGE_PIXELS_PER_UNIT);
|
|
|
|
struct v2 dir = v2_mul_v2(sprite_size, slice.dir);
|
|
f32 rot = v2_angle(dir) + PI / 2;
|
|
|
|
struct xform xf = XFORM_IDENT;
|
|
xf = xform_rotated(xf, -rot);
|
|
xf = xform_scaled(xf, sprite_size);
|
|
xf = xform_translated(xf, v2_neg(slice.center));
|
|
ent->sprite_local_xform = xf;
|
|
}
|
|
|
|
/* Update collider from sprite */
|
|
if (ent->sprite_collider_slice.len > 0) {
|
|
struct xform cxf = ent->sprite_local_xform;
|
|
|
|
struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, ent->sprite_collider_slice, ent->animation_frame);
|
|
ent->local_collider = collider_from_quad(xform_mul_quad(cxf, quad_from_rect(slice.rect)));
|
|
}
|
|
|
|
/* Test collider */
|
|
#if 0
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_TEST)) {
|
|
//if ((true)) {
|
|
#if 0
|
|
ent->local_collider.points[0] = V2(0, 0);
|
|
ent->local_collider.count = 1;
|
|
ent->local_collider.radius = 0.5;
|
|
#elif 0
|
|
ent->local_collider.points[0] = v2_with_len(V2(0.08f, 0.17f), 0.15f);
|
|
ent->local_collider.points[1] = v2_with_len(V2(-0.07f, -0.2f), 0.15f);
|
|
ent->local_collider.count = 2;
|
|
ent->local_collider.radius = 0.075f;
|
|
#elif 1
|
|
#if 0
|
|
/* "Bad" winding order */
|
|
ent->local_collider.points[0] = V2(-0.15, 0.15);
|
|
ent->local_collider.points[1] = V2(0.15, 0.15);
|
|
ent->local_collider.points[2] = V2(0, -0.15);
|
|
#else
|
|
ent->local_collider.points[0] = V2(0, -0.15);
|
|
ent->local_collider.points[1] = V2(0.15, 0.15);
|
|
ent->local_collider.points[2] = V2(-0.15, 0.15);
|
|
#endif
|
|
ent->local_collider.count = 3;
|
|
ent->local_collider.radius = 0.25;
|
|
//ent->local_collider.radius = math_fabs(math_sin(ctx->tick.time) / 3);
|
|
#else
|
|
//ent->local_collider.radius = 0.5;
|
|
ent->local_collider.radius = 0.25;
|
|
//ent->local_collider.radius = 0.;
|
|
#endif
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* ========================== *
|
|
* Update attachments
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_ATTACHED)) continue;
|
|
|
|
struct sim_ent *parent = sim_ent_from_handle(ent_store, ent->parent);
|
|
struct sprite_tag parent_sprite = parent->sprite;
|
|
struct sprite_sheet *parent_sheet = sprite_sheet_from_tag_await(sprite_frame_scope, parent_sprite);
|
|
|
|
struct xform parent_sprite_xf = parent->sprite_local_xform;
|
|
|
|
struct sprite_sheet_slice attach_slice = sprite_sheet_get_slice(parent_sheet, ent->attach_slice, parent->animation_frame);
|
|
struct v2 attach_pos = xform_mul_v2(parent_sprite_xf, attach_slice.center);
|
|
struct v2 attach_dir = xform_basis_mul_v2(parent_sprite_xf, attach_slice.dir);
|
|
|
|
struct xform xf = sim_ent_get_local_xform(ent);
|
|
xf.og = attach_pos;
|
|
xf = xform_basis_with_rotation_world(xf, v2_angle(attach_dir) + PI / 2);
|
|
sim_ent_set_local_xform(ent, xf);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Test
|
|
* ========================== */
|
|
|
|
#if 0
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_TEST)) continue;
|
|
|
|
#if 0
|
|
if (!ent->test_initialized) {
|
|
ent->test_initialized = true;
|
|
ent->test_start_local_xform = sim_ent_get_local_xform(ent);
|
|
ent->test_start_sprite_xform = ent->sprite_local_xform;
|
|
}
|
|
|
|
f32 t = (f32)time;
|
|
struct v2 og = v2_mul(V2(math_cos(t), math_sin(t)), 3);
|
|
f32 r = t * 3;
|
|
struct v2 s = V2(1 + (math_fabs(math_sin(t * 5)) * 3), 1);
|
|
(UNUSED)og;
|
|
(UNUSED)r;
|
|
(UNUSED)s;
|
|
|
|
og = v2_add(og, ent->test_start_local_xform.og);
|
|
r += xform_get_rotation(ent->test_start_local_xform);
|
|
s = v2_add(s, xform_get_scale(ent->test_start_local_xform));
|
|
|
|
struct xform xf = sim_ent_get_local_xform(ent);
|
|
xf.og = og;
|
|
xf = xform_rotated_to(xf, r);
|
|
xf = xform_scaled_to(xf, s);
|
|
sim_ent_set_local_xform(ent, xf);
|
|
#else
|
|
f32 t = (f32)time;
|
|
struct v2 og = v2_mul(V2(math_cos(t), math_sin(t)), 3);
|
|
f32 rot = t * PI / 3;
|
|
struct v2 scale = V2(1 + (math_fabs(math_sin(t * 5)) * 3), 1);
|
|
(UNUSED)og;
|
|
(UNUSED)rot;
|
|
(UNUSED)scale;
|
|
|
|
struct xform xf = sim_ent_get_local_xform(ent);
|
|
xf = xform_rotated_to(xf, rot);
|
|
xf = xform_scaled_to(xf, scale);
|
|
sim_ent_set_local_xform(ent, xf);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Trigger equipped
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_TRIGGERING_EQUIPPED)) {
|
|
struct sim_ent *eq = sim_ent_from_handle(ent_store, ent->equipped);
|
|
if (sim_ent_is_valid_and_active(eq)) {
|
|
sim_ent_enable_prop(eq, SIM_ENT_PROP_TRIGGERED_THIS_TICK);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Process triggered entities
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_TRIGGERED_THIS_TICK)) continue;
|
|
if ((time - ent->last_triggered < ent->trigger_delay) && ent->last_triggered != 0) continue;
|
|
|
|
ent->last_triggered = time;
|
|
|
|
/* Fire weapon */
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_WEAPON)) {
|
|
struct sprite_tag sprite = ent->sprite;
|
|
u32 animation_frame = ent->animation_frame;
|
|
struct sprite_sheet *sheet = sprite_sheet_from_tag_await(sprite_frame_scope, sprite);
|
|
|
|
struct xform sprite_local_xform = ent->sprite_local_xform;
|
|
|
|
struct sprite_sheet_slice out_slice = sprite_sheet_get_slice(sheet, LIT("out"), animation_frame);
|
|
struct v2 rel_pos = xform_mul_v2(sprite_local_xform, out_slice.center);
|
|
struct v2 rel_dir = xform_basis_mul_v2(sprite_local_xform, out_slice.dir);
|
|
|
|
/* Spawn bullet */
|
|
struct sim_ent *bullet;
|
|
{
|
|
bullet = sim_ent_alloc(root);
|
|
|
|
bullet->bullet_src = ent->handle;
|
|
bullet->bullet_src_pos = rel_pos;
|
|
bullet->bullet_src_dir = rel_dir;
|
|
bullet->bullet_impulse = 0.75f;
|
|
bullet->bullet_knockback = 10;
|
|
bullet->mass_unscaled = 0.04f;
|
|
bullet->inertia_unscaled = 0.00001f;
|
|
bullet->layer = SIM_LAYER_BULLETS;
|
|
|
|
#if 1
|
|
/* Point collider */
|
|
bullet->local_collider.points[0] = V2(0, 0);
|
|
bullet->local_collider.count = 1;
|
|
#else
|
|
bullet->sprite = sprite_tag_from_path(LIT("res/graphics/bullet.ase"));
|
|
bullet->sprite_collider_slice = LIT("shape");
|
|
#endif
|
|
|
|
sim_ent_enable_prop(bullet, SIM_ENT_PROP_BULLET);
|
|
sim_ent_enable_prop(bullet, SIM_ENT_PROP_SENSOR);
|
|
}
|
|
|
|
/* Spawn tracer */
|
|
{
|
|
struct sim_ent *tracer = sim_ent_alloc(root);
|
|
tracer->tracer_fade_duration = 0.025f;
|
|
tracer->layer = SIM_LAYER_TRACERS;
|
|
sim_ent_enable_prop(tracer, SIM_ENT_PROP_TRACER);
|
|
|
|
bullet->bullet_tracer = tracer->handle;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Create forces from control move
|
|
* ========================== */
|
|
|
|
#if 0
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_PLAYER_CONTROLLED)) {
|
|
struct v2 move = ent->control.move;
|
|
struct v2 force = v2_mul(move, ent->control_force);
|
|
sim_ent_apply_force_to_center(ent, force);
|
|
}
|
|
}
|
|
#else
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_CONTROLLED)) {
|
|
struct sim_ent *joint_ent = sim_ent_from_handle(ent_store, ent->move_joint);
|
|
if (!sim_ent_is_valid_and_active(joint_ent)) {
|
|
joint_ent = sim_ent_alloc(root);
|
|
joint_ent->mass_unscaled = F32_INFINITY;
|
|
joint_ent->inertia_unscaled = F32_INFINITY;
|
|
sim_ent_enable_prop(joint_ent, SIM_ENT_PROP_MOTOR_JOINT);
|
|
sim_ent_enable_prop(joint_ent, SIM_ENT_PROP_ACTIVE);
|
|
ent->move_joint = joint_ent->handle;
|
|
|
|
struct phys_motor_joint_def def = ZI;
|
|
def.e0 = joint_ent->handle; /* Re-using joint entity as e0 */
|
|
def.e1 = ent->handle;
|
|
def.correction_rate = 0;
|
|
def.max_force = ent->control_force;
|
|
def.max_torque = 0;
|
|
joint_ent->motor_joint_data = motor_joint_from_def(def);
|
|
}
|
|
|
|
sim_ent_set_xform(joint_ent, XFORM_IDENT); /* Reset joint ent position */
|
|
sim_ent_set_linear_velocity(joint_ent, v2_mul(v2_clamp_len(ent->control.move, 1), ent->control_force_max_speed));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Create forces from control focus (aim)
|
|
* ========================== */
|
|
|
|
#if SIM_PLAYER_AIM
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_CONTROLLED)) {
|
|
struct xform xf = sim_ent_get_xform(ent);
|
|
struct xform sprite_xf = xform_mul(xf, ent->sprite_local_xform);
|
|
|
|
/* Retrieve / create aim joint */
|
|
struct sim_ent *joint_ent = sim_ent_from_handle(ent_store, ent->aim_joint);
|
|
if (!sim_ent_is_valid_and_active(joint_ent)) {
|
|
joint_ent = sim_ent_alloc(root);
|
|
joint_ent->mass_unscaled = F32_INFINITY;
|
|
joint_ent->inertia_unscaled = F32_INFINITY;
|
|
sim_ent_enable_prop(joint_ent, SIM_ENT_PROP_PHYSICAL_KINEMATIC); /* Since we'll be setting velocity */
|
|
sim_ent_enable_prop(joint_ent, SIM_ENT_PROP_MOTOR_JOINT);
|
|
sim_ent_enable_prop(joint_ent, SIM_ENT_PROP_ACTIVE);
|
|
ent->aim_joint = joint_ent->handle;
|
|
|
|
struct phys_motor_joint_def def = ZI;
|
|
def.e0 = joint_ent->handle; /* Re-using joint entity as e0 */
|
|
def.e1 = ent->handle;
|
|
def.max_force = 0;
|
|
def.max_torque = ent->control_torque;
|
|
joint_ent->motor_joint_data = motor_joint_from_def(def);
|
|
}
|
|
|
|
/* Set correction rate dynamically since motor velocity is only set for one frame */
|
|
joint_ent->motor_joint_data.correction_rate = 10 * dt;
|
|
|
|
|
|
/* Solve for final angle using law of sines */
|
|
f32 new_angle;
|
|
{
|
|
struct v2 ent_pos = xf.og;
|
|
struct v2 focus_pos = v2_add(ent_pos, ent->control.focus);
|
|
|
|
struct v2 sprite_hold_pos;
|
|
struct v2 sprite_hold_dir;
|
|
{
|
|
struct sprite_sheet *sheet = sprite_sheet_from_tag_await(sprite_frame_scope, ent->sprite);
|
|
struct sprite_sheet_slice slice = sprite_sheet_get_slice(sheet, LIT("attach.wep"), ent->animation_frame);
|
|
sprite_hold_pos = slice.center;
|
|
sprite_hold_dir = slice.dir;
|
|
}
|
|
|
|
struct v2 hold_dir = xform_basis_mul_v2(sprite_xf, sprite_hold_dir);
|
|
struct v2 hold_pos = xform_mul_v2(sprite_xf, sprite_hold_pos);
|
|
if (v2_eq(hold_pos, ent_pos)) {
|
|
/* If hold pos is same as origin (E.G if pivot is being used as hold pos), then move hold pos forward a tad to avoid issue */
|
|
sprite_hold_pos = v2_add(sprite_hold_pos, V2(0, -1));
|
|
hold_pos = xform_mul_v2(sprite_xf, sprite_hold_pos);
|
|
}
|
|
|
|
f32 forward_hold_angle_offset;
|
|
{
|
|
struct xform xf_unrotated = xform_basis_with_rotation_world(xf, 0);
|
|
struct v2 hold_pos_unrotated = xform_mul_v2(xf_unrotated, xform_mul_v2(ent->sprite_local_xform, sprite_hold_pos));
|
|
forward_hold_angle_offset = v2_angle_from_dirs(V2(0, -1), v2_sub(hold_pos_unrotated, xf_unrotated.og));
|
|
}
|
|
|
|
struct v2 hold_ent_dir = v2_sub(ent_pos, hold_pos);
|
|
struct v2 focus_ent_dir = v2_sub(ent_pos, focus_pos);
|
|
|
|
f32 hold_ent_len = v2_len(hold_ent_dir);
|
|
f32 focus_ent_len = v2_len(focus_ent_dir);
|
|
|
|
f32 final_hold_angle_btw_ent_and_focus = v2_angle_from_dirs(hold_ent_dir, hold_dir);
|
|
f32 final_focus_angle_btw_ent_and_hold = math_asin((math_sin(final_hold_angle_btw_ent_and_focus) * hold_ent_len) / focus_ent_len);
|
|
f32 final_ent_angle_btw_focus_and_hold = PI - (final_focus_angle_btw_ent_and_hold + final_hold_angle_btw_ent_and_focus);
|
|
|
|
new_angle = math_unwind_angle(v2_angle_from_dirs(V2(0, -1), v2_sub(focus_pos, ent_pos)) + final_ent_angle_btw_focus_and_hold - forward_hold_angle_offset);
|
|
}
|
|
|
|
f32 new_vel = 0;
|
|
if (!F32_IS_NAN(new_angle)) {
|
|
const f32 angle_error_allowed = 0.001f;
|
|
struct xform joint_xf = sim_ent_get_xform(joint_ent);
|
|
f32 diff = math_unwind_angle(new_angle - xform_get_rotation(joint_xf));
|
|
if (math_fabs(diff) > angle_error_allowed) {
|
|
/* Instantly snap joint ent to new angle */
|
|
new_vel = diff / dt;
|
|
}
|
|
}
|
|
sim_ent_set_angular_velocity(joint_ent, new_vel);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Create ground friction force (gravity)
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_PHYSICAL_DYNAMIC)) continue;
|
|
|
|
struct sim_ent *joint_ent = sim_ent_from_handle(ent_store, ent->ground_friction_joint);
|
|
|
|
struct phys_motor_joint_def def = ZI;
|
|
def.e0 = root->handle;
|
|
def.e1 = ent->handle;
|
|
def.correction_rate = 0;
|
|
def.max_force = ent->linear_ground_friction;
|
|
def.max_torque = ent->angular_ground_friction;
|
|
if (joint_ent->motor_joint_data.max_force != def.max_force || joint_ent->motor_joint_data.max_torque != def.max_torque) {
|
|
if (!sim_ent_is_valid_and_active(joint_ent)) {
|
|
joint_ent = sim_ent_alloc(root);
|
|
sim_ent_enable_prop(joint_ent, SIM_ENT_PROP_MOTOR_JOINT);
|
|
sim_ent_enable_prop(joint_ent, SIM_ENT_PROP_ACTIVE);
|
|
joint_ent->motor_joint_data = motor_joint_from_def(def);
|
|
ent->ground_friction_joint = joint_ent->handle;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Physics
|
|
* ========================== */
|
|
|
|
{
|
|
struct phys_ctx phys = ZI;
|
|
phys.tick_id = ctx->tick.tick_id;
|
|
phys.store = ent_store;
|
|
phys.space = space;
|
|
phys.contact_lookup = &ctx->contact_lookup;
|
|
phys.pre_solve_callback = on_collision;
|
|
phys.pre_solve_callback_udata = ctx;
|
|
#if COLLIDER_DEBUG
|
|
phys.debug_lookup = &phys->collision_debug_lookup;
|
|
#endif
|
|
|
|
#if 0
|
|
/* Mouse drag */
|
|
phys.dbg_cursor_pos = ctx->user_cursor;
|
|
for (struct sim_cmd *cmd = sim_cmds.first; cmd; cmd = cmd->next) {
|
|
if (cmd->kind == SIM_CMD_KIND_DRAG_OBJECT) {
|
|
if (cmd->state == SIM_CMD_STATE_START) {
|
|
phys.dbg_start_dragging = true;
|
|
} else if (cmd->state == SIM_CMD_STATE_STOP) {
|
|
phys.dbg_stop_dragging = true;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Step */
|
|
ctx->last_phys_iteration = phys_step(&phys, dt, ctx->last_phys_iteration);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Update tracers
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_TRACER)) continue;
|
|
|
|
struct v2 end = sim_ent_get_xform(ent).og;
|
|
|
|
struct v2 tick_velocity = v2_mul(ent->tracer_start_velocity, dt);
|
|
struct v2 gradient_start = v2_add(ent->tracer_gradient_start, tick_velocity);
|
|
struct v2 gradient_end = v2_add(ent->tracer_gradient_end, tick_velocity);
|
|
|
|
if (v2_dot(tick_velocity, v2_sub(gradient_start, end)) > 0) {
|
|
/* Tracer has disappeared */
|
|
sim_ent_enable_prop(ent, SIM_ENT_PROP_RELEASE_NEXT_TICK);
|
|
}
|
|
|
|
ent->tracer_gradient_start = gradient_start;
|
|
ent->tracer_gradient_end = gradient_end;
|
|
}
|
|
|
|
/* ========================== *
|
|
* Initialize bullet kinematics from sources
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_BULLET)) continue;
|
|
|
|
if (ent->activation_tick == ctx->tick.tick_id) {
|
|
struct sim_ent *src = sim_ent_from_handle(ent_store, ent->bullet_src);
|
|
struct xform src_xf = sim_ent_get_xform(src);
|
|
|
|
struct v2 pos = xform_mul_v2(src_xf, ent->bullet_src_pos);
|
|
struct v2 impulse = xform_basis_mul_v2(src_xf, ent->bullet_src_dir);
|
|
impulse = v2_with_len(impulse, ent->bullet_impulse);
|
|
|
|
#if 0
|
|
/* Add shooter velocity to bullet */
|
|
{
|
|
/* TODO: Add angular velocity as well? */
|
|
struct sim_ent *top = sim_ent_from_handle(ent_store, src->top);
|
|
impulse = v2_add(impulse, v2_mul(top->linear_velocity, dt));
|
|
}
|
|
#endif
|
|
|
|
struct xform xf = XFORM_TRS(.t = pos, .r = v2_angle(impulse) + PI / 2);
|
|
sim_ent_set_xform(ent, xf);
|
|
sim_ent_enable_prop(ent, SIM_ENT_PROP_PHYSICAL_KINEMATIC);
|
|
|
|
sim_ent_apply_linear_impulse_to_center(ent, impulse);
|
|
|
|
/* Initialize tracer */
|
|
struct sim_ent *tracer = sim_ent_from_handle(ent_store, ent->bullet_tracer);
|
|
if (sim_ent_is_valid_and_active(tracer)) {
|
|
sim_ent_set_xform(tracer, xf);
|
|
sim_ent_enable_prop(tracer, SIM_ENT_PROP_PHYSICAL_KINEMATIC);
|
|
sim_ent_set_linear_velocity(tracer, ent->linear_velocity);
|
|
tracer->tracer_start = pos;
|
|
tracer->tracer_start_velocity = ent->linear_velocity;
|
|
tracer->tracer_gradient_end = pos;
|
|
tracer->tracer_gradient_start = v2_sub(pos, v2_mul(ent->linear_velocity, tracer->tracer_fade_duration));
|
|
}
|
|
|
|
/* Spawn quake */
|
|
{
|
|
struct sim_ent *quake = sim_ent_alloc(root);
|
|
sim_ent_set_xform(quake, XFORM_POS(pos));
|
|
quake->quake_intensity = 0.2f;
|
|
quake->quake_fade = quake->quake_intensity / 0.1f;
|
|
sim_ent_enable_prop(quake, SIM_ENT_PROP_QUAKE);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Update cameras
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_CAMERA)) continue;
|
|
|
|
struct xform xf = sim_ent_get_xform(ent);
|
|
|
|
/* Camera follow */
|
|
{
|
|
struct sim_ent *follow = sim_ent_from_handle(ent_store, ent->camera_follow);
|
|
|
|
f32 aspect_ratio = 1.0;
|
|
{
|
|
struct xform quad_xf = xform_mul(sim_ent_get_xform(ent), ent->camera_quad_xform);
|
|
struct v2 camera_size = xform_get_scale(quad_xf);
|
|
if (!v2_is_zero(camera_size)) {
|
|
aspect_ratio = camera_size.x / camera_size.y;
|
|
}
|
|
}
|
|
f32 ratio_y = 0.33f;
|
|
f32 ratio_x = ratio_y / aspect_ratio;
|
|
struct v2 camera_focus_dir = v2_mul_v2(follow->control.focus, V2(ratio_x, ratio_y));
|
|
struct v2 camera_focus_pos = v2_add(sim_ent_get_xform(follow).og, camera_focus_dir);
|
|
ent->camera_xform_target = xf;
|
|
ent->camera_xform_target.og = camera_focus_pos;
|
|
|
|
/* Lerp camera */
|
|
if (ent->camera_applied_lerp_continuity_gen_plus_one == ent->camera_lerp_continuity_gen + 1) {
|
|
f32 t = 1 - math_pow(2.f, -20.f * (f32)dt);
|
|
xf = xform_lerp(xf, ent->camera_xform_target, t);
|
|
} else {
|
|
/* Skip lerp */
|
|
xf = ent->camera_xform_target;
|
|
}
|
|
ent->camera_applied_lerp_continuity_gen_plus_one = ent->camera_lerp_continuity_gen + 1;
|
|
}
|
|
|
|
/* Camera shake */
|
|
{
|
|
/* TODO: Update based on distance to quake */
|
|
ent->shake = 0;
|
|
for (u64 quake_ent_index = 0; quake_ent_index < ent_store->num_reserved; ++quake_ent_index) {
|
|
struct sim_ent *quake = &ent_store->entities[quake_ent_index];
|
|
if (!sim_ent_is_valid_and_active(quake)) continue;
|
|
if (!sim_ent_has_prop(quake, SIM_ENT_PROP_QUAKE)) continue;
|
|
ent->shake += quake->quake_intensity;
|
|
}
|
|
}
|
|
|
|
sim_ent_set_xform(ent, xf);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Update quakes
|
|
* ========================== */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
if (!sim_ent_has_prop(ent, SIM_ENT_PROP_QUAKE)) continue;
|
|
|
|
ent->quake_intensity = max_f32(0, ent->quake_intensity - (ent->quake_fade * dt));
|
|
if (ent->quake_intensity <= 0) {
|
|
sim_ent_enable_prop(ent, SIM_ENT_PROP_RELEASE_NEXT_TICK);
|
|
}
|
|
}
|
|
|
|
/* ========================== *
|
|
* Update relative layers
|
|
* ========================== */
|
|
|
|
{
|
|
struct temp_arena temp = arena_temp_begin(scratch.arena);
|
|
|
|
struct sim_ent **stack = arena_push(temp.arena, struct sim_ent *);
|
|
u64 stack_count = 1;
|
|
*stack = root;
|
|
|
|
while (stack_count > 0) {
|
|
struct sim_ent *parent;
|
|
arena_pop(temp.arena, struct sim_ent *, &parent);
|
|
--stack_count;
|
|
|
|
i32 parent_layer = parent->final_layer;
|
|
for (struct sim_ent *child = sim_ent_from_handle(ent_store, parent->first); child->valid; child = sim_ent_from_handle(ent_store, child->next)) {
|
|
if (sim_ent_is_valid_and_active(child)) {
|
|
child->final_layer = parent_layer + child->layer;
|
|
*arena_push(temp.arena, struct sim_ent *) = child;
|
|
++stack_count;
|
|
}
|
|
}
|
|
}
|
|
|
|
arena_temp_end(temp);
|
|
}
|
|
|
|
#if 0
|
|
/* ========================== *
|
|
* Update sound emitters
|
|
* ========================== */
|
|
|
|
/* TODO: Sound entities should be created by sim thread, but played by the
|
|
* user thread. This is so sounds play at the correct time on the user
|
|
* thread regardless of interp delay. */
|
|
|
|
for (u64 ent_index = 0; ent_index < ent_store->num_reserved; ++ent_index) {
|
|
struct sim_ent *ent = &ent_store->entities[ent_index];
|
|
if (!sim_ent_is_valid_and_active(ent)) continue;
|
|
|
|
if (sim_ent_has_prop(ent, SIM_ENT_PROP_TEST_SOUND_EMITTER)) {
|
|
struct mixer_desc desc = ent->sound_desc;
|
|
desc.speed = ctx->tick.timescale;
|
|
|
|
desc.pos = sim_ent_get_xform(ent).og;
|
|
struct sound *sound = sound_load_async(ent->sound_name, 0);
|
|
b32 played = ent->sound_handle.gen != 0;
|
|
if (sound) {
|
|
if (!played) {
|
|
ent->sound_handle = mixer_play_ex(sound, desc);
|
|
} else {
|
|
mixer_track_set(ent->sound_handle, desc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* ========================== *
|
|
* Release entities
|
|
* ========================== */
|
|
|
|
release_entities_with_prop(ctx, SIM_ENT_PROP_RELEASE_THIS_TICK);
|
|
|
|
/* ========================== *
|
|
* Publish tick
|
|
* ========================== */
|
|
|
|
for (u64 i = 0; i < ctx->tick.client_store->num_reserved; ++i) {
|
|
struct sim_client *client = &ctx->tick.client_store->clients[i];
|
|
if (client->valid) {
|
|
struct temp_arena temp = arena_temp_begin(scratch.arena);
|
|
|
|
/* TODO: Not like this */
|
|
struct sim_event snapshot_event = ZI;
|
|
snapshot_event.kind = SIM_EVENT_KIND_SNAPSHOT;
|
|
snapshot_event.snapshot_data = sim_string_from_tick(temp.arena, client, &ctx->tick);
|
|
|
|
struct sim_event_list l = ZI;
|
|
l.first = &snapshot_event;
|
|
l.last = &snapshot_event;
|
|
struct string msg = sim_string_from_events(temp.arena, l);
|
|
|
|
host_queue_write(ctx->host, client->channel_id, msg, 0);
|
|
//host_queue_write(ctx->host, HOST_CHANNEL_ID_ALL, msg, 0);
|
|
|
|
arena_temp_end(temp);
|
|
}
|
|
}
|
|
|
|
host_update(ctx->host);
|
|
__profframe("Sim");
|
|
|
|
/* ========================== *
|
|
* End frame cache scopes
|
|
* ========================== */
|
|
|
|
sprite_scope_end(sprite_frame_scope);
|
|
|
|
scratch_end(scratch);
|
|
}
|
|
|
|
/* ========================== *
|
|
* Sim thread
|
|
* ========================== */
|
|
|
|
INTERNAL SYS_THREAD_ENTRY_POINT_FUNC_DEF(sim_thread_entry_point, arg)
|
|
{
|
|
struct sim_ctx *ctx = (struct sim_ctx *)arg;
|
|
i64 last_frame_ns = 0;
|
|
i64 target_dt_ns = NS_FROM_SECONDS(SIM_FPS > (0) ? (1.0 / SIM_FPS) : 0);
|
|
while (!atomic_i32_eval(&ctx->sim_thread_shutdown)) {
|
|
__profscope(sim_update_w_sleep);
|
|
sleep_frame(last_frame_ns, target_dt_ns);
|
|
last_frame_ns = sys_time_ns();
|
|
sim_update(ctx, (1.0 / SIM_FPS));
|
|
}
|
|
}
|