Orkuncakilkaya
0c73287e35
fn(int, float) -> bool is a type, fn name is any top-level function's value, and a call through a local, a global, a record field, a slice element, a parameter or a result of a function type is an indirect call; two function types mix only when equal, a call checks its argument count, and a value may be null (examples/functions/values.ludic). Job.parallel_for keeps its worker check. render3d's scene is registered rather than required by name: r3d_on_draw, r3d_on_casters and r3d_on_stream_fill (hooks.ludic). The two rendering examples register theirs - and had defined scene_draw_casters with no parameter while the renderer passed one, which nothing checked. render3d declares numbers float itself; smooth.ludic is converted to floats and returns when r3d_init fails instead of running on into a segfault. Noise.* check their argument count (a call one short crashed the compiler). selfhost-build says why it failed. The migration tool reads a declared float as evidence. Seed regenerated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
88 lines
4 KiB
Text
88 lines
4 KiB
Text
# reload.ludic — the world replaced at run time.
|
|
#
|
|
# Generate a 2 km map, scatter onto it, give it colliders and water; release all of it and
|
|
# generate a 3 km map in its place with two water planes; then go back. Prints RELOAD OK when
|
|
# nothing of the previous map survived and the new one is whole.
|
|
#
|
|
# bin/ludic build examples/rendering/reload.ludic --headless && ./build/reload_headless
|
|
program Reload {
|
|
import "ludic.render3d/r3d.ludic"
|
|
|
|
property Marker { on: int = 1 }
|
|
model Anchor { Marker }
|
|
|
|
# A program only links the GL runtime render3d stands on when it names Gl.* itself
|
|
# (the parser's g_uses_gl), so even a check that draws nothing presents its frame.
|
|
# render3d calls back into the program for what stands on the terrain
|
|
function scene_draw() -> void { scatter_draw() }
|
|
function scene_draw_casters(light_vp: floats) -> void { scatter_draw_casters(light_vp) }
|
|
# no streamed cover here, but stream.ludic names the generator, so every program supplies one
|
|
function stream_fill(s: Stream, cx: int, cz: int, band: int) -> void { }
|
|
|
|
handler Present phase Render {
|
|
Gl.swap()
|
|
}
|
|
|
|
function check(what: string, cond: bool) -> bool {
|
|
if not cond { print(`reload: FAILED - {what}`) }
|
|
return cond
|
|
}
|
|
function populate() -> void {
|
|
let l = layer_cards(model_cross_card(), 1000, F_ZERO, fi(400))
|
|
for i in 0 .. 400 {
|
|
let x = fi(i * 2 - 400)
|
|
layer_add(l, x, terrain_height(x, fi(30)), fi(30), F_ONE, F_ZERO, F_ZERO, F_ZERO)
|
|
col_add(x, fi(30), F_ONE)
|
|
}
|
|
col_build()
|
|
}
|
|
|
|
handler Boot phase Start {
|
|
spawn Anchor {}
|
|
r3d_on_draw(fn scene_draw)
|
|
r3d_on_casters(fn scene_draw_casters)
|
|
r3d_on_stream_fill(fn stream_fill)
|
|
TERRAIN_HALF = 1000
|
|
ter_smooth = true
|
|
if not r3d_init(640, 360, "Reload") {
|
|
quit()
|
|
return
|
|
}
|
|
cam_set(F_ZERO, fi(80), fi(300), fi(180), f_neg(fi(10)))
|
|
water_init(fl(4.0), F_ZERO, F_ZERO, fi(200), fi(200))
|
|
populate()
|
|
var ok = true
|
|
ok = check("the first map has layers and colliders", len(sc_layers) == 1 and col_n == 400) and ok
|
|
# --- swap to a 3 km map with a sea and a lake above it
|
|
scatter_clear_all()
|
|
actor_clear_all()
|
|
col_reset()
|
|
water_bodies_clear()
|
|
terrain_lake(F_ZERO, F_ZERO, F_ZERO, F_ZERO, F_ZERO)
|
|
terrain_reload("", F_ZERO, F_ZERO, F_ZERO, F_ZERO, F_ZERO, "", 1500)
|
|
ok = check("everything of the first map released", len(sc_layers) == 0 and col_n == 0 and wb_n == 0 and not water_on) and ok
|
|
ok = check("the new half", TERRAIN_HALF == 1500 and ter_heights != null and ter_height_tex != 0) and ok
|
|
ok = check("patch bounds rebuilt", cd_min != null and len(cd_min) == CD_LEVELS) and ok
|
|
ok = check("patches scale with the map", cd_size(0) == f_mul(fi(32), fr(3000, 8192))) and ok
|
|
terrain_height(F_ZERO, F_ZERO)
|
|
ok = check("the cached height scale is the new map's", ter_h_scale == fr(TERRAIN_RES, 3000)) and ok
|
|
let sea = water_body_add(F_ZERO, F_ZERO, F_ZERO, fi(20000), fi(20000), true)
|
|
let lake = water_body_add(fl(12.0), fi(600), fi(-400), fi(150), fi(100), false)
|
|
ok = check("two water bodies, the sea mirrored", sea == 0 and lake == 1 and wb_n == 2 and wb_primary == 0 and water_level == F_ZERO and water_on) and ok
|
|
populate()
|
|
ok = check("the new map takes layers and colliders", len(sc_layers) == 1 and col_n == 400 and col_side == 3000 / COL_CELL) and ok
|
|
# a sea below the carved lake: set once, and not undone by a reload
|
|
terrain_sea(fl(-2.0))
|
|
terrain_lake(fl(12.0), fi(600), fi(-400), fi(150), fi(100))
|
|
ok = check("the sea is its own level", ter_sea_set and ter_sea_gen() == fl(-2.0) and ter_lake_level == fl(12.0)) and ok
|
|
# --- and back: the swap is repeatable
|
|
scatter_clear_all()
|
|
col_reset()
|
|
water_init(fl(4.0), F_ZERO, F_ZERO, fi(200), fi(200))
|
|
terrain_reload("", F_ZERO, F_ZERO, F_ZERO, F_ZERO, F_ZERO, "", 1000)
|
|
populate()
|
|
ok = check("back to 2 km", TERRAIN_HALF == 1000 and len(cd_min) == CD_LEVELS and wb_n == 1 and col_side == 2000 / COL_CELL) and ok
|
|
if ok { print("RELOAD OK") } else { print("RELOAD FAILED") }
|
|
quit()
|
|
}
|
|
}
|