rafx-plugins 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
110
111
112
113
114
115

use rafx::render_feature_extract_job_predule::*;

use super::*;
use hydrate_base::handle::Handle;
use rafx::assets::{AssetManagerExtractRef, AssetManagerRenderResource, MaterialAsset};
use rafx::graph::SwapchainSurfaceInfo;
use rafx::renderer::SwapchainRenderResource;
use std::marker::PhantomData;

pub struct EguiExtractJob<'extract> {
    egui_manager: EguiManager,
    swapchain_surface_info: SwapchainSurfaceInfo,
    asset_manager: AssetManagerExtractRef,
    egui_material: Handle<MaterialAsset>,
    phantom_data: PhantomData<&'extract ()>,
}

impl<'extract> EguiExtractJob<'extract> {
    pub fn new(
        extract_context: &RenderJobExtractContext<'extract>,
        frame_packet: Box<EguiFramePacket>,
        egui_material: Handle<MaterialAsset>,
    ) -> Arc<dyn RenderFeatureExtractJob<'extract> + 'extract> {
        #[cfg(feature = "egui-winit")]
        let egui_manager = extract_context
            .extract_resources
            .fetch_mut::<WinitEguiManager>()
            .egui_manager();

        #[cfg(feature = "egui-sdl2")]
        let egui_manager = extract_context
            .extract_resources
            .fetch_mut::<Sdl2EguiManager>()
            .egui_manager();

        Arc::new(ExtractJob::new(
            Self {
                egui_manager,
                swapchain_surface_info: extract_context
                    .render_resources
                    .fetch::<SwapchainRenderResource>()
                    .surface_info()
                    .unwrap()
                    .swapchain_surface_info
                    .clone(),
                asset_manager: extract_context
                    .render_resources
                    .fetch::<AssetManagerRenderResource>()
                    .extract_ref(),
                egui_material,
                phantom_data: PhantomData,
            },
            extract_context,
            frame_packet,
        ))
    }
}

impl<'extract> ExtractJobEntryPoints<'extract> for EguiExtractJob<'extract> {
    fn begin_per_frame_extract(
        &self,
        context: &ExtractPerFrameContext<'extract, '_, Self>,
    ) {
        let egui_draw_data = self.egui_manager.take_draw_data();
        let view_ubo = {
            let pixels_per_point = match &egui_draw_data {
                Some(data) => data.pixels_per_point,
                None => 1.0,
            };

            let top = 0.0;
            let bottom = self.swapchain_surface_info.extents.height as f32 / pixels_per_point;

            let view_proj = glam::Mat4::orthographic_rh(
                0.0,
                self.swapchain_surface_info.extents.width as f32 / pixels_per_point,
                bottom,
                top,
                -100.0,
                100.0,
            );

            EguiUniformBufferObject {
                mvp: view_proj.to_cols_array_2d(),
            }
        };

        context
            .frame_packet()
            .per_frame_data()
            .set(EguiPerFrameData {
                egui_draw_data,
                egui_material_pass: self
                    .asset_manager
                    .committed_asset(&self.egui_material)
                    .unwrap()
                    .get_single_material_pass()
                    .ok(),
                view_ubo,
            });
    }

    fn feature_debug_constants(&self) -> &'static RenderFeatureDebugConstants {
        super::render_feature_debug_constants()
    }

    fn feature_index(&self) -> RenderFeatureIndex {
        super::render_feature_index()
    }

    type RenderObjectInstanceJobContextT = DefaultJobContext;
    type RenderObjectInstancePerViewJobContextT = DefaultJobContext;

    type FramePacketDataT = EguiRenderFeatureTypes;
}