phobos 0.10.0

Fast, powerful Vulkan abstraction library
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
130
131
132
133
134
135
136
137
138
139

//! Exposes the virtual resource utility used to refer to resources in a graph.

use std::fmt::{Display, Formatter};

use crate::graph::resource::ResourceType;

/// Represents a virtual resource in the system, uniquely identified by a string.
///
/// Note that the resource named `swapchain` is assumed to always be the swapchain resource for presenting.
#[derive(Debug, Default, Clone, Hash, Eq, PartialEq)]
pub struct VirtualResource {
    pub(crate) name: String,
    pub(crate) version: usize,
    ty: ResourceType,
}

/// Holds a hashed resource in the pass graph implementation
#[derive(Eq, PartialEq, Copy, Clone, Debug)]
pub struct HashedResource {
    /// Hash of the resource
    pub hash: u64,
}

impl Display for HashedResource {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.hash)
    }
}

impl VirtualResource {
    pub(crate) fn final_image(name: impl Into<String>) -> Self {
        VirtualResource {
            name: name.into(),
            version: usize::MAX,
            ty: ResourceType::Image,
        }
    }

    /// Create a new image virtual resource.
    pub fn image(name: impl Into<String>) -> Self {
        VirtualResource {
            name: name.into(),
            version: 0,
            ty: ResourceType::Image,
        }
    }

    /// Create a new buffer virtual resource.
    pub fn buffer(name: impl Into<String>) -> Self {
        VirtualResource {
            name: name.into(),
            version: 0,
            ty: ResourceType::Buffer,
        }
    }

    /// 'Upgrades' the resource to a new version of itself. This is used to obtain the virtual resource name of an input resource after
    /// a task completes.
    pub fn upgrade(&self) -> Self {
        VirtualResource {
            name: self.name.clone(),
            version: self.version + 1,
            ty: self.ty,
        }
    }

    /// Returns the full, original name of the resource
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Returns the version of a resource, the larger this the more recent the version of the resource is.
    pub fn version(&self) -> usize {
        self.version
    }

    /// Returns true if the resource is a source resource, e.g. an instance that does not depend on a previous pass.
    pub fn is_source(&self) -> bool {
        self.version() == 0
    }

    /// Check if these virtual resources refer to the same physical resource
    pub fn is_associated_with(&self, rhs: &VirtualResource) -> bool {
        self.name() == rhs.name()
    }

    /// One virtual resource is older than another if it has less '+' symbols.
    pub fn is_older(lhs: &VirtualResource, rhs: &VirtualResource) -> bool {
        if !lhs.is_associated_with(rhs) {
            return false;
        }
        lhs.version() < rhs.version()
    }

    /// Note that this is not the same as inverting the result of as_older(), for the same exact state of the resource,
    /// both of these functions should return false (they decide whether resources are strictly older or younger than each other).
    pub fn is_younger(lhs: &VirtualResource, rhs: &VirtualResource) -> bool {
        if !lhs.is_associated_with(rhs) {
            return false;
        }
        lhs.version() > rhs.version()
    }

    /// Get the resource type of this virtual resource
    pub fn resource_type(&self) -> ResourceType {
        self.ty
    }

    /// Get the uid of this virtual resource
    pub fn uid(&self) -> String {
        format!("{}", self)
    }
}

impl Display for VirtualResource {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if self.version == usize::MAX {
            write!(f, "{}_final", self.name())
        } else {
            write!(f, "{}{}", self.name(), String::from_utf8(vec![b'+'; self.version]).unwrap())
        }
    }
}

/// Syntax sugar to easily construct image virtual resources
#[macro_export]
macro_rules! image {
    ($id:literal) => {
        ::phobos::prelude::VirtualResource::image($id)
    };
}

/// Syntax sugar to easily construct buffer virtual resources
#[macro_export]
macro_rules! buffer {
    ($id:literal) => {
        ::phobos::prelude::VirtualResource::buffer($id)
    };
}