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
|
pub mod assetinfo;
pub mod gameobject;
pub mod material;
pub mod mesh;
pub mod pptr;
pub mod streaming_info;
pub mod texture2d;
pub mod transform;
pub mod vectors;
pub mod renderer;
pub mod shader;
pub mod cubemap;
pub mod render_settings;
pub mod audio_clip;
pub mod streamed_resource;
use crate::object::{Value, parser::FromValue};
use anyhow::Result;
use assetinfo::AssetInfo;
use gameobject::GameObject;
use material::Material;
use mesh::Mesh;
use pptr::PPtr;
use serde::Serialize;
use std::collections::BTreeMap;
use streaming_info::StreamingInfo;
use texture2d::Texture2D;
use transform::Transform;
#[derive(Debug, Serialize)]
pub enum HValue {
AssetInfo(AssetInfo),
GameObject(GameObject),
Transform(Transform),
PPtr(PPtr),
StreamingInfo(StreamingInfo),
Texture2D(Texture2D),
Mesh(Mesh),
Material(Material),
Pair(Box<HValue>, Box<HValue>),
Value([Value; 1]),
Map(BTreeMap<String, HValue>),
Array(Vec<HValue>),
Object {
class: String,
fields: BTreeMap<String, HValue>,
},
}
impl HValue {
pub fn from_value(v: Value) -> Result<HValue> {
Ok(match v {
value @ Value::Object { .. } => {
let class = value.class_name().unwrap();
match class.as_str() {
x if x.starts_with("PPtr<") => Self::PPtr(PPtr::from_value(value)?),
"AssetInfo" => Self::AssetInfo(AssetInfo::from_value(value)?),
"GameObject" => Self::GameObject(GameObject::from_value(value)?),
"Transform" => Self::Transform(Transform::from_value(value)?),
"Texture2D" => Self::Texture2D(Texture2D::from_value(value)?),
"Mesh" => Self::Mesh(Mesh::from_value(value)?),
"Material" => Self::Material(Material::from_value(value)?),
_ => Self::Value([value]),
}
}
Value::Array(a) => Self::Array(
a.into_iter()
.map(|e| HValue::from_value(e))
.collect::<Result<Vec<_>>>()?,
),
x => Self::Value([x]),
})
}
pub fn as_value(&self) -> Option<&Value> {
if let HValue::Value(v) = self {
Some(&v[0])
} else {
None
}
}
pub fn as_pptr(self) -> Option<PPtr> {
if let HValue::PPtr(v) = self {
Some(v)
} else {
None
}
}
pub fn as_array(self) -> Option<Vec<HValue>> {
if let HValue::Array(v) = self {
Some(v)
} else {
None
}
}
pub fn as_class(self, name: &str) -> Option<BTreeMap<String, HValue>> {
if let HValue::Object { class, fields } = self {
if class == name { Some(fields) } else { None }
} else {
None
}
}
}
|
