Misc heading fixes

about/faq.rst

@@ -155,8 +155,8 @@ that is incompatible with the `open license <https://opensource.org/licenses/MIT
 provided by Godot. That being said, FBX support could still be provided by third parties
 as a plugin. (See Plugins question above.)
 
-Will [Insert closed SDK such as PhysX, GameWorks, etc.] be supported in Godot?
-------------------------------------------------------------------------------
+Will [insert closed SDK such as FMOD, GameWorks, etc.] be supported in Godot?
+-----------------------------------------------------------------------------
 
 The aim of Godot is to create a free and open-source MIT-licensed engine that
 is modular and extendable. There are no plans for the core engine development

community/contributing/docs_writing_guidelines.rst

@@ -1,7 +1,7 @@
 .. _doc_docs_writing_guidelines:
 
 Docs writing guidelines
-=============================
+=======================
 
 The Godot community is rich and international. Users come from all
 around the world. Some of them are young, and many aren't native English
@@ -35,7 +35,6 @@ There are 3 rules to describe classes:
 7 rules for a clear english
 ---------------------------
 
-
 Use the direct voice
 ~~~~~~~~~~~~~~~~~~~~
 
@@ -229,7 +228,7 @@ If you need to repeat the same variable name 3 or 4 times, you probably
 need to rephrase your description.
 
 Use 's to show possession
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Avoid "The milk **of** the cow". It feels unnatural in English. Write "The cow's
 milk" instead.
@@ -336,7 +335,7 @@ For boolean member variables, always use ``if true`` and/or
 ``if false``, to stay explicit. ``Controls whether or not`` may be
 ambiguous and won't work for every member variable.
 
-Also surround boolean values, variable names and methods with [code][/code].
+Also surround boolean values, variable names and methods with ``[code][/code]``.
 
 **Do** start with "if true":
 
@@ -346,10 +345,10 @@ Also surround boolean values, variable names and methods with [code][/code].
     If [code]true[/code] the timer will automatically start when it enters the scene tree. Default value: [code]false[/code].
 
 
-Use [code] around arguments
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Use ``[code]`` around arguments
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-In the class reference, always surround arguments with [code][/code]. In the documentation and in Godot, it will display like ``this``. When you edit XML files in the Godot repository, replace existing arguments written like 'this' or \`this\` with [code]this[/code].
+In the class reference, always surround arguments with ``[code][/code]``. In the documentation and in Godot, it will display like ``this``. When you edit XML files in the Godot repository, replace existing arguments written like 'this' or \`this\` with ``[code]this[/code]``.
 
 
 Common vocabulary to use in godot's docs
@@ -386,7 +385,7 @@ class names, which you can't fold, are ``Classes`` e.g. the
 ``properties``. E.g. ``position`` or ``modulate color`` are both
 ``properties``.
 
-Image Contribution guidelines
+Image contribution guidelines
 -----------------------------
 
 A significant part of the documentation is images, and there are several important

development/cpp/configuring_an_ide.rst

@@ -75,7 +75,7 @@ Run configuration:
 
 .. image:: img/qtcreator-run-command.png
 
-Updating Sources after pulling latest commits
+Updating sources after pulling latest commits
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 As a developer you usually want to frequently pull the latest commits
@@ -178,7 +178,7 @@ That's it! Now you should be good to go :)
 Xcode
 -----
 
-Project Setup
+Project setup
 ^^^^^^^^^^^^^
 
 - Create an Xcode external build project anywhere
@@ -227,7 +227,7 @@ Add Godot Source to the Project:
 - Grab a cup of coffee... Maybe make something to eat, too
 - You should have jump to definition, auto completion, and full syntax highlighting when it is done.
 
-Scheme Setup
+Scheme setup
 ^^^^^^^^^^^^
 
 Edit Build Scheme of External Build Target:
@@ -295,6 +295,4 @@ To create them:
 
 - You can now start Debug process again to test that everything works.
 
-- If build phase fails, check console for hints. On Linux it's most likely that some dependencies are missing. Check :ref:`Compiling for X11 (Linux, \*BSD) <doc_compiling_for_x11>`
-
-
+- If the build phase fails, check console for hints. On Linux it's most likely that some dependencies are missing. Check :ref:`Compiling for X11 (Linux, \*BSD) <doc_compiling_for_x11>`

getting_started/scripting/gdscript/gdscript_basics.rst

@@ -1,7 +1,7 @@
 .. _doc_gdscript:
 
-GDScript
-========
+GDScript basics
+===============
 
 Introduction
 ------------

getting_started/scripting/visual_script/getting_started.rst

@@ -19,7 +19,7 @@ palette from where you can drag and drop all sorts of information to the script
 .. image:: img/visual_script2.png
 
 
-Creating a Script
+Creating a script
 -----------------
 
 Creating scripts works the same as with other scripting languages: Select any node in the scene
@@ -39,7 +39,7 @@ Finally, the Script Editor will open, allowing you to start editing the visual s
 .. image:: img/visual_script5.png
 
 
-Adding a Function
+Adding a function
 -----------------
 
 Unlike other visual scripting implementations, Visual Scripting in Godot is heavily based on functions.
@@ -52,7 +52,7 @@ A single script can contain many functions, each of which will have a canvas of
 
 There are three main ways to add functions in a script:
 
-Overriding a Virtual Function
+Overriding a virtual function
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Most types of nodes and other types of objects in Godot contain virtual functions. These are functions that
@@ -79,7 +79,7 @@ provided:
 .. image:: img/visual_script9.png
 
 
-Connecting a Signal to a Function
+Connecting a signal to a function
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Nodes in a tree emit signals when something happens. Godot uses signals for all sorts of things.
@@ -103,7 +103,7 @@ connected to it:
 .. image:: img/visual_script12.png
 
 
-Creating a Function Manually
+Creating a function manually
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The last way to create functions is to do it manually. In general, this is not as common unless you

getting_started/step_by_step/ui_game_user_interface.rst

@@ -369,7 +369,7 @@ create the life bar. It's the same for the ``Counter``.
 
    With no extra changes, our Bar is ready to use
 
-Use Scene Inheritance to create the remaining elements
+Use scene inheritance to create the remaining elements
 ------------------------------------------------------
 
 We need two bars that work the same way: they should feature a label on

getting_started/workflow/assets/escn_exporter/index.rst

@@ -1,9 +1,13 @@
-Godot-Blender-Exporter
-======================
+Blender ESCN exporter
+=====================
 
-.. note:: This chapter relates to the blender plugin called "Godot-Blender-Exporter",
+.. note:: This chapter relates to the Blender plugin called "Godot Blender Exporter",
           which can be downloaded here: https://github.com/godotengine/godot-blender-exporter
 
+This plugin can be used to export Blender scenes in a Godot-specific scene format
+called ESCN, which is similar to TSCN (text format) but will be imported as binary
+SCN for performance.
+
 Details on exporting
 --------------------
 
@@ -22,7 +26,7 @@ Details on exporting
 Disabling specific objects
 --------------------------
 
-Sometimes you don't want some objects exported (eg high-res models used for
+Sometimes you don't want some objects exported (e.g. high-res models used for
 baking). An object will not be exported if it is not rendered in the scene.
 This can be set in the outliner:
 

getting_started/workflow/assets/importing_audio_samples.rst

@@ -34,7 +34,7 @@ Here is a comparative chart.
 
 In general, what is recommended, is to use WAV for most sound effects, especially those that are short and repetitive, and OGG for music, voice and long sound effects.
 
-Best Practices
+Best practices
 --------------
 
 Godot 3+ has an amazing bus system with built-in effects. This saves
@@ -60,12 +60,10 @@ this.
 Looping
 ~~~~~~~
 
-Godot supports looping in the samples (Tools such as Sound Forge or
+Godot supports looping in the samples (tools such as Sound Forge or
 Audition can add loop points to wav files). This is useful for sound
 effects, such as engines, machine guns etc. Ping-pong looping is also
 supported.
 
 As an alternative, the import screen has a "loop" option that enables
 looping for the entire sample when importing.
-
-

getting_started/workflow/assets/importing_scenes.rst

@@ -3,7 +3,7 @@
 Importing 3D scenes
 ===================
 
-Godot Scene Importer
+Godot scene importer
 --------------------
 
 When dealing with 3D assets, Godot has a flexible and configurable importer.
@@ -70,7 +70,7 @@ import a scene with:
 * External meshes: Where each mesh is saved to a different file. Many users prefer to deal with meshes directly.
 * External animations: Allowing saved animations to be modified and merged when sources change.
 * External scenes: Save each of the root nodes of the imported scenes as a separate scene.
-* Single Scene: A single scene file with everything built in.
+* Single scene: A single scene file with everything built in.
 
 .. image:: img/scene_import1.png
 
@@ -147,7 +147,7 @@ most 3D DCCs don't have the same material options as those present in Godot.
 When materials are built-in, they will be lost each time the source scene
 is modified and re-imported.
 
-Keep on Reimport
+Keep On Reimport
 ^^^^^^^^^^^^^^^^
 
 Once materials are edited to use Godot features, the importer will keep the
@@ -207,7 +207,7 @@ External Files
 Generated meshes and materials can be optionally stored in a subdirectory with the
 name of the scene.
 
-Animation Options
+Animation options
 -----------------
 
 Godot provides many options regarding how animation data is dealt with. Some exporters
@@ -238,7 +238,6 @@ Storage
 By default, animations are saved as built-in. It is possible to save them to a file instead. This
 allows adding custom tracks to the animations and keeping them after a reimport.
 
-
 Optimizer
 ~~~~~~~~~
 

getting_started/workflow/assets/importing_translations.rst

@@ -67,7 +67,7 @@ uppercase, to differentiate from other strings). Here's an example:
 | BYE     | Good Bye         | Adiós          | さようなら   |
 +---------+------------------+----------------+--------------+
 
-CSV Importer
+CSV importer
 ------------
 
 Godot will treat CSV files as translations by default. It will import them

getting_started/workflow/export/feature_tags.rst

@@ -117,8 +117,8 @@ in many sections of the project settings.
 
 .. image:: img/feature_tags4.png
 
-Customizing Build
-------------------
+Customizing the build
+---------------------
 
 Feature tags can be used to customize a build process too, by writing a custom **ExportPlugin**.
 They are also used to specify which shared library is loaded and exported in **GDNative**.

tutorials/2d/index.rst

@@ -8,7 +8,7 @@
    canvas_layers
    2d_transforms
    using_tilemaps
-   custom_drawing_in_2d
    particle_systems_2d
    2d_movement
    2d_lights_and_shadows
+   custom_drawing_in_2d

tutorials/3d/fps_tutorial/part_five.rst

@@ -3,7 +3,7 @@
 Part 5
 ======
 
-Part Overview
+Part overview
 -------------
 
 In this part, we're going to add grenades to the player, give the player the ability to grab and throw objects, and add turrets!

tutorials/3d/fps_tutorial/part_four.rst

@@ -3,7 +3,7 @@
 Part 4
 ======
 
-Part Overview
+Part overview
 -------------
 
 In this part, we will be adding health pickups, ammo pickups, targets the player can destroy, support for joypads, and add the ability to change weapons with the scroll wheel.

tutorials/3d/fps_tutorial/part_one.rst

@@ -63,7 +63,7 @@ Feel free to use these assets however you want! All original assets belong to th
 
 .. tip:: You can find the finished project for each part at the bottom of each part's page
 
-Part Overview
+Part overview
 -------------
 
 In this part we will be making a first person player that can move around
@@ -76,6 +76,7 @@ sprint, look around with a mouse based first person camera, jump into the air, a
 
 Getting everything ready
 ------------------------
+
 Launch Godot and open up the project included in the starter assets.
 
 .. note:: While these assets are not necessarily required to use the scripts provided in this tutorial,

tutorials/3d/fps_tutorial/part_six.rst

@@ -3,7 +3,7 @@
 Part 6
 ======
 
-Part Overview
+Part overview
 -------------
 
 In this part, we're going to add a main menu and pause menu,

tutorials/3d/fps_tutorial/part_three.rst

@@ -3,7 +3,7 @@
 Part 3
 ======
 
-Part Overview
+Part overview
 -------------
 
 In this part, we will be limiting the player's weapons by giving them ammo. We will also

tutorials/3d/fps_tutorial/part_two.rst

@@ -3,7 +3,7 @@
 Part 2
 ======
 
-Part Overview
+Part overview
 -------------
 
 In this part we will be giving our player weapons to play with.

tutorials/3d/using_multi_mesh_instance.rst

@@ -54,35 +54,43 @@ Below are descriptions of the options.
 
 Target Surface
 ++++++++++++++
+
 The mesh used as the target surface on which to place copies of your
 source mesh.
 
 Source Mesh
 +++++++++++
+
 The mesh you want duplicated on the target surface.
 
 Mesh Up Axis
 ++++++++++++
+
 The axis used as the up axis of the source mesh.
 
 Random Rotation
 +++++++++++++++
+
 Randomizing the rotation around the up axis of the source mesh.
 
 Random Tilt
 +++++++++++
+
 Randomizing the overall rotation of the source mesh.
 
 Random Scale
 ++++++++++++
+
 Randomizing the scale of the source mesh.
 
 Scale
 +++++
+
 The scale of the source mesh that will be placed over the target surface.
 
 Amount
 ++++++
+
 The amount of mesh instances placed over the target surface.
 
 Select the target surface. In the tree case, this should be the landscape node.

tutorials/3d/working_with_3d_skeletons.rst

@@ -343,7 +343,7 @@ Or you can browse it using the web-interface:
 
 https://github.com/slapin/godot-skel3d
 
-Using 3D "bones" to implement Inverse Kinematics
+Using 3D "bones" to implement inverse kinematics
 ------------------------------------------------
 
 See :ref:`doc_inverse_kinematics`.

tutorials/io/background_loading.rst

@@ -197,11 +197,11 @@ Using multiple threads
 ResourceInteractiveLoader can be used from multiple threads. A couple of
 things to keep in mind if you attempt it:
 
-Use a Semaphore
+Use a semaphore
 ~~~~~~~~~~~~~~~
 
 While your thread waits for the main thread to request a new resource,
-use a Semaphore to sleep (instead of a busy loop or anything similar).
+use a ``Semaphore`` to sleep (instead of a busy loop or anything similar).
 
 Not blocking main thread during the polling
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

tutorials/physics/kinematic_character_2d.rst

@@ -1,6 +1,6 @@
 .. _doc_kinematic_character_2d:
 
-Kinematic Character (2D)
+Kinematic character (2D)
 ========================
 
 Introduction
@@ -18,7 +18,7 @@ physics engines (or a lot of patience with trial and error).
 
 Some physics engines, such as Havok seem to swear by dynamic character
 controllers as the best option, while others (PhysX) would rather
-promote the Kinematic one.
+promote the kinematic one.
 
 So, what is the difference?:
 
@@ -107,7 +107,7 @@ map scene the main one, so it runs when pressing play.
 
 .. image:: img/kbinstance.png
 
-Moving the Kinematic character
+Moving the kinematic character
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Go back to the character scene, and open the script, the magic begins

tutorials/physics/physics_introduction.rst

@@ -23,7 +23,7 @@ In this guide, you will learn:
           and collision shape has a direct equivalent in 3D and in most cases
           they work in much the same way.
 
-Collision Objects
+Collision objects
 -----------------
 
 Godot offers four kinds of physics bodies, extending :ref:`CollisionObject2D <class_CollisionObject2D>`:
@@ -51,7 +51,7 @@ The other three bodies extend :ref:`PhysicsBody2D <class_PhysicsBody2D>`:
     A body that provides collision detection, but no physics. All movement and
     collision response must be implemented in code.
 
-Collision Shapes
+Collision shapes
 ~~~~~~~~~~~~~~~~
 
 A physics body can hold any number of :ref:`Shape2D <class_Shape2D>` objects
@@ -86,7 +86,7 @@ be run in the :ref:`Node._physics_process() <class_Node_method__physics_process>
 callback, which is called before each physics step at a constant frame rate
 (60 times per second by default).
 
-Collision Layers and Masks
+Collision layers and masks
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 One of the most powerful, but frequently misunderstood, collision features

tutorials/physics/rigid_body.rst

@@ -1,7 +1,7 @@
 .. _doc_rigid_body:
 
-Rigid Body
-==========
+RigidBody
+=========
 
 What is a rigid body?
 ---------------------
@@ -21,7 +21,7 @@ As an example, consider a rigid body that you want to rotate so that it points t
 
 The fact that you can't use ``set_global_transform()`` or ``look_at()`` methods doesn't mean that you can't have full control of a rigid body. Instead, you can control it by using the ``_integrate_forces()`` callback. In this method, you can add *forces*, apply *impulses*, or set the *velocity* in order to achieve any movement you desire.
 
-The "Look at" method
+The "look at" method
 --------------------
 
 As described above, using the Spatial node's ``look_at()`` method can't be used each frame to follow a target.

tutorials/physics/using_kinematic_body_2d.rst

@@ -29,7 +29,7 @@ precise control over how they move and react.
         but you must calculate the movement in code. The physics engine will
         not move a `KinematicBody2D`.
 
-Movement and Collision
+Movement and collision
 ----------------------
 
 When moving a ``KinematicBody2D``, you should not set its ``position`` property

tutorials/plugins/gdnative/gdnative-cpp-example.rst

@@ -15,7 +15,7 @@ NativeScript GDNative API and provide a nicer way to "extend" nodes
 in Godot using C++. This is equivalent to writing scripts in GDScript,
 but in C++ instead.
 
-Godot 3.1 saw the introduction of the NativeScript 1.1 additions that 
+Godot 3.1 saw the introduction of the NativeScript 1.1 additions that
 enabled the GDNative team to build a nicer C++ bindings library.
 These changes have now been merged into the master branch and will
 be the way we go forward. If you want to write a C++ GDNative plugin
@@ -41,10 +41,10 @@ to the ones you need to compile Godot from source.
 
 You can download these repositories from GitHub or let Git
 do the work for you.
-Note that these repositories now have different branches for different 
-versions of Godot. GDNative modules written for an earlier version of 
-Godot will work in newer versions (with the exception of one breaking 
-change in ARVR interfaces between 3.0 and 3.1) but not vise versa so 
+Note that these repositories now have different branches for different
+versions of Godot. GDNative modules written for an earlier version of
+Godot will work in newer versions (with the exception of one breaking
+change in ARVR interfaces between 3.0 and 3.1) but not vise versa so
 make sure you download the correct branch.
 Also note that the version of Godot you use to generate the ``api.json``
 with becomes your minimum version.
@@ -246,7 +246,7 @@ The second is our ``_process`` function,
 which will work exactly the same as the ``_process`` function
 you're used to in GDScript.
 The third is our ``_init`` function which is called after Godot has properly
-set up our object. It has to exist even if you don't place any code in it. 
+set up our object. It has to exist even if you don't place any code in it.
 
 Let's implement our functions by creating our ``gdexample.cpp`` file:
 
@@ -258,7 +258,7 @@ Let's implement our functions by creating our ``gdexample.cpp`` file:
     using namespace godot;
 
     void GDExample::_register_methods() {
-        register_method("_process", &GDExample::_process);  
+        register_method("_process", &GDExample::_process);
     }
 
     GDExample::GDExample() {
@@ -370,7 +370,10 @@ use for building. For the purpose of this example, just use
 we've prepared. We'll cover a more customizable, detailed example on
 how to use these build files in a subsequent tutorial.
 
-.. note:: This ``SConstruct`` file was written to be used with the latest godot-cpp master, you may need to make small changes using it with older versions or refer to the ``SConstruct`` file in the Godot 3.0 documentation.
+.. note:: This ``SConstruct`` file was written to be used with the latest
+          ``godot-cpp`` master, you may need to make small changes using it with
+          older versions or refer to the ``SConstruct`` file in the Godot 3.0
+          documentation.
 
 Once you've downloaded the ``SConstruct`` file, place it in your
 GDNative module folder besides ``godot-cpp``, ``godot_headers``
@@ -507,7 +510,7 @@ In our ``gdexample.h`` file we simply need to add a member variable like so:
         float amplitude;
     ...
 
-In our ``gdexample.cpp`` file we need to make a number of changes, we will only show 
+In our ``gdexample.cpp`` file we need to make a number of changes, we will only show
 the methods we end up changing, don't remove the lines we're omitting:
 
 .. tabs::
@@ -559,9 +562,9 @@ the methods we end up changing, don't remove the lines we're omitting:
         owner->set_position(new_position);
     }
 
-Once you compile the module with these changes in place you will see that 
+Once you compile the module with these changes in place you will see that
 a property has been added to our interface.
-You can now change this property and when you run your project, you will 
+You can now change this property and when you run your project, you will
 see that our Godot icon travels along a larger figure.
 
 Lets do the same but for the speed of our animation and use a setter and getter function.
@@ -578,7 +581,7 @@ Our ``gdexample.h`` header file again only needs a few more lines of code:
         float get_speed();
     ...
 
-This requires a few more changes to our ``gdexample.cpp`` file, again we're only showing the 
+This requires a few more changes to our ``gdexample.cpp`` file, again we're only showing the
 methods that have changed so don't remove anything we're omitting:
 
 .. tabs::
@@ -654,7 +657,7 @@ Now when the project is compiled we'll see another property called speed.
 Changing its value will make the animation go faster or slower.
 
 For this example there is no obvious advantage of using a setter and getter.
-It is just more code to write. For a simple example as this there may be a 
+It is just more code to write. For a simple example as this there may be a
 good reason for a setter if you want to react on the variable being changed
 but in many cases just binding the variable will be enough.
 
@@ -663,14 +666,14 @@ where you need to make additional choices based on the state of your
 object.
 
 .. note::
-    
+
     For simplicity we've left out the optional parameters in the
     register_property<class, type> method call. These parameters are
     ``rpc_mode``, ``usage``, ``hint`` and ``hint_string``. These can
     be used to further configure how properties are displayed and set
     on the Godot side.
 
-    Modern C++ compilers are able to infer the class and variable type 
+    Modern C++ compilers are able to infer the class and variable type
     and allow you to omit the ``<GDExample, float>`` part of our
     ``register_property`` method. we've had mixed experiences with this
     however.
@@ -682,7 +685,7 @@ Last but not least, signals fully work in GDNative as well.
 Having your module react to a signal given out by another object requires
 you to call ``connect`` on that object. We can't think of a good example for
 our wobbling Godot icon, we would need to showcase a far more complete
-example. 
+example.
 
 This however is the required syntax:
 
@@ -700,7 +703,7 @@ it in your ``_register_methods`` method.
 
 Having your object sending out signals is far more common. For our wobbling
 Godot icon we'll do something silly just to show how it works. We're going
-to emit a signal every time a second has passed and pass the new location 
+to emit a signal every time a second has passed and pass the new location
 along.
 
 In our ``gdexample.h`` header file we just need to define a new member ``time_emit``:
@@ -718,7 +721,7 @@ First you'll need to set ``time_emit = 0.0;`` in either our ``_init`` method or
 in our constructor. But the other two needed changes we'll look at one by one.
 
 In our ``_register_methods`` method we need to declare our signal and we do this
-as follows: 
+as follows:
 
 .. tabs::
  .. code-tab:: C++ NativeScript 1.1
@@ -744,12 +747,12 @@ as follows:
         register_signal<GDExample>((char *)"position_changed", args);
     }
 
-Here we see a nice improvement in the latest version of godot-cpp where our 
-``register_signal`` method can be a single call first taking the signals name, 
-then having pairs of values specificying the parameter name and type of each 
+Here we see a nice improvement in the latest version of godot-cpp where our
+``register_signal`` method can be a single call first taking the signals name,
+then having pairs of values specificying the parameter name and type of each
 parameter we'll send along with this signal.
 
-For NativeScript 1.0 we first build a dictionary in which we tell Godot about 
+For NativeScript 1.0 we first build a dictionary in which we tell Godot about
 the types of arguments we will pass to our signal, and then register it.
 
 Next we'll need to change our ``_process`` method:
@@ -801,7 +804,7 @@ Next we'll need to change our ``_process`` method:
 After a second has passed we emit our signal and reset our counter.
 Again in the new version of godot-cpp we can add our parameter values
 directly to ``emit_signal``.
-In NativeScript 1.0 We first build an array of values and then 
+In NativeScript 1.0 We first build an array of values and then
 call ``emit_signal``.
 
 Once compiled we can go into Godot and select our sprite node.
@@ -818,8 +821,8 @@ We've added a script on our main node and implemented our signal like this:
 Every second we simply output our position to the console.
 
 
-NativeScript 1.1 v.s. NativeScript 1.0
---------------------------------------
+NativeScript 1.1 vs NativeScript 1.0
+------------------------------------
 
 So far in our example above there doesn't seem to be a lot of difference
 between the old and new syntax. The class is defined slightly differently
@@ -829,7 +832,7 @@ side of our object. A lot of the improvements are hidden under the hood.
 This example only deals with simple variables and simple methods.
 Especially once you start passing references to other objects or when you
 start calling methods that require more complex parameters, NativeScript 1.1
-does start to show its benefits. 
+does start to show its benefits.
 
 Next steps
 ----------

tutorials/shading/migrating_to_godot_shader_language.rst

@@ -1,7 +1,7 @@
 .. _doc_migrating_to_godot_shader_language:
 
-Migrating to Godot shading language
-===================================
+Migrating to Godot's shading language
+=====================================
 
 Introduction
 ------------
@@ -19,7 +19,7 @@ GLSL
 Godot uses a shading language based on GLSL with the addition of a few quality-of-life features.
 Accordingly, most features available in GLSL are available in Godot's shading language.
 
-Shader Programs
+Shader programs
 ^^^^^^^^^^^^^^^
 
 In GLSL each shader uses a separate program. You have one program for the vertex shader and one
@@ -138,6 +138,7 @@ has the regular types, including `Constants`_ and macros.
 
 mainImage
 ^^^^^^^^^
+
 The main point of entry to a Shadertoy shader is the ``mainImage`` function. ``mainImage`` has two
 parameters, ``fragColor`` and ``fragCoord`` which correspond to ``COLOR`` and ``FRAGCOORD`` in Godot
 respectively. These parameters are handled automatically in Godot, so you do not need to include them
@@ -146,6 +147,7 @@ function when porting to Godot.
 
 Variables
 ^^^^^^^^^
+
 In order to make writing fragment shaders straightforward and easy, Shadertoy handles passing a lot
 of helpful information from the main program into the fragment shader for you. A few of these
 have no equivalents in Godot because Godot has chosen not to make them available by default.
@@ -181,8 +183,8 @@ uniform themself. The description gives the reader a hint about what they can pa
 
 Coordinates
 ^^^^^^^^^^^
-``fragCoord`` behaves the same as ``gl_FragCoord`` in :ref:`GLSL <glsl_coordinates>` and ``FRAGCOORD`` in Godot.
 
+``fragCoord`` behaves the same as ``gl_FragCoord`` in :ref:`GLSL <glsl_coordinates>` and ``FRAGCOORD`` in Godot.
 
 
 The Book of Shaders
@@ -231,4 +233,3 @@ Coordinates
 ^^^^^^^^^^^
 
 The Book of Shaders uses the same coordinate system as :ref:`GLSL <glsl_coordinates>`.
-

tutorials/shading/screen-reading_shaders.rst

@@ -17,8 +17,8 @@ The workaround is to make a copy of the screen, or a part of the screen,
 to a back-buffer and then read from it while drawing. Godot provides a
 few tools that makes this process easy!
 
-SCREEN_TEXTURE built-in texture.
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+SCREEN_TEXTURE built-in texture
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Godot :ref:`doc_shading_language` has a special texture, "SCREEN_TEXTURE" (and "DEPTH_TEXTURE" for depth, in case of 3D).
 It takes as parameter the UV of the screen and returns a vec3 RGB with the color. A

tutorials/shading/shading_reference/canvas_item_shader.rst

@@ -1,7 +1,7 @@
 .. _doc_canvas_item_shader:
 
 CanvasItem shaders
-===================
+==================
 
 CanvasItem shaders are used to draw all 2D elements in Godot. These include
 all nodes that inherit from CanvasItems, and all GUI elements.
@@ -10,11 +10,11 @@ CanvasItem shaders contain less built-in variables and functionality than Spatia
 shaders, but they maintain the same basic structure with vertex, fragment, and 
 light processor functions.
 
-Render Modes
+Render modes
 ^^^^^^^^^^^^
 
 +---------------------------------+----------------------------------------------------------------------+
-| Render Mode                     | Description                                                          |
+| Render mode                     | Description                                                          |
 +=================================+======================================================================+
 | **blend_mix**                   | Mix blend mode (alpha is transparency), default.                     |
 +---------------------------------+----------------------------------------------------------------------+
@@ -33,8 +33,9 @@ Render Modes
 | **skip_vertex_transform**       | VERTEX/NORMAL/etc need to be transformed manually in vertex function.|
 +---------------------------------+----------------------------------------------------------------------+
 
-Vertex Built-Ins
+Vertex built-ins
 ^^^^^^^^^^^^^^^^
+
 Values marked as "in" are read-only. Values marked as "out" are for optional writing and will 
 not necessarily contain sensible values. Values marked as "inout" provide a sensible default 
 value, and can optionally be written to. Samplers are not subjects of writing and they are 
@@ -66,7 +67,7 @@ is usually:
 * **z**: Animation frame.
 
 +--------------------------------+----------------------------------------------------------------+
-| Built-In                       | Description                                                    |
+| Built-in                       | Description                                                    |
 +================================+================================================================+
 | in mat4 **WORLD_MATRIX**       | Image to World transform.                                      |
 +--------------------------------+----------------------------------------------------------------+
@@ -89,7 +90,7 @@ is usually:
 | inout float **POINT_SIZE**     | Point size for point drawing.                                  |
 +--------------------------------+----------------------------------------------------------------+
 
-Fragment Built-Ins
+Fragment built-ins
 ^^^^^^^^^^^^^^^^^^
 
 Certain Nodes (for example, :ref:`Sprites <class_Sprite>`) display a texture by default. However, 
@@ -111,7 +112,7 @@ it to the ``NORMALMAP`` property. Godot will handle converting it for use in 2D
   NORMALMAP = texture(NORMAL_TEXTURE, UV).rgb;
 
 +----------------------------------+----------------------------------------------------------------+
-| Built-In                         | Description                                                    |
+| Built-in                         | Description                                                    |
 +==================================+================================================================+
 | in vec4 **FRAGCOORD**            | Fragment coordinate, pixel adjusted.                           |
 +----------------------------------+----------------------------------------------------------------+
@@ -148,8 +149,8 @@ it to the ``NORMALMAP`` property. Godot will handle converting it for use in 2D
 | in sampler2D **SCREEN_TEXTURE**  | Screen texture, mipmaps contain gaussian blurred versions.     |
 +----------------------------------+----------------------------------------------------------------+
 
-Light Built-Ins
-^^^^^^^^^^^^^^^^
+Light built-ins
+^^^^^^^^^^^^^^^
 
 Light processor functions work differently in 2D than they do in 3D. In CanvasItem shaders, the 
 shader is called once for the object being drawn, and then once for each light touching that 
@@ -160,7 +161,7 @@ that object, this can be useful when you only want the object visible where it i
 When the shader is on a light pass the ``AT_LIGHT_PASS`` variable will be ``true``.
 
 +-------------------------------------+-------------------------------------------------------------------------------+
-| Built-In                            | Description                                                                   |
+| Built-in                            | Description                                                                   |
 +=====================================+===============================================================================+
 | in vec4 **FRAGCOORD**               | Fragment coordinate of pixel center. Origin at lower left.                    |
 +-------------------------------------+-------------------------------------------------------------------------------+

tutorials/shading/shading_reference/index.rst

@@ -1,4 +1,4 @@
-Shading Reference
+Shading reference
 =================
 
 .. toctree::

tutorials/shading/shading_reference/particle_shader.rst

@@ -23,11 +23,11 @@ data they have calculated once they draw to the frame buffer.
 .. note:: Particle shaders are only available in the GLES3 renderer. If you need 
           particles in GLES2, use :ref:`CPUParticles <class_CPUParticles>`.
 
-Render Modes
+Render modes
 ^^^^^^^^^^^^
 
 +---------------------------------+----------------------------------------------------------------------+
-| Render Mode                     | Description                                                          |
+| Render mode                     | Description                                                          |
 +=================================+======================================================================+
 | **keep_data**                   | Do not clear previous data on restart.                               |
 +---------------------------------+----------------------------------------------------------------------+
@@ -36,8 +36,9 @@ Render Modes
 | **disable_velocity**            | Ignore **VELOCITY** value.                                           |
 +---------------------------------+----------------------------------------------------------------------+
 
-Vertex Built-Ins
+Vertex built-ins
 ^^^^^^^^^^^^^^^^
+
 Values marked as "in" are read-only. Values marked as "out" are for optional writing and will 
 not necessarily contain sensible values. Values marked as "inout" provide a sensible default 
 value, and can optionally be written to. Samplers are not subjects of writing and they are 
@@ -47,7 +48,7 @@ In order to use the ``COLOR`` variable in a SpatialMaterial, set ``use_vertex_as
 to ``true``. In a ShaderMaterial, access it with the ``COLOR`` variable.
 
 +---------------------------------+-------------------------------------------------------------------------------------+
-| Built-In                        | Description                                                                         |
+| Built-in                        | Description                                                                         |
 +=================================+=====================================================================================+
 | inout vec4 **COLOR**            | Particle color, can be written to and accessed in mesh's vertex function.           |
 +---------------------------------+-------------------------------------------------------------------------------------+

tutorials/shading/shading_reference/shaders.rst

@@ -23,7 +23,7 @@ For more advanced shaders you can turn this functionality off using a render_mod
 This document provides you with some information about shaders, specific to Godot. For a detailed
 reference of the shading language in Godot see the :ref:`Godot shading language doc<doc_shading_language>`.
 
-Shader Types
+Shader types
 ------------
 
 Instead of supplying a general purpose configuration for all uses (2D, 3D, particles), 
@@ -44,7 +44,7 @@ Valid types are:
 
 For detailed information on each shading type see the corresponding reference document.
 
-Render Modes
+Render modes
 ------------
 
 Different shader types support different render modes. They are optional and, if specified, must
@@ -62,14 +62,14 @@ Render modes are specified underneath the shader type:
 Each shader type has a different list of render modes available. See the document for each shader
 type for a complete list of render modes. 
 
-Processor Functions
+Processor functions
 -------------------
 
 Depending on the shader type, different processor functions may be optionally overridden.
 For "spatial" and "canvas_item", it is possible to override ``vertex``, ``fragment``, and ``light``.
 For "particles", only ``vertex`` can be overridden.
 
-Vertex Processor
+Vertex processor
 ^^^^^^^^^^^^^^^^
 
 The ``vertex`` processing function is called once for every vertex in "spatial" and "canvas_item" shaders. 
@@ -83,7 +83,7 @@ By default Godot will take your vertex information and transform it accordingly
 undesirable, you can use render modes to to transform the data yourself, see the 
 :ref:`Spatial shader doc <doc_spatial_shader>` for an example of this.
 
-Fragment Processor
+Fragment processor
 ^^^^^^^^^^^^^^^^^^
 
 The ``fragment`` processing function is used to set up the Godot material parameters per pixel. This code
@@ -99,7 +99,7 @@ if you do not write a value to ``RIM``, Godot will not calculate rim lighting. D
 to see if ``RIM`` is used, if not it cuts all the corresponding code out. Therefore, you will not 
 waste calculations on effects that you do not use. 
 
-Light Processor
+Light processor
 ^^^^^^^^^^^^^^^
 
 The ``light`` processor runs per pixel too, but also runs for every light that affects the object 

tutorials/shading/shading_reference/shading_language.rst

@@ -175,8 +175,8 @@ Keep in mind that some architectures (mainly mobile) benefit a lot from this, bu
 to find out more. In all honesty though, mobile drivers are buggy so to stay out of trouble make simple 
 shaders without specifying precision unless you *really* need to.
 
-Operators:
-----------
+Operators
+---------
 
 Godot shading language supports the same set of operators as GLSL ES 3.0. Below is the list of them in precedence order:
 
@@ -208,7 +208,7 @@ Godot shading language supports the same set of operators as GLSL ES 3.0. Below
 | 12 (lowest) | logical inclusive or  | **||**             |
 +-------------+-----------------------+--------------------+
 
-Flow Control
+Flow control
 ------------
 
 Godot Shading language supports the most common types of flow control:
@@ -237,7 +237,7 @@ Keep in mind that, in modern GPUs, an infinite loop can exist and can freeze you
 Godot can't protect you from this, so be careful to not make this mistake!
 
 Discarding
------------
+----------
 
 Fragment and light functions can use the **discard** keyword. If used, the fragment is discarded and nothing is written.
 
@@ -421,7 +421,7 @@ Uniforms can also be assigned default values:
     uniform vec4 some_vector = vec4(0.0);
     uniform vec4 some_color : hint_color = vec4(1.0);
 
-Built-in Functions
+Built-in functions
 ------------------
 
 A large number of built-in functions are supported, conforming mostly to GLSL ES 3.0.
@@ -606,4 +606,3 @@ When vec_type (float), vec_int_type, vec_uint_type, vec_bool_type nomenclature i
 +-----------------------------------------------------------------------------------------------+------------------------------------------------+
 | vec_type **fwidth** ( vec_type )                                                              | Sum of absolute derivative in x and y          |
 +-----------------------------------------------------------------------------------------------+------------------------------------------------+
-

tutorials/shading/shading_reference/spatial_shader.rst

@@ -1,18 +1,18 @@
 .. _doc_spatial_shader:
 
 Spatial shaders
-================
+===============
 
 Spatial shaders are used for shading 3D objects. They are the most complex type of shader Godot offers. 
 Spatial shaders are highly configurable with different render modes and different rendering options
 (e.g. Subsurface Scattering, Transmission, Ambient Occlusion, Rim lighting etc). Users can optionally
 write vertex, fragment, and light processor functions to affect how objects are drawn.
 
-Render Modes
+Render modes
 ^^^^^^^^^^^^
 
 +---------------------------------+-----------------------------------------------------------------------+
-| Render Mode                     | Description                                                           |
+| Render mode                     | Description                                                           |
 +=================================+=======================================================================+
 | **blend_mix**                   | Mix blend mode (alpha is transparency), default.                      |
 +---------------------------------+-----------------------------------------------------------------------+
@@ -67,7 +67,7 @@ Render Modes
 | **vertex_lighting**             | Use vertex-based lighting.                                            |
 +---------------------------------+-----------------------------------------------------------------------+
 
-Vertex Built-Ins
+Vertex built-ins
 ^^^^^^^^^^^^^^^^
 
 Values marked as "in" are read-only. Values marked as "out" are for optional writing and will 
@@ -109,7 +109,7 @@ This allows you to easily adjust the shader to a particle system using default p
 shader, this value can be used as desired.
 
 +------------------------------------+-------------------------------------------------------+
-| Built-In                           | Description                                           |
+| Built-in                           | Description                                           |
 +====================================+=======================================================+
 | out mat4 **WORLD_MATRIX**          | Model space to world space transform.                 |
 +------------------------------------+-------------------------------------------------------+
@@ -150,7 +150,7 @@ shader, this value can be used as desired.
 | out float **ROUGHNESS**            | Roughness for vertex lighting.                        |
 +------------------------------------+-------------------------------------------------------+
 
-Fragment Built-Ins
+Fragment built-ins
 ^^^^^^^^^^^^^^^^^^
 
 The default use of a Godot fragment processor function is to set up the material properties of your object
@@ -158,7 +158,7 @@ and to let the built-in renderer handle the final shading. However, you are not
 these properties, and if you don't write to them, Godot will optimize away the corresponding functionality. 
 
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
-| Built-In                          | Description                                                                                      |
+| Built-in                          | Description                                                                                      |
 +===================================+==================================================================================================+
 | in vec4 **FRAGCOORD**             | Fragment coordinate, pixel adjusted. In screen space.                                            |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
@@ -239,7 +239,7 @@ these properties, and if you don't write to them, Godot will optimize away the c
 | out float **ALPHA_SCISSOR**       | If written to, values below a certain amount of alpha are discarded.                             |
 +-----------------------------------+--------------------------------------------------------------------------------------------------+
 
-Light Built-Ins
+Light built-ins
 ^^^^^^^^^^^^^^^
 
 Writing light processor functions is completely optional. You can skip the light function by setting