Skia in Actual Application

Oct 13, 2025 by talynt.org 66 views

Introduction

While experimenting with the open gl context in order to implement the three-d library, I found that Skia completely breaks down while FemtoVG works as expected. This article will delve into the issue, provide reproducible code, and discuss the environment details and product impact.

Bug Description

The issue arises when using Skia as the backend/renderer in the three-d library. The Skia OpenGL context is broken, resulting in a completely different behavior compared to FemtoVG. The images below demonstrate the issue:

FemtoVG

Skia

Skia in Actual Application

As shown in the images, the Skia OpenGL context is broken, resulting in a flashing application window. The window will randomly crash with different errors every time.

Reproducible Code

The code snippet below demonstrates the issue:

export component App inherits Window {
    in property <image> threed-widget-texture <=> threed-container-image.source;
    out property <length> threed-widget-width: threed-container-image.width;
    out property <length> threed-widget-height: threed-container-image.height;
    out property <length> threed-widget-x: threed-container-image.absolute-position.x;
    out property <length> threed-widget-y: threed-container-image.absolute-position.y;

    preferred-width: 500px;
    preferred-height: 600px;
    title: "Slint OpenGL Texture Example";

    threed-container-image := Image {
        width: 100%;
        height: 100%;
    }
}

use std::sync::Arc;
use three_d::{context::*, *};

slint::include_modules!();

struct ModelContainer {
    context: three_d::Context,
    model: Gm<Mesh, ColorMaterial>,
}

impl ModelContainer {
    pub fn new(context: three_d::Context) -> Self {
        let cpu_mesh = CpuMesh {
            positions: Positions::F32(vec![
                vec3(0.5, -0.5, 0.0),  // bottom right
                vec3(-0.5, -0.5, 0.0), // bottom left
                vec3(0.0, 0.5, 0.0),   // top
            ]),
            colors: Some(vec![
                Srgba::new(255, 0, 0, 255), // bottom right
                Srgba::new(0, 255, 0, 255), // bottom left
                Srgba::new(0, 0, 255, 255), // top
            ]),
            ..Default::default()
        };

        let model = Gm::new(Mesh::new(&context, &cpu_mesh), ColorMaterial::default());

        Self { context, model }
    }

    pub fn render(&self, width: u32, height: u32) -> slint::Image {
        let context = &self.context;

        unsafe {
            let texture = context.create_texture().unwrap();
            context.bind_texture(TEXTURE_2D, Some(texture));
            context.tex_image_2d(
                TEXTURE_2D,
                0,
                RGBA as _,
                width as _,
                height as _,
                0,
                RGBA,
                UNSIGNED_BYTE,
                three_d::context::PixelUnpackData::Slice(None),
            );
            context.tex_parameter_i32(TEXTURE_2D, TEXTURE_MIN_FILTER, LINEAR as _);
            context.tex_parameter_i32(TEXTURE_2D, TEXTURE_MAG_FILTER, LINEAR as _);

            let framebuffer = context.create_framebuffer().unwrap();
            context.bind_framebuffer(FRAMEBUFFER, Some(framebuffer));
            context.framebuffer_texture_2d(
                FRAMEBUFFER,
                COLOR_ATTACHMENT0,
                TEXTURE_2D,
                Some(texture),
                0,
            );

            let renderer = RenderTarget::from_framebuffer(context, width, height, framebuffer);

            let camera = Camera::new_perspective(
                renderer.viewport(),
                vec3(0.0, 0.0, 2.0),
                vec3(0.0, 0.0, 0.0),
                vec3(0.0, 1.0, 0.0),
                degrees(45.0),
                0.1,
                10.0,
            );

            renderer.clear(ClearState::color_and_depth(0.8, 0.8, 0.8, 1.0, 1.0));
            renderer.render(camera, &self.model, &[]);

            slint::BorrowedOpenGLTextureBuilder::new_gl_2d_rgba_texture(
                texture.0,
                (width as _, height as _).into(),
            )
            .build()
        }
    }
}

fn main() {
    let app = App::new().unwrap();
    let weak_app = app.as_weak();
    let mut model_container = None;

    app.window()
        .set_rendering_notifier(move |state, graphics_api| match state {
            slint::RenderingState::RenderingSetup => {
                let gl_context = match graphics_api {
                    slint::GraphicsAPI::NativeOpenGL { get_proc_address } => unsafe {
                        three_d::context::Context::from_loader_function_cstr(get_proc_address)
                    },
                    _ => return,
                };

                if let Ok(context) = three_d::Context::from_gl_context(Arc::new(gl_context)) {
                    model_container = Some(ModelContainer::new(context));
                }
            }
            slint::RenderingState::BeforeRendering => {
                if let (Some(model_container), Some(app)) = (&model_container, weak_app.upgrade()) {
                    let image = model_container.render(
                        app.get_threed_widget_width() as _,
                        app.get_threed_widget_height() as _,
                    );
                    app.set_threed_widget_texture(image);
                    app.window().request_redraw();
                }
            }
            _ => {}
        })
        .unwrap();
    app.run().unwrap();
}

Environment Details

The environment details are as follows:

Slint Version: 1.10.0
Platform/OS: Fedora Linux 41 | NVidia 570.86.16 | Wayland
Programming Language: Rust
Backend/Renderer: FemtoVG | Skia

Product Impact

The use of Skia as the backend/renderer in the three-d library is a major blocker due to the broken Skia OpenGL context. The Path objects behave as expected in Skia, but FemtoVG produces completely different results. This issue affects the use of the gl context for other libraries, making it a significant problem.

Q: What is the issue with Skia OpenGL context?

A: The issue with Skia OpenGL context is that it is broken compared to FemtoVG. This means that Skia does not behave as expected when used as the backend/renderer in the three-d library, resulting in a completely different behavior.

Q: What are the symptoms of the broken Skia OpenGL context?

A: The symptoms of the broken Skia OpenGL context include:

A flashing application window
Random crashes with different errors every time
Inconsistent behavior when using Path objects

Q: What is the impact of the broken Skia OpenGL context?

A: The impact of the broken Skia OpenGL context is significant. It makes it difficult to use Skia as the backend/renderer in the three-d library, as the Path objects behave differently compared to FemtoVG. This can lead to inconsistencies in the application's behavior and make it harder to develop and maintain.

Q: What are the environment details that are affected by the broken Skia OpenGL context?

A: The environment details that are affected by the broken Skia OpenGL context include:

Slint Version: 1.10.0
Platform/OS: Fedora Linux 41 | NVidia 570.86.16 | Wayland
Programming Language: Rust
Backend/Renderer: FemtoVG | Skia

Q: What is the recommended solution to the broken Skia OpenGL context?

A: The recommended solution to the broken Skia OpenGL context is to use FemtoVG as the backend/renderer in the three-d library. FemtoVG produces consistent results and behaves as expected, making it a more reliable choice.

Q: Can the broken Skia OpenGL context be fixed?

A: It is possible to fix the broken Skia OpenGL context, but it would require significant effort and resources. The issue is likely due to a bug in the Skia library, and fixing it would require collaboration between the Skia developers and the three-d library developers.

Q: What are the next steps to resolve the broken Skia OpenGL context?

A: The next steps to resolve the broken Skia OpenGL context are:

Report the issue to the Skia developers and the three-d library developers
Collaborate with the developers to identify the root cause of the issue
Work together to fix the issue and provide a solution

Q: What is the timeline for resolving the broken Skia OpenGL context?

A: The timeline for resolving the broken Skia OpenGL context is uncertain. It will depend on the complexity of the issue, the availability of resources, and the collaboration between the developers. However, it is essential to prioritize the resolution of this issue to ensure the stability and consistency of the three-d library.

Q: What is the expected outcome of resolving the broken Skia OpenGL context?

A: The expected outcome of resolving the broken Skia OpenGL context is a stable and consistent three-d library that behaves as expected. This will enable developers to use the library with confidence, knowing that it will produce consistent results and behave as expected.