re_view 0.36.1

Types & utilities for defining view classes and communicating with the viewport.
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 std::sync::Arc;

use ahash::HashMap;
use re_chunk_store::external::re_chunk::external::re_byte_size::{
    MemUsageTree, MemUsageTreeCapture,
};
use re_viewer_context::{AnnotationMap, Cache, CacheEntryAccess, SizeBytes as _};

struct AnnotationMapCacheAccessor<'a> {
    recording: &'a re_entity_db::EntityDb,
    query: &'a re_chunk_store::LatestAtQuery,
}

/// Caches annotation maps by query for one recording store and one frame.
///
/// [`Self::for_query`] shares each map among all callers through
/// [`re_viewer_context::StoreViewContext::memoizer_read_or_compute`], and frame boundaries discard
/// every entry.
#[derive(Default)]
pub struct AnnotationMapCache {
    maps: HashMap<re_chunk_store::LatestAtQuery, Arc<AnnotationMap>>,
}

impl AnnotationMapCache {
    /// Returns annotations for a recording query, shared by all callers during the frame.
    pub fn for_query(
        ctx: &re_viewer_context::ViewerContext<'_>,
        query: &re_chunk_store::LatestAtQuery,
    ) -> Arc<AnnotationMap> {
        ctx.active_recording_store_view_context()
            .memoizer_read_or_compute::<Self, _, _>(&AnnotationMapCacheAccessor {
                recording: ctx.recording(),
                query,
            })
    }
}

impl CacheEntryAccess<AnnotationMapCacheAccessor<'_>, Arc<AnnotationMap>> for AnnotationMapCache {
    fn read(&self, key: &AnnotationMapCacheAccessor<'_>) -> Option<Arc<AnnotationMap>> {
        self.maps.get(key.query).cloned()
    }

    fn compute(&mut self, key: &AnnotationMapCacheAccessor<'_>) -> Arc<AnnotationMap> {
        self.maps
            .entry(key.query.clone())
            .or_insert_with(|| {
                let mut annotation_map = AnnotationMap::default();
                annotation_map.load(key.recording, key.query);
                Arc::new(annotation_map)
            })
            .clone()
    }
}

impl Cache for AnnotationMapCache {
    fn name(&self) -> &'static str {
        "AnnotationMapCache"
    }

    fn begin_frame(&mut self) {
        // The stored annotation contexts are dependent on the current latest-at query which may change every frame.
        // But they're also fairly cheap to compute, just not so cheap that we want to do it
        // for every visualizer that needs it, so we cache them per frame.
        self.maps.clear();
    }

    fn purge_memory(&mut self) {
        self.maps.clear();
    }
}

impl MemUsageTreeCapture for AnnotationMapCache {
    fn capture_mem_usage_tree(&self) -> MemUsageTree {
        MemUsageTree::Bytes(self.maps.total_size_bytes())
    }
}