pybevy_scene 0.2.0

Scene components and assets for PyBevy
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

use bevy::{
    asset::Handle,
    scene::{DynamicScene, Scene, SceneSpawner},
};
use pybevy_core::{PyEntity, PyHandle, PyResource, ResourceStorage};
use pyo3::prelude::*;

use crate::instance_id::PyInstanceId;

#[pyclass(name = "SceneSpawner", extends = PyResource)]
pub struct PySceneSpawner {
    pub(crate) storage: ResourceStorage<SceneSpawner>,
}

impl PySceneSpawner {
    pub fn from_borrowed(storage: ResourceStorage<SceneSpawner>) -> (Self, PyResource) {
        (Self { storage }, PyResource)
    }

    fn as_ref(&self) -> PyResult<&SceneSpawner> {
        Ok(self.storage.as_ref()?)
    }

    fn as_mut(&mut self) -> PyResult<&mut SceneSpawner> {
        Ok(self.storage.as_mut()?)
    }
}

#[pymethods]
impl PySceneSpawner {
    pub fn spawn_dynamic(&mut self, id: &PyHandle) -> PyResult<PyInstanceId> {
        let handle: Handle<DynamicScene> = id.try_into()?;
        let instance_id = self.as_mut()?.spawn_dynamic(handle);
        Ok(PyInstanceId(instance_id))
    }

    pub fn spawn_dynamic_as_child(
        &mut self,
        id: &PyHandle,
        parent: &PyEntity,
    ) -> PyResult<PyInstanceId> {
        let handle: Handle<DynamicScene> = id.try_into()?;
        let instance_id = self.as_mut()?.spawn_dynamic_as_child(handle, parent.0);
        Ok(PyInstanceId(instance_id))
    }

    pub fn spawn(&mut self, id: &PyHandle) -> PyResult<PyInstanceId> {
        let handle: Handle<Scene> = id.try_into()?;
        let instance_id = self.as_mut()?.spawn(handle);
        Ok(PyInstanceId(instance_id))
    }

    pub fn spawn_as_child(&mut self, id: &PyHandle, parent: &PyEntity) -> PyResult<PyInstanceId> {
        let handle: Handle<Scene> = id.try_into()?;
        let instance_id = self.as_mut()?.spawn_as_child(handle, parent.0);
        Ok(PyInstanceId(instance_id))
    }

    pub fn despawn(&mut self, id: &PyHandle) -> PyResult<()> {
        let handle: Handle<Scene> = id.try_into()?;
        self.as_mut()?.despawn(&handle);
        Ok(())
    }

    pub fn despawn_dynamic(&mut self, id: &PyHandle) -> PyResult<()> {
        let handle: Handle<DynamicScene> = id.try_into()?;
        self.as_mut()?.despawn_dynamic(&handle);
        Ok(())
    }

    pub fn despawn_instance(&mut self, instance_id: &PyInstanceId) -> PyResult<()> {
        self.as_mut()?.despawn_instance(instance_id.0);
        Ok(())
    }

    pub fn unregister_instance(&mut self, instance_id: &PyInstanceId) -> PyResult<()> {
        self.as_mut()?.unregister_instance(instance_id.0);
        Ok(())
    }

    pub fn instance_is_ready(&self, instance_id: &PyInstanceId) -> PyResult<bool> {
        Ok(self.as_ref()?.instance_is_ready(instance_id.0))
    }

    pub fn iter_instance_entities(
        &self,
        instance_id: &PyInstanceId,
    ) -> PyResult<Option<Vec<PyEntity>>> {
        let spawner = self.as_ref()?;
        if !spawner.instance_is_ready(instance_id.0) {
            return Ok(None);
        }
        Ok(Some(
            spawner
                .iter_instance_entities(instance_id.0)
                .map(PyEntity)
                .collect(),
        ))
    }
}