mepeyew 0.3.5

mepeyew - Small But Powerful Graphics 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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Since not all platforms are created equal, extensions exist to use special features or eak out
//! more performance.
//! See [`Extensions`] for details of each extension.
//!
//! ## Extension Support
//!
//! ✅ = Fully Supported
//! 🆗  = Has No Effect
//! ❌ = Unsupported
//!
//!  
//! | Extension                         | Vulkan    | WebGpu    |
//! | ---                               | ---       | ---       |
//! | `flight_frames_count`             | ✅        | 🆗        |
//! | `gpu_power_level`                 | ✅        | 🆗        |
//! | `native_debug`                    | ✅        | 🆗        |
//! | `memory_flush`                    | ✅        | 🆗        |
//! | `naga_translation`                | ✅        | ✅        |
//! | `webgpu_init_from_window`         | 🆗        | ✅        |
//! | `webgpu_init`                     | 🆗        | ✅        |
//! | `surface_extension`               | ✅        | ✅        |
//! | `compute`                         | ✅        | ✅        |
//! | `shader_storage_buffer_object`    | ✅        | ✅        |
//!

pub mod compute;
pub mod gpu_power_level;
pub mod memory_flush;
pub mod native_debug;
pub mod shader_storage_buffer_object;
pub mod webgpu_init;
pub mod webgpu_init_from_window;

#[cfg(feature = "surface_extension")]
pub mod surface;

#[cfg(feature = "naga_translation")]
pub mod naga_translation;

pub use compute::{
    CompileComputePassExt, ComputePass, ComputePassSubmitData, Dispatch, DispatchType,
    NewComputeProgramExt,
};
pub use gpu_power_level::GpuPowerLevel;
pub use native_debug::NativeDebugConfiguration;
pub use shader_storage_buffer_object::{
    NewShaderStorageBufferExt, ReadSyncedShaderStorageBufferExt, ShaderStorageBufferId,
};
pub use webgpu_init::WebGpuInit;
pub use webgpu_init_from_window::WebGpuInitFromWindow;

#[cfg(feature = "surface_extension")]
pub use surface::*;

#[cfg(feature = "naga_translation")]
pub use naga_translation::*;

use super::*;

#[derive(Default, Debug, Clone)]
pub struct Extensions {
    pub(crate) extensions: Vec<Extension>,
}

impl Extensions {
    pub fn new() -> Self {
        Self::default()
    }

    /// Configure how many frames ahead the gpu runs ahead.
    /// 2-3 frames should suffice.
    /// Also, this typically does not apply for compute workflows.
    pub fn flight_frames_count(&mut self, count: usize) -> &mut Self {
        self.extensions.push(Extension::FlightFramesCount(count));
        self
    }

    /// Prefer Integrated vs Discrete?
    pub fn gpu_power_level(&mut self, power_level: GpuPowerLevel) -> &mut Self {
        self.extensions.push(Extension::GpuPowerLevel(power_level));
        self
    }

    /// Api dependent debug logs.
    pub fn native_debug(&mut self, cfg: NativeDebugConfiguration) -> &mut Self {
        self.extensions.push(Extension::NativeDebug(cfg));
        self
    }

    /// Explicitly clear out unused gpu memory.
    /// Invoke using [`Context::flush_memory`].
    pub fn memory_flush(&mut self) -> &mut Self {
        self.extensions.push(Extension::MemoryFlush);
        self
    }

    /// Translate from one shader language to another via [`naga`](https://github.com/gfx-rs/naga).
    /// Invoke using [`Context::naga_translate_shader_code`].
    /// Requires that the `naga_translation` feature is enabled for you project.
    #[cfg(feature = "naga_translation")]
    pub fn naga_translation(&mut self) -> &mut Self {
        self.extensions.push(Extension::NagaTranslation);
        self
    }

    /// Initialize the WebGpu Context.
    /// You will need to use [`Context::async_new`] to use this.
    pub fn webgpu_init(&mut self, init: WebGpuInit) -> &mut Self {
        self.extensions.push(Extension::WebGpuInit(init));
        self
    }

    /// Workaround required to initialize the WebGpu Context without async.
    /// This extension is not compatible to [`Context::new`].
    pub fn webgpu_init_from_window(&mut self, init: WebGpuInitFromWindow) -> &mut Self {
        self.extensions.push(Extension::WebGpuInitFromWindow(init));
        self
    }

    /// Rendering to the screen.
    /// Enable this unless you plan to run headlessly.
    /// Be sure to invoke [`Context::set_surface_size`] properly.
    /// Requires that the `surface_extension` feature is enabled for you project.
    #[cfg(feature = "surface_extension")]
    pub fn surface_extension(&mut self, cfg: SurfaceConfiguration) -> &mut Self {
        self.extensions.push(Extension::Surface(cfg));
        self
    }

    /// Enable compute support.
    /// Note that using feature without this extension may or may not work.
    pub fn compute(&mut self) -> &mut Self {
        self.extensions.push(Extension::Compute);
        self
    }

    /// Enable shader storage buffer objects.
    /// Note that using this feature without this extension may or may not work.
    pub fn shader_storage_buffer_object(&mut self) -> &mut Self {
        self.extensions.push(Extension::ShaderStorageBufferObject);
        self
    }
}

#[derive(Debug, Clone)]
pub enum Extension {
    FlightFramesCount(usize),
    GpuPowerLevel(GpuPowerLevel),
    NativeDebug(NativeDebugConfiguration),
    MemoryFlush,
    NagaTranslation,
    WebGpuInitFromWindow(WebGpuInitFromWindow),
    WebGpuInit(WebGpuInit),
    Surface(SurfaceConfiguration),
    Compute,
    ShaderStorageBufferObject,
}