dymokomi/luce-cad
Source of release 0.9.1
0.9.1 / src / brep / codec.lucb
## A B-rep in a geometry file (geocore's prism codec): element `brep` with the
## tolerance and every column as it is stored, so a load gives back the same
## model bit for bit; face paths are one byte column split by offsets.
## Derived data (records, caches, tessellations) is never written. The
## writer borrows the stores' bytes until the file is written.
## Every column of `model` under element `path`.
pub func encode_brep(model: const BrepModel*, writer: GeometryWriter*, path: str) -> !:
try writer.crate.element(path, "brep")
try writer.crate.number("tolerance", model.tolerance)
try put[Vector3](writer, "vertices", dtype_float64, 3, &model.vertices)
try put[u8](writer, "curve_kind", dtype_uint8, 1, &model.curve_kind)
try put[i32](writer, "curve_ends", dtype_int32, 2, &model.curve_ends)
try put[f64](writer, "curve_frame", dtype_float64, curve_stride, &model.curve_frame)
try put[i32](writer, "curve_degree", dtype_int32, 1, &model.curve_degree)
try put[u8](writer, "curve_sense", dtype_uint8, 1, &model.curve_sense)
try put[i32](writer, "curve_point_offsets", dtype_int32, 1, &model.curve_point_offsets)
try put[Vector3](writer, "curve_points", dtype_float64, 3, &model.curve_points)
try put[i32](writer, "curve_weight_offsets", dtype_int32, 1, &model.curve_weight_offsets)
try put[f64](writer, "curve_weights", dtype_float64, 1, &model.curve_weights)
try put[i32](writer, "curve_knot_offsets", dtype_int32, 1, &model.curve_knot_offsets)
try put[f64](writer, "curve_knots", dtype_float64, 1, &model.curve_knots)
try put[u8](writer, "surface_kind", dtype_uint8, 1, &model.surface_kind)
try put[u8](writer, "surface_edited", dtype_uint8, 1, &model.surface_edited)
try put[f64](writer, "surface_frame", dtype_float64, surface_stride, &model.surface_frame)
try put[i32](writer, "surface_dims", dtype_int32, 4, &model.surface_dims)
try put[i32](writer, "surface_cv_offsets", dtype_int32, 1, &model.surface_cv_offsets)
try put[Vector3](writer, "cv_positions", dtype_float64, 3, &model.cv_positions)
try put[i32](writer, "surface_weight_offsets", dtype_int32, 1, &model.surface_weight_offsets)
try put[f64](writer, "cv_weights", dtype_float64, 1, &model.cv_weights)
try put[i32](writer, "surface_knot_offsets", dtype_int32, 1, &model.surface_knot_offsets)
try put[f64](writer, "surface_knots", dtype_float64, 1, &model.surface_knots)
try put[i32](writer, "face_surface", dtype_int32, 1, &model.face_surface)
try put[u8](writer, "face_sense", dtype_uint8, 1, &model.face_sense)
try put[i32](writer, "face_use_offsets", dtype_int32, 1, &model.face_use_offsets)
try put[i32](writer, "face_uses", dtype_int32, 1, &model.face_uses)
try put[i32](writer, "face_loop_offsets", dtype_int32, 1, &model.face_loop_offsets)
try put[i32](writer, "loop_sizes", dtype_int32, 1, &model.loop_sizes)
try put[Matrix4](writer, "face_placement", dtype_float64, 12, &model.face_placement)
try put[Vector3](writer, "face_color", dtype_float64, 3, &model.face_color)
try put[u8](writer, "face_colored", dtype_uint8, 1, &model.face_colored)
# Face paths: their bytes, split by offsets.
var bytes = Growing[u8]()
defer bytes.close()
var offsets = Growing[i32]()
defer offsets.close()
try offsets.push(0)
for path_text in model.face_paths.view():
if let text = path_text:
for byte in text.value.bytes: try bytes.push(byte)
try offsets.push((i32)bytes.count)
# The writer borrows array bytes until the file is written; these are
# temporary, so they are copied.
try writer.crate.copied_array("path_bytes", dtype_uint8, bytes.count, bytes.view())
try writer.crate.copied_array("path_offsets", dtype_int32, offsets.count, u8[]((u8*)offsets.items.data, offsets.count * 4))
func put[T](writer: GeometryWriter*, name: str, dtype: u8, columns: usize, store: const Store[T]*) -> !:
let values = store.view()
let component: usize = 8 if dtype == dtype_float64 else (4 if dtype == dtype_int32 else 1)
let rows = values.length * memory.size_of(T) // (columns * component)
try writer.column(name, dtype, rows, columns, u8[]((u8*)values.data, values.length * memory.size_of(T)))
## A B-rep read back from element `path`'s properties.
pub func decode_brep(reader: GeometryReader*, path: str) -> interop.Reference[BrepModel]!:
_ = path
var tolerance = 0.000001
var model_owner: interop.Reference[BrepModel]? = none
defer:
if let made = model_owner: made.release()
var path_bytes: Column[u8]
defer path_bytes.release()
var path_offsets: Column[i32]
defer path_offsets.release()
# The tolerance comes first; the model is made when it is known.
while let header = try reader.next_property():
let name = header.name
if name == "tolerance":
var value = try reader.column[f64](header)
defer value.release()
if value.count() == 1: tolerance = value.view()[0]
continue
if model_owner == none:
model_owner = try interop.Reference[BrepModel].adopt(new BrepModel(tolerance) in memory.heap, brep_model_type, memory.heap)
let model = (model_owner else error(invalid, "a saved B-rep lost its model")).value()
let label = base_name(name)
if label == "path_bytes": path_bytes = try reader.column[u8](header)
elif label == "path_offsets": path_offsets = try reader.column[i32](header)
else: try read_store(reader, header, label, model)
let owner = model_owner else error(invalid, "a saved B-rep has no columns")
let model = owner.value()
model.changed()
if model.surface_edited.count != model.surface_kind.count: error(invalid, "a saved B-rep's surface columns do not match")
# Paths, one per face.
let offsets = path_offsets.view()
let faces = (usize)model.face_count()
if offsets.length != faces + 1: error(invalid, "a saved B-rep's paths do not match its faces")
let bytes = path_bytes.view()
model.face_paths.clear()
for face in 0..<faces:
let first = (usize)offsets[face]
let end = (usize)offsets[face + 1]
if end < first or end > bytes.length: error(invalid, "a saved B-rep's path offsets are out of range")
var copy: interop.Packet[str]? = none
if end > first: copy = try interop.text_transfer.copy((str)bytes[first..<end])
model.face_paths.push(copy) catch failure:
if let made = copy: made.release()
error(failure.code, failure.message)
model_owner = none
return owner
## `name` without a `_chunks` suffix.
func base_name(name: str) -> str:
let bytes = name.bytes
if bytes.length > 7 and (str)bytes[bytes.length - 7..] == "_chunks": return (str)bytes[..<bytes.length - 7]
return name
## Read one column into the store it names.
func read_store(reader: GeometryReader*, header: PropertyHeader, label: str, model: BrepModel*) -> !:
if label == "vertices": try take[Vector3](reader, header, &model.vertices)
elif label == "curve_kind": try take[u8](reader, header, &model.curve_kind)
elif label == "curve_ends": try take[i32](reader, header, &model.curve_ends)
elif label == "curve_frame": try take[f64](reader, header, &model.curve_frame)
elif label == "curve_degree": try take[i32](reader, header, &model.curve_degree)
elif label == "curve_sense": try take[u8](reader, header, &model.curve_sense)
elif label == "curve_point_offsets": try take[i32](reader, header, &model.curve_point_offsets)
elif label == "curve_points": try take[Vector3](reader, header, &model.curve_points)
elif label == "curve_weight_offsets": try take[i32](reader, header, &model.curve_weight_offsets)
elif label == "curve_weights": try take[f64](reader, header, &model.curve_weights)
elif label == "curve_knot_offsets": try take[i32](reader, header, &model.curve_knot_offsets)
elif label == "curve_knots": try take[f64](reader, header, &model.curve_knots)
elif label == "surface_kind": try take[u8](reader, header, &model.surface_kind)
elif label == "surface_edited": try take[u8](reader, header, &model.surface_edited)
elif label == "surface_frame": try take[f64](reader, header, &model.surface_frame)
elif label == "surface_dims": try take[i32](reader, header, &model.surface_dims)
elif label == "surface_cv_offsets": try take[i32](reader, header, &model.surface_cv_offsets)
elif label == "cv_positions": try take[Vector3](reader, header, &model.cv_positions)
elif label == "surface_weight_offsets": try take[i32](reader, header, &model.surface_weight_offsets)
elif label == "cv_weights": try take[f64](reader, header, &model.cv_weights)
elif label == "surface_knot_offsets": try take[i32](reader, header, &model.surface_knot_offsets)
elif label == "surface_knots": try take[f64](reader, header, &model.surface_knots)
elif label == "face_surface": try take[i32](reader, header, &model.face_surface)
elif label == "face_sense": try take[u8](reader, header, &model.face_sense)
elif label == "face_use_offsets": try take[i32](reader, header, &model.face_use_offsets)
elif label == "face_uses": try take[i32](reader, header, &model.face_uses)
elif label == "face_loop_offsets": try take[i32](reader, header, &model.face_loop_offsets)
elif label == "loop_sizes": try take[i32](reader, header, &model.loop_sizes)
elif label == "face_placement": try take[Matrix4](reader, header, &model.face_placement)
elif label == "face_color": try take[Vector3](reader, header, &model.face_color)
elif label == "face_colored": try take[u8](reader, header, &model.face_colored)
func take[T](reader: GeometryReader*, header: PropertyHeader, store: Store[T]*) -> !:
var column = try reader.column[T](header)
store.close()
store.count = column.count()
store.column = column.take()