molgfx-core 0.1.2

The semantic scene graph: columnar tables, GPU record layouts, the borrowed coordinate seam.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use super::{AnchorLayout, Relation, RelationBatch, RelationStyle, SpatialAnchor};
use crate::{
    InstanceBatchHandle, PointBatchHandle, RowDomain, RowEntityRef, SourceNamespace, SourceRows,
    TemplatePartRef, handle::RawHandle,
};
use molgfx_math::Vec3;
use std::sync::Arc;

fn points() -> RowDomain {
    RowDomain::Points(PointBatchHandle(RawHandle::new_for_test(4, 1)))
}

#[test]
fn mixed_relations_partition_stably_and_keep_a_remap_only_when_needed() {
    let dynamic = SpatialAnchor::entity(RowEntityRef::new(points(), 0)).unwrap();
    let world_a = SpatialAnchor::world(Vec3::ZERO).unwrap();
    let world_b = SpatialAnchor::world(Vec3::splat(1.0)).unwrap();
    let relations: Arc<[Relation]> = Arc::from([
        Relation {
            start: dynamic,
            end: world_b,
        },
        Relation {
            start: world_a,
            end: world_b,
        },
        Relation {
            start: dynamic,
            end: world_a,
        },
    ]);
    let batch = RelationBatch::new(
        relations,
        SourceRows::ordered(SourceNamespace(1), 3),
        RelationStyle::default(),
    )
    .unwrap();

    assert_eq!(batch.partitions().len(), 2);
    assert_eq!(batch.partitions()[0].layout.start, AnchorLayout::World);
    assert_eq!(
        batch.remap().map(std::convert::AsRef::as_ref),
        Some(&[1, 0, 2][..])
    );
}

#[test]
fn relations_cannot_anchor_to_relations() {
    let relation_domain =
        RowDomain::Relations(crate::RelationBatchHandle(RawHandle::new_for_test(1, 0)));
    assert!(SpatialAnchor::entity(RowEntityRef::new(relation_domain, 0)).is_err());
}

#[test]
fn template_part_anchors_require_an_exact_instance_occurrence() {
    let batch = InstanceBatchHandle(RawHandle::new_for_test(8, 2));
    let ambiguous = RowEntityRef::new(RowDomain::TemplateParts(batch), 3);
    assert!(SpatialAnchor::entity(ambiguous).is_err());

    let exact = SpatialAnchor::template_part(TemplatePartRef::new(batch, 5, 3));
    assert_eq!(exact.layout(), AnchorLayout::TemplatePart);
    assert!(exact.is_dynamic());
    let relations = Arc::from([Relation {
        start: exact,
        end: SpatialAnchor::world(Vec3::ZERO).unwrap(),
    }]);
    let batch = RelationBatch::new(
        relations,
        SourceRows::ordered(SourceNamespace(2), 1),
        RelationStyle::default(),
    )
    .unwrap();
    assert_eq!(batch.dependencies().len(), 2);
    assert_eq!(batch.dependencies()[0].maximum_row, 5);
    assert_eq!(batch.dependencies()[1].maximum_row, 3);
}