3 files changed, 117 insertions, 0 deletions
diff --git a/rust/src/game.rs b/rust/src/game.rs
new file mode 100644
index 0000000..ece5a54
--- /dev/null
+++ b/rust/src/game.rs
@@ -0,0 +1,46 @@
+use gdnative::api::*;
+use gdnative::prelude::*;
+
+/// The Game "class"
+#[derive(NativeClass)]
+#[inherit(Spatial)]
+#[register_with(Self::register_builder)]
+pub struct Game {
+    name: String,
+}
+
+// __One__ `impl` block can have the `#[methods]` attribute, which will generate
+// code to automatically bind any exported methods to Godot.
+#[methods]
+impl Game {
+    // Register the builder for methods, properties and/or signals.
+    fn register_builder(_builder: &ClassBuilder<Self>) {
+        godot_print!("Game builder is registered!");
+    }
+
+    /// The "constructor" of the class.
+    fn new(_owner: &Spatial) -> Self {
+        godot_print!("Game is created!");
+        Game {
+            name: "".to_string(),
+        }
+    }
+
+    // In order to make a method known to Godot, the #[export] attribute has to be used.
+    // In Godot script-classes do not actually inherit the parent class.
+    // Instead they are "attached" to the parent object, called the "owner".
+    // The owner is passed to every single exposed method.
+    #[export]
+    unsafe fn _ready(&mut self, _owner: &Spatial) {
+        // The `godot_print!` macro works like `println!` but prints to the Godot-editor
+        // output tab as well.
+        self.name = "Game".to_string();
+        godot_print!("{} is ready!", self.name);
+    }
+
+    // This function will be called in every frame
+    #[export]
+    unsafe fn _process(&self, _owner: &Spatial, delta: f64) {
+        godot_print!("Inside {} _process(), delta is {}", self.name, delta);
+    }
+}
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
new file mode 100644
index 0000000..1cc766a
--- /dev/null
+++ b/rust/src/lib.rs
@@ -0,0 +1,13 @@
+mod game;
+mod spinning_cube;
+
+use gdnative::prelude::{godot_init, InitHandle};
+
+// Function that registers all exposed classes to Godot
+fn init(handle: InitHandle) {
+    handle.add_class::<game::Game>();
+    handle.add_class::<spinning_cube::SpinningCube>();
+}
+
+// macros that create the entry-points of the dynamic library.
+godot_init!(init);
diff --git a/rust/src/spinning_cube.rs b/rust/src/spinning_cube.rs
new file mode 100644
index 0000000..41b429f
--- /dev/null
+++ b/rust/src/spinning_cube.rs
@@ -0,0 +1,58 @@
+use gdnative::api::*;
+use gdnative::prelude::*;
+
+/// The SpinningCube "class"
+#[derive(NativeClass)]
+#[inherit(MeshInstance)]
+#[register_with(Self::register_builder)]
+pub struct SpinningCube {
+    start: Vector3,
+    time: f32,
+    #[property(path = "base/rotate_speed")]
+    rotate_speed: f64,
+}
+
+// __One__ `impl` block can have the `#[methods]` attribute, which will generate
+// code to automatically bind any exported methods to Godot.
+#[methods]
+impl SpinningCube {
+    // Register the builder for methods, properties and/or signals.
+    fn register_builder(_builder: &ClassBuilder<Self>) {
+        godot_print!("SpinningCube builder is registered!");
+    }
+
+    /// The "constructor" of the class.
+    fn new(_owner: &MeshInstance) -> Self {
+        SpinningCube {
+            start: Vector3::new(0.0, 0.0, 0.0),
+            time: 0.0,
+            rotate_speed: 0.05,
+        }
+    }
+
+    // In order to make a method known to Godot, the #[export] attribute has to be used.
+    // In Godot script-classes do not actually inherit the parent class.
+    // Instead they are "attached" to the parent object, called the "owner".
+    // The owner is passed to every single exposed method.
+    #[export]
+    unsafe fn _ready(&mut self, owner: &MeshInstance) {
+        owner.set_physics_process(true);
+    }
+
+    #[export]
+    unsafe fn _physics_process(&mut self, owner: &MeshInstance, delta: f64) {
+        use gdnative::api::SpatialMaterial;
+
+        self.time += delta as f32;
+        owner.rotate_y(self.rotate_speed * delta);
+
+        let offset = Vector3::new(0.0, 1.0, 0.0) * self.time.cos() * 0.5;
+        owner.set_translation(self.start + offset);
+
+        if let Some(mat) = owner.get_surface_material(0) {
+            let mat = mat.assume_safe();
+            let mat = mat.cast::<SpatialMaterial>().expect("Incorrect material");
+            mat.set_albedo(Color::from_rgba(self.time.cos().abs(), 0.0, 0.0, 1.0));
+        }
+    }
+}