cortenforge-sim-core 0.6.0

Bevy-based simulation runtime primitives (modes, config, plugins) for the CortenForge stack.
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Recorder subsystem types for data capture and metadata management.
//!
//! This module consolidates all recorder-related types previously split across
//! `recorder_types` and `recorder_meta` modules for clearer organization.

use bevy::math::UVec2;
use bevy::prelude::{Resource, Timer, TimerMode};
use std::path::PathBuf;
use vision_core::prelude::Recorder;

// Configuration and State ------------------------------------------------

/// Configuration resource for the recorder subsystem.
#[derive(Resource)]
pub struct Config {
    pub output_root: PathBuf,
    pub capture_interval: Timer,
    pub resolution: UVec2,
    pub prune_empty: bool,
    pub prune_output_root: Option<PathBuf>,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            output_root: PathBuf::from("assets/datasets/captures"),
            capture_interval: Timer::from_seconds(0.33, TimerMode::Repeating),
            resolution: UVec2::new(640, 360),
            prune_empty: false,
            prune_output_root: None,
        }
    }
}

/// Runtime state resource for the recorder subsystem.
#[derive(Resource)]
pub struct State {
    pub enabled: bool,
    pub session_dir: PathBuf,
    pub frame_idx: u64,
    pub last_toggle: f64,
    pub last_image_ok: bool,
    pub paused: bool,
    pub overlays_done: bool,
    pub prune_done: bool,
    pub initialized: bool,
    pub manifest_written: bool,
}

impl Default for State {
    fn default() -> Self {
        Self {
            enabled: false,
            session_dir: PathBuf::from("assets/datasets/captures/unsynced"),
            frame_idx: 0,
            last_toggle: 0.0,
            last_image_ok: false,
            paused: false,
            overlays_done: false,
            prune_done: false,
            initialized: false,
            manifest_written: false,
        }
    }
}

/// Motion tracking resource for recorder triggers.
#[derive(Resource, Default)]
pub struct Motion {
    pub last_head_z: Option<f32>,
    pub cumulative_forward: f32,
    pub started: bool,
}

/// Auto-record timer resource.
#[derive(Resource)]
pub struct AutoRecordTimer {
    pub timer: Timer,
}

impl Default for AutoRecordTimer {
    fn default() -> Self {
        Self {
            timer: Timer::from_seconds(30.0, TimerMode::Once),
        }
    }
}

// Metadata Management ----------------------------------------------------

/// Trait for providing metadata to the recorder (e.g., label seeds).
pub trait MetadataProvider: Send + Sync + 'static {
    fn label_seed(&self) -> u64;
}

/// Resource holding a boxed metadata provider.
#[derive(Resource)]
pub struct MetaProvider {
    pub provider: Box<dyn MetadataProvider>,
}

/// Basic metadata provider implementation with a configurable seed.
#[derive(Default)]
pub struct BasicMeta {
    pub seed: u64,
}

impl MetadataProvider for BasicMeta {
    fn label_seed(&self) -> u64 {
        self.seed
    }
}

// Integration Types ------------------------------------------------------

/// Resource holding the active recorder sink (trait object).
#[derive(Resource, Default)]
pub struct Sink {
    pub writer: Option<Box<dyn Recorder + Send + Sync>>,
}

/// App-provided world state for recorder triggers (head position, stop flag).
#[derive(Resource, Default)]
pub struct RecorderWorldSnapshot {
    pub head_z: Option<f32>,
    pub stop_flag: bool,
}