Fixing a variety of broken links (#116)

Author: reshen

src/bind/classes.md

@@ -33,21 +33,21 @@ fn init(handle: InitHandle) {
 
 ## Class definition
 
-Similar to the [Hello World](../getting-started/hello-world.md#overriding-a-godot-method) example, we can define the `GodotApi` native class as follows:
+Similar to the [Hello World](../intro/hello-world.md#overriding-a-godot-method) example, we can define the `GodotApi` native class as follows:
 ```rust
-// Tell godot-rust that this struct is exported as a native class 
+// Tell godot-rust that this struct is exported as a native class
 // (implements NativeClass trait)
 #[derive(NativeClass)]
 
 // Specify the base class (corresponds to 'extends' statement in GDScript).
-// * Like 'extends' in GDScript, this can be omitted. 
+// * 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(Node)]
 pub struct GodotApi {}
 
-// Exactly one impl block can have the #[methods] annotation, 
+// Exactly one impl block can have the #[methods] annotation,
 // which registers methods in the background.
 #[methods]
 impl GodotApi {
@@ -58,10 +58,10 @@ impl GodotApi {
 }
 ```
 
-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 [`#[derive(NativeClass)]` macro](https://docs.rs/gdnative/latest/gdnative/derive/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/export/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 _base_ 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.
 
-At this point, arguments cannot be passed into the constructor. Consult [this FAQ entry](../faq.md#passing-additional-arguments-to-a-class-constructor) for available workarounds.
+At this point, arguments cannot be passed into the constructor. Consult [this FAQ entry](../faq/code.html#can-the-new-constructor-have-additional-parameters) for available workarounds.

src/bind/index.md

@@ -1,14 +1,14 @@
 # Binding to Rust code
 
-This chapter provides an exhaustive list of mechanisms to pass data through the Rust GDNative binding, in both directions: 
+This chapter provides an exhaustive list of mechanisms to pass data through the Rust GDNative binding, in both directions:
 * **GDScript -> Rust**, e.g. to react to an input event with custom Rust logic
 * **Rust -> GDScript**, e.g. to apply a game logic change to a graphics node in Godot
 
-The goal is to serve as both an in-depth learning resource for newcomers and a reference to look up specific mechanisms at a later stage. Before delving into this chapter, make sure to read [An Overview of GDNative](gdnative-overview.md), which explains several fundamental concepts used here.
+The goal is to serve as both an in-depth learning resource for newcomers and a reference to look up specific mechanisms at a later stage. Before delving into this chapter, make sure to read [An Overview of GDNative](../overview), which explains several fundamental concepts used here.
 
 The subchapters are intended to be read in order, but you can navigate to them directly:
 
-1. [Class registration](rust-binding/classes.md)
-1. [Exported methods](rust-binding/methods.md)
-1. [Exported properties](rust-binding/properties.md)
-1. [Calling into GDScript from Rust](./rust-binding/calling-gdscript.md)
+1. [Class registration](classes.md)
+1. [Exported methods](methods.md)
+1. [Exported properties](properties.md)
+1. [Calling into GDScript from Rust](./calling-gdscript.md)

src/bind/methods.md

@@ -6,7 +6,7 @@ In order to receive data from Godot, you can export methods. With the `#[method]
 > `#[export]` has been renamed to `#[method]` and is now deprecated.
 > It keeps working for the time being though (i.e. gdnative 0.11).
 >
-> For more information, see [`gdnative::derive::NativeClass`](https://godot-rust.github.io/docs/gdnative/derive/derive.NativeClass.html).
+> For more information, see [`gdnative::derive::NativeClass`](https://docs.rs/gdnative/latest/gdnative/derive/derive.NativeClass.html).
 
 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).
 
@@ -24,7 +24,7 @@ impl GodotApi {
         godot_print!("_init()");
         Self { enemy_count: 0 }
     }
-    
+
     #[method]
     fn create_enemy(
         &mut self,
@@ -48,7 +48,7 @@ impl GodotApi {
     #[method]
     fn count_enemies(&self) -> i32 {
         self.enemy_count
-    }  
+    }
 }
 ```
 The two creation methods are semantically equivalent, yet they demonstrate how godot-rust implicitly converts the values to the parameter types (unmarshalling). You could use `Variant` everywhere, however it is more type-safe and expressive to use specific types. The same applies to return types, you could use `Variant` instead of `i32`.
@@ -63,7 +63,7 @@ api.create_enemy2("Elf", Vector2(50, 70));
 
 print("enemies: ", api.count_enemies())
 
-# don't forget to add it to the scene tree, otherwise memory must be managed manually 
+# don't forget to add it to the scene tree, otherwise memory must be managed manually
 self.add_child(api)
 ```
 
@@ -99,7 +99,7 @@ impl GodotApi {
     ) {
         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.

src/bind/traits.md

@@ -31,7 +31,7 @@ For more information about how you can customize the behavior of the dervive mac
 
 ## Export Trait
 
-The Godot editor retrieves property information from [Object::get_property_list](https://docs.godotengine.org/en/stable/classes/class_object.html#id2). To populate this data, `godot-rust` requires that the [`Export`](https://docs.rs/gdnative/latest/gdnative/nativescript/trait.Export.html) trait be implemented for each type Rust struct.
+The Godot editor retrieves property information from [Object::get_property_list](https://docs.godotengine.org/en/stable/classes/class_object.html#id2). To populate this data, `godot-rust` requires that the [`Export`](https://docs.rs/gdnative/latest/gdnative/export/trait.Export.html) trait be implemented for each type Rust struct.
 
 There are no derive macros that can be used for `Export` but many of the primitive types have it implemented by default.
 

src/faq/code.md

@@ -84,13 +84,13 @@ impl SignalEmitter {
             data: "initial",
         }
     }
-    
+
     #[method]
     fn update_data(&mut self, #[base] base: TRef<Node>, data: LargeData) {
         self.data = data;
       base.emit_signal("updated", &[]);
     }
-    
+
     #[method]
     fn get_data(&self) -> &LargeData {
         &self.data
@@ -439,16 +439,16 @@ impl MyNode {
 
 The GDNative API supports any type that implements the [`ToVariant`](https://docs.rs/gdnative/latest/gdnative/core_types/trait.ToVariant.html) and/or [`FromVariant`](https://docs.rs/gdnative/latest/gdnative/core_types/trait.FromVariant.html) traits.
 
-To use a type as a property, in addition to the above, the type will also need to implement the [`Export`](https://docs.rs/gdnative/latest/gdnative/nativescript/trait.Export.html) trait.
+To use a type as a property, in addition to the above, the type will also need to implement the [`Export`](https://docs.rs/gdnative/latest/gdnative/export/trait.Export.html) trait.
 
 Some concrete examples of types that can be used with the GDNative API are the following:
 
 - [`Variant`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.Variant.html), this is Godot's "any" type. It must be converted before it can be used.
 - A subset of scalar types such as `i64`, `f64`, `bool`, etc.
 - [`String`](https://doc.rust-lang.org/std/string/struct.String.html) and [`GodotString`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.GodotString.html).
-- [Godot core types](https://docs.rs/gdnative/latest/gdnative/core_types/index.html) such as [`Color`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.Color.html), [`Aabb`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.Aabb.html), [`Transform2D`](https://docs.rs/gdnative/latest/gdnative/core_types/type.Transform2D.html), [`Vector2`](https://docs.rs/gdnative/latest/gdnative/core_types/type.Vector2.html), etc.
-- Godot classes such as `Node`, `Reference`, etc. which must be accessed via [`Ref<T>`](https://docs.rs/gdnative/latest/gdnative/struct.Ref.html) (you can't pass them by value, because Godot owns them).
-- Any Rust struct that derives [`NativeClass`](https://docs.rs/gdnative/latest/gdnative/derive.NativeClass.html), through [`Instance<T>`](https://docs.rs/gdnative/latest/gdnative/nativescript/struct.Instance.html).
+- [Godot core types](https://docs.rs/gdnative/latest/gdnative/core_types/index.html) such as [`Color`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.Color.html), [`Aabb`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.Aabb.html), [`Transform2D`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.Transform2D.html), [`Vector2`](https://docs.rs/gdnative/latest/gdnative/core_types/struct.Vector2.html), etc.
+- Godot classes such as `Node`, `Reference`, etc. which must be accessed via [`Ref<T>`](https://docs.rs/gdnative/latest/gdnative/object/struct.Ref.html) (you can't pass them by value, because Godot owns them).
+- Any Rust struct that derives [`NativeClass`](https://docs.rs/gdnative/latest/gdnative/derive/derive.NativeClass.html), through [`Instance<T>`](https://docs.rs/gdnative/latest/gdnative/object/struct.Instance.html).
 
 
 ## How can I profile my code to measure performance?

src/faq/multithreading.md

@@ -5,7 +5,7 @@
 
 ## How do I use multithreading?
 
-Make sure you read [Godot's thread safety guidelines](https://docs.godotengine.org/en/stable/tutorials/performance/threads/thread_safe_apis.html).
+Make sure you read [Godot's thread safety guidelines](https://docs.godotengine.org/en/3.6/tutorials/performance/threads/thread_safe_apis.html).
 
 > This is **EXTREMELY IMPORTANT**.
 

src/index.md

@@ -56,7 +56,7 @@ The source repository for this book is [hosted on GitHub](https://github.com/god
 
 ## License
 
-The GDNative bindings and this user guide are licensed under the MIT license.  
+The GDNative bindings and this user guide are licensed under the MIT license.
 The GDExtension bindings are licensed under the [Mozilla Public License 2.0](https://www.mozilla.org/en-US/MPL).
 
 

src/intro/hello-world.md

@@ -44,7 +44,7 @@ gdnative = "0.10"
 > While it's also possible to place the Rust crate within the Godot project, doing so might lead to problems with Godot's resource importer. It's best to place the Rust crate somewhere outside the Godot project directory.
 >
 > Previously, some third-party resources have recommended separating Rust code into multiple crates. While this is fine to do, godot-rust works best when there is a single `cdylib` crate acting as the entry point for all crates in the workspace. Script downcasting, for example, only works for types registered in the same GDNative library. Code from `std` and other dependencies can also lead to code bloat when duplicated in multiple binaries.
-> 
+>
 > We suggest that users start projects as a single crate, and only split code into workspaces when necessary.
 
 
@@ -88,7 +88,7 @@ This macro defines the necessary C callbacks used by Godot. You only need *one*
 
 > ### GDNative internals
 >
-> The purposes of this macro will be discussed in detail in [_An Overview of GDNative_](../gdnative-overview.md). For now, treat it as a magic incantation.
+> The purposes of this macro will be discussed in detail in [_An Overview of GDNative_](../overview). For now, treat it as a magic incantation.
 
 
 ## Your first script

src/intro/setup.md

@@ -6,7 +6,7 @@ Before we can start creating a hello-world project using godot-rust, we'll need
 
 The default API version is currently 3.2.3-stable. For the rest of the tutorial, we'll assume that you have Godot 3.2.3-stable installed, and available in your `PATH` as `godot`.
 
-You may download binaries of Godot 3.2.3-stable from the official repository: [https://downloads.tuxfamily.org/godotengine/3.2.3/](https://downloads.tuxfamily.org/godotengine/3.2.3/).
+You may download binaries of Godot 3.2.3-stable from the official repository: [https://godotengine.org/download/archive/3.2.3-stable/](https://godotengine.org/download/archive/3.2.3-stable/).
 
 > ### Using another build of the engine
 >

src/overview/data-representations.md

@@ -1,6 +1,6 @@
 # Data representations
 
-The godot-rust library uses many different approaches to store and transport data. This chapter explains high-level concepts of related terminology used throughout the library and its documentation. It is not a usage guide however -- to see the concepts in action, check out [Binding to Rust code](../rust-binding.md).
+The godot-rust library uses many different approaches to store and transport data. This chapter explains high-level concepts of related terminology used throughout the library and its documentation. It is not a usage guide however -- to see the concepts in action, check out [Binding to Rust code](../bind).
 
 
 ## Object and class
@@ -16,24 +16,24 @@ Every user-defined class inherits `Object` directly or indirectly, and thus all
 
 `Object` itself comes with manual memory management. All instances must be deallocated using the `free()` method. This is typically not what you want, instead you will most often work with the following classes inherited from `Object`:
 
-* **`Reference`**  
-  Reference-counted objects. This is the default base class if you don't use the `extends` keyword in GDScript. Allows to pass around instances of this type freely, managing memory automatically when the last reference goes out of scope.  
+* **`Reference`**
+  Reference-counted objects. This is the default base class if you don't use the `extends` keyword in GDScript. Allows to pass around instances of this type freely, managing memory automatically when the last reference goes out of scope.
   Do not confuse this type with the godot-rust `Ref` smart pointer.
-* **`Node`**  
-  Anything that's part of the scene tree, such as `Spatial` (3D), `CanvasItem` and `Node2D` (2D). Each node in the tree is responsible of its children and will deallocate them automatically when it is removed from the tree. At the latest, the entire tree will be destroyed when ending the application.  
+* **`Node`**
+  Anything that's part of the scene tree, such as `Spatial` (3D), `CanvasItem` and `Node2D` (2D). Each node in the tree is responsible of its children and will deallocate them automatically when it is removed from the tree. At the latest, the entire tree will be destroyed when ending the application.
   **Important:** as long as a node is not attached to the scene tree, it behaves like an `Object` instance and must be freed manually. On the other hand, as long as it is part of the tree, it can be destroyed (e.g. when its parent is removed) and other references pointing to it become invalid.
-* **`Resource`**  
+* **`Resource`**
   Data set that is loaded from disk and cached in memory, for example 3D meshes, materials, textures, fonts or music (see also [Godot tutorial](https://docs.godotengine.org/en/stable/getting_started/step_by_step/resources.html)).
-  `Resource` inherits `Reference`, so in the context of godot-rust, it can be treated like a normal, reference-counted class. 
+  `Resource` inherits `Reference`, so in the context of godot-rust, it can be treated like a normal, reference-counted class.
 
 When talking about inheritance, we always mean the relationship in GDScript code. Rust does not have inheritance, instead godot-rust implements `Deref` traits to allow implicit upcasts. This enables to invoke all parent methods and makes the godot-rust API very close to GDScript.
 
 Classes need to be added as `NativeScript` resources inside the Godot editor, see [here](../intro/hello-world.html#creating-the-nativescript-resource) for a description.
 
 _See `Object` in
 [godot-rust docs](https://docs.rs/gdnative/latest/gdnative/api/struct.Object.html),
-[Godot docs](https://docs.godotengine.org/en/latest/classes/class_object.html)_  
-_See `GodotObject`, the Rust trait implemented for all Godot classes, in [godot-rust docs](https://docs.rs/gdnative/latest/gdnative/trait.GodotObject.html)_
+[Godot docs](https://docs.godotengine.org/en/latest/classes/class_object.html)_
+_See `GodotObject`, the Rust trait implemented for all Godot classes, in [godot-rust docs](https://docs.rs/gdnative/latest/gdnative/object/trait.GodotObject.html)_
 
 
 ## Variant
@@ -53,7 +53,7 @@ _See `Variant` in
 
 Scripts are programmable building blocks that can be attached to nodes in the scene tree, in order to customize their behavior. Depending on the language in which the script is written, there are different classes which inherit the `Script` class; relevant here will be `NativeScript` for classes defined in Rust, and `GDScript` for classes defined in GDScript. Scripts are stored as Godot resources (like materials, textures, shaders etc), usually in their own separate file.
 
-Scripts _always_ inherit another class from Godot's `Object` hierarchy, either an existing one from Godot or a user-defined one. In Rust, scripts are limited to inherit an existing Godot class; other scripts cannot be inherited. This makes each script a class on their own: they provide the properties and methods from their _base object_, plus all the properties and methods that you define in the script. 
+Scripts _always_ inherit another class from Godot's `Object` hierarchy, either an existing one from Godot or a user-defined one. In Rust, scripts are limited to inherit an existing Godot class; other scripts cannot be inherited. This makes each script a class on their own: they provide the properties and methods from their _base object_, plus all the properties and methods that you define in the script.
 
 _See `Script` in
 [godot-rust docs](https://docs.rs/gdnative/latest/gdnative/api/struct.Script.html),