scena 1.0.0

A Rust-native scene-graph renderer with typed scene state, glTF assets, and explicit prepare/render lifecycles.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use super::super::Transform;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ConnectionAlignment {
    #[default]
    ForwardToForward,
    ForwardToBack,
    NormalToNormal,
    NormalToOpposite,
}

#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub enum ConnectionRoll {
    #[default]
    MatchTarget,
    PreserveSource,
    ChooseNearest {
        step_degrees: f32,
    },
    ExplicitDegrees(f32),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum ConnectionParenting {
    #[default]
    PreserveSourceParent,
    ReparentSourceToTargetParent,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ConnectOptions {
    pub(crate) mate_offset: Transform,
    pub(crate) allow_non_uniform_scale: bool,
    alignment: ConnectionAlignment,
    roll: ConnectionRoll,
    parenting: ConnectionParenting,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ConnectionRequest {
    source: super::super::ConnectorKey,
    target: super::super::ConnectorKey,
    options: ConnectOptions,
}

impl Default for ConnectOptions {
    fn default() -> Self {
        Self {
            mate_offset: Transform::IDENTITY,
            allow_non_uniform_scale: false,
            alignment: ConnectionAlignment::ForwardToForward,
            roll: ConnectionRoll::MatchTarget,
            parenting: ConnectionParenting::PreserveSourceParent,
        }
    }
}

impl ConnectOptions {
    pub const fn with_mate_offset(mut self, mate_offset: Transform) -> Self {
        self.mate_offset = mate_offset;
        self
    }

    pub const fn allow_non_uniform_scale(mut self, allow: bool) -> Self {
        self.allow_non_uniform_scale = allow;
        self
    }

    pub const fn with_alignment(mut self, alignment: ConnectionAlignment) -> Self {
        self.alignment = alignment;
        self
    }

    pub const fn alignment(self) -> ConnectionAlignment {
        self.alignment
    }

    pub const fn match_target_roll(mut self) -> Self {
        self.roll = ConnectionRoll::MatchTarget;
        self
    }

    pub const fn preserve_roll(mut self) -> Self {
        self.roll = ConnectionRoll::PreserveSource;
        self
    }

    pub fn choose_nearest_roll_degrees(mut self, step_degrees: f32) -> Self {
        let step_degrees = if step_degrees.is_finite() && step_degrees.abs() > f32::EPSILON {
            step_degrees.abs()
        } else {
            90.0
        };
        self.roll = ConnectionRoll::ChooseNearest { step_degrees };
        self
    }

    pub const fn with_explicit_roll_degrees(mut self, degrees: f32) -> Self {
        self.roll = ConnectionRoll::ExplicitDegrees(degrees);
        self
    }

    pub const fn roll(self) -> ConnectionRoll {
        self.roll
    }

    pub const fn preserve_source_parent(mut self) -> Self {
        self.parenting = ConnectionParenting::PreserveSourceParent;
        self
    }

    pub const fn reparent_source_to_target_parent(mut self) -> Self {
        self.parenting = ConnectionParenting::ReparentSourceToTargetParent;
        self
    }

    pub const fn parenting(self) -> ConnectionParenting {
        self.parenting
    }

    pub(crate) fn alignment_transform(self) -> Transform {
        match self.alignment {
            ConnectionAlignment::ForwardToForward | ConnectionAlignment::NormalToNormal => {
                Transform::IDENTITY
            }
            ConnectionAlignment::ForwardToBack | ConnectionAlignment::NormalToOpposite => {
                Transform::IDENTITY.rotate_y_deg(180.0)
            }
        }
    }
}

impl ConnectionRequest {
    pub const fn new(
        source: super::super::ConnectorKey,
        target: super::super::ConnectorKey,
        options: ConnectOptions,
    ) -> Self {
        Self {
            source,
            target,
            options,
        }
    }

    pub const fn source(self) -> super::super::ConnectorKey {
        self.source
    }

    pub const fn target(self) -> super::super::ConnectorKey {
        self.target
    }

    pub const fn options(self) -> ConnectOptions {
        self.options
    }
}