kson 0.2.0

Rust implementation of the kson sdvx chart format.
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
158
159
160

use std::cmp::Ordering;

use crate::{ByPulse, Graph, GraphPoint, GraphSectionPoint};
use serde::{Deserialize, Serialize};

#[cfg(feature = "schema")]
use schemars::JsonSchema;

#[derive(Serialize, Deserialize, Clone, Default)]
#[serde(default)]
pub struct CameraInfo {
    pub tilt: TiltInfo,
    pub cam: CamInfo,
}

#[derive(Serialize, Deserialize, Clone, Default)]
#[serde(default)]
pub struct TiltInfo {
    pub scale: ByPulse<f64>,
    pub manual: ByPulse<Vec<GraphSectionPoint>>,
    pub keep: ByPulse<bool>,
}

impl Graph<Option<f64>> for ByPulse<Vec<GraphSectionPoint>> {
    fn value_at(&self, tick: f64) -> Option<f64> {
        let tick_u = tick as u32;
        let index = self
            .binary_search_by(|x| cmp_graph_section(x, tick_u))
            .ok()?;
        let (y, graph) = &self[index];

        graph.value_at(tick - (*y) as f64)
    }

    fn direction_at(&self, tick: f64) -> Option<f64> {
        let tick_u = tick as u32;
        let index = self
            .binary_search_by(|x| cmp_graph_section(x, tick_u))
            .ok()?;
        let (y, graph) = &self[index];

        graph.direction_at(tick - (*y) as f64)
    }

    fn wide_at(&self, _: f64) -> u32 {
        1
    }
}

fn cmp_graph_section((y, graph): &(u32, Vec<GraphSectionPoint>), cmp_y: u32) -> Ordering {
    if cmp_y < *y {
        Ordering::Less
    } else {
        let ry = graph.last().map(|x| x.ry).unwrap_or(0);
        if (cmp_y - *y) <= ry {
            Ordering::Equal
        } else {
            Ordering::Greater
        }
    }
}

#[derive(Serialize, Deserialize, Clone, Default)]
#[serde(default)]
pub struct CamInfo {
    pub body: CamGraphs,
    #[serde(skip_serializing_if = "CamPatternInfo::is_empty")]
    pub pattern: CamPatternInfo,
}

#[derive(Serialize, Deserialize, Clone, Default)]
#[serde(default)]
pub struct CamPatternInfo {
    #[serde(skip_serializing_if = "CamPatternLaserInfo::is_empty")]
    pub laser: CamPatternLaserInfo,
}

impl CamPatternInfo {
    fn is_empty(&self) -> bool {
        self.laser.slam_event.is_empty()
    }
}

#[derive(Serialize, Deserialize, Clone, Default)]
#[serde(default)]
pub struct CamPatternLaserInfo {
    #[serde(skip_serializing_if = "CamPatternLaserInvokeList::is_empty")]
    pub slam_event: CamPatternLaserInvokeList,
}

impl CamPatternLaserInfo {
    fn is_empty(&self) -> bool {
        self.slam_event.is_empty()
    }
}

#[derive(Serialize, Deserialize, Clone, Default)]
#[serde(default)]
pub struct CamPatternLaserInvokeList {
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub spin: Vec<CamPatternInvokeSpin>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub half_spin: Vec<CamPatternInvokeSpin>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub swing: Vec<CamPatternInvokeSwing>,
}

impl CamPatternLaserInvokeList {
    fn is_empty(&self) -> bool {
        self.spin.is_empty() && self.swing.is_empty() && self.half_spin.is_empty()
    }
}

/// (pulse, direction, duration)
#[derive(Debug, Serialize, Deserialize, Copy, Clone, Default)]
pub struct CamPatternInvokeSpin(pub u32, pub i32, pub u32);
#[derive(Debug, Serialize, Deserialize, Copy, Clone, Default)]
pub struct CamPatternInvokeSwing(
    pub u32,
    pub i32,
    pub u32,
    #[serde(default, skip_serializing_if = "crate::IsDefault::is_default")]
    pub  CamPatternInvokeSwingValue,
);

#[derive(Debug, Serialize, Deserialize, Copy, Clone, PartialEq)]
pub struct CamPatternInvokeSwingValue {
    pub scale: f32,  // scale
    pub repeat: u32, // number of repetitions
    pub decay_order: u32, // order of the decay that scales camera values (0-2)
                     // (note that this decay is applied even if repeat=1)
                     // - equation: `value * (1.0 - ((l - ry) / l))^decay_order`
                     // - 0: no decay, 1: linear decay, 2: squared decay
}

impl Default for CamPatternInvokeSwingValue {
    fn default() -> Self {
        Self {
            scale: 1.0,
            repeat: 1,
            decay_order: 0,
        }
    }
}

type GraphVec = Vec<GraphPoint>;

#[derive(Serialize, Deserialize, Clone, Default)]
#[serde(default)]
pub struct CamGraphs {
    pub zoom: GraphVec,
    pub shift_x: GraphVec,
    pub rotation_x: GraphVec,
    pub rotation_z: GraphVec,
    #[serde(rename = "rotation_z.highway")]
    pub rotation_z_highway: GraphVec,
    #[serde(rename = "rotation_z.jdgline")]
    pub rotation_z_jdgline: GraphVec,
    pub split: GraphVec,
}