Merge pull request #170 from tom-leys/feature/scene_create_example

Add Scene Creation example

Author: karroffel

Cargo.toml

@@ -11,4 +11,5 @@ members = [
     "bindings_generator",
     "examples/hello_world",
     "examples/spinning_cube",
+    "examples/scene_create",
 ]

examples/hello_world/src/lib.rs

@@ -7,7 +7,6 @@ struct HelloWorld;
 
 #[gdnative::methods]
 impl HelloWorld {
-
     fn _init(_owner: gdnative::Node) -> Self {
         HelloWorld
     }

examples/scene_create/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "scene_create"
+version = "0.1.0"
+authors = ["tom.leys <[email protected]>", "karroffel <[email protected]>"]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+gdnative = { path = "../../gdnative" }
+euclid = "0.19.6"

examples/scene_create/Child_scene.tscn

@@ -0,0 +1,13 @@
+[gd_scene load_steps=2 format=2]
+
+[sub_resource type="CubeMesh" id=1]
+
+[node name="Child" type="Spatial"]
+
+[node name="CSGMesh" type="CSGMesh" parent="."]
+transform = Transform( 0.9, 0, 0, 0, 0.9, 0, 0, 0, 0.9, 0, 0, 0 )
+mesh = SubResource( 1 )
+
+[node name="CSGMesh2" type="CSGMesh" parent="."]
+transform = Transform( 0.1, 0, 0, 0, 0.4, 0, 0, 0, 0.1, 0, 2.15568, 0 )
+mesh = SubResource( 1 )

examples/scene_create/Main.tscn

@@ -0,0 +1,48 @@
+[gd_scene load_steps=3 format=2]
+
+[ext_resource path="res://Parent.gdns" type="Script" id=1]
+[ext_resource path="res://Panel.gd" type="Script" id=2]
+
+[node name="Main" type="Spatial"]
+
+[node name="Camera" type="Camera" parent="."]
+transform = Transform( 0.707107, 0.5, -0.5, 0, 0.707107, 0.707107, 0.707107, -0.5, 0.5, -9.65923, 12.7955, 9.30623 )
+current = true
+
+[node name="Parent" type="Spatial" parent="."]
+script = ExtResource( 1 )
+
+[node name="Ui" type="Node2D" parent="."]
+
+[node name="Canvas" type="CanvasLayer" parent="Ui"]
+
+[node name="Panel" type="Panel" parent="Ui/Canvas"]
+margin_top = 533.0
+margin_right = 1023.0
+margin_bottom = 598.0
+grow_horizontal = 2
+grow_vertical = 2
+script = ExtResource( 2 )
+
+[node name="Add" type="Button" parent="Ui/Canvas/Panel"]
+margin_left = 28.8019
+margin_top = 18.0811
+margin_right = 160.802
+margin_bottom = 48.0811
+text = "Add Child"
+
+[node name="Remove" type="Button" parent="Ui/Canvas/Panel"]
+margin_left = 179.803
+margin_top = 19.4414
+margin_right = 311.803
+margin_bottom = 49.4414
+text = "Remove Child"
+
+[node name="Label" type="Label" parent="Ui/Canvas/Panel"]
+margin_left = 345.0
+margin_top = 21.0
+margin_right = 580.0
+margin_bottom = 40.0
+text = "No Children have been created yet"
+[connection signal="pressed" from="Ui/Canvas/Panel/Add" to="Ui/Canvas/Panel" method="_on_Add_pressed"]
+[connection signal="pressed" from="Ui/Canvas/Panel/Remove" to="Ui/Canvas/Panel" method="_on_Remove_pressed"]

examples/scene_create/Panel.gd

@@ -0,0 +1,32 @@
+extends Panel
+
+func _ready():
+	pass # Replace with function body.
+
+# There is a signal set up on the Add button which calls
+#   this method. We pass the call into Parent.spawn_one
+#   (This calls Rust)
+func _on_Add_pressed():
+	var spawner_node = get_node("/root/Main/Parent")
+	spawner_node.spawn_one("example string")
+
+# There is a signal set up on the Remove button which calls
+#   this method. We pass the call into Parent.remove_one
+#   (This calls Rust)
+func _on_Remove_pressed():
+	var spawner_node = get_node("/root/Main/Parent")
+	spawner_node.remove_one("Another example string")
+
+# This function is called from Rust. All we need there is this 
+#   node and the name "set_num_children"
+func set_num_children(children_count):
+	# This is called from rust
+	if children_count == 0 :
+		$Label.text = "What did you go and kill all the children for!?"
+	elif children_count == 1:
+		$Label.text = "We have one child"
+	else :
+		$Label.text = "%d children have been created so far" % children_count
+		
+	
+	

examples/scene_create/Parent.gdns

@@ -0,0 +1,8 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://scene_create_library.gdnlib" type="GDNativeLibrary" id=1]
+
+[resource]
+resource_name = "ChildSpawner"
+class_name = "SceneCreate"
+library = ExtResource( 1 )

examples/scene_create/default_env.tres

@@ -0,0 +1,14 @@
+[gd_resource type="Environment" load_steps=2 format=2]
+
+[sub_resource type="ProceduralSky" id=1]
+sky_top_color = Color( 0.0470588, 0.454902, 0.976471, 1 )
+sky_horizon_color = Color( 0.556863, 0.823529, 0.909804, 1 )
+sky_curve = 0.25
+ground_bottom_color = Color( 0.101961, 0.145098, 0.188235, 1 )
+ground_horizon_color = Color( 0.482353, 0.788235, 0.952941, 1 )
+ground_curve = 0.01
+sun_energy = 16.0
+
+[resource]
+background_mode = 2
+background_sky = SubResource( 1 )

examples/scene_create/icon.png

@@ -0,0 +1,34 @@
+[remap]
+
+importer="texture"
+type="StreamTexture"
+path="res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://icon.png"
+dest_files=[ "res://.import/icon.png-487276ed1e3a0c39cad0279d744ee560.stex" ]
+
+[params]
+
+compress/mode=0
+compress/lossy_quality=0.7
+compress/hdr_mode=0
+compress/bptc_ldr=0
+compress/normal_map=0
+flags/repeat=0
+flags/filter=true
+flags/mipmaps=false
+flags/anisotropic=false
+flags/srgb=2
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/HDR_as_SRGB=false
+process/invert_color=false
+stream=false
+size_limit=0
+detect_3d=true
+svg/scale=1.0

examples/scene_create/icon.png.import

@@ -0,0 +1,24 @@
+; Engine configuration file.
+; It's best edited using the editor UI and not directly,
+; since the parameters that go here are not all obvious.
+;
+; Format:
+;   [section] ; section goes between []
+;   param=value ; assign values to parameters
+
+config_version=4
+
+_global_script_classes=[  ]
+_global_script_class_icons={
+
+}
+
+[application]
+
+config/name="Godot Rust - Scene Create Example"
+run/main_scene="res://Main.tscn"
+config/icon="res://icon.png"
+
+[rendering]
+
+environment/default_environment="res://default_env.tres"

examples/scene_create/project.godot

@@ -0,0 +1,18 @@
+[general]
+
+singleton=false
+load_once=false
+symbol_prefix="godot_"
+reloadable=true
+
+[entry]
+
+OSX.64="../../target/debug/libscene_create.dylib"
+X11.64="../../target/debug/libscene_create.so"
+Windows.64="res://../../target/debug/scene_create.dll"
+
+[dependencies]
+
+OSX.64=[  ]
+UWP.64=[  ]
+X11.64=[  ]

examples/scene_create/scene_create_library.gdnlib

@@ -0,0 +1,164 @@
+#[macro_use]
+extern crate gdnative;
+extern crate euclid;
+
+use euclid::vec3;
+use gdnative::{GodotString, PackedScene, ResourceLoader, Spatial, Variant};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ManageErrs {
+    CouldNotMakeInstance,
+    RootClassNotSpatial(String),
+}
+
+#[derive(gdnative::NativeClass)]
+#[inherit(gdnative::Spatial)]
+struct SceneCreate {
+    // Store the loaded scene for a very slight performance boost but mostly to show you how.
+    template: Option<PackedScene>,
+    children_spawned: u32,
+}
+
+// Demonstrates Scene creation, calling to/from gdscript
+//
+//   1. Child scene is created when spawn_one is called
+//   2. Child scenes are deleted when remove_one is called
+//   3. Find and call functions in a node (Panel)
+//   4. Call functions in GDNative (from panel into spawn/remove)
+//
+//  Note, the same mechanism which is used to call from panel into spawn_one and remove_one can be
+//   used to call other GDNative classes here in rust.
+
+#[gdnative::methods]
+impl SceneCreate {
+    fn _init(_owner: gdnative::Spatial) -> Self {
+        SceneCreate {
+            template: None, // Have not loaded this template yet.
+            children_spawned: 0,
+        }
+    }
+
+    #[export]
+    fn _ready(&mut self, _owner: gdnative::Spatial) {
+        self.template = load_scene("res://Child_scene.tscn");
+        match &self.template {
+            Some(_scene) => godot_print!("Loaded child scene successfully!"),
+            None => godot_print!("Could not load child scene. Check name."),
+        }
+    }
+
+    #[export]
+    unsafe fn spawn_one(&mut self, mut owner: gdnative::Spatial, message: GodotString) {
+        godot_print!("Called spawn_one({})", message.to_string());
+
+        let template = if let Some(template) = &self.template {
+            template
+        } else {
+            godot_print!("Cannot spawn a child because we couldn't load the template scene");
+            return;
+        };
+
+        // Create the scene here. Note that we are hardcoding that the parent must at least be a
+        //   child of Spatial in the template argument here...
+        match instance_scene::<Spatial>(template) {
+            Ok(mut spatial) => {
+                // Here is how you rename the child...
+                let key_str = format!("child_{}", self.children_spawned);
+                spatial.set_name(GodotString::from_str(&key_str));
+
+                let x = (self.children_spawned % 10) as f32;
+                let z = (self.children_spawned / 10) as f32;
+                spatial.translate(vec3(-10.0 + x * 2.0, 0.0, -10.0 + z * 2.0));
+
+                // You need to parent the new scene under some node if you want it in the scene.
+                //   We parent it under ourselves.
+                owner.add_child(Some(spatial.to_object()), false);
+                self.children_spawned += 1;
+            }
+            Err(err) => godot_print!("Could not instance Child : {:?}", err),
+        }
+
+        let num_children = owner.get_child_count();
+        update_panel(&mut owner, num_children);
+    }
+
+    #[export]
+    unsafe fn remove_one(&mut self, mut owner: gdnative::Spatial, str: GodotString) {
+        godot_print!("Called remove_one({})", str.to_string());
+        let num_children = owner.get_child_count();
+        if num_children <= 0 {
+            godot_print!("No children to delete");
+            return;
+        }
+
+        assert_eq!(self.children_spawned as i64, num_children);
+
+        let last_child = owner.get_child(num_children - 1);
+        if let Some(mut node) = last_child {
+            node.queue_free();
+            self.children_spawned -= 1;
+        }
+
+        update_panel(&mut owner, num_children - 1);
+    }
+}
+
+fn init(handle: gdnative::init::InitHandle) {
+    handle.add_class::<SceneCreate>();
+}
+
+pub fn load_scene(path: &str) -> Option<PackedScene> {
+    let scene = ResourceLoader::godot_singleton().load(
+        GodotString::from_str(path), // could also use path.into() here
+        GodotString::from_str("PackedScene"),
+        false,
+    );
+
+    scene.and_then(|s| s.cast::<PackedScene>())
+}
+
+/// Root here is needs to be the same type (or a parent type) of the node that you put in the child
+///   scene as the root. For instance Spatial is used for this example.
+unsafe fn instance_scene<Root>(scene: &PackedScene) -> Result<Root, ManageErrs>
+where
+    Root: gdnative::GodotObject,
+{
+    let inst_option = scene.instance(0); // 0 - GEN_EDIT_STATE_DISABLED
+
+    if let Some(instance) = inst_option {
+        if let Some(instance_root) = instance.cast::<Root>() {
+            Ok(instance_root)
+        } else {
+            Err(ManageErrs::RootClassNotSpatial(
+                instance.get_name().to_string(),
+            ))
+        }
+    } else {
+        Err(ManageErrs::CouldNotMakeInstance)
+    }
+}
+
+unsafe fn update_panel(owner: &mut gdnative::Spatial, num_children: i64) {
+    // Here is how we call into the panel. First we get its node (we might have saved it
+    //   from earlier)
+    let panel_node_opt = owner
+        .get_parent()
+        .and_then(|parent| parent.find_node(GodotString::from_str("Panel"), true, false));
+    if let Some(panel_node) = panel_node_opt {
+        // Put the Node
+        let mut as_variant = Variant::from_object(&panel_node);
+        match as_variant.call(
+            &GodotString::from_str("set_num_children"),
+            &[Variant::from_u64(num_children as u64)],
+        ) {
+            Ok(_) => godot_print!("Called Panel OK."),
+            Err(_) => godot_print!("Error calling Panel"),
+        }
+    } else {
+        godot_print!("Could not find panel node");
+    }
+}
+
+godot_gdnative_init!();
+godot_nativescript_init!(init);
+godot_gdnative_terminate!();