Orkuncakilkaya
b4af12025d
An empty world at the game's size held 51839 KB of Jolt's heap (200000 bodies, 65536 pairs, 20480 contacts, a 32 MB temp heap), the jolt= floor under every walk. Pairs and contacts come from what moves - drops, boats, a few walkers - and a valley's still things make none. Now 11743 KB at 200000 bodies and 8461 KB at the 98304 the game opens for (jolt_floor_test holds it under 16 MB). The temp heap still falls back to malloc for a step that wants more. lib/macos-arm64 rebuilt; lib/windows-x64 needs native/build.sh on the PC (jph_world_new's new sizes). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
61 lines
3.3 KiB
Text
61 lines
3.3 KiB
Text
# shapes.ludic - shapes: made in C, kept here, named by an int. A shape may be used by any number of
|
|
# bodies; phys_close (world.ludic) frees them all.
|
|
|
|
# a crate: half extents in metres
|
|
@creates(PhysShape)
|
|
export function phys_box(physics_st: mut PhysicsState, hx: float, hy: float, hz: float) -> int { return ph_keep(physics_st, jph_shape_box(hx, hy, hz)) }
|
|
@creates(PhysShape)
|
|
export function phys_sphere(physics_st: mut PhysicsState, r: float) -> int { return ph_keep(physics_st, jph_shape_sphere(r)) }
|
|
# a trunk or a body: upright, its straight part 2 * half_h tall, centred on its origin
|
|
@creates(PhysShape)
|
|
export function phys_capsule(physics_st: mut PhysicsState, half_h: float, r: float) -> int { return ph_keep(physics_st, jph_shape_capsule(half_h, r)) }
|
|
# a post: upright, 2 * half_h tall, centred on its origin
|
|
@creates(PhysShape)
|
|
export function phys_cylinder(physics_st: mut PhysicsState, half_h: float, r: float) -> int { return ph_keep(physics_st, jph_shape_cylinder(half_h, r)) }
|
|
# a boulder: a dome r across and h tall, standing on its origin
|
|
export function phys_dome(physics_st: mut PhysicsState, r: float, h: float) -> int { return ph_keep(physics_st, jph_shape_dome(r, h)) }
|
|
|
|
# a rock: the convex hull of n points (x, y, z) about its origin, its edges rounded by 2 cm
|
|
@creates(PhysShape)
|
|
export function phys_convex(physics_st: mut PhysicsState, v: []float, n: int) -> int {
|
|
if n < 4 or len(v) < n * 3 { return -1 }
|
|
return ph_keep(physics_st, jph_shape_convex(v, n, 0.02))
|
|
}
|
|
# another shape k times its size, so one hull serves every boulder of its shape
|
|
@creates(PhysShape)
|
|
export function phys_scaled(physics_st: mut PhysicsState, shape: int, k: float) -> int {
|
|
let s = ph_shape(physics_st, shape)
|
|
if s == null { return -1 }
|
|
return ph_keep(physics_st, jph_shape_scaled(s, k))
|
|
}
|
|
|
|
# another shape moved and turned about y inside its body (a post whose foot is its origin)
|
|
@creates(PhysShape)
|
|
export function phys_offset(physics_st: mut PhysicsState, shape: int, x: float, y: float, z: float, yaw: float) -> int {
|
|
let s = ph_shape(physics_st, shape)
|
|
if s == null { return -1 }
|
|
return ph_keep(physics_st, jph_shape_offset(s, x, y, z, yaw))
|
|
}
|
|
|
|
# n x n heights, row by row along z, the first at (ox, oz), cell metres apart; PHYS_HOLE is none
|
|
export const PHYS_HOLE: float = 340282346638528859811704183484516925440.0
|
|
@creates(PhysShape)
|
|
export function phys_heightfield(physics_st: mut PhysicsState, h: []float, n: int, ox: float, oz: float, cell: float) -> int {
|
|
if len(h) < n * n { return -1 }
|
|
return ph_keep(physics_st, jph_shape_heightfield(h, n, ox, oz, cell))
|
|
}
|
|
|
|
# the ground as a renderer draws a cubic B-spline height map: tex is n x n texels, the first
|
|
# texel's centre at (ox, oz), cell metres apart; the smoothing is done in C
|
|
@creates(PhysShape)
|
|
export function phys_heightfield_smooth(physics_st: mut PhysicsState, tex: []float, n: int, ox: float, oz: float, cell: float) -> int {
|
|
if len(tex) < n * n { return -1 }
|
|
return ph_keep(physics_st, jph_shape_heightfield_bspline(tex, n, ox, oz, cell))
|
|
}
|
|
|
|
# a dock or a cabin: v holds nv points (x, y, z), tri holds nt triangles (i, j, k)
|
|
@creates(PhysShape)
|
|
export function phys_mesh(physics_st: mut PhysicsState, v: []float, nv: int, tri: []int, nt: int) -> int {
|
|
if len(v) < nv * 3 or len(tri) < nt * 3 { return -1 }
|
|
return ph_keep(physics_st, jph_shape_mesh(v, nv, tri, nt))
|
|
}
|