Integrate AO Baker into Editor

Author: TitanNano

blender/bake_ao.py

@@ -47,7 +47,7 @@ def export_gltf(object, file_path):
     bpy.ops.export_scene.gltf(
         filepath=file_path,
         export_format="GLTF_SEPARATE",
-        export_keep_originals=False,
+        export_keep_originals=True,
         export_extras=True,
         use_mesh_edges=True,
         use_selection=True,
@@ -288,9 +288,11 @@ def create_ground_ao_catcher(object: bpy.types.Object) -> bpy.types.Object:
     for file in config.file:
         clear_scene()
 
-        print("baking Ambient Occlusion texture for " + file + "...")
+        print("File|" + file, flush=True)
+        print("baking Ambient Occlusion texture for " + file + "...", flush=True)
 
         # Import the glTF model
+        print("Progress|Importing model...", flush=True)
         object = import_gltf(file)
 
         # Specify the output path for the AO map
@@ -303,22 +305,35 @@ def create_ground_ao_catcher(object: bpy.types.Object) -> bpy.types.Object:
         ao_ground_output_path = str(ao_output_path.with_stem(ao_output_path.stem + '_ground'))
         ao_output_path = str(ao_output_path)
 
+        print("Progress|Creating UV map...", flush=True)
         create_uv_map(object)
+        print("Progress|Baking Ambient Occlusion...", flush=True)
         bake_ambient_occlusion(object, ao_output_path)
+        print("Progress|Setting up Ground Ambient Occlusion...", flush=True)
+
         ground_ao_catcher = create_ground_ao_catcher(object)
+
+        print("Progress|Baking Ground Ambient Occlusion...", flush=True)
         bake_ambient_occlusion(ground_ao_catcher, ao_ground_output_path, is_orm=True)
 
-        print("Ambient Occlusion map baked and saved successfully.")
+        print("Ambient Occlusion map baked and saved successfully.", flush=True)
 
+        print("Progress|Clearing Scene...", flush=True)
         clear_scene()
 
-        object= import_gltf(file)
+        print("Progress|Re-Importing model...", flush=True)
+        object = import_gltf(file)
+
+        print("Progress|Re-Creating UV Map...", flush=True)
         create_uv_map(object)
+        print("Progress|Setting up Ambient Occlusion map...", flush=True)
         setup_ao_map(object, ao_output_path)
 
         ao_ground_object = create_ground_ao_catcher(object)
+        print("Progress|Setting up Ground Ambient Occlusion map...", flush=True)
         setup_ao_decal(ao_ground_object, ao_ground_output_path)
 
         file = str(Path(file).with_suffix(".gltf"))
 
+        print("Progress|Exporting modified model...", flush=True)
         export_gltf(object, file)

native/Cargo.lock

@@ -7,7 +7,7 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-godot = { version = "0.2.2", features = ["experimental-threads", "api-4-3"] }
+godot = { version = "0.2.3", features = ["experimental-threads", "api-4-3"] }
 godot-rust-script = { git = "https://github.com/titannano/godot-rust-script", rev = "46b151f558370c260fa1e79502637f128ea7bb7f" }
 lerp = "0.4.0"
 backtrace = "0.3.64"

native/Cargo.toml

@@ -1,42 +1,114 @@
+mod ao_baker;
 mod building_imports;
 mod gltf;
+pub mod ui;
 
+use std::num::NonZero;
+
+use ao_baker::AoBaker;
 use gltf::GltfImporter;
+use godot::builtin::{Dictionary, VariantType};
 use godot::classes::notify::NodeNotification;
-use godot::classes::{EditorPlugin, GltfDocument, IEditorPlugin};
-use godot::obj::{Base, Gd, NewGd, WithBaseField};
+use godot::classes::{EditorPlugin, GltfDocument, IEditorPlugin, ProjectSettings};
+use godot::global::PropertyHint;
+use godot::obj::{Base, Gd, NewGd, OnReady, WithBaseField};
 use godot::register::{godot_api, GodotClass};
 
 use building_imports::SetupBuildingImports;
 
 use crate::engine_callable;
+use crate::util::variant_type_default_value;
 
 #[derive(GodotClass)]
 #[class(tool, base=EditorPlugin)]
 struct EditorExtension {
     setup_building_imports: Gd<SetupBuildingImports>,
     gltf_importer: Gd<GltfImporter>,
+    ao_baker: OnReady<Gd<AoBaker>>,
+
     base: Base<EditorPlugin>,
 }
 
+const fn new_non_zero(value: u32) -> NonZero<u32> {
+    NonZero::new(value).unwrap()
+}
+
+#[godot_api]
+impl EditorExtension {
+    fn define_project_settings(
+        settings: &[(&'static str, VariantType, PropertyHint, &'static str)],
+        project_settings: &mut Gd<ProjectSettings>,
+    ) {
+        for (name, ty, hint, hint_str) in settings {
+            Self::define_project_settings_property(name, *ty, *hint, hint_str, project_settings);
+        }
+    }
+
+    fn define_project_settings_property(
+        name: &'static str,
+        ty: VariantType,
+        hint: PropertyHint,
+        hint_str: &'static str,
+        project_settings: &mut Gd<ProjectSettings>,
+    ) {
+        let default_value = variant_type_default_value(ty);
+
+        if !project_settings.has_setting(name) {
+            project_settings.set_setting(name, &default_value);
+        }
+
+        project_settings.set_initial_value(name, &default_value);
+
+        let mut property = Dictionary::new();
+
+        property.set("name", name);
+        property.set("type", ty);
+        property.set("hint", hint);
+        property.set("hint_string", hint_str);
+
+        project_settings.add_property_info(&property);
+    }
+}
+
 #[godot_api]
 impl IEditorPlugin for EditorExtension {
     fn init(base: Base<EditorPlugin>) -> Self {
         Self {
             setup_building_imports: SetupBuildingImports::new(base.to_gd().get_editor_interface()),
             gltf_importer: GltfImporter::new_gd(),
+            ao_baker: OnReady::manual(),
             base,
         }
     }
 
     fn enter_tree(&mut self) {
         let building_imports = self.setup_building_imports.clone();
 
+        Self::define_project_settings(&AoBaker::SETTINGS, &mut ProjectSettings::singleton());
+
         self.base_mut().add_tool_menu_item(
             "Setup Building Imports...",
             &engine_callable!(&building_imports, SetupBuildingImports::start),
         );
 
+        let ao_baker = {
+            let mut base = self.base_mut();
+
+            AoBaker::new(
+                base.get_editor_interface()
+                    .expect("editor interface should be available after entering the tree"),
+                base.get_tree()
+                    .expect("SceneTree should be available after entering the tree"),
+            )
+        };
+
+        self.ao_baker.init(ao_baker);
+
+        let callable = &engine_callable!(&self.ao_baker, AoBaker::bake);
+
+        self.base_mut()
+            .add_tool_menu_item("Bake Ambient Occlusion...", callable);
+
         GltfDocument::register_gltf_document_extension(&self.gltf_importer);
     }