sophus_renderer 0.14.0

wgpu-based renderer
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

use eframe::{
    egui_wgpu,
    epaint::mutex::RwLock,
};

use crate::{
    prelude::*,
    types::DOG_MULTISAMPLE_COUNT,
};

/// The render context
#[derive(Clone)]
pub struct RenderContext {
    /// state
    pub egui_wgpu_renderer: Arc<RwLock<egui_wgpu::Renderer>>,
    /// device
    pub wgpu_device: Arc<wgpu::Device>,
    /// queue
    pub wgpu_queue: Arc<wgpu::Queue>,
    /// adapter
    pub wgpu_adapter: Arc<wgpu::Adapter>,
}

impl RenderContext {
    /// Creates a render context from a egui_wgpu render state
    pub fn from_render_state(render_state: &egui_wgpu::RenderState) -> Self {
        RenderContext {
            wgpu_adapter: render_state.adapter.clone(),
            wgpu_device: render_state.device.clone(),
            wgpu_queue: render_state.queue.clone(),
            egui_wgpu_renderer: render_state.renderer.clone(),
        }
    }

    /// Creates a new render context, include wgpu device, adapter and queue
    /// as well as egui_wgpu renderer.
    pub async fn new() -> Self {
        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
            backends: wgpu::Backends::all(),
            ..Default::default()
        });
        let adapter = instance
            .request_adapter(&wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::default(),
                compatible_surface: None,
                force_fallback_adapter: false,
            })
            .await
            .unwrap();
        let (device, queue) = adapter
            .request_device(&Default::default(), None)
            .await
            .unwrap();

        let renderer = egui_wgpu::Renderer::new(
            &device,
            wgpu::TextureFormat::Rgba8Unorm,
            None,
            DOG_MULTISAMPLE_COUNT,
        );

        RenderContext {
            egui_wgpu_renderer: Arc::new(RwLock::new(renderer)),
            wgpu_device: device.into(),
            wgpu_queue: queue.into(),
            wgpu_adapter: adapter.into(),
        }
    }

    /// Creates a render context from an eframe creation context.
    pub fn from_egui_cc(cc: &eframe::CreationContext) -> Self {
        RenderContext::from_render_state(cc.wgpu_render_state.as_ref().unwrap())
    }
}