renati/voxel-game
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Separate out Chunks-related code, "fix" collisions to be less broken

Browse Source
This commit is contained in:
Szymon Nowakowski
2025-12-21 22:26:55 +01:00
parent d63aeba562
commit a77bddbdb2
5 changed files with 313 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

295
src/Player.zig
View File

@@ -6,7 +6,7 @@ const glfw = @import("zglfw");
const math = @import("math.zig");
const Blocks = @import("assets/Blocks.zig");
const Chunk = @import("assets/Chunk.zig");
const Chunks = @import("Chunks.zig");
const Iterator2 = math.Iterator2;
const Vector2 = math.Vector2;
const Vector3 = math.Vector3;
@@ -226,7 +226,7 @@ pub fn onMouseMove(self: *Player, dx: f32, dy: f32) void {
self.yaw_rad = @mod(self.yaw_rad - dx * self.mouse_sensitivity, std.math.tau);
}
pub fn update(self: *Player, dt: f32, chunks: *const std.AutoHashMapUnmanaged([3]i16, Chunk)) void {
pub fn update(self: *Player, dt: f32, chunks: *const Chunks) void {
defer self.resetAllButtons();
// --- GATHER INPUTS -------------------------------------------------------
@@ -272,17 +272,21 @@ pub fn update(self: *Player, dt: f32, chunks: *const std.AutoHashMapUnmanaged([3
var vertical_displacement_sv = math.mulIntFloat(vertical_velocity_sv, dt);
var position_sv = self.position_sv;
var min_sv = position_sv.add(.init(-collision_half_width_sv, -collision_half_width_sv, 0));
var max_sv = position_sv.add(.init(collision_half_width_sv, collision_half_width_sv, collision_height_sv));
if (vertical_displacement_sv > 0) {
if (sweepCastUp(position_sv, vertical_displacement_sv, chunks)) |hit| {
if (chunks.sweepCastUp(min_sv, max_sv, vertical_displacement_sv)) |hit| {
vertical_displacement_sv -= hit.projected_distance_sv;
}
position_sv = .add(position_sv, .init(0, 0, vertical_displacement_sv));
min_sv = .add(min_sv, .init(0, 0, vertical_displacement_sv));
max_sv = .add(max_sv, .init(0, 0, vertical_displacement_sv));
}
var i: usize = 0;
while (i < 2) : (i += 1) {
if (sweepCastHorizontal(position_sv, horizontal_displacement_sv, chunks)) |hit| {
if (chunks.sweepCastHorizontal(min_sv, max_sv, horizontal_displacement_sv)) |hit| {
const adjustment = hit.normal_frac
.asVector2Int()
.mulScalarFrac(hit.projected_distance_sv);
@@ -306,7 +310,9 @@ pub fn update(self: *Player, dt: f32, chunks: *const std.AutoHashMapUnmanaged([3
position_sv = .add(position_sv, horizontal_displacement_sv.asVector3Int(0));
if (vertical_displacement_sv < 0.0) {
if (sweepCastDown(position_sv, -vertical_displacement_sv, chunks)) |hit| {
min_sv = .add(min_sv, horizontal_displacement_sv.asVector3Int(0));
max_sv = .add(max_sv, horizontal_displacement_sv.asVector3Int(0));
if (chunks.sweepCastDown(min_sv, max_sv, -vertical_displacement_sv)) |hit| {
vertical_displacement_sv += hit.projected_distance_sv;
}
position_sv = .add(position_sv, .init(0, 0, vertical_displacement_sv));
@@ -317,251 +323,6 @@ pub fn update(self: *Player, dt: f32, chunks: *const std.AutoHashMapUnmanaged([3
}
}
const SweepHit = struct {
normal_frac: Vector3Int,
projected_distance_sv: i32,
};
fn sweepCastDown(origin_sv: Vector3Int, distance_sv: i32, chunks: *const std.AutoHashMapUnmanaged([3]i16, Chunk)) ?SweepHit {
const min_origin_sv = origin_sv.add(.init(-collision_half_width_sv, -collision_half_width_sv, 0));
const max_origin_sv = origin_sv.add(.init(collision_half_width_sv, collision_half_width_sv, collision_height_sv));
const min_x_vx = c.subvoxelsToVoxels(.border_up, min_origin_sv.getX());
const min_y_vx = c.subvoxelsToVoxels(.border_up, min_origin_sv.getY());
const max_x_vx = c.subvoxelsToVoxels(.border_down, max_origin_sv.getX());
const max_y_vx = c.subvoxelsToVoxels(.border_down, max_origin_sv.getY());
const start_z_vx = c.subvoxelsToVoxels(.border_up, min_origin_sv.getZ()) - 1;
const end_z_vx = c.subvoxelsToVoxels(.border_up, min_origin_sv.getZ() - distance_sv);
var z_vx: i32 = start_z_vx;
while (z_vx >= end_z_vx) : (z_vx -= 1) {
const z_sv = c.voxelsToSubvoxels(z_vx + 1);
var it = Iterator2(i32).init(.{
.min = .{ min_x_vx, min_y_vx },
.max = .{ max_x_vx, max_y_vx },
});
while (it.next()) |xy_vx| {
const x_vx, const y_vx = xy_vx;
if (!isSolid(chunks, .init(x_vx, y_vx, z_vx))) continue;
return .{
.projected_distance_sv = distance_sv - (min_origin_sv.getZ() - z_sv),
.normal_frac = .unit_z_frac,
};
}
}
return null;
}
fn sweepCastUp(origin_sv: Vector3Int, distance_sv: i32, chunks: *const std.AutoHashMapUnmanaged([3]i16, Chunk)) ?SweepHit {
const min_origin_sv = origin_sv.add(.init(-collision_half_width_sv, -collision_half_width_sv, 0));
const max_origin_sv = origin_sv.add(.init(collision_half_width_sv, collision_half_width_sv, collision_height_sv));
const min_x_vx = c.subvoxelsToVoxels(.border_up, min_origin_sv.getX());
const min_y_vx = c.subvoxelsToVoxels(.border_up, min_origin_sv.getY());
const max_x_vx = c.subvoxelsToVoxels(.border_down, max_origin_sv.getX());
const max_y_vx = c.subvoxelsToVoxels(.border_down, max_origin_sv.getY());
const start_z_vx = c.subvoxelsToVoxels(.border_down, max_origin_sv.getZ()) + 1;
const end_z_vx = c.subvoxelsToVoxels(.border_down, max_origin_sv.getZ() + distance_sv);
var z_vx: i32 = start_z_vx;
while (z_vx <= end_z_vx) : (z_vx += 1) {
const z_sv = c.voxelsToSubvoxels(z_vx);
var it = Iterator2(i32).init(.{
.min = .{ min_x_vx, min_y_vx },
.max = .{ max_x_vx, max_y_vx },
});
while (it.next()) |xy_vx| {
const x_vx, const y_vx = xy_vx;
if (!isSolid(chunks, .init(x_vx, y_vx, z_vx))) continue;
return .{
.projected_distance_sv = distance_sv - (z_sv - max_origin_sv.getZ()),
.normal_frac = .unit_nz_frac,
};
}
}
return null;
}
fn sweepCastHorizontal(origin_sv: Vector3Int, ray_sv: Vector2Int, chunks: *const std.AutoHashMapUnmanaged([3]i16, Chunk)) ?SweepHit {
const min_origin_sv = origin_sv.add(.init(-collision_half_width_sv, -collision_half_width_sv, 0));
const max_origin_sv = origin_sv.add(.init(collision_half_width_sv, collision_half_width_sv, collision_height_sv));
const min_z_vx = c.subvoxelsToVoxels(.border_up, min_origin_sv.getZ());
const max_z_vx = c.subvoxelsToVoxels(.border_down, max_origin_sv.getZ());
var hit: ?SweepHit = null;
var hit_distance_squared = std.math.inf(f32);
const fdydx: f32 = @as(f32, @floatFromInt(ray_sv.getY())) / @as(f32, @floatFromInt(ray_sv.getX()));
const fdxdy: f32 = @as(f32, @floatFromInt(ray_sv.getX())) / @as(f32, @floatFromInt(ray_sv.getY()));
// Positive X
if (ray_sv.getX() > 0) {
const x0_sv = max_origin_sv.getX();
const y0_sv = min_origin_sv.getY();
const y1_sv = max_origin_sv.getY();
const start_x_vx = c.subvoxelsToVoxels(.border_down, x0_sv) + 1;
const end_x_vx = c.subvoxelsToVoxels(.border_down, x0_sv + ray_sv.getX());
var x_vx: i32 = start_x_vx;
px: while (x_vx <= end_x_vx) : (x_vx += 1) {
const x_sv = c.voxelsToSubvoxels(x_vx);
const min_y_vx = c.subvoxelsToVoxels(.border_up, wideMulDivFloor(x_sv - x0_sv, ray_sv.getY(), ray_sv.getX()) + y0_sv);
const max_y_vx = c.subvoxelsToVoxels(.border_down, wideMulDivCeil(x_sv - x0_sv, ray_sv.getY(), ray_sv.getX()) + y1_sv);
var it = Iterator2(i32).init(.{
.min = .{ min_y_vx, min_z_vx },
.max = .{ max_y_vx, max_z_vx },
});
while (it.next()) |yz_vx| {
const y_vx, const z_vx = yz_vx;
if (!isSolid(chunks, .init(x_vx, y_vx, z_vx))) continue;
const dx = x_sv - x0_sv;
const fdx: f32 = @floatFromInt(dx);
const fdy: f32 = fdx * fdydx;
hit = .{
.projected_distance_sv = ray_sv.getX() - dx,
.normal_frac = .unit_nx_frac,
};
hit_distance_squared = fdx * fdx + fdy * fdy;
std.debug.print("+X fdx={d} fdy={d} dist2={d}\n", .{ fdx, fdy, hit_distance_squared });
break :px;
}
}
}
// Negative X
if (ray_sv.getX() < 0) {
const x0_sv = min_origin_sv.getX();
const y0_sv = min_origin_sv.getY();
const y1_sv = max_origin_sv.getY();
const start_x_vx = c.subvoxelsToVoxels(.border_up, x0_sv) - 1;
const end_x_vx = c.subvoxelsToVoxels(.border_up, x0_sv + ray_sv.getX());
var x_vx: i32 = start_x_vx;
nx: while (x_vx >= end_x_vx) : (x_vx -= 1) {
const x_sv = c.voxelsToSubvoxels(x_vx + 1);
const min_y_vx = c.subvoxelsToVoxels(.border_up, wideMulDivFloor(x_sv - x0_sv, ray_sv.getY(), ray_sv.getX()) + y0_sv);
const max_y_vx = c.subvoxelsToVoxels(.border_down, wideMulDivCeil(x_sv - x0_sv, ray_sv.getY(), ray_sv.getX()) + y1_sv);
var it = Iterator2(i32).init(.{
.min = .{ min_y_vx, min_z_vx },
.max = .{ max_y_vx, max_z_vx },
});
while (it.next()) |yz_vx| {
const y_vx, const z_vx = yz_vx;
if (!isSolid(chunks, .init(x_vx, y_vx, z_vx))) continue;
const dx = x_sv - x0_sv;
const fdx: f32 = @floatFromInt(dx);
const fdy: f32 = fdx * fdydx;
hit = .{
.projected_distance_sv = -(ray_sv.getX() - dx),
.normal_frac = .unit_x_frac,
};
hit_distance_squared = fdx * fdx + fdy * fdy;
std.debug.print("-X fdx={d} fdy={d} dist2={d}\n", .{ fdx, fdy, hit_distance_squared });
break :nx;
}
}
}
// Positive Y
if (ray_sv.getY() > 0) {
const y0_sv = max_origin_sv.getY();
const x0_sv = min_origin_sv.getX();
const x1_sv = max_origin_sv.getX();
const start_y_vx = c.subvoxelsToVoxels(.border_down, y0_sv) + 1;
const end_y_vx = c.subvoxelsToVoxels(.border_down, y0_sv + ray_sv.getY());
var y_vx = start_y_vx;
py: while (y_vx <= end_y_vx) : (y_vx += 1) {
const y_sv = c.voxelsToSubvoxels(y_vx);
const min_x_vx = c.subvoxelsToVoxels(.border_up, wideMulDivFloor(y_sv - y0_sv, ray_sv.getX(), ray_sv.getY()) + x0_sv);
const max_x_vx = c.subvoxelsToVoxels(.border_down, wideMulDivCeil(y_sv - y0_sv, ray_sv.getX(), ray_sv.getY()) + x1_sv);
var it = Iterator2(i32).init(.{
.min = .{ min_x_vx, min_z_vx },
.max = .{ max_x_vx, max_z_vx },
});
while (it.next()) |xz_vx| {
const x_vx, const z_vx = xz_vx;
if (!isSolid(chunks, .init(x_vx, y_vx, z_vx))) continue;
const dy = y_sv - y0_sv;
const fdy: f32 = @floatFromInt(dy);
const fdx: f32 = fdy * fdxdy;
const this_hit_distance_squared = fdx * fdx + fdy * fdy;
std.debug.print("+Y fdx={d} fdy={d} dist2={d}\n", .{ fdx, fdy, this_hit_distance_squared });
if (this_hit_distance_squared < hit_distance_squared) {
hit = .{
.projected_distance_sv = ray_sv.getY() - dy,
.normal_frac = .unit_ny_frac,
};
hit_distance_squared = this_hit_distance_squared;
}
break :py;
}
}
}
// Negative Y
if (ray_sv.getY() < 0.0) {
const y0_sv = min_origin_sv.getY();
const x0_sv = min_origin_sv.getX();
const x1_sv = max_origin_sv.getX();
const start_y_vx = c.subvoxelsToVoxels(.border_up, y0_sv) - 1;
const end_y_vx = c.subvoxelsToVoxels(.border_up, y0_sv + ray_sv.getY());
var y_vx = start_y_vx;
ny: while (y_vx >= end_y_vx) : (y_vx -= 1) {
const y_sv = c.voxelsToSubvoxels(y_vx + 1);
const min_x_vx = c.subvoxelsToVoxels(.border_up, wideMulDivFloor(y_sv - y0_sv, ray_sv.getX(), ray_sv.getY()) + x0_sv);
const max_x_vx = c.subvoxelsToVoxels(.border_down, wideMulDivCeil(y_sv - y0_sv, ray_sv.getX(), ray_sv.getY()) + x1_sv);
var it = Iterator2(i32).init(.{
.min = .{ min_x_vx, min_z_vx },
.max = .{ max_x_vx, max_z_vx },
});
while (it.next()) |xz_vx| {
const x_vx, const z_vx = xz_vx;
if (!isSolid(chunks, .init(x_vx, y_vx, z_vx))) continue;
const dy = y_sv - y0_sv;
const fdy: f32 = @floatFromInt(dy);
const fdx: f32 = fdy * fdxdy;
const this_hit_distance_squared = fdx * fdx + fdy * fdy;
std.debug.print("-Y fdx={d} fdy={d} dist2={d}\n", .{ fdx, fdy, this_hit_distance_squared });
if (this_hit_distance_squared < hit_distance_squared) {
hit = .{
.projected_distance_sv = -(ray_sv.getY() - dy),
.normal_frac = .unit_y_frac,
};
hit_distance_squared = this_hit_distance_squared;
}
break :ny;
}
}
}
return hit;
}
fn resetAllButtons(self: *Player) void {
inline for (@typeInfo(Player).@"struct".fields) |field| {
if (field.type == Button) {
@@ -570,40 +331,6 @@ fn resetAllButtons(self: *Player) void {
}
}
fn getVoxelAt(chunks: *const std.AutoHashMapUnmanaged([3]i16, Chunk), vx: Vector3Int) ?Blocks.Id {
const min_ck = Vector3Int.initScalar(std.math.minInt(i16));
const max_ck = Vector3Int.initScalar(std.math.maxInt(i16));
const ck = vx.divScalar(c.vx_per_ck);
if (@reduce(.Or, (ck.vector < min_ck.vector) | (ck.vector > max_ck.vector))) {
return null;
}
if (chunks.get(.{
@intCast(ck.getX()),
@intCast(ck.getY()),
@intCast(ck.getZ()),
})) |chunk| {
const ckvx = vx.modScalar(c.vx_per_ck);
return chunk.blocks[@intCast(ckvx.getZ())][@intCast(ckvx.getY())][@intCast(ckvx.getX())];
} else {
return .air;
}
}
fn isSolid(chunks: *const std.AutoHashMapUnmanaged([3]i16, Chunk), vx: Vector3Int) bool {
const maybe_id = getVoxelAt(chunks, vx);
// NOTE `null` is considered solid, as it's out of bounds.
return maybe_id != .air;
}
inline fn wideMulDivFloor(a: i32, mul: i32, div: i32) i32 {
return @intCast(@divFloor(@as(i64, a) * @as(i64, mul), div));
}
inline fn wideMulDivCeil(a: i32, mul: i32, div: i32) i32 {
return @intCast(@divFloor(@as(i64, a) * @as(i64, mul) + @as(i64, div) - 1, div));
}
inline fn sv(comptime vx: comptime_float) comptime_int {
return @intFromFloat(@round(vx * c.sv_per_vx));
}