skia-safe 0.97.0

Safe Skia Bindings for Rust
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

pub mod backend_formats {
    use skia_bindings as sb;

    use crate::{
        gpu::{
            vk::{Format, YcbcrConversionInfo},
            BackendFormat,
        },
        prelude::*,
    };

    pub fn make_vk(
        format: Format,
        will_use_drm_format_modifiers: impl Into<Option<bool>>,
    ) -> BackendFormat {
        let will_use_drm_format_modifiers = will_use_drm_format_modifiers.into().unwrap_or(false);
        BackendFormat::construct(|bf| unsafe {
            sb::C_GrBackendFormat_ConstructVk(bf, format, will_use_drm_format_modifiers)
        })
        .assert_valid()
    }

    pub fn make_vk_ycbcr(
        conversion_info: &YcbcrConversionInfo,
        will_use_drm_format_modifiers: impl Into<Option<bool>>,
    ) -> BackendFormat {
        let will_use_drm_format_modifiers = will_use_drm_format_modifiers.into().unwrap_or(false);
        BackendFormat::construct(|bf| unsafe {
            sb::C_GrBackendFormat_ConstructVk2(
                bf,
                conversion_info.native(),
                will_use_drm_format_modifiers,
            )
        })
        .assert_valid()
    }

    pub fn as_vk_format(backend_format: &BackendFormat) -> Option<Format> {
        let mut r = Format::UNDEFINED;
        unsafe { sb::C_GrBackendFormats_AsVkFormat(backend_format.native(), &mut r) }.then_some(r)
    }

    pub fn get_vk_ycbcr_conversion_info(
        backend_format: &BackendFormat,
    ) -> Option<&YcbcrConversionInfo> {
        unsafe {
            YcbcrConversionInfo::from_native_ptr(sb::C_GrBackendFormats_GetVkYcbcrConversionInfo(
                backend_format.native(),
            ))
            .into_non_null()
            .map(|r| r.as_ref())
        }
    }
}

pub mod backend_textures {
    use skia_bindings as sb;

    use crate::{
        gpu::{
            vk::{ImageInfo, ImageLayout},
            BackendTexture,
        },
        prelude::*,
    };

    #[allow(clippy::missing_safety_doc)]
    pub unsafe fn make_vk(
        (width, height): (i32, i32),
        vk_info: &ImageInfo,
        label: impl AsRef<str>,
    ) -> BackendTexture {
        let label = label.as_ref().as_bytes();
        BackendTexture::from_native_if_valid(sb::C_GrBackendTexture_newVk(
            width,
            height,
            vk_info.native(),
            label.as_ptr() as _,
            label.len(),
        ))
        .unwrap()
    }

    pub fn get_vk_image_info(texture: &BackendTexture) -> Option<ImageInfo> {
        unsafe {
            // constructor not available.
            let mut image_info = ImageInfo::default();

            sb::C_GrBackendTextures_GetVkImageInfo(texture.native(), image_info.native_mut())
                .then_some(image_info)
        }
    }

    pub fn set_vk_image_layout(
        texture: &mut BackendTexture,
        layout: ImageLayout,
    ) -> &mut BackendTexture {
        unsafe { sb::C_GrBackendTextures_SetVkImageLayout(texture.native_mut(), layout) }
        texture
    }
}

pub mod backend_render_targets {
    use skia_bindings as sb;

    use crate::{
        gpu::{
            vk::{ImageInfo, ImageLayout},
            BackendRenderTarget,
        },
        prelude::*,
    };

    pub fn make_vk((width, height): (i32, i32), info: &ImageInfo) -> BackendRenderTarget {
        BackendRenderTarget::construct(|target| unsafe {
            sb::C_GrBackendRenderTargets_ConstructVk(target, width, height, info.native())
        })
    }

    pub fn get_vk_image_info(target: &BackendRenderTarget) -> Option<ImageInfo> {
        let mut info = ImageInfo::default();
        unsafe { sb::C_GrBackendRenderTargets_GetVkImageInfo(target.native(), info.native_mut()) }
            .then_some(info)
    }

    pub fn set_vk_image_layout(
        target: &mut BackendRenderTarget,
        layout: ImageLayout,
    ) -> &mut BackendRenderTarget {
        unsafe { sb::C_GrBackendRenderTargets_SetVkImageLayout(target.native_mut(), layout) }
        target
    }
}