retro-rs 0.5.6

A Rust front-end for libretro cores.
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

use crate::gfx::Gfx;
use rust_libretro_sys::{retro_hw_context_type, retro_hw_render_callback, retro_system_av_info};
use surfman::{Connection, ContextAttributeFlags, ContextAttributes, GLApi, GLVersion};
use surfman::{SurfaceAccess, SurfaceType};

pub struct GlGfx {}

impl Gfx for GlGfx {
    fn preferred_api(&self) -> retro_hw_context_type {
        retro_hw_context_type::RETRO_HW_CONTEXT_OPENGL
    }
    fn prepare_hardware_context(
        &mut self,
        av: retro_system_av_info,
        cb: &mut retro_hw_render_callback,
    ) -> bool {
        let ctype = cb.context_type;
        if ctype == retro_hw_context_type::RETRO_HW_CONTEXT_VULKAN
            || ctype == retro_hw_context_type::RETRO_HW_CONTEXT_DIRECT3D
        {
            println!("Tried to load unsupported gfx context type {ctype:?}");
            return false;
        }
        let Ok(connection) = Connection::new() else {
            println!("Could not create connection");
            return false;
        };
        let Ok(adapter) = connection.create_adapter() else {
            println!("Could not obtain adapter");
            return false;
        };
        let Ok(mut device) = connection.create_device(&adapter) else {
            println!("Could not create device");
            return false;
        };
        let attributes = ContextAttributes {
            version: GLVersion::new(3, 3),
            flags: ContextAttributeFlags::DEPTH | ContextAttributeFlags::STENCIL,
        };
        let Ok(context_descriptor) = device.create_context_descriptor(&attributes) else {
            println!("Failed to create context descriptor");
            return false;
        };
        let Ok(mut context) = device.create_context(&context_descriptor, None) else {
            println!("Failed to create context");
            return false;
        };
        let Ok(w) = i32::try_from(av.geometry.max_width).or(i32::try_from(av.geometry.base_width))
        else {
            println!("Invalid context width in {:?}", av.geometry);
            return false;
        };
        let Ok(h) =
            i32::try_from(av.geometry.max_height).or(i32::try_from(av.geometry.base_height))
        else {
            println!("Invalid context height in {:?}", av.geometry);
            return false;
        };

        let Ok(surface) = device.create_surface(
            &context,
            SurfaceAccess::GPUOnly,
            SurfaceType::Generic {
                size: euclid::Size2D::new(w, h),
            },
        ) else {
            println!("Failed to create surface");
            return false;
        };
        device
            .bind_surface_to_context(&mut context, surface)
            .unwrap();
        cb.version_major = 3;
        cb.version_minor = 3;
        cb.bottom_left_origin = true;
        cb.cache_context = true;
        cb.debug_context = false;
        //cb.context_reset = ;
        //cb.context_destroy = ;
        //cb.get_proc_address = ;
        true
    }
}