hydrate_editor/
lib.rs

1mod app;
2mod ui;
3
4mod db_state;
5pub use db_state::DbState;
6
7mod persistent_app_state;
8
9pub mod action_queue;
10
11mod egui_debug_ui;
12mod fonts;
13mod image_loader;
14mod modal_action;
15mod ui_state;
16
17pub use egui;
18pub use egui_extras;
19use hydrate_model::{AssetPathCache, EditorModelWithCache, SchemaSet};
20
21use crate::app::HydrateEditorApp;
22use crate::inspector_system::InspectorRegistry;
23pub use crate::ui::components::inspector_system;
24use hydrate_model::pipeline::{
25    AssetEngine, AssetPluginRegistryBuilders, HydrateProjectConfiguration, ImportJobToQueue,
26};
27
28pub struct Editor {
29    db_state: DbState,
30    asset_engine: AssetEngine,
31    inspector_registry: InspectorRegistry,
32}
33
34impl Editor {
35    pub fn inspector_registry_mut(&mut self) -> &mut InspectorRegistry {
36        &mut self.inspector_registry
37    }
38
39    pub fn schema_set(&self) -> &SchemaSet {
40        self.db_state.editor_model.schema_set()
41    }
42
43    pub fn new(
44        project_configuration: HydrateProjectConfiguration,
45        asset_plugin_registry: AssetPluginRegistryBuilders,
46    ) -> Self {
47        profiling::scope!("Hydrate Initialization");
48
49        let schema_set = {
50            profiling::scope!("Load Schema");
51            DbState::load_schema(&project_configuration)
52        };
53
54        let registries = asset_plugin_registry.finish(&schema_set);
55
56        let mut import_job_to_queue = ImportJobToQueue::default();
57        let mut db_state = DbState::load(
58            &schema_set,
59            &registries.importer_registry,
60            &project_configuration,
61            &mut import_job_to_queue,
62        );
63
64        let asset_path_cache = AssetPathCache::build(&db_state.editor_model).unwrap();
65        let mut editor_model_with_cache = EditorModelWithCache {
66            editor_model: &mut db_state.editor_model,
67            asset_path_cache: &asset_path_cache,
68        };
69
70        let mut asset_engine = {
71            profiling::scope!("Create Asset Engine");
72            AssetEngine::new(
73                &schema_set,
74                registries,
75                &mut editor_model_with_cache,
76                &project_configuration,
77            )
78        };
79
80        {
81            profiling::scope!("Queue import operations");
82            if !import_job_to_queue.is_empty() {
83                asset_engine.queue_import_operation(import_job_to_queue);
84            }
85        }
86        let inspector_registry = InspectorRegistry::default();
87
88        Self {
89            db_state,
90            asset_engine,
91            inspector_registry,
92        }
93    }
94
95    pub fn run(self) -> eframe::Result<()> {
96        let native_options = eframe::NativeOptions {
97            viewport: egui::ViewportBuilder::default().with_inner_size([450.0, 300.0]),
98            //.with_min_inner_size([900.0, 650.0]),
99            follow_system_theme: false,
100            default_theme: eframe::Theme::Dark,
101            centered: true,
102            window_builder: Some(Box::new(|mut builder| {
103                builder.position = Some(egui::pos2(1000.0, 0.0));
104                builder.inner_size = Some(egui::vec2(700.0, 500.0));
105                builder
106            })),
107            ..Default::default()
108        };
109
110        eframe::run_native(
111            "Hydrate Editor",
112            native_options,
113            Box::new(|cc| {
114                Box::new(HydrateEditorApp::new(
115                    cc,
116                    self.db_state,
117                    self.asset_engine,
118                    self.inspector_registry,
119                ))
120            }),
121        )
122    }
123}