scenevm 0.9.7

A GPU-based layer renderer with configurable compute shaders for Eldiron.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Native file dialogs for desktop platforms
//! Handles export, save, open, and import dialogs using rfd

#[cfg(all(feature = "ui", not(target_arch = "wasm32"), not(target_os = "ios")))]
use crate::{SceneVM, SceneVMApp};

/// Handle export requests with native file dialog
#[cfg(all(feature = "ui", not(target_arch = "wasm32"), not(target_os = "ios")))]
pub fn handle_export<T: SceneVMApp>(app: &mut T, vm: &mut SceneVM, format: &str, filename: &str) {
    use rfd::FileDialog;

    let extension = format.to_lowercase();
    let filter_name = match extension.as_str() {
        "png" => "PNG Image",
        "jpg" | "jpeg" => "JPEG Image",
        "json" => "JSON File",
        _ => "File",
    };

    let default_name = if filename.is_empty() {
        format!("export.{}", extension)
    } else {
        format!("{}.{}", filename, extension)
    };

    if let Some(path) = FileDialog::new()
        .add_filter(filter_name, &[&extension])
        .set_file_name(&default_name)
        .save_file()
    {
        // Try app-specific export first
        if let Some(data) = app.export_data(vm, &extension) {
            if let Err(e) = std::fs::write(&path, data) {
                eprintln!("Failed to write export file: {}", e);
            } else {
            }
        } else {
            eprintln!("Export format '{}' not supported by this app", extension);
        }
    }
}

/// Handle save requests with native file dialog
#[cfg(all(feature = "ui", not(target_arch = "wasm32"), not(target_os = "ios")))]
pub fn handle_save<T: SceneVMApp>(app: &mut T, vm: &mut SceneVM, filename: &str, extension: &str) {
    use rfd::FileDialog;

    let default_name = if filename.is_empty() {
        format!("project.{}", extension)
    } else {
        format!("{}.{}", filename, extension)
    };

    let filter_name = "Project File";

    if let Some(path) = FileDialog::new()
        .add_filter(filter_name, &[extension])
        .set_file_name(&default_name)
        .save_file()
    {
        if let Some(json) = app.save_to_json(vm) {
            if let Err(e) = std::fs::write(&path, json) {
                eprintln!("Failed to save project: {}", e);
            } else {
            }
        } else {
            eprintln!("Save not implemented for this app");
        }
    }
}

/// Handle open requests with native file dialog
#[cfg(all(feature = "ui", not(target_arch = "wasm32"), not(target_os = "ios")))]
pub fn handle_open<T: SceneVMApp>(app: &mut T, vm: &mut SceneVM, extension: &str) {
    use rfd::FileDialog;

    if let Some(path) = FileDialog::new()
        .add_filter("Project File", &[extension])
        .pick_file()
    {
        match std::fs::read_to_string(&path) {
            Ok(json) => {
                if app.load_from_json(vm, &json) {
                } else {
                    eprintln!("Failed to load project");
                }
            }
            Err(e) => {
                eprintln!("Failed to read file: {}", e);
            }
        }
    }
}

/// Handle import requests with native file dialog
#[cfg(all(feature = "ui", not(target_arch = "wasm32"), not(target_os = "ios")))]
pub fn handle_import<T: SceneVMApp>(_app: &mut T, _vm: &mut SceneVM, file_types: &[String]) {
    use rfd::FileDialog;

    let mut dialog = FileDialog::new();

    if !file_types.is_empty() {
        let extensions: Vec<&str> = file_types.iter().map(|s| s.as_str()).collect();
        dialog = dialog.add_filter("Files", &extensions);
    }

    if let Some(_path) = dialog.pick_file() {

        // Apps can implement custom import logic
    }
}