From f3b86f84c2c97b077883feb006bd977c970bbdbf Mon Sep 17 00:00:00 2001 From: asrael Date: Fri, 21 Nov 2025 16:44:42 -0600 Subject: [PATCH] add collision w/ walls --- src/lua/pxl8.lua | 2 + src/lua/pxl8/world.lua | 12 ++ src/pxl8_script.c | 8 +- src/pxl8_world.c | 271 +++++++++++++++++++++++++++++++++++++---- src/pxl8_world.h | 9 +- 5 files changed, 270 insertions(+), 32 deletions(-) diff --git a/src/lua/pxl8.lua b/src/lua/pxl8.lua index e2fa1f8..2927384 100644 --- a/src/lua/pxl8.lua +++ b/src/lua/pxl8.lua @@ -143,6 +143,8 @@ pxl8.world_unload = world.unload pxl8.world_is_loaded = world.is_loaded pxl8.world_generate = world.generate pxl8.world_apply_textures = world.apply_textures +pxl8.world_check_collision = world.check_collision +pxl8.world_resolve_collision = world.resolve_collision pxl8.procgen_tex = world.procgen_tex pxl8.PROCGEN_ROOMS = world.PROCGEN_ROOMS pxl8.PROCGEN_TERRAIN = world.PROCGEN_TERRAIN diff --git a/src/lua/pxl8/world.lua b/src/lua/pxl8/world.lua index f86e4f3..c6c9ad9 100644 --- a/src/lua/pxl8/world.lua +++ b/src/lua/pxl8/world.lua @@ -95,4 +95,16 @@ function world.apply_textures(w, texture_defs) return result end +function world.check_collision(w, x, y, z, radius) + local pos = ffi.new("pxl8_vec3", {x = x, y = y, z = z}) + return C.pxl8_world_check_collision(w, pos, radius) +end + +function world.resolve_collision(w, from_x, from_y, from_z, to_x, to_y, to_z, radius) + local from = ffi.new("pxl8_vec3", {x = from_x, y = from_y, z = from_z}) + local to = ffi.new("pxl8_vec3", {x = to_x, y = to_y, z = to_z}) + local result = C.pxl8_world_resolve_collision(w, from, to, radius) + return result.x, result.y, result.z +end + return world diff --git a/src/pxl8_script.c b/src/pxl8_script.c index 158c01a..a5b83d2 100644 --- a/src/pxl8_script.c +++ b/src/pxl8_script.c @@ -302,11 +302,13 @@ static const char* pxl8_ffi_cdefs = "pxl8_world* pxl8_world_create(void);\n" "void pxl8_world_destroy(pxl8_world* world);\n" "int pxl8_world_generate(pxl8_world* world, pxl8_gfx* gfx, const pxl8_procgen_params* params);\n" -"int pxl8_world_apply_textures(pxl8_world* world, const pxl8_world_texture* textures, unsigned int count);\n" -"bool pxl8_world_is_loaded(const pxl8_world* world);\n" "int pxl8_world_load(pxl8_world* world, const char* path);\n" -"void pxl8_world_render(pxl8_world* world, pxl8_gfx* gfx, pxl8_vec3 camera_pos);\n" "void pxl8_world_unload(pxl8_world* world);\n" +"int pxl8_world_apply_textures(pxl8_world* world, const pxl8_world_texture* textures, unsigned int count);\n" +"bool pxl8_world_check_collision(const pxl8_world* world, pxl8_vec3 pos, float radius);\n" +"bool pxl8_world_is_loaded(const pxl8_world* world);\n" +"void pxl8_world_render(pxl8_world* world, pxl8_gfx* gfx, pxl8_vec3 camera_pos);\n" +"pxl8_vec3 pxl8_world_resolve_collision(const pxl8_world* world, pxl8_vec3 from, pxl8_vec3 to, float radius);\n" "\n" "typedef struct { i32 cursor_x; i32 cursor_y; bool cursor_down; bool cursor_clicked; u32 hot_id; u32 active_id; } pxl8_gui_state;\n" "pxl8_gui_state* pxl8_gui_state_create(void);\n" diff --git a/src/pxl8_world.c b/src/pxl8_world.c index d34d081..87e6689 100644 --- a/src/pxl8_world.c +++ b/src/pxl8_world.c @@ -38,8 +38,6 @@ void pxl8_world_destroy(pxl8_world* world) { } pxl8_result pxl8_world_generate(pxl8_world* world, pxl8_gfx* gfx, const pxl8_procgen_params* params) { - pxl8_debug("pxl8_world_generate called"); - if (!world || !gfx || !params) { pxl8_error("Invalid arguments to pxl8_world_generate"); return PXL8_ERROR_INVALID_ARGUMENT; @@ -63,6 +61,35 @@ pxl8_result pxl8_world_generate(pxl8_world* world, pxl8_gfx* gfx, const pxl8_pro return PXL8_OK; } +pxl8_result pxl8_world_load(pxl8_world* world, const char* path) { + if (!world || !path) return PXL8_ERROR_INVALID_ARGUMENT; + + if (world->loaded) { + pxl8_bsp_destroy(&world->bsp); + world->loaded = false; + } + + memset(&world->bsp, 0, sizeof(pxl8_bsp)); + + pxl8_result result = pxl8_bsp_load(path, &world->bsp); + if (result != PXL8_OK) { + pxl8_error("Failed to load world: %s", path); + return result; + } + + world->loaded = true; + pxl8_info("Loaded world: %s", path); + + return PXL8_OK; +} + +void pxl8_world_unload(pxl8_world* world) { + if (!world || !world->loaded) return; + + pxl8_bsp_destroy(&world->bsp); + world->loaded = false; +} + pxl8_result pxl8_world_apply_textures(pxl8_world* world, const pxl8_world_texture* textures, u32 count) { if (!world || !world->loaded || !textures || count == 0) { return PXL8_ERROR_INVALID_ARGUMENT; @@ -151,26 +178,229 @@ pxl8_result pxl8_world_apply_textures(pxl8_world* world, const pxl8_world_textur return PXL8_OK; } -pxl8_result pxl8_world_load(pxl8_world* world, const char* path) { - if (!world || !path) return PXL8_ERROR_INVALID_ARGUMENT; +bool pxl8_world_check_collision(const pxl8_world* world, pxl8_vec3 pos, f32 radius) { + if (!world || !world->loaded) return false; - if (world->loaded) { - pxl8_bsp_destroy(&world->bsp); - world->loaded = false; + const pxl8_bsp* bsp = &world->bsp; + + for (u32 i = 0; i < bsp->num_faces; i++) { + const pxl8_bsp_face* face = &bsp->faces[i]; + const pxl8_bsp_plane* plane = &bsp->planes[face->plane_id]; + + if (fabsf(plane->normal.y) > 0.7f) { + continue; + } + + f32 dist = plane->normal.x * pos.x + + plane->normal.y * pos.y + + plane->normal.z * pos.z - plane->dist; + + if (fabsf(dist) > radius) { + continue; + } + + pxl8_vec3 closest_point = { + pos.x - plane->normal.x * dist, + pos.y - plane->normal.y * dist, + pos.z - plane->normal.z * dist + }; + + if (closest_point.x < face->aabb_min.x - radius || closest_point.x > face->aabb_max.x + radius || + closest_point.y < face->aabb_min.y - radius || closest_point.y > face->aabb_max.y + radius || + closest_point.z < face->aabb_min.z - radius || closest_point.z > face->aabb_max.z + radius) { + continue; + } + + return true; } - memset(&world->bsp, 0, sizeof(pxl8_bsp)); + return false; +} - pxl8_result result = pxl8_bsp_load(path, &world->bsp); - if (result != PXL8_OK) { - pxl8_error("Failed to load world: %s", path); - return result; +bool pxl8_world_is_loaded(const pxl8_world* world) { + return world && world->loaded; +} + +static inline f32 vec3_dot(pxl8_vec3 a, pxl8_vec3 b) { + return a.x * b.x + a.y * b.y + a.z * b.z; +} + +static inline pxl8_vec3 vec3_cross(pxl8_vec3 a, pxl8_vec3 b) { + return (pxl8_vec3){ + a.y * b.z - a.z * b.y, + a.z * b.x - a.x * b.z, + a.x * b.y - a.y * b.x + }; +} + +static inline f32 vec3_length(pxl8_vec3 v) { + return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z); +} + +pxl8_vec3 pxl8_world_resolve_collision(const pxl8_world* world, pxl8_vec3 from, pxl8_vec3 to, f32 radius) { + if (!world || !world->loaded) return to; + + const pxl8_bsp* bsp = &world->bsp; + pxl8_vec3 pos = to; + pxl8_vec3 original_velocity = {to.x - from.x, to.y - from.y, to.z - from.z}; + + pxl8_vec3 clip_planes[5]; + u32 num_planes = 0; + + const f32 edge_epsilon = 1.2f; + const f32 radius_min = -radius + edge_epsilon; + const f32 radius_max = radius - edge_epsilon; + + for (i32 iteration = 0; iteration < 4; iteration++) { + bool collided = false; + + for (u32 i = 0; i < bsp->num_faces; i++) { + const pxl8_bsp_face* face = &bsp->faces[i]; + const pxl8_bsp_plane* plane = &bsp->planes[face->plane_id]; + + if (fabsf(plane->normal.y) > 0.7f) continue; + + f32 dist = plane->normal.x * pos.x + + plane->normal.y * pos.y + + plane->normal.z * pos.z - plane->dist; + + f32 abs_dist = fabsf(dist); + if (abs_dist > radius) continue; + + pxl8_vec3 closest_point = { + pos.x - plane->normal.x * dist, + pos.y - plane->normal.y * dist, + pos.z - plane->normal.z * dist + }; + + if (closest_point.x < face->aabb_min.x + radius_min || closest_point.x > face->aabb_max.x + radius_max || + closest_point.y < face->aabb_min.y + radius_min || closest_point.y > face->aabb_max.y + radius_max || + closest_point.z < face->aabb_min.z + radius_min || closest_point.z > face->aabb_max.z + radius_max) { + continue; + } + + f32 penetration = radius - abs_dist; + if (penetration > 0.01f) { + pxl8_vec3 push_dir; + if (dist < 0) { + push_dir.x = -plane->normal.x; + push_dir.y = -plane->normal.y; + push_dir.z = -plane->normal.z; + } else { + push_dir.x = plane->normal.x; + push_dir.y = plane->normal.y; + push_dir.z = plane->normal.z; + } + + bool is_new_plane = true; + for (u32 p = 0; p < num_planes; p++) { + if (vec3_dot(push_dir, clip_planes[p]) > 0.99f) { + is_new_plane = false; + break; + } + } + + if (is_new_plane && num_planes < 5) { + clip_planes[num_planes++] = push_dir; + } + + pos.x += push_dir.x * penetration; + pos.y += push_dir.y * penetration; + pos.z += push_dir.z * penetration; + + collided = true; + } + } + + if (!collided) { + break; + } + + if (num_planes >= 3) { + break; + } } - world->loaded = true; - pxl8_info("Loaded world: %s", path); + if (num_planes == 2) { + f32 orig_vel_len_sq = original_velocity.x * original_velocity.x + + original_velocity.y * original_velocity.y + + original_velocity.z * original_velocity.z; - return PXL8_OK; + if (orig_vel_len_sq > 0.000001f) { + f32 vdot0 = vec3_dot(original_velocity, clip_planes[0]); + f32 vdot1 = vec3_dot(original_velocity, clip_planes[1]); + f32 dot0 = fabsf(vdot0); + f32 dot1 = fabsf(vdot1); + + pxl8_vec3 slide_vel; + if (dot0 < dot1) { + slide_vel.x = original_velocity.x - clip_planes[0].x * vdot0; + slide_vel.y = original_velocity.y - clip_planes[0].y * vdot0; + slide_vel.z = original_velocity.z - clip_planes[0].z * vdot0; + } else { + slide_vel.x = original_velocity.x - clip_planes[1].x * vdot1; + slide_vel.y = original_velocity.y - clip_planes[1].y * vdot1; + slide_vel.z = original_velocity.z - clip_planes[1].z * vdot1; + } + + f32 slide_len = sqrtf(slide_vel.x * slide_vel.x + slide_vel.y * slide_vel.y + slide_vel.z * slide_vel.z); + + if (slide_len > 0.01f) { + pos.x += slide_vel.x; + pos.y += slide_vel.y; + pos.z += slide_vel.z; + + pxl8_vec3 crease_dir = vec3_cross(clip_planes[0], clip_planes[1]); + f32 crease_len = vec3_length(crease_dir); + if (crease_len > 0.01f && fabsf(crease_dir.y / crease_len) > 0.9f) { + f32 bias0 = vec3_dot(original_velocity, clip_planes[0]); + f32 bias1 = vec3_dot(original_velocity, clip_planes[1]); + + if (bias0 < 0 && bias1 < 0) { + const f32 corner_push = 0.1f; + pxl8_vec3 push_away = { + clip_planes[0].x + clip_planes[1].x, + clip_planes[0].y + clip_planes[1].y, + clip_planes[0].z + clip_planes[1].z + }; + f32 push_len_sq = push_away.x * push_away.x + push_away.y * push_away.y + push_away.z * push_away.z; + if (push_len_sq > 0.000001f) { + f32 inv_push_len = corner_push / sqrtf(push_len_sq); + pos.x += push_away.x * inv_push_len; + pos.y += push_away.y * inv_push_len; + pos.z += push_away.z * inv_push_len; + } + } + } + } + } + } + + f32 horizontal_movement_sq = (pos.x - from.x) * (pos.x - from.x) + + (pos.z - from.z) * (pos.z - from.z); + f32 desired_horizontal_sq = (to.x - from.x) * (to.x - from.x) + + (to.z - from.z) * (to.z - from.z); + + if (desired_horizontal_sq > 0.01f && horizontal_movement_sq < desired_horizontal_sq * 0.25f) { + const f32 max_step_height = 0.4f; + + pxl8_vec3 step_up = pos; + step_up.y += max_step_height; + + if (!pxl8_world_check_collision(world, step_up, radius)) { + pxl8_vec3 step_forward = { + step_up.x + (to.x - pos.x), + step_up.y, + step_up.z + (to.z - pos.z) + }; + + if (!pxl8_world_check_collision(world, step_forward, radius)) { + pos = step_forward; + } + } + } + + return pos; } void pxl8_world_render(pxl8_world* world, pxl8_gfx* gfx, pxl8_vec3 camera_pos) { @@ -182,14 +412,3 @@ void pxl8_world_render(pxl8_world* world, pxl8_gfx* gfx, pxl8_vec3 camera_pos) { pxl8_bsp_render_textured(gfx, &world->bsp, camera_pos); } } - -void pxl8_world_unload(pxl8_world* world) { - if (!world || !world->loaded) return; - - pxl8_bsp_destroy(&world->bsp); - world->loaded = false; -} - -bool pxl8_world_is_loaded(const pxl8_world* world) { - return world && world->loaded; -} diff --git a/src/pxl8_world.h b/src/pxl8_world.h index 03158af..129d5ec 100644 --- a/src/pxl8_world.h +++ b/src/pxl8_world.h @@ -24,12 +24,15 @@ pxl8_world* pxl8_world_create(void); void pxl8_world_destroy(pxl8_world* world); pxl8_result pxl8_world_generate(pxl8_world* world, pxl8_gfx* gfx, const pxl8_procgen_params* params); -pxl8_result pxl8_world_apply_textures(pxl8_world* world, const pxl8_world_texture* textures, u32 count); -bool pxl8_world_is_loaded(const pxl8_world* world); pxl8_result pxl8_world_load(pxl8_world* world, const char* path); -void pxl8_world_render(pxl8_world* world, pxl8_gfx* gfx, pxl8_vec3 camera_pos); void pxl8_world_unload(pxl8_world* world); +pxl8_result pxl8_world_apply_textures(pxl8_world* world, const pxl8_world_texture* textures, u32 count); +bool pxl8_world_check_collision(const pxl8_world* world, pxl8_vec3 pos, f32 radius); +bool pxl8_world_is_loaded(const pxl8_world* world); +void pxl8_world_render(pxl8_world* world, pxl8_gfx* gfx, pxl8_vec3 camera_pos); +pxl8_vec3 pxl8_world_resolve_collision(const pxl8_world* world, pxl8_vec3 from, pxl8_vec3 to, f32 radius); + #ifdef __cplusplus } #endif