Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.6

0.9.6 / src / renderers / cad_edges.lucb

## A CAD mesh's boundary segments grouped by the CAD edge they draw (the
## `cad_edge` id within the `cad_edge_model` model of each mesh edge), made
## once per mesh topology and tagging: hovering a boundary lights its whole
## edge from its own segments, without a pass over the mesh's edges.
from luce_geocore.geocore import Mesh
from luce_geocore.core.growing import Growing

## No group (an edge without a CAD id).
let ungrouped: u32 = 0xFFFFFFFF

## A CAD edge: its model's id and its id there.
struct Pair:
    var model: f64
    var edge: f64

## What groups are made from: the topology and both tags' columns.
struct Source:
    var topology: u64
    var tags: u64
    var owners: u64

pub struct CadEdges:
    var key: Source
    ## Each mesh edge's group, and each group's edges (`starts` into
    ## `members`).
    var group_of: Growing[u32]
    var starts: Growing[u32]
    var members: Growing[u32]
    ## Open-addressed (model, edge) pairs to their group: slot + 1 in
    ## `slots` names group `slots[...] - 1`, whose pair is `pairs[group]`.
    var slots: Growing[u32]
    var pairs: Growing[Pair]

    pub func init():
        self.key = Source(0, 0, 0)
        self.group_of = Growing[u32]()
        self.starts = Growing[u32]()
        self.members = Growing[u32]()
        self.slots = Growing[u32]()
        self.pairs = Growing[Pair]()

    ## The segments of the CAD edge mesh edge `edge` belongs to (empty when
    ## it has none or the mesh has no tags).
    pub func segments(mesh: const Mesh*, edge: i64) -> const u32[]!:
        try self.update(mesh)
        if edge < 0 or (usize)edge >= self.group_of.count: return self.members.view()[..<0]
        let group = self.group_of.items[(usize)edge]
        if group == ungrouped: return self.members.view()[..<0]
        return self.members.view()[(usize)self.starts.items[(usize)group]..<(usize)self.starts.items[(usize)group + 1]]

    func update(mesh: const Mesh*) -> !:
        let tag = mesh.find_attribute("cad_edge", 4)
        let owner = mesh.find_attribute("cad_edge_model", 4)
        if tag < 0 or owner < 0:
            self.group_of.clear()
            self.key = Source(0, 0, 0)
            return
        let key = Source(mesh.corners_id(), try mesh.attribute_id(tag), try mesh.attribute_id(owner))
        if key == self.key: return
        let tags = try mesh.attribute_entry(tag)
        let owners = try mesh.attribute_entry(owner)
        let edges = (usize)(try mesh.edge_count())
        self.pairs.clear()
        try self.slots.fill(64, 0)
        try self.group_of.fill(edges, ungrouped)
        for edge in 0..<edges:
            let id = tags.number(edge, 0)
            if id < 0.0: continue
            self.group_of.items[edge] = try self.group(Pair(owners.number(edge, 0), id))
        let groups = self.pairs.count
        try self.starts.fill(groups + 1, 0)
        for group in self.group_of.view():
            if group != ungrouped: self.starts.items[(usize)group + 1] += 1
        for at in 0..<groups: self.starts.items[at + 1] += self.starts.items[at]
        try self.members.fill((usize)self.starts.items[groups], 0)
        for edge in 0..<edges:
            let group = self.group_of.items[edge]
            if group == ungrouped: continue
            self.members.items[(usize)self.starts.items[(usize)group]] = (u32)edge
            self.starts.items[(usize)group] += 1
        # Filling moved each start to its group's end: move them back.
        var at = groups
        while at > 0:
            self.starts.items[at] = self.starts.items[at - 1]
            at -= 1
        self.starts.items[0] = 0
        self.key = key

    ## The group of `pair`, made when new.
    func group(pair: Pair) -> u32!:
        if (self.pairs.count + 1) * 2 > self.slots.count:
            try self.slots.fill(self.slots.count * 2, 0)
            for at in 0..<self.pairs.count: self.place(at)
        var slot = spread(pair) & (self.slots.count - 1)
        while self.slots.items[slot] != 0:
            let at = (usize)self.slots.items[slot] - 1
            if self.pairs.items[at].model == pair.model and self.pairs.items[at].edge == pair.edge: return (u32)at
            slot = (slot + 1) & (self.slots.count - 1)
        try self.pairs.push(pair)
        self.slots.items[slot] = (u32)self.pairs.count
        return (u32)(self.pairs.count - 1)

    func place(at: usize):
        var slot = spread(self.pairs.items[at]) & (self.slots.count - 1)
        while self.slots.items[slot] != 0: slot = (slot + 1) & (self.slots.count - 1)
        self.slots.items[slot] = (u32)(at + 1)

    pub func close():
        self.group_of.close()
        self.starts.close()
        self.members.close()
        self.slots.close()
        self.pairs.close()

func spread(pair: Pair) -> usize:
    let mixed = ((u64)(i64)pair.model *% 0x9E3779B97F4A7C15) ^ ((u64)(i64)pair.edge *% 0xC2B2AE3D27D4EB4F)
    return (usize)(mixed ^ (mixed >> 31))