sugarloaf 0.3.1

Sugarloaf is Rio rendering engine, designed to be multiplatform. It is based on WebGPU, Rust library for Desktops and WebAssembly for Web (JavaScript). This project is created and maintained for Rio terminal purposes but feel free to use it.
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

#[cfg(target_os = "macos")]
pub mod metal;
pub mod webgpu;

use crate::sugarloaf::{SugarloafBackend, SugarloafWindow};
use crate::{SugarloafRenderer, SugarloafWindowSize};

pub struct Context<'a> {
    pub inner: ContextType<'a>,
}

#[allow(clippy::large_enum_variant)]
pub enum ContextType<'a> {
    Wgpu(webgpu::WgpuContext<'a>),
    #[cfg(target_os = "macos")]
    Metal(metal::MetalContext),
}

impl Context<'_> {
    pub fn new<'a>(
        sugarloaf_window: SugarloafWindow,
        renderer_config: SugarloafRenderer,
    ) -> Context<'a> {
        let inner = match renderer_config.backend {
            SugarloafBackend::Wgpu(backends) => ContextType::Wgpu(
                webgpu::WgpuContext::new(sugarloaf_window, renderer_config, backends),
            ),
            #[cfg(target_os = "macos")]
            SugarloafBackend::Metal => {
                ContextType::Metal(metal::MetalContext::new(sugarloaf_window))
            }
        };

        Context { inner }
    }

    #[inline]
    pub fn scale(&self) -> f32 {
        match &self.inner {
            ContextType::Wgpu(ctx) => ctx.scale,
            #[cfg(target_os = "macos")]
            ContextType::Metal(ctx) => ctx.scale,
        }
    }

    #[inline]
    pub fn set_scale(&mut self, scale: f32) {
        match &mut self.inner {
            ContextType::Wgpu(ctx) => {
                ctx.set_scale(scale);
            }
            #[cfg(target_os = "macos")]
            ContextType::Metal(ctx) => {
                ctx.set_scale(scale);
            }
        }
    }

    #[inline]
    pub fn size(&self) -> SugarloafWindowSize {
        match &self.inner {
            ContextType::Wgpu(ctx) => ctx.size,
            #[cfg(target_os = "macos")]
            ContextType::Metal(ctx) => ctx.size,
        }
    }

    pub fn resize(&mut self, width: u32, height: u32) {
        if width == 0 || height == 0 {
            return;
        }

        match &mut self.inner {
            ContextType::Wgpu(ctx) => ctx.resize(width, height),
            #[cfg(target_os = "macos")]
            ContextType::Metal(ctx) => ctx.resize(width, height),
        }
    }

    #[inline]
    pub fn supports_f16(&self) -> bool {
        match &self.inner {
            ContextType::Wgpu(ctx) => ctx.supports_f16(),
            #[cfg(target_os = "macos")]
            ContextType::Metal(ctx) => ctx.supports_f16(),
        }
    }
}