pybevy 0.2.1

PyBevy: A Python Real-Time Engine Built on Bevy
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

use bevy::asset::{Asset, AssetEvent};
use pybevy_core::handle::PyHandle;
use pyo3::prelude::*;

use crate::ecs::message::PyMessage;

#[pyclass(name = "AssetEventType", eq, eq_int, frozen)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PyAssetEventType {
    Added,
    Modified,
    Removed,
    Unused,
    LoadedWithDependencies,
}

#[pymethods]
impl PyAssetEventType {
    fn __repr__(&self) -> &'static str {
        match self {
            PyAssetEventType::Added => "AssetEventType.Added",
            PyAssetEventType::Modified => "AssetEventType.Modified",
            PyAssetEventType::Removed => "AssetEventType.Removed",
            PyAssetEventType::Unused => "AssetEventType.Unused",
            PyAssetEventType::LoadedWithDependencies => "AssetEventType.LoadedWithDependencies",
        }
    }

    fn __str__(&self) -> &'static str {
        match self {
            PyAssetEventType::Added => "Added",
            PyAssetEventType::Modified => "Modified",
            PyAssetEventType::Removed => "Removed",
            PyAssetEventType::Unused => "Unused",
            PyAssetEventType::LoadedWithDependencies => "LoadedWithDependencies",
        }
    }
}

#[pyclass(name = "AssetEvent", extends = PyMessage)]
#[derive(Debug, Clone)]
pub struct PyAssetEvent {
    #[pyo3(get)]
    pub handle: PyHandle,

    #[pyo3(get)]
    pub event_type: PyAssetEventType,
}

impl PyAssetEvent {
    pub fn from_bevy<A: Asset>(event: &AssetEvent<A>) -> Self {
        let (id, event_type) = match event {
            AssetEvent::Added { id } => (*id, PyAssetEventType::Added),
            AssetEvent::Modified { id } => (*id, PyAssetEventType::Modified),
            AssetEvent::Removed { id } => (*id, PyAssetEventType::Removed),
            AssetEvent::Unused { id } => (*id, PyAssetEventType::Unused),
            AssetEvent::LoadedWithDependencies { id } => {
                (*id, PyAssetEventType::LoadedWithDependencies)
            }
        };

        PyAssetEvent {
            handle: PyHandle::from(&id),
            event_type,
        }
    }
}

#[pymethods]
impl PyAssetEvent {
    pub fn is_added(&self) -> bool {
        self.event_type == PyAssetEventType::Added
    }

    pub fn is_modified(&self) -> bool {
        self.event_type == PyAssetEventType::Modified
    }

    pub fn is_removed(&self) -> bool {
        self.event_type == PyAssetEventType::Removed
    }

    pub fn is_unused(&self) -> bool {
        self.event_type == PyAssetEventType::Unused
    }

    pub fn is_loaded_with_dependencies(&self) -> bool {
        self.event_type == PyAssetEventType::LoadedWithDependencies
    }

    fn __repr__(&self) -> String {
        format!(
            "AssetEvent(handle={:?}, type={})",
            self.handle,
            self.event_type.__str__()
        )
    }
}