bevy_serialization_core 0.7.0

A crate which contains the plugins/systems that bevy_serializations_extras relies on, + some misc wrappers
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

use bevy_asset::Asset;
use bevy_color::prelude::*;
use bevy_ecs::component::Component;
use bevy_ecs::prelude::ReflectComponent;
use bevy_pbr::prelude::*;
use bevy_reflect::prelude::*;
use bevy_utils::prelude::*;
use derive_more::derive::From;

use crate::traits::{AssetHandleComponent, AssetState, AssetWrapper};

/// serializable wrapper for mesh materials
#[derive(Component, Reflect, Clone, PartialEq, From)]
#[reflect(Component)]
pub enum Material3dFlag {
    Pure(MaterialWrapper),
    Path(String),
}

#[derive(Clone, From, PartialEq, Reflect)]
pub enum MaterialWrapper {
    Color(Color),
}

impl AssetWrapper for Material3dFlag {
    type WrapperTarget = MeshMaterial3d<StandardMaterial>;
    type PureVariant = MaterialWrapper;

    fn asset_state(&self) -> AssetState<Self::PureVariant, String> {
        match self {
            Material3dFlag::Pure(material_wrapper) => AssetState::Pure(material_wrapper),
            Material3dFlag::Path(path) => AssetState::Path(path),
        }
    }
}
// impl<'a, 'b> Into<AssetState<'b, <Material3dFlag as AssetWrapper>::PureVariant, <Material3dFlag as AssetWrapper>::PathVariant>> for &'a Material3dFlag

// impl IntoAssetState for Material3dFlag {
//     fn asset_state(&self) -> AssetState<Self::PureVariant,  Self::PathVariant> {
//         match self {
//             Material3dFlag::Pure(material_wrapper) => AssetState::Pure(material_wrapper),
//             Material3dFlag::Path(path) => AssetState::Path(path),
//         }
//     }
// }

// impl<'a, 'b> From<&'a Material3dFlag> for AssetState<'b, <Material3dFlag as AssetWrapper>::PureVariant, <Material3dFlag as AssetWrapper>::PathVariant>
//     where
//         'a: 'b
// {
//     fn from(value: &'a Material3dFlag) -> Self {
//         match value {
//             Material3dFlag::Pure(material_wrapper) => AssetState::Pure(material_wrapper),
//             Material3dFlag::Path(path) => AssetState::Path(path),
//         }
//     }
// }

impl From<&MaterialWrapper> for StandardMaterial {
    fn from(value: &MaterialWrapper) -> Self {
        match value {
            MaterialWrapper::Color(color) => Self {
                base_color: *color,
                ..default()
            },
        }
    }
}

impl From<&StandardMaterial> for MaterialWrapper {
    fn from(value: &StandardMaterial) -> Self {
        Self::Color(value.base_color)
    }
}

// impl FromAssetState<&Material3dFlag> for StandardMaterial {
//     fn from_asset_state(value: &Material3dFlag) -> AssetState<Self> {
//         match value {
//             Material3dFlag::Pure(color) => AssetState::Pure(
//                         Self {
//                             base_color: *color,
//                             ..default()
//                         }
//                     ),
//             //Material3dFlag::Path(path) => todo!(),
//         }
//     }
// }

// impl FromAssetState<&StandardMaterial> for Material3dFlag {
//     fn from_asset_state(value: &StandardMaterial) -> AssetState<Self> {
//         todo!()
//     }
// }

// impl From<&Material3dFlag> for AssetState<StandardMaterial> {
//     fn from(value: &Material3dFlag) -> Self {
//         match value {
//             Material3dFlag::Color(color) => AssetState::Pure(
//                 Self {
//                     base_color: *color,
//                     ..default()
//                 }
//             ),
//         }
//         // match value {
//         //     Material3dFlag::Color(color) => Self {
//         //         base_color: *color,
//         //         ..default()
//         //     },
//         // }
//     }
// }

impl From<&StandardMaterial> for Material3dFlag {
    fn from(value: &StandardMaterial) -> Self {
        Self::Pure(value.base_color.into())
    }
}

impl<T: Asset + Material> AssetHandleComponent for MeshMaterial3d<T> {
    type AssetType = T;
}

impl Default for Material3dFlag {
    fn default() -> Self {
        Material3dFlag::Pure(Color::default().into())
    }
}