mocari 0.2.0

A pure Rust Live2D/Cubism-compatible runtime
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

use serde::Deserialize;

use crate::{Error, Result};

const FORMAT: &str = "cdi3.json";
const SUPPORTED_VERSION: u32 = 3;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Cdi3 {
    version: u32,
    parameters: Vec<CdiEntry>,
    parameter_groups: Vec<CdiEntry>,
    parts: Vec<CdiPart>,
    combined_parameters: Vec<Vec<String>>,
}

impl Cdi3 {
    pub fn from_json_str(source: &str) -> Result<Self> {
        let raw: RawCdi3 = serde_json::from_str(source).map_err(|error| Error::InvalidJson {
            format: FORMAT,
            message: error.to_string(),
        })?;

        if raw.version != SUPPORTED_VERSION {
            return Err(Error::UnsupportedVersion {
                format: FORMAT,
                version: raw.version,
            });
        }

        Ok(Self {
            version: raw.version,
            parameters: raw.parameters,
            parameter_groups: raw.parameter_groups,
            parts: raw.parts,
            combined_parameters: raw.combined_parameters,
        })
    }

    pub fn version(&self) -> u32 {
        self.version
    }

    pub fn parameters(&self) -> &[CdiEntry] {
        &self.parameters
    }

    pub fn parameter_groups(&self) -> &[CdiEntry] {
        &self.parameter_groups
    }

    pub fn parts(&self) -> &[CdiPart] {
        &self.parts
    }

    pub fn combined_parameters(&self) -> &[Vec<String>] {
        &self.combined_parameters
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
struct RawCdi3 {
    #[serde(rename = "Version")]
    version: u32,
    #[serde(rename = "Parameters", default)]
    parameters: Vec<CdiEntry>,
    #[serde(rename = "ParameterGroups", default)]
    parameter_groups: Vec<CdiEntry>,
    #[serde(rename = "Parts", default)]
    parts: Vec<CdiPart>,
    #[serde(rename = "CombinedParameters", default)]
    combined_parameters: Vec<Vec<String>>,
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub struct CdiEntry {
    #[serde(rename = "Id")]
    id: String,
    #[serde(rename = "GroupId")]
    group_id: String,
    #[serde(rename = "Name")]
    name: String,
}

impl CdiEntry {
    pub fn id(&self) -> &str {
        &self.id
    }

    pub fn group_id(&self) -> &str {
        &self.group_id
    }

    pub fn name(&self) -> &str {
        &self.name
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
pub struct CdiPart {
    #[serde(rename = "Id")]
    id: String,
    #[serde(rename = "Name")]
    name: String,
}

impl CdiPart {
    pub fn id(&self) -> &str {
        &self.id
    }

    pub fn name(&self) -> &str {
        &self.name
    }
}