Orkuncakilkaya
7c74d95efa
Within a pass a row writes only its own still-masked texels and reads only neighbours already let go, which no row writes that pass, so the result is the single-threaded one. The worker takes a DilateJob of plain buffers and allocates nothing. tex_dilate_bytes (safe_api) and examples/rendering/dilate.ludic, which checks it against the old loop on RGB and RGBA atlases of sizes that do not divide (DILATE OK). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
46 lines
2.4 KiB
Text
46 lines
2.4 KiB
Text
# safe_api.ludic — the renderer's raw buffers, as a program may hold them (L7). The renderer reads
|
|
# glTF accessors, the screen and PNG files into raw memory, which is its business; a game gets the
|
|
# same data as slices, bounds-checked, and never frees anything. Each of these copies or hands over
|
|
# at the boundary, so nothing raw crosses it.
|
|
|
|
# an accessor's float components (gltf_count elements of gltf_comps floats), as floats
|
|
function gltf_accessor_floats(render3d_st: mut Render3dState, idx: int) -> floats {
|
|
let p = gltf_accessor(render3d_st, idx)
|
|
let n = render3d_st.gltf_count * render3d_st.gltf_comps
|
|
let out = floats(n)
|
|
for i in 0 .. n { out[i] = float_from_bits(mem_get_f32_bits(p, i)) }
|
|
free(p)
|
|
return out
|
|
}
|
|
# how many elements an accessor holds, without reading them
|
|
function gltf_accessor_count(render3d_st: Render3dState, idx: int) -> int {
|
|
let acc = value_at(value_get(render3d_st.gltf_doc, "accessors"), idx)
|
|
return jint(acc, "count", 0)
|
|
}
|
|
# the presented frame as RGB8, bottom row first, into `out` (at least w * h * 3 bytes)
|
|
function gpu_read_screen_bytes(render3d_st: mut Render3dState, w: int, h: int, out: []byte) -> bool {
|
|
if out == null or len(out) < w * h * 3 { return false }
|
|
gpu_read_screen(render3d_st, w, h, data_of(out))
|
|
return true
|
|
}
|
|
# a PNG's samples (tex_w x tex_h x tex_channels, 8 or 16 bits): into `reuse` when it is large
|
|
# enough - a map swap decodes the same size again - else into a new buffer. null if unreadable.
|
|
function png_decode_bytes(render3d_st: mut Render3dState, path: string, reuse: []byte) -> []byte {
|
|
let p = png_decode(render3d_st, path)
|
|
if p == null { return null }
|
|
let n = render3d_st.tex_w * render3d_st.tex_h * render3d_st.tex_channels * (render3d_st.tex_depth / 8)
|
|
var out = reuse
|
|
if out == null or len(out) < n { out = buffer(n) }
|
|
for i in 0 .. n { out[i] = p[i] }
|
|
free(p)
|
|
return out
|
|
}
|
|
# upload samples laid out as the last decode left them (tex_w, tex_h, tex_channels, tex_depth)
|
|
function tex_upload_bytes(render3d_st: mut Render3dState, px: []byte, srgb: bool, mips: bool) -> int {
|
|
return tex_upload(render3d_st, data_of(px), srgb, mips)
|
|
}
|
|
# cut-out edge padding over samples laid out as the last decode left them (tex_dilate)
|
|
function tex_dilate_bytes(render3d_st: Render3dState, px: []byte, thresh: int, passes: int) -> void {
|
|
if px == null or len(px) < render3d_st.tex_w * render3d_st.tex_h * render3d_st.tex_channels { return }
|
|
tex_dilate(render3d_st, data_of(px), thresh, passes)
|
|
}
|