mocari 0.2.4

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 mocari::{
    Error,
    json::{Physics3, PhysicsValueKind},
};

#[test]
fn parses_physics3_meta_and_setting_shape() {
    let physics = Physics3::from_json_str(
        r#"{
            "Version": 3,
            "Meta": {
                "PhysicsSettingCount": 1,
                "TotalInputCount": 1,
                "TotalOutputCount": 1,
                "VertexCount": 2,
                "EffectiveForces": {
                    "Gravity": { "X": 0.0, "Y": -1.0 },
                    "Wind": { "X": 0.0, "Y": 0.0 }
                },
                "PhysicsDictionary": [
                    { "Id": "PhysicsSetting1", "Name": "Hair" }
                ]
            },
            "PhysicsSettings": [
                {
                    "Id": "PhysicsSetting1",
                    "Input": [
                        {
                            "Source": { "Target": "Parameter", "Id": "ParamAngleX" },
                            "Weight": 60.0,
                            "Type": "X",
                            "Reflect": false
                        }
                    ],
                    "Output": [
                        {
                            "Destination": { "Target": "Parameter", "Id": "ParamHairFront" },
                            "VertexIndex": 1,
                            "Scale": 1.0,
                            "Weight": 100.0,
                            "Type": "Angle",
                            "Reflect": true
                        }
                    ],
                    "Vertices": [
                        {
                            "Mobility": 1.0,
                            "Delay": 0.2,
                            "Acceleration": 0.8,
                            "Radius": 10.0,
                            "Position": { "X": 0.0, "Y": 0.0 }
                        },
                        {
                            "Mobility": 0.8,
                            "Delay": 0.3,
                            "Acceleration": 0.7,
                            "Radius": 20.0,
                            "Position": { "X": 0.0, "Y": -20.0 }
                        }
                    ],
                    "Normalization": {
                        "Position": { "Minimum": -30.0, "Default": 0.0, "Maximum": 30.0 },
                        "Angle": { "Minimum": -45.0, "Default": 0.0, "Maximum": 45.0 }
                    }
                }
            ]
        }"#,
    )
    .unwrap();

    assert_eq!(physics.version(), 3);
    assert_eq!(physics.meta().physics_setting_count(), 1);
    assert_eq!(physics.meta().effective_forces().gravity().y(), -1.0);
    assert_eq!(physics.meta().physics_dictionary()[0].name(), "Hair");

    let setting = &physics.settings()[0];
    assert_eq!(setting.id(), "PhysicsSetting1");
    assert_eq!(setting.inputs()[0].source().id(), "ParamAngleX");
    assert_eq!(setting.inputs()[0].kind(), PhysicsValueKind::X);
    assert_eq!(setting.outputs()[0].destination().id(), "ParamHairFront");
    assert_eq!(setting.outputs()[0].kind(), PhysicsValueKind::Angle);
    assert!(setting.outputs()[0].reflect());
    assert_eq!(setting.vertices()[1].position().y(), -20.0);
    assert_eq!(setting.normalization().angle().maximum(), 45.0);
}

#[test]
fn rejects_unsupported_physics3_version() {
    let error = Physics3::from_json_str(
        r#"{
            "Version": 2,
            "Meta": {
                "PhysicsSettingCount": 0,
                "TotalInputCount": 0,
                "TotalOutputCount": 0,
                "VertexCount": 0,
                "EffectiveForces": {
                    "Gravity": { "X": 0.0, "Y": -1.0 },
                    "Wind": { "X": 0.0, "Y": 0.0 }
                },
                "PhysicsDictionary": []
            },
            "PhysicsSettings": []
        }"#,
    )
    .unwrap_err();

    assert!(matches!(
        error,
        Error::UnsupportedVersion {
            format: "physics3.json",
            version: 2
        }
    ));
}