bevy_webgl2 0.5.2

A webgl2 wasm32 render backend for Bevy Engine
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

use crate::renderer::{WebGL2RenderContext, WebGL2RenderResourceContext};
use bevy::ecs::world::{Mut, World};
use bevy::render::{
    render_graph::{
        DependentNodeStager, Edge, NodeId, RenderGraph, RenderGraphStager, ResourceSlots,
    },
    renderer::RenderResourceContext,
};
use std::sync::Arc;

use bevy::utils::HashMap;
use parking_lot::RwLock;
use std::cell::{Ref, RefCell};

#[derive(Default)]
pub struct Device {
    context: RefCell<Option<web_sys::WebGl2RenderingContext>>,
}

impl Device {
    pub fn get_context(&self) -> std::cell::Ref<web_sys::WebGl2RenderingContext> {
        return Ref::map(self.context.borrow(), |t| {
            t.as_ref().expect("webgl context is set")
        });
    }

    pub fn set_context(&self, context: web_sys::WebGl2RenderingContext) {
        *self.context.borrow_mut() = Some(context);
    }
}

impl std::fmt::Debug for Device {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&format!("Device: {:?}", self.context.borrow()))
    }
}

unsafe impl Send for Device {}
unsafe impl Sync for Device {}

#[derive(Default)]
pub struct WebGL2Renderer {
    pub device: Arc<Device>,
}

impl WebGL2Renderer {
    pub fn run_graph(&mut self, world: &mut World) {
        world.resource_scope(|world, mut render_graph: Mut<RenderGraph>| {
            render_graph.prepare(world);
            // stage nodes
            let mut stager = DependentNodeStager::loose_grouping();
            let stages = stager.get_stages(&render_graph).unwrap();
            let mut borrowed = stages.borrow(&mut render_graph);

            let render_resource_context = {
                let context = world
                    .get_resource::<Box<dyn RenderResourceContext>>()
                    .unwrap();
                context
                    .downcast_ref::<WebGL2RenderResourceContext>()
                    .unwrap()
                    .clone()
            };

            let node_outputs: Arc<RwLock<HashMap<NodeId, ResourceSlots>>> = Default::default();
            for stage in borrowed.iter_mut() {
                // TODO: sort jobs and slice by "amount of work" / weights
                // stage.jobs.sort_by_key(|j| j.node_states.len());

                let chunk_size = stage.jobs.len();
                for jobs_chunk in stage.jobs.chunks_mut(chunk_size) {
                    let render_resource_context = render_resource_context.clone();
                    let node_outputs = node_outputs.clone();
                    let mut render_context =
                        WebGL2RenderContext::new(self.device.clone(), render_resource_context);
                    for job in jobs_chunk.iter_mut() {
                        for node_state in job.node_states.iter_mut() {
                            // bind inputs from connected node outputs
                            for (i, mut input_slot) in node_state.input_slots.iter_mut().enumerate()
                            {
                                if let Edge::SlotEdge {
                                    output_node,
                                    output_index,
                                    ..
                                } = node_state.edges.get_input_slot_edge(i).unwrap()
                                {
                                    let node_outputs = node_outputs.read();
                                    let outputs =
                                        if let Some(outputs) = node_outputs.get(output_node) {
                                            outputs
                                        } else {
                                            panic!("node inputs not set")
                                        };

                                    let output_resource =
                                        outputs.get(*output_index).expect("output should be set");
                                    input_slot.resource = Some(output_resource);
                                } else {
                                    panic!("no edge connected to input")
                                }
                            }
                            node_state.node.update(
                                world,
                                &mut render_context,
                                &node_state.input_slots,
                                &mut node_state.output_slots,
                            );
                            node_outputs
                                .write()
                                .insert(node_state.id, node_state.output_slots.clone());
                        }
                    }
                }
            }
        });
    }

    pub fn update(&mut self, world: &mut World) {
        self.run_graph(world);
        if let Some(render_resource_context) =
            world.get_resource::<Box<dyn RenderResourceContext>>()
        {
            render_resource_context.drop_all_swap_chain_textures();
            render_resource_context.clear_bind_groups();
        }
    }
}