skia-rs-gpu 0.2.1

GPU backends for skia-rs
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! GPU surface abstraction.

use crate::{GpuError, GpuResult, TextureDescriptor, TextureFormat, TextureUsage};
use skia_rs_core::{Color, Rect, Scalar};

/// GPU surface properties.
#[derive(Debug, Clone)]
pub struct GpuSurfaceProps {
    /// Width in pixels.
    pub width: u32,
    /// Height in pixels.
    pub height: u32,
    /// Sample count for MSAA.
    pub sample_count: u32,
    /// Surface format.
    pub format: TextureFormat,
    /// Use sRGB color space.
    pub srgb: bool,
}

impl Default for GpuSurfaceProps {
    fn default() -> Self {
        Self {
            width: 0,
            height: 0,
            sample_count: 1,
            format: TextureFormat::Rgba8Unorm,
            srgb: false,
        }
    }
}

impl GpuSurfaceProps {
    /// Create new surface properties.
    pub fn new(width: u32, height: u32) -> Self {
        Self {
            width,
            height,
            ..Default::default()
        }
    }

    /// Set format.
    pub fn with_format(mut self, format: TextureFormat) -> Self {
        self.format = format;
        self
    }

    /// Set sample count.
    pub fn with_sample_count(mut self, count: u32) -> Self {
        self.sample_count = count;
        self
    }

    /// Enable sRGB.
    pub fn with_srgb(mut self, srgb: bool) -> Self {
        self.srgb = srgb;
        self
    }
}

/// Trait for GPU surfaces.
pub trait GpuSurface: Send + Sync {
    /// Get width.
    fn width(&self) -> u32;

    /// Get height.
    fn height(&self) -> u32;

    /// Get format.
    fn format(&self) -> TextureFormat;

    /// Get sample count.
    fn sample_count(&self) -> u32;

    /// Clear the surface.
    fn clear(&mut self, color: Color);

    /// Present the surface (for display surfaces).
    fn present(&mut self);

    /// Read pixels from the surface.
    fn read_pixels(&self, dst: &mut [u8], dst_row_bytes: usize) -> bool;

    /// Flush pending operations.
    fn flush(&mut self);
}

/// Render pass descriptor.
#[derive(Debug, Clone)]
pub struct RenderPassDescriptor {
    /// Clear color (if any).
    pub clear_color: Option<[f32; 4]>,
    /// Clear depth (if any).
    pub clear_depth: Option<f32>,
    /// Clear stencil (if any).
    pub clear_stencil: Option<u32>,
}

impl Default for RenderPassDescriptor {
    fn default() -> Self {
        Self {
            clear_color: Some([0.0, 0.0, 0.0, 1.0]),
            clear_depth: Some(1.0),
            clear_stencil: Some(0),
        }
    }
}

impl RenderPassDescriptor {
    /// Create with no clearing.
    pub fn no_clear() -> Self {
        Self {
            clear_color: None,
            clear_depth: None,
            clear_stencil: None,
        }
    }

    /// Create with color clear only.
    pub fn color_clear(r: f32, g: f32, b: f32, a: f32) -> Self {
        Self {
            clear_color: Some([r, g, b, a]),
            clear_depth: None,
            clear_stencil: None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_surface_props() {
        let props = GpuSurfaceProps::new(800, 600)
            .with_format(TextureFormat::Bgra8Unorm)
            .with_sample_count(4);

        assert_eq!(props.width, 800);
        assert_eq!(props.height, 600);
        assert_eq!(props.sample_count, 4);
    }

    #[test]
    fn test_render_pass_descriptor() {
        let desc = RenderPassDescriptor::color_clear(1.0, 0.0, 0.0, 1.0);
        assert!(desc.clear_color.is_some());
        assert!(desc.clear_depth.is_none());
    }
}