Strip module prefixes

Author: Bromeon

src/faq.md

@@ -108,7 +108,7 @@ As a work-around, it is possible to use a ZST (zero-sized type):
 #[inherit(Object)]
 pub struct StaticUtil;
 
-#[godot::methods]
+#[methods]
 impl StaticUtil {
     #[export]
     fn compute_something(&self, _owner: &Object, input: i32) -> i32 {
@@ -140,7 +140,7 @@ How can I access the Rust type given the Variant?
 This conversion can be accomplished by casting the `Variant` to a `Ref`, and then to an `Instance` or `RefInstance`, and mapping over it to access the Rust data type:
 
 ```rust
-#[godot::methods]
+#[methods]
 impl AnotherNativeScript {
 
     #[export]

src/gdnative-overview/wrappers.md

@@ -13,7 +13,7 @@ The generic smart pointer `gdnative::Ref<T, Access>` allows you to store `Object
 For example, storing a reference to a Godot `Node2D` instance in a struct would look as follows:
 ```rust
 struct GodotNode {
-	node_ref: gd::Ref<gd::api::Node2D>,
+	node_ref: Ref<Node2D>,
 }
 ```
 
@@ -28,14 +28,14 @@ While `Ref` is a persistent pointer to retain references to Godot objects for an
 The following example demonstrates `TRef`. A node is stored inside a Rust struct, and its position is modified through `set_position()`. This approach could be used in an ECS (Entity-Component-System) architecture, where `GodotNode` is a component, updated by a system.
 ```rust
 struct GodotNode {
-    node_ref: gd::Ref<gd::api::Node2D>,
+    node_ref: Ref<Node2D>,
 }
 
 fn update_position(node: &GodotNode) {
-    let pos = gd::core_types::Vector2::new(20, 30);
+    let pos = Vector2::new(20, 30);
 
     // fetch temporary reference to the node
-    let node: gd::TRef<gd::api::Node2D> = unsafe { node.node_ref.assume_safe() };
+    let node: TRef<Node2D> = unsafe { node.node_ref.assume_safe() };
 
     // call into the Godot engine
     // this implicitly invokes deref(), turning TRef<Node2D> into &Node2D
@@ -69,16 +69,16 @@ When passing around your own Rust types, you will thus be working with `Instance
 
 Let's use a straightforward example: a player with name and score. Exported methods and properties are omitted for simplicity; the full interfacing will be explained later in [Calling into GDScript from Rust](../rust-binding/calling-gdscript.md).
 ```rust
-#[derive(gd::NativeClass)]
+#[derive(NativeClass)]
 // no #[inherit], thus inherits Reference by default
 pub struct Player {
     name: String,
     score: u32,
 }
 
-#[gd::methods]
+#[methods]
 impl Player {
-    fn new(_owner: &gd::Reference) -> Self {
+    fn new(_owner: &Reference) -> Self {
         Self {
             name: "New player".to_string(),
             score: 0
@@ -104,14 +104,14 @@ instance.map_mut(|p: &mut Player, _base: TRef<Reference, Unique>| {
 
 If you don't need a Godot-enabled default constructor, use the `#[no_constructor]` attribute and define your own Rust `new()` constructor.
 ```rust
-#[derive(gd::NativeClass)]
+#[derive(NativeClass)]
 #[no_constructor]
 pub struct Player {
     name: String,
     score: u32,
 }
 
-#[gd::methods]
+#[methods]
 impl Player {
     pub fn new(name: &str, score: u32) -> Self {
        Self { name: name.to_string(), score }

src/rust-binding/calling-gdscript.md

@@ -20,12 +20,12 @@ On the previous pages, we explained how to export a class, so it can be instanti
 Let's define a class `Enemy` which acts as a simple data bundle, i.e. no functionality. We inherit it from `Reference`, such that memory is managed automatically. In addition, we define `_to_string()` and delegate it to the derived `Debug` trait implementation, to make it printable from GDScript.
 
 ```rust
-#[derive(gd::NativeClass, Debug)]
+#[derive(NativeClass, Debug)]
 // no #[inherit], thus inherits Reference by default
 #[no_constructor]
 pub struct Enemy {
     #[property]
-    pos: gd::core_types::Vector2,
+    pos: Vector2,
 
     #[property]
     health: f32,
@@ -34,35 +34,35 @@ pub struct Enemy {
     name: String,
 }
 
-#[gd::methods]
+#[methods]
 impl Enemy {
     #[export]
-    fn _to_string(&self, _owner: &gd::Reference) -> String {
+    fn _to_string(&self, _owner: &Reference) -> String {
         format!("{:?}", self) // calls Debug::fmt()
     }
 }
 ```
 Godot can only use classes that are registered, so let's do that:
 ```rust
-fn init(handle: gd::nativescript::InitHandle) {
+fn init(handle: InitHandle) {
     // ...
     handle.add_class::<Enemy>();
 }
 ```
 Now, it's not possible to directly return `Enemy` instances in exported methods, so this won't work:
 ```rust
-#[gdnative::export]
-fn create_enemy(&mut self, _owner: &gd::Node) -> Enemy {...}
+#[export]
+fn create_enemy(&mut self, _owner: &Node) -> Enemy {...}
 ```
 Instead, you can wrap the object in a `Instance<Enemy, Unique>`, using `emplace()`. For an in-depth explanation of the `Instance` class, read [this section](http://localhost:3000/gdnative-overview/wrappers.html#instance-reference-with-attached-rust-class).
 ```rust
-#[gdnative::export]
+#[export]
 fn create_enemy(
     &self,
-    _owner: &gd::Node
-) -> gd::Instance<Enemy, gd::thread_access::Unique> {
+    _owner: &Node
+) -> Instance<Enemy, Unique> {
     let enemy = Enemy {
-        pos: gd::Vector2::new(7.0, 2.0),
+        pos: Vector2::new(7.0, 2.0),
         health: 100.0,
         name: "MyEnemy".to_string(),
     };

src/rust-binding/classes.md

@@ -11,9 +11,9 @@ This workflow implies that when you want to execute Rust code, you need to first
 
 Somewhere in your code, usually in `lib.rs`, you need to declare the functions that will be called by the engine when the native library is loaded and unloaded, as well as the registration function for native classes exposed to the engine. godot-rust provides the following macros (consult [their documentation](https://docs.rs/gdnative/latest/gdnative/index.html#macros) for further info and customization):
 ```rust
-gd::godot_gdnative_init!();
-gd::godot_nativescript_init!(init);
-gd::godot_gdnative_terminate!();
+godot_gdnative_init!();
+godot_nativescript_init!(init);
+godot_gdnative_terminate!();
 ```
 Or the equivalent short-hand:
 ```rust
@@ -25,7 +25,7 @@ The argument `init` refers to the function registering native script classes, wh
 // see details later
 struct GodotApi { ... }
 
-fn init(handle: gd::nativescript::InitHandle) {
+fn init(handle: InitHandle) {
     handle.add_class::<GodotApi>();
 }
 ```
@@ -37,30 +37,30 @@ Similar to the [Hello World](../getting-started/hello-world.md#overriding-a-godo
 ```rust
 // Tell godot-rust that this struct is exported as a native class 
 // (implements NativeClass trait)
-#[derive(gd::nativescript::NativeClass)]
+#[derive(NativeClass)]
 
 // Specify the base class (corresponds to 'extends' statement in GDScript).
 // * Like 'extends' in GDScript, this can be omitted. 
 //   In that case, the 'Reference' class is used as a base.
 // * Unlike 'extends' however, only existing Godot types are permitted,
 //   no other user-defined scripts.
-#[inherit(gd::api::Node)]
+#[inherit(Node)]
 pub struct GodotApi {}
 
 // Exactly one impl block can have the #[methods] annotation, 
 // which registers methods in the background.
-#[gd::methods]
+#[methods]
 impl GodotApi {
     // Constructor, either:
-    fn new(owner: &gd::api::Node) -> Self { ... }
+    fn new(owner: &Node) -> Self { ... }
     // or:
-    fn new(owner: gd::TRef<gd::api::Node>) -> Self { ... }
+    fn new(owner: TRef<Node>) -> Self { ... }
 }
 ```
 
 The [`#[derive(NativeClass)]` macro](https://docs.rs/gdnative/latest/gdnative/derive.NativeClass.html) enables a Rust type to be usable as a _native class_ in Godot. It implements [the `NativeClass` trait](https://docs.rs/gdnative/latest/gdnative/nativescript/trait.NativeClass.html), which fills in the glue code required to make the class available in Godot. Among other information, this includes class name and registry of exported methods and properties. For the user, the utility methods `new_instance()` and `emplace()` are provided for constructing `Instance` objects.
 
-The function `new()` corresponds to `_init()` in GDScript. The _owner_ is the base object of the script, and must correspond to the class specified in the `#[inherit]` attribute (or `gd::api::Reference` if the attribute is absent). The parameter can be a shared reference `&T` or a `TRef<T>`.
+The function `new()` corresponds to `_init()` in GDScript. The _owner_ is the base object of the script, and must correspond to the class specified in the `#[inherit]` attribute (or `Reference` if the attribute is absent). The parameter can be a shared reference `&T` or a `TRef<T>`.
 
 With a `new()` method, you are able to write `GodotApi.new()` in GDScript. If you don't need this, you can add the `#[no_constructor]` attribute to the struct declaration.
 

src/rust-binding/methods.md

@@ -5,44 +5,44 @@ In order to receive data from Godot, you can export methods. With the `#[export]
 The exported method's first parameter is always `&self` or `&mut self` (operating on the Rust object), and the second parameter is `&T` or `TRef<T>` (operating on the Godot base object, with `T` being the inherited type).
 
 ```rust
-#[derive(gd::nativescript::NativeClass)]
-#[inherit(gd::api::Node)]
+#[derive(NativeClass)]
+#[inherit(Node)]
 pub struct GodotApi {
     enemy_count: i32,
 }
 
-#[gd::methods]
+#[methods]
 impl GodotApi {
-    fn new(_owner: &gd::api::Node) -> Self {
+    fn new(_owner: &Node) -> Self {
         // Print to both shell and Godot editor console
-        gd::godot_print!("_init()");
+        godot_print!("_init()");
         Self { enemy_count: 0 }
     }
 
-    #[gd::export]
+    #[export]
     fn create_enemy(
         &mut self,
-        _owner: &gd::api::Node,
+        _owner: &Node,
         typ: String,
-        pos: gd::core_types::Vector2
+        pos: Vector2
     ) {
-        gd::godot_print!("create_enemy(): type '{}' at position {:?}", typ, pos);
+        godot_print!("create_enemy(): type '{}' at position {:?}", typ, pos);
         self.enemy_count += 1;
     }
 
-    #[gd::export]
+    #[export]
     fn create_enemy2(
         &mut self,
-        _owner: &gd::api::Node,
-        typ: gd::core_types::GodotString,
-        pos: gd::core_types::Variant
+        _owner: &Node,
+        typ: GodotString,
+        pos: Variant
     ) {
-        gd::godot_print!("create_enemy2(): type '{}' at position {:?}", typ, pos);
+        godot_print!("create_enemy2(): type '{}' at position {:?}", typ, pos);
         self.enemy_count += 1;
     }
 
-    #[gd::export]
-    fn count_enemies(&self, _owner: &gd::api::Node) -> i32 {
+    #[export]
+    fn count_enemies(&self, _owner: &Node) -> i32 {
         self.enemy_count
     }  
 }
@@ -77,34 +77,34 @@ The above examples have dealt with simple types such as strings and integers. Wh
 
 Let's say we want to pass in an enemy from GDScript, instead of creating one locally. It could be represented by the `Node2D` class and directly configured in the Godot editor. What you then would do is use [the `Ref` wrapper](../gdnative-overview/wrappers.md):
 ```rust
-#[derive(gd::nativescript::NativeClass)]
-#[inherit(gd::api::Node)]
+#[derive(NativeClass)]
+#[inherit(Node)]
 pub struct GodotApi {
     // Store references to all enemy nodes
-    enemies: Vec<gd::Ref<gd::api::Node2D>>,
+    enemies: Vec<Ref<Node2D>>,
 }
 
-#[gd::methods]
+#[methods]
 impl GodotApi {
     // new() etc...
 
-    #[gd::export]
+    #[export]
     fn add_enemy(
         &mut self,
-        _owner: &gd::Node,
-        enemy: gd::Ref<gd::api::Node2D> // pass in enemy
+        _owner: &Node,
+        enemy: Ref<Node2D> // pass in enemy
     ) {
         self.enemies.push(enemy);
     }
 
     // You can even return the enemies directly with Vec.
     // In GDScript, you will get an array of nodes.
     // An alternative would be VariantArray, able to hold different types.
-    #[gd::export]
+    #[export]
     fn get_enemies(
         &self,
-        _owner: &gd::api::Node
-    ) ->  Vec<gd::Ref<gd::api::Node2D>> {
+        _owner: &Node
+    ) ->  Vec<Ref<Node2D>> {
         self.enemies.clone()
     }
 }
@@ -116,20 +116,20 @@ Godot offers some special methods. Most of them implement [notifications](https:
 
 If you need to override a Godot special method, just declare it as a normal exported method, with the same name and signature as in GDScript:
 ```rust
-#[gd::export]
-fn _ready(&mut self, _owner: &gd::Node) {...}
+#[export]
+fn _ready(&mut self, _owner: &Node) {...}
 
-#[gd::export]
-fn _process(&mut self, _owner: &gd::Node, delta: f32) {...}
+#[export]
+fn _process(&mut self, _owner: &Node, delta: f32) {...}
 
-#[gd::export]
-fn _physics_process(&mut self, _owner: &gd::Node, delta: f32) {...}
+#[export]
+fn _physics_process(&mut self, _owner: &Node, delta: f32) {...}
 ```
 
 If you want to change how GDScript's default formatter in functions like `str()` or `print()` works, you can overload the `to_string` GDScript method, which corresponds to the following Rust method:
 ```rust
-#[gd::export]
-fn _to_string(&self, _owner: &gd::Reference) -> String {...}
+#[export]
+fn _to_string(&self, _owner: &Reference) -> String {...}
 ```
 
 

src/rust-binding/properties.md

@@ -4,8 +4,8 @@ Like methods, properties can be exported. The `#[property]` attribute above a fi
 
 In the previous example, we could replace the `count_enemies()` method with a property `enemy_count`.
 ```rust
-#[derive(gd::nativescript::NativeClass)]
-#[inherit(gd::api::Node)]
+#[derive(NativeClass)]
+#[inherit(Node)]
 pub struct GodotApi {
     #[property]
     enemy_count: i32,