Orkuncakilkaya
967f15ded9
baked_tex.ludic reads ludic.base's baked form by hand (render3d uses no package): the LBAK header, the
key ("png_sheets" / "cutouts", the Bakes rows) and the generator version, then the payload -
w, h, channels, depth and the samples for a PNG (the caller frees them as it would a decode), a whole
.dds for a cut-out (tex_load_dds_at: a .dds at an offset). Missing, or another key or version, and the
PNG path runs as before. Compiles with Maroon Lake (game, lab, lab/bake/textures).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
75 lines
3.6 KiB
Text
75 lines
3.6 KiB
Text
# baked_tex.ludic - textures a game baked at build time (`ludic bake`, assets/baked/), read before the PNG
|
|
# they came from: a boot decodes, pads and converts nothing it can take ready-made. The file is ludic.base's
|
|
# baked form (a 32-byte "LBAK" header, then the payload), read by hand here since render3d uses no package.
|
|
# Missing, or of another key or version, and the PNG is decoded as it always was.
|
|
# assets/baked/png/<path under assets/>.tex a PNG's samples: u32 w, h, channels, depth, then them
|
|
# assets/baked/cutouts/<path under assets/>.bc7 a cut-out atlas, padded as tex_dilate pads it: a .dds
|
|
const BAKED_PNG_KEY: string = "png_sheets" # the Bakes row (Maroon Lake's bakes.lres) and the key in its header
|
|
const BAKED_PNG_VERSION: int = 1
|
|
const BAKED_CUT_KEY: string = "cutouts"
|
|
const BAKED_CUT_VERSION: int = 1
|
|
|
|
function baked_u32(b: []byte, o: int) -> int { return b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24) }
|
|
|
|
# where the bake of `path` (a PNG under assets/) lives, or "" for any other path
|
|
@alloc_ok("a load: the baked file's name")
|
|
function baked_tex_path(path: string, dir: string, ext: string) -> string {
|
|
let n = len(path)
|
|
if n < 12 or path[0 .. 7] != "assets/" or path[n - 4 .. n] != ".png" { return "" }
|
|
return `assets/baked/{dir}/{path[7 .. n - 4]}{ext}`
|
|
}
|
|
|
|
# the payload's offset in a baked file of this key and version, or -1 (not one, or another's)
|
|
function baked_payload(b: []byte, key: string, version: int) -> int {
|
|
if b == null or len(b) < 40 { return -1 }
|
|
if b[0] != 76 or b[1] != 66 or b[2] != 65 or b[3] != 75 { return -1 } # "LBAK"
|
|
if baked_u32(b, 4) != 1 or baked_u32(b, 8) != version { return -1 }
|
|
let off = baked_u32(b, 12)
|
|
if off < 32 + len(key) or off > len(b) { return -1 }
|
|
for i in 0 .. len(key) { if b[32 + i] != key[i] { return -1 } }
|
|
if b[32 + len(key)] != 0 { return -1 }
|
|
return off
|
|
}
|
|
|
|
# a PNG's samples as the bake left them (tex_w .. tex_depth set, the caller frees them), or null
|
|
@alloc_ok("a load: the baked file read, its samples kept by the caller")
|
|
function baked_png(render3d_st: mut Render3dState, path: pointer) -> pointer {
|
|
let bp = baked_tex_path(path, "png", ".tex")
|
|
if bp == "" or not Fs.exists(bp) { return null }
|
|
let b = Fs.read_bytes(bp)
|
|
let off = baked_payload(b, BAKED_PNG_KEY, BAKED_PNG_VERSION)
|
|
if off < 0 or off + 16 > len(b) {
|
|
if b != null { free(b) }
|
|
print(`r3d: {bp} is not this build's bake; {path} is decoded`)
|
|
return null
|
|
}
|
|
let w = baked_u32(b, off)
|
|
let h = baked_u32(b, off + 4)
|
|
let ch = baked_u32(b, off + 8)
|
|
let depth = baked_u32(b, off + 12)
|
|
let n = w * h * ch * (depth / 8)
|
|
if w < 1 or h < 1 or ch < 1 or ch > 4 or (depth != 8 and depth != 16) or off + 16 + n > len(b) {
|
|
free(b)
|
|
return null
|
|
}
|
|
let out = bytes(n + 8)
|
|
mem_copy(out, mem_off(data_of(b), off + 16), n)
|
|
free(b)
|
|
render3d_st.tex_w = w; render3d_st.tex_h = h; render3d_st.tex_channels = ch; render3d_st.tex_depth = depth
|
|
return out
|
|
}
|
|
|
|
# a cut-out atlas as the bake padded and compressed it (a texture id), or 0
|
|
@alloc_ok("a load: the baked file read and let go")
|
|
function baked_cutout(render3d_st: mut Render3dState, path: pointer, srgb: bool) -> int {
|
|
if not render3d_st.gvk_has_bc { return 0 }
|
|
let bp = baked_tex_path(path, "cutouts", ".bc7")
|
|
if bp == "" or not Fs.exists(bp) { return 0 }
|
|
let b = Fs.read_bytes(bp)
|
|
let off = baked_payload(b, BAKED_CUT_KEY, BAKED_CUT_VERSION)
|
|
var id = 0
|
|
if off >= 0 { id = tex_load_dds_at(render3d_st, b, off, srgb) }
|
|
if b != null { free(b) }
|
|
if id == 0 { print(`r3d: {bp} is not this build's bake; {path} is padded here`) }
|
|
return id
|
|
}
|