rafx-assets 0.0.16

Rendering framework built on an extensible asset pipeline
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

use crossbeam_channel::Sender;
use hydrate_base::LoadHandle;
use hydrate_loader::storage::ArtifactLoadOp;
use rafx_api::RafxError;
use rafx_framework::upload::UploadOp;

//
// Ghetto futures - UploadOp is used to signal completion and UploadOpAwaiter is used to check the result
//
pub enum UploadAssetOpResult<ResourceT, AssetT> {
    UploadError(LoadHandle),
    UploadComplete(ArtifactLoadOp, Sender<AssetT>, ResourceT),
    UploadDrop(LoadHandle),
}

pub struct UploadAssetOpInner<ResourceT, AssetT> {
    load_op: ArtifactLoadOp,
    load_handle: LoadHandle,
    asset_sender: Sender<AssetT>, // This sends back to the asset storage, we just pass it along
    sender: Sender<UploadAssetOpResult<ResourceT, AssetT>>, // This sends back to the resource manager to finalize the load
}

pub struct UploadAssetOp<ResourceT, AssetT> {
    inner: Option<UploadAssetOpInner<ResourceT, AssetT>>,
}

impl<ResourceT, AssetT> Drop for UploadAssetOp<ResourceT, AssetT> {
    fn drop(&mut self) {
        if let Some(inner) = self.inner.take() {
            let sender = inner.sender;
            let _ = sender.send(UploadAssetOpResult::UploadDrop(inner.load_handle));
        }
    }
}

impl<ResourceT, AssetT> UploadAssetOp<ResourceT, AssetT> {
    pub fn new(
        load_op: ArtifactLoadOp,
        load_handle: LoadHandle,
        asset_sender: Sender<AssetT>,
        sender: Sender<UploadAssetOpResult<ResourceT, AssetT>>,
    ) -> Self {
        let inner = UploadAssetOpInner {
            load_op,
            load_handle,
            asset_sender,
            sender,
        };

        UploadAssetOp { inner: Some(inner) }
    }

    pub fn complete(
        mut self,
        resource: ResourceT,
    ) {
        self.do_complete(resource)
    }

    pub fn error(
        mut self: Box<Self>,
        error: RafxError,
    ) {
        self.do_error(error)
    }

    fn do_complete(
        &mut self,
        resource: ResourceT,
    ) {
        let inner = self.inner.take().unwrap();
        let load_op = inner.load_op;
        let asset_sender = inner.asset_sender;
        let _ = inner.sender.send(UploadAssetOpResult::UploadComplete(
            load_op,
            asset_sender,
            resource,
        ));
    }

    fn do_error(
        &mut self,
        error: RafxError,
    ) {
        let inner = self.inner.take().unwrap();
        inner.load_op.error(error);
        let _ = inner
            .sender
            .send(UploadAssetOpResult::UploadError(inner.load_handle));
    }
}

impl<ResourceT: Send + Sync, AssetT: Send + Sync> UploadOp<ResourceT>
    for UploadAssetOp<ResourceT, AssetT>
{
    fn complete(
        mut self: Box<Self>,
        resource: ResourceT,
    ) {
        self.do_complete(resource)
    }

    fn error(
        mut self: Box<Self>,
        error: RafxError,
    ) {
        self.do_error(error)
    }
}