Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.5

0.7.5 / src / fields / component.lucb

## Volumes and SDFs in a geometry set. A volume holds named sparse grids,
## each shared by count; an SDF is one analytic program. Both place (an SDF
## wraps its program in a transform, a grid composes its transform), join
## (grids side by side; SDF programs as a union), describe themselves and
## have no polygons. Their display is a surface preview built once and kept
## with the component: an SDF's zero set sampled at 1/128 of its extent and
## pulled onto the exact surface, and a level set's zero set. A fog volume has
## no surface: viewports ray-march its densities (luce-3d's FogVolume).

pub struct Volume:
    pub var users: @usize
    var grids: Growing[SparseGrid*]
    var lock: sync.Mutex
    var preview: Mesh*? = none
    var previewed: bool = false

    pub func grid_count() -> usize:
        return self.grids.count

    pub func grid(index: usize) -> const SparseGrid*:
        return self.grids.items[index]

    func close():
        for grid in self.grids.view(): release_grid(grid)
        self.grids.close()
        if let mesh = self.preview: mesh_dispose(mesh)
        self.preview = none

## A new volume of no grids.
pub func new_volume() -> Volume*!:
    let storage = try new Volume[1] --- in memory.heap
    let volume = storage.data
    volume.users.store(1, .relaxed)
    volume.grids = Growing[SparseGrid*]()
    volume.lock = sync.Mutex()
    volume.preview = none
    volume.previewed = false
    return volume

## Add `grid` (taken, even on failure) to a volume being built.
pub func add_grid(volume: Volume*, grid: SparseGrid*) -> !:
    volume.grids.push(grid) catch failure:
        release_grid(grid)
        error(failure.code, failure.message)

pub func release_volume(volume: Volume*):
    if volume.users.sub(1, .acq_rel) != 1: return
    volume.close()
    free(Volume[](volume, 1)) in memory.heap

pub let volume_component: ComponentType = ComponentType("volume", share_volume, close_volume, volume_size, volume_bytes, volume_bounds, place_volume, join_volumes, no_field_paths, keep_volume, describe_volume, "", no_trace)
pub let sdf_component: ComponentType = ComponentType("sdf", share_sdf_data, close_sdf, sdf_size, sdf_bytes, sdf_bounds, place_sdf, join_sdfs, no_field_paths, keep_sdf, describe_sdf, "", no_trace)

pub func volume_type() -> const ComponentType*:
    return &volume_component

pub func sdf_type() -> const ComponentType*:
    return &sdf_component

pub func set_volume(set: const GeometrySet*) -> const Volume*?:
    let data = set.find(&volume_component) else return none
    return (const Volume*)data

pub func set_sdf(set: const GeometrySet*) -> const Sdf*?:
    let data = set.find(&sdf_component) else return none
    return (const Sdf*)data

func share_volume(data: const void*) -> void*!:
    let volume = (Volume*)data
    _ = volume.users.add(1, .relaxed)
    return (void*)volume

func close_volume(data: void*):
    release_volume((Volume*)data)

func volume_size(data: const void*) -> usize:
    return ((const Volume*)data).grid_count()

func volume_bytes(data: const void*, ids: IdSet*) -> usize!:
    var total: usize = 64
    for grid in ((const Volume*)data).grids.view():
        total += 256 + (try ids.charge(grid.keys.id(), grid.keys.bytes())) + (try ids.charge(grid.values.id(), grid.values.bytes())) + (try ids.charge(grid.masks.id(), grid.masks.bytes()))
    return total

func volume_bounds(data: const void*, matrix: Matrix4, out: Bounds*) -> bool!:
    var found = false
    for grid in ((const Volume*)data).grids.view():
        let box = grid.bounds() else continue
        let placed = placed_box(box, matrix)
        *out = union_box(*out, placed) if found else placed
        found = true
    return found

func place_volume(data: const void*, placement: const Placement*) -> void*!:
    let volume = try new_volume()
    errdefer release_volume(volume)
    for grid in ((const Volume*)data).grids.view(): try add_grid(volume, try grid.placed(placement.matrix))
    return (void*)volume

func join_volumes(first: const void*, second: const void*) -> void*!:
    let volume = try new_volume()
    errdefer release_volume(volume)
    for grid in ((const Volume*)first).grids.view(): try add_grid(volume, share_grid(grid))
    for grid in ((const Volume*)second).grids.view(): try add_grid(volume, share_grid(grid))
    return (void*)volume

func no_field_paths(data: const void*, out: TableBuilder*) -> !:
    _ = data
    _ = out

func keep_volume(data: const void*, filter: const PathFilter*, keep: bool) -> void*!:
    if filter.is_empty() == keep: return try share_volume(data)
    return (void*)(try new_volume())

func describe_volume(data: const void*, out: Growing[u8]*) -> !:
    let volume = (const Volume*)data
    var active: usize = 0
    for grid in volume.grids.view(): active += grid.active_count()
    try append_number(out, volume.grid_count())
    try append_text(out, " volume grids / ")
    try append_number(out, active)
    try append_text(out, " active voxels")

func share_sdf_data(data: const void*) -> void*!:
    return (void*)share_sdf((Sdf*)data)

func close_sdf(data: void*):
    release_sdf((Sdf*)data)

func sdf_size(data: const void*) -> usize:
    return ((const Sdf*)data).op_count()

func sdf_bytes(data: const void*, ids: IdSet*) -> usize!:
    let sdf = (const Sdf*)data
    return 64 + (try ids.charge(sdf.ops.id(), sdf.ops.bytes())) + (try ids.charge(sdf.params.id(), sdf.params.bytes()))

func sdf_bounds(data: const void*, matrix: Matrix4, out: Bounds*) -> bool!:
    *out = placed_box(((const Sdf*)data).bounds(), matrix)
    return true

func place_sdf(data: const void*, placement: const Placement*) -> void*!:
    return (void*)(try placed_sdf((const Sdf*)data, placement.matrix))

func join_sdfs(first: const void*, second: const void*) -> void*!:
    return (void*)(try combined_sdf((const Sdf*)first, (const Sdf*)second, SdfOp.unite, 0.0))

func keep_sdf(data: const void*, filter: const PathFilter*, keep: bool) -> void*!:
    if filter.is_empty() == keep: return try share_sdf_data(data)
    # An SDF that is nowhere: a point sphere far away is not empty, so an
    # emptied SDF drops out of the set (size 0 is removed on put).
    return (void*)(try empty_sdf())

func describe_sdf(data: const void*, out: Growing[u8]*) -> !:
    try append_text(out, "SDF of ")
    try append_number(out, ((const Sdf*)data).op_count())
    try append_text(out, " ops")

# mark: Previews

## Voxels across an SDF's longest side in its preview, and in the quick
## preview a drag's frames show (about a tenth of the work).
let preview_voxels: f64 = 128.0
let quick_voxels: f64 = 40.0

## The SDF's surface preview, built on first use and kept; `quick`, the
## coarse one (kept apart, so a full request after a drag builds in full).
pub func sdf_preview(sdf: const Sdf*, quick: bool = false) -> const Mesh*?!:
    let cache = (Sdf*)sdf
    cache.lock.lock()
    defer cache.lock.unlock()
    if let made = cache.preview: return made
    if quick:
        if let made = cache.quick_preview: return made
    let box = sdf.bounds()
    let size = box.maximum.subtract(box.minimum)
    let longest = math.max(size.x, math.max(size.y, size.z))
    if not (longest > 0.0 and math.is_finite(longest)): return none
    let voxel = longest / (quick_voxels if quick else preview_voxels)
    let grid = try sampled_sdf(sdf, voxel, 2.0, "preview")
    defer release_grid(grid)
    if grid.leaf_count() == 0: return none
    let mesh = try surface_mesh(grid, 0.0, sdf)
    if quick:
        cache.quick_preview = mesh
        return mesh
    cache.preview = mesh
    cache.preview_voxel = voxel
    return mesh

## The surface preview of the volume's level sets, built on first use and
## kept; fog grids have none.
pub func volume_preview(volume: const Volume*) -> const Mesh*?!:
    let cache = (Volume*)volume
    cache.lock.lock()
    defer cache.lock.unlock()
    if cache.previewed: return cache.preview
    var parts = Growing[Mesh*]()
    defer:
        for part in parts.view(): mesh_dispose(part)
        parts.close()
    for grid in volume.grids.view():
        if grid.leaf_count() == 0 or grid.class == GridClass.fog: continue
        try push_mesh(&parts, try surface_mesh(grid, 0.0, none))
    if parts.count == 1:
        cache.preview = parts.items[0]
        parts.count = 0
    elif parts.count > 1:
        var pieces = Growing[MeshPart]()
        defer pieces.close()
        for part in parts.view(): try pieces.push(MeshPart(part, Matrix4()))
        let joined = try concatenated(pieces.view())
        defer joined.release()
        cache.preview = try mesh_share(joined.value())
    cache.previewed = true
    return cache.preview

## Keep `mesh` (taken, even on failure) in `parts`.
pub func push_mesh(parts: Growing[Mesh*]*, mesh: Mesh*) -> !:
    parts.push(mesh) catch failure:
        mesh_dispose(mesh)
        error(failure.code, failure.message)