Merge pull request #43 from jacobsky/introtext

Did a second pass at the intro-page of the book.

Author: Bromeon

src/faq/code.md

@@ -277,6 +277,8 @@ Also, you can always put a Mutex<HashMap> into a Rust static and load everything
 
 ## How do I keep a reference of `Node`?
 
+The idiomatic way to maintain a reference to a node in the SceneTree from Rust is to use `Option<Ref<T>>`. 
+
 For example, in the following GDScript code
 ```gdscript
 extends Node
@@ -313,6 +315,51 @@ Note: As `TRef<T>` is a temporary pointer, it will be necessary to get the base
 
 This can be done with the [`TRef<T>::claim()`](https://docs.rs/gdnative/latest/gdnative/struct.TRef.html#method.claim) function that will return the persistent version of the pointer that you can store in your class.
 
+## What is the Rust equivalent to `onready var` in GDScript
+
+Rust does not have a direct equivalent to `onready var`. The most idiomatic workaround with Rust is to use `Option<Ref<T>>` of you need the Godot node type or `Option<Instance<T>>` if you are using a Rust based `NativeClass`.
+
+```gdscript
+extends Node
+class_name MyClass
+onready var node = $Node2d
+```
+You would need to use the following code.
+
+```rust
+#[derive(NativeClass)]
+#[inherit(Node)]
+#[no_constructor]
+struct MyNode {
+    node2d: Option<Ref<Node>>
+    instance: Option<Ref<MyClass>>,
+}
+
+#[methods]
+impl MyNode {
+    #[export]
+    fn _ready(&self, owner: TRef<Node>) {
+        // Get an existing child node that is a Godot class.
+        let node2d = owner
+            .get_node("Node2D")
+            .expect("this node must have a child with the path `Node2D`");
+        let node2d = unsafe { node2d.assume_safe() };
+        let node2d = node2d.cast::<Node2D>();
+        self.node2d = Some(node2d.claim());
+        // Get an existing child node that is a Rust class.
+        let instance = owner
+            .get_node("MyClass")
+            .expect("this node must have a child with the path `MyNode2D`");
+        let instance = unsafe { node2d.assume_safe() };
+        let instance = node2d.cast::<Node2D>();
+        let instance = godot_egui.cast_instance::<MyClass>()
+                        .expect("child `MyNode2D` must be type `MyClass`");
+        
+        self.instance = Some(instance.claim());
+    }
+}
+```
+
 ## What types are supported for passing through the GDNative API?
 
 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.

src/introduction.md

@@ -4,8 +4,29 @@ Welcome to the `godot-rust` book! This is a work-in-progress user guide for the
 
 If you're new to `godot-rust`, try the [Getting Started](./getting-started.md) tutorial first!
 
+For more information about architecture with `godot-rust`, the [GDNative Overview](gdnative-overview.md) gives a broad overview for _how_ `godot-rust` can be used with a few different use-cases as well as some indepth information for the underlying API.
+
+If have specific code questions that are not covered in the Getting Started guide, please check out the [Frequently Asked Questions](faq.md) or [Recipes](recipes.md) for some additional resources related to configuring `godot-rust`.
+
+If you're new to Rust, before getting started, it is highly recommended that you familiarize yourself with all of the concepts outlined in the officially maintained [Rust Book](https://doc.rust-lang.org/book/) before you getting started with `godot-rust`.
+
 If you have used earlier versions of `godot-rust` before, see [Migrating from godot-rust 0.8.x](./migrating-0-8.md) for a quick guided tour to the new API.
 
+## About godot-rust
+
+This project specifically supports the [Rust Programming Language](https://www.rust-lang.org/) bindings to the [GDNative API](https://docs.godotengine.org/en/stable/tutorials/plugins/gdnative/gdnative-cpp-example.html) for the Godot Game Engine.
+
+Outside of personal preference, Rust may be a good choice for your game for some of the following reasons:
+- Native levels of performance.
+- Memory safety validated at compile time.*
+- [Fearless Concurrency](https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html).*
+- The leveraging the [cargo](https://doc.rust-lang.org/stable/cargo/) build system to build the GDNative library. 
+- The ability to leverage Rust's crate ecosystem from [crates.io](https://crates.io/). 
+
+*: Compile time memory and thread safety guarantees only apply to the Rust code. As the user is allowed to call into the Godot engine (C++ code, via GDNative Foreign Function Interface) or into user-defined scripts (GDScript), some of the validity checks are outside godot-rust's control. However, `godot-rust` guides the user by making clear which operations are potentially unsafe.
+
+For more information about the `godot-rust` project and how it may be useful to you, please refer to the [FAQ Section](faq/meta.md) for project specific information.
+
 ## Contributing
 
 The source repository for this book is [hosted on GitHub](https://github.com/godot-rust/book).