Fix all missing "<stuff>" + some proofing

contributing/doc_and_l10n_guidelines.rst

@@ -105,9 +105,9 @@ to the English base page you translate from:
 
 Traduction de ![[Godot Engine:Creating 2D Games]]
 
-The previous link is of the form ![[:]] which enables you to add a link
-to a page located in an other project. Here, "Godot Engine" is the
-English project.
+The previous link is of the form ![[<project name>:<project page>]] which
+enables you to add a link to a page located in an other project. Here,
+"Godot Engine" is the English project.
 
 Important changes and discussions
 ---------------------------------

contributing/reference_filling_work.rst

@@ -94,114 +94,114 @@ You can edit this file using your favourite text editor.
 
 Here is an example with the Node2D class:
 
-::
-
-
-        
-        Base node for 2D system.
-        
-        
-        Base node for 2D system. Node2D contains a position, rotation and scale, which is used to position and animate. It can alternatively be used with a custom 2D transform ([Matrix32]). A tree of Node2Ds allows complex hierarchies for animation and positioning.
-        
-        
-            
-                
-                
-                
-                Set the position of the 2d node.
-                
-            
-            
-                
-                
-                
-                Set the rotation of the 2d node.
-                
-            
-            
-                
-                
-                
-                Set the scale of the 2d node.
-                
-            
-            
-                
-                
-                
-                Return the position of the 2D node.
-                
-            
-            
-                
-                
-                
-                Return the rotation of the 2D node.
-                
-            
-            
-                
-                
-                
-                Return the scale of the 2D node.
-                
-            
-            
-                
-                
-                
-                
-            
-            
-                
-                
-                
-                
-                
-                
-            
-            
-                
-                
-                
-                
-                
-                
-            
-            
-                
-                
-                
-                Return the global position of the 2D node.
-                
-            
-            
-                
-                
-                
-                
-            
-            
-                
-                
-                
-                
-            
-            
-                
-                
-                
-                
-            
-            
-                
-                
-                
-                
-            
-        
-        
-        
+.. code:: xml
+    <class name="Node2D" inherits="CanvasItem" category="Core">
+    <brief_description>
+    Base node for 2D system.
+    </brief_description>
+    <description>
+    Base node for 2D system. Node2D contains a position, rotation and scale, which is used to position and animate. It can alternatively be used with a custom 2D transform ([Matrix32]). A tree of Node2Ds allows complex hierachies for animation and positioning.
+    </description>
+    <methods>
+        <method name="set_pos">
+            <argument index="0" name="pos" type="Vector2">
+            </argument>
+            <description>
+            Set the position of the 2d node.
+            </description>
+        </method>
+        <method name="set_rot">
+            <argument index="0" name="rot" type="float">
+            </argument>
+            <description>
+            Set the rotation of the 2d node.
+            </description>
+        </method>
+        <method name="set_scale">
+            <argument index="0" name="scale" type="Vector2">
+            </argument>
+            <description>
+            Set the scale of the 2d node.
+            </description>
+        </method>
+        <method name="get_pos" qualifiers="const">
+            <return type="Vector2">
+            </return>
+            <description>
+            Return the position of the 2D node.
+            </description>
+        </method>
+        <method name="get_rot" qualifiers="const">
+            <return type="float">
+            </return>
+            <description>
+            Return the rotation of the 2D node.
+            </description>
+        </method>
+        <method name="get_scale" qualifiers="const">
+            <return type="Vector2">
+            </return>
+            <description>
+            Return the scale of the 2D node.
+            </description>
+        </method>
+        <method name="rotate">
+            <argument index="0" name="degrees" type="float">
+            </argument>
+            <description>
+        </description>
+        </method>
+        <method name="move_local_x">
+            <argument index="0" name="delta" type="float">
+            </argument>
+            <argument index="1" name="scaled" type="bool" default="false">
+            </argument>
+            <description>
+            </description>
+        </method>
+        <method name="move_local_y">
+            <argument index="0" name="delta" type="float">
+            </argument>
+            <argument index="1" name="scaled" type="bool" default="false">
+            </argument>
+            <description>
+            </description>
+        </method>
+        <method name="get_global_pos" qualifiers="const">
+            <return type="Vector2">
+            </return>
+            <description>
+            Return the global position of the 2D node.
+            </description>
+        </method>
+        <method name="set_global_pos">
+            <argument index="0" name="arg0" type="Vector2">
+            </argument>
+            <description>
+            </description>
+        </method>
+        <method name="set_transform">
+            <argument index="0" name="xform" type="Matrix32">
+            </argument>
+            <description>
+            </description>
+        </method>
+        <method name="set_global_transform">
+            <argument index="0" name="xform" type="Matrix32">
+            </argument>
+            <description>
+            </description>
+        </method>
+        <method name="edit_set_pivot">
+            <argument index="0" name="arg0" type="Vector2">
+            </argument>
+            <description>
+            </description>
+        </method>
+    </methods>
+    <constants>
+    </constants>
+</class>
 
 As you can see, some methods in this class have no description (i.e.
 there is no text between their marks). This can also happen for the
@@ -209,22 +209,22 @@ description and the brief_description of the class, but in our case
 they are already filled. Let's edit the description of the rotate()
 method:
 
-::
-
-
-        
-        
-        
+.. code:: xml
+    <method name="rotate">
+        <argument index="0" name="degrees" type="float">
+        </argument>
+        <description>
         Rotates the node of "degrees" degrees.
-        
+        </description>
+    </method>
 
 That's all!
 
 You simply have to write any missing text between these marks:
 
--  
--  
--  
+-  <description></description>
+-  <brief_description></brief_description>
+-  <constant></constant>
 
 Describe clearly and shortly what it does. You can include an example of
 use if needed. Avoid grammar faults.

reference/2d_and_3d_keybindings.rst

@@ -1,14 +1,14 @@
 .. _doc_2d_and_3d_keybindings:
 
-2D and 3D Keybindings
+2D and 3D keybindings
 =====================
 
-2D Viewport
+2D viewport
 -----------
 
 .. image:: /img/keybinds_2d.png
 
-3D Viewport
+3D viewport
 -----------
 
 .. image:: /img/keybinds_3d.png

reference/batch_building_templates.rst

@@ -3,11 +3,11 @@
 Batch building templates
 ========================
 
-The following is almost the same exact script we use to build all the
-export templates that go to the site. If you want to build or roll them
+The following is almost the same script that we use to build all the
+export templates that go to the website. If you want to build or roll them
 yourself, this might be of use.
 
-(note: mac stuff is missing)
+(note: Apple stuff is missing)
 
 ::
 
@@ -113,7 +113,7 @@ yourself, this might be of use.
 
     # BlackBerry 10 (currently disabled)
 
-    #. /path/to/bbndk/bbndk-env.sh
+    #./path/to/bbndk/bbndk-env.sh
     #scons -j 4 platform/bb10/godot_bb10_opt.qnx.armle target=release
     #cp platform/bb10/godot_bb10_opt.qnx.armle platform/bb10/bar
 

reference/binary_serialization_api.rst

@@ -15,10 +15,9 @@ is not used for binary scenes and resources.
 Packet specification
 --------------------
 
-| The packet is designed to be always padded to 4 bytes. All values are
-  little endian encoded.
-| All packets have a 4 byte header representing an integer, specifying
-  the type of data:
+The packet is designed to be always padded to 4 bytes. All values are
+little endian encoded. All packets have a 4 byte header representing an
+integer, specifying the type of data:
 
 +--------+--------------------------+
 | Type   | Value                    |

reference/compiling_for_universal_windows_apps.rst

@@ -79,7 +79,9 @@ App.Windows
 -  Find the "Application" section, and add (or modify) the "Executable"
    property with the name of your .exe. Example:
 
-  <Application Id="App" Executable="godot.winrt.tools.x64.exe" EntryPoint="App_Windows.App">
+::
+
+    <Application Id="App" Executable="godot.winrt.tools.x64.exe" EntryPoint="App_Windows.App">
 
 App.WindowsPhone
 ~~~~~~~~~~~~~~~~

reference/configure_your_ide.rst

@@ -3,11 +3,17 @@
 Configure an IDE
 ================
 
-With Eclipse
-------------
+Eclipse
+-------
 
-With QtCreator
---------------
+TODO.
 
-With another editor (vim, emacs, Atom...)
------------------------------------------
+QtCreator
+---------
+
+TODO.
+
+Other editors (vim, emacs, Atom...)
+-----------------------------------
+
+TODO.

reference/core_types.rst

@@ -3,7 +3,7 @@
 Core types
 ==========
 
-Godot has a rich set of classes and template that make for its core,
+Godot has a rich set of classes and templates that compose its core,
 and everything is built upon them.
 
 This reference will try to list them in order for their better
@@ -52,7 +52,7 @@ but over time and with abuse, this can lead to segmentation.
 Segmentation slowly creates holes that are too small for most common
 allocations, so that memory is wasted. There is a lot of literature
 about heap and segmentation, so this topic will not be developed
-further here. Modern Operating Systems use paged memory, which helps
+further here. Modern operating systems use paged memory, which helps
 mitigate the problem of segmentation but doesn't solve it.
 
 However, in many studies and tests, it is shown that given enough
@@ -73,13 +73,13 @@ of the game, the programmer can configure the dynamic memory pool size.
 Allocating memory
 -----------------
 
-Godot has many tools for tracking memory usage in an game, specially
+Godot has many tools for tracking memory usage in a game, specially
 during debug. Because of this, the regular C and C++ library calls
 should not be used. Instead, a few other ones are provided.
 
 For C-style allocation, Godot provides a few macros:
 
-::
+.. code:: cpp
 
     memalloc()
     memrealloc()
@@ -90,7 +90,7 @@ library.
 
 For C++-style allocation, special macros are provided:
 
-::
+.. code:: cpp
 
     memnew( Class / Class(args) )
     memdelete( instance )
@@ -106,24 +106,24 @@ after they are created, and right before they are deleted.
 For dynamic memory, the DVector<> template is provided. Just use it
 like:
 
-::
+.. code:: cpp
 
-    DVector
+    DVector<int>
 
 DVector is just a standard vector class, it can be accessed using the []
 operator, but that's probably slow for large amount of accesses (as it
 has to lock internally). A few helpers exist for this:
 
-::
+.. code:: cpp
 
-    DVector::Read r = dvector.read()
+    DVector<int>::Read r = dvector.read()
     int someint = r[4]
 
 and
 
-::
+.. code:: cpp
 
-    DVector::Write w = dvector.write()
+    DVector<int>::Write w = dvector.write()
     w[4]=22;
 
 respectively. These allow fast read/write from DVectors and keep it
@@ -150,9 +150,9 @@ in C++ are often inlined and make the binary size much fatter, both in
 debug symbols and code. List, Set and Map can be iterated using
 pointers, like this:
 
-::
+.. code:: cpp
 
-    for(List::Element *E=somelist.front();E;E=E->next()) {
+    for(List<int>::Element *E=somelist.front();E;E=E->next()) {
         print_line(E->get()); //print the element
     }
 
@@ -214,7 +214,7 @@ References:
 NodePath
 --------
 
-This is a special datatype sued for storing paths in a scenetree and
+This is a special datatype used for storing paths in a scene tree and
 referencing them fast.
 
 References:

reference/creating_android_modules.rst

@@ -6,8 +6,8 @@ Creating Android modules
 Introduction
 ------------
 
-Making videogames portable is all fine and dandy, until mobile gaming
-monetization shows up.
+Making video games portable is all fine and dandy, until mobile
+gaming monetization shows up.
 
 This area is complex, usually a mobile game that monetizes needs
 special connections to a server for stuff such as:
@@ -18,7 +18,7 @@ special connections to a server for stuff such as:
 -  Install tracking
 -  Ads
 -  Video ads
--  Cross promotion
+-  Cross-promotion
 -  In-game soft & hard currencies
 -  Promo codes
 -  A/B testing
@@ -82,7 +82,7 @@ functions:
 
     def configure(env):
         if env['platform'] == 'android':
-             #androd specific code
+            # android specific code
 
 Java singleton
 --------------
@@ -93,47 +93,45 @@ template follows:
 
 .. code:: java
 
-    //namespace is wrong, will eventually change
+    // namespace is wrong, will eventually change
     package com.android.godot;
 
     public class MySingleton extends Godot.SingletonBase {
 
-
         public int myFunction(String p_str) {
-              // a function to bind
+            // a function to bind
         }
 
         static public Godot.SingletonBase initialize(Activity p_activity) {
-
-                    return new MySingleton(p_activity);
+            return new MySingleton(p_activity);
         } 
 
         public MySingleton(Activity p_activity) {
-              //register class name and functions to bind
-              registerClass("MySingleton", new String[]{"myFunction"});
+            //register class name and functions to bind
+            registerClass("MySingleton", new String[]{"myFunction"});
 
-              // you might want to try initializing your singleton here, but android
-              // threads are weird and this runs in another thread, so you usually have to do
-              activity.runOnUiThread(new Runnable() {
-                   public void run() {
+            // you might want to try initializing your singleton here, but android
+            // threads are weird and this runs in another thread, so you usually have to do
+            activity.runOnUiThread(new Runnable() {
+                    public void run() {
                         //useful way to get config info from engine.cfg
                         String key = GodotLib.getGlobal("plugin/api_key");
                         SDK.initializeHere();
-                   }
-              });
+                    }
+            });
 
         }
 
-         // forwarded callbacks you can reimplement, as SDKs often need them
+        // forwarded callbacks you can reimplement, as SDKs often need them
 
-         protected void onMainActivityResult(int requestCode, int resultCode, Intent data) {}
+        protected void onMainActivityResult(int requestCode, int resultCode, Intent data) {}
 
-         protected void onMainPause() {}
-         protected void onMainResume() {}
-         protected void onMainDestroy() {}
+        protected void onMainPause() {}
+        protected void onMainResume() {}
+        protected void onMainDestroy() {}
 
-         protected void onGLDrawFrame(GL10 gl) {}
-         protected void onGLSurfaceChanged(GL10 gl, int width, int height) {} // singletons will always miss first onGLSurfaceChanged call
+        protected void onGLDrawFrame(GL10 gl) {}
+        protected void onGLSurfaceChanged(GL10 gl, int width, int height) {} // singletons will always miss first onGLSurfaceChanged call
 
     }
 
@@ -142,12 +140,12 @@ ID of the script must be known first, this is obtained by calling
 ``get_instance_ID()`` on the script. This returns an integer that can be
 passed to Java.
 
-From Java, use the calldeferred function to communicate back with Godot.
+From Java, use the ``calldeferred`` function to communicate back with Godot.
 Java will most likely run in a separate thread, so calls are deferred:
 
 .. code:: java
 
-    GodotLib.calldeferred(, "", new Object[]{param1,param2,etc});
+    GodotLib.calldeferred(<instanceid>, "<function>", new Object[]{param1,param2,etc});
 
 Add this singleton to the build of the project by adding the following
 to config.py:
@@ -211,12 +209,11 @@ the project folder inside the module directory and configure it:
 
 ::
 
-    c:\\godot\\modules\\mymodule\\sdk-1.2> android -p . -t 15
-
-As of this writing, godot uses minsdk 10 and target sdk 15. If this ever
-changes, should be reflected in the manifest template:
+    c:\godot\modules\mymodule\sdk-1.2> android -p . -t 15
 
-https://github.com/godotengine/godot/blob/master/platform/android/AndroidManifest.xml.template
+As of this writing, Godot uses minsdk 10 and target sdk 15. If this ever
+changes, it should be reflected in the manifest template:
+`AndroidManifest.xml.template <https://github.com/godotengine/godot/blob/master/platform/android/AndroidManifest.xml.template>`
 
 Then, add the module folder to the project:
 
@@ -241,17 +238,17 @@ Godot, so compile android normally.
 
 ::
 
-    c:\\godot> scons p=android
+    c:\godot> scons p=android
 
 This will cause your module to be included, the .jar will be copied to
 the java folder, the .java will be copied to the sources folder, etc.
-Each time you modify the .java scons must be called.
+Each time you modify the .java, scons must be called.
 
 Afterwards, just build the ant project normally:
 
 ::
 
-    c:\\godot\\platform\\android\\java> ant release
+    c:\godot\platform\android\java> ant release
 
 This should generate the apk used as export template properly, as
 defined in :ref:`doc_compiling_for_android`.
@@ -261,8 +258,8 @@ sequence:
 
 ::
 
-    c:\\godot> scons p=android
-    c:\\godot\\platform\\android\\java> ant release
+    c:\godot> scons p=android
+    c:\godot\platform\android\java> ant release
 
 Using the Module
 ~~~~~~~~~~~~~~~~
@@ -276,7 +273,7 @@ the following line to engine.cfg:
 
     modules="com/android/godot/MySingleton"
 
-More than one singleton module can be enable by separating with comma:
+More than one singleton module can be enabled by separating with commas:
 
 ::
 
@@ -286,15 +283,15 @@ More than one singleton module can be enable by separating with comma:
 
 Then just request the singleton Java object from Globals like this:
 
-.. code:: python
+::
 
-    #in any file
+    # in any file
 
-    var singleton=null
+    var singleton = null
 
     func _init():
         singleton = Globals.get_singleton("MySingleton")
-        print( singleton.myFunction("Hello") )
+        print(singleton.myFunction("Hello"))
 
 Troubleshooting
 ---------------
@@ -306,7 +303,7 @@ Godot crashes upon load
 
 Check ``adb logcat`` for possible problems, then:
 
--  Make sure libgodot_android.so is in the libs/armeabi folder
+-  Make sure libgodot_android.so is in the ``libs/armeabi`` folder
 -  Check that the methods used in the Java singleton only use simple
    Java datatypes, more complex ones are not supported.
 
@@ -314,13 +311,13 @@ Future
 ------
 
 Godot has an experimental Java API Wrapper that allows to use the
-entire Java API fro GDScript.
+entire Java API from GDScript.
 
 It's simple to use and it's used like this:
 
 ::
 
-    class = JavaClassWrapper.wrap()
+    class = JavaClassWrapper.wrap(<javaclass as text>)
 
 This is most likely not functional yet, if you want to test it and help
 us make it work, contact us through the `developer mailing

reference/custom_modules_in_c++.rst

@@ -11,8 +11,8 @@ created and then enabled/disabled. This allows for adding new engine
 functionality at every level without modifying the core, which can be
 split for use and reuse in different modules.
 
-Modules are located in them modules/ subdirectory of the build system.
-By default, two modules exist, GDScript (which, yes it's not part of the
+Modules are located in the ``modules/`` subdirectory of the build system.
+By default, two modules exist, GDScript (which, yes, is not part of the
 core engine), and the GridMap. As many new modules as desired can be
 created and combined, and the SCons build system will take care of it
 transparently.
@@ -34,22 +34,22 @@ Creating a new module
 ---------------------
 
 Before creating a module, make sure to download the source code of Godot
-and manage to compile it. There are tutorials in the wiki for this.
+and manage to compile it. There are tutorials in the documentation for this.
 
 To create a new module, the first step is creating a directory inside
-modules. If you want to maintain the module separately, you can checkout
+``modules/``. If you want to maintain the module separately, you can checkout
 a different VCS into modules and use it.
 
 The example module will be called "sumator", and is placed inside the
-Godot source tree (C:\\\\godot refers to wherever the Godot sources are
+Godot source tree (``C:\godot`` refers to wherever the Godot sources are
 located):
 
 ::
 
-    c:\\godot> cd modules
-    c:\\godot\\modules> mkdir sumator
-    c:\\godot\\modules> cd sumator
-    c:\\godot\\modules\\sumator>
+    C:\godot> cd modules
+    C:\godot\modules> mkdir sumator
+    C:\godot\modules> cd sumator
+    C:\godot\modules\sumator>
 
 Inside we will create a simple sumator class:
 
@@ -68,8 +68,8 @@ Inside we will create a simple sumator class:
 
     protected:
         static void _bind_methods();
-    public:
 
+    public:
         void add(int value);
         void reset();
         int get_total() const;
@@ -121,7 +121,7 @@ need to be created:
     register_types.h
     register_types.cpp
 
-With the following contents
+With the following contents:
 
 .. code:: cpp
 
@@ -148,8 +148,8 @@ With the following contents
        //nothing to do here
     }
 
-Next, we need to create a SCsub so the build system compiles this
-module:
+Next, we need to create a ``SCsub`` file so the build system compiles
+this module:
 
 .. code:: python
 
@@ -159,14 +159,14 @@ module:
     env.add_source_files(env.modules_sources,"*.cpp") # just add all cpp files to the build
 
 And finally, the configuration file for the module, this is a simple
-python script that must be named 'config.py'
+python script that must be named ``config.py``:
 
 .. code:: python
 
     # config.py
 
     def can_build(platform):
-        return True  
+        return True
 
     def configure(env):
         pass
@@ -175,9 +175,9 @@ The module is asked if it's ok to build for the specific platform (in
 this case, True means it will build for every platform).
 
 The second function allows to customize the build process for the
-module, like adding special compiler flags, options etc. (This can be
-done in SCSub, but configure(env) is called at a previous stage). If
-unsure, just ignore this.
+module, like adding special compiler flags, options, etc. (This can be
+done in ``SCsub``, but ``configure(env)`` is called at a previous stage).
+If unsure, just ignore this.
 
 And that's it. Hope it was not too complex! Your module should look like
 this:
@@ -192,22 +192,22 @@ this:
     godot/modules/sumator/SCsub
 
 You can then zip it and share the module with everyone else. When
-building for every platform (instructions in the previous section), your
-module will be included.
+building for every platform (instructions in the previous sections),
+your module will be included.
 
 Using the module
 ----------------
 
 Using your newly created module is very easy, from any script you can
-do:
+now do:
 
-.. code:: python
+::
 
     var s = Sumator.new()
     s.add(10)
     s.add(20)
     s.add(30)
-    print( s.get_total() )
+    print(s.get_total())
     s.reset()
 
 And the output will be ``60``.
@@ -228,7 +228,7 @@ some surprises.
 -  If you inherit from :ref:`class_Node` (or any derived node type, such as
    Sprite), your new class will appear in the editor, in the inheritance
    tree in the "Add Node" dialog.
--  If you inherit from :ref:`class_Resource`, it will appear int the resource
+-  If you inherit from :ref:`class_Resource`, it will appear in the resource
    list, and all the exposed properties can be serialized when
    saved/loaded.
 -  By this same logic, you can extend the Editor and almost any area of

reference/gdscript_more_efficiently.rst

@@ -191,7 +191,7 @@ Example:
 
 ::
 
-    std::vector array;
+    std::vector<int> array;
     array.resize(4);
     array[0]=10; //initialize manually
     array[1]=20; //can't mix types
@@ -335,7 +335,7 @@ Iterating in some statically typed languages can be quite complex:
 
     //Even in STL:
 
-    for(std::list::const_iterator it = strings.begin() ; it != strings.end() ; it++) {
+    for(std::list<std::string>::const_iterator it = strings.begin() ; it != strings.end() ; it++) {
 
         std::cout << *it << std::endl;
     }

reference/introduction_to_godot_development.rst

@@ -12,4 +12,5 @@ Debugging the editor with gdb
 If you are writing or correcting bugs affecting Godot Engine editor,
 remember that the binary runs the launcher first, which runs the editor
 in another process. Thus, you need to run the editor directly by passing
-the ``-e`` argument to Godot Engine editor's binary.
+the ``-e`` argument to Godot Engine editor's binary from within your
+project's folder.

reference/introduction_to_the_buildsystem.rst

@@ -76,9 +76,9 @@ To build for a platform (for example, x11), run with the ``platform=`` (or just
     user@host:~/godot$ scons platform=x11
 
 This will start the build process, which will take a while. If you want
-scons to build faster, use the ``-j`` parameter to specify how many cores
-will be used for the build. Or just leave it using one core, so you can
-use your computer for something else :)
+scons to build faster, use the ``-j <cores>`` parameter to specify how many
+cores will be used for the build. Or just leave it using one core, so you
+can use your computer for something else :)
 
 Example for using 4 cores:
 
@@ -94,7 +94,7 @@ generally with this naming convention:
 
 ::
 
-    godot.<platform>.[opt].[tools/debug].<bits>[extension]
+    godot.<platform>.[opt].[tools/debug].<architecture>[extension]
 
 For the previous build attempt the result would look like this:
 

reference/object_class.rst

@@ -3,7 +3,7 @@
 Object class
 ============
 
-Object is the base class for almost everything. Most classes in Godot
+:ref:`Object <class_object>` is the base class for almost everything. Most classes in Godot
 inherit directly or indirectly from it. Objects provide reflection and
 editable properties, and declaring them is a matter of using a single
 macro like this.
@@ -12,10 +12,10 @@ macro like this.
 
     class CustomObject : public Object {
 
-        OBJ_TYPE(CustomObject,Object); // this required to inherit
+        OBJ_TYPE(CustomObject,Object); // this is required to inherit
     };
 
-This makes objects gain a lot of functionality, like for example
+This makes Objects gain a lot of functionality, like for example
 
 .. code:: cpp
 
@@ -32,15 +32,15 @@ References:
 Registering an Object
 ---------------------
 
-ObjectTypeDB is a static class that hold the entire list of registered
-classes that inherit from object, as well as dynamic bindings to all
+ObjectTypeDB is a static class that holds the entire list of registered
+classes that inherit from Object, as well as dynamic bindings to all
 their methods properties and integer constants.
 
 Classes are registered by calling:
 
 .. code:: cpp
 
-    ObjectTypeDB::register_type()
+    ObjectTypeDB::register_type<MyCustomType>()
 
 Registering it will allow the type to be instanced by scripts, code, or
 creating them again when deserializing.
@@ -49,10 +49,10 @@ Registering as virtual is the same but it can't be instanced.
 
 .. code:: cpp
 
-    ObjectTypeDB::register_virtual_type()
+    ObjectTypeDB::register_virtual_type<MyCustomType>()
 
-Object derived classes can override a static function
-``static void _bind_methods()``, when one class is registered, this
+Object-derived classes can override the static function
+``static void _bind_methods()``. When one class is registered, this
 static function is called to register all the object methods,
 properties, constants, etc. It's only called once. If an Object derived
 class is instanced but has not been registered, it will be registered as
@@ -63,15 +63,15 @@ Registering functions is one:
 
 .. code:: cpp
 
-    ObjectTypeDB::register_method(_MD("methodname","arg1name","arg2name"),&MyCustethod);
+    ObjectTypeDB::register_method(_MD("methodname","arg1name","arg2name"),&MyCustomMethod);
 
 Default values for arguments can be passed in reverse order:
 
 .. code:: cpp
 
-    ObjectTypeDB::register_method(_MD("methodname","arg1name","arg2name"),&MyCustomType::method,DEFVAL(-1)); //default argument for arg2name
+    ObjectTypeDB::register_method(_MD("methodname","arg1name","arg2name"),&MyCustomType::method,DEFVAL(-1)); //default value for arg2name
 
-``_MD`` is a macro that convers "methodname" to a stringname for more
+``_MD`` is a macro that convers "methodname" to a StringName for more
 efficiency. Argument names are used for instrospection, but when
 compiling on release, the macro ignores them, so the strings are unused
 and optimized away.
@@ -79,7 +79,7 @@ and optimized away.
 Check ``_bind_methods`` of Control or Object for more examples.
 
 If just adding modules and functionality that is not expected to be
-documented as thoroughly, the ``_MD()`` macro can safely be ignore and a
+documented as thoroughly, the ``_MD()`` macro can safely be ignored and a
 string passing the name can be passed for brevity.
 
 References:
@@ -104,7 +104,7 @@ convertible to int, for this a macro is provided:
 
 .. code:: cpp
 
-    VARIANT_ENUM_CAST( MyClass::SomeMode); // now functions that take SomeMode can be bound.
+    VARIANT_ENUM_CAST( MyClass::SomeMode ); // now functions that take SomeMode can be bound.
 
 The constants can also be bound inside ``_bind_methods``, by using:
 
@@ -138,27 +138,27 @@ This is an integer property, named "amount", hint is a range, range goes
 from 0 to 49 in steps of 1 (integers). It is only usable for the editor
 (edit value visually) but wont be serialized.
 
-or
+Another example:
 
 .. code:: cpp
 
     PropertyInfo(Variant::STRING,"modes",PROPERTY_HINT_ENUM,"Enabled,Disabled,Turbo")
 
 This is a string property, can take any string but the editor will only
-allow the defined hint ones. Since no hint flags were specified, the
+allow the defined hint ones. Since no usage flags were specified, the
 default ones are PROPERTY_USAGE_STORAGE and PROPERTY_USAGE_EDITOR.
 
-There are plenty of hints and usages available in object.h, give them a
+There are plenty of hints and usage flags available in object.h, give them a
 check.
 
 Properties can also work like C# properties and be accessed from script
-using indexing, but ths usage is generally discouraged, as using
+using indexing, but this usage is generally discouraged, as using
 functions is preferred for legibility. Many properties are also bound
 with categories, such as "animation/frame" which also make indexing
 imposssible unless using operator [].
 
 From ``_bind_methods()``, properties can be created and bound as long as
-a set/get functions exist. Example:
+set/get functions exist. Example:
 
 .. code:: cpp
 
@@ -171,7 +171,7 @@ Binding properties using ``_set``/``_get``/``_get_property_list``
 -----------------------------------------------------------------
 
 An additional method of creating properties exists when more flexibility
-is desired (i.e. adding or removing properties on context):
+is desired (i.e. adding or removing properties on context).
 
 The following functions can be overriden in an Object derived class,
 they are NOT virtual, DO NOT make them virtual, they are called for
@@ -180,7 +180,7 @@ call).
 
 .. code:: cpp
 
-    void _get_property_info(List *r_props); //return list of propertes
+    void _get_property_info(List<PropertyInfo> *r_props); //return list of propertes
     bool _get(const StringName& p_property, Variany& r_value) const; //return true if property was found
     bool _set(const StringName& p_property, const Variany& p_value); //return true if property was found
 
@@ -190,14 +190,14 @@ compared against the desired names in serial order.
 Dynamic casting
 ---------------
 
-Godot provides dynamic casting between Object Derived classes, for
+Godot provides dynamic casting between Object-derived classes, for
 example:
 
 .. code:: cpp
 
     void somefunc(Object *some_obj) {
 
-         Button * button = some_obj->cast_to<Button>();
+         Button *button = some_obj->cast_to<Button>();
     }
 
 If cast fails, NULL is returned. This system uses RTTI, but it also
@@ -213,7 +213,7 @@ languages). Connecting to them is rather easy:
 
 .. code:: cpp
 
-    obj->connect(,target_instance,target_method)
+    obj->connect(<signal>,target_instance,target_method)
     //for example
     obj->connect("enter_tree",this,"_node_entered_tree")
 
@@ -230,17 +230,17 @@ Adding signals to a class is done in ``_bind_methods``, using the
 References
 ----------
 
-Reference inherits from Object and holds a reference count. It is the
-base for reference counted object types. Declaring them must be done
-using Ref<> template. For example.
+:ref:`Reference <class_reference>` inherits from Object and holds a
+reference count. It is the base for reference counted object types.
+Declaring them must be done using Ref<> template. For example:
 
 .. code:: cpp
 
     class MyReference: public Reference {
-        OBJ_TYPE( MyReference ,Reference);
+        OBJ_TYPE( MyReference,Reference );
     };
 
-    Ref myref = memnew( MyReference );
+    Ref<MyReference> myref = memnew( MyReference );
 
 ``myref`` is reference counted. It will be freed when no more Ref<>
 templates point to it.
@@ -253,11 +253,11 @@ References:
 Resources:
 ----------
 
-Resource inherits from Reference, so all resources are reference
-counted. Resources can optionally contain a path, which reference a file
-on disk. This can be set with ``resource.set_path(path)``. This is
-normally done by the resource loader though. No two different resources
-can have the same path, attempt to do so will result in an error.
+:ref:`Resource <class_resource>` inherits from Reference, so all resources
+are reference counted. Resources can optionally contain a path, which
+reference a file on disk. This can be set with ``resource.set_path(path)``.
+This is normally done by the resource loader though. No two different
+resources can have the same path, attempt to do so will result in an error.
 
 Resources without a path are fine too.
 
@@ -273,7 +273,7 @@ Resources can be loaded with the ResourceLoader API, like this:
 
 .. code:: cpp
 
-    Ref res = ResourceLoader::load("res://someresource.res")
+    Ref<Resource> res = ResourceLoader::load("res://someresource.res")
 
 If a reference to that resource has been loaded previously and is in
 memory, the resource loader will return that reference. This means that
@@ -299,7 +299,7 @@ Saving a resource can be done with the resource saver API:
 Instance will be saved. Sub resources that have a path to a file will be
 saved as a reference to that resource. Sub resources without a path will
 be bundled with the saved resource and assigned sub-IDs, like
-"res://somereource.res::1". This also helps to cache them when loaded.
+"res://someresource.res::1". This also helps to cache them when loaded.
 
 References:
 ~~~~~~~~~~~

reference/richtextlabel_bbcode.rst

@@ -6,15 +6,14 @@ BBCode RichTextLabel
 Introduction
 ------------
 
-:ref:`class_RichTextLabel` allows to display complex text markup in a control. It
-has a built-in API for generating the markup, but can also parse a
-BBCode.
+:ref:`class_RichTextLabel` allows to display complex text markup in a control.
+It has a built-in API for generating the markup, but can also parse a BBCode.
 
-Setting Up
+Setting up
 ----------
 
-For RichTextLabel to work properly, it must be set-up. This means
-loading the intended fonts in the releavant properties:
+For RichTextLabel to work properly, it must be set up. This means loading
+the intended fonts in the relevant properties:
 
 .. image:: /img/rtl_setup.png
 
@@ -40,21 +39,21 @@ Reference
 +-----------------+--------------------------------------------+--------------------------------------------------------------+
 | **indent**      | ``[indent]{text}[/indent]``                | Incrase indent level of {text}.                              |
 +-----------------+--------------------------------------------+--------------------------------------------------------------+
-| **url**         | ``[url]{url}[/url]``                       | Show as such.                                                |
+| **url**         | ``[url]{url}[/url]``                       | Show {url} as such.                                          |
 +-----------------+--------------------------------------------+--------------------------------------------------------------+
-| **url (ref)**   | ``[url=<url>]{text}[/url]``                | Makes {text} reference .                                     |
+| **url (ref)**   | ``[url=<url>]{text}[/url]``                | Makes {text} reference <url>.                                |
 +-----------------+--------------------------------------------+--------------------------------------------------------------+
-| **image**       | ``[img=<path>][/img]``                     | Insert image at resource .                                   |
+| **image**       | ``[img=<path>][/img]``                     | Insert image at resource <path>.                             |
 +-----------------+--------------------------------------------+--------------------------------------------------------------+
-| **font**        | ``[font=<path>]{text}[/font]``             | Use custom font at for {text}.                               |
+| **font**        | ``[font=<path>]{text}[/font]``             | Use custom font at <path> for {text}.                        |
 +-----------------+--------------------------------------------+--------------------------------------------------------------+
 | **color**       | ``[color=<code/name>]{text}[/color]``      | Change {text} color, use # format such as #ff00ff or name.   |
 +-----------------+--------------------------------------------+--------------------------------------------------------------+
 
-Built-In Color Names
+Built-in color names
 ~~~~~~~~~~~~~~~~~~~~
 
-List of valid color names for the [color=] tag:
+List of valid color names for the [color=<name>] tag:
 
 -  aqua
 -  black
@@ -71,5 +70,3 @@ List of valid color names for the [color=] tag:
 -  teal
 -  white
 -  yellow
-
-

reference/variant_class.rst

@@ -32,7 +32,7 @@ A Variant can:
 
 Basically, thanks to the Variant class, writing Godot itself was a much,
 much easier task, as it allows for highly dynamic constructs not common
-of c++ with little effort. Become a friend of Variant today.
+of C++ with little effort. Become a friend of Variant today.
 
 References:
 ~~~~~~~~~~~

tutorials/asset_pipeline/importing_translations.rst

@@ -43,7 +43,7 @@ requirement is that the files have a special format. The csv files must
 be saved in utf-8 encoding and the format is as follows:
 
 +--------+----------+----------+----------+
-|        |          |          |          |
+|        | <lang1>  | <lang2>  | <langN>  |
 +========+==========+==========+==========+
 | KEY1   | string   | string   | string   |
 +--------+----------+----------+----------+

tutorials/engine/background_loading.rst

@@ -30,7 +30,7 @@ Obtaining a ResourceInteractiveLoader
 
 ::
 
-    Ref ResourceLoader::load_interactive(String p_path);
+    Ref<ResourceInteractiveLoader> ResourceLoader::load_interactive(String p_path);
 
 This method will give you a ResourceInteractiveLoader that you will use
 to manage the load operation.
@@ -101,7 +101,7 @@ Obtaining the resource
 
 ::
 
-    Ref ResourceInteractiveLoader::get_resource();
+    Ref<Resource> ResourceInteractiveLoader::get_resource();
 
 If everything goes well, use this method to retrieve your loaded
 resource.