feat(gl): OpenGL 4.1 and the ludic.render3d renderer
`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>
This commit is contained in:
parent
470971bf70
commit
f25289db20
90 changed files with 35316 additions and 19853 deletions
542
tools/ludic-cli/glgen.ludic
Normal file
542
tools/ludic-cli/glgen.ludic
Normal file
|
|
@ -0,0 +1,542 @@
|
|||
# glgen.ludic — the OpenGL binding generator, in Ludic (ported off glgen.py, the
|
||||
# same way docgen.ludic was ported off gen.py). One x subcommand:
|
||||
#
|
||||
# ludic-dev glgen [--check] read the platform gl3.h and emit
|
||||
# runtime/native/gl_api.ludic + runtime/native/gl_thunks.ll;
|
||||
# --check regenerates into scratch files and compares,
|
||||
# so the drift guard judges the working tree.
|
||||
#
|
||||
# Both outputs are tracked, so a build never runs this: it is the tool you run
|
||||
# when the SDK's gl3.h changes. Output is byte-identical to the Python generator
|
||||
# it replaces (verified by the drift guard in `ludic-dev test`).
|
||||
|
||||
# ---- parsed constants -------------------------------------------------------
|
||||
var glg_cname: []pointer = null # GL_DEPTH_BUFFER_BIT
|
||||
var glg_ctype: []pointer = null # "int" | "long"
|
||||
var glg_cval: []pointer = null # the literal as it is emitted
|
||||
|
||||
# ---- parsed entry points ----------------------------------------------------
|
||||
# Parallel arrays; the params of function f are the pcount[f] entries of the flat
|
||||
# pp_* arrays starting at poff[f]. Flat arrays keep this free of nested slices.
|
||||
var glg_fname: []pointer = null # "CullFace" (the gl prefix already stripped)
|
||||
var glg_frbase: []pointer = null # return base type ("void", "GLuint", …)
|
||||
var glg_frstar: []int = null # return pointer depth
|
||||
var glg_fpoff: []int = null
|
||||
var glg_fpcnt: []int = null
|
||||
var glg_ppbase: []pointer = null
|
||||
var glg_ppstar: []int = null
|
||||
var glg_ppname: []pointer = null
|
||||
|
||||
# ---- character helpers ------------------------------------------------------
|
||||
function glg_upper(c: int) -> bool { return c >= 'A' and c <= 'Z' }
|
||||
function glg_lower(c: int) -> bool { return c >= 'a' and c <= 'z' }
|
||||
function glg_digit(c: int) -> bool { return c >= '0' and c <= '9' }
|
||||
function glg_hexdig(c: int) -> bool {
|
||||
return glg_digit(c) or (c >= 'a' and c <= 'f') or (c >= 'A' and c <= 'F')
|
||||
}
|
||||
# a GL_* macro name character
|
||||
function glg_namech(c: int) -> bool { return glg_upper(c) or glg_digit(c) or c == '_' }
|
||||
|
||||
# a fresh NUL-terminated copy of s[a..b)
|
||||
|
||||
# CamelCase -> snake_case, exactly as glgen.py's snake(): an underscore goes in
|
||||
# before an upper-case letter that follows a lower-case one, nowhere else.
|
||||
function glg_snake(n: pointer) -> pointer {
|
||||
let b = sb_new()
|
||||
let m = slen(n)
|
||||
var i = 0
|
||||
while i < m {
|
||||
let c = n[i]
|
||||
if glg_upper(c) and i > 0 and glg_lower(n[i - 1]) { sb_putc(b, '_') }
|
||||
if glg_upper(c) { sb_putc(b, c + 32) } else { sb_putc(b, c) }
|
||||
i += 1
|
||||
}
|
||||
return sb_str(b)
|
||||
}
|
||||
|
||||
# ---- the type tables (glgen.py's INT / LONG / FLT / DBL) --------------------
|
||||
# Membership in a space-delimited list, matched as whole tokens — one line per
|
||||
# table instead of a chain of `or`s that a newline would cut in half.
|
||||
function glg_in(t: pointer, set: pointer) -> bool {
|
||||
let n = slen(set)
|
||||
var p = 0
|
||||
while p <= n {
|
||||
var q = p
|
||||
while q < n and set[q] != 32 { q += 1 }
|
||||
if str_sub(set, p, q) == t { return true }
|
||||
if q >= n { break }
|
||||
p = q + 1
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
function glg_is_int(t: pointer) -> bool {
|
||||
return glg_in(t, "GLenum GLuint GLint GLsizei GLbitfield GLshort GLushort GLbyte GLubyte GLhalf GLchar GLboolean GLfixed")
|
||||
}
|
||||
function glg_is_long(t: pointer) -> bool {
|
||||
return glg_in(t, "GLsizeiptr GLintptr GLint64 GLuint64 GLint64EXT GLuint64EXT")
|
||||
}
|
||||
function glg_is_flt(t: pointer) -> bool { return glg_in(t, "GLfloat GLclampf") }
|
||||
function glg_is_dbl(t: pointer) -> bool { return glg_in(t, "GLdouble GLclampd") }
|
||||
|
||||
# the LLVM type a C parameter of this shape has
|
||||
function glg_ir_ty(base: pointer, star: int) -> pointer {
|
||||
if star > 0 { return "ptr" }
|
||||
if base == "GLboolean" { return "i8" }
|
||||
if base == "GLbyte" or base == "GLubyte" or base == "GLchar" { return "i8" }
|
||||
if base == "GLshort" or base == "GLushort" or base == "GLhalf" { return "i16" }
|
||||
if glg_is_int(base) { return "i32" }
|
||||
if glg_is_long(base) { return "i64" }
|
||||
if glg_is_flt(base) { return "float" }
|
||||
if glg_is_dbl(base) { return "double" }
|
||||
if base == "GLsync" { return "ptr" }
|
||||
if base == "void" { return "void" }
|
||||
return null
|
||||
}
|
||||
|
||||
# the Ludic type it is bound as
|
||||
function glg_ludic_ty(base: pointer, star: int) -> pointer {
|
||||
if star > 0 or base == "GLsync" { return "pointer" }
|
||||
if glg_is_int(base) { return "int" }
|
||||
if glg_is_long(base) { return "long" }
|
||||
if glg_is_flt(base) or glg_is_dbl(base) { return "fixed" }
|
||||
if base == "void" { return "void" }
|
||||
return null
|
||||
}
|
||||
|
||||
# the Ludic ABI type carrying an LLVM type across the extern boundary
|
||||
function glg_abi_ty(ct: pointer) -> pointer {
|
||||
if ct == "i64" { return "i64" }
|
||||
if ct == "ptr" { return "ptr" }
|
||||
if ct == "void" { return "void" }
|
||||
return "i32"
|
||||
}
|
||||
|
||||
# ---- parameter names --------------------------------------------------------
|
||||
# A Ludic keyword or type name cannot label a parameter. glVertexAttribPointer's
|
||||
# `pointer` is a byte offset, so it says so rather than wearing a trailing _.
|
||||
function glg_reserved(n: pointer) -> bool {
|
||||
if glg_in(n, "program import property model enum ui namespace const var function extern handler entry") { return true }
|
||||
if glg_in(n, "event scene test phase query on cancellable public layer start") { return true }
|
||||
if glg_in(n, "let return if else while for in spawn despawn enable disable match machine state become where prefab") { return true }
|
||||
if glg_in(n, "and or not break continue new emit cancel try") { return true }
|
||||
if glg_in(n, "int long fixed countdown bool entity string pointer byte words fixeds pointers") { return true }
|
||||
if glg_in(n, "Vector IVec2 Rect void true false null") { return true }
|
||||
return false
|
||||
}
|
||||
function glg_pname(raw: pointer, i: int) -> pointer {
|
||||
var n = raw
|
||||
if slen(n) == 0 { n = `a{string(i)}` }
|
||||
n = glg_snake(n)
|
||||
if n == "pointer" { return "offset" }
|
||||
if n == "program" { return "prog" }
|
||||
if n == "start" { return "first" }
|
||||
if n == "string" { return "text" }
|
||||
if n == "layer" { return "level" }
|
||||
if glg_reserved(n) { return n + "_" }
|
||||
return n
|
||||
}
|
||||
|
||||
# ---- one C declarator -> (base, star, name) ---------------------------------
|
||||
# glgen.py's ctype_of: count the stars, drop every `const`, split what is left.
|
||||
# Sets glg_t_base / glg_t_star / glg_t_name (Ludic has no tuple return).
|
||||
var glg_t_base: pointer = null
|
||||
var glg_t_star: int = 0
|
||||
var glg_t_name: pointer = null
|
||||
|
||||
function glg_ctype_of(decl: pointer) -> void {
|
||||
let m = slen(decl)
|
||||
var star = 0
|
||||
var i = 0
|
||||
while i < m {
|
||||
if decl[i] == '*' { star += 1 }
|
||||
i += 1
|
||||
}
|
||||
# drop `const` (whole words) and turn '*' into a separator
|
||||
let b = sb_new()
|
||||
i = 0
|
||||
while i < m {
|
||||
if decl[i] == 'c' and i + 5 <= m and str_sub(decl, i, i + 5) == "const" {
|
||||
i += 5
|
||||
sb_putc(b, 32)
|
||||
} else {
|
||||
if decl[i] == '*' { sb_putc(b, 32) } else { sb_putc(b, decl[i]) }
|
||||
i += 1
|
||||
}
|
||||
}
|
||||
let flat = sb_str(b)
|
||||
# split on whitespace
|
||||
let parts = new []pointer
|
||||
let fn = slen(flat)
|
||||
var p = 0
|
||||
while p < fn {
|
||||
while p < fn and str_space(flat[p]) { p += 1 }
|
||||
if p >= fn { break }
|
||||
var q = p
|
||||
while q < fn and not str_space(flat[q]) { q += 1 }
|
||||
push(parts, str_sub(flat, p, q))
|
||||
p = q
|
||||
}
|
||||
glg_t_star = star
|
||||
if len(parts) == 0 { glg_t_base = ""; glg_t_name = ""; return }
|
||||
glg_t_base = parts[0]
|
||||
if len(parts) > 1 { glg_t_name = parts[1] } else { glg_t_name = "" }
|
||||
}
|
||||
|
||||
# ---- constants --------------------------------------------------------------
|
||||
# `#define GL_NAME <0xHEX|-?DEC>[u|U|ull|ULL]` and nothing else on the line —
|
||||
# the shape glgen.py's regex accepted. Returns false when the line is not one.
|
||||
var glg_v_hex: bool = false
|
||||
var glg_v_digits: pointer = null # the numeric text, suffix stripped
|
||||
var glg_v_neg: bool = false
|
||||
|
||||
function glg_num_of(tok: pointer) -> bool {
|
||||
let n = slen(tok)
|
||||
var i = 0
|
||||
glg_v_neg = false
|
||||
glg_v_hex = false
|
||||
if i < n and tok[i] == '-' { glg_v_neg = true; i += 1 }
|
||||
let numstart = i
|
||||
if i + 1 < n and tok[i] == '0' and tok[i + 1] == 'x' {
|
||||
if glg_v_neg { return false }
|
||||
glg_v_hex = true
|
||||
i += 2
|
||||
let ds = i
|
||||
while i < n and glg_hexdig(tok[i]) { i += 1 }
|
||||
if i == ds { return false }
|
||||
} else {
|
||||
let ds = i
|
||||
while i < n and glg_digit(tok[i]) { i += 1 }
|
||||
if i == ds { return false }
|
||||
}
|
||||
glg_v_digits = str_sub(tok, numstart, i)
|
||||
# what is left must be one of the accepted integer suffixes
|
||||
let suf = str_sub(tok, i, n)
|
||||
if suf == "" or suf == "u" or suf == "U" or suf == "ull" or suf == "ULL" { return true }
|
||||
return false
|
||||
}
|
||||
|
||||
# accumulate hex digits into an i32: the wrap makes an 8-digit value with the top
|
||||
# bit set come out as the signed integer with those exact bits (glgen.py's v - 2^32).
|
||||
function glg_hex_i32(h: pointer) -> int {
|
||||
var v = 0
|
||||
var i = 0
|
||||
while i < slen(h) {
|
||||
let c = h[i]
|
||||
var d = 0
|
||||
if glg_digit(c) { d = c - '0' }
|
||||
if c >= 'a' and c <= 'f' { d = c - 'a' + 10 }
|
||||
if c >= 'A' and c <= 'F' { d = c - 'A' + 10 }
|
||||
v = v * 16 + d
|
||||
i += 1
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
function glg_parse_define(line: pointer) -> void {
|
||||
let n = slen(line)
|
||||
if n < 8 { return }
|
||||
if str_sub(line, 0, 8) != "#define " { return }
|
||||
var i = 8
|
||||
while i < n and str_space(line[i]) { i += 1 }
|
||||
let ns = i
|
||||
while i < n and glg_namech(line[i]) { i += 1 }
|
||||
let name = str_sub(line, ns, i)
|
||||
if slen(name) < 4 { return }
|
||||
if str_sub(name, 0, 3) != "GL_" { return }
|
||||
# the name must be followed by whitespace (not '(' — that is a macro)
|
||||
if i >= n or not str_space(line[i]) { return }
|
||||
while i < n and str_space(line[i]) { i += 1 }
|
||||
let vs = i
|
||||
while i < n and not str_space(line[i]) { i += 1 }
|
||||
let tok = str_sub(line, vs, i)
|
||||
# trailing whitespace only
|
||||
while i < n and str_space(line[i]) { i += 1 }
|
||||
if i != n { return }
|
||||
if slen(tok) == 0 { return }
|
||||
# glgen.py skips the GL_VERSION_* feature macros and any repeated name
|
||||
if slen(name) >= 11 and str_sub(name, 0, 11) == "GL_VERSION_" { return }
|
||||
var k = 0
|
||||
while k < len(glg_cname) {
|
||||
if glg_cname[k] == name { return }
|
||||
k += 1
|
||||
}
|
||||
if not glg_num_of(tok) { return }
|
||||
|
||||
# classify the width exactly as glgen.py did, but by digit count so a 64-bit
|
||||
# all-ones literal never has to be parsed into a signed 64-bit register.
|
||||
if glg_v_hex {
|
||||
var d = glg_v_digits
|
||||
var h = str_sub(d, 2, slen(d)) # drop the 0x
|
||||
var z = 0
|
||||
while z < slen(h) - 1 and h[z] == '0' { z += 1 }
|
||||
h = str_sub(h, z, slen(h))
|
||||
let hn = slen(h)
|
||||
if hn > 8 {
|
||||
push(glg_cname, name); push(glg_ctype, "long"); push(glg_cval, "-1")
|
||||
return
|
||||
}
|
||||
if hn == 8 and not (h[0] >= '0' and h[0] <= '7') {
|
||||
# 0x8… — the same bits as a negative i32; emit the signed decimal
|
||||
let v = glg_hex_i32(h)
|
||||
push(glg_cname, name); push(glg_ctype, "int"); push(glg_cval, string(v))
|
||||
return
|
||||
}
|
||||
push(glg_cname, name); push(glg_ctype, "int"); push(glg_cval, glg_v_digits)
|
||||
return
|
||||
}
|
||||
var lit = glg_v_digits
|
||||
if glg_v_neg { lit = "-" + lit }
|
||||
push(glg_cname, name); push(glg_ctype, "int"); push(glg_cval, lit)
|
||||
}
|
||||
|
||||
# ---- entry points -----------------------------------------------------------
|
||||
# `GLAPI <ret> APIENTRY gl<Name> (<args>) …;` — every gl3.h declaration is on one
|
||||
# line, so a line scan matches what glgen.py's re.M regex did.
|
||||
function glg_parse_glapi(line: pointer) -> void {
|
||||
let n = slen(line)
|
||||
if n < 6 { return }
|
||||
if str_sub(line, 0, 6) != "GLAPI " { return }
|
||||
let ap = Text.index_of(line, " APIENTRY ")
|
||||
if ap < 0 { return }
|
||||
let ret = Text.trim(str_sub(line, 6, ap))
|
||||
var i = ap + 10
|
||||
while i < n and str_space(line[i]) { i += 1 }
|
||||
let ns = i
|
||||
while i < n and (glg_upper(line[i]) or glg_lower(line[i]) or glg_digit(line[i]) or line[i] == '_') { i += 1 }
|
||||
let fname = str_sub(line, ns, i)
|
||||
if slen(fname) < 3 { return }
|
||||
if str_sub(fname, 0, 2) != "gl" { return }
|
||||
while i < n and str_space(line[i]) { i += 1 }
|
||||
if i >= n or line[i] != '(' { return }
|
||||
let argstart = i + 1
|
||||
var depth = 1
|
||||
i += 1
|
||||
while i < n and depth > 0 {
|
||||
if line[i] == '(' { depth += 1 }
|
||||
if line[i] == ')' { depth -= 1 }
|
||||
if depth == 0 { break }
|
||||
i += 1
|
||||
}
|
||||
if depth != 0 { return }
|
||||
let args = str_sub(line, argstart, i)
|
||||
let bare = str_sub(fname, 2, slen(fname))
|
||||
var k = 0
|
||||
while k < len(glg_fname) {
|
||||
if glg_fname[k] == bare { return }
|
||||
k += 1
|
||||
}
|
||||
|
||||
glg_ctype_of(ret)
|
||||
let rbase = glg_t_base
|
||||
let rstar = glg_t_star
|
||||
|
||||
let poff = len(glg_ppbase)
|
||||
var pcnt = 0
|
||||
let at = Text.trim(args)
|
||||
if at != "void" and at != "" {
|
||||
# split the argument list on commas (no function-pointer args in gl3.h)
|
||||
let an = slen(args)
|
||||
var p = 0
|
||||
while p <= an {
|
||||
var q = p
|
||||
while q < an and args[q] != ',' { q += 1 }
|
||||
let one = str_sub(args, p, q)
|
||||
glg_ctype_of(one)
|
||||
push(glg_ppbase, glg_t_base)
|
||||
push(glg_ppstar, glg_t_star)
|
||||
push(glg_ppname, glg_t_name)
|
||||
pcnt += 1
|
||||
if q >= an { break }
|
||||
p = q + 1
|
||||
}
|
||||
}
|
||||
push(glg_fname, bare)
|
||||
push(glg_frbase, rbase)
|
||||
push(glg_frstar, rstar)
|
||||
push(glg_fpoff, poff)
|
||||
push(glg_fpcnt, pcnt)
|
||||
}
|
||||
|
||||
function glg_parse(h: pointer) -> void {
|
||||
glg_cname = new []pointer; glg_ctype = new []pointer; glg_cval = new []pointer
|
||||
glg_fname = new []pointer; glg_frbase = new []pointer; glg_frstar = new []int
|
||||
glg_fpoff = new []int; glg_fpcnt = new []int
|
||||
glg_ppbase = new []pointer; glg_ppstar = new []int; glg_ppname = new []pointer
|
||||
let n = slen(h)
|
||||
var i = 0
|
||||
while i < n {
|
||||
var j = i
|
||||
while j < n and h[j] != 10 { j += 1 }
|
||||
let line = str_sub(h, i, j)
|
||||
if slen(line) > 0 {
|
||||
if line[0] == '#' { glg_parse_define(line) }
|
||||
if line[0] == 'G' { glg_parse_glapi(line) }
|
||||
}
|
||||
i = j + 1
|
||||
}
|
||||
}
|
||||
|
||||
# ---- emit gl_api.ludic ------------------------------------------------------
|
||||
function glg_emit_ludic(path: pointer) -> bool {
|
||||
let b = sb_new()
|
||||
sb_puts(b, "# ============================================================================\n")
|
||||
sb_puts(b, "# gl_api.ludic — the OpenGL 4.1 core API, bound for Ludic. GENERATED by\n")
|
||||
sb_puts(b, "# `ludic-dev glgen` from the platform gl3.h: every entry point and every GL_* constant.\n")
|
||||
sb_puts(b, "# Do not edit by hand; regenerate. float/double parameters take `fixed`; the IR\n")
|
||||
sb_puts(b, "# thunks in runtime/native/gl.ll (also generated) convert at the C boundary.\n")
|
||||
sb_puts(b, "# ============================================================================\n")
|
||||
sb_puts(b, "\n")
|
||||
var i = 0
|
||||
while i < len(glg_cname) {
|
||||
sb_puts(b, `const {glg_cname[i]}: {glg_ctype[i]} = {glg_cval[i]}\n`)
|
||||
i += 1
|
||||
}
|
||||
sb_puts(b, "\n")
|
||||
i = 0
|
||||
while i < len(glg_fname) {
|
||||
let lname = "gl_" + glg_snake(glg_fname[i])
|
||||
let ps = sb_new()
|
||||
var p = 0
|
||||
while p < glg_fpcnt[i] {
|
||||
let ix = glg_fpoff[i] + p
|
||||
if p > 0 { sb_puts(ps, ", ") }
|
||||
let lt = glg_ludic_ty(glg_ppbase[ix], glg_ppstar[ix])
|
||||
sb_puts(ps, `{glg_pname(glg_ppname[ix], p)}: {lt}`)
|
||||
p += 1
|
||||
}
|
||||
let rt = glg_ludic_ty(glg_frbase[i], glg_frstar[i])
|
||||
var rets = ""
|
||||
if rt != "void" { rets = " -> " + rt }
|
||||
sb_puts(b, `extern function {lname}({sb_str(ps)}){rets} = "lgl_{glg_fname[i]}"\n`)
|
||||
i += 1
|
||||
}
|
||||
return write_file(path, sb_str(b))
|
||||
}
|
||||
|
||||
# ---- emit gl_thunks.ll ------------------------------------------------------
|
||||
function glg_emit_thunks(path: pointer) -> bool {
|
||||
let b = sb_new()
|
||||
sb_puts(b, "; ============================================================================\n")
|
||||
sb_puts(b, "; gl_thunks.ll — one thunk per OpenGL 4.1 core entry point. GENERATED by\n")
|
||||
sb_puts(b, "; `ludic-dev glgen` from gl3.h. Each @lgl_* takes the Ludic ABI (i32 / i64 / ptr,\n")
|
||||
sb_puts(b, "; float and double as Q16.16 fixed) and calls the real gl* with exact C types.\n")
|
||||
sb_puts(b, "; ============================================================================\n")
|
||||
sb_puts(b, "\n")
|
||||
var i = 0
|
||||
while i < len(glg_fname) {
|
||||
let cret = glg_ir_ty(glg_frbase[i], glg_frstar[i])
|
||||
let ps = sb_new()
|
||||
var p = 0
|
||||
while p < glg_fpcnt[i] {
|
||||
let ix = glg_fpoff[i] + p
|
||||
if p > 0 { sb_puts(ps, ", ") }
|
||||
sb_puts(ps, glg_ir_ty(glg_ppbase[ix], glg_ppstar[ix]))
|
||||
p += 1
|
||||
}
|
||||
sb_puts(b, `declare {cret} @gl{glg_fname[i]}({sb_str(ps)})\n`)
|
||||
i += 1
|
||||
}
|
||||
sb_puts(b, "\n")
|
||||
i = 0
|
||||
while i < len(glg_fname) {
|
||||
let cret = glg_ir_ty(glg_frbase[i], glg_frstar[i])
|
||||
let lret = glg_abi_ty(cret)
|
||||
let sig = sb_new()
|
||||
let body = sb_new()
|
||||
let call = sb_new()
|
||||
var p = 0
|
||||
while p < glg_fpcnt[i] {
|
||||
let ix = glg_fpoff[i] + p
|
||||
let ct = glg_ir_ty(glg_ppbase[ix], glg_ppstar[ix])
|
||||
let lt = glg_abi_ty(ct)
|
||||
if p > 0 { sb_puts(sig, ", "); sb_puts(call, ", ") }
|
||||
sb_puts(sig, `{lt} %a{string(p)}`)
|
||||
if ct == lt {
|
||||
sb_puts(call, `{ct} %a{string(p)}`)
|
||||
} else {
|
||||
if ct == "i8" or ct == "i16" {
|
||||
sb_puts(body, ` %c{string(p)} = trunc i32 %a{string(p)} to {ct}\n`)
|
||||
sb_puts(call, `{ct} %c{string(p)}`)
|
||||
} else {
|
||||
# float / double: the Ludic side passes Q16.16, so scale by 1/65536
|
||||
sb_puts(body, ` %f{string(p)} = sitofp i32 %a{string(p)} to {ct}\n`)
|
||||
sb_puts(body, ` %c{string(p)} = fmul {ct} %f{string(p)}, 0x3EF0000000000000\n`)
|
||||
sb_puts(call, `{ct} %c{string(p)}`)
|
||||
}
|
||||
}
|
||||
p += 1
|
||||
}
|
||||
sb_puts(b, `define {lret} @lgl_{glg_fname[i]}({sb_str(sig)}) `)
|
||||
sb_puts(b, "{\n")
|
||||
sb_puts(b, "entry:\n")
|
||||
sb_puts(b, sb_str(body))
|
||||
let invoke = `call {cret} @gl{glg_fname[i]}({sb_str(call)})`
|
||||
if cret == "void" {
|
||||
sb_puts(b, ` {invoke}\n`)
|
||||
sb_puts(b, " ret void\n")
|
||||
} else {
|
||||
if cret == lret {
|
||||
sb_puts(b, ` %r = {invoke}\n`)
|
||||
sb_puts(b, ` ret {lret} %r\n`)
|
||||
} else {
|
||||
if cret == "i8" or cret == "i16" {
|
||||
sb_puts(b, ` %r = {invoke}\n`)
|
||||
sb_puts(b, ` %z = zext {cret} %r to i32\n`)
|
||||
sb_puts(b, " ret i32 %z\n")
|
||||
} else {
|
||||
sb_puts(b, ` %r = {invoke}\n`)
|
||||
sb_puts(b, ` %m = fmul {cret} %r, 65536.0\n`)
|
||||
sb_puts(b, ` %z = fptosi {cret} %m to i32\n`)
|
||||
sb_puts(b, " ret i32 %z\n")
|
||||
}
|
||||
}
|
||||
}
|
||||
sb_puts(b, "}\n")
|
||||
i += 1
|
||||
}
|
||||
return write_file(path, sb_str(b))
|
||||
}
|
||||
|
||||
# ---- the task ---------------------------------------------------------------
|
||||
# `ludic-dev glgen` rewrites the two tracked outputs; `--check` regenerates into
|
||||
# scratch files and compares, so the guard judges the working tree, not git HEAD.
|
||||
function cmd_glgen() -> int {
|
||||
let check = arg_count() > 2 and arg(2) == "--check"
|
||||
let sdk = Text.trim(capture("xcrun --show-sdk-path"))
|
||||
if sdk == "" { err("glgen: no macOS SDK (xcrun --show-sdk-path)\n"); return 1 }
|
||||
let hpath = `{sdk}/System/Library/Frameworks/OpenGL.framework/Headers/gl3.h`
|
||||
let h = read_file(hpath)
|
||||
if h == null { err(`glgen: cannot read {hpath}\n`); return 1 }
|
||||
glg_parse(h)
|
||||
if len(glg_fname) == 0 { err("glgen: no GLAPI declarations found\n"); return 1 }
|
||||
|
||||
# every type in the header must be one this generator knows how to bind
|
||||
var i = 0
|
||||
while i < len(glg_fname) {
|
||||
if glg_ir_ty(glg_frbase[i], glg_frstar[i]) == null or glg_ludic_ty(glg_frbase[i], glg_frstar[i]) == null {
|
||||
err(`glgen: unknown return type {glg_frbase[i]} on gl{glg_fname[i]}\n`); return 1
|
||||
}
|
||||
var p = 0
|
||||
while p < glg_fpcnt[i] {
|
||||
let ix = glg_fpoff[i] + p
|
||||
if glg_ir_ty(glg_ppbase[ix], glg_ppstar[ix]) == null or glg_ludic_ty(glg_ppbase[ix], glg_ppstar[ix]) == null {
|
||||
err(`glgen: unknown parameter type {glg_ppbase[ix]} on gl{glg_fname[i]}\n`); return 1
|
||||
}
|
||||
p += 1
|
||||
}
|
||||
i += 1
|
||||
}
|
||||
|
||||
var api_out = "runtime/native/gl_api.ludic"
|
||||
var thunk_out = "runtime/native/gl_thunks.ll"
|
||||
if check { api_out = tmp_path("gl_api.ludic"); thunk_out = tmp_path("gl_thunks.ll") }
|
||||
if not glg_emit_ludic(api_out) { err("glgen: cannot write gl_api.ludic\n"); return 1 }
|
||||
if not glg_emit_thunks(thunk_out) { err("glgen: cannot write gl_thunks.ll\n"); return 1 }
|
||||
if check {
|
||||
if not shq(`cmp -s {api_out} runtime/native/gl_api.ludic`) { err("gl_api.ludic drifted from gl3.h (run: ludic-dev glgen)\n"); return 1 }
|
||||
if not shq(`cmp -s {thunk_out} runtime/native/gl_thunks.ll`) { err("gl_thunks.ll drifted from gl3.h (run: ludic-dev glgen)\n"); return 1 }
|
||||
}
|
||||
print(`OK {string(len(glg_cname))} constants, {string(len(glg_fname))} entry points`)
|
||||
return 0
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue