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

use raw_window_handle::{
    HasDisplayHandle, HasRawWindowHandle, HasWindowHandle, RawWindowHandle, WindowHandle,
};
use std::{convert::Infallible, fmt};
use wasm_bindgen::{JsCast, JsValue};
use web_sys::{HtmlCanvasElement, WebGl2RenderingContext};

use crate::{
    generic::{
        Capabilities, DeviceCapabilities, DeviceDesc, DeviceError, FamilyCapabilities, Features,
        QueueFlags,
    },
    SurfaceError,
};

use super::{Device, Queue, Surface};

pub struct Instance {
    capabilities: Capabilities,
}

impl Instance {
    pub fn load() -> Result<Self, DeviceError> {
        // Check if WebGL2RenderingContext is available
        if js_sys::Reflect::get(&js_sys::global(), &"WebGL2RenderingContext".into()).is_err() {
            return Err(DeviceError::DeviceLost);
        }

        // WebGL always has one device (the GPU) with one queue family
        Ok(Instance {
            capabilities: Capabilities {
                devices: vec![DeviceCapabilities {
                    features: Features::SURFACE, // WebGL always supports surfaces
                    families: vec![FamilyCapabilities {
                        queue_flags: QueueFlags::GRAPHICS | QueueFlags::TRANSFER,
                        queue_count: 1, // WebGL has single queue
                    }],
                }],
            },
        })
    }

    fn create_context(canvas: &HtmlCanvasElement) -> Result<WebGl2RenderingContext, DeviceError> {
        let context = canvas
            .get_context("webgl2")
            .map_err(|err| {
                tracing::error!("Failed to get WebGL2 context: {:?}", err);
                DeviceError::DeviceLost
            })?
            .ok_or(DeviceError::DeviceLost)?
            .dyn_into::<WebGl2RenderingContext>()
            .unwrap();

        // Enable standard WebGL2 features
        context.enable(WebGl2RenderingContext::DEPTH_TEST);
        context.enable(WebGl2RenderingContext::CULL_FACE);

        Ok(context)
    }
}

impl fmt::Debug for Instance {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple("Instance").finish()
    }
}

impl crate::traits::Resource for Instance {}

#[hidden_trait::expose]
impl crate::traits::Instance for Instance {
    fn capabilities(&self) -> &Capabilities {
        &self.capabilities
    }

    fn new_device(&self, desc: DeviceDesc) -> Result<(Device, Vec<Queue>), DeviceError> {
        unimplemented!("WebGL does not support device creation without a surface")
    }

    fn new_device_with_surface(
        &self,
        info: DeviceDesc,
        window: &impl HasWindowHandle,
        display: &impl HasDisplayHandle,
    ) -> Result<(Device, Vec<Queue>, Surface), SurfaceError> {
        let handle = window.window_handle().map_err(|err| {
            tracing::error!("Failed to get window handle: {:?}", err);
            SurfaceError::SurfaceLost
        })?;

        match handle.as_raw() {
            RawWindowHandle::WebCanvas(web_canvas) => {}
            RawWindowHandle::Web(web) => {}
        }

        let context = Self::create_context(desc.canvas).map_err(|e| DeviceError::DeviceLost)?;

        let device = Device::new(context);

        let queues = vec![Queue::new(device.clone())];

        Ok((device, queues))
    }
}