🥮 mooncakes.io

    OrisGo/octree/objects does not have a README file

    BatchError

    source
    pub(all) suberror BatchError {
      InvalidOutputRange(position~ : Int)
      OverlappingOutputRanges(first~ : Int, second~ : Int)
      InsufficientWorkspace(required~ : Int, available~ : Int)
    } derive(Eq, 
    Debug    )

    BatchError::equal

    source
    fn BatchError::equal(BatchError, BatchError) -> Bool

    BatchError::not_equal

    source
    fn BatchError::not_equal(x : BatchError, y : BatchError) -> Bool

    BatchError::to_repr

    source

    BuildError

    source
    pub(all) suberror BuildError {
      InvalidConfig(String)
      ObjectCapacityExceeded(limit~ : Int, actual~ : Int)
      DuplicateId(position~ : Int, id~ : UInt)
      OutsideRoot(position~ : Int, id~ : UInt)
    } derive(Eq, 
    Debug    )

    BuildError::equal

    source
    fn BuildError::equal(BuildError, BuildError) -> Bool

    BuildError::not_equal

    source
    fn BuildError::not_equal(x : BuildError, y : BuildError) -> Bool

    BuildError::to_repr

    source

    QueryError

    source
    pub(all) suberror QueryError {
      InvalidOutputRange
      InsufficientWorkspace(required~ : Int, available~ : Int)
      InvalidWorkspaceCapacity
      InvalidNode
      InvalidObjectOffset
    } derive(Eq, 
    Debug    )

    QueryError::equal

    source
    fn QueryError::equal(QueryError, QueryError) -> Bool

    QueryError::not_equal

    source
    fn QueryError::not_equal(x : QueryError, y : QueryError) -> Bool

    QueryError::to_repr

    source

    BatchQuery

    source
    pub struct BatchQuery[T] {
      query : Result[T, 
    GeometryError    ]
      offset : Int
      capacity : Int
    }

    A query or its geometry validation error, with an explicit output interval.

    BatchQuery::new

    source
    fn[T] BatchQuery::new(query : Result[T, 
    GeometryError    ], offset~ : Int, capacity~ : Int) -> BatchQuery[T]

    Completeness

    source
    pub(all) enum Completeness {
      Complete
      Truncated
    } derive(Eq, 
    Debug    )

    Completeness::equal

    source

    Completeness::not_equal

    source
    fn Completeness::not_equal(x : Completeness, y : Completeness) -> Bool

    Completeness::to_repr

    source

    Entry

    source
    pub struct Entry {
      id : UInt
      bounds : 
    Aabb
    } derive(Eq, 
    Debug    )

    One immutable object snapshot. IDs are unique within an index.

    Entry::equal

    source
    fn Entry::equal(Entry, Entry) -> Bool

    Entry::new

    source
    fn Entry::new(id : UInt, bounds : 
    Aabb    ) -> Entry

    Entry::not_equal

    source
    fn Entry::not_equal(x : Entry, y : Entry) -> Bool

    Entry::to_repr

    source

    IndexStats

    source
    pub struct IndexStats {
      object_count : Int
      node_count : Int
      depth : Int
      max_objects : Int
      max_nodes : Int
      max_depth : Int
      split_threshold : Int
      object_capacity : Int
      node_capacity : Int
      order_capacity : Int
      workspace_required : Int
    } derive(Eq, 
    Debug    )

    IndexStats::equal

    source
    fn IndexStats::equal(IndexStats, IndexStats) -> Bool

    IndexStats::not_equal

    source
    fn IndexStats::not_equal(x : IndexStats, y : IndexStats) -> Bool

    IndexStats::to_repr

    source

    NodeInfo

    source
    pub struct NodeInfo {
      id : Int
      bounds : 
    Aabb
      depth : Int
      octant : Int
      object_count : Int
      child_mask : UInt
    } derive(Eq, 
    Debug    )

    A read-only value snapshot, not a mutable node reference.

    NodeInfo::equal

    source
    fn NodeInfo::equal(NodeInfo, NodeInfo) -> Bool

    NodeInfo::not_equal

    source
    fn NodeInfo::not_equal(x : NodeInfo, y : NodeInfo) -> Bool

    NodeInfo::to_repr

    source

    QueryStats

    source
    pub struct QueryStats {
      written : Int
      total_hits : Int
      completeness : Completeness
      visited_nodes : Int
      tested_objects : Int
    } derive(Eq, 
    Debug    )

    QueryStats::equal

    source
    fn QueryStats::equal(QueryStats, QueryStats) -> Bool

    QueryStats::not_equal

    source
    fn QueryStats::not_equal(x : QueryStats, y : QueryStats) -> Bool

    QueryStats::to_repr

    source

    StaticObjectIndex

    source
    pub struct StaticObjectIndex {
      // private fields
    }

    Read-only tree. Private arrays are never returned to callers.

    StaticObjectIndex::build

    source
    fn StaticObjectIndex::build(input : ArrayView[Entry], root~ : 
    Cube    , max_objects~ : Int, max_nodes~ : Int, max_depth? : Int, split_threshold? : Int) -> StaticObjectIndex raise BuildError

    Build atomically from copied snapshots. A node-budget stop never discards entries.

    StaticObjectIndex::node_info

    source
    fn StaticObjectIndex::node_info(self : StaticObjectIndex, id : Int) -> NodeInfo raise QueryError

    StaticObjectIndex::node_object_id

    source
    fn StaticObjectIndex::node_object_id(self : StaticObjectIndex, id : Int, offset : Int) -> UInt raise QueryError

    Read one ID belonging directly to a node, including objects kept at parents.

    StaticObjectIndex::query_aabb

    source

    Allocating convenience query. Result order is unspecified.

    StaticObjectIndex::query_aabb_batch_into

    source

    Validates every output interval before writing; reports follow input order.

    StaticObjectIndex::query_aabb_into

    source
    fn StaticObjectIndex::query_aabb_into(self : StaticObjectIndex, query : 
    Aabb    , output : FixedArray[UInt], workspace : Workspace, offset? : Int, capacity? : Int) -> QueryStats raise QueryError

    Writes only the valid prefix of the selected output range; always counts all hits.

    StaticObjectIndex::query_ray_candidates

    source
    fn StaticObjectIndex::query_ray_candidates(self : StaticObjectIndex, query : 
    Ray    ) -> Array[UInt]

    Allocating convenience query; IDs are not sorted by distance.

    StaticObjectIndex::query_ray_candidates_batch_into

    source
    fn StaticObjectIndex::query_ray_candidates_batch_into(self : StaticObjectIndex, queries : ArrayView[BatchQuery[
    Ray    ]], output : FixedArray[UInt], workspace : Workspace) -> Array[Result[QueryStats, 
    GeometryError    ]] raise BatchError

    StaticObjectIndex::query_ray_candidates_into

    source
    fn StaticObjectIndex::query_ray_candidates_into(self : StaticObjectIndex, query : 
    Ray    , output : FixedArray[UInt], workspace : Workspace, offset? : Int, capacity? : Int) -> QueryStats raise QueryError

    StaticObjectIndex::stats

    source

    StaticObjectIndex::visit

    source
    fn StaticObjectIndex::visit(self : StaticObjectIndex, workspace : Workspace, visitor : (NodeInfo) -> Bool) -> Unit raise QueryError

    Preorder traversal in ascending octant order. Return false to stop. The callback may query the index, but must not reuse this active workspace.

    StaticObjectIndex::workspace

    source

    Workspace

    source
    pub struct Workspace {
      // private fields
    }

    Caller-owned reusable traversal memory. Do not share during an active query.

    Workspace::capacity

    source
    fn Workspace::capacity(self : Workspace) -> Int

    Workspace::new

    source
    fn Workspace::new(capacity : Int) -> Workspace raise QueryError

    scan_aabb

    source
    fn scan_aabb(input : ArrayView[Entry], query : 
    Aabb    ) -> Array[UInt]

    Linear oracle: allocates results, performs no tree pruning or ID validation. Duplicate input IDs remain duplicated. Intended for verification and tiny inputs.

    scan_ray_candidates

    source
    fn scan_ray_candidates(input : ArrayView[Entry], query : 
    Ray    ) -> Array[UInt]

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsBuild queueStatistics

    © 2026 mooncakes.io