Orkuncakilkaya
f25289db20
`Gl.*` binds the whole OpenGL 4.1 core API — every entry point of the platform gl3.h with every GL_* constant, generated by `ludic-dev glgen` with per-call ABI thunks. Windowed builds get an NSOpenGLContext on the existing window at Retina resolution; headless builds render into an offscreen CGL context, so a program that uses Gl.* renders and screenshots identically under the test harness. It links gl.ll, the thunks and OpenGL.framework only when used; every other build stays byte-identical. packages/ludic.render3d is a physically based renderer written on that surface: HDRI image-based lighting, GPU-generated terrain with scanned PBR materials, CDLOD, cascaded shadows, glTF with skinning, instanced vegetation with impostors, procedural grass, water, SSAO, and an HDR pipeline with bloom, auto-exposure and ACES. It also carries this session's work on it: the terrain at half its cost (10.3 -> 5.4 ms of frame), the streaming hitch that got worse the longer you played, a resize that emptied the world, and the packaging that lets a game use the renderer from its own repository — `ludic assets`, the material manifest shipping with the package, and shader lookup falling back to the install root. See changes/ for each, with its numbers. The camping game that drove all of it has moved out to its own repository, Maroon Lake; examples/rendering/smooth.ludic stays as the renderer's example here. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
82 lines
3.8 KiB
Text
82 lines
3.8 KiB
Text
# build.ludic — turning a .ludic file into an executable.
|
|
#
|
|
# compile_app is the one place that happens, shared by `ludic build` / `ludic
|
|
# run` and by the contributor tool, so a user's build and the repo's own example
|
|
# builds cannot drift apart. Everything the toolchain owns — the compiler, the
|
|
# engine runtime it splices — is addressed through ludic_home(), so the same code
|
|
# path works from a checkout and from an installed ~/.ludic.
|
|
|
|
# ensure bin/ludicc exists and is current with the seed. Built from the checked-in
|
|
# IR seed with clang alone — no C compiler is ever involved.
|
|
function ensure_ludicc() -> void {
|
|
if not in_toolchain_repo() { return }
|
|
run("mkdir -p bin build")
|
|
if (not is_exec("bin/ludicc")) or newer("selfhost/ludicc.seed.ll", "bin/ludicc") {
|
|
print("cc: selfhost/ludicc.seed.ll -> bin/ludicc (from the IR seed, no C compiler)")
|
|
if not shq(`{cc()} selfhost/ludicc.seed.ll -o bin/ludicc`) {
|
|
err("ludic: could not assemble the seed\n"); exit(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
# ---- compiling one program to a native binary -------------------------------
|
|
#
|
|
# mode 1 = windowed (a game opens a real window), 2 = headless (the last frame is
|
|
# rendered to build/out.ppm from piped input — deterministic output for tests).
|
|
# Returns true on success. `ludic build`, `ludic run` and the contributor tool all
|
|
# go through here.
|
|
function compile_app(src: pointer, out: pointer, mode: int, save: bool) -> bool {
|
|
ensure_ludicc() # in a checkout: assemble the seed if bin/ludicc is missing or stale
|
|
let home = ludic_home()
|
|
let pbf = prebuilt_link_flags() # #64: link resolved prebuilt module dylibs, if any
|
|
let odir = dir_of_path(out)
|
|
if len(odir) > 0 { run(`mkdir -p {odir}`) }
|
|
run("mkdir -p build")
|
|
let ll = `{out}.ll`
|
|
|
|
if mode == 2 {
|
|
if not shq(`{ludicc()} --headless {src} --emit-llvm -o {ll}`) { return false }
|
|
if not shq(`{cc()} -O2 {ll}{gl_link_flags(ll)}{pbf} -o {out}`) { return false }
|
|
if not save { run(`rm -f {ll}`) }
|
|
return true
|
|
}
|
|
|
|
if not shq(`{ludicc()} --windowed {src} --emit-llvm -o {ll}`) { return false }
|
|
# audio.ll (#22) is always linked here — unused snd_* are dead-stripped; the
|
|
# canonical `ludicc -o` path links it only when Audio.* is used.
|
|
let cocoa = `{home}runtime/native/cocoa.ll`
|
|
let audio = `{home}runtime/native/audio.ll`
|
|
if not shq(`{cc()} -O2 {ll} {cocoa} {audio} -framework Cocoa -Wl,-needed_framework,GameController -Wl,-needed_framework,AVFoundation -Wl,-rpath,@loader_path{gl_link_flags(ll)}{pbf} -o {out}`) { return false }
|
|
if not save { run(`rm -f {ll}`) }
|
|
return true
|
|
}
|
|
|
|
# A program that uses Gl.* references the @lgl_* thunks; link the OpenGL backend
|
|
# (gl.ll + gl_thunks.ll + OpenGL.framework) only then, so other builds are untouched.
|
|
function gl_link_flags(ll: pointer) -> pointer {
|
|
if not shq(`grep -q "@lgl_" {ll}`) { return "" }
|
|
let home = ludic_home()
|
|
return ` {home}runtime/native/gl.ll {home}runtime/native/gl_thunks.ll -framework OpenGL`
|
|
}
|
|
|
|
# the directory part of a path, without the trailing '/' ("" when there is none)
|
|
function dir_of_path(p: pointer) -> pointer {
|
|
var last = -1
|
|
var i = 0
|
|
while p[i] != 0 { if p[i] == '/' { last = i }; i += 1 }
|
|
if last < 0 { return "" }
|
|
return p[0..last]
|
|
}
|
|
|
|
# Remove every generated artifact and leave the tracked source untouched: the
|
|
# whole build/ tree (IR, objects, compiled apps, the headless render at
|
|
# build/out.ppm), and any stray *.tmp/*.ll left behind by a failed build. A
|
|
# legacy out.ppm in the root (from an older toolchain) is swept too. Binaries in
|
|
# bin/ are kept so the running CLI survives; in the toolchain repo, rebuild them
|
|
# any time with `ludic-dev build`.
|
|
function cmd_clean() -> int {
|
|
run("rm -rf build")
|
|
run("rm -f out.ppm bin/*.tmp")
|
|
print("cleaned: build/ (incl. build/out.ppm) and stray artifacts (bin/ is left alone)")
|
|
return 0
|
|
}
|