mev 0.1.0

Metal Et Vulkan abstraction
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
140
141
142
143
144

use super::{BufferSlice, VertexFormat};

/// Memory sizes required for acceleration structure operation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct AccelerationStructureSizes {
    /// Size of the acceleration structure in bytes.
    /// 
    /// Allocate this amount of memory in buffer that will contain the acceleration structure.
    pub size: usize,

    /// Size of the scratch memory in bytes.
    /// 
    /// Allocate this amount of memory in buffer that will be used during acceleration structure build.
    pub scratch_size: usize,

    /// Size of the update scratch memory in bytes.
    /// 
    /// Allocate this amount of memory in buffer that will be used during acceleration structure update.
    pub update_scratch_size: usize,
}

/// Performance hints for acceleration structure operation.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum AccelerationStructurePerformance {
    /// Default preference for acceleration structure operation.
    Default,

    /// Prefer fast trace performance.
    /// 
    /// This may result in slower build times.
    /// Use this when acceleration structure will be used repeatedly.
    FastTrace,

    /// Prefer fast build performance.
    /// 
    /// This may result in slower trace times.
    /// Use this when acceleration structure will be rebuilt frequently.
    FastBuild,
}

bitflags::bitflags! {
    /// These flags are used to specify the build properties of an acceleration structure.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub struct AccelerationStructureBuildFlags: u32 {
        /// Specifies that built acceleration structure could be used as a source
        /// for build with update operation.
        const ALLOW_UPDATE = 0x1;

        /// Specifies that built acceleration structure could be used as a source
        /// for copy operation with `Compact` mode.
        const ALLOW_COMPACTION = 0x2;
    }
}

/// Description of a bottom-level acceleration structure triangle-based geometry.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct BlasTriangles<'a> {
    /// Flag to indicate if geometry is opaque.
    /// If true, tracing will stop on hit to this geometry.
    /// Otherwise opaque test may be invoked.
    /// 
    /// Set this flag is there are not non-opaque surfaces using this geometry.
    pub opaque: bool,

    /// Buffer slice containing triangle indices.
    /// If none, indices are not used and vertices are used directly.
    pub indices: Option<BufferSlice<'a>>,

    /// Buffer slice containing triangle vertices.
    pub vertices: BufferSlice<'a>,

    /// Stride between vertices in bytes.
    pub vertex_stride: usize,

    /// Format of the vertices.
    pub vertex_format: VertexFormat,

    /// Buffer slice containing transform matrix.
    pub transform: Option<BufferSlice<'a>>,
}

/// Description of a bottom-level acceleration structure axis-aligned bounding box-based geometry.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct BlasAABBs<'a> {
    /// Flag to indicate if geometry is opaque.
    pub opaque: bool,

    /// Buffer slice containing AABBs.
    pub boxes: BufferSlice<'a>,

    /// Stride between AABBs in bytes.
    pub box_stride: usize,
}

/// Description of a bottom-level acceleration structure geometry.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum BlasGeometryDesc<'a> {
    /// Triangle-based geometry.
    Triangles(BlasTriangles<'a>),

    /// Axis-aligned bounding box-based geometry.
    AABBs(BlasAABBs<'a>),
}

/// Flags for bottom-level acceleration structure.
/// Reserved for future use.
bitflags::bitflags! {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub struct BlasFlags: u32 {}
}

/// Description of a bottom-level acceleration structure
/// Contains flags and size of the acceleration structure.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct BlasDesc {
    pub flags: BlasFlags,
    pub size: usize,
}

/// Description of a bottom-level acceleration structure build.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct BlasBuildDesc<'a> {
    pub performance: AccelerationStructurePerformance,
    pub flags: AccelerationStructureBuildFlags,
    pub geometry: &'a [BlasGeometryDesc<'a>],
}

pub struct TlasBuildDesc {
    pub flags: AccelerationStructureBuildFlags,
    pub instances: Vec<TlasInstanceDesc>,
}

pub struct TlasInstanceDesc {}

bitflags::bitflags! {
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub struct TlasFlags: u32 {}
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct TlasDesc {
    pub flags: TlasFlags,
    pub size: usize,
}