dymokomi/luce-geocore
Source of release 0.7.5
0.7.5 / src / geometry_files / fields.lucb
## Codecs of the field families: a volume's grids as child elements (name,
## class, background, the 12 transform numbers, the leaf keys, values and
## masks as columns, and a look other than the default: its 12 numbers, field
## names and emission ramp), and an SDF's program (ops and parameters).
func encode_volume(data: const void*, writer: GeometryWriter*, path: str) -> !:
let volume = (const Volume*)data
try writer.crate.element(path, "volume")
try writer.crate.integer("count", (i64)volume.grid_count())
let base = try copied_text(path)
defer free(base) in memory.heap
for index in 0..<volume.grid_count():
let grid = volume.grid(index)
var name = Growing[u8]()
defer name.close()
try append_text(&name, "g")
try append_number(&name, index)
let child = try writer.child((str)base, (str)name.view())
try writer.crate.element(child, "grid")
try writer.crate.text("name", grid.name())
try writer.crate.integer("class", (i64)(u8)grid.class)
try writer.crate.number("background", (f64)grid.background)
let m = grid.transform
let numbers: f64[12] = [m.x.x, m.x.y, m.x.z, m.y.x, m.y.y, m.y.z, m.z.x, m.z.y, m.z.z, m.translation.x, m.translation.y, m.translation.z]
try writer.crate.copied_array("transform", dtype_float64, 12, u8[]((u8*)&numbers[0], 96))
let keys = grid.keys.view()
try writer.column_borrowed("keys", dtype_uint64, keys.length, 1, bytes_view(keys))
let values = grid.values.view()
try writer.column_borrowed("values", dtype_float32, values.length // leaf_voxels, leaf_voxels, bytes_view(values))
let masks = grid.masks.view()
try writer.column_borrowed("masks", dtype_uint64, masks.length // mask_words, mask_words, bytes_view(masks))
try encode_look(writer, &grid.look)
## A grid's look, when it is not the default.
func encode_look(writer: GeometryWriter*, look: const VolumeLook*) -> !:
let plain = VolumeLook()
if look.same(&plain): return
let numbers: f64[12] = [look.density, look.smoke.x, look.smoke.y, look.smoke.z, look.shadow, look.emission, look.emission_color.x, look.emission_color.y,
look.emission_color.z, look.emission_low, look.emission_high, look.step]
try writer.crate.copied_array("look", dtype_float64, 12, u8[]((u8*)&numbers[0], 96))
if look.density_field().length > 0: try writer.crate.text("density_field", look.density_field())
if look.emission_field().length > 0: try writer.crate.text("emission_field", look.emission_field())
if look.emission_color_field().length > 0: try writer.crate.text("emission_color_field", look.emission_color_field())
let ramp = look.emission_ramp()
if ramp.length > 0: try writer.crate.copied_array("emission_ramp", dtype_float64, ramp.length, u8[]((u8*)ramp.data, ramp.length * 8))
func decode_volume(reader: GeometryReader*, path: str) -> void*!:
while let header = try reader.next_property(): _ = header
let volume = try new_volume()
errdefer release_volume(volume)
while let found = try reader.next_child(path):
if found.1 != "grid": error(errors.invalid, "volumes hold grid elements")
var name = Growing[u8]()
defer name.close()
var class: i64 = 0
var background = 0.0
var numbers: f64[12] = [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]
var keys: Column[u64]
defer keys.release()
var values: Column[f32]
defer values.release()
var masks: Column[u64]
defer masks.release()
var look = VolumeLook()
while let header = try reader.next_property():
let label = header.name
if label == "name": try reader.text(header, &name)
elif label == "class": class = try reader.integer(header)
elif label == "background":
var bytes: f64[1] = [0.0]
if header.dtype != dtype_float64 or header.bytes != 8: error(errors.invalid, "a grid background is one float64")
try reader.crate.read_payload(u8[]((u8*)&bytes[0], 8))
background = bytes[0]
elif label == "transform":
if header.dtype != dtype_float64 or header.bytes != 96: error(errors.invalid, "a grid transform is twelve float64s")
try reader.crate.read_payload(u8[]((u8*)&numbers[0], 96))
elif label == "keys" or label == "keys_chunks": keys = try reader.column[u64](header)
elif label == "values" or label == "values_chunks": values = try reader.column[f32](header)
elif label == "masks" or label == "masks_chunks": masks = try reader.column[u64](header)
elif label == "look":
var parts: f64[12]
if header.dtype != dtype_float64 or header.bytes != 96: error(errors.invalid, "a grid look is twelve float64s")
try reader.crate.read_payload(u8[]((u8*)&parts[0], 96))
look.density = parts[0]
look.smoke = Vector3(parts[1], parts[2], parts[3])
look.shadow = parts[4]
look.emission = parts[5]
look.emission_color = Vector3(parts[6], parts[7], parts[8])
look.emission_low = parts[9]
look.emission_high = parts[10]
look.step = parts[11]
elif label == "density_field" or label == "emission_field" or label == "emission_color_field":
var text = Growing[u8]()
defer text.close()
try reader.text(header, &text)
if label == "density_field": try look.set_density_field((str)text.view())
elif label == "emission_field": try look.set_emission_field((str)text.view())
else: try look.set_emission_color_field((str)text.view())
elif label == "emission_ramp":
var ramp: f64[163]
if header.dtype != dtype_float64 or header.bytes % 8 != 0 or header.bytes > 163 * 8: error(errors.invalid, "a grid's emission ramp is at most 163 float64s")
let count = header.bytes // 8
try reader.crate.read_payload(u8[]((u8*)&ramp[0], count * 8))
try look.set_emission_ramp(ramp[..<count])
let leaves = keys.count()
if values.count() != leaves * leaf_voxels or masks.count() != leaves * mask_words: error(errors.invalid, "a saved grid's columns disagree")
let sorted = keys.view()
for at in 1..<leaves:
if sorted[at] <= sorted[at - 1]: error(errors.invalid, "a saved grid's leaves are not sorted")
let transform = Matrix4(Vector3(numbers[0], numbers[1], numbers[2]), Vector3(numbers[3], numbers[4], numbers[5]),
Vector3(numbers[6], numbers[7], numbers[8]), Vector3(numbers[9], numbers[10], numbers[11]))
let grid = try new_grid((str)name.view(), GridClass.level_set if class == 1 else GridClass.fog, (f32)background, transform, keys.take(), values.take(), masks.take())
grid.look = look
try add_grid(volume, grid)
return (void*)volume
func encode_sdf(data: const void*, writer: GeometryWriter*, path: str) -> !:
let sdf = (const Sdf*)data
try writer.crate.element(path, "sdf")
let ops = sdf.op_span()
try writer.column_borrowed("ops", dtype_uint8, ops.length, 1, ops)
let params = sdf.param_span()
try writer.column_borrowed("params", dtype_float32, ops.length, sdf_stride, bytes_view(params))
func decode_sdf(reader: GeometryReader*, path: str) -> void*!:
var ops: Column[u8]
errdefer ops.release()
var params: Column[f32]
errdefer params.release()
while let header = try reader.next_property():
if header.name == "ops" or header.name == "ops_chunks": ops = try reader.column[u8](header)
elif header.name == "params" or header.name == "params_chunks": params = try reader.column[f32](header)
_ = path
return (void*)(try new_sdf(ops.take(), params.take()))